Mercurial > hg > truffle
comparison test/compiler/8001183/TestCharVect.java @ 6893:b2c669fd8114
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 } |