|
6803
|
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 }
|
