1 /*

     2  * Copyright (c) 2013, 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 6934604

    27  * @summary enable parts of EliminateAutoBox by default

    28  * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestByteBoxing

    29  * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox

    30  * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing

    31  * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox

    32  * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing

    33  *

    34  */

    35 

    36 public class TestByteBoxing {

    37 

    38   static final Byte ibc = new Byte((byte)1);

    39 

    40   //===============================================

    41   // Non-inlined methods to test deoptimization info

    42   static void dummy()      { }

    43   static byte foo(byte i)  { return i; }

    44   static Byte foob(byte i) { return Byte.valueOf(i); }

    45 

    46 

    47   static byte simple(byte i) {

    48     Byte ib = new Byte(i);

    49     return ib;

    50   }

    51 

    52   static byte simpleb(byte i) {

    53     Byte ib = Byte.valueOf(i);

    54     return ib;

    55   }

    56 

    57   static byte simplec() {

    58     Byte ib = ibc;

    59     return ib;

    60   }

    61 

    62   static byte simplef(byte i) {

    63     Byte ib = foob(i);

    64     return ib;

    65   }

    66 

    67   static byte simplep(Byte ib) {

    68     return ib;

    69   }

    70 

    71   static byte simple2(byte i) {

    72     Byte ib1 = new Byte(i);

    73     Byte ib2 = new Byte((byte)(i+1));

    74     return (byte)(ib1 + ib2);

    75   }

    76 

    77   static byte simpleb2(byte i) {

    78     Byte ib1 = Byte.valueOf(i);

    79     Byte ib2 = Byte.valueOf((byte)(i+1));

    80     return (byte)(ib1 + ib2);

    81   }

    82 

    83   static byte simplem2(byte i) {

    84     Byte ib1 = new Byte(i);

    85     Byte ib2 = Byte.valueOf((byte)(i+1));

    86     return (byte)(ib1 + ib2);

    87   }

    88 

    89   static byte simplep2(byte i, Byte ib1) {

    90     Byte ib2 = Byte.valueOf((byte)(i+1));

    91     return (byte)(ib1 + ib2);

    92   }

    93 

    94   static byte simplec2(byte i) {

    95     Byte ib1 = ibc;

    96     Byte ib2 = Byte.valueOf((byte)(i+1));

    97     return (byte)(ib1 + ib2);

    98   }

    99 

   100   //===============================================

   101   static byte test(byte i) {

   102     Byte ib = new Byte(i);

   103     if ((i&1) == 0)

   104       ib = (byte)(i+1);

   105     return ib;

   106   }

   107 

   108   static byte testb(byte i) {

   109     Byte ib = i;

   110     if ((i&1) == 0)

   111       ib = (byte)(i+1);

   112     return ib;

   113   }

   114 

   115   static byte testm(byte i) {

   116     Byte ib = i;

   117     if ((i&1) == 0)

   118       ib = new Byte((byte)(i+1));

   119     return ib;

   120   }

   121 

   122   static byte testp(byte i, Byte ib) {

   123     if ((i&1) == 0)

   124       ib = new Byte((byte)(i+1));

   125     return ib;

   126   }

   127 

   128   static byte testc(byte i) {

   129     Byte ib = ibc;

   130     if ((i&1) == 0)

   131       ib = new Byte((byte)(i+1));

   132     return ib;

   133   }

   134 

   135   static byte test2(byte i) {

   136     Byte ib1 = new Byte(i);

   137     Byte ib2 = new Byte((byte)(i+1));

   138     if ((i&1) == 0) {

   139       ib1 = new Byte((byte)(i+1));

   140       ib2 = new Byte((byte)(i+2));

   141     }

   142     return (byte)(ib1+ib2);

   143   }

   144 

   145   static byte testb2(byte i) {

   146     Byte ib1 = i;

   147     Byte ib2 = (byte)(i+1);

   148     if ((i&1) == 0) {

   149       ib1 = (byte)(i+1);

   150       ib2 = (byte)(i+2);

   151     }

   152     return (byte)(ib1 + ib2);

   153   }

   154 

   155   static byte testm2(byte i) {

   156     Byte ib1 = new Byte(i);

   157     Byte ib2 = (byte)(i+1);

   158     if ((i&1) == 0) {

   159       ib1 = new Byte((byte)(i+1));

   160       ib2 = (byte)(i+2);

   161     }

   162     return (byte)(ib1 + ib2);

   163   }

   164 

   165   static byte testp2(byte i, Byte ib1) {

   166     Byte ib2 = (byte)(i+1);

   167     if ((i&1) == 0) {

   168       ib1 = new Byte((byte)(i+1));

   169       ib2 = (byte)(i+2);

   170     }

   171     return (byte)(ib1 + ib2);

   172   }

   173 

   174   static byte testc2(byte i) {

   175     Byte ib1 = ibc;

   176     Byte ib2 = (byte)(i+1);

   177     if ((i&1) == 0) {

   178       ib1 = (byte)(ibc+1);

   179       ib2 = (byte)(i+2);

   180     }

   181     return (byte)(ib1 + ib2);

   182   }

   183 

   184   //===============================================

   185   static byte sum(byte[] a) {

   186     byte result = 1;

   187     for (Byte i : a)

   188         result += i;

   189     return result;

   190   }

   191 

   192   static byte sumb(byte[] a) {

   193     Byte result = 1;

   194     for (Byte i : a)

   195         result = (byte)(result + i);

   196     return result;

   197   }

   198 

   199   static byte sumc(byte[] a) {

   200     Byte result = ibc;

   201     for (Byte i : a)

   202         result = (byte)(result + i);

   203     return result;

   204   }

   205 

   206   static byte sumf(byte[] a) {

   207     Byte result = foob((byte)1);

   208     for (Byte i : a)

   209         result = (byte)(result + i);

   210     return result;

   211   }

   212 

   213   static byte sump(byte[] a, Byte result) {

   214     for (Byte i : a)

   215         result = (byte)(result + i);

   216     return result;

   217   }

   218 

   219   static byte sum2(byte[] a) {

   220     byte result1 = 1;

   221     byte result2 = 1;

   222     for (Byte i : a) {

   223         result1 += i;

   224         result2 += i + 1;

   225     }

   226     return (byte)(result1 + result2);

   227   }

   228 

   229   static byte sumb2(byte[] a) {

   230     Byte result1 = 1;

   231     Byte result2 = 1;

   232     for (Byte i : a) {

   233         result1 = (byte)(result1 + i);

   234         result2 = (byte)(result2 + i + 1);

   235     }

   236     return (byte)(result1 + result2);

   237   }

   238 

   239   static byte summ2(byte[] a) {

   240     Byte result1 = 1;

   241     Byte result2 = new Byte((byte)1);

   242     for (Byte i : a) {

   243         result1 = (byte)(result1 + i);

   244         result2 = (byte)(result2 + new Byte((byte)(i + 1)));

   245     }

   246     return (byte)(result1 + result2);

   247   }

   248 

   249   static byte sump2(byte[] a, Byte result2) {

   250     Byte result1 = 1;

   251     for (Byte i : a) {

   252         result1 = (byte)(result1 + i);

   253         result2 = (byte)(result2 + i + 1);

   254     }

   255     return (byte)(result1 + result2);

   256   }

   257 

   258   static byte sumc2(byte[] a) {

   259     Byte result1 = 1;

   260     Byte result2 = ibc;

   261     for (Byte i : a) {

   262         result1 = (byte)(result1 + i);

   263         result2 = (byte)(result2 + i + ibc);

   264     }

   265     return (byte)(result1 + result2);

   266   }

   267 

   268   //===============================================

   269   static byte remi_sum() {

   270     Byte j = new Byte((byte)1);

   271     for (int i = 0; i< 1000; i++) {

   272       j = new Byte((byte)(j + 1));

   273     }

   274     return j;

   275   }

   276 

   277   static byte remi_sumb() {

   278     Byte j = Byte.valueOf((byte)1);

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

   280       j = (byte)(j + 1);

   281     }

   282     return j;

   283   }

   284 

   285   static byte remi_sumf() {

   286     Byte j = foob((byte)1);

   287     for (int i = 0; i< 1000; i++) {

   288       j = (byte)(j + 1);

   289     }

   290     return j;

   291   }

   292 

   293   static byte remi_sump(Byte j) {

   294     for (int i = 0; i< 1000; i++) {

   295       j = new Byte((byte)(j + 1));

   296     }

   297     return j;

   298   }

   299 

   300   static byte remi_sumc() {

   301     Byte j = ibc;

   302     for (int i = 0; i< 1000; i++) {

   303       j = (byte)(j + ibc);

   304     }

   305     return j;

   306   }

   307 

   308   static byte remi_sum2() {

   309     Byte j1 = new Byte((byte)1);

   310     Byte j2 = new Byte((byte)1);

   311     for (int i = 0; i< 1000; i++) {

   312       j1 = new Byte((byte)(j1 + 1));

   313       j2 = new Byte((byte)(j2 + 2));

   314     }

   315     return (byte)(j1 + j2);

   316   }

   317 

   318   static byte remi_sumb2() {

   319     Byte j1 = Byte.valueOf((byte)1);

   320     Byte j2 = Byte.valueOf((byte)1);

   321     for (int i = 0; i< 1000; i++) {

   322       j1 = (byte)(j1 + 1);

   323       j2 = (byte)(j2 + 2);

   324     }

   325     return (byte)(j1 + j2);

   326   }

   327 

   328   static byte remi_summ2() {

   329     Byte j1 = new Byte((byte)1);

   330     Byte j2 = Byte.valueOf((byte)1);

   331     for (int i = 0; i< 1000; i++) {

   332       j1 = new Byte((byte)(j1 + 1));

   333       j2 = (byte)(j2 + 2);

   334     }

   335     return (byte)(j1 + j2);

   336   }

   337 

   338   static byte remi_sump2(Byte j1) {

   339     Byte j2 = Byte.valueOf((byte)1);

   340     for (int i = 0; i< 1000; i++) {

   341       j1 = new Byte((byte)(j1 + 1));

   342       j2 = (byte)(j2 + 2);

   343     }

   344     return (byte)(j1 + j2);

   345   }

   346 

   347   static byte remi_sumc2() {

   348     Byte j1 = ibc;

   349     Byte j2 = Byte.valueOf((byte)1);

   350     for (int i = 0; i< 1000; i++) {

   351       j1 = (byte)(j1 + ibc);

   352       j2 = (byte)(j2 + 2);

   353     }

   354     return (byte)(j1 + j2);

   355   }

   356 

   357 

   358   //===============================================

   359   // Safepointa and debug info for deoptimization

   360   static byte simple_deop(byte i) {

   361     Byte ib = new Byte(foo(i));

   362     dummy();

   363     return ib;

   364   }

   365 

   366   static byte simpleb_deop(byte i) {

   367     Byte ib = Byte.valueOf(foo(i));

   368     dummy();

   369     return ib;

   370   }

   371 

   372   static byte simplef_deop(byte i) {

   373     Byte ib = foob(i);

   374     dummy();

   375     return ib;

   376   }

   377 

   378   static byte simplep_deop(Byte ib) {

   379     dummy();

   380     return ib;

   381   }

   382 

   383   static byte simplec_deop(byte i) {

   384     Byte ib = ibc;

   385     dummy();

   386     return ib;

   387   }

   388 

   389   static byte test_deop(byte i) {

   390     Byte ib = new Byte(foo(i));

   391     if ((i&1) == 0)

   392       ib = foo((byte)(i+1));

   393     dummy();

   394     return ib;

   395   }

   396 

   397   static byte testb_deop(byte i) {

   398     Byte ib = foo(i);

   399     if ((i&1) == 0)

   400       ib = foo((byte)(i+1));

   401     dummy();

   402     return ib;

   403   }

   404 

   405   static byte testf_deop(byte i) {

   406     Byte ib = foob(i);

   407     if ((i&1) == 0)

   408       ib = foo((byte)(i+1));

   409     dummy();

   410     return ib;

   411   }

   412 

   413   static byte testp_deop(byte i, Byte ib) {

   414     if ((i&1) == 0)

   415       ib = foo((byte)(i+1));

   416     dummy();

   417     return ib;

   418   }

   419 

   420   static byte testc_deop(byte i) {

   421     Byte ib = ibc;

   422     if ((i&1) == 0)

   423       ib = foo((byte)(i+1));

   424     dummy();

   425     return ib;

   426   }

   427 

   428   static byte sum_deop(byte[] a) {

   429     byte result = 1;

   430     for (Byte i : a)

   431         result += foo(i);

   432     dummy();

   433     return result;

   434   }

   435 

   436   static byte sumb_deop(byte[] a) {

   437     Byte result = 1;

   438     for (Byte i : a)

   439         result = (byte)(result + foo(i));

   440     dummy();

   441     return result;

   442   }

   443 

   444   static byte sumf_deop(byte[] a) {

   445     Byte result = 1;

   446     for (Byte i : a)

   447         result = (byte)(result + foob(i));

   448     dummy();

   449     return result;

   450   }

   451 

   452   static byte sump_deop(byte[] a, Byte result) {

   453     for (Byte i : a)

   454         result = (byte)(result + foob(i));

   455     dummy();

   456     return result;

   457   }

   458 

   459   static byte sumc_deop(byte[] a) {

   460     Byte result = ibc;

   461     for (Byte i : a)

   462         result = (byte)(result + foo(i));

   463     dummy();

   464     return result;

   465   }

   466 

   467   static byte remi_sum_deop() {

   468     Byte j = new Byte(foo((byte)1));

   469     for (int i = 0; i< 1000; i++) {

   470       j = new Byte(foo((byte)(j + 1)));

   471     }

   472     dummy();

   473     return j;

   474   }

   475 

   476   static byte remi_sumb_deop() {

   477     Byte j = Byte.valueOf(foo((byte)1));

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

   479       j = foo((byte)(j + 1));

   480     }

   481     dummy();

   482     return j;

   483   }

   484 

   485   static byte remi_sumf_deop() {

   486     Byte j = foob((byte)1);

   487     for (int i = 0; i< 1000; i++) {

   488       j = foo((byte)(j + 1));

   489     }

   490     dummy();

   491     return j;

   492   }

   493 

   494   static byte remi_sump_deop(Byte j) {

   495     for (int i = 0; i< 1000; i++) {

   496       j = foo((byte)(j + 1));

   497     }

   498     dummy();

   499     return j;

   500   }

   501 

   502   static byte remi_sumc_deop() {

   503     Byte j = ibc;

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

   505       j = foo((byte)(j + 1));

   506     }

   507     dummy();

   508     return j;

   509   }

   510 

   511   //===============================================

   512   // Conditional increment

   513   static byte remi_sum_cond() {

   514     Byte j = new Byte((byte)1);

   515     for (int i = 0; i< 1000; i++) {

   516       if ((i&1) == 0) {

   517         j = new Byte((byte)(j + 1));

   518       }

   519     }

   520     return j;

   521   }

   522 

   523   static byte remi_sumb_cond() {

   524     Byte j = Byte.valueOf((byte)1);

   525     for (int i = 0; i< 1000; i++) {

   526       if ((i&1) == 0) {

   527         j = (byte)(j + 1);

   528       }

   529     }

   530     return j;

   531   }

   532 

   533   static byte remi_sumf_cond() {

   534     Byte j = foob((byte)1);

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

   536       if ((i&1) == 0) {

   537         j = (byte)(j + 1);

   538       }

   539     }

   540     return j;

   541   }

   542 

   543   static byte remi_sump_cond(Byte j) {

   544     for (int i = 0; i< 1000; i++) {

   545       if ((i&1) == 0) {

   546         j = (byte)(j + 1);

   547       }

   548     }

   549     return j;

   550   }

   551 

   552   static byte remi_sumc_cond() {

   553     Byte j = ibc;

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

   555       if ((i&1) == 0) {

   556         j = (byte)(j + ibc);

   557       }

   558     }

   559     return j;

   560   }

   561 

   562   static byte remi_sum2_cond() {

   563     Byte j1 = new Byte((byte)1);

   564     Byte j2 = new Byte((byte)1);

   565     for (int i = 0; i< 1000; i++) {

   566       if ((i&1) == 0) {

   567         j1 = new Byte((byte)(j1 + 1));

   568       } else {

   569         j2 = new Byte((byte)(j2 + 2));

   570       }

   571     }

   572     return (byte)(j1 + j2);

   573   }

   574 

   575   static byte remi_sumb2_cond() {

   576     Byte j1 = Byte.valueOf((byte)1);

   577     Byte j2 = Byte.valueOf((byte)1);

   578     for (int i = 0; i< 1000; i++) {

   579       if ((i&1) == 0) {

   580         j1 = (byte)(j1 + 1);

   581       } else {

   582         j2 = (byte)(j2 + 2);

   583       }

   584     }

   585     return (byte)(j1 + j2);

   586   }

   587 

   588   static byte remi_summ2_cond() {

   589     Byte j1 = new Byte((byte)1);

   590     Byte j2 = Byte.valueOf((byte)1);

   591     for (int i = 0; i< 1000; i++) {

   592       if ((i&1) == 0) {

   593         j1 = new Byte((byte)(j1 + 1));

   594       } else {

   595         j2 = (byte)(j2 + 2);

   596       }

   597     }

   598     return (byte)(j1 + j2);

   599   }

   600 

   601   static byte remi_sump2_cond(Byte j1) {

   602     Byte j2 = Byte.valueOf((byte)1);

   603     for (int i = 0; i< 1000; i++) {

   604       if ((i&1) == 0) {

   605         j1 = new Byte((byte)(j1 + 1));

   606       } else {

   607         j2 = (byte)(j2 + 2);

   608       }

   609     }

   610     return (byte)(j1 + j2);

   611   }

   612 

   613   static byte remi_sumc2_cond() {

   614     Byte j1 = ibc;

   615     Byte j2 = Byte.valueOf((byte)1);

   616     for (int i = 0; i< 1000; i++) {

   617       if ((i&1) == 0) {

   618         j1 = (byte)(j1 + ibc);

   619       } else {

   620         j2 = (byte)(j2 + 2);

   621       }

   622     }

   623     return (byte)(j1 + j2);

   624   }

   625 

   626 

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

   628     final int ntests = 70;

   629 

   630     String[] test_name = new String[] {

   631         "simple",      "simpleb",      "simplec",      "simplef",      "simplep",

   632         "simple2",     "simpleb2",     "simplec2",     "simplem2",     "simplep2",

   633         "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",

   634         "test",        "testb",        "testc",        "testm",        "testp",

   635         "test2",       "testb2",       "testc2",       "testm2",       "testp2",

   636         "test_deop",   "testb_deop",   "testc_deop",   "testf_deop",   "testp_deop",

   637         "sum",         "sumb",         "sumc",         "sumf",         "sump",

   638         "sum2",        "sumb2",        "sumc2",        "summ2",        "sump2",

   639         "sum_deop",    "sumb_deop",    "sumc_deop",    "sumf_deop",    "sump_deop",

   640         "remi_sum",       "remi_sumb",       "remi_sumc",       "remi_sumf",       "remi_sump",

   641         "remi_sum2",      "remi_sumb2",      "remi_sumc2",      "remi_summ2",      "remi_sump2",

   642         "remi_sum_deop",  "remi_sumb_deop",  "remi_sumc_deop",  "remi_sumf_deop",  "remi_sump_deop",

   643         "remi_sum_cond",  "remi_sumb_cond",  "remi_sumc_cond",  "remi_sumf_cond",  "remi_sump_cond",

   644         "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"

   645     };

   646 

   647     final int[] val = new int[] {

   648       -5488, -5488, 12000, -5488, -5488,

   649        1024,  1024, -5552,  1024,  1024,

   650       -5488, -5488, 12000, -5488, -5488,

   651         512,   512,  6256,   512,   512,

   652       13024, 13024, -5584, 13024, 13024,

   653         512,   512,  6256,   512,   512,

   654          45,    45,    45,    45,    45,

   655          66,    66,    66,    66,    66,

   656          45,    45,    45,    45,    45,

   657         -23,   -23,   -23,   -23,   -23,

   658         -70,   -70,   -70,   -70,   -70,

   659         -23,   -23,   -23,   -23,   -23,

   660         -11,   -11,   -11,   -11,   -11,

   661         -34,   -34,   -34,   -34,   -34

   662     };

   663 

   664     int[] res = new int[ntests];

   665     for (int i = 0; i < ntests; i++) {

   666       res[i] = 0;

   667     }

   668 

   669 

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

   671       res[0] += simple((byte)i);

   672       res[1] += simpleb((byte)i);

   673       res[2] += simplec();

   674       res[3] += simplef((byte)i);

   675       res[4] += simplep((byte)i);

   676 

   677       res[5] += simple2((byte)i);

   678       res[6] += simpleb2((byte)i);

   679       res[7] += simplec2((byte)i);

   680       res[8] += simplem2((byte)i);

   681       res[9] += simplep2((byte)i, (byte)i);

   682 

   683       res[10] += simple_deop((byte)i);

   684       res[11] += simpleb_deop((byte)i);

   685       res[12] += simplec_deop((byte)i);

   686       res[13] += simplef_deop((byte)i);

   687       res[14] += simplep_deop((byte)i);

   688 

   689       res[15] += test((byte)i);

   690       res[16] += testb((byte)i);

   691       res[17] += testc((byte)i);

   692       res[18] += testm((byte)i);

   693       res[19] += testp((byte)i, (byte)i);

   694 

   695       res[20] += test2((byte)i);

   696       res[21] += testb2((byte)i);

   697       res[22] += testc2((byte)i);

   698       res[23] += testm2((byte)i);

   699       res[24] += testp2((byte)i, (byte)i);

   700 

   701       res[25] += test_deop((byte)i);

   702       res[26] += testb_deop((byte)i);

   703       res[27] += testc_deop((byte)i);

   704       res[28] += testf_deop((byte)i);

   705       res[29] += testp_deop((byte)i, (byte)i);

   706     }

   707 

   708     byte[] ia = new byte[1000];

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

   710       ia[i] = (byte)i;

   711     }

   712 

   713     for (int i = 0; i < 100; i++) {

   714       res[30] = sum(ia);

   715       res[31] = sumb(ia);

   716       res[32] = sumc(ia);

   717       res[33] = sumf(ia);

   718       res[34] = sump(ia, (byte)1);

   719 

   720       res[35] = sum2(ia);

   721       res[36] = sumb2(ia);

   722       res[37] = sumc2(ia);

   723       res[38] = summ2(ia);

   724       res[39] = sump2(ia, (byte)1);

   725 

   726       res[40] = sum_deop(ia);

   727       res[41] = sumb_deop(ia);

   728       res[42] = sumc_deop(ia);

   729       res[43] = sumf_deop(ia);

   730       res[44] = sump_deop(ia, (byte)1);

   731 

   732       res[45] = remi_sum();

   733       res[46] = remi_sumb();

   734       res[47] = remi_sumc();

   735       res[48] = remi_sumf();

   736       res[49] = remi_sump((byte)1);

   737 

   738       res[50] = remi_sum2();

   739       res[51] = remi_sumb2();

   740       res[52] = remi_sumc2();

   741       res[53] = remi_summ2();

   742       res[54] = remi_sump2((byte)1);

   743 

   744       res[55] = remi_sum_deop();

   745       res[56] = remi_sumb_deop();

   746       res[57] = remi_sumc_deop();

   747       res[58] = remi_sumf_deop();

   748       res[59] = remi_sump_deop((byte)1);

   749 

   750       res[60] = remi_sum_cond();

   751       res[61] = remi_sumb_cond();

   752       res[62] = remi_sumc_cond();

   753       res[63] = remi_sumf_cond();

   754       res[64] = remi_sump_cond((byte)1);

   755 

   756       res[65] = remi_sum2_cond();

   757       res[66] = remi_sumb2_cond();

   758       res[67] = remi_sumc2_cond();

   759       res[68] = remi_summ2_cond();

   760       res[69] = remi_sump2_cond((byte)1);

   761     }

   762 

   763     int failed = 0;

   764     for (int i = 0; i < ntests; i++) {

   765       if (res[i] != val[i]) {

   766         System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);

   767         failed++;

   768       }

   769     }

   770     if (failed > 0) {

   771       System.err.println("Failed " + failed + " tests.");

   772       throw new InternalError();

   773     } else {

   774       System.out.println("Passed.");

   775     }

   776   }

   777 }