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

6976186: integrate Shark HotSpot changes
Summary: Shark is a JIT compiler for Zero that uses the LLVM compiler infrastructure.
Reviewed-by: kvn, twisti
Contributed-by: Gary Benson <gbenson@redhat.com>

     1 /*

     2  * Copyright (c) 1999, 2007, 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 "incls/_precompiled.incl"

    27 #include "incls/_sharkBlock.cpp.incl"

    29 using namespace llvm;

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

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

    33   int i;

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

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

    37   current_state();

    39   // Parse the bytecodes

    40   iter()->reset_to_bci(start);

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

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

    43     iter()->next();

    45     if (SharkTraceBytecodes)

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

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

    49       do_trap(trap_request());

    50       return;

    51     }

    53     if (UseLoopSafepoints) {

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

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

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

    57       switch (bc()) {

    58       case Bytecodes::_goto:

    59       case Bytecodes::_ifnull:

    60       case Bytecodes::_ifnonnull:

    61       case Bytecodes::_if_acmpeq:

    62       case Bytecodes::_if_acmpne:

    63       case Bytecodes::_ifeq:

    64       case Bytecodes::_ifne:

    65       case Bytecodes::_iflt:

    66       case Bytecodes::_ifle:

    67       case Bytecodes::_ifgt:

    68       case Bytecodes::_ifge:

    69       case Bytecodes::_if_icmpeq:

    70       case Bytecodes::_if_icmpne:

    71       case Bytecodes::_if_icmplt:

    72       case Bytecodes::_if_icmple:

    73       case Bytecodes::_if_icmpgt:

    74       case Bytecodes::_if_icmpge:

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

    76           maybe_add_backedge_safepoint();

    77         break;

    79       case Bytecodes::_goto_w:

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

    81           maybe_add_backedge_safepoint();

    82         break;

    84       case Bytecodes::_tableswitch:

    85       case Bytecodes::_lookupswitch:

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

    87           maybe_add_backedge_safepoint();

    88           break;

    89         }

    90         int len = switch_table_length();

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

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

    93             maybe_add_backedge_safepoint();

    94             break;

    95           }

    96         }

    97         break;

    98       }

    99     }

   101     switch (bc()) {

   102     case Bytecodes::_nop:

   103       break;

   105     case Bytecodes::_aconst_null:

   106       push(SharkValue::null());

   107       break;

   109     case Bytecodes::_iconst_m1:

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

   111       break;

   112     case Bytecodes::_iconst_0:

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

   114       break;

   115     case Bytecodes::_iconst_1:

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

   117       break;

   118     case Bytecodes::_iconst_2:

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

   120       break;

   121     case Bytecodes::_iconst_3:

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

   123       break;

   124     case Bytecodes::_iconst_4:

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

   126       break;

   127     case Bytecodes::_iconst_5:

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

   129       break;

   131     case Bytecodes::_lconst_0:

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

   133       break;

   134     case Bytecodes::_lconst_1:

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

   136       break;

   138     case Bytecodes::_fconst_0:

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

   140       break;

   141     case Bytecodes::_fconst_1:

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

   143       break;

   144     case Bytecodes::_fconst_2:

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

   146       break;

   148     case Bytecodes::_dconst_0:

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

   150       break;

   151     case Bytecodes::_dconst_1:

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

   153       break;

   155     case Bytecodes::_bipush:

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

   157       break;

   158     case Bytecodes::_sipush:

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

   160       break;

   162     case Bytecodes::_ldc:

   163     case Bytecodes::_ldc_w:

   164     case Bytecodes::_ldc2_w:

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

   166       break;

   168     case Bytecodes::_iload_0:

   169     case Bytecodes::_lload_0:

   170     case Bytecodes::_fload_0:

   171     case Bytecodes::_dload_0:

   172     case Bytecodes::_aload_0:

   173       push(local(0));

   174       break;

   175     case Bytecodes::_iload_1:

   176     case Bytecodes::_lload_1:

   177     case Bytecodes::_fload_1:

   178     case Bytecodes::_dload_1:

   179     case Bytecodes::_aload_1:

   180       push(local(1));

   181       break;

   182     case Bytecodes::_iload_2:

   183     case Bytecodes::_lload_2:

   184     case Bytecodes::_fload_2:

   185     case Bytecodes::_dload_2:

   186     case Bytecodes::_aload_2:

   187       push(local(2));

   188       break;

   189     case Bytecodes::_iload_3:

   190     case Bytecodes::_lload_3:

   191     case Bytecodes::_fload_3:

   192     case Bytecodes::_dload_3:

   193     case Bytecodes::_aload_3:

   194       push(local(3));

   195       break;

   196     case Bytecodes::_iload:

   197     case Bytecodes::_lload:

   198     case Bytecodes::_fload:

   199     case Bytecodes::_dload:

   200     case Bytecodes::_aload:

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

   202       break;

   204     case Bytecodes::_baload:

   205       do_aload(T_BYTE);

   206       break;

   207     case Bytecodes::_caload:

   208       do_aload(T_CHAR);

   209       break;

   210     case Bytecodes::_saload:

   211       do_aload(T_SHORT);

   212       break;

   213     case Bytecodes::_iaload:

   214       do_aload(T_INT);

   215       break;

   216     case Bytecodes::_laload:

   217       do_aload(T_LONG);

   218       break;

   219     case Bytecodes::_faload:

   220       do_aload(T_FLOAT);

   221       break;

   222     case Bytecodes::_daload:

   223       do_aload(T_DOUBLE);

   224       break;

   225     case Bytecodes::_aaload:

   226       do_aload(T_OBJECT);

   227       break;

   229     case Bytecodes::_istore_0:

   230     case Bytecodes::_lstore_0:

   231     case Bytecodes::_fstore_0:

   232     case Bytecodes::_dstore_0:

   233     case Bytecodes::_astore_0:

   234       set_local(0, pop());

   235       break;

   236     case Bytecodes::_istore_1:

   237     case Bytecodes::_lstore_1:

   238     case Bytecodes::_fstore_1:

   239     case Bytecodes::_dstore_1:

   240     case Bytecodes::_astore_1:

   241       set_local(1, pop());

   242       break;

   243     case Bytecodes::_istore_2:

   244     case Bytecodes::_lstore_2:

   245     case Bytecodes::_fstore_2:

   246     case Bytecodes::_dstore_2:

   247     case Bytecodes::_astore_2:

   248       set_local(2, pop());

   249       break;

   250     case Bytecodes::_istore_3:

   251     case Bytecodes::_lstore_3:

   252     case Bytecodes::_fstore_3:

   253     case Bytecodes::_dstore_3:

   254     case Bytecodes::_astore_3:

   255       set_local(3, pop());

   256       break;

   257     case Bytecodes::_istore:

   258     case Bytecodes::_lstore:

   259     case Bytecodes::_fstore:

   260     case Bytecodes::_dstore:

   261     case Bytecodes::_astore:

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

   263       break;

   265     case Bytecodes::_bastore:

   266       do_astore(T_BYTE);

   267       break;

   268     case Bytecodes::_castore:

   269       do_astore(T_CHAR);

   270       break;

   271     case Bytecodes::_sastore:

   272       do_astore(T_SHORT);

   273       break;

   274     case Bytecodes::_iastore:

   275       do_astore(T_INT);

   276       break;

   277     case Bytecodes::_lastore:

   278       do_astore(T_LONG);

   279       break;

   280     case Bytecodes::_fastore:

   281       do_astore(T_FLOAT);

   282       break;

   283     case Bytecodes::_dastore:

   284       do_astore(T_DOUBLE);

   285       break;

   286     case Bytecodes::_aastore:

   287       do_astore(T_OBJECT);

   288       break;

   290     case Bytecodes::_pop:

   291       xpop();

   292       break;

   293     case Bytecodes::_pop2:

   294       xpop();

   295       xpop();

   296       break;

   297     case Bytecodes::_swap:

   298       a = xpop();

   299       b = xpop();

   300       xpush(a);

   301       xpush(b);

   302       break;

   303     case Bytecodes::_dup:

   304       a = xpop();

   305       xpush(a);

   306       xpush(a);

   307       break;

   308     case Bytecodes::_dup_x1:

   309       a = xpop();

   310       b = xpop();

   311       xpush(a);

   312       xpush(b);

   313       xpush(a);

   314       break;

   315     case Bytecodes::_dup_x2:

   316       a = xpop();

   317       b = xpop();

   318       c = xpop();

   319       xpush(a);

   320       xpush(c);

   321       xpush(b);

   322       xpush(a);

   323       break;

   324     case Bytecodes::_dup2:

   325       a = xpop();

   326       b = xpop();

   327       xpush(b);

   328       xpush(a);

   329       xpush(b);

   330       xpush(a);

   331       break;

   332     case Bytecodes::_dup2_x1:

   333       a = xpop();

   334       b = xpop();

   335       c = xpop();

   336       xpush(b);

   337       xpush(a);

   338       xpush(c);

   339       xpush(b);

   340       xpush(a);

   341       break;

   342     case Bytecodes::_dup2_x2:

   343       a = xpop();

   344       b = xpop();

   345       c = xpop();

   346       d = xpop();

   347       xpush(b);

   348       xpush(a);

   349       xpush(d);

   350       xpush(c);

   351       xpush(b);

   352       xpush(a);

   353       break;

   355     case Bytecodes::_arraylength:

   356       do_arraylength();

   357       break;

   359     case Bytecodes::_getfield:

   360       do_getfield();

   361       break;

   362     case Bytecodes::_getstatic:

   363       do_getstatic();

   364       break;

   365     case Bytecodes::_putfield:

   366       do_putfield();

   367       break;

   368     case Bytecodes::_putstatic:

   369       do_putstatic();

   370       break;

   372     case Bytecodes::_iadd:

   373       b = pop();

   374       a = pop();

   375       push(SharkValue::create_jint(

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

   377       break;

   378     case Bytecodes::_isub:

   379       b = pop();

   380       a = pop();

   381       push(SharkValue::create_jint(

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

   383       break;

   384     case Bytecodes::_imul:

   385       b = pop();

   386       a = pop();

   387       push(SharkValue::create_jint(

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

   389       break;

   390     case Bytecodes::_idiv:

   391       do_idiv();

   392       break;

   393     case Bytecodes::_irem:

   394       do_irem();

   395       break;

   396     case Bytecodes::_ineg:

   397       a = pop();

   398       push(SharkValue::create_jint(

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

   400       break;

   401     case Bytecodes::_ishl:

   402       b = pop();

   403       a = pop();

   404       push(SharkValue::create_jint(

   405         builder()->CreateShl(

   406           a->jint_value(),

   407           builder()->CreateAnd(

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

   409       break;

   410     case Bytecodes::_ishr:

   411       b = pop();

   412       a = pop();

   413       push(SharkValue::create_jint(

   414         builder()->CreateAShr(

   415           a->jint_value(),

   416           builder()->CreateAnd(

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

   418       break;

   419     case Bytecodes::_iushr:

   420       b = pop();

   421       a = pop();

   422       push(SharkValue::create_jint(

   423         builder()->CreateLShr(

   424           a->jint_value(),

   425           builder()->CreateAnd(

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

   427       break;

   428     case Bytecodes::_iand:

   429       b = pop();

   430       a = pop();

   431       push(SharkValue::create_jint(

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

   433       break;

   434     case Bytecodes::_ior:

   435       b = pop();

   436       a = pop();

   437       push(SharkValue::create_jint(

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

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

   440       break;

   441     case Bytecodes::_ixor:

   442       b = pop();

   443       a = pop();

   444       push(SharkValue::create_jint(

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

   446       break;

   448     case Bytecodes::_ladd:

   449       b = pop();

   450       a = pop();

   451       push(SharkValue::create_jlong(

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

   453       break;

   454     case Bytecodes::_lsub:

   455       b = pop();

   456       a = pop();

   457       push(SharkValue::create_jlong(

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

   459       break;

   460     case Bytecodes::_lmul:

   461       b = pop();

   462       a = pop();

   463       push(SharkValue::create_jlong(

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

   465       break;

   466     case Bytecodes::_ldiv:

   467       do_ldiv();

   468       break;

   469     case Bytecodes::_lrem:

   470       do_lrem();

   471       break;

   472     case Bytecodes::_lneg:

   473       a = pop();

   474       push(SharkValue::create_jlong(

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

   476       break;

   477     case Bytecodes::_lshl:

   478       b = pop();

   479       a = pop();

   480       push(SharkValue::create_jlong(

   481         builder()->CreateShl(

   482           a->jlong_value(),

   483           builder()->CreateIntCast(

   484             builder()->CreateAnd(

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

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

   487       break;

   488     case Bytecodes::_lshr:

   489       b = pop();

   490       a = pop();

   491       push(SharkValue::create_jlong(

   492         builder()->CreateAShr(

   493           a->jlong_value(),

   494           builder()->CreateIntCast(

   495             builder()->CreateAnd(

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

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

   498       break;

   499     case Bytecodes::_lushr:

   500       b = pop();

   501       a = pop();

   502       push(SharkValue::create_jlong(

   503         builder()->CreateLShr(

   504           a->jlong_value(),

   505           builder()->CreateIntCast(

   506             builder()->CreateAnd(

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

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

   509       break;

   510     case Bytecodes::_land:

   511       b = pop();

   512       a = pop();

   513       push(SharkValue::create_jlong(

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

   515       break;

   516     case Bytecodes::_lor:

   517       b = pop();

   518       a = pop();

   519       push(SharkValue::create_jlong(

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

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

   522       break;

   523     case Bytecodes::_lxor:

   524       b = pop();

   525       a = pop();

   526       push(SharkValue::create_jlong(

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

   528       break;

   530     case Bytecodes::_fadd:

   531       b = pop();

   532       a = pop();

   533       push(SharkValue::create_jfloat(

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

   535       break;

   536     case Bytecodes::_fsub:

   537       b = pop();

   538       a = pop();

   539       push(SharkValue::create_jfloat(

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

   541       break;

   542     case Bytecodes::_fmul:

   543       b = pop();

   544       a = pop();

   545       push(SharkValue::create_jfloat(

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

   547       break;

   548     case Bytecodes::_fdiv:

   549       b = pop();

   550       a = pop();

   551       push(SharkValue::create_jfloat(

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

   553       break;

   554     case Bytecodes::_frem:

   555       b = pop();

   556       a = pop();

   557       push(SharkValue::create_jfloat(

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

   559       break;

   560     case Bytecodes::_fneg:

   561       a = pop();

   562       push(SharkValue::create_jfloat(

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

   564       break;

   566     case Bytecodes::_dadd:

   567       b = pop();

   568       a = pop();

   569       push(SharkValue::create_jdouble(

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

   571       break;

   572     case Bytecodes::_dsub:

   573       b = pop();

   574       a = pop();

   575       push(SharkValue::create_jdouble(

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

   577       break;

   578     case Bytecodes::_dmul:

   579       b = pop();

   580       a = pop();

   581       push(SharkValue::create_jdouble(

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

   583       break;

   584     case Bytecodes::_ddiv:

   585       b = pop();

   586       a = pop();

   587       push(SharkValue::create_jdouble(

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

   589       break;

   590     case Bytecodes::_drem:

   591       b = pop();

   592       a = pop();

   593       push(SharkValue::create_jdouble(

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

   595       break;

   596     case Bytecodes::_dneg:

   597       a = pop();

   598       push(SharkValue::create_jdouble(

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

   600       break;

   602     case Bytecodes::_iinc:

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

   604       set_local(

   605         i,

   606         SharkValue::create_jint(

   607           builder()->CreateAdd(

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

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

   610       break;

   612     case Bytecodes::_lcmp:

   613       do_lcmp();

   614       break;

   616     case Bytecodes::_fcmpl:

   617       do_fcmp(false, false);

   618       break;

   619     case Bytecodes::_fcmpg:

   620       do_fcmp(false, true);

   621       break;

   622     case Bytecodes::_dcmpl:

   623       do_fcmp(true, false);

   624       break;

   625     case Bytecodes::_dcmpg:

   626       do_fcmp(true, true);

   627       break;

   629     case Bytecodes::_i2l:

   630       a = pop();

   631       push(SharkValue::create_jlong(

   632         builder()->CreateIntCast(

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

   634       break;

   635     case Bytecodes::_i2f:

   636       push(SharkValue::create_jfloat(

   637         builder()->CreateSIToFP(

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

   639       break;

   640     case Bytecodes::_i2d:

   641       push(SharkValue::create_jdouble(

   642         builder()->CreateSIToFP(

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

   644       break;

   646     case Bytecodes::_l2i:

   647       push(SharkValue::create_jint(

   648         builder()->CreateIntCast(

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

   650       break;

   651     case Bytecodes::_l2f:

   652       push(SharkValue::create_jfloat(

   653         builder()->CreateSIToFP(

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

   655       break;

   656     case Bytecodes::_l2d:

   657       push(SharkValue::create_jdouble(

   658         builder()->CreateSIToFP(

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

   660       break;

   662     case Bytecodes::_f2i:

   663       push(SharkValue::create_jint(

   664         builder()->CreateCall(

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

   666       break;

   667     case Bytecodes::_f2l:

   668       push(SharkValue::create_jlong(

   669         builder()->CreateCall(

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

   671       break;

   672     case Bytecodes::_f2d:

   673       push(SharkValue::create_jdouble(

   674         builder()->CreateFPExt(

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

   676       break;

   678     case Bytecodes::_d2i:

   679       push(SharkValue::create_jint(

   680         builder()->CreateCall(

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

   682       break;

   683     case Bytecodes::_d2l:

   684       push(SharkValue::create_jlong(

   685         builder()->CreateCall(

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

   687       break;

   688     case Bytecodes::_d2f:

   689       push(SharkValue::create_jfloat(

   690         builder()->CreateFPTrunc(

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

   692       break;

   694     case Bytecodes::_i2b:

   695       push(SharkValue::create_jint(

   696         builder()->CreateAShr(

   697           builder()->CreateShl(

   698             pop()->jint_value(),

   699             LLVMValue::jint_constant(24)),

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

   701       break;

   702     case Bytecodes::_i2c:

   703       push(SharkValue::create_jint(

   704         builder()->CreateAnd(

   705             pop()->jint_value(),

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

   707       break;

   708     case Bytecodes::_i2s:

   709       push(SharkValue::create_jint(

   710         builder()->CreateAShr(

   711           builder()->CreateShl(

   712             pop()->jint_value(),

   713             LLVMValue::jint_constant(16)),

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

   715       break;

   717     case Bytecodes::_return:

   718       do_return(T_VOID);

   719       break;

   720     case Bytecodes::_ireturn:

   721       do_return(T_INT);

   722       break;

   723     case Bytecodes::_lreturn:

   724       do_return(T_LONG);

   725       break;

   726     case Bytecodes::_freturn:

   727       do_return(T_FLOAT);

   728       break;

   729     case Bytecodes::_dreturn:

   730       do_return(T_DOUBLE);

   731       break;

   732     case Bytecodes::_areturn:

   733       do_return(T_OBJECT);

   734       break;

   736     case Bytecodes::_athrow:

   737       do_athrow();

   738       break;

   740     case Bytecodes::_goto:

   741     case Bytecodes::_goto_w:

   742       do_goto();

   743       break;

   745     case Bytecodes::_jsr:

   746     case Bytecodes::_jsr_w:

   747       do_jsr();

   748       break;

   750     case Bytecodes::_ret:

   751       do_ret();

   752       break;

   754     case Bytecodes::_ifnull:

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

   756       break;

   757     case Bytecodes::_ifnonnull:

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

   759       break;

   760     case Bytecodes::_if_acmpeq:

   761       b = pop();

   762       a = pop();

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

   764       break;

   765     case Bytecodes::_if_acmpne:

   766       b = pop();

   767       a = pop();

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

   769       break;

   770     case Bytecodes::_ifeq:

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

   772       break;

   773     case Bytecodes::_ifne:

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

   775       break;

   776     case Bytecodes::_iflt:

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

   778       break;

   779     case Bytecodes::_ifle:

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

   781       break;

   782     case Bytecodes::_ifgt:

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

   784       break;

   785     case Bytecodes::_ifge:

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

   787       break;

   788     case Bytecodes::_if_icmpeq:

   789       b = pop();

   790       a = pop();

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

   792       break;

   793     case Bytecodes::_if_icmpne:

   794       b = pop();

   795       a = pop();

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

   797       break;

   798     case Bytecodes::_if_icmplt:

   799       b = pop();

   800       a = pop();

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

   802       break;

   803     case Bytecodes::_if_icmple:

   804       b = pop();

   805       a = pop();

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

   807       break;

   808     case Bytecodes::_if_icmpgt:

   809       b = pop();

   810       a = pop();

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

   812       break;

   813     case Bytecodes::_if_icmpge:

   814       b = pop();

   815       a = pop();

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

   817       break;

   819     case Bytecodes::_tableswitch:

   820     case Bytecodes::_lookupswitch:

   821       do_switch();

   822       break;

   824     case Bytecodes::_invokestatic:

   825     case Bytecodes::_invokespecial:

   826     case Bytecodes::_invokevirtual:

   827     case Bytecodes::_invokeinterface:

   828       do_call();

   829       break;

   831     case Bytecodes::_instanceof:

   832       // This is a very common construct:

   833       //

   834       //  if (object instanceof Klass) {

   835       //    something = (Klass) object;

   836       //    ...

   837       //  }

   838       //

   839       // which gets compiled to something like this:

   840       //

   841       //  28: aload 9

   842       //  30: instanceof <Class Klass>

   843       //  33: ifeq 52

   844       //  36: aload 9

   845       //  38: checkcast <Class Klass>

   846       //

   847       // Handling both bytecodes at once allows us

   848       // to eliminate the checkcast.

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

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

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

   852           (!UseLoopSafepoints ||

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

   854         if (maybe_do_instanceof_if()) {

   855           iter()->next();

   856           if (SharkTraceBytecodes)

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

   858           break;

   859         }

   860       }

   861       // fall through

   862     case Bytecodes::_checkcast:

   863       do_instance_check();

   864       break;

   866     case Bytecodes::_new:

   867       do_new();

   868       break;

   869     case Bytecodes::_newarray:

   870       do_newarray();

   871       break;

   872     case Bytecodes::_anewarray:

   873       do_anewarray();

   874       break;

   875     case Bytecodes::_multianewarray:

   876       do_multianewarray();

   877       break;

   879     case Bytecodes::_monitorenter:

   880       do_monitorenter();

   881       break;

   882     case Bytecodes::_monitorexit:

   883       do_monitorexit();

   884       break;

   886     default:

   887       ShouldNotReachHere();

   888     }

   889   }

   890 }

   892 SharkState* SharkBlock::initial_current_state() {

   893   return entry_state()->copy();

   894 }

   896 int SharkBlock::switch_default_dest() {

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

   898 }

   900 int SharkBlock::switch_table_length() {

   901   switch(bc()) {

   902   case Bytecodes::_tableswitch:

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

   905   case Bytecodes::_lookupswitch:

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

   908   default:

   909     ShouldNotReachHere();

   910   }

   911 }

   913 int SharkBlock::switch_key(int i) {

   914   switch(bc()) {

   915   case Bytecodes::_tableswitch:

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

   918   case Bytecodes::_lookupswitch:

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

   921   default:

   922     ShouldNotReachHere();

   923   }

   924 }

   926 int SharkBlock::switch_dest(int i) {

   927   switch(bc()) {

   928   case Bytecodes::_tableswitch:

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

   931   case Bytecodes::_lookupswitch:

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

   934   default:

   935     ShouldNotReachHere();

   936   }

   937 }

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

   940   SharkValue *sb = pop();

   941   SharkValue *sa = pop();

   943   check_divide_by_zero(sb);

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

   946   if (is_long) {

   947     a = sa->jlong_value();

   948     b = sb->jlong_value();

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

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

   951   }

   952   else {

   953     a = sa->jint_value();

   954     b = sb->jint_value();

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

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

   957   }

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

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

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

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

   964   builder()->CreateCondBr(

   965     builder()->CreateAnd(

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

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

   968     special_case, general_case);

   970   builder()->SetInsertPoint(special_case);

   971   Value *special_result;

   972   if (is_rem) {

   973     if (is_long)

   974       special_result = LLVMValue::jlong_constant(0);

   975     else

   976       special_result = LLVMValue::jint_constant(0);

   977   }

   978   else {

   979     special_result = a;

   980   }

   981   builder()->CreateBr(done);

   983   builder()->SetInsertPoint(general_case);

   984   Value *general_result;

   985   if (is_rem)

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

   987   else

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

   989   builder()->CreateBr(done);

   991   builder()->SetInsertPoint(done);

   992   PHINode *result;

   993   if (is_long)

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

   995   else

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

   997   result->addIncoming(special_result, special_case);

   998   result->addIncoming(general_result, general_case);

  1000   if (is_long)

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

  1002   else

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

  1004 }

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

  1007   bool will_link;

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

  1009   assert(will_link, "typeflow responsibility");

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

  1012   // Pop the value off the stack where necessary

  1013   SharkValue *value = NULL;

  1014   if (!is_get)

  1015     value = pop();

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

  1018   Value *object = NULL;

  1019   if (is_field) {

  1020     SharkValue *value = pop();

  1021     check_null(value);

  1022     object = value->generic_value();

  1023   }

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

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

  1026     if (constant->is_loaded())

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

  1028   }

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

  1030     if (!is_field)

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

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

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

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

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

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

  1039       PointerType::getUnqual(field_type),

  1040       "addr");

  1042     // Do the access

  1043     if (is_get) {

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

  1046       if (field_type != stack_type) {

  1047         field_value = builder()->CreateIntCast(

  1048           field_value, stack_type, basic_type != T_CHAR);

  1049       }

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

  1052     }

  1053     else {

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

  1056       if (field_type != stack_type) {

  1057         field_value = builder()->CreateIntCast(

  1058           field_value, field_type, basic_type != T_CHAR);

  1059       }

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

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

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

  1066       if (field->is_volatile())

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

  1068     }

  1069   }

  1071   // Push the value onto the stack where necessary

  1072   if (is_get)

  1073     push(value);

  1074 }

  1076 void SharkBlock::do_lcmp() {

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

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

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

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

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

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

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

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

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

  1089   builder()->SetInsertPoint(ne);

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

  1092   builder()->SetInsertPoint(lt);

  1093   builder()->CreateBr(done);

  1095   builder()->SetInsertPoint(gt);

  1096   builder()->CreateBr(done);

  1098   builder()->SetInsertPoint(done);

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

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

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

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

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

  1105 }

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

  1108   Value *a, *b;

  1109   if (is_double) {

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

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

  1112   }

  1113   else {

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

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

  1116   }

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

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

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

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

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

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

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

  1126   builder()->CreateCondBr(

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

  1128     unordered_is_greater ? gt : lt, ordered);

  1130   builder()->SetInsertPoint(ordered);

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

  1133   builder()->SetInsertPoint(ge);

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

  1136   builder()->SetInsertPoint(lt);

  1137   builder()->CreateBr(done);

  1139   builder()->SetInsertPoint(gt);

  1140   builder()->CreateBr(done);

  1142   builder()->SetInsertPoint(eq);

  1143   builder()->CreateBr(done);

  1145   builder()->SetInsertPoint(done);

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

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

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

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

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

  1152 }

  1154 void SharkBlock::emit_IR() {

  1155   ShouldNotCallThis();

  1156 }

  1158 SharkState* SharkBlock::entry_state() {

  1159   ShouldNotCallThis();

  1160 }

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

  1163   ShouldNotCallThis();

  1164 }

  1166 void SharkBlock::maybe_add_backedge_safepoint() {

  1167   ShouldNotCallThis();

  1168 }

  1170 bool SharkBlock::has_trap() {

  1171   return false;

  1172 }

  1174 int SharkBlock::trap_request() {

  1175   ShouldNotCallThis();

  1176 }

  1178 int SharkBlock::trap_bci() {

  1179   ShouldNotCallThis();

  1180 }

  1182 void SharkBlock::do_trap(int trap_request) {

  1183   ShouldNotCallThis();

  1184 }

  1186 void SharkBlock::do_arraylength() {

  1187   ShouldNotCallThis();

  1188 }

  1190 void SharkBlock::do_aload(BasicType basic_type) {

  1191   ShouldNotCallThis();

  1192 }

  1194 void SharkBlock::do_astore(BasicType basic_type) {

  1195   ShouldNotCallThis();

  1196 }

  1198 void SharkBlock::do_return(BasicType type) {

  1199   ShouldNotCallThis();

  1200 }

  1202 void SharkBlock::do_athrow() {

  1203   ShouldNotCallThis();

  1204 }

  1206 void SharkBlock::do_goto() {

  1207   ShouldNotCallThis();

  1208 }

  1210 void SharkBlock::do_jsr() {

  1211   ShouldNotCallThis();

  1212 }

  1214 void SharkBlock::do_ret() {

  1215   ShouldNotCallThis();

  1216 }

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

  1219   ShouldNotCallThis();

  1220 }

  1222 void SharkBlock::do_switch() {

  1223   ShouldNotCallThis();

  1224 }

  1226 void SharkBlock::do_call() {

  1227   ShouldNotCallThis();

  1228 }

  1230 void SharkBlock::do_instance_check() {

  1231   ShouldNotCallThis();

  1232 }

  1234 bool SharkBlock::maybe_do_instanceof_if() {

  1235   ShouldNotCallThis();

  1236 }

  1238 void SharkBlock::do_new() {

  1239   ShouldNotCallThis();

  1240 }

  1242 void SharkBlock::do_newarray() {

  1243   ShouldNotCallThis();

  1244 }

  1246 void SharkBlock::do_anewarray() {

  1247   ShouldNotCallThis();

  1248 }

  1250 void SharkBlock::do_multianewarray() {

  1251   ShouldNotCallThis();

  1252 }

  1254 void SharkBlock::do_monitorenter() {

  1255   ShouldNotCallThis();

  1256 }

  1258 void SharkBlock::do_monitorexit() {

  1259   ShouldNotCallThis();

  1260 }

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

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

src/share/vm/shark/sharkBlock.cpp