jdk8-mips64-public/hotspot: src/share/vm/shark/sharkBlock.cpp@e863062e521d

7032458: Zero and Shark fixes
Reviewed-by: twisti
Contributed-by: Gary Benson <gbenson@redhat.com>

     1 /*

     2  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2008, 2009, 2010 Red Hat, Inc.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    26 #include "precompiled.hpp"

    27 #include "interpreter/bytecodes.hpp"

    28 #include "shark/llvmHeaders.hpp"

    29 #include "shark/llvmValue.hpp"

    30 #include "shark/sharkBlock.hpp"

    31 #include "shark/sharkBuilder.hpp"

    32 #include "shark/sharkConstant.hpp"

    33 #include "shark/sharkState.hpp"

    34 #include "shark/sharkValue.hpp"

    35 #include "shark/shark_globals.hpp"

    36 #include "utilities/debug.hpp"

    38 using namespace llvm;

    40 void SharkBlock::parse_bytecode(int start, int limit) {

    41   SharkValue *a, *b, *c, *d;

    42   int i;

    44   // Ensure the current state is initialized before we emit any code,

    45   // so that any setup code for the state is at the start of the block

    46   current_state();

    48   // Parse the bytecodes

    49   iter()->reset_to_bci(start);

    50   while (iter()->next_bci() < limit) {

    51     NOT_PRODUCT(a = b = c = d = NULL);

    52     iter()->next();

    54     if (SharkTraceBytecodes)

    55       tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc()));

    57     if (has_trap() && trap_bci() == bci()) {

    58       do_trap(trap_request());

    59       return;

    60     }

    62     if (UseLoopSafepoints) {

    63       // XXX if a lcmp is followed by an if_?? then C2 maybe-inserts

    64       // the safepoint before the lcmp rather than before the if.

    65       // Maybe we should do this too.  See parse2.cpp for details.

    66       switch (bc()) {

    67       case Bytecodes::_goto:

    68       case Bytecodes::_ifnull:

    69       case Bytecodes::_ifnonnull:

    70       case Bytecodes::_if_acmpeq:

    71       case Bytecodes::_if_acmpne:

    72       case Bytecodes::_ifeq:

    73       case Bytecodes::_ifne:

    74       case Bytecodes::_iflt:

    75       case Bytecodes::_ifle:

    76       case Bytecodes::_ifgt:

    77       case Bytecodes::_ifge:

    78       case Bytecodes::_if_icmpeq:

    79       case Bytecodes::_if_icmpne:

    80       case Bytecodes::_if_icmplt:

    81       case Bytecodes::_if_icmple:

    82       case Bytecodes::_if_icmpgt:

    83       case Bytecodes::_if_icmpge:

    84         if (iter()->get_dest() <= bci())

    85           maybe_add_backedge_safepoint();

    86         break;

    88       case Bytecodes::_goto_w:

    89         if (iter()->get_far_dest() <= bci())

    90           maybe_add_backedge_safepoint();

    91         break;

    93       case Bytecodes::_tableswitch:

    94       case Bytecodes::_lookupswitch:

    95         if (switch_default_dest() <= bci()) {

    96           maybe_add_backedge_safepoint();

    97           break;

    98         }

    99         int len = switch_table_length();

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

   101           if (switch_dest(i) <= bci()) {

   102             maybe_add_backedge_safepoint();

   103             break;

   104           }

   105         }

   106         break;

   107       }

   108     }

   110     switch (bc()) {

   111     case Bytecodes::_nop:

   112       break;

   114     case Bytecodes::_aconst_null:

   115       push(SharkValue::null());

   116       break;

   118     case Bytecodes::_iconst_m1:

   119       push(SharkValue::jint_constant(-1));

   120       break;

   121     case Bytecodes::_iconst_0:

   122       push(SharkValue::jint_constant(0));

   123       break;

   124     case Bytecodes::_iconst_1:

   125       push(SharkValue::jint_constant(1));

   126       break;

   127     case Bytecodes::_iconst_2:

   128       push(SharkValue::jint_constant(2));

   129       break;

   130     case Bytecodes::_iconst_3:

   131       push(SharkValue::jint_constant(3));

   132       break;

   133     case Bytecodes::_iconst_4:

   134       push(SharkValue::jint_constant(4));

   135       break;

   136     case Bytecodes::_iconst_5:

   137       push(SharkValue::jint_constant(5));

   138       break;

   140     case Bytecodes::_lconst_0:

   141       push(SharkValue::jlong_constant(0));

   142       break;

   143     case Bytecodes::_lconst_1:

   144       push(SharkValue::jlong_constant(1));

   145       break;

   147     case Bytecodes::_fconst_0:

   148       push(SharkValue::jfloat_constant(0));

   149       break;

   150     case Bytecodes::_fconst_1:

   151       push(SharkValue::jfloat_constant(1));

   152       break;

   153     case Bytecodes::_fconst_2:

   154       push(SharkValue::jfloat_constant(2));

   155       break;

   157     case Bytecodes::_dconst_0:

   158       push(SharkValue::jdouble_constant(0));

   159       break;

   160     case Bytecodes::_dconst_1:

   161       push(SharkValue::jdouble_constant(1));

   162       break;

   164     case Bytecodes::_bipush:

   165       push(SharkValue::jint_constant(iter()->get_constant_u1()));

   166       break;

   167     case Bytecodes::_sipush:

   168       push(SharkValue::jint_constant(iter()->get_constant_u2()));

   169       break;

   171     case Bytecodes::_ldc:

   172     case Bytecodes::_ldc_w:

   173     case Bytecodes::_ldc2_w:

   174       push(SharkConstant::for_ldc(iter())->value(builder()));

   175       break;

   177     case Bytecodes::_iload_0:

   178     case Bytecodes::_lload_0:

   179     case Bytecodes::_fload_0:

   180     case Bytecodes::_dload_0:

   181     case Bytecodes::_aload_0:

   182       push(local(0));

   183       break;

   184     case Bytecodes::_iload_1:

   185     case Bytecodes::_lload_1:

   186     case Bytecodes::_fload_1:

   187     case Bytecodes::_dload_1:

   188     case Bytecodes::_aload_1:

   189       push(local(1));

   190       break;

   191     case Bytecodes::_iload_2:

   192     case Bytecodes::_lload_2:

   193     case Bytecodes::_fload_2:

   194     case Bytecodes::_dload_2:

   195     case Bytecodes::_aload_2:

   196       push(local(2));

   197       break;

   198     case Bytecodes::_iload_3:

   199     case Bytecodes::_lload_3:

   200     case Bytecodes::_fload_3:

   201     case Bytecodes::_dload_3:

   202     case Bytecodes::_aload_3:

   203       push(local(3));

   204       break;

   205     case Bytecodes::_iload:

   206     case Bytecodes::_lload:

   207     case Bytecodes::_fload:

   208     case Bytecodes::_dload:

   209     case Bytecodes::_aload:

   210       push(local(iter()->get_index()));

   211       break;

   213     case Bytecodes::_baload:

   214       do_aload(T_BYTE);

   215       break;

   216     case Bytecodes::_caload:

   217       do_aload(T_CHAR);

   218       break;

   219     case Bytecodes::_saload:

   220       do_aload(T_SHORT);

   221       break;

   222     case Bytecodes::_iaload:

   223       do_aload(T_INT);

   224       break;

   225     case Bytecodes::_laload:

   226       do_aload(T_LONG);

   227       break;

   228     case Bytecodes::_faload:

   229       do_aload(T_FLOAT);

   230       break;

   231     case Bytecodes::_daload:

   232       do_aload(T_DOUBLE);

   233       break;

   234     case Bytecodes::_aaload:

   235       do_aload(T_OBJECT);

   236       break;

   238     case Bytecodes::_istore_0:

   239     case Bytecodes::_lstore_0:

   240     case Bytecodes::_fstore_0:

   241     case Bytecodes::_dstore_0:

   242     case Bytecodes::_astore_0:

   243       set_local(0, pop());

   244       break;

   245     case Bytecodes::_istore_1:

   246     case Bytecodes::_lstore_1:

   247     case Bytecodes::_fstore_1:

   248     case Bytecodes::_dstore_1:

   249     case Bytecodes::_astore_1:

   250       set_local(1, pop());

   251       break;

   252     case Bytecodes::_istore_2:

   253     case Bytecodes::_lstore_2:

   254     case Bytecodes::_fstore_2:

   255     case Bytecodes::_dstore_2:

   256     case Bytecodes::_astore_2:

   257       set_local(2, pop());

   258       break;

   259     case Bytecodes::_istore_3:

   260     case Bytecodes::_lstore_3:

   261     case Bytecodes::_fstore_3:

   262     case Bytecodes::_dstore_3:

   263     case Bytecodes::_astore_3:

   264       set_local(3, pop());

   265       break;

   266     case Bytecodes::_istore:

   267     case Bytecodes::_lstore:

   268     case Bytecodes::_fstore:

   269     case Bytecodes::_dstore:

   270     case Bytecodes::_astore:

   271       set_local(iter()->get_index(), pop());

   272       break;

   274     case Bytecodes::_bastore:

   275       do_astore(T_BYTE);

   276       break;

   277     case Bytecodes::_castore:

   278       do_astore(T_CHAR);

   279       break;

   280     case Bytecodes::_sastore:

   281       do_astore(T_SHORT);

   282       break;

   283     case Bytecodes::_iastore:

   284       do_astore(T_INT);

   285       break;

   286     case Bytecodes::_lastore:

   287       do_astore(T_LONG);

   288       break;

   289     case Bytecodes::_fastore:

   290       do_astore(T_FLOAT);

   291       break;

   292     case Bytecodes::_dastore:

   293       do_astore(T_DOUBLE);

   294       break;

   295     case Bytecodes::_aastore:

   296       do_astore(T_OBJECT);

   297       break;

   299     case Bytecodes::_pop:

   300       xpop();

   301       break;

   302     case Bytecodes::_pop2:

   303       xpop();

   304       xpop();

   305       break;

   306     case Bytecodes::_swap:

   307       a = xpop();

   308       b = xpop();

   309       xpush(a);

   310       xpush(b);

   311       break;

   312     case Bytecodes::_dup:

   313       a = xpop();

   314       xpush(a);

   315       xpush(a);

   316       break;

   317     case Bytecodes::_dup_x1:

   318       a = xpop();

   319       b = xpop();

   320       xpush(a);

   321       xpush(b);

   322       xpush(a);

   323       break;

   324     case Bytecodes::_dup_x2:

   325       a = xpop();

   326       b = xpop();

   327       c = xpop();

   328       xpush(a);

   329       xpush(c);

   330       xpush(b);

   331       xpush(a);

   332       break;

   333     case Bytecodes::_dup2:

   334       a = xpop();

   335       b = xpop();

   336       xpush(b);

   337       xpush(a);

   338       xpush(b);

   339       xpush(a);

   340       break;

   341     case Bytecodes::_dup2_x1:

   342       a = xpop();

   343       b = xpop();

   344       c = xpop();

   345       xpush(b);

   346       xpush(a);

   347       xpush(c);

   348       xpush(b);

   349       xpush(a);

   350       break;

   351     case Bytecodes::_dup2_x2:

   352       a = xpop();

   353       b = xpop();

   354       c = xpop();

   355       d = xpop();

   356       xpush(b);

   357       xpush(a);

   358       xpush(d);

   359       xpush(c);

   360       xpush(b);

   361       xpush(a);

   362       break;

   364     case Bytecodes::_arraylength:

   365       do_arraylength();

   366       break;

   368     case Bytecodes::_getfield:

   369       do_getfield();

   370       break;

   371     case Bytecodes::_getstatic:

   372       do_getstatic();

   373       break;

   374     case Bytecodes::_putfield:

   375       do_putfield();

   376       break;

   377     case Bytecodes::_putstatic:

   378       do_putstatic();

   379       break;

   381     case Bytecodes::_iadd:

   382       b = pop();

   383       a = pop();

   384       push(SharkValue::create_jint(

   385         builder()->CreateAdd(a->jint_value(), b->jint_value()), false));

   386       break;

   387     case Bytecodes::_isub:

   388       b = pop();

   389       a = pop();

   390       push(SharkValue::create_jint(

   391         builder()->CreateSub(a->jint_value(), b->jint_value()), false));

   392       break;

   393     case Bytecodes::_imul:

   394       b = pop();

   395       a = pop();

   396       push(SharkValue::create_jint(

   397         builder()->CreateMul(a->jint_value(), b->jint_value()), false));

   398       break;

   399     case Bytecodes::_idiv:

   400       do_idiv();

   401       break;

   402     case Bytecodes::_irem:

   403       do_irem();

   404       break;

   405     case Bytecodes::_ineg:

   406       a = pop();

   407       push(SharkValue::create_jint(

   408         builder()->CreateNeg(a->jint_value()), a->zero_checked()));

   409       break;

   410     case Bytecodes::_ishl:

   411       b = pop();

   412       a = pop();

   413       push(SharkValue::create_jint(

   414         builder()->CreateShl(

   415           a->jint_value(),

   416           builder()->CreateAnd(

   417             b->jint_value(), LLVMValue::jint_constant(0x1f))), false));

   418       break;

   419     case Bytecodes::_ishr:

   420       b = pop();

   421       a = pop();

   422       push(SharkValue::create_jint(

   423         builder()->CreateAShr(

   424           a->jint_value(),

   425           builder()->CreateAnd(

   426             b->jint_value(), LLVMValue::jint_constant(0x1f))), false));

   427       break;

   428     case Bytecodes::_iushr:

   429       b = pop();

   430       a = pop();

   431       push(SharkValue::create_jint(

   432         builder()->CreateLShr(

   433           a->jint_value(),

   434           builder()->CreateAnd(

   435             b->jint_value(), LLVMValue::jint_constant(0x1f))), false));

   436       break;

   437     case Bytecodes::_iand:

   438       b = pop();

   439       a = pop();

   440       push(SharkValue::create_jint(

   441         builder()->CreateAnd(a->jint_value(), b->jint_value()), false));

   442       break;

   443     case Bytecodes::_ior:

   444       b = pop();

   445       a = pop();

   446       push(SharkValue::create_jint(

   447         builder()->CreateOr(a->jint_value(), b->jint_value()),

   448         a->zero_checked() && b->zero_checked()));

   449       break;

   450     case Bytecodes::_ixor:

   451       b = pop();

   452       a = pop();

   453       push(SharkValue::create_jint(

   454         builder()->CreateXor(a->jint_value(), b->jint_value()), false));

   455       break;

   457     case Bytecodes::_ladd:

   458       b = pop();

   459       a = pop();

   460       push(SharkValue::create_jlong(

   461         builder()->CreateAdd(a->jlong_value(), b->jlong_value()), false));

   462       break;

   463     case Bytecodes::_lsub:

   464       b = pop();

   465       a = pop();

   466       push(SharkValue::create_jlong(

   467         builder()->CreateSub(a->jlong_value(), b->jlong_value()), false));

   468       break;

   469     case Bytecodes::_lmul:

   470       b = pop();

   471       a = pop();

   472       push(SharkValue::create_jlong(

   473         builder()->CreateMul(a->jlong_value(), b->jlong_value()), false));

   474       break;

   475     case Bytecodes::_ldiv:

   476       do_ldiv();

   477       break;

   478     case Bytecodes::_lrem:

   479       do_lrem();

   480       break;

   481     case Bytecodes::_lneg:

   482       a = pop();

   483       push(SharkValue::create_jlong(

   484         builder()->CreateNeg(a->jlong_value()), a->zero_checked()));

   485       break;

   486     case Bytecodes::_lshl:

   487       b = pop();

   488       a = pop();

   489       push(SharkValue::create_jlong(

   490         builder()->CreateShl(

   491           a->jlong_value(),

   492           builder()->CreateIntCast(

   493             builder()->CreateAnd(

   494               b->jint_value(), LLVMValue::jint_constant(0x3f)),

   495             SharkType::jlong_type(), true)), false));

   496       break;

   497     case Bytecodes::_lshr:

   498       b = pop();

   499       a = pop();

   500       push(SharkValue::create_jlong(

   501         builder()->CreateAShr(

   502           a->jlong_value(),

   503           builder()->CreateIntCast(

   504             builder()->CreateAnd(

   505               b->jint_value(), LLVMValue::jint_constant(0x3f)),

   506             SharkType::jlong_type(), true)), false));

   507       break;

   508     case Bytecodes::_lushr:

   509       b = pop();

   510       a = pop();

   511       push(SharkValue::create_jlong(

   512         builder()->CreateLShr(

   513           a->jlong_value(),

   514           builder()->CreateIntCast(

   515             builder()->CreateAnd(

   516               b->jint_value(), LLVMValue::jint_constant(0x3f)),

   517             SharkType::jlong_type(), true)), false));

   518       break;

   519     case Bytecodes::_land:

   520       b = pop();

   521       a = pop();

   522       push(SharkValue::create_jlong(

   523         builder()->CreateAnd(a->jlong_value(), b->jlong_value()), false));

   524       break;

   525     case Bytecodes::_lor:

   526       b = pop();

   527       a = pop();

   528       push(SharkValue::create_jlong(

   529         builder()->CreateOr(a->jlong_value(), b->jlong_value()),

   530         a->zero_checked() && b->zero_checked()));

   531       break;

   532     case Bytecodes::_lxor:

   533       b = pop();

   534       a = pop();

   535       push(SharkValue::create_jlong(

   536         builder()->CreateXor(a->jlong_value(), b->jlong_value()), false));

   537       break;

   539     case Bytecodes::_fadd:

   540       b = pop();

   541       a = pop();

   542       push(SharkValue::create_jfloat(

   543         builder()->CreateFAdd(a->jfloat_value(), b->jfloat_value())));

   544       break;

   545     case Bytecodes::_fsub:

   546       b = pop();

   547       a = pop();

   548       push(SharkValue::create_jfloat(

   549         builder()->CreateFSub(a->jfloat_value(), b->jfloat_value())));

   550       break;

   551     case Bytecodes::_fmul:

   552       b = pop();

   553       a = pop();

   554       push(SharkValue::create_jfloat(

   555         builder()->CreateFMul(a->jfloat_value(), b->jfloat_value())));

   556       break;

   557     case Bytecodes::_fdiv:

   558       b = pop();

   559       a = pop();

   560       push(SharkValue::create_jfloat(

   561         builder()->CreateFDiv(a->jfloat_value(), b->jfloat_value())));

   562       break;

   563     case Bytecodes::_frem:

   564       b = pop();

   565       a = pop();

   566       push(SharkValue::create_jfloat(

   567         builder()->CreateFRem(a->jfloat_value(), b->jfloat_value())));

   568       break;

   569     case Bytecodes::_fneg:

   570       a = pop();

   571       push(SharkValue::create_jfloat(

   572         builder()->CreateFNeg(a->jfloat_value())));

   573       break;

   575     case Bytecodes::_dadd:

   576       b = pop();

   577       a = pop();

   578       push(SharkValue::create_jdouble(

   579         builder()->CreateFAdd(a->jdouble_value(), b->jdouble_value())));

   580       break;

   581     case Bytecodes::_dsub:

   582       b = pop();

   583       a = pop();

   584       push(SharkValue::create_jdouble(

   585         builder()->CreateFSub(a->jdouble_value(), b->jdouble_value())));

   586       break;

   587     case Bytecodes::_dmul:

   588       b = pop();

   589       a = pop();

   590       push(SharkValue::create_jdouble(

   591         builder()->CreateFMul(a->jdouble_value(), b->jdouble_value())));

   592       break;

   593     case Bytecodes::_ddiv:

   594       b = pop();

   595       a = pop();

   596       push(SharkValue::create_jdouble(

   597         builder()->CreateFDiv(a->jdouble_value(), b->jdouble_value())));

   598       break;

   599     case Bytecodes::_drem:

   600       b = pop();

   601       a = pop();

   602       push(SharkValue::create_jdouble(

   603         builder()->CreateFRem(a->jdouble_value(), b->jdouble_value())));

   604       break;

   605     case Bytecodes::_dneg:

   606       a = pop();

   607       push(SharkValue::create_jdouble(

   608         builder()->CreateFNeg(a->jdouble_value())));

   609       break;

   611     case Bytecodes::_iinc:

   612       i = iter()->get_index();

   613       set_local(

   614         i,

   615         SharkValue::create_jint(

   616           builder()->CreateAdd(

   617             LLVMValue::jint_constant(iter()->get_iinc_con()),

   618             local(i)->jint_value()), false));

   619       break;

   621     case Bytecodes::_lcmp:

   622       do_lcmp();

   623       break;

   625     case Bytecodes::_fcmpl:

   626       do_fcmp(false, false);

   627       break;

   628     case Bytecodes::_fcmpg:

   629       do_fcmp(false, true);

   630       break;

   631     case Bytecodes::_dcmpl:

   632       do_fcmp(true, false);

   633       break;

   634     case Bytecodes::_dcmpg:

   635       do_fcmp(true, true);

   636       break;

   638     case Bytecodes::_i2l:

   639       a = pop();

   640       push(SharkValue::create_jlong(

   641         builder()->CreateIntCast(

   642           a->jint_value(), SharkType::jlong_type(), true), a->zero_checked()));

   643       break;

   644     case Bytecodes::_i2f:

   645       push(SharkValue::create_jfloat(

   646         builder()->CreateSIToFP(

   647           pop()->jint_value(), SharkType::jfloat_type())));

   648       break;

   649     case Bytecodes::_i2d:

   650       push(SharkValue::create_jdouble(

   651         builder()->CreateSIToFP(

   652           pop()->jint_value(), SharkType::jdouble_type())));

   653       break;

   655     case Bytecodes::_l2i:

   656       push(SharkValue::create_jint(

   657         builder()->CreateIntCast(

   658           pop()->jlong_value(), SharkType::jint_type(), true), false));

   659       break;

   660     case Bytecodes::_l2f:

   661       push(SharkValue::create_jfloat(

   662         builder()->CreateSIToFP(

   663           pop()->jlong_value(), SharkType::jfloat_type())));

   664       break;

   665     case Bytecodes::_l2d:

   666       push(SharkValue::create_jdouble(

   667         builder()->CreateSIToFP(

   668           pop()->jlong_value(), SharkType::jdouble_type())));

   669       break;

   671     case Bytecodes::_f2i:

   672       push(SharkValue::create_jint(

   673         builder()->CreateCall(

   674           builder()->f2i(), pop()->jfloat_value()), false));

   675       break;

   676     case Bytecodes::_f2l:

   677       push(SharkValue::create_jlong(

   678         builder()->CreateCall(

   679           builder()->f2l(), pop()->jfloat_value()), false));

   680       break;

   681     case Bytecodes::_f2d:

   682       push(SharkValue::create_jdouble(

   683         builder()->CreateFPExt(

   684           pop()->jfloat_value(), SharkType::jdouble_type())));

   685       break;

   687     case Bytecodes::_d2i:

   688       push(SharkValue::create_jint(

   689         builder()->CreateCall(

   690           builder()->d2i(), pop()->jdouble_value()), false));

   691       break;

   692     case Bytecodes::_d2l:

   693       push(SharkValue::create_jlong(

   694         builder()->CreateCall(

   695           builder()->d2l(), pop()->jdouble_value()), false));

   696       break;

   697     case Bytecodes::_d2f:

   698       push(SharkValue::create_jfloat(

   699         builder()->CreateFPTrunc(

   700           pop()->jdouble_value(), SharkType::jfloat_type())));

   701       break;

   703     case Bytecodes::_i2b:

   704       push(SharkValue::create_jint(

   705         builder()->CreateAShr(

   706           builder()->CreateShl(

   707             pop()->jint_value(),

   708             LLVMValue::jint_constant(24)),

   709           LLVMValue::jint_constant(24)), false));

   710       break;

   711     case Bytecodes::_i2c:

   712       push(SharkValue::create_jint(

   713         builder()->CreateAnd(

   714             pop()->jint_value(),

   715             LLVMValue::jint_constant(0xffff)), false));

   716       break;

   717     case Bytecodes::_i2s:

   718       push(SharkValue::create_jint(

   719         builder()->CreateAShr(

   720           builder()->CreateShl(

   721             pop()->jint_value(),

   722             LLVMValue::jint_constant(16)),

   723           LLVMValue::jint_constant(16)), false));

   724       break;

   726     case Bytecodes::_return:

   727       do_return(T_VOID);

   728       break;

   729     case Bytecodes::_ireturn:

   730       do_return(T_INT);

   731       break;

   732     case Bytecodes::_lreturn:

   733       do_return(T_LONG);

   734       break;

   735     case Bytecodes::_freturn:

   736       do_return(T_FLOAT);

   737       break;

   738     case Bytecodes::_dreturn:

   739       do_return(T_DOUBLE);

   740       break;

   741     case Bytecodes::_areturn:

   742       do_return(T_OBJECT);

   743       break;

   745     case Bytecodes::_athrow:

   746       do_athrow();

   747       break;

   749     case Bytecodes::_goto:

   750     case Bytecodes::_goto_w:

   751       do_goto();

   752       break;

   754     case Bytecodes::_jsr:

   755     case Bytecodes::_jsr_w:

   756       do_jsr();

   757       break;

   759     case Bytecodes::_ret:

   760       do_ret();

   761       break;

   763     case Bytecodes::_ifnull:

   764       do_if(ICmpInst::ICMP_EQ, SharkValue::null(), pop());

   765       break;

   766     case Bytecodes::_ifnonnull:

   767       do_if(ICmpInst::ICMP_NE, SharkValue::null(), pop());

   768       break;

   769     case Bytecodes::_if_acmpeq:

   770       b = pop();

   771       a = pop();

   772       do_if(ICmpInst::ICMP_EQ, b, a);

   773       break;

   774     case Bytecodes::_if_acmpne:

   775       b = pop();

   776       a = pop();

   777       do_if(ICmpInst::ICMP_NE, b, a);

   778       break;

   779     case Bytecodes::_ifeq:

   780       do_if(ICmpInst::ICMP_EQ, SharkValue::jint_constant(0), pop());

   781       break;

   782     case Bytecodes::_ifne:

   783       do_if(ICmpInst::ICMP_NE, SharkValue::jint_constant(0), pop());

   784       break;

   785     case Bytecodes::_iflt:

   786       do_if(ICmpInst::ICMP_SLT, SharkValue::jint_constant(0), pop());

   787       break;

   788     case Bytecodes::_ifle:

   789       do_if(ICmpInst::ICMP_SLE, SharkValue::jint_constant(0), pop());

   790       break;

   791     case Bytecodes::_ifgt:

   792       do_if(ICmpInst::ICMP_SGT, SharkValue::jint_constant(0), pop());

   793       break;

   794     case Bytecodes::_ifge:

   795       do_if(ICmpInst::ICMP_SGE, SharkValue::jint_constant(0), pop());

   796       break;

   797     case Bytecodes::_if_icmpeq:

   798       b = pop();

   799       a = pop();

   800       do_if(ICmpInst::ICMP_EQ, b, a);

   801       break;

   802     case Bytecodes::_if_icmpne:

   803       b = pop();

   804       a = pop();

   805       do_if(ICmpInst::ICMP_NE, b, a);

   806       break;

   807     case Bytecodes::_if_icmplt:

   808       b = pop();

   809       a = pop();

   810       do_if(ICmpInst::ICMP_SLT, b, a);

   811       break;

   812     case Bytecodes::_if_icmple:

   813       b = pop();

   814       a = pop();

   815       do_if(ICmpInst::ICMP_SLE, b, a);

   816       break;

   817     case Bytecodes::_if_icmpgt:

   818       b = pop();

   819       a = pop();

   820       do_if(ICmpInst::ICMP_SGT, b, a);

   821       break;

   822     case Bytecodes::_if_icmpge:

   823       b = pop();

   824       a = pop();

   825       do_if(ICmpInst::ICMP_SGE, b, a);

   826       break;

   828     case Bytecodes::_tableswitch:

   829     case Bytecodes::_lookupswitch:

   830       do_switch();

   831       break;

   833     case Bytecodes::_invokestatic:

   834     case Bytecodes::_invokespecial:

   835     case Bytecodes::_invokevirtual:

   836     case Bytecodes::_invokeinterface:

   837       do_call();

   838       break;

   840     case Bytecodes::_instanceof:

   841       // This is a very common construct:

   842       //

   843       //  if (object instanceof Klass) {

   844       //    something = (Klass) object;

   845       //    ...

   846       //  }

   847       //

   848       // which gets compiled to something like this:

   849       //

   850       //  28: aload 9

   851       //  30: instanceof <Class Klass>

   852       //  33: ifeq 52

   853       //  36: aload 9

   854       //  38: checkcast <Class Klass>

   855       //

   856       // Handling both bytecodes at once allows us

   857       // to eliminate the checkcast.

   858       if (iter()->next_bci() < limit &&

   859           (iter()->next_bc() == Bytecodes::_ifeq ||

   860            iter()->next_bc() == Bytecodes::_ifne) &&

   861           (!UseLoopSafepoints ||

   862            iter()->next_get_dest() > iter()->next_bci())) {

   863         if (maybe_do_instanceof_if()) {

   864           iter()->next();

   865           if (SharkTraceBytecodes)

   866             tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc()));

   867           break;

   868         }

   869       }

   870       // fall through

   871     case Bytecodes::_checkcast:

   872       do_instance_check();

   873       break;

   875     case Bytecodes::_new:

   876       do_new();

   877       break;

   878     case Bytecodes::_newarray:

   879       do_newarray();

   880       break;

   881     case Bytecodes::_anewarray:

   882       do_anewarray();

   883       break;

   884     case Bytecodes::_multianewarray:

   885       do_multianewarray();

   886       break;

   888     case Bytecodes::_monitorenter:

   889       do_monitorenter();

   890       break;

   891     case Bytecodes::_monitorexit:

   892       do_monitorexit();

   893       break;

   895     default:

   896       ShouldNotReachHere();

   897     }

   898   }

   899 }

   901 SharkState* SharkBlock::initial_current_state() {

   902   return entry_state()->copy();

   903 }

   905 int SharkBlock::switch_default_dest() {

   906   return iter()->get_dest_table(0);

   907 }

   909 int SharkBlock::switch_table_length() {

   910   switch(bc()) {

   911   case Bytecodes::_tableswitch:

   912     return iter()->get_int_table(2) - iter()->get_int_table(1) + 1;

   914   case Bytecodes::_lookupswitch:

   915     return iter()->get_int_table(1);

   917   default:

   918     ShouldNotReachHere();

   919   }

   920 }

   922 int SharkBlock::switch_key(int i) {

   923   switch(bc()) {

   924   case Bytecodes::_tableswitch:

   925     return iter()->get_int_table(1) + i;

   927   case Bytecodes::_lookupswitch:

   928     return iter()->get_int_table(2 + 2 * i);

   930   default:

   931     ShouldNotReachHere();

   932   }

   933 }

   935 int SharkBlock::switch_dest(int i) {

   936   switch(bc()) {

   937   case Bytecodes::_tableswitch:

   938     return iter()->get_dest_table(i + 3);

   940   case Bytecodes::_lookupswitch:

   941     return iter()->get_dest_table(2 + 2 * i + 1);

   943   default:

   944     ShouldNotReachHere();

   945   }

   946 }

   948 void SharkBlock::do_div_or_rem(bool is_long, bool is_rem) {

   949   SharkValue *sb = pop();

   950   SharkValue *sa = pop();

   952   check_divide_by_zero(sb);

   954   Value *a, *b, *p, *q;

   955   if (is_long) {

   956     a = sa->jlong_value();

   957     b = sb->jlong_value();

   958     p = LLVMValue::jlong_constant(0x8000000000000000LL);

   959     q = LLVMValue::jlong_constant(-1);

   960   }

   961   else {

   962     a = sa->jint_value();

   963     b = sb->jint_value();

   964     p = LLVMValue::jint_constant(0x80000000);

   965     q = LLVMValue::jint_constant(-1);

   966   }

   968   BasicBlock *ip           = builder()->GetBlockInsertionPoint();

   969   BasicBlock *special_case = builder()->CreateBlock(ip, "special_case");

   970   BasicBlock *general_case = builder()->CreateBlock(ip, "general_case");

   971   BasicBlock *done         = builder()->CreateBlock(ip, "done");

   973   builder()->CreateCondBr(

   974     builder()->CreateAnd(

   975       builder()->CreateICmpEQ(a, p),

   976       builder()->CreateICmpEQ(b, q)),

   977     special_case, general_case);

   979   builder()->SetInsertPoint(special_case);

   980   Value *special_result;

   981   if (is_rem) {

   982     if (is_long)

   983       special_result = LLVMValue::jlong_constant(0);

   984     else

   985       special_result = LLVMValue::jint_constant(0);

   986   }

   987   else {

   988     special_result = a;

   989   }

   990   builder()->CreateBr(done);

   992   builder()->SetInsertPoint(general_case);

   993   Value *general_result;

   994   if (is_rem)

   995     general_result = builder()->CreateSRem(a, b);

   996   else

   997     general_result = builder()->CreateSDiv(a, b);

   998   builder()->CreateBr(done);

  1000   builder()->SetInsertPoint(done);

  1001   PHINode *result;

  1002   if (is_long)

  1003     result = builder()->CreatePHI(SharkType::jlong_type(), "result");

  1004   else

  1005     result = builder()->CreatePHI(SharkType::jint_type(), "result");

  1006   result->addIncoming(special_result, special_case);

  1007   result->addIncoming(general_result, general_case);

  1009   if (is_long)

  1010     push(SharkValue::create_jlong(result, false));

  1011   else

  1012     push(SharkValue::create_jint(result, false));

  1013 }

  1015 void SharkBlock::do_field_access(bool is_get, bool is_field) {

  1016   bool will_link;

  1017   ciField *field = iter()->get_field(will_link);

  1018   assert(will_link, "typeflow responsibility");

  1019   assert(is_field != field->is_static(), "mismatch");

  1021   // Pop the value off the stack where necessary

  1022   SharkValue *value = NULL;

  1023   if (!is_get)

  1024     value = pop();

  1026   // Find the object we're accessing, if necessary

  1027   Value *object = NULL;

  1028   if (is_field) {

  1029     SharkValue *value = pop();

  1030     check_null(value);

  1031     object = value->generic_value();

  1032   }

  1033   if (is_get && field->is_constant()) {

  1034     SharkConstant *constant = SharkConstant::for_field(iter());

  1035     if (constant->is_loaded())

  1036       value = constant->value(builder());

  1037   }

  1038   if (!is_get || value == NULL) {

  1039     if (!is_field)

  1040       object = builder()->CreateInlineOop(field->holder());

  1042     BasicType   basic_type = field->type()->basic_type();

  1043     const Type *stack_type = SharkType::to_stackType(basic_type);

  1044     const Type *field_type = SharkType::to_arrayType(basic_type);

  1046     Value *addr = builder()->CreateAddressOfStructEntry(

  1047       object, in_ByteSize(field->offset_in_bytes()),

  1048       PointerType::getUnqual(field_type),

  1049       "addr");

  1051     // Do the access

  1052     if (is_get) {

  1053       Value *field_value = builder()->CreateLoad(addr);

  1055       if (field_type != stack_type) {

  1056         field_value = builder()->CreateIntCast(

  1057           field_value, stack_type, basic_type != T_CHAR);

  1058       }

  1060       value = SharkValue::create_generic(field->type(), field_value, false);

  1061     }

  1062     else {

  1063       Value *field_value = value->generic_value();

  1065       if (field_type != stack_type) {

  1066         field_value = builder()->CreateIntCast(

  1067           field_value, field_type, basic_type != T_CHAR);

  1068       }

  1070       builder()->CreateStore(field_value, addr);

  1072       if (!field->type()->is_primitive_type())

  1073         builder()->CreateUpdateBarrierSet(oopDesc::bs(), addr);

  1075       if (field->is_volatile())

  1076         builder()->CreateMemoryBarrier(SharkBuilder::BARRIER_STORELOAD);

  1077     }

  1078   }

  1080   // Push the value onto the stack where necessary

  1081   if (is_get)

  1082     push(value);

  1083 }

  1085 void SharkBlock::do_lcmp() {

  1086   Value *b = pop()->jlong_value();

  1087   Value *a = pop()->jlong_value();

  1089   BasicBlock *ip   = builder()->GetBlockInsertionPoint();

  1090   BasicBlock *ne   = builder()->CreateBlock(ip, "lcmp_ne");

  1091   BasicBlock *lt   = builder()->CreateBlock(ip, "lcmp_lt");

  1092   BasicBlock *gt   = builder()->CreateBlock(ip, "lcmp_gt");

  1093   BasicBlock *done = builder()->CreateBlock(ip, "done");

  1095   BasicBlock *eq = builder()->GetInsertBlock();

  1096   builder()->CreateCondBr(builder()->CreateICmpEQ(a, b), done, ne);

  1098   builder()->SetInsertPoint(ne);

  1099   builder()->CreateCondBr(builder()->CreateICmpSLT(a, b), lt, gt);

  1101   builder()->SetInsertPoint(lt);

  1102   builder()->CreateBr(done);

  1104   builder()->SetInsertPoint(gt);

  1105   builder()->CreateBr(done);

  1107   builder()->SetInsertPoint(done);

  1108   PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");

  1109   result->addIncoming(LLVMValue::jint_constant(-1), lt);

  1110   result->addIncoming(LLVMValue::jint_constant(0),  eq);

  1111   result->addIncoming(LLVMValue::jint_constant(1),  gt);

  1113   push(SharkValue::create_jint(result, false));

  1114 }

  1116 void SharkBlock::do_fcmp(bool is_double, bool unordered_is_greater) {

  1117   Value *a, *b;

  1118   if (is_double) {

  1119     b = pop()->jdouble_value();

  1120     a = pop()->jdouble_value();

  1121   }

  1122   else {

  1123     b = pop()->jfloat_value();

  1124     a = pop()->jfloat_value();

  1125   }

  1127   BasicBlock *ip      = builder()->GetBlockInsertionPoint();

  1128   BasicBlock *ordered = builder()->CreateBlock(ip, "ordered");

  1129   BasicBlock *ge      = builder()->CreateBlock(ip, "fcmp_ge");

  1130   BasicBlock *lt      = builder()->CreateBlock(ip, "fcmp_lt");

  1131   BasicBlock *eq      = builder()->CreateBlock(ip, "fcmp_eq");

  1132   BasicBlock *gt      = builder()->CreateBlock(ip, "fcmp_gt");

  1133   BasicBlock *done    = builder()->CreateBlock(ip, "done");

  1135   builder()->CreateCondBr(

  1136     builder()->CreateFCmpUNO(a, b),

  1137     unordered_is_greater ? gt : lt, ordered);

  1139   builder()->SetInsertPoint(ordered);

  1140   builder()->CreateCondBr(builder()->CreateFCmpULT(a, b), lt, ge);

  1142   builder()->SetInsertPoint(ge);

  1143   builder()->CreateCondBr(builder()->CreateFCmpUGT(a, b), gt, eq);

  1145   builder()->SetInsertPoint(lt);

  1146   builder()->CreateBr(done);

  1148   builder()->SetInsertPoint(gt);

  1149   builder()->CreateBr(done);

  1151   builder()->SetInsertPoint(eq);

  1152   builder()->CreateBr(done);

  1154   builder()->SetInsertPoint(done);

  1155   PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");

  1156   result->addIncoming(LLVMValue::jint_constant(-1), lt);

  1157   result->addIncoming(LLVMValue::jint_constant(0),  eq);

  1158   result->addIncoming(LLVMValue::jint_constant(1),  gt);

  1160   push(SharkValue::create_jint(result, false));

  1161 }

  1163 void SharkBlock::emit_IR() {

  1164   ShouldNotCallThis();

  1165 }

  1167 SharkState* SharkBlock::entry_state() {

  1168   ShouldNotCallThis();

  1169 }

  1171 void SharkBlock::do_zero_check(SharkValue* value) {

  1172   ShouldNotCallThis();

  1173 }

  1175 void SharkBlock::maybe_add_backedge_safepoint() {

  1176   ShouldNotCallThis();

  1177 }

  1179 bool SharkBlock::has_trap() {

  1180   return false;

  1181 }

  1183 int SharkBlock::trap_request() {

  1184   ShouldNotCallThis();

  1185 }

  1187 int SharkBlock::trap_bci() {

  1188   ShouldNotCallThis();

  1189 }

  1191 void SharkBlock::do_trap(int trap_request) {

  1192   ShouldNotCallThis();

  1193 }

  1195 void SharkBlock::do_arraylength() {

  1196   ShouldNotCallThis();

  1197 }

  1199 void SharkBlock::do_aload(BasicType basic_type) {

  1200   ShouldNotCallThis();

  1201 }

  1203 void SharkBlock::do_astore(BasicType basic_type) {

  1204   ShouldNotCallThis();

  1205 }

  1207 void SharkBlock::do_return(BasicType type) {

  1208   ShouldNotCallThis();

  1209 }

  1211 void SharkBlock::do_athrow() {

  1212   ShouldNotCallThis();

  1213 }

  1215 void SharkBlock::do_goto() {

  1216   ShouldNotCallThis();

  1217 }

  1219 void SharkBlock::do_jsr() {

  1220   ShouldNotCallThis();

  1221 }

  1223 void SharkBlock::do_ret() {

  1224   ShouldNotCallThis();

  1225 }

  1227 void SharkBlock::do_if(ICmpInst::Predicate p, SharkValue* b, SharkValue* a) {

  1228   ShouldNotCallThis();

  1229 }

  1231 void SharkBlock::do_switch() {

  1232   ShouldNotCallThis();

  1233 }

  1235 void SharkBlock::do_call() {

  1236   ShouldNotCallThis();

  1237 }

  1239 void SharkBlock::do_instance_check() {

  1240   ShouldNotCallThis();

  1241 }

  1243 bool SharkBlock::maybe_do_instanceof_if() {

  1244   ShouldNotCallThis();

  1245 }

  1247 void SharkBlock::do_new() {

  1248   ShouldNotCallThis();

  1249 }

  1251 void SharkBlock::do_newarray() {

  1252   ShouldNotCallThis();

  1253 }

  1255 void SharkBlock::do_anewarray() {

  1256   ShouldNotCallThis();

  1257 }

  1259 void SharkBlock::do_multianewarray() {

  1260   ShouldNotCallThis();

  1261 }

  1263 void SharkBlock::do_monitorenter() {

  1264   ShouldNotCallThis();

  1265 }

  1267 void SharkBlock::do_monitorexit() {

  1268   ShouldNotCallThis();

  1269 }

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

src/share/vm/shark/sharkBlock.cpp@e863062e521d

src/share/vm/shark/sharkBlock.cpp