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