jdk8-mips64-public/hotspot: test/compiler/6340864/TestLongVect.java@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

     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  */

    25 /**

    26  * @test

    27  * @bug 6340864

    28  * @summary Implement vectorization optimizations in hotspot-server

    29  *

    30  * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestLongVect

    31  */

    33 public class TestLongVect {

    34   private static final int ARRLEN = 997;

    35   private static final int ITERS  = 11000;

    36   private static final long ADD_INIT = Long.MAX_VALUE-500;

    37   private static final long BIT_MASK = 0xEC80F731EC80F731L;

    38   private static final int VALUE = 31;

    39   private static final int SHIFT = 64;

    41   public static void main(String args[]) {

    42     System.out.println("Testing Long 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   }

    51   static int test() {

    52     long[] a0 = new long[ARRLEN];

    53     long[] a1 = new long[ARRLEN];

    54     long[] a2 = new long[ARRLEN];

    55     long[] a3 = new long[ARRLEN];

    56     long[] a4 = new long[ARRLEN];

    57     // Initialize

    58     long gold_sum = 0;

    59     for (int i=0; i<ARRLEN; i++) {

    60       long val = (long)(ADD_INIT+i);

    61       gold_sum += val;

    62       a1[i] = val;

    63       a2[i] = (long)VALUE;

    64       a3[i] = (long)-VALUE;

    65       a4[i] = (long)BIT_MASK;

    66     }

    67     System.out.println("Warmup");

    68     for (int i=0; i<ITERS; i++) {

    69       test_sum(a1);

    70       test_addc(a0, a1);

    71       test_addv(a0, a1, (long)VALUE);

    72       test_adda(a0, a1, a2);

    73       test_subc(a0, a1);

    74       test_subv(a0, a1, (long)VALUE);

    75       test_suba(a0, a1, a2);

    77       test_mulc(a0, a1);

    78       test_mulv(a0, a1, (long)VALUE);

    79       test_mula(a0, a1, a2);

    80       test_divc(a0, a1);

    81       test_divv(a0, a1, (long)VALUE);

    82       test_diva(a0, a1, a2);

    83       test_mulc_n(a0, a1);

    84       test_mulv(a0, a1, (long)-VALUE);

    85       test_mula(a0, a1, a3);

    86       test_divc_n(a0, a1);

    87       test_divv(a0, a1, (long)-VALUE);

    88       test_diva(a0, a1, a3);

    90       test_andc(a0, a1);

    91       test_andv(a0, a1, (long)BIT_MASK);

    92       test_anda(a0, a1, a4);

    93       test_orc(a0, a1);

    94       test_orv(a0, a1, (long)BIT_MASK);

    95       test_ora(a0, a1, a4);

    96       test_xorc(a0, a1);

    97       test_xorv(a0, a1, (long)BIT_MASK);

    98       test_xora(a0, a1, a4);

   100       test_sllc(a0, a1);

   101       test_sllv(a0, a1, VALUE);

   102       test_srlc(a0, a1);

   103       test_srlv(a0, a1, VALUE);

   104       test_srac(a0, a1);

   105       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);

   114       test_sllc_o(a0, a1);

   115       test_sllv(a0, a1, SHIFT);

   116       test_srlc_o(a0, a1);

   117       test_srlv(a0, a1, SHIFT);

   118       test_srac_o(a0, a1);

   119       test_srav(a0, a1, SHIFT);

   121       test_sllc_on(a0, a1);

   122       test_sllv(a0, a1, -SHIFT);

   123       test_srlc_on(a0, a1);

   124       test_srlv(a0, a1, -SHIFT);

   125       test_srac_on(a0, a1);

   126       test_srav(a0, a1, -SHIFT);

   128       test_sllc_add(a0, a1);

   129       test_sllv_add(a0, a1, ADD_INIT);

   130       test_srlc_add(a0, a1);

   131       test_srlv_add(a0, a1, ADD_INIT);

   132       test_srac_add(a0, a1);

   133       test_srav_add(a0, a1, ADD_INIT);

   135       test_sllc_and(a0, a1);

   136       test_sllv_and(a0, a1, BIT_MASK);

   137       test_srlc_and(a0, a1);

   138       test_srlv_and(a0, a1, BIT_MASK);

   139       test_srac_and(a0, a1);

   140       test_srav_and(a0, a1, BIT_MASK);

   141     }

   142     // Test and verify results

   143     System.out.println("Verification");

   144     int errn = 0;

   145     {

   146       long sum = test_sum(a1);

   147       if (sum != gold_sum) {

   148         System.err.println("test_sum:  " + sum + " != " + gold_sum);

   149         errn++;

   150       }

   152       test_addc(a0, a1);

   153       for (int i=0; i<ARRLEN; i++) {

   154         errn += verify("test_addc: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));

   155       }

   156       test_addv(a0, a1, (long)VALUE);

   157       for (int i=0; i<ARRLEN; i++) {

   158         errn += verify("test_addv: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));

   159       }

   160       test_adda(a0, a1, a2);

   161       for (int i=0; i<ARRLEN; i++) {

   162         errn += verify("test_adda: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));

   163       }

   165       test_subc(a0, a1);

   166       for (int i=0; i<ARRLEN; i++) {

   167         errn += verify("test_subc: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));

   168       }

   169       test_subv(a0, a1, (long)VALUE);

   170       for (int i=0; i<ARRLEN; i++) {

   171         errn += verify("test_subv: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));

   172       }

   173       test_suba(a0, a1, a2);

   174       for (int i=0; i<ARRLEN; i++) {

   175         errn += verify("test_suba: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));

   176       }

   178       test_mulc(a0, a1);

   179       for (int i=0; i<ARRLEN; i++) {

   180         errn += verify("test_mulc: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));

   181       }

   182       test_mulv(a0, a1, (long)VALUE);

   183       for (int i=0; i<ARRLEN; i++) {

   184         errn += verify("test_mulv: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));

   185       }

   186       test_mula(a0, a1, a2);

   187       for (int i=0; i<ARRLEN; i++) {

   188         errn += verify("test_mula: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));

   189       }

   191       test_divc(a0, a1);

   192       for (int i=0; i<ARRLEN; i++) {

   193         errn += verify("test_divc: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));

   194       }

   195       test_divv(a0, a1, (long)VALUE);

   196       for (int i=0; i<ARRLEN; i++) {

   197         errn += verify("test_divv: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));

   198       }

   199       test_diva(a0, a1, a2);

   200       for (int i=0; i<ARRLEN; i++) {

   201         errn += verify("test_diva: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));

   202       }

   204       test_mulc_n(a0, a1);

   205       for (int i=0; i<ARRLEN; i++) {

   206         errn += verify("test_mulc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));

   207       }

   208       test_mulv(a0, a1, (long)-VALUE);

   209       for (int i=0; i<ARRLEN; i++) {

   210         errn += verify("test_mulv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));

   211       }

   212       test_mula(a0, a1, a3);

   213       for (int i=0; i<ARRLEN; i++) {

   214         errn += verify("test_mula_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));

   215       }

   217       test_divc_n(a0, a1);

   218       for (int i=0; i<ARRLEN; i++) {

   219         errn += verify("test_divc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));

   220       }

   221       test_divv(a0, a1, (long)-VALUE);

   222       for (int i=0; i<ARRLEN; i++) {

   223         errn += verify("test_divv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));

   224       }

   225       test_diva(a0, a1, a3);

   226       for (int i=0; i<ARRLEN; i++) {

   227         errn += verify("test_diva_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));

   228       }

   230       test_andc(a0, a1);

   231       for (int i=0; i<ARRLEN; i++) {

   232         errn += verify("test_andc: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));

   233       }

   234       test_andv(a0, a1, (long)BIT_MASK);

   235       for (int i=0; i<ARRLEN; i++) {

   236         errn += verify("test_andv: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));

   237       }

   238       test_anda(a0, a1, a4);

   239       for (int i=0; i<ARRLEN; i++) {

   240         errn += verify("test_anda: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));

   241       }

   243       test_orc(a0, a1);

   244       for (int i=0; i<ARRLEN; i++) {

   245         errn += verify("test_orc: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));

   246       }

   247       test_orv(a0, a1, (long)BIT_MASK);

   248       for (int i=0; i<ARRLEN; i++) {

   249         errn += verify("test_orv: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));

   250       }

   251       test_ora(a0, a1, a4);

   252       for (int i=0; i<ARRLEN; i++) {

   253         errn += verify("test_ora: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));

   254       }

   256       test_xorc(a0, a1);

   257       for (int i=0; i<ARRLEN; i++) {

   258         errn += verify("test_xorc: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));

   259       }

   260       test_xorv(a0, a1, (long)BIT_MASK);

   261       for (int i=0; i<ARRLEN; i++) {

   262         errn += verify("test_xorv: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));

   263       }

   264       test_xora(a0, a1, a4);

   265       for (int i=0; i<ARRLEN; i++) {

   266         errn += verify("test_xora: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));

   267       }

   269       test_sllc(a0, a1);

   270       for (int i=0; i<ARRLEN; i++) {

   271         errn += verify("test_sllc: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));

   272       }

   273       test_sllv(a0, a1, VALUE);

   274       for (int i=0; i<ARRLEN; i++) {

   275         errn += verify("test_sllv: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));

   276       }

   278       test_srlc(a0, a1);

   279       for (int i=0; i<ARRLEN; i++) {

   280         errn += verify("test_srlc: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));

   281       }

   282       test_srlv(a0, a1, VALUE);

   283       for (int i=0; i<ARRLEN; i++) {

   284         errn += verify("test_srlv: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));

   285       }

   287       test_srac(a0, a1);

   288       for (int i=0; i<ARRLEN; i++) {

   289         errn += verify("test_srac: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));

   290       }

   291       test_srav(a0, a1, VALUE);

   292       for (int i=0; i<ARRLEN; i++) {

   293         errn += verify("test_srav: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));

   294       }

   296       test_sllc_n(a0, a1);

   297       for (int i=0; i<ARRLEN; i++) {

   298         errn += verify("test_sllc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));

   299       }

   300       test_sllv(a0, a1, -VALUE);

   301       for (int i=0; i<ARRLEN; i++) {

   302         errn += verify("test_sllv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));

   303       }

   305       test_srlc_n(a0, a1);

   306       for (int i=0; i<ARRLEN; i++) {

   307         errn += verify("test_srlc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));

   308       }

   309       test_srlv(a0, a1, -VALUE);

   310       for (int i=0; i<ARRLEN; i++) {

   311         errn += verify("test_srlv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));

   312       }

   314       test_srac_n(a0, a1);

   315       for (int i=0; i<ARRLEN; i++) {

   316         errn += verify("test_srac_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));

   317       }

   318       test_srav(a0, a1, -VALUE);

   319       for (int i=0; i<ARRLEN; i++) {

   320         errn += verify("test_srav_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));

   321       }

   323       test_sllc_o(a0, a1);

   324       for (int i=0; i<ARRLEN; i++) {

   325         errn += verify("test_sllc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));

   326       }

   327       test_sllv(a0, a1, SHIFT);

   328       for (int i=0; i<ARRLEN; i++) {

   329         errn += verify("test_sllv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));

   330       }

   332       test_srlc_o(a0, a1);

   333       for (int i=0; i<ARRLEN; i++) {

   334         errn += verify("test_srlc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));

   335       }

   336       test_srlv(a0, a1, SHIFT);

   337       for (int i=0; i<ARRLEN; i++) {

   338         errn += verify("test_srlv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));

   339       }

   341       test_srac_o(a0, a1);

   342       for (int i=0; i<ARRLEN; i++) {

   343         errn += verify("test_srac_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));

   344       }

   345       test_srav(a0, a1, SHIFT);

   346       for (int i=0; i<ARRLEN; i++) {

   347         errn += verify("test_srav_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));

   348       }

   350       test_sllc_on(a0, a1);

   351       for (int i=0; i<ARRLEN; i++) {

   352         errn += verify("test_sllc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));

   353       }

   354       test_sllv(a0, a1, -SHIFT);

   355       for (int i=0; i<ARRLEN; i++) {

   356         errn += verify("test_sllv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));

   357       }

   359       test_srlc_on(a0, a1);

   360       for (int i=0; i<ARRLEN; i++) {

   361         errn += verify("test_srlc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));

   362       }

   363       test_srlv(a0, a1, -SHIFT);

   364       for (int i=0; i<ARRLEN; i++) {

   365         errn += verify("test_srlv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));

   366       }

   368       test_srac_on(a0, a1);

   369       for (int i=0; i<ARRLEN; i++) {

   370         errn += verify("test_srac_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));

   371       }

   372       test_srav(a0, a1, -SHIFT);

   373       for (int i=0; i<ARRLEN; i++) {

   374         errn += verify("test_srav_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));

   375       }

   377       test_sllc_add(a0, a1);

   378       for (int i=0; i<ARRLEN; i++) {

   379         errn += verify("test_sllc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));

   380       }

   381       test_sllv_add(a0, a1, ADD_INIT);

   382       for (int i=0; i<ARRLEN; i++) {

   383         errn += verify("test_sllv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));

   384       }

   386       test_srlc_add(a0, a1);

   387       for (int i=0; i<ARRLEN; i++) {

   388         errn += verify("test_srlc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));

   389       }

   390       test_srlv_add(a0, a1, ADD_INIT);

   391       for (int i=0; i<ARRLEN; i++) {

   392         errn += verify("test_srlv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));

   393       }

   395       test_srac_add(a0, a1);

   396       for (int i=0; i<ARRLEN; i++) {

   397         errn += verify("test_srac_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));

   398       }

   399       test_srav_add(a0, a1, ADD_INIT);

   400       for (int i=0; i<ARRLEN; i++) {

   401         errn += verify("test_srav_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));

   402       }

   404       test_sllc_and(a0, a1);

   405       for (int i=0; i<ARRLEN; i++) {

   406         errn += verify("test_sllc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));

   407       }

   408       test_sllv_and(a0, a1, BIT_MASK);

   409       for (int i=0; i<ARRLEN; i++) {

   410         errn += verify("test_sllv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));

   411       }

   413       test_srlc_and(a0, a1);

   414       for (int i=0; i<ARRLEN; i++) {

   415         errn += verify("test_srlc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));

   416       }

   417       test_srlv_and(a0, a1, BIT_MASK);

   418       for (int i=0; i<ARRLEN; i++) {

   419         errn += verify("test_srlv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));

   420       }

   422       test_srac_and(a0, a1);

   423       for (int i=0; i<ARRLEN; i++) {

   424         errn += verify("test_srac_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));

   425       }

   426       test_srav_and(a0, a1, BIT_MASK);

   427       for (int i=0; i<ARRLEN; i++) {

   428         errn += verify("test_srav_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));

   429       }

   431     }

   433     if (errn > 0)

   434       return errn;

   436     System.out.println("Time");

   437     long start, end;

   439     start = System.currentTimeMillis();

   440     for (int i=0; i<ITERS; i++) {

   441       test_sum(a1);

   442     }

   443     end = System.currentTimeMillis();

   444     System.out.println("test_sum: " + (end - start));

   446     start = System.currentTimeMillis();

   447     for (int i=0; i<ITERS; i++) {

   448       test_addc(a0, a1);

   449     }

   450     end = System.currentTimeMillis();

   451     System.out.println("test_addc: " + (end - start));

   452     start = System.currentTimeMillis();

   453     for (int i=0; i<ITERS; i++) {

   454       test_addv(a0, a1, (long)VALUE);

   455     }

   456     end = System.currentTimeMillis();

   457     System.out.println("test_addv: " + (end - start));

   458     start = System.currentTimeMillis();

   459     for (int i=0; i<ITERS; i++) {

   460       test_adda(a0, a1, a2);

   461     }

   462     end = System.currentTimeMillis();

   463     System.out.println("test_adda: " + (end - start));

   465     start = System.currentTimeMillis();

   466     for (int i=0; i<ITERS; i++) {

   467       test_subc(a0, a1);

   468     }

   469     end = System.currentTimeMillis();

   470     System.out.println("test_subc: " + (end - start));

   471     start = System.currentTimeMillis();

   472     for (int i=0; i<ITERS; i++) {

   473       test_subv(a0, a1, (long)VALUE);

   474     }

   475     end = System.currentTimeMillis();

   476     System.out.println("test_subv: " + (end - start));

   477     start = System.currentTimeMillis();

   478     for (int i=0; i<ITERS; i++) {

   479       test_suba(a0, a1, a2);

   480     }

   481     end = System.currentTimeMillis();

   482     System.out.println("test_suba: " + (end - start));

   484     start = System.currentTimeMillis();

   485     for (int i=0; i<ITERS; i++) {

   486       test_mulc(a0, a1);

   487     }

   488     end = System.currentTimeMillis();

   489     System.out.println("test_mulc: " + (end - start));

   490     start = System.currentTimeMillis();

   491     for (int i=0; i<ITERS; i++) {

   492       test_mulv(a0, a1, (long)VALUE);

   493     }

   494     end = System.currentTimeMillis();

   495     System.out.println("test_mulv: " + (end - start));

   496     start = System.currentTimeMillis();

   497     for (int i=0; i<ITERS; i++) {

   498       test_mula(a0, a1, a2);

   499     }

   500     end = System.currentTimeMillis();

   501     System.out.println("test_mula: " + (end - start));

   503     start = System.currentTimeMillis();

   504     for (int i=0; i<ITERS; i++) {

   505       test_divc(a0, a1);

   506     }

   507     end = System.currentTimeMillis();

   508     System.out.println("test_divc: " + (end - start));

   509     start = System.currentTimeMillis();

   510     for (int i=0; i<ITERS; i++) {

   511       test_divv(a0, a1, (long)VALUE);

   512     }

   513     end = System.currentTimeMillis();

   514     System.out.println("test_divv: " + (end - start));

   515     start = System.currentTimeMillis();

   516     for (int i=0; i<ITERS; i++) {

   517       test_diva(a0, a1, a2);

   518     }

   519     end = System.currentTimeMillis();

   520     System.out.println("test_diva: " + (end - start));

   522     start = System.currentTimeMillis();

   523     for (int i=0; i<ITERS; i++) {

   524       test_mulc_n(a0, a1);

   525     }

   526     end = System.currentTimeMillis();

   527     System.out.println("test_mulc_n: " + (end - start));

   528     start = System.currentTimeMillis();

   529     for (int i=0; i<ITERS; i++) {

   530       test_mulv(a0, a1, (long)-VALUE);

   531     }

   532     end = System.currentTimeMillis();

   533     System.out.println("test_mulv_n: " + (end - start));

   534     start = System.currentTimeMillis();

   535     for (int i=0; i<ITERS; i++) {

   536       test_mula(a0, a1, a3);

   537     }

   538     end = System.currentTimeMillis();

   539     System.out.println("test_mula_n: " + (end - start));

   541     start = System.currentTimeMillis();

   542     for (int i=0; i<ITERS; i++) {

   543       test_divc_n(a0, a1);

   544     }

   545     end = System.currentTimeMillis();

   546     System.out.println("test_divc_n: " + (end - start));

   547     start = System.currentTimeMillis();

   548     for (int i=0; i<ITERS; i++) {

   549       test_divv(a0, a1, (long)-VALUE);

   550     }

   551     end = System.currentTimeMillis();

   552     System.out.println("test_divv_n: " + (end - start));

   553     start = System.currentTimeMillis();

   554     for (int i=0; i<ITERS; i++) {

   555       test_diva(a0, a1, a3);

   556     }

   557     end = System.currentTimeMillis();

   558     System.out.println("test_diva_n: " + (end - start));

   560     start = System.currentTimeMillis();

   561     for (int i=0; i<ITERS; i++) {

   562       test_andc(a0, a1);

   563     }

   564     end = System.currentTimeMillis();

   565     System.out.println("test_andc: " + (end - start));

   566     start = System.currentTimeMillis();

   567     for (int i=0; i<ITERS; i++) {

   568       test_andv(a0, a1, (long)BIT_MASK);

   569     }

   570     end = System.currentTimeMillis();

   571     System.out.println("test_andv: " + (end - start));

   572     start = System.currentTimeMillis();

   573     for (int i=0; i<ITERS; i++) {

   574       test_anda(a0, a1, a4);

   575     }

   576     end = System.currentTimeMillis();

   577     System.out.println("test_anda: " + (end - start));

   579     start = System.currentTimeMillis();

   580     for (int i=0; i<ITERS; i++) {

   581       test_orc(a0, a1);

   582     }

   583     end = System.currentTimeMillis();

   584     System.out.println("test_orc: " + (end - start));

   585     start = System.currentTimeMillis();

   586     for (int i=0; i<ITERS; i++) {

   587       test_orv(a0, a1, (long)BIT_MASK);

   588     }

   589     end = System.currentTimeMillis();

   590     System.out.println("test_orv: " + (end - start));

   591     start = System.currentTimeMillis();

   592     for (int i=0; i<ITERS; i++) {

   593       test_ora(a0, a1, a4);

   594     }

   595     end = System.currentTimeMillis();

   596     System.out.println("test_ora: " + (end - start));

   598     start = System.currentTimeMillis();

   599     for (int i=0; i<ITERS; i++) {

   600       test_xorc(a0, a1);

   601     }

   602     end = System.currentTimeMillis();

   603     System.out.println("test_xorc: " + (end - start));

   604     start = System.currentTimeMillis();

   605     for (int i=0; i<ITERS; i++) {

   606       test_xorv(a0, a1, (long)BIT_MASK);

   607     }

   608     end = System.currentTimeMillis();

   609     System.out.println("test_xorv: " + (end - start));

   610     start = System.currentTimeMillis();

   611     for (int i=0; i<ITERS; i++) {

   612       test_xora(a0, a1, a4);

   613     }

   614     end = System.currentTimeMillis();

   615     System.out.println("test_xora: " + (end - start));

   617     start = System.currentTimeMillis();

   618     for (int i=0; i<ITERS; i++) {

   619       test_sllc(a0, a1);

   620     }

   621     end = System.currentTimeMillis();

   622     System.out.println("test_sllc: " + (end - start));

   623     start = System.currentTimeMillis();

   624     for (int i=0; i<ITERS; i++) {

   625       test_sllv(a0, a1, VALUE);

   626     }

   627     end = System.currentTimeMillis();

   628     System.out.println("test_sllv: " + (end - start));

   630     start = System.currentTimeMillis();

   631     for (int i=0; i<ITERS; i++) {

   632       test_srlc(a0, a1);

   633     }

   634     end = System.currentTimeMillis();

   635     System.out.println("test_srlc: " + (end - start));

   636     start = System.currentTimeMillis();

   637     for (int i=0; i<ITERS; i++) {

   638       test_srlv(a0, a1, VALUE);

   639     }

   640     end = System.currentTimeMillis();

   641     System.out.println("test_srlv: " + (end - start));

   643     start = System.currentTimeMillis();

   644     for (int i=0; i<ITERS; i++) {

   645       test_srac(a0, a1);

   646     }

   647     end = System.currentTimeMillis();

   648     System.out.println("test_srac: " + (end - start));

   649     start = System.currentTimeMillis();

   650     for (int i=0; i<ITERS; i++) {

   651       test_srav(a0, a1, VALUE);

   652     }

   653     end = System.currentTimeMillis();

   654     System.out.println("test_srav: " + (end - start));

   656     start = System.currentTimeMillis();

   657     for (int i=0; i<ITERS; i++) {

   658       test_sllc_n(a0, a1);

   659     }

   660     end = System.currentTimeMillis();

   661     System.out.println("test_sllc_n: " + (end - start));

   662     start = System.currentTimeMillis();

   663     for (int i=0; i<ITERS; i++) {

   664       test_sllv(a0, a1, -VALUE);

   665     }

   666     end = System.currentTimeMillis();

   667     System.out.println("test_sllv_n: " + (end - start));

   669     start = System.currentTimeMillis();

   670     for (int i=0; i<ITERS; i++) {

   671       test_srlc_n(a0, a1);

   672     }

   673     end = System.currentTimeMillis();

   674     System.out.println("test_srlc_n: " + (end - start));

   675     start = System.currentTimeMillis();

   676     for (int i=0; i<ITERS; i++) {

   677       test_srlv(a0, a1, -VALUE);

   678     }

   679     end = System.currentTimeMillis();

   680     System.out.println("test_srlv_n: " + (end - start));

   682     start = System.currentTimeMillis();

   683     for (int i=0; i<ITERS; i++) {

   684       test_srac_n(a0, a1);

   685     }

   686     end = System.currentTimeMillis();

   687     System.out.println("test_srac_n: " + (end - start));

   688     start = System.currentTimeMillis();

   689     for (int i=0; i<ITERS; i++) {

   690       test_srav(a0, a1, -VALUE);

   691     }

   692     end = System.currentTimeMillis();

   693     System.out.println("test_srav_n: " + (end - start));

   695     start = System.currentTimeMillis();

   696     for (int i=0; i<ITERS; i++) {

   697       test_sllc_o(a0, a1);

   698     }

   699     end = System.currentTimeMillis();

   700     System.out.println("test_sllc_o: " + (end - start));

   701     start = System.currentTimeMillis();

   702     for (int i=0; i<ITERS; i++) {

   703       test_sllv(a0, a1, SHIFT);

   704     }

   705     end = System.currentTimeMillis();

   706     System.out.println("test_sllv_o: " + (end - start));

   708     start = System.currentTimeMillis();

   709     for (int i=0; i<ITERS; i++) {

   710       test_srlc_o(a0, a1);

   711     }

   712     end = System.currentTimeMillis();

   713     System.out.println("test_srlc_o: " + (end - start));

   714     start = System.currentTimeMillis();

   715     for (int i=0; i<ITERS; i++) {

   716       test_srlv(a0, a1, SHIFT);

   717     }

   718     end = System.currentTimeMillis();

   719     System.out.println("test_srlv_o: " + (end - start));

   721     start = System.currentTimeMillis();

   722     for (int i=0; i<ITERS; i++) {

   723       test_srac_o(a0, a1);

   724     }

   725     end = System.currentTimeMillis();

   726     System.out.println("test_srac_o: " + (end - start));

   727     start = System.currentTimeMillis();

   728     for (int i=0; i<ITERS; i++) {

   729       test_srav(a0, a1, SHIFT);

   730     }

   731     end = System.currentTimeMillis();

   732     System.out.println("test_srav_o: " + (end - start));

   734     start = System.currentTimeMillis();

   735     for (int i=0; i<ITERS; i++) {

   736       test_sllc_on(a0, a1);

   737     }

   738     end = System.currentTimeMillis();

   739     System.out.println("test_sllc_on: " + (end - start));

   740     start = System.currentTimeMillis();

   741     for (int i=0; i<ITERS; i++) {

   742       test_sllv(a0, a1, -SHIFT);

   743     }

   744     end = System.currentTimeMillis();

   745     System.out.println("test_sllv_on: " + (end - start));

   747     start = System.currentTimeMillis();

   748     for (int i=0; i<ITERS; i++) {

   749       test_srlc_on(a0, a1);

   750     }

   751     end = System.currentTimeMillis();

   752     System.out.println("test_srlc_on: " + (end - start));

   753     start = System.currentTimeMillis();

   754     for (int i=0; i<ITERS; i++) {

   755       test_srlv(a0, a1, -SHIFT);

   756     }

   757     end = System.currentTimeMillis();

   758     System.out.println("test_srlv_on: " + (end - start));

   760     start = System.currentTimeMillis();

   761     for (int i=0; i<ITERS; i++) {

   762       test_srac_on(a0, a1);

   763     }

   764     end = System.currentTimeMillis();

   765     System.out.println("test_srac_on: " + (end - start));

   766     start = System.currentTimeMillis();

   767     for (int i=0; i<ITERS; i++) {

   768       test_srav(a0, a1, -SHIFT);

   769     }

   770     end = System.currentTimeMillis();

   771     System.out.println("test_srav_on: " + (end - start));

   773     start = System.currentTimeMillis();

   774     for (int i=0; i<ITERS; i++) {

   775       test_sllc_add(a0, a1);

   776     }

   777     end = System.currentTimeMillis();

   778     System.out.println("test_sllc_add: " + (end - start));

   779     start = System.currentTimeMillis();

   780     for (int i=0; i<ITERS; i++) {

   781       test_sllv_add(a0, a1, ADD_INIT);

   782     }

   783     end = System.currentTimeMillis();

   784     System.out.println("test_sllv_add: " + (end - start));

   786     start = System.currentTimeMillis();

   787     for (int i=0; i<ITERS; i++) {

   788       test_srlc_add(a0, a1);

   789     }

   790     end = System.currentTimeMillis();

   791     System.out.println("test_srlc_add: " + (end - start));

   792     start = System.currentTimeMillis();

   793     for (int i=0; i<ITERS; i++) {

   794       test_srlv_add(a0, a1, ADD_INIT);

   795     }

   796     end = System.currentTimeMillis();

   797     System.out.println("test_srlv_add: " + (end - start));

   799     start = System.currentTimeMillis();

   800     for (int i=0; i<ITERS; i++) {

   801       test_srac_add(a0, a1);

   802     }

   803     end = System.currentTimeMillis();

   804     System.out.println("test_srac_add: " + (end - start));

   805     start = System.currentTimeMillis();

   806     for (int i=0; i<ITERS; i++) {

   807       test_srav_add(a0, a1, ADD_INIT);

   808     }

   809     end = System.currentTimeMillis();

   810     System.out.println("test_srav_add: " + (end - start));

   812     start = System.currentTimeMillis();

   813     for (int i=0; i<ITERS; i++) {

   814       test_sllc_and(a0, a1);

   815     }

   816     end = System.currentTimeMillis();

   817     System.out.println("test_sllc_and: " + (end - start));

   818     start = System.currentTimeMillis();

   819     for (int i=0; i<ITERS; i++) {

   820       test_sllv_and(a0, a1, BIT_MASK);

   821     }

   822     end = System.currentTimeMillis();

   823     System.out.println("test_sllv_and: " + (end - start));

   825     start = System.currentTimeMillis();

   826     for (int i=0; i<ITERS; i++) {

   827       test_srlc_and(a0, a1);

   828     }

   829     end = System.currentTimeMillis();

   830     System.out.println("test_srlc_and: " + (end - start));

   831     start = System.currentTimeMillis();

   832     for (int i=0; i<ITERS; i++) {

   833       test_srlv_and(a0, a1, BIT_MASK);

   834     }

   835     end = System.currentTimeMillis();

   836     System.out.println("test_srlv_and: " + (end - start));

   838     start = System.currentTimeMillis();

   839     for (int i=0; i<ITERS; i++) {

   840       test_srac_and(a0, a1);

   841     }

   842     end = System.currentTimeMillis();

   843     System.out.println("test_srac_and: " + (end - start));

   844     start = System.currentTimeMillis();

   845     for (int i=0; i<ITERS; i++) {

   846       test_srav_and(a0, a1, BIT_MASK);

   847     }

   848     end = System.currentTimeMillis();

   849     System.out.println("test_srav_and: " + (end - start));

   851     return errn;

   852   }

   854   static long test_sum(long[] a1) {

   855     long sum = 0;

   856     for (int i = 0; i < a1.length; i+=1) {

   857       sum += a1[i];

   858     }

   859     return sum;

   860   }

   862   static void test_addc(long[] a0, long[] a1) {

   863     for (int i = 0; i < a0.length; i+=1) {

   864       a0[i] = (long)(a1[i]+VALUE);

   865     }

   866   }

   867   static void test_addv(long[] a0, long[] a1, long b) {

   868     for (int i = 0; i < a0.length; i+=1) {

   869       a0[i] = (long)(a1[i]+b);

   870     }

   871   }

   872   static void test_adda(long[] a0, long[] a1, long[] a2) {

   873     for (int i = 0; i < a0.length; i+=1) {

   874       a0[i] = (long)(a1[i]+a2[i]);

   875     }

   876   }

   878   static void test_subc(long[] a0, long[] a1) {

   879     for (int i = 0; i < a0.length; i+=1) {

   880       a0[i] = (long)(a1[i]-VALUE);

   881     }

   882   }

   883   static void test_subv(long[] a0, long[] a1, long b) {

   884     for (int i = 0; i < a0.length; i+=1) {

   885       a0[i] = (long)(a1[i]-b);

   886     }

   887   }

   888   static void test_suba(long[] a0, long[] a1, long[] a2) {

   889     for (int i = 0; i < a0.length; i+=1) {

   890       a0[i] = (long)(a1[i]-a2[i]);

   891     }

   892   }

   894   static void test_mulc(long[] a0, long[] a1) {

   895     for (int i = 0; i < a0.length; i+=1) {

   896       a0[i] = (long)(a1[i]*VALUE);

   897     }

   898   }

   899   static void test_mulc_n(long[] a0, long[] a1) {

   900     for (int i = 0; i < a0.length; i+=1) {

   901       a0[i] = (long)(a1[i]*(-VALUE));

   902     }

   903   }

   904   static void test_mulv(long[] a0, long[] a1, long b) {

   905     for (int i = 0; i < a0.length; i+=1) {

   906       a0[i] = (long)(a1[i]*b);

   907     }

   908   }

   909   static void test_mula(long[] a0, long[] a1, long[] a2) {

   910     for (int i = 0; i < a0.length; i+=1) {

   911       a0[i] = (long)(a1[i]*a2[i]);

   912     }

   913   }

   915   static void test_divc(long[] a0, long[] a1) {

   916     for (int i = 0; i < a0.length; i+=1) {

   917       a0[i] = (long)(a1[i]/VALUE);

   918     }

   919   }

   920   static void test_divc_n(long[] a0, long[] a1) {

   921     for (int i = 0; i < a0.length; i+=1) {

   922       a0[i] = (long)(a1[i]/(-VALUE));

   923     }

   924   }

   925   static void test_divv(long[] a0, long[] a1, long b) {

   926     for (int i = 0; i < a0.length; i+=1) {

   927       a0[i] = (long)(a1[i]/b);

   928     }

   929   }

   930   static void test_diva(long[] a0, long[] a1, long[] a2) {

   931     for (int i = 0; i < a0.length; i+=1) {

   932       a0[i] = (long)(a1[i]/a2[i]);

   933     }

   934   }

   936   static void test_andc(long[] a0, long[] a1) {

   937     for (int i = 0; i < a0.length; i+=1) {

   938       a0[i] = (long)(a1[i]&BIT_MASK);

   939     }

   940   }

   941   static void test_andv(long[] a0, long[] a1, long b) {

   942     for (int i = 0; i < a0.length; i+=1) {

   943       a0[i] = (long)(a1[i]&b);

   944     }

   945   }

   946   static void test_anda(long[] a0, long[] a1, long[] a2) {

   947     for (int i = 0; i < a0.length; i+=1) {

   948       a0[i] = (long)(a1[i]&a2[i]);

   949     }

   950   }

   952   static void test_orc(long[] a0, long[] a1) {

   953     for (int i = 0; i < a0.length; i+=1) {

   954       a0[i] = (long)(a1[i]|BIT_MASK);

   955     }

   956   }

   957   static void test_orv(long[] a0, long[] a1, long b) {

   958     for (int i = 0; i < a0.length; i+=1) {

   959       a0[i] = (long)(a1[i]|b);

   960     }

   961   }

   962   static void test_ora(long[] a0, long[] a1, long[] a2) {

   963     for (int i = 0; i < a0.length; i+=1) {

   964       a0[i] = (long)(a1[i]|a2[i]);

   965     }

   966   }

   968   static void test_xorc(long[] a0, long[] a1) {

   969     for (int i = 0; i < a0.length; i+=1) {

   970       a0[i] = (long)(a1[i]^BIT_MASK);

   971     }

   972   }

   973   static void test_xorv(long[] a0, long[] a1, long b) {

   974     for (int i = 0; i < a0.length; i+=1) {

   975       a0[i] = (long)(a1[i]^b);

   976     }

   977   }

   978   static void test_xora(long[] a0, long[] a1, long[] a2) {

   979     for (int i = 0; i < a0.length; i+=1) {

   980       a0[i] = (long)(a1[i]^a2[i]);

   981     }

   982   }

   984   static void test_sllc(long[] a0, long[] a1) {

   985     for (int i = 0; i < a0.length; i+=1) {

   986       a0[i] = (long)(a1[i]<<VALUE);

   987     }

   988   }

   989   static void test_sllc_n(long[] a0, long[] a1) {

   990     for (int i = 0; i < a0.length; i+=1) {

   991       a0[i] = (long)(a1[i]<<(-VALUE));

   992     }

   993   }

   994   static void test_sllc_o(long[] a0, long[] a1) {

   995     for (int i = 0; i < a0.length; i+=1) {

   996       a0[i] = (long)(a1[i]<<SHIFT);

   997     }

   998   }

   999   static void test_sllc_on(long[] a0, long[] a1) {

  1000     for (int i = 0; i < a0.length; i+=1) {

  1001       a0[i] = (long)(a1[i]<<(-SHIFT));

  1002     }

  1003   }

  1004   static void test_sllv(long[] a0, long[] a1, int b) {

  1005     for (int i = 0; i < a0.length; i+=1) {

  1006       a0[i] = (long)(a1[i]<<b);

  1007     }

  1008   }

  1009   static void test_sllc_add(long[] a0, long[] a1) {

  1010     for (int i = 0; i < a0.length; i+=1) {

  1011       a0[i] = (long)((a1[i] + ADD_INIT)<<VALUE);

  1012     }

  1013   }

  1014   static void test_sllv_add(long[] a0, long[] a1, long b) {

  1015     for (int i = 0; i < a0.length; i+=1) {

  1016       a0[i] = (long)((a1[i] + b)<<VALUE);

  1017     }

  1018   }

  1019   static void test_sllc_and(long[] a0, long[] a1) {

  1020     for (int i = 0; i < a0.length; i+=1) {

  1021       a0[i] = (long)((a1[i] & BIT_MASK)<<VALUE);

  1022     }

  1023   }

  1024   static void test_sllv_and(long[] a0, long[] a1, long b) {

  1025     for (int i = 0; i < a0.length; i+=1) {

  1026       a0[i] = (long)((a1[i] & b)<<VALUE);

  1027     }

  1028   }

  1030   static void test_srlc(long[] a0, long[] a1) {

  1031     for (int i = 0; i < a0.length; i+=1) {

  1032       a0[i] = (long)(a1[i]>>>VALUE);

  1033     }

  1034   }

  1035   static void test_srlc_n(long[] a0, long[] a1) {

  1036     for (int i = 0; i < a0.length; i+=1) {

  1037       a0[i] = (long)(a1[i]>>>(-VALUE));

  1038     }

  1039   }

  1040   static void test_srlc_o(long[] a0, long[] a1) {

  1041     for (int i = 0; i < a0.length; i+=1) {

  1042       a0[i] = (long)(a1[i]>>>SHIFT);

  1043     }

  1044   }

  1045   static void test_srlc_on(long[] a0, long[] a1) {

  1046     for (int i = 0; i < a0.length; i+=1) {

  1047       a0[i] = (long)(a1[i]>>>(-SHIFT));

  1048     }

  1049   }

  1050   static void test_srlv(long[] a0, long[] a1, int b) {

  1051     for (int i = 0; i < a0.length; i+=1) {

  1052       a0[i] = (long)(a1[i]>>>b);

  1053     }

  1054   }

  1055   static void test_srlc_add(long[] a0, long[] a1) {

  1056     for (int i = 0; i < a0.length; i+=1) {

  1057       a0[i] = (long)((a1[i] + ADD_INIT)>>>VALUE);

  1058     }

  1059   }

  1060   static void test_srlv_add(long[] a0, long[] a1, long b) {

  1061     for (int i = 0; i < a0.length; i+=1) {

  1062       a0[i] = (long)((a1[i] + b)>>>VALUE);

  1063     }

  1064   }

  1065   static void test_srlc_and(long[] a0, long[] a1) {

  1066     for (int i = 0; i < a0.length; i+=1) {

  1067       a0[i] = (long)((a1[i] & BIT_MASK)>>>VALUE);

  1068     }

  1069   }

  1070   static void test_srlv_and(long[] a0, long[] a1, long b) {

  1071     for (int i = 0; i < a0.length; i+=1) {

  1072       a0[i] = (long)((a1[i] & b)>>>VALUE);

  1073     }

  1074   }

  1076   static void test_srac(long[] a0, long[] a1) {

  1077     for (int i = 0; i < a0.length; i+=1) {

  1078       a0[i] = (long)(a1[i]>>VALUE);

  1079     }

  1080   }

  1081   static void test_srac_n(long[] a0, long[] a1) {

  1082     for (int i = 0; i < a0.length; i+=1) {

  1083       a0[i] = (long)(a1[i]>>(-VALUE));

  1084     }

  1085   }

  1086   static void test_srac_o(long[] a0, long[] a1) {

  1087     for (int i = 0; i < a0.length; i+=1) {

  1088       a0[i] = (long)(a1[i]>>SHIFT);

  1089     }

  1090   }

  1091   static void test_srac_on(long[] a0, long[] a1) {

  1092     for (int i = 0; i < a0.length; i+=1) {

  1093       a0[i] = (long)(a1[i]>>(-SHIFT));

  1094     }

  1095   }

  1096   static void test_srav(long[] a0, long[] a1, int b) {

  1097     for (int i = 0; i < a0.length; i+=1) {

  1098       a0[i] = (long)(a1[i]>>b);

  1099     }

  1100   }

  1101   static void test_srac_add(long[] a0, long[] a1) {

  1102     for (int i = 0; i < a0.length; i+=1) {

  1103       a0[i] = (long)((a1[i] + ADD_INIT)>>VALUE);

  1104     }

  1105   }

  1106   static void test_srav_add(long[] a0, long[] a1, long b) {

  1107     for (int i = 0; i < a0.length; i+=1) {

  1108       a0[i] = (long)((a1[i] + b)>>VALUE);

  1109     }

  1110   }

  1111   static void test_srac_and(long[] a0, long[] a1) {

  1112     for (int i = 0; i < a0.length; i+=1) {

  1113       a0[i] = (long)((a1[i] & BIT_MASK)>>VALUE);

  1114     }

  1115   }

  1116   static void test_srav_and(long[] a0, long[] a1, long b) {

  1117     for (int i = 0; i < a0.length; i+=1) {

  1118       a0[i] = (long)((a1[i] & b)>>VALUE);

  1119     }

  1120   }

  1122   static int verify(String text, int i, long elem, long val) {

  1123     if (elem != val) {

  1124       System.err.println(text + "[" + i + "] = " + elem + " != " + val);

  1125       return 1;

  1126     }

  1127     return 0;

  1128   }

  1129 }

Mercurial > jdk8-mips64-public > hotspot / file revision

test/compiler/6340864/TestLongVect.java@b2c669fd8114

test/compiler/6340864/TestLongVect.java