Mercurial > hg > truffle

comparison test/compiler/8001183/TestCharVect.java @ 6893:b2c669fd8114

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8001183: incorrect results of char vectors right shift operaiton Summary: do vector right shift operation for small int types only after loads Reviewed-by: jrose, dlong
author kvn
date Tue, 23 Oct 2012 13:06:37 -0700
parents
children
comparison
equal deleted inserted replaced
6892:fd1d564dd460 6893:b2c669fd8114
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 8001183
28 * @summary incorrect results of char vectors right shift operaiton
29 *
30 * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestCharVect
31 */
32
33 public class TestCharVect {
34 private static final int ARRLEN = 997;
35 private static final int ITERS = 11000;
36 private static final int ADD_INIT = Character.MAX_VALUE-500;
37 private static final int BIT_MASK = 0xB731;
38 private static final int VALUE = 7;
39 private static final int SHIFT = 16;
40
41 public static void main(String args[]) {
42 System.out.println("Testing Char vectors");
43 int errn = test();
44 if (errn > 0) {
45 System.err.println("FAILED: " + errn + " errors");
46 System.exit(97);
47 }
48 System.out.println("PASSED");
49 }
50
51 static int test() {
52 char[] a0 = new char[ARRLEN];
53 char[] a1 = new char[ARRLEN];
54 short[] a2 = new short[ARRLEN];
55 short[] a3 = new short[ARRLEN];
56 short[] a4 = new short[ARRLEN];
57 int[] p2 = new int[ARRLEN/2];
58 long[] p4 = new long[ARRLEN/4];
59 // Initialize
60 int gold_sum = 0;
61 for (int i=0; i<ARRLEN; i++) {
62 char val = (char)(ADD_INIT+i);
63 gold_sum += val;
64 a1[i] = val;
65 a2[i] = VALUE;
66 a3[i] = -VALUE;
67 a4[i] = (short)BIT_MASK;
68 }
69 System.out.println("Warmup");
70 for (int i=0; i<ITERS; i++) {
71 test_sum(a1);
72 test_addc(a0, a1);
73 test_addv(a0, a1, (char)VALUE);
74 test_adda(a0, a1, a2);
75 test_subc(a0, a1);
76 test_subv(a0, a1, (char)VALUE);
77 test_suba(a0, a1, a2);
78
79 test_mulc(a0, a1);
80 test_mulv(a0, a1, (char)VALUE);
81 test_mula(a0, a1, a2);
82 test_divc(a0, a1);
83 test_divv(a0, a1, VALUE);
84 test_diva(a0, a1, a2);
85 test_mulc_n(a0, a1);
86 test_mulv(a0, a1, (char)-VALUE);
87 test_mula(a0, a1, a3);
88 test_divc_n(a0, a1);
89 test_divv(a0, a1, -VALUE);
90 test_diva(a0, a1, a3);
91
92 test_andc(a0, a1);
93 test_andv(a0, a1, (short)BIT_MASK);
94 test_anda(a0, a1, a4);
95 test_orc(a0, a1);
96 test_orv(a0, a1, (short)BIT_MASK);
97 test_ora(a0, a1, a4);
98 test_xorc(a0, a1);
99 test_xorv(a0, a1, (short)BIT_MASK);
100 test_xora(a0, a1, a4);
101
102 test_sllc(a0, a1);
103 test_sllv(a0, a1, VALUE);
104 test_srlc(a0, a1);
105 test_srlv(a0, a1, VALUE);
106 test_srac(a0, a1);
107 test_srav(a0, a1, VALUE);
108
109 test_sllc_n(a0, a1);
110 test_sllv(a0, a1, -VALUE);
111 test_srlc_n(a0, a1);
112 test_srlv(a0, a1, -VALUE);
113 test_srac_n(a0, a1);
114 test_srav(a0, a1, -VALUE);
115
116 test_sllc_o(a0, a1);
117 test_sllv(a0, a1, SHIFT);
118 test_srlc_o(a0, a1);
119 test_srlv(a0, a1, SHIFT);
120 test_srac_o(a0, a1);
121 test_srav(a0, a1, SHIFT);
122
123 test_sllc_on(a0, a1);
124 test_sllv(a0, a1, -SHIFT);
125 test_srlc_on(a0, a1);
126 test_srlv(a0, a1, -SHIFT);
127 test_srac_on(a0, a1);
128 test_srav(a0, a1, -SHIFT);
129
130 test_sllc_add(a0, a1);
131 test_sllv_add(a0, a1, ADD_INIT);
132 test_srlc_add(a0, a1);
133 test_srlv_add(a0, a1, ADD_INIT);
134 test_srac_add(a0, a1);
135 test_srav_add(a0, a1, ADD_INIT);
136
137 test_sllc_and(a0, a1);
138 test_sllv_and(a0, a1, BIT_MASK);
139 test_srlc_and(a0, a1);
140 test_srlv_and(a0, a1, BIT_MASK);
141 test_srac_and(a0, a1);
142 test_srav_and(a0, a1, BIT_MASK);
143
144 test_pack2(p2, a1);
145 test_unpack2(a0, p2);
146 test_pack2_swap(p2, a1);
147 test_unpack2_swap(a0, p2);
148 test_pack4(p4, a1);
149 test_unpack4(a0, p4);
150 test_pack4_swap(p4, a1);
151 test_unpack4_swap(a0, p4);
152 }
153 // Test and verify results
154 System.out.println("Verification");
155 int errn = 0;
156 {
157 int sum = test_sum(a1);
158 if (sum != gold_sum) {
159 System.err.println("test_sum: " + sum + " != " + gold_sum);
160 errn++;
161 }
162
163 test_addc(a0, a1);
164 for (int i=0; i<ARRLEN; i++) {
165 errn += verify("test_addc: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));
166 }
167 test_addv(a0, a1, (char)VALUE);
168 for (int i=0; i<ARRLEN; i++) {
169 errn += verify("test_addv: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));
170 }
171 test_adda(a0, a1, a2);
172 for (int i=0; i<ARRLEN; i++) {
173 errn += verify("test_adda: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));
174 }
175
176 test_subc(a0, a1);
177 for (int i=0; i<ARRLEN; i++) {
178 errn += verify("test_subc: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));
179 }
180 test_subv(a0, a1, (char)VALUE);
181 for (int i=0; i<ARRLEN; i++) {
182 errn += verify("test_subv: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));
183 }
184 test_suba(a0, a1, a2);
185 for (int i=0; i<ARRLEN; i++) {
186 errn += verify("test_suba: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));
187 }
188
189 test_mulc(a0, a1);
190 for (int i=0; i<ARRLEN; i++) {
191 errn += verify("test_mulc: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));
192 }
193 test_mulv(a0, a1, (char)VALUE);
194 for (int i=0; i<ARRLEN; i++) {
195 errn += verify("test_mulv: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));
196 }
197 test_mula(a0, a1, a2);
198 for (int i=0; i<ARRLEN; i++) {
199 errn += verify("test_mula: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));
200 }
201
202 test_divc(a0, a1);
203 for (int i=0; i<ARRLEN; i++) {
204 errn += verify("test_divc: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));
205 }
206 test_divv(a0, a1, VALUE);
207 for (int i=0; i<ARRLEN; i++) {
208 errn += verify("test_divv: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));
209 }
210 test_diva(a0, a1, a2);
211 for (int i=0; i<ARRLEN; i++) {
212 errn += verify("test_diva: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));
213 }
214
215 test_mulc_n(a0, a1);
216 for (int i=0; i<ARRLEN; i++) {
217 errn += verify("test_mulc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));
218 }
219 test_mulv(a0, a1, (char)-VALUE);
220 for (int i=0; i<ARRLEN; i++) {
221 errn += verify("test_mulv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));
222 }
223 test_mula(a0, a1, a3);
224 for (int i=0; i<ARRLEN; i++) {
225 errn += verify("test_mula_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));
226 }
227
228 test_divc_n(a0, a1);
229 for (int i=0; i<ARRLEN; i++) {
230 errn += verify("test_divc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));
231 }
232 test_divv(a0, a1, -VALUE);
233 for (int i=0; i<ARRLEN; i++) {
234 errn += verify("test_divv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));
235 }
236 test_diva(a0, a1, a3);
237 for (int i=0; i<ARRLEN; i++) {
238 errn += verify("test_diva_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));
239 }
240
241 test_andc(a0, a1);
242 for (int i=0; i<ARRLEN; i++) {
243 errn += verify("test_andc: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));
244 }
245 test_andv(a0, a1, (short)BIT_MASK);
246 for (int i=0; i<ARRLEN; i++) {
247 errn += verify("test_andv: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));
248 }
249 test_anda(a0, a1, a4);
250 for (int i=0; i<ARRLEN; i++) {
251 errn += verify("test_anda: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));
252 }
253
254 test_orc(a0, a1);
255 for (int i=0; i<ARRLEN; i++) {
256 errn += verify("test_orc: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));
257 }
258 test_orv(a0, a1, (short)BIT_MASK);
259 for (int i=0; i<ARRLEN; i++) {
260 errn += verify("test_orv: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));
261 }
262 test_ora(a0, a1, a4);
263 for (int i=0; i<ARRLEN; i++) {
264 errn += verify("test_ora: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));
265 }
266
267 test_xorc(a0, a1);
268 for (int i=0; i<ARRLEN; i++) {
269 errn += verify("test_xorc: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));
270 }
271 test_xorv(a0, a1, (short)BIT_MASK);
272 for (int i=0; i<ARRLEN; i++) {
273 errn += verify("test_xorv: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));
274 }
275 test_xora(a0, a1, a4);
276 for (int i=0; i<ARRLEN; i++) {
277 errn += verify("test_xora: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));
278 }
279
280 test_sllc(a0, a1);
281 for (int i=0; i<ARRLEN; i++) {
282 errn += verify("test_sllc: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE));
283 }
284 test_sllv(a0, a1, VALUE);
285 for (int i=0; i<ARRLEN; i++) {
286 errn += verify("test_sllv: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE));
287 }
288
289 test_srlc(a0, a1);
290 for (int i=0; i<ARRLEN; i++) {
291 errn += verify("test_srlc: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE));
292 }
293 test_srlv(a0, a1, VALUE);
294 for (int i=0; i<ARRLEN; i++) {
295 errn += verify("test_srlv: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE));
296 }
297
298 test_srac(a0, a1);
299 for (int i=0; i<ARRLEN; i++) {
300 errn += verify("test_srac: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE));
301 }
302 test_srav(a0, a1, VALUE);
303 for (int i=0; i<ARRLEN; i++) {
304 errn += verify("test_srav: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE));
305 }
306
307 test_sllc_n(a0, a1);
308 for (int i=0; i<ARRLEN; i++) {
309 errn += verify("test_sllc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE)));
310 }
311 test_sllv(a0, a1, -VALUE);
312 for (int i=0; i<ARRLEN; i++) {
313 errn += verify("test_sllv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE)));
314 }
315
316 test_srlc_n(a0, a1);
317 for (int i=0; i<ARRLEN; i++) {
318 errn += verify("test_srlc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE)));
319 }
320 test_srlv(a0, a1, -VALUE);
321 for (int i=0; i<ARRLEN; i++) {
322 errn += verify("test_srlv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE)));
323 }
324
325 test_srac_n(a0, a1);
326 for (int i=0; i<ARRLEN; i++) {
327 errn += verify("test_srac_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE)));
328 }
329 test_srav(a0, a1, -VALUE);
330 for (int i=0; i<ARRLEN; i++) {
331 errn += verify("test_srav_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE)));
332 }
333
334 test_sllc_o(a0, a1);
335 for (int i=0; i<ARRLEN; i++) {
336 errn += verify("test_sllc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT));
337 }
338 test_sllv(a0, a1, SHIFT);
339 for (int i=0; i<ARRLEN; i++) {
340 errn += verify("test_sllv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT));
341 }
342
343 test_srlc_o(a0, a1);
344 for (int i=0; i<ARRLEN; i++) {
345 errn += verify("test_srlc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT));
346 }
347 test_srlv(a0, a1, SHIFT);
348 for (int i=0; i<ARRLEN; i++) {
349 errn += verify("test_srlv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT));
350 }
351
352 test_srac_o(a0, a1);
353 for (int i=0; i<ARRLEN; i++) {
354 errn += verify("test_srac_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT));
355 }
356 test_srav(a0, a1, SHIFT);
357 for (int i=0; i<ARRLEN; i++) {
358 errn += verify("test_srav_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT));
359 }
360
361 test_sllc_on(a0, a1);
362 for (int i=0; i<ARRLEN; i++) {
363 errn += verify("test_sllc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT)));
364 }
365 test_sllv(a0, a1, -SHIFT);
366 for (int i=0; i<ARRLEN; i++) {
367 errn += verify("test_sllv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT)));
368 }
369
370 test_srlc_on(a0, a1);
371 for (int i=0; i<ARRLEN; i++) {
372 errn += verify("test_srlc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT)));
373 }
374 test_srlv(a0, a1, -SHIFT);
375 for (int i=0; i<ARRLEN; i++) {
376 errn += verify("test_srlv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT)));
377 }
378
379 test_srac_on(a0, a1);
380 for (int i=0; i<ARRLEN; i++) {
381 errn += verify("test_srac_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT)));
382 }
383 test_srav(a0, a1, -SHIFT);
384 for (int i=0; i<ARRLEN; i++) {
385 errn += verify("test_srav_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT)));
386 }
387
388 test_sllc_add(a0, a1);
389 for (int i=0; i<ARRLEN; i++) {
390 errn += verify("test_sllc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE));
391 }
392 test_sllv_add(a0, a1, ADD_INIT);
393 for (int i=0; i<ARRLEN; i++) {
394 errn += verify("test_sllv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE));
395 }
396
397 test_srlc_add(a0, a1);
398 for (int i=0; i<ARRLEN; i++) {
399 errn += verify("test_srlc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
400 }
401 test_srlv_add(a0, a1, ADD_INIT);
402 for (int i=0; i<ARRLEN; i++) {
403 errn += verify("test_srlv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
404 }
405
406 test_srac_add(a0, a1);
407 for (int i=0; i<ARRLEN; i++) {
408 errn += verify("test_srac_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE));
409 }
410 test_srav_add(a0, a1, ADD_INIT);
411 for (int i=0; i<ARRLEN; i++) {
412 errn += verify("test_srav_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE));
413 }
414
415 test_sllc_and(a0, a1);
416 for (int i=0; i<ARRLEN; i++) {
417 errn += verify("test_sllc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE));
418 }
419 test_sllv_and(a0, a1, BIT_MASK);
420 for (int i=0; i<ARRLEN; i++) {
421 errn += verify("test_sllv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE));
422 }
423
424 test_srlc_and(a0, a1);
425 for (int i=0; i<ARRLEN; i++) {
426 errn += verify("test_srlc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
427 }
428 test_srlv_and(a0, a1, BIT_MASK);
429 for (int i=0; i<ARRLEN; i++) {
430 errn += verify("test_srlv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
431 }
432
433 test_srac_and(a0, a1);
434 for (int i=0; i<ARRLEN; i++) {
435 errn += verify("test_srac_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE));
436 }
437 test_srav_and(a0, a1, BIT_MASK);
438 for (int i=0; i<ARRLEN; i++) {
439 errn += verify("test_srav_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE));
440 }
441
442 test_pack2(p2, a1);
443 for (int i=0; i<ARRLEN/2; i++) {
444 errn += verify("test_pack2: ", i, p2[i], ((int)(ADD_INIT+2*i) & 0xFFFF) | ((int)(ADD_INIT+2*i+1) << 16));
445 }
446 for (int i=0; i<ARRLEN; i++) {
447 a0[i] = (char)-1;
448 }
449 test_unpack2(a0, p2);
450 for (int i=0; i<(ARRLEN&(-2)); i++) {
451 errn += verify("test_unpack2: ", i, a0[i], (char)(ADD_INIT+i));
452 }
453
454 test_pack2_swap(p2, a1);
455 for (int i=0; i<ARRLEN/2; i++) {
456 errn += verify("test_pack2_swap: ", i, p2[i], ((int)(ADD_INIT+2*i+1) & 0xFFFF) | ((int)(ADD_INIT+2*i) << 16));
457 }
458 for (int i=0; i<ARRLEN; i++) {
459 a0[i] = (char)-1;
460 }
461 test_unpack2_swap(a0, p2);
462 for (int i=0; i<(ARRLEN&(-2)); i++) {
463 errn += verify("test_unpack2_swap: ", i, a0[i], (char)(ADD_INIT+i));
464 }
465
466 test_pack4(p4, a1);
467 for (int i=0; i<ARRLEN/4; i++) {
468 errn += verify("test_pack4: ", i, p4[i], ((long)(ADD_INIT+4*i+0) & 0xFFFFl) |
469 (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 16) |
470 (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 32) |
471 (((long)(ADD_INIT+4*i+3) & 0xFFFFl) << 48));
472 }
473 for (int i=0; i<ARRLEN; i++) {
474 a0[i] = (char)-1;
475 }
476 test_unpack4(a0, p4);
477 for (int i=0; i<(ARRLEN&(-4)); i++) {
478 errn += verify("test_unpack4: ", i, a0[i], (char)(ADD_INIT+i));
479 }
480
481 test_pack4_swap(p4, a1);
482 for (int i=0; i<ARRLEN/4; i++) {
483 errn += verify("test_pack4_swap: ", i, p4[i], ((long)(ADD_INIT+4*i+3) & 0xFFFFl) |
484 (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 16) |
485 (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 32) |
486 (((long)(ADD_INIT+4*i+0) & 0xFFFFl) << 48));
487 }
488 for (int i=0; i<ARRLEN; i++) {
489 a0[i] = (char)-1;
490 }
491 test_unpack4_swap(a0, p4);
492 for (int i=0; i<(ARRLEN&(-4)); i++) {
493 errn += verify("test_unpack4_swap: ", i, a0[i], (char)(ADD_INIT+i));
494 }
495
496 }
497
498 if (errn > 0)
499 return errn;
500
501 System.out.println("Time");
502 long start, end;
503
504 start = System.currentTimeMillis();
505 for (int i=0; i<ITERS; i++) {
506 test_sum(a1);
507 }
508 end = System.currentTimeMillis();
509 System.out.println("test_sum: " + (end - start));
510
511 start = System.currentTimeMillis();
512 for (int i=0; i<ITERS; i++) {
513 test_addc(a0, a1);
514 }
515 end = System.currentTimeMillis();
516 System.out.println("test_addc: " + (end - start));
517 start = System.currentTimeMillis();
518 for (int i=0; i<ITERS; i++) {
519 test_addv(a0, a1, (char)VALUE);
520 }
521 end = System.currentTimeMillis();
522 System.out.println("test_addv: " + (end - start));
523 start = System.currentTimeMillis();
524 for (int i=0; i<ITERS; i++) {
525 test_adda(a0, a1, a2);
526 }
527 end = System.currentTimeMillis();
528 System.out.println("test_adda: " + (end - start));
529
530 start = System.currentTimeMillis();
531 for (int i=0; i<ITERS; i++) {
532 test_subc(a0, a1);
533 }
534 end = System.currentTimeMillis();
535 System.out.println("test_subc: " + (end - start));
536 start = System.currentTimeMillis();
537 for (int i=0; i<ITERS; i++) {
538 test_subv(a0, a1, (char)VALUE);
539 }
540 end = System.currentTimeMillis();
541 System.out.println("test_subv: " + (end - start));
542 start = System.currentTimeMillis();
543 for (int i=0; i<ITERS; i++) {
544 test_suba(a0, a1, a2);
545 }
546 end = System.currentTimeMillis();
547 System.out.println("test_suba: " + (end - start));
548
549 start = System.currentTimeMillis();
550 for (int i=0; i<ITERS; i++) {
551 test_mulc(a0, a1);
552 }
553 end = System.currentTimeMillis();
554 System.out.println("test_mulc: " + (end - start));
555 start = System.currentTimeMillis();
556 for (int i=0; i<ITERS; i++) {
557 test_mulv(a0, a1, (char)VALUE);
558 }
559 end = System.currentTimeMillis();
560 System.out.println("test_mulv: " + (end - start));
561 start = System.currentTimeMillis();
562 for (int i=0; i<ITERS; i++) {
563 test_mula(a0, a1, a2);
564 }
565 end = System.currentTimeMillis();
566 System.out.println("test_mula: " + (end - start));
567
568 start = System.currentTimeMillis();
569 for (int i=0; i<ITERS; i++) {
570 test_divc(a0, a1);
571 }
572 end = System.currentTimeMillis();
573 System.out.println("test_divc: " + (end - start));
574 start = System.currentTimeMillis();
575 for (int i=0; i<ITERS; i++) {
576 test_divv(a0, a1, VALUE);
577 }
578 end = System.currentTimeMillis();
579 System.out.println("test_divv: " + (end - start));
580 start = System.currentTimeMillis();
581 for (int i=0; i<ITERS; i++) {
582 test_diva(a0, a1, a2);
583 }
584 end = System.currentTimeMillis();
585 System.out.println("test_diva: " + (end - start));
586
587 start = System.currentTimeMillis();
588 for (int i=0; i<ITERS; i++) {
589 test_mulc_n(a0, a1);
590 }
591 end = System.currentTimeMillis();
592 System.out.println("test_mulc_n: " + (end - start));
593 start = System.currentTimeMillis();
594 for (int i=0; i<ITERS; i++) {
595 test_mulv(a0, a1, (char)-VALUE);
596 }
597 end = System.currentTimeMillis();
598 System.out.println("test_mulv_n: " + (end - start));
599 start = System.currentTimeMillis();
600 for (int i=0; i<ITERS; i++) {
601 test_mula(a0, a1, a3);
602 }
603 end = System.currentTimeMillis();
604 System.out.println("test_mula_n: " + (end - start));
605
606 start = System.currentTimeMillis();
607 for (int i=0; i<ITERS; i++) {
608 test_divc_n(a0, a1);
609 }
610 end = System.currentTimeMillis();
611 System.out.println("test_divc_n: " + (end - start));
612 start = System.currentTimeMillis();
613 for (int i=0; i<ITERS; i++) {
614 test_divv(a0, a1, -VALUE);
615 }
616 end = System.currentTimeMillis();
617 System.out.println("test_divv_n: " + (end - start));
618 start = System.currentTimeMillis();
619 for (int i=0; i<ITERS; i++) {
620 test_diva(a0, a1, a3);
621 }
622 end = System.currentTimeMillis();
623 System.out.println("test_diva_n: " + (end - start));
624
625 start = System.currentTimeMillis();
626 for (int i=0; i<ITERS; i++) {
627 test_andc(a0, a1);
628 }
629 end = System.currentTimeMillis();
630 System.out.println("test_andc: " + (end - start));
631 start = System.currentTimeMillis();
632 for (int i=0; i<ITERS; i++) {
633 test_andv(a0, a1, (short)BIT_MASK);
634 }
635 end = System.currentTimeMillis();
636 System.out.println("test_andv: " + (end - start));
637 start = System.currentTimeMillis();
638 for (int i=0; i<ITERS; i++) {
639 test_anda(a0, a1, a4);
640 }
641 end = System.currentTimeMillis();
642 System.out.println("test_anda: " + (end - start));
643
644 start = System.currentTimeMillis();
645 for (int i=0; i<ITERS; i++) {
646 test_orc(a0, a1);
647 }
648 end = System.currentTimeMillis();
649 System.out.println("test_orc: " + (end - start));
650 start = System.currentTimeMillis();
651 for (int i=0; i<ITERS; i++) {
652 test_orv(a0, a1, (short)BIT_MASK);
653 }
654 end = System.currentTimeMillis();
655 System.out.println("test_orv: " + (end - start));
656 start = System.currentTimeMillis();
657 for (int i=0; i<ITERS; i++) {
658 test_ora(a0, a1, a4);
659 }
660 end = System.currentTimeMillis();
661 System.out.println("test_ora: " + (end - start));
662
663 start = System.currentTimeMillis();
664 for (int i=0; i<ITERS; i++) {
665 test_xorc(a0, a1);
666 }
667 end = System.currentTimeMillis();
668 System.out.println("test_xorc: " + (end - start));
669 start = System.currentTimeMillis();
670 for (int i=0; i<ITERS; i++) {
671 test_xorv(a0, a1, (short)BIT_MASK);
672 }
673 end = System.currentTimeMillis();
674 System.out.println("test_xorv: " + (end - start));
675 start = System.currentTimeMillis();
676 for (int i=0; i<ITERS; i++) {
677 test_xora(a0, a1, a4);
678 }
679 end = System.currentTimeMillis();
680 System.out.println("test_xora: " + (end - start));
681
682 start = System.currentTimeMillis();
683 for (int i=0; i<ITERS; i++) {
684 test_sllc(a0, a1);
685 }
686 end = System.currentTimeMillis();
687 System.out.println("test_sllc: " + (end - start));
688 start = System.currentTimeMillis();
689 for (int i=0; i<ITERS; i++) {
690 test_sllv(a0, a1, VALUE);
691 }
692 end = System.currentTimeMillis();
693 System.out.println("test_sllv: " + (end - start));
694
695 start = System.currentTimeMillis();
696 for (int i=0; i<ITERS; i++) {
697 test_srlc(a0, a1);
698 }
699 end = System.currentTimeMillis();
700 System.out.println("test_srlc: " + (end - start));
701 start = System.currentTimeMillis();
702 for (int i=0; i<ITERS; i++) {
703 test_srlv(a0, a1, VALUE);
704 }
705 end = System.currentTimeMillis();
706 System.out.println("test_srlv: " + (end - start));
707
708 start = System.currentTimeMillis();
709 for (int i=0; i<ITERS; i++) {
710 test_srac(a0, a1);
711 }
712 end = System.currentTimeMillis();
713 System.out.println("test_srac: " + (end - start));
714 start = System.currentTimeMillis();
715 for (int i=0; i<ITERS; i++) {
716 test_srav(a0, a1, VALUE);
717 }
718 end = System.currentTimeMillis();
719 System.out.println("test_srav: " + (end - start));
720
721 start = System.currentTimeMillis();
722 for (int i=0; i<ITERS; i++) {
723 test_sllc_n(a0, a1);
724 }
725 end = System.currentTimeMillis();
726 System.out.println("test_sllc_n: " + (end - start));
727 start = System.currentTimeMillis();
728 for (int i=0; i<ITERS; i++) {
729 test_sllv(a0, a1, -VALUE);
730 }
731 end = System.currentTimeMillis();
732 System.out.println("test_sllv_n: " + (end - start));
733
734 start = System.currentTimeMillis();
735 for (int i=0; i<ITERS; i++) {
736 test_srlc_n(a0, a1);
737 }
738 end = System.currentTimeMillis();
739 System.out.println("test_srlc_n: " + (end - start));
740 start = System.currentTimeMillis();
741 for (int i=0; i<ITERS; i++) {
742 test_srlv(a0, a1, -VALUE);
743 }
744 end = System.currentTimeMillis();
745 System.out.println("test_srlv_n: " + (end - start));
746
747 start = System.currentTimeMillis();
748 for (int i=0; i<ITERS; i++) {
749 test_srac_n(a0, a1);
750 }
751 end = System.currentTimeMillis();
752 System.out.println("test_srac_n: " + (end - start));
753 start = System.currentTimeMillis();
754 for (int i=0; i<ITERS; i++) {
755 test_srav(a0, a1, -VALUE);
756 }
757 end = System.currentTimeMillis();
758 System.out.println("test_srav_n: " + (end - start));
759
760 start = System.currentTimeMillis();
761 for (int i=0; i<ITERS; i++) {
762 test_sllc_o(a0, a1);
763 }
764 end = System.currentTimeMillis();
765 System.out.println("test_sllc_o: " + (end - start));
766 start = System.currentTimeMillis();
767 for (int i=0; i<ITERS; i++) {
768 test_sllv(a0, a1, SHIFT);
769 }
770 end = System.currentTimeMillis();
771 System.out.println("test_sllv_o: " + (end - start));
772
773 start = System.currentTimeMillis();
774 for (int i=0; i<ITERS; i++) {
775 test_srlc_o(a0, a1);
776 }
777 end = System.currentTimeMillis();
778 System.out.println("test_srlc_o: " + (end - start));
779 start = System.currentTimeMillis();
780 for (int i=0; i<ITERS; i++) {
781 test_srlv(a0, a1, SHIFT);
782 }
783 end = System.currentTimeMillis();
784 System.out.println("test_srlv_o: " + (end - start));
785
786 start = System.currentTimeMillis();
787 for (int i=0; i<ITERS; i++) {
788 test_srac_o(a0, a1);
789 }
790 end = System.currentTimeMillis();
791 System.out.println("test_srac_o: " + (end - start));
792 start = System.currentTimeMillis();
793 for (int i=0; i<ITERS; i++) {
794 test_srav(a0, a1, SHIFT);
795 }
796 end = System.currentTimeMillis();
797 System.out.println("test_srav_o: " + (end - start));
798
799 start = System.currentTimeMillis();
800 for (int i=0; i<ITERS; i++) {
801 test_sllc_on(a0, a1);
802 }
803 end = System.currentTimeMillis();
804 System.out.println("test_sllc_on: " + (end - start));
805 start = System.currentTimeMillis();
806 for (int i=0; i<ITERS; i++) {
807 test_sllv(a0, a1, -SHIFT);
808 }
809 end = System.currentTimeMillis();
810 System.out.println("test_sllv_on: " + (end - start));
811
812 start = System.currentTimeMillis();
813 for (int i=0; i<ITERS; i++) {
814 test_srlc_on(a0, a1);
815 }
816 end = System.currentTimeMillis();
817 System.out.println("test_srlc_on: " + (end - start));
818 start = System.currentTimeMillis();
819 for (int i=0; i<ITERS; i++) {
820 test_srlv(a0, a1, -SHIFT);
821 }
822 end = System.currentTimeMillis();
823 System.out.println("test_srlv_on: " + (end - start));
824
825 start = System.currentTimeMillis();
826 for (int i=0; i<ITERS; i++) {
827 test_srac_on(a0, a1);
828 }
829 end = System.currentTimeMillis();
830 System.out.println("test_srac_on: " + (end - start));
831 start = System.currentTimeMillis();
832 for (int i=0; i<ITERS; i++) {
833 test_srav(a0, a1, -SHIFT);
834 }
835 end = System.currentTimeMillis();
836 System.out.println("test_srav_on: " + (end - start));
837
838 start = System.currentTimeMillis();
839 for (int i=0; i<ITERS; i++) {
840 test_sllc_add(a0, a1);
841 }
842 end = System.currentTimeMillis();
843 System.out.println("test_sllc_add: " + (end - start));
844 start = System.currentTimeMillis();
845 for (int i=0; i<ITERS; i++) {
846 test_sllv_add(a0, a1, ADD_INIT);
847 }
848 end = System.currentTimeMillis();
849 System.out.println("test_sllv_add: " + (end - start));
850
851 start = System.currentTimeMillis();
852 for (int i=0; i<ITERS; i++) {
853 test_srlc_add(a0, a1);
854 }
855 end = System.currentTimeMillis();
856 System.out.println("test_srlc_add: " + (end - start));
857 start = System.currentTimeMillis();
858 for (int i=0; i<ITERS; i++) {
859 test_srlv_add(a0, a1, ADD_INIT);
860 }
861 end = System.currentTimeMillis();
862 System.out.println("test_srlv_add: " + (end - start));
863
864 start = System.currentTimeMillis();
865 for (int i=0; i<ITERS; i++) {
866 test_srac_add(a0, a1);
867 }
868 end = System.currentTimeMillis();
869 System.out.println("test_srac_add: " + (end - start));
870 start = System.currentTimeMillis();
871 for (int i=0; i<ITERS; i++) {
872 test_srav_add(a0, a1, ADD_INIT);
873 }
874 end = System.currentTimeMillis();
875 System.out.println("test_srav_add: " + (end - start));
876
877 start = System.currentTimeMillis();
878 for (int i=0; i<ITERS; i++) {
879 test_sllc_and(a0, a1);
880 }
881 end = System.currentTimeMillis();
882 System.out.println("test_sllc_and: " + (end - start));
883 start = System.currentTimeMillis();
884 for (int i=0; i<ITERS; i++) {
885 test_sllv_and(a0, a1, BIT_MASK);
886 }
887 end = System.currentTimeMillis();
888 System.out.println("test_sllv_and: " + (end - start));
889
890 start = System.currentTimeMillis();
891 for (int i=0; i<ITERS; i++) {
892 test_srlc_and(a0, a1);
893 }
894 end = System.currentTimeMillis();
895 System.out.println("test_srlc_and: " + (end - start));
896 start = System.currentTimeMillis();
897 for (int i=0; i<ITERS; i++) {
898 test_srlv_and(a0, a1, BIT_MASK);
899 }
900 end = System.currentTimeMillis();
901 System.out.println("test_srlv_and: " + (end - start));
902
903 start = System.currentTimeMillis();
904 for (int i=0; i<ITERS; i++) {
905 test_srac_and(a0, a1);
906 }
907 end = System.currentTimeMillis();
908 System.out.println("test_srac_and: " + (end - start));
909 start = System.currentTimeMillis();
910 for (int i=0; i<ITERS; i++) {
911 test_srav_and(a0, a1, BIT_MASK);
912 }
913 end = System.currentTimeMillis();
914 System.out.println("test_srav_and: " + (end - start));
915
916 start = System.currentTimeMillis();
917 for (int i=0; i<ITERS; i++) {
918 test_pack2(p2, a1);
919 }
920 end = System.currentTimeMillis();
921 System.out.println("test_pack2: " + (end - start));
922 start = System.currentTimeMillis();
923 for (int i=0; i<ITERS; i++) {
924 test_unpack2(a0, p2);
925 }
926 end = System.currentTimeMillis();
927 System.out.println("test_unpack2: " + (end - start));
928 start = System.currentTimeMillis();
929 for (int i=0; i<ITERS; i++) {
930 test_pack2_swap(p2, a1);
931 }
932 end = System.currentTimeMillis();
933 System.out.println("test_pack2_swap: " + (end - start));
934 start = System.currentTimeMillis();
935 for (int i=0; i<ITERS; i++) {
936 test_unpack2_swap(a0, p2);
937 }
938 end = System.currentTimeMillis();
939 System.out.println("test_unpack2_swap: " + (end - start));
940
941 start = System.currentTimeMillis();
942 for (int i=0; i<ITERS; i++) {
943 test_pack4(p4, a1);
944 }
945 end = System.currentTimeMillis();
946 System.out.println("test_pack4: " + (end - start));
947 start = System.currentTimeMillis();
948 for (int i=0; i<ITERS; i++) {
949 test_unpack4(a0, p4);
950 }
951 end = System.currentTimeMillis();
952 System.out.println("test_unpack4: " + (end - start));
953 start = System.currentTimeMillis();
954 for (int i=0; i<ITERS; i++) {
955 test_pack4_swap(p4, a1);
956 }
957 end = System.currentTimeMillis();
958 System.out.println("test_pack4_swap: " + (end - start));
959 start = System.currentTimeMillis();
960 for (int i=0; i<ITERS; i++) {
961 test_unpack4_swap(a0, p4);
962 }
963 end = System.currentTimeMillis();
964 System.out.println("test_unpack4_swap: " + (end - start));
965
966 return errn;
967 }
968
969 static int test_sum(char[] a1) {
970 int sum = 0;
971 for (int i = 0; i < a1.length; i+=1) {
972 sum += a1[i];
973 }
974 return sum;
975 }
976
977 static void test_addc(char[] a0, char[] a1) {
978 for (int i = 0; i < a0.length; i+=1) {
979 a0[i] = (char)(a1[i]+VALUE);
980 }
981 }
982 static void test_addv(char[] a0, char[] a1, char b) {
983 for (int i = 0; i < a0.length; i+=1) {
984 a0[i] = (char)(a1[i]+b);
985 }
986 }
987 static void test_adda(char[] a0, char[] a1, short[] a2) {
988 for (int i = 0; i < a0.length; i+=1) {
989 a0[i] = (char)(a1[i]+a2[i]);
990 }
991 }
992
993 static void test_subc(char[] a0, char[] a1) {
994 for (int i = 0; i < a0.length; i+=1) {
995 a0[i] = (char)(a1[i]-VALUE);
996 }
997 }
998 static void test_subv(char[] a0, char[] a1, char b) {
999 for (int i = 0; i < a0.length; i+=1) {
1000 a0[i] = (char)(a1[i]-b);
1001 }
1002 }
1003 static void test_suba(char[] a0, char[] a1, short[] a2) {
1004 for (int i = 0; i < a0.length; i+=1) {
1005 a0[i] = (char)(a1[i]-a2[i]);
1006 }
1007 }
1008
1009 static void test_mulc(char[] a0, char[] a1) {
1010 for (int i = 0; i < a0.length; i+=1) {
1011 a0[i] = (char)(a1[i]*VALUE);
1012 }
1013 }
1014 static void test_mulc_n(char[] a0, char[] a1) {
1015 for (int i = 0; i < a0.length; i+=1) {
1016 a0[i] = (char)(a1[i]*(-VALUE));
1017 }
1018 }
1019 static void test_mulv(char[] a0, char[] a1, char b) {
1020 for (int i = 0; i < a0.length; i+=1) {
1021 a0[i] = (char)(a1[i]*b);
1022 }
1023 }
1024 static void test_mula(char[] a0, char[] a1, short[] a2) {
1025 for (int i = 0; i < a0.length; i+=1) {
1026 a0[i] = (char)(a1[i]*a2[i]);
1027 }
1028 }
1029
1030 static void test_divc(char[] a0, char[] a1) {
1031 for (int i = 0; i < a0.length; i+=1) {
1032 a0[i] = (char)(a1[i]/VALUE);
1033 }
1034 }
1035 static void test_divc_n(char[] a0, char[] a1) {
1036 for (int i = 0; i < a0.length; i+=1) {
1037 a0[i] = (char)(a1[i]/(-VALUE));
1038 }
1039 }
1040 static void test_divv(char[] a0, char[] a1, int b) {
1041 for (int i = 0; i < a0.length; i+=1) {
1042 a0[i] = (char)(a1[i]/b);
1043 }
1044 }
1045 static void test_diva(char[] a0, char[] a1, short[] a2) {
1046 for (int i = 0; i < a0.length; i+=1) {
1047 a0[i] = (char)(a1[i]/a2[i]);
1048 }
1049 }
1050
1051 static void test_andc(char[] a0, char[] a1) {
1052 for (int i = 0; i < a0.length; i+=1) {
1053 a0[i] = (char)(a1[i]&BIT_MASK);
1054 }
1055 }
1056 static void test_andv(char[] a0, char[] a1, short b) {
1057 for (int i = 0; i < a0.length; i+=1) {
1058 a0[i] = (char)(a1[i]&b);
1059 }
1060 }
1061 static void test_anda(char[] a0, char[] a1, short[] a2) {
1062 for (int i = 0; i < a0.length; i+=1) {
1063 a0[i] = (char)(a1[i]&a2[i]);
1064 }
1065 }
1066
1067 static void test_orc(char[] a0, char[] a1) {
1068 for (int i = 0; i < a0.length; i+=1) {
1069 a0[i] = (char)(a1[i]|BIT_MASK);
1070 }
1071 }
1072 static void test_orv(char[] a0, char[] a1, short b) {
1073 for (int i = 0; i < a0.length; i+=1) {
1074 a0[i] = (char)(a1[i]|b);
1075 }
1076 }
1077 static void test_ora(char[] a0, char[] a1, short[] a2) {
1078 for (int i = 0; i < a0.length; i+=1) {
1079 a0[i] = (char)(a1[i]|a2[i]);
1080 }
1081 }
1082
1083 static void test_xorc(char[] a0, char[] a1) {
1084 for (int i = 0; i < a0.length; i+=1) {
1085 a0[i] = (char)(a1[i]^BIT_MASK);
1086 }
1087 }
1088 static void test_xorv(char[] a0, char[] a1, short b) {
1089 for (int i = 0; i < a0.length; i+=1) {
1090 a0[i] = (char)(a1[i]^b);
1091 }
1092 }
1093 static void test_xora(char[] a0, char[] a1, short[] a2) {
1094 for (int i = 0; i < a0.length; i+=1) {
1095 a0[i] = (char)(a1[i]^a2[i]);
1096 }
1097 }
1098
1099 static void test_sllc(char[] a0, char[] a1) {
1100 for (int i = 0; i < a0.length; i+=1) {
1101 a0[i] = (char)(a1[i]<<VALUE);
1102 }
1103 }
1104 static void test_sllc_n(char[] a0, char[] a1) {
1105 for (int i = 0; i < a0.length; i+=1) {
1106 a0[i] = (char)(a1[i]<<(-VALUE));
1107 }
1108 }
1109 static void test_sllc_o(char[] a0, char[] a1) {
1110 for (int i = 0; i < a0.length; i+=1) {
1111 a0[i] = (char)(a1[i]<<SHIFT);
1112 }
1113 }
1114 static void test_sllc_on(char[] a0, char[] a1) {
1115 for (int i = 0; i < a0.length; i+=1) {
1116 a0[i] = (char)(a1[i]<<(-SHIFT));
1117 }
1118 }
1119 static void test_sllv(char[] a0, char[] a1, int b) {
1120 for (int i = 0; i < a0.length; i+=1) {
1121 a0[i] = (char)(a1[i]<<b);
1122 }
1123 }
1124 static void test_sllc_add(char[] a0, char[] a1) {
1125 for (int i = 0; i < a0.length; i+=1) {
1126 a0[i] = (char)((a1[i] + ADD_INIT)<<VALUE);
1127 }
1128 }
1129 static void test_sllv_add(char[] a0, char[] a1, int b) {
1130 for (int i = 0; i < a0.length; i+=1) {
1131 a0[i] = (char)((a1[i] + b)<<VALUE);
1132 }
1133 }
1134 static void test_sllc_and(char[] a0, char[] a1) {
1135 for (int i = 0; i < a0.length; i+=1) {
1136 a0[i] = (char)((a1[i] & BIT_MASK)<<VALUE);
1137 }
1138 }
1139 static void test_sllv_and(char[] a0, char[] a1, int b) {
1140 for (int i = 0; i < a0.length; i+=1) {
1141 a0[i] = (char)((a1[i] & b)<<VALUE);
1142 }
1143 }
1144
1145 static void test_srlc(char[] a0, char[] a1) {
1146 for (int i = 0; i < a0.length; i+=1) {
1147 a0[i] = (char)(a1[i]>>>VALUE);
1148 }
1149 }
1150 static void test_srlc_n(char[] a0, char[] a1) {
1151 for (int i = 0; i < a0.length; i+=1) {
1152 a0[i] = (char)(a1[i]>>>(-VALUE));
1153 }
1154 }
1155 static void test_srlc_o(char[] a0, char[] a1) {
1156 for (int i = 0; i < a0.length; i+=1) {
1157 a0[i] = (char)(a1[i]>>>SHIFT);
1158 }
1159 }
1160 static void test_srlc_on(char[] a0, char[] a1) {
1161 for (int i = 0; i < a0.length; i+=1) {
1162 a0[i] = (char)(a1[i]>>>(-SHIFT));
1163 }
1164 }
1165 static void test_srlv(char[] a0, char[] a1, int b) {
1166 for (int i = 0; i < a0.length; i+=1) {
1167 a0[i] = (char)(a1[i]>>>b);
1168 }
1169 }
1170 static void test_srlc_add(char[] a0, char[] a1) {
1171 for (int i = 0; i < a0.length; i+=1) {
1172 a0[i] = (char)((a1[i] + ADD_INIT)>>>VALUE);
1173 }
1174 }
1175 static void test_srlv_add(char[] a0, char[] a1, int b) {
1176 for (int i = 0; i < a0.length; i+=1) {
1177 a0[i] = (char)((a1[i] + b)>>>VALUE);
1178 }
1179 }
1180 static void test_srlc_and(char[] a0, char[] a1) {
1181 for (int i = 0; i < a0.length; i+=1) {
1182 a0[i] = (char)((a1[i] & BIT_MASK)>>>VALUE);
1183 }
1184 }
1185 static void test_srlv_and(char[] a0, char[] a1, int b) {
1186 for (int i = 0; i < a0.length; i+=1) {
1187 a0[i] = (char)((a1[i] & b)>>>VALUE);
1188 }
1189 }
1190
1191 static void test_srac(char[] a0, char[] a1) {
1192 for (int i = 0; i < a0.length; i+=1) {
1193 a0[i] = (char)(a1[i]>>VALUE);
1194 }
1195 }
1196 static void test_srac_n(char[] a0, char[] a1) {
1197 for (int i = 0; i < a0.length; i+=1) {
1198 a0[i] = (char)(a1[i]>>(-VALUE));
1199 }
1200 }
1201 static void test_srac_o(char[] a0, char[] a1) {
1202 for (int i = 0; i < a0.length; i+=1) {
1203 a0[i] = (char)(a1[i]>>SHIFT);
1204 }
1205 }
1206 static void test_srac_on(char[] a0, char[] a1) {
1207 for (int i = 0; i < a0.length; i+=1) {
1208 a0[i] = (char)(a1[i]>>(-SHIFT));
1209 }
1210 }
1211 static void test_srav(char[] a0, char[] a1, int b) {
1212 for (int i = 0; i < a0.length; i+=1) {
1213 a0[i] = (char)(a1[i]>>b);
1214 }
1215 }
1216 static void test_srac_add(char[] a0, char[] a1) {
1217 for (int i = 0; i < a0.length; i+=1) {
1218 a0[i] = (char)((a1[i] + ADD_INIT)>>VALUE);
1219 }
1220 }
1221 static void test_srav_add(char[] a0, char[] a1, int b) {
1222 for (int i = 0; i < a0.length; i+=1) {
1223 a0[i] = (char)((a1[i] + b)>>VALUE);
1224 }
1225 }
1226 static void test_srac_and(char[] a0, char[] a1) {
1227 for (int i = 0; i < a0.length; i+=1) {
1228 a0[i] = (char)((a1[i] & BIT_MASK)>>VALUE);
1229 }
1230 }
1231 static void test_srav_and(char[] a0, char[] a1, int b) {
1232 for (int i = 0; i < a0.length; i+=1) {
1233 a0[i] = (char)((a1[i] & b)>>VALUE);
1234 }
1235 }
1236
1237 static void test_pack2(int[] p2, char[] a1) {
1238 if (p2.length*2 > a1.length) return;
1239 for (int i = 0; i < p2.length; i+=1) {
1240 int l0 = (int)a1[i*2+0];
1241 int l1 = (int)a1[i*2+1];
1242 p2[i] = (l1 << 16) | (l0 & 0xFFFF);
1243 }
1244 }
1245 static void test_unpack2(char[] a0, int[] p2) {
1246 if (p2.length*2 > a0.length) return;
1247 for (int i = 0; i < p2.length; i+=1) {
1248 int l = p2[i];
1249 a0[i*2+0] = (char)(l & 0xFFFF);
1250 a0[i*2+1] = (char)(l >> 16);
1251 }
1252 }
1253 static void test_pack2_swap(int[] p2, char[] a1) {
1254 if (p2.length*2 > a1.length) return;
1255 for (int i = 0; i < p2.length; i+=1) {
1256 int l0 = (int)a1[i*2+0];
1257 int l1 = (int)a1[i*2+1];
1258 p2[i] = (l0 << 16) | (l1 & 0xFFFF);
1259 }
1260 }
1261 static void test_unpack2_swap(char[] a0, int[] p2) {
1262 if (p2.length*2 > a0.length) return;
1263 for (int i = 0; i < p2.length; i+=1) {
1264 int l = p2[i];
1265 a0[i*2+0] = (char)(l >> 16);
1266 a0[i*2+1] = (char)(l & 0xFFFF);
1267 }
1268 }
1269
1270 static void test_pack4(long[] p4, char[] a1) {
1271 if (p4.length*4 > a1.length) return;
1272 for (int i = 0; i < p4.length; i+=1) {
1273 long l0 = (long)a1[i*4+0];
1274 long l1 = (long)a1[i*4+1];
1275 long l2 = (long)a1[i*4+2];
1276 long l3 = (long)a1[i*4+3];
1277 p4[i] = (l0 & 0xFFFFl) |
1278 ((l1 & 0xFFFFl) << 16) |
1279 ((l2 & 0xFFFFl) << 32) |
1280 ((l3 & 0xFFFFl) << 48);
1281 }
1282 }
1283 static void test_unpack4(char[] a0, long[] p4) {
1284 if (p4.length*4 > a0.length) return;
1285 for (int i = 0; i < p4.length; i+=1) {
1286 long l = p4[i];
1287 a0[i*4+0] = (char)(l & 0xFFFFl);
1288 a0[i*4+1] = (char)(l >> 16);
1289 a0[i*4+2] = (char)(l >> 32);
1290 a0[i*4+3] = (char)(l >> 48);
1291 }
1292 }
1293 static void test_pack4_swap(long[] p4, char[] a1) {
1294 if (p4.length*4 > a1.length) return;
1295 for (int i = 0; i < p4.length; i+=1) {
1296 long l0 = (long)a1[i*4+0];
1297 long l1 = (long)a1[i*4+1];
1298 long l2 = (long)a1[i*4+2];
1299 long l3 = (long)a1[i*4+3];
1300 p4[i] = (l3 & 0xFFFFl) |
1301 ((l2 & 0xFFFFl) << 16) |
1302 ((l1 & 0xFFFFl) << 32) |
1303 ((l0 & 0xFFFFl) << 48);
1304 }
1305 }
1306 static void test_unpack4_swap(char[] a0, long[] p4) {
1307 if (p4.length*4 > a0.length) return;
1308 for (int i = 0; i < p4.length; i+=1) {
1309 long l = p4[i];
1310 a0[i*4+0] = (char)(l >> 48);
1311 a0[i*4+1] = (char)(l >> 32);
1312 a0[i*4+2] = (char)(l >> 16);
1313 a0[i*4+3] = (char)(l & 0xFFFFl);
1314 }
1315 }
1316
1317 static int verify(String text, int i, int elem, int val) {
1318 if (elem != val) {
1319 System.err.println(text + "[" + i + "] = " + elem + " != " + val);
1320 return 1;
1321 }
1322 return 0;
1323 }
1324
1325 static int verify(String text, int i, long elem, long val) {
1326 if (elem != val) {
1327 System.err.println(text + "[" + i + "] = " + Long.toHexString(elem) + " != " + Long.toHexString(val));
1328 return 1;
1329 }
1330 return 0;
1331 }
1332 }