Mercurial > hg > truffle
comparison test/compiler/7200264/TestIntVect.java @ 6803:06f52c4d0e18
7200264: 7192963 changes disabled shift vectors
Summary: Replaced is_vector_use() call with explicit check for vector shift's count.
Reviewed-by: twisti, roland, dlong, vlivanov
author | kvn |
---|---|
date | Tue, 25 Sep 2012 15:48:17 -0700 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
6802:0702f188baeb | 6803:06f52c4d0e18 |
---|---|
1 /* | |
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. | |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 /** | |
26 * @test | |
27 * @bug 7200264 | |
28 * @summary 7192963 changes disabled shift vectors | |
29 * | |
30 * @run shell Test7200264.sh | |
31 */ | |
32 | |
33 /* | |
34 * Copy of test/compiler/6340864/TestIntVect.java without performance tests. | |
35 */ | |
36 public class TestIntVect { | |
37 private static final int ARRLEN = 997; | |
38 private static final int ITERS = 11000; | |
39 private static final int ADD_INIT = Integer.MAX_VALUE-500; | |
40 private static final int BIT_MASK = 0xEC80F731; | |
41 private static final int VALUE = 15; | |
42 private static final int SHIFT = 32; | |
43 | |
44 public static void main(String args[]) { | |
45 System.out.println("Testing Integer vectors"); | |
46 int errn = test(); | |
47 if (errn > 0) { | |
48 System.err.println("FAILED: " + errn + " errors"); | |
49 System.exit(97); | |
50 } | |
51 System.out.println("PASSED"); | |
52 } | |
53 | |
54 static int test() { | |
55 int[] a0 = new int[ARRLEN]; | |
56 int[] a1 = new int[ARRLEN]; | |
57 int[] a2 = new int[ARRLEN]; | |
58 int[] a3 = new int[ARRLEN]; | |
59 int[] a4 = new int[ARRLEN]; | |
60 long[] p2 = new long[ARRLEN/2]; | |
61 // Initialize | |
62 int gold_sum = 0; | |
63 for (int i=0; i<ARRLEN; i++) { | |
64 int val = (int)(ADD_INIT+i); | |
65 gold_sum += val; | |
66 a1[i] = val; | |
67 a2[i] = (int)VALUE; | |
68 a3[i] = (int)-VALUE; | |
69 a4[i] = (int)BIT_MASK; | |
70 } | |
71 System.out.println("Warmup"); | |
72 for (int i=0; i<ITERS; i++) { | |
73 test_sum(a1); | |
74 test_addc(a0, a1); | |
75 test_addv(a0, a1, (int)VALUE); | |
76 test_adda(a0, a1, a2); | |
77 test_subc(a0, a1); | |
78 test_subv(a0, a1, (int)VALUE); | |
79 test_suba(a0, a1, a2); | |
80 test_mulc(a0, a1); | |
81 test_mulv(a0, a1, (int)VALUE); | |
82 test_mula(a0, a1, a2); | |
83 test_divc(a0, a1); | |
84 test_divv(a0, a1, (int)VALUE); | |
85 test_diva(a0, a1, a2); | |
86 test_mulc_n(a0, a1); | |
87 test_mulv(a0, a1, (int)-VALUE); | |
88 test_mula(a0, a1, a3); | |
89 test_divc_n(a0, a1); | |
90 test_divv(a0, a1, (int)-VALUE); | |
91 test_diva(a0, a1, a3); | |
92 test_andc(a0, a1); | |
93 test_andv(a0, a1, (int)BIT_MASK); | |
94 test_anda(a0, a1, a4); | |
95 test_orc(a0, a1); | |
96 test_orv(a0, a1, (int)BIT_MASK); | |
97 test_ora(a0, a1, a4); | |
98 test_xorc(a0, a1); | |
99 test_xorv(a0, a1, (int)BIT_MASK); | |
100 test_xora(a0, a1, a4); | |
101 test_sllc(a0, a1); | |
102 test_sllv(a0, a1, VALUE); | |
103 test_srlc(a0, a1); | |
104 test_srlv(a0, a1, VALUE); | |
105 test_srac(a0, a1); | |
106 test_srav(a0, a1, VALUE); | |
107 test_sllc_n(a0, a1); | |
108 test_sllv(a0, a1, -VALUE); | |
109 test_srlc_n(a0, a1); | |
110 test_srlv(a0, a1, -VALUE); | |
111 test_srac_n(a0, a1); | |
112 test_srav(a0, a1, -VALUE); | |
113 test_sllc_o(a0, a1); | |
114 test_sllv(a0, a1, SHIFT); | |
115 test_srlc_o(a0, a1); | |
116 test_srlv(a0, a1, SHIFT); | |
117 test_srac_o(a0, a1); | |
118 test_srav(a0, a1, SHIFT); | |
119 test_sllc_on(a0, a1); | |
120 test_sllv(a0, a1, -SHIFT); | |
121 test_srlc_on(a0, a1); | |
122 test_srlv(a0, a1, -SHIFT); | |
123 test_srac_on(a0, a1); | |
124 test_srav(a0, a1, -SHIFT); | |
125 test_pack2(p2, a1); | |
126 test_unpack2(a0, p2); | |
127 test_pack2_swap(p2, a1); | |
128 test_unpack2_swap(a0, p2); | |
129 } | |
130 // Test and verify results | |
131 System.out.println("Verification"); | |
132 int errn = 0; | |
133 { | |
134 int sum = test_sum(a1); | |
135 if (sum != gold_sum) { | |
136 System.err.println("test_sum: " + sum + " != " + gold_sum); | |
137 errn++; | |
138 } | |
139 | |
140 test_addc(a0, a1); | |
141 for (int i=0; i<ARRLEN; i++) { | |
142 errn += verify("test_addc: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE)); | |
143 } | |
144 test_addv(a0, a1, (int)VALUE); | |
145 for (int i=0; i<ARRLEN; i++) { | |
146 errn += verify("test_addv: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE)); | |
147 } | |
148 test_adda(a0, a1, a2); | |
149 for (int i=0; i<ARRLEN; i++) { | |
150 errn += verify("test_adda: ", i, a0[i], (int)((int)(ADD_INIT+i)+VALUE)); | |
151 } | |
152 | |
153 test_subc(a0, a1); | |
154 for (int i=0; i<ARRLEN; i++) { | |
155 errn += verify("test_subc: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE)); | |
156 } | |
157 test_subv(a0, a1, (int)VALUE); | |
158 for (int i=0; i<ARRLEN; i++) { | |
159 errn += verify("test_subv: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE)); | |
160 } | |
161 test_suba(a0, a1, a2); | |
162 for (int i=0; i<ARRLEN; i++) { | |
163 errn += verify("test_suba: ", i, a0[i], (int)((int)(ADD_INIT+i)-VALUE)); | |
164 } | |
165 | |
166 test_mulc(a0, a1); | |
167 for (int i=0; i<ARRLEN; i++) { | |
168 errn += verify("test_mulc: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE)); | |
169 } | |
170 test_mulv(a0, a1, (int)VALUE); | |
171 for (int i=0; i<ARRLEN; i++) { | |
172 errn += verify("test_mulv: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE)); | |
173 } | |
174 test_mula(a0, a1, a2); | |
175 for (int i=0; i<ARRLEN; i++) { | |
176 errn += verify("test_mula: ", i, a0[i], (int)((int)(ADD_INIT+i)*VALUE)); | |
177 } | |
178 | |
179 test_divc(a0, a1); | |
180 for (int i=0; i<ARRLEN; i++) { | |
181 errn += verify("test_divc: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE)); | |
182 } | |
183 test_divv(a0, a1, (int)VALUE); | |
184 for (int i=0; i<ARRLEN; i++) { | |
185 errn += verify("test_divv: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE)); | |
186 } | |
187 test_diva(a0, a1, a2); | |
188 for (int i=0; i<ARRLEN; i++) { | |
189 errn += verify("test_diva: ", i, a0[i], (int)((int)(ADD_INIT+i)/VALUE)); | |
190 } | |
191 | |
192 test_mulc_n(a0, a1); | |
193 for (int i=0; i<ARRLEN; i++) { | |
194 errn += verify("test_mulc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE))); | |
195 } | |
196 test_mulv(a0, a1, (int)-VALUE); | |
197 for (int i=0; i<ARRLEN; i++) { | |
198 errn += verify("test_mulv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE))); | |
199 } | |
200 test_mula(a0, a1, a3); | |
201 for (int i=0; i<ARRLEN; i++) { | |
202 errn += verify("test_mula_n: ", i, a0[i], (int)((int)(ADD_INIT+i)*(-VALUE))); | |
203 } | |
204 | |
205 test_divc_n(a0, a1); | |
206 for (int i=0; i<ARRLEN; i++) { | |
207 errn += verify("test_divc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE))); | |
208 } | |
209 test_divv(a0, a1, (int)-VALUE); | |
210 for (int i=0; i<ARRLEN; i++) { | |
211 errn += verify("test_divv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE))); | |
212 } | |
213 test_diva(a0, a1, a3); | |
214 for (int i=0; i<ARRLEN; i++) { | |
215 errn += verify("test_diva_n: ", i, a0[i], (int)((int)(ADD_INIT+i)/(-VALUE))); | |
216 } | |
217 | |
218 test_andc(a0, a1); | |
219 for (int i=0; i<ARRLEN; i++) { | |
220 errn += verify("test_andc: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK)); | |
221 } | |
222 test_andv(a0, a1, (int)BIT_MASK); | |
223 for (int i=0; i<ARRLEN; i++) { | |
224 errn += verify("test_andv: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK)); | |
225 } | |
226 test_anda(a0, a1, a4); | |
227 for (int i=0; i<ARRLEN; i++) { | |
228 errn += verify("test_anda: ", i, a0[i], (int)((int)(ADD_INIT+i)&BIT_MASK)); | |
229 } | |
230 | |
231 test_orc(a0, a1); | |
232 for (int i=0; i<ARRLEN; i++) { | |
233 errn += verify("test_orc: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK)); | |
234 } | |
235 test_orv(a0, a1, (int)BIT_MASK); | |
236 for (int i=0; i<ARRLEN; i++) { | |
237 errn += verify("test_orv: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK)); | |
238 } | |
239 test_ora(a0, a1, a4); | |
240 for (int i=0; i<ARRLEN; i++) { | |
241 errn += verify("test_ora: ", i, a0[i], (int)((int)(ADD_INIT+i)|BIT_MASK)); | |
242 } | |
243 | |
244 test_xorc(a0, a1); | |
245 for (int i=0; i<ARRLEN; i++) { | |
246 errn += verify("test_xorc: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK)); | |
247 } | |
248 test_xorv(a0, a1, (int)BIT_MASK); | |
249 for (int i=0; i<ARRLEN; i++) { | |
250 errn += verify("test_xorv: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK)); | |
251 } | |
252 test_xora(a0, a1, a4); | |
253 for (int i=0; i<ARRLEN; i++) { | |
254 errn += verify("test_xora: ", i, a0[i], (int)((int)(ADD_INIT+i)^BIT_MASK)); | |
255 } | |
256 | |
257 test_sllc(a0, a1); | |
258 for (int i=0; i<ARRLEN; i++) { | |
259 errn += verify("test_sllc: ", i, a0[i], (int)((int)(ADD_INIT+i)<<VALUE)); | |
260 } | |
261 test_sllv(a0, a1, VALUE); | |
262 for (int i=0; i<ARRLEN; i++) { | |
263 errn += verify("test_sllv: ", i, a0[i], (int)((int)(ADD_INIT+i)<<VALUE)); | |
264 } | |
265 | |
266 test_srlc(a0, a1); | |
267 for (int i=0; i<ARRLEN; i++) { | |
268 errn += verify("test_srlc: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>VALUE)); | |
269 } | |
270 test_srlv(a0, a1, VALUE); | |
271 for (int i=0; i<ARRLEN; i++) { | |
272 errn += verify("test_srlv: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>VALUE)); | |
273 } | |
274 | |
275 test_srac(a0, a1); | |
276 for (int i=0; i<ARRLEN; i++) { | |
277 errn += verify("test_srac: ", i, a0[i], (int)((int)(ADD_INIT+i)>>VALUE)); | |
278 } | |
279 test_srav(a0, a1, VALUE); | |
280 for (int i=0; i<ARRLEN; i++) { | |
281 errn += verify("test_srav: ", i, a0[i], (int)((int)(ADD_INIT+i)>>VALUE)); | |
282 } | |
283 | |
284 test_sllc_n(a0, a1); | |
285 for (int i=0; i<ARRLEN; i++) { | |
286 errn += verify("test_sllc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-VALUE))); | |
287 } | |
288 test_sllv(a0, a1, -VALUE); | |
289 for (int i=0; i<ARRLEN; i++) { | |
290 errn += verify("test_sllv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-VALUE))); | |
291 } | |
292 | |
293 test_srlc_n(a0, a1); | |
294 for (int i=0; i<ARRLEN; i++) { | |
295 errn += verify("test_srlc_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-VALUE))); | |
296 } | |
297 test_srlv(a0, a1, -VALUE); | |
298 for (int i=0; i<ARRLEN; i++) { | |
299 errn += verify("test_srlv_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-VALUE))); | |
300 } | |
301 | |
302 test_srac_n(a0, a1); | |
303 for (int i=0; i<ARRLEN; i++) { | |
304 errn += verify("test_srac_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-VALUE))); | |
305 } | |
306 test_srav(a0, a1, -VALUE); | |
307 for (int i=0; i<ARRLEN; i++) { | |
308 errn += verify("test_srav_n: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-VALUE))); | |
309 } | |
310 | |
311 test_sllc_o(a0, a1); | |
312 for (int i=0; i<ARRLEN; i++) { | |
313 errn += verify("test_sllc_o: ", i, a0[i], (int)((int)(ADD_INIT+i)<<SHIFT)); | |
314 } | |
315 test_sllv(a0, a1, SHIFT); | |
316 for (int i=0; i<ARRLEN; i++) { | |
317 errn += verify("test_sllv_o: ", i, a0[i], (int)((int)(ADD_INIT+i)<<SHIFT)); | |
318 } | |
319 | |
320 test_srlc_o(a0, a1); | |
321 for (int i=0; i<ARRLEN; i++) { | |
322 errn += verify("test_srlc_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>SHIFT)); | |
323 } | |
324 test_srlv(a0, a1, SHIFT); | |
325 for (int i=0; i<ARRLEN; i++) { | |
326 errn += verify("test_srlv_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>SHIFT)); | |
327 } | |
328 | |
329 test_srac_o(a0, a1); | |
330 for (int i=0; i<ARRLEN; i++) { | |
331 errn += verify("test_srac_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>SHIFT)); | |
332 } | |
333 test_srav(a0, a1, SHIFT); | |
334 for (int i=0; i<ARRLEN; i++) { | |
335 errn += verify("test_srav_o: ", i, a0[i], (int)((int)(ADD_INIT+i)>>SHIFT)); | |
336 } | |
337 | |
338 test_sllc_on(a0, a1); | |
339 for (int i=0; i<ARRLEN; i++) { | |
340 errn += verify("test_sllc_on: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-SHIFT))); | |
341 } | |
342 test_sllv(a0, a1, -SHIFT); | |
343 for (int i=0; i<ARRLEN; i++) { | |
344 errn += verify("test_sllv_on: ", i, a0[i], (int)((int)(ADD_INIT+i)<<(-SHIFT))); | |
345 } | |
346 | |
347 test_srlc_on(a0, a1); | |
348 for (int i=0; i<ARRLEN; i++) { | |
349 errn += verify("test_srlc_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-SHIFT))); | |
350 } | |
351 test_srlv(a0, a1, -SHIFT); | |
352 for (int i=0; i<ARRLEN; i++) { | |
353 errn += verify("test_srlv_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>>(-SHIFT))); | |
354 } | |
355 | |
356 test_srac_on(a0, a1); | |
357 for (int i=0; i<ARRLEN; i++) { | |
358 errn += verify("test_srac_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-SHIFT))); | |
359 } | |
360 test_srav(a0, a1, -SHIFT); | |
361 for (int i=0; i<ARRLEN; i++) { | |
362 errn += verify("test_srav_on: ", i, a0[i], (int)((int)(ADD_INIT+i)>>(-SHIFT))); | |
363 } | |
364 | |
365 test_pack2(p2, a1); | |
366 for (int i=0; i<ARRLEN/2; i++) { | |
367 errn += verify("test_pack2: ", i, p2[i], ((long)(ADD_INIT+2*i) & 0xFFFFFFFFl) | ((long)(ADD_INIT+2*i+1) << 32)); | |
368 } | |
369 for (int i=0; i<ARRLEN; i++) { | |
370 a0[i] = -1; | |
371 } | |
372 test_unpack2(a0, p2); | |
373 for (int i=0; i<(ARRLEN&(-2)); i++) { | |
374 errn += verify("test_unpack2: ", i, a0[i], (ADD_INIT+i)); | |
375 } | |
376 | |
377 test_pack2_swap(p2, a1); | |
378 for (int i=0; i<ARRLEN/2; i++) { | |
379 errn += verify("test_pack2_swap: ", i, p2[i], ((long)(ADD_INIT+2*i+1) & 0xFFFFFFFFl) | ((long)(ADD_INIT+2*i) << 32)); | |
380 } | |
381 for (int i=0; i<ARRLEN; i++) { | |
382 a0[i] = -1; | |
383 } | |
384 test_unpack2_swap(a0, p2); | |
385 for (int i=0; i<(ARRLEN&(-2)); i++) { | |
386 errn += verify("test_unpack2_swap: ", i, a0[i], (ADD_INIT+i)); | |
387 } | |
388 | |
389 } | |
390 | |
391 return errn; | |
392 } | |
393 | |
394 static int test_sum(int[] a1) { | |
395 int sum = 0; | |
396 for (int i = 0; i < a1.length; i+=1) { | |
397 sum += a1[i]; | |
398 } | |
399 return sum; | |
400 } | |
401 | |
402 static void test_addc(int[] a0, int[] a1) { | |
403 for (int i = 0; i < a0.length; i+=1) { | |
404 a0[i] = (int)(a1[i]+VALUE); | |
405 } | |
406 } | |
407 static void test_addv(int[] a0, int[] a1, int b) { | |
408 for (int i = 0; i < a0.length; i+=1) { | |
409 a0[i] = (int)(a1[i]+b); | |
410 } | |
411 } | |
412 static void test_adda(int[] a0, int[] a1, int[] a2) { | |
413 for (int i = 0; i < a0.length; i+=1) { | |
414 a0[i] = (int)(a1[i]+a2[i]); | |
415 } | |
416 } | |
417 | |
418 static void test_subc(int[] a0, int[] a1) { | |
419 for (int i = 0; i < a0.length; i+=1) { | |
420 a0[i] = (int)(a1[i]-VALUE); | |
421 } | |
422 } | |
423 static void test_subv(int[] a0, int[] a1, int b) { | |
424 for (int i = 0; i < a0.length; i+=1) { | |
425 a0[i] = (int)(a1[i]-b); | |
426 } | |
427 } | |
428 static void test_suba(int[] a0, int[] a1, int[] a2) { | |
429 for (int i = 0; i < a0.length; i+=1) { | |
430 a0[i] = (int)(a1[i]-a2[i]); | |
431 } | |
432 } | |
433 | |
434 static void test_mulc(int[] a0, int[] a1) { | |
435 for (int i = 0; i < a0.length; i+=1) { | |
436 a0[i] = (int)(a1[i]*VALUE); | |
437 } | |
438 } | |
439 static void test_mulc_n(int[] a0, int[] a1) { | |
440 for (int i = 0; i < a0.length; i+=1) { | |
441 a0[i] = (int)(a1[i]*(-VALUE)); | |
442 } | |
443 } | |
444 static void test_mulv(int[] a0, int[] a1, int b) { | |
445 for (int i = 0; i < a0.length; i+=1) { | |
446 a0[i] = (int)(a1[i]*b); | |
447 } | |
448 } | |
449 static void test_mula(int[] a0, int[] a1, int[] a2) { | |
450 for (int i = 0; i < a0.length; i+=1) { | |
451 a0[i] = (int)(a1[i]*a2[i]); | |
452 } | |
453 } | |
454 | |
455 static void test_divc(int[] a0, int[] a1) { | |
456 for (int i = 0; i < a0.length; i+=1) { | |
457 a0[i] = (int)(a1[i]/VALUE); | |
458 } | |
459 } | |
460 static void test_divc_n(int[] a0, int[] a1) { | |
461 for (int i = 0; i < a0.length; i+=1) { | |
462 a0[i] = (int)(a1[i]/(-VALUE)); | |
463 } | |
464 } | |
465 static void test_divv(int[] a0, int[] a1, int b) { | |
466 for (int i = 0; i < a0.length; i+=1) { | |
467 a0[i] = (int)(a1[i]/b); | |
468 } | |
469 } | |
470 static void test_diva(int[] a0, int[] a1, int[] a2) { | |
471 for (int i = 0; i < a0.length; i+=1) { | |
472 a0[i] = (int)(a1[i]/a2[i]); | |
473 } | |
474 } | |
475 | |
476 static void test_andc(int[] a0, int[] a1) { | |
477 for (int i = 0; i < a0.length; i+=1) { | |
478 a0[i] = (int)(a1[i]&BIT_MASK); | |
479 } | |
480 } | |
481 static void test_andv(int[] a0, int[] a1, int b) { | |
482 for (int i = 0; i < a0.length; i+=1) { | |
483 a0[i] = (int)(a1[i]&b); | |
484 } | |
485 } | |
486 static void test_anda(int[] a0, int[] a1, int[] a2) { | |
487 for (int i = 0; i < a0.length; i+=1) { | |
488 a0[i] = (int)(a1[i]&a2[i]); | |
489 } | |
490 } | |
491 | |
492 static void test_orc(int[] a0, int[] a1) { | |
493 for (int i = 0; i < a0.length; i+=1) { | |
494 a0[i] = (int)(a1[i]|BIT_MASK); | |
495 } | |
496 } | |
497 static void test_orv(int[] a0, int[] a1, int b) { | |
498 for (int i = 0; i < a0.length; i+=1) { | |
499 a0[i] = (int)(a1[i]|b); | |
500 } | |
501 } | |
502 static void test_ora(int[] a0, int[] a1, int[] a2) { | |
503 for (int i = 0; i < a0.length; i+=1) { | |
504 a0[i] = (int)(a1[i]|a2[i]); | |
505 } | |
506 } | |
507 | |
508 static void test_xorc(int[] a0, int[] a1) { | |
509 for (int i = 0; i < a0.length; i+=1) { | |
510 a0[i] = (int)(a1[i]^BIT_MASK); | |
511 } | |
512 } | |
513 static void test_xorv(int[] a0, int[] a1, int b) { | |
514 for (int i = 0; i < a0.length; i+=1) { | |
515 a0[i] = (int)(a1[i]^b); | |
516 } | |
517 } | |
518 static void test_xora(int[] a0, int[] a1, int[] a2) { | |
519 for (int i = 0; i < a0.length; i+=1) { | |
520 a0[i] = (int)(a1[i]^a2[i]); | |
521 } | |
522 } | |
523 | |
524 static void test_sllc(int[] a0, int[] a1) { | |
525 for (int i = 0; i < a0.length; i+=1) { | |
526 a0[i] = (int)(a1[i]<<VALUE); | |
527 } | |
528 } | |
529 static void test_sllc_n(int[] a0, int[] a1) { | |
530 for (int i = 0; i < a0.length; i+=1) { | |
531 a0[i] = (int)(a1[i]<<(-VALUE)); | |
532 } | |
533 } | |
534 static void test_sllc_o(int[] a0, int[] a1) { | |
535 for (int i = 0; i < a0.length; i+=1) { | |
536 a0[i] = (int)(a1[i]<<SHIFT); | |
537 } | |
538 } | |
539 static void test_sllc_on(int[] a0, int[] a1) { | |
540 for (int i = 0; i < a0.length; i+=1) { | |
541 a0[i] = (int)(a1[i]<<(-SHIFT)); | |
542 } | |
543 } | |
544 static void test_sllv(int[] a0, int[] a1, int b) { | |
545 for (int i = 0; i < a0.length; i+=1) { | |
546 a0[i] = (int)(a1[i]<<b); | |
547 } | |
548 } | |
549 | |
550 static void test_srlc(int[] a0, int[] a1) { | |
551 for (int i = 0; i < a0.length; i+=1) { | |
552 a0[i] = (int)(a1[i]>>>VALUE); | |
553 } | |
554 } | |
555 static void test_srlc_n(int[] a0, int[] a1) { | |
556 for (int i = 0; i < a0.length; i+=1) { | |
557 a0[i] = (int)(a1[i]>>>(-VALUE)); | |
558 } | |
559 } | |
560 static void test_srlc_o(int[] a0, int[] a1) { | |
561 for (int i = 0; i < a0.length; i+=1) { | |
562 a0[i] = (int)(a1[i]>>>SHIFT); | |
563 } | |
564 } | |
565 static void test_srlc_on(int[] a0, int[] a1) { | |
566 for (int i = 0; i < a0.length; i+=1) { | |
567 a0[i] = (int)(a1[i]>>>(-SHIFT)); | |
568 } | |
569 } | |
570 static void test_srlv(int[] a0, int[] a1, int b) { | |
571 for (int i = 0; i < a0.length; i+=1) { | |
572 a0[i] = (int)(a1[i]>>>b); | |
573 } | |
574 } | |
575 | |
576 static void test_srac(int[] a0, int[] a1) { | |
577 for (int i = 0; i < a0.length; i+=1) { | |
578 a0[i] = (int)(a1[i]>>VALUE); | |
579 } | |
580 } | |
581 static void test_srac_n(int[] a0, int[] a1) { | |
582 for (int i = 0; i < a0.length; i+=1) { | |
583 a0[i] = (int)(a1[i]>>(-VALUE)); | |
584 } | |
585 } | |
586 static void test_srac_o(int[] a0, int[] a1) { | |
587 for (int i = 0; i < a0.length; i+=1) { | |
588 a0[i] = (int)(a1[i]>>SHIFT); | |
589 } | |
590 } | |
591 static void test_srac_on(int[] a0, int[] a1) { | |
592 for (int i = 0; i < a0.length; i+=1) { | |
593 a0[i] = (int)(a1[i]>>(-SHIFT)); | |
594 } | |
595 } | |
596 static void test_srav(int[] a0, int[] a1, int b) { | |
597 for (int i = 0; i < a0.length; i+=1) { | |
598 a0[i] = (int)(a1[i]>>b); | |
599 } | |
600 } | |
601 | |
602 static void test_pack2(long[] p2, int[] a1) { | |
603 if (p2.length*2 > a1.length) return; | |
604 for (int i = 0; i < p2.length; i+=1) { | |
605 long l0 = (long)a1[i*2+0]; | |
606 long l1 = (long)a1[i*2+1]; | |
607 p2[i] = (l1 << 32) | (l0 & 0xFFFFFFFFl); | |
608 } | |
609 } | |
610 static void test_unpack2(int[] a0, long[] p2) { | |
611 if (p2.length*2 > a0.length) return; | |
612 for (int i = 0; i < p2.length; i+=1) { | |
613 long l = p2[i]; | |
614 a0[i*2+0] = (int)(l & 0xFFFFFFFFl); | |
615 a0[i*2+1] = (int)(l >> 32); | |
616 } | |
617 } | |
618 static void test_pack2_swap(long[] p2, int[] a1) { | |
619 if (p2.length*2 > a1.length) return; | |
620 for (int i = 0; i < p2.length; i+=1) { | |
621 long l0 = (long)a1[i*2+0]; | |
622 long l1 = (long)a1[i*2+1]; | |
623 p2[i] = (l0 << 32) | (l1 & 0xFFFFFFFFl); | |
624 } | |
625 } | |
626 static void test_unpack2_swap(int[] a0, long[] p2) { | |
627 if (p2.length*2 > a0.length) return; | |
628 for (int i = 0; i < p2.length; i+=1) { | |
629 long l = p2[i]; | |
630 a0[i*2+0] = (int)(l >> 32); | |
631 a0[i*2+1] = (int)(l & 0xFFFFFFFFl); | |
632 } | |
633 } | |
634 | |
635 static int verify(String text, int i, int elem, int val) { | |
636 if (elem != val) { | |
637 System.err.println(text + "[" + i + "] = " + elem + " != " + val); | |
638 return 1; | |
639 } | |
640 return 0; | |
641 } | |
642 | |
643 static int verify(String text, int i, long elem, long val) { | |
644 if (elem != val) { | |
645 System.err.println(text + "[" + i + "] = " + Long.toHexString(elem) + " != " + Long.toHexString(val)); | |
646 return 1; | |
647 } | |
648 return 0; | |
649 } | |
650 } |