1 /*

     2  * Copyright 2000-2006 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_c1_LIR.cpp.incl"

    27 

    28 Register LIR_OprDesc::as_register() const {

    29   return FrameMap::cpu_rnr2reg(cpu_regnr());

    30 }

    31 

    32 Register LIR_OprDesc::as_register_lo() const {

    33   return FrameMap::cpu_rnr2reg(cpu_regnrLo());

    34 }

    35 

    36 Register LIR_OprDesc::as_register_hi() const {

    37   return FrameMap::cpu_rnr2reg(cpu_regnrHi());

    38 }

    39 

    40 #ifdef IA32

    41 

    42 XMMRegister LIR_OprDesc::as_xmm_float_reg() const {

    43   return FrameMap::nr2xmmreg(xmm_regnr());

    44 }

    45 

    46 XMMRegister LIR_OprDesc::as_xmm_double_reg() const {

    47   assert(xmm_regnrLo() == xmm_regnrHi(), "assumed in calculation");

    48   return FrameMap::nr2xmmreg(xmm_regnrLo());

    49 }

    50 

    51 #endif

    52 

    53 

    54 #ifdef SPARC

    55 

    56 FloatRegister LIR_OprDesc::as_float_reg() const {

    57   return FrameMap::nr2floatreg(fpu_regnr());

    58 }

    59 

    60 FloatRegister LIR_OprDesc::as_double_reg() const {

    61   return FrameMap::nr2floatreg(fpu_regnrHi());

    62 }

    63 

    64 #endif

    65 

    66 LIR_Opr LIR_OprFact::illegalOpr = LIR_OprFact::illegal();

    67 

    68 LIR_Opr LIR_OprFact::value_type(ValueType* type) {

    69   ValueTag tag = type->tag();

    70   switch (tag) {

    71   case objectTag : {

    72     ClassConstant* c = type->as_ClassConstant();

    73     if (c != NULL && !c->value()->is_loaded()) {

    74       return LIR_OprFact::oopConst(NULL);

    75     } else {

    76       return LIR_OprFact::oopConst(type->as_ObjectType()->encoding());

    77     }

    78   }

    79   case addressTag: return LIR_OprFact::intConst(type->as_AddressConstant()->value());

    80   case intTag    : return LIR_OprFact::intConst(type->as_IntConstant()->value());

    81   case floatTag  : return LIR_OprFact::floatConst(type->as_FloatConstant()->value());

    82   case longTag   : return LIR_OprFact::longConst(type->as_LongConstant()->value());

    83   case doubleTag : return LIR_OprFact::doubleConst(type->as_DoubleConstant()->value());

    84   default: ShouldNotReachHere();

    85   }

    86 }

    87 

    88 

    89 LIR_Opr LIR_OprFact::dummy_value_type(ValueType* type) {

    90   switch (type->tag()) {

    91     case objectTag: return LIR_OprFact::oopConst(NULL);

    92     case addressTag:

    93     case intTag:    return LIR_OprFact::intConst(0);

    94     case floatTag:  return LIR_OprFact::floatConst(0.0);

    95     case longTag:   return LIR_OprFact::longConst(0);

    96     case doubleTag: return LIR_OprFact::doubleConst(0.0);

    97     default:        ShouldNotReachHere();

    98   }

    99   return illegalOpr;

   100 }

   101 

   102 

   103 

   104 //---------------------------------------------------

   105 

   106 

   107 LIR_Address::Scale LIR_Address::scale(BasicType type) {

   108   int elem_size = type2aelembytes[type];

   109   switch (elem_size) {

   110   case 1: return LIR_Address::times_1;

   111   case 2: return LIR_Address::times_2;

   112   case 4: return LIR_Address::times_4;

   113   case 8: return LIR_Address::times_8;

   114   }

   115   ShouldNotReachHere();

   116   return LIR_Address::times_1;

   117 }

   118 

   119 

   120 #ifndef PRODUCT

   121 void LIR_Address::verify() const {

   122 #ifdef SPARC

   123   assert(scale() == times_1, "Scaled addressing mode not available on SPARC and should not be used");

   124   assert(disp() == 0 || index()->is_illegal(), "can't have both");

   125 #endif

   126 #ifdef _LP64

   127   assert(base()->is_cpu_register(), "wrong base operand");

   128   assert(index()->is_illegal() || index()->is_double_cpu(), "wrong index operand");

   129   assert(base()->type() == T_OBJECT || base()->type() == T_LONG,

   130          "wrong type for addresses");

   131 #else

   132   assert(base()->is_single_cpu(), "wrong base operand");

   133   assert(index()->is_illegal() || index()->is_single_cpu(), "wrong index operand");

   134   assert(base()->type() == T_OBJECT || base()->type() == T_INT,

   135          "wrong type for addresses");

   136 #endif

   137 }

   138 #endif

   139 

   140 

   141 //---------------------------------------------------

   142 

   143 char LIR_OprDesc::type_char(BasicType t) {

   144   switch (t) {

   145     case T_ARRAY:

   146       t = T_OBJECT;

   147     case T_BOOLEAN:

   148     case T_CHAR:

   149     case T_FLOAT:

   150     case T_DOUBLE:

   151     case T_BYTE:

   152     case T_SHORT:

   153     case T_INT:

   154     case T_LONG:

   155     case T_OBJECT:

   156     case T_ADDRESS:

   157     case T_VOID:

   158       return ::type2char(t);

   159 

   160     case T_ILLEGAL:

   161       return '?';

   162 

   163     default:

   164       ShouldNotReachHere();

   165   }

   166 }

   167 

   168 #ifndef PRODUCT

   169 void LIR_OprDesc::validate_type() const {

   170 

   171 #ifdef ASSERT

   172   if (!is_pointer() && !is_illegal()) {

   173     switch (as_BasicType(type_field())) {

   174     case T_LONG:

   175       assert((kind_field() == cpu_register || kind_field() == stack_value) && size_field() == double_size, "must match");

   176       break;

   177     case T_FLOAT:

   178       assert((kind_field() == fpu_register || kind_field() == stack_value) && size_field() == single_size, "must match");

   179       break;

   180     case T_DOUBLE:

   181       assert((kind_field() == fpu_register || kind_field() == stack_value) && size_field() == double_size, "must match");

   182       break;

   183     case T_BOOLEAN:

   184     case T_CHAR:

   185     case T_BYTE:

   186     case T_SHORT:

   187     case T_INT:

   188     case T_OBJECT:

   189     case T_ARRAY:

   190       assert((kind_field() == cpu_register || kind_field() == stack_value) && size_field() == single_size, "must match");

   191       break;

   192 

   193     case T_ILLEGAL:

   194       // XXX TKR also means unknown right now

   195       // assert(is_illegal(), "must match");

   196       break;

   197 

   198     default:

   199       ShouldNotReachHere();

   200     }

   201   }

   202 #endif

   203 

   204 }

   205 #endif // PRODUCT

   206 

   207 

   208 bool LIR_OprDesc::is_oop() const {

   209   if (is_pointer()) {

   210     return pointer()->is_oop_pointer();

   211   } else {

   212     OprType t= type_field();

   213     assert(t != unknown_type, "not set");

   214     return t == object_type;

   215   }

   216 }

   217 

   218 

   219 

   220 void LIR_Op2::verify() const {

   221 #ifdef ASSERT

   222   switch (code()) {

   223     case lir_cmove:

   224       break;

   225 

   226     default:

   227       assert(!result_opr()->is_register() || !result_opr()->is_oop_register(),

   228              "can't produce oops from arith");

   229   }

   230 

   231   if (TwoOperandLIRForm) {

   232     switch (code()) {

   233     case lir_add:

   234     case lir_sub:

   235     case lir_mul:

   236     case lir_mul_strictfp:

   237     case lir_div:

   238     case lir_div_strictfp:

   239     case lir_rem:

   240     case lir_logic_and:

   241     case lir_logic_or:

   242     case lir_logic_xor:

   243     case lir_shl:

   244     case lir_shr:

   245       assert(in_opr1() == result_opr(), "opr1 and result must match");

   246       assert(in_opr1()->is_valid() && in_opr2()->is_valid(), "must be valid");

   247       break;

   248 

   249     // special handling for lir_ushr because of write barriers

   250     case lir_ushr:

   251       assert(in_opr1() == result_opr() || in_opr2()->is_constant(), "opr1 and result must match or shift count is constant");

   252       assert(in_opr1()->is_valid() && in_opr2()->is_valid(), "must be valid");

   253       break;

   254 

   255     }

   256   }

   257 #endif

   258 }

   259 

   260 

   261 LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block)

   262   : LIR_Op(lir_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)

   263   , _cond(cond)

   264   , _type(type)

   265   , _label(block->label())

   266   , _block(block)

   267   , _ublock(NULL)

   268   , _stub(NULL) {

   269 }

   270 

   271 LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, CodeStub* stub) :

   272   LIR_Op(lir_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)

   273   , _cond(cond)

   274   , _type(type)

   275   , _label(stub->entry())

   276   , _block(NULL)

   277   , _ublock(NULL)

   278   , _stub(stub) {

   279 }

   280 

   281 LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block, BlockBegin* ublock)

   282   : LIR_Op(lir_cond_float_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)

   283   , _cond(cond)

   284   , _type(type)

   285   , _label(block->label())

   286   , _block(block)

   287   , _ublock(ublock)

   288   , _stub(NULL)

   289 {

   290 }

   291 

   292 void LIR_OpBranch::change_block(BlockBegin* b) {

   293   assert(_block != NULL, "must have old block");

   294   assert(_block->label() == label(), "must be equal");

   295 

   296   _block = b;

   297   _label = b->label();

   298 }

   299 

   300 void LIR_OpBranch::change_ublock(BlockBegin* b) {

   301   assert(_ublock != NULL, "must have old block");

   302   _ublock = b;

   303 }

   304 

   305 void LIR_OpBranch::negate_cond() {

   306   switch (_cond) {

   307     case lir_cond_equal:        _cond = lir_cond_notEqual;     break;

   308     case lir_cond_notEqual:     _cond = lir_cond_equal;        break;

   309     case lir_cond_less:         _cond = lir_cond_greaterEqual; break;

   310     case lir_cond_lessEqual:    _cond = lir_cond_greater;      break;

   311     case lir_cond_greaterEqual: _cond = lir_cond_less;         break;

   312     case lir_cond_greater:      _cond = lir_cond_lessEqual;    break;

   313     default: ShouldNotReachHere();

   314   }

   315 }

   316 

   317 

   318 LIR_OpTypeCheck::LIR_OpTypeCheck(LIR_Code code, LIR_Opr result, LIR_Opr object, ciKlass* klass,

   319                                  LIR_Opr tmp1, LIR_Opr tmp2, LIR_Opr tmp3,

   320                                  bool fast_check, CodeEmitInfo* info_for_exception, CodeEmitInfo* info_for_patch,

   321                                  CodeStub* stub,

   322                                  ciMethod* profiled_method,

   323                                  int profiled_bci)

   324   : LIR_Op(code, result, NULL)

   325   , _object(object)

   326   , _array(LIR_OprFact::illegalOpr)

   327   , _klass(klass)

   328   , _tmp1(tmp1)

   329   , _tmp2(tmp2)

   330   , _tmp3(tmp3)

   331   , _fast_check(fast_check)

   332   , _stub(stub)

   333   , _info_for_patch(info_for_patch)

   334   , _info_for_exception(info_for_exception)

   335   , _profiled_method(profiled_method)

   336   , _profiled_bci(profiled_bci) {

   337   if (code == lir_checkcast) {

   338     assert(info_for_exception != NULL, "checkcast throws exceptions");

   339   } else if (code == lir_instanceof) {

   340     assert(info_for_exception == NULL, "instanceof throws no exceptions");

   341   } else {

   342     ShouldNotReachHere();

   343   }

   344 }

   345 

   346 

   347 

   348 LIR_OpTypeCheck::LIR_OpTypeCheck(LIR_Code code, LIR_Opr object, LIR_Opr array, LIR_Opr tmp1, LIR_Opr tmp2, LIR_Opr tmp3, CodeEmitInfo* info_for_exception, ciMethod* profiled_method, int profiled_bci)

   349   : LIR_Op(code, LIR_OprFact::illegalOpr, NULL)

   350   , _object(object)

   351   , _array(array)

   352   , _klass(NULL)

   353   , _tmp1(tmp1)

   354   , _tmp2(tmp2)

   355   , _tmp3(tmp3)

   356   , _fast_check(false)

   357   , _stub(NULL)

   358   , _info_for_patch(NULL)

   359   , _info_for_exception(info_for_exception)

   360   , _profiled_method(profiled_method)

   361   , _profiled_bci(profiled_bci) {

   362   if (code == lir_store_check) {

   363     _stub = new ArrayStoreExceptionStub(info_for_exception);

   364     assert(info_for_exception != NULL, "store_check throws exceptions");

   365   } else {

   366     ShouldNotReachHere();

   367   }

   368 }

   369 

   370 

   371 LIR_OpArrayCopy::LIR_OpArrayCopy(LIR_Opr src, LIR_Opr src_pos, LIR_Opr dst, LIR_Opr dst_pos, LIR_Opr length,

   372                                  LIR_Opr tmp, ciArrayKlass* expected_type, int flags, CodeEmitInfo* info)

   373   : LIR_Op(lir_arraycopy, LIR_OprFact::illegalOpr, info)

   374   , _tmp(tmp)

   375   , _src(src)

   376   , _src_pos(src_pos)

   377   , _dst(dst)

   378   , _dst_pos(dst_pos)

   379   , _flags(flags)

   380   , _expected_type(expected_type)

   381   , _length(length) {

   382   _stub = new ArrayCopyStub(this);

   383 }

   384 

   385 

   386 //-------------------verify--------------------------

   387 

   388 void LIR_Op1::verify() const {

   389   switch(code()) {

   390   case lir_move:

   391     assert(in_opr()->is_valid() && result_opr()->is_valid(), "must be");

   392     break;

   393   case lir_null_check:

   394     assert(in_opr()->is_register(), "must be");

   395     break;

   396   case lir_return:

   397     assert(in_opr()->is_register() || in_opr()->is_illegal(), "must be");

   398     break;

   399   }

   400 }

   401 

   402 void LIR_OpRTCall::verify() const {

   403   assert(strcmp(Runtime1::name_for_address(addr()), "<unknown function>") != 0, "unknown function");

   404 }

   405 

   406 //-------------------visits--------------------------

   407 

   408 // complete rework of LIR instruction visitor.

   409 // The virtual calls for each instruction type is replaced by a big

   410 // switch that adds the operands for each instruction

   411 

   412 void LIR_OpVisitState::visit(LIR_Op* op) {

   413   // copy information from the LIR_Op

   414   reset();

   415   set_op(op);

   416 

   417   switch (op->code()) {

   418 

   419 // LIR_Op0

   420     case lir_word_align:               // result and info always invalid

   421     case lir_backwardbranch_target:    // result and info always invalid

   422     case lir_build_frame:              // result and info always invalid

   423     case lir_fpop_raw:                 // result and info always invalid

   424     case lir_24bit_FPU:                // result and info always invalid

   425     case lir_reset_FPU:                // result and info always invalid

   426     case lir_breakpoint:               // result and info always invalid

   427     case lir_membar:                   // result and info always invalid

   428     case lir_membar_acquire:           // result and info always invalid

   429     case lir_membar_release:           // result and info always invalid

   430     {

   431       assert(op->as_Op0() != NULL, "must be");

   432       assert(op->_info == NULL, "info not used by this instruction");

   433       assert(op->_result->is_illegal(), "not used");

   434       break;

   435     }

   436 

   437     case lir_nop:                      // may have info, result always invalid

   438     case lir_std_entry:                // may have result, info always invalid

   439     case lir_osr_entry:                // may have result, info always invalid

   440     case lir_get_thread:               // may have result, info always invalid

   441     {

   442       assert(op->as_Op0() != NULL, "must be");

   443       if (op->_info != NULL)           do_info(op->_info);

   444       if (op->_result->is_valid())     do_output(op->_result);

   445       break;

   446     }

   447 

   448 

   449 // LIR_OpLabel

   450     case lir_label:                    // result and info always invalid

   451     {

   452       assert(op->as_OpLabel() != NULL, "must be");

   453       assert(op->_info == NULL, "info not used by this instruction");

   454       assert(op->_result->is_illegal(), "not used");

   455       break;

   456     }

   457 

   458 

   459 // LIR_Op1

   460     case lir_fxch:           // input always valid, result and info always invalid

   461     case lir_fld:            // input always valid, result and info always invalid

   462     case lir_ffree:          // input always valid, result and info always invalid

   463     case lir_push:           // input always valid, result and info always invalid

   464     case lir_pop:            // input always valid, result and info always invalid

   465     case lir_return:         // input always valid, result and info always invalid

   466     case lir_leal:           // input and result always valid, info always invalid

   467     case lir_neg:            // input and result always valid, info always invalid

   468     case lir_monaddr:        // input and result always valid, info always invalid

   469     case lir_null_check:     // input and info always valid, result always invalid

   470     case lir_move:           // input and result always valid, may have info

   471     case lir_prefetchr:      // input always valid, result and info always invalid

   472     case lir_prefetchw:      // input always valid, result and info always invalid

   473     {

   474       assert(op->as_Op1() != NULL, "must be");

   475       LIR_Op1* op1 = (LIR_Op1*)op;

   476 

   477       if (op1->_info)                  do_info(op1->_info);

   478       if (op1->_opr->is_valid())       do_input(op1->_opr);

   479       if (op1->_result->is_valid())    do_output(op1->_result);

   480 

   481       break;

   482     }

   483 

   484     case lir_safepoint:

   485     {

   486       assert(op->as_Op1() != NULL, "must be");

   487       LIR_Op1* op1 = (LIR_Op1*)op;

   488 

   489       assert(op1->_info != NULL, "");  do_info(op1->_info);

   490       if (op1->_opr->is_valid())       do_temp(op1->_opr); // safepoints on SPARC need temporary register

   491       assert(op1->_result->is_illegal(), "safepoint does not produce value");

   492 

   493       break;

   494     }

   495 

   496 // LIR_OpConvert;

   497     case lir_convert:        // input and result always valid, info always invalid

   498     {

   499       assert(op->as_OpConvert() != NULL, "must be");

   500       LIR_OpConvert* opConvert = (LIR_OpConvert*)op;

   501 

   502       assert(opConvert->_info == NULL, "must be");

   503       if (opConvert->_opr->is_valid())       do_input(opConvert->_opr);

   504       if (opConvert->_result->is_valid())    do_output(opConvert->_result);

   505       do_stub(opConvert->_stub);

   506 

   507       break;

   508     }

   509 

   510 // LIR_OpBranch;

   511     case lir_branch:                   // may have info, input and result register always invalid

   512     case lir_cond_float_branch:        // may have info, input and result register always invalid

   513     {

   514       assert(op->as_OpBranch() != NULL, "must be");

   515       LIR_OpBranch* opBranch = (LIR_OpBranch*)op;

   516 

   517       if (opBranch->_info != NULL)     do_info(opBranch->_info);

   518       assert(opBranch->_result->is_illegal(), "not used");

   519       if (opBranch->_stub != NULL)     opBranch->stub()->visit(this);

   520 

   521       break;

   522     }

   523 

   524 

   525 // LIR_OpAllocObj

   526     case lir_alloc_object:

   527     {

   528       assert(op->as_OpAllocObj() != NULL, "must be");

   529       LIR_OpAllocObj* opAllocObj = (LIR_OpAllocObj*)op;

   530 

   531       if (opAllocObj->_info)                     do_info(opAllocObj->_info);

   532       if (opAllocObj->_opr->is_valid())          do_input(opAllocObj->_opr);

   533       if (opAllocObj->_tmp1->is_valid())         do_temp(opAllocObj->_tmp1);

   534       if (opAllocObj->_tmp2->is_valid())         do_temp(opAllocObj->_tmp2);

   535       if (opAllocObj->_tmp3->is_valid())         do_temp(opAllocObj->_tmp3);

   536       if (opAllocObj->_tmp4->is_valid())         do_temp(opAllocObj->_tmp4);

   537       if (opAllocObj->_result->is_valid())       do_output(opAllocObj->_result);

   538                                                  do_stub(opAllocObj->_stub);

   539       break;

   540     }

   541 

   542 

   543 // LIR_OpRoundFP;

   544     case lir_roundfp: {

   545       assert(op->as_OpRoundFP() != NULL, "must be");

   546       LIR_OpRoundFP* opRoundFP = (LIR_OpRoundFP*)op;

   547 

   548       assert(op->_info == NULL, "info not used by this instruction");

   549       assert(opRoundFP->_tmp->is_illegal(), "not used");

   550       do_input(opRoundFP->_opr);

   551       do_output(opRoundFP->_result);

   552 

   553       break;

   554     }

   555 

   556 

   557 // LIR_Op2

   558     case lir_cmp:

   559     case lir_cmp_l2i:

   560     case lir_ucmp_fd2i:

   561     case lir_cmp_fd2i:

   562     case lir_add:

   563     case lir_sub:

   564     case lir_mul:

   565     case lir_div:

   566     case lir_rem:

   567     case lir_sqrt:

   568     case lir_abs:

   569     case lir_log:

   570     case lir_log10:

   571     case lir_logic_and:

   572     case lir_logic_or:

   573     case lir_logic_xor:

   574     case lir_shl:

   575     case lir_shr:

   576     case lir_ushr:

   577     {

   578       assert(op->as_Op2() != NULL, "must be");

   579       LIR_Op2* op2 = (LIR_Op2*)op;

   580 

   581       if (op2->_info)                     do_info(op2->_info);

   582       if (op2->_opr1->is_valid())         do_input(op2->_opr1);

   583       if (op2->_opr2->is_valid())         do_input(op2->_opr2);

   584       if (op2->_tmp->is_valid())          do_temp(op2->_tmp);

   585       if (op2->_result->is_valid())       do_output(op2->_result);

   586 

   587       break;

   588     }

   589 

   590     // special handling for cmove: right input operand must not be equal

   591     // to the result operand, otherwise the backend fails

   592     case lir_cmove:

   593     {

   594       assert(op->as_Op2() != NULL, "must be");

   595       LIR_Op2* op2 = (LIR_Op2*)op;

   596 

   597       assert(op2->_info == NULL && op2->_tmp->is_illegal(), "not used");

   598       assert(op2->_opr1->is_valid() && op2->_opr2->is_valid() && op2->_result->is_valid(), "used");

   599 

   600       do_input(op2->_opr1);

   601       do_input(op2->_opr2);

   602       do_temp(op2->_opr2);

   603       do_output(op2->_result);

   604 

   605       break;

   606     }

   607 

   608     // vspecial handling for strict operations: register input operands

   609     // as temp to guarantee that they do not overlap with other

   610     // registers

   611     case lir_mul_strictfp:

   612     case lir_div_strictfp:

   613     {

   614       assert(op->as_Op2() != NULL, "must be");

   615       LIR_Op2* op2 = (LIR_Op2*)op;

   616 

   617       assert(op2->_info == NULL, "not used");

   618       assert(op2->_opr1->is_valid(), "used");

   619       assert(op2->_opr2->is_valid(), "used");

   620       assert(op2->_result->is_valid(), "used");

   621 

   622       do_input(op2->_opr1); do_temp(op2->_opr1);

   623       do_input(op2->_opr2); do_temp(op2->_opr2);

   624       if (op2->_tmp->is_valid()) do_temp(op2->_tmp);

   625       do_output(op2->_result);

   626 

   627       break;

   628     }

   629 

   630     case lir_throw:

   631     case lir_unwind: {

   632       assert(op->as_Op2() != NULL, "must be");

   633       LIR_Op2* op2 = (LIR_Op2*)op;

   634 

   635       if (op2->_info)                     do_info(op2->_info);

   636       if (op2->_opr1->is_valid())         do_temp(op2->_opr1);

   637       if (op2->_opr2->is_valid())         do_input(op2->_opr2); // exception object is input parameter

   638       assert(op2->_result->is_illegal(), "no result");

   639 

   640       break;

   641     }

   642 

   643 

   644     case lir_tan:

   645     case lir_sin:

   646     case lir_cos: {

   647       assert(op->as_Op2() != NULL, "must be");

   648       LIR_Op2* op2 = (LIR_Op2*)op;

   649 

   650       // sin and cos need two temporary fpu stack slots, so register

   651       // two temp operands.  Register input operand as temp to

   652       // guarantee that they do not overlap

   653       assert(op2->_info == NULL, "not used");

   654       assert(op2->_opr1->is_valid(), "used");

   655       do_input(op2->_opr1); do_temp(op2->_opr1);

   656 

   657       if (op2->_opr2->is_valid())         do_temp(op2->_opr2);

   658       if (op2->_tmp->is_valid())          do_temp(op2->_tmp);

   659       if (op2->_result->is_valid())       do_output(op2->_result);

   660 

   661       break;

   662     }

   663 

   664 

   665 // LIR_Op3

   666     case lir_idiv:

   667     case lir_irem: {

   668       assert(op->as_Op3() != NULL, "must be");

   669       LIR_Op3* op3= (LIR_Op3*)op;

   670 

   671       if (op3->_info)                     do_info(op3->_info);

   672       if (op3->_opr1->is_valid())         do_input(op3->_opr1);

   673 

   674       // second operand is input and temp, so ensure that second operand

   675       // and third operand get not the same register

   676       if (op3->_opr2->is_valid())         do_input(op3->_opr2);

   677       if (op3->_opr2->is_valid())         do_temp(op3->_opr2);

   678       if (op3->_opr3->is_valid())         do_temp(op3->_opr3);

   679 

   680       if (op3->_result->is_valid())       do_output(op3->_result);

   681 

   682       break;

   683     }

   684 

   685 

   686 // LIR_OpJavaCall

   687     case lir_static_call:

   688     case lir_optvirtual_call:

   689     case lir_icvirtual_call:

   690     case lir_virtual_call: {

   691       assert(op->as_OpJavaCall() != NULL, "must be");

   692       LIR_OpJavaCall* opJavaCall = (LIR_OpJavaCall*)op;

   693 

   694       if (opJavaCall->_receiver->is_valid())     do_input(opJavaCall->_receiver);

   695 

   696       // only visit register parameters

   697       int n = opJavaCall->_arguments->length();

   698       for (int i = 0; i < n; i++) {

   699         if (!opJavaCall->_arguments->at(i)->is_pointer()) {

   700           do_input(*opJavaCall->_arguments->adr_at(i));

   701         }

   702       }

   703 

   704       if (opJavaCall->_info)                     do_info(opJavaCall->_info);

   705       do_call();

   706       if (opJavaCall->_result->is_valid())       do_output(opJavaCall->_result);

   707 

   708       break;

   709     }

   710 

   711 

   712 // LIR_OpRTCall

   713     case lir_rtcall: {

   714       assert(op->as_OpRTCall() != NULL, "must be");

   715       LIR_OpRTCall* opRTCall = (LIR_OpRTCall*)op;

   716 

   717       // only visit register parameters

   718       int n = opRTCall->_arguments->length();

   719       for (int i = 0; i < n; i++) {

   720         if (!opRTCall->_arguments->at(i)->is_pointer()) {

   721           do_input(*opRTCall->_arguments->adr_at(i));

   722         }

   723       }

   724       if (opRTCall->_info)                     do_info(opRTCall->_info);

   725       if (opRTCall->_tmp->is_valid())          do_temp(opRTCall->_tmp);

   726       do_call();

   727       if (opRTCall->_result->is_valid())       do_output(opRTCall->_result);

   728 

   729       break;

   730     }

   731 

   732 

   733 // LIR_OpArrayCopy

   734     case lir_arraycopy: {

   735       assert(op->as_OpArrayCopy() != NULL, "must be");

   736       LIR_OpArrayCopy* opArrayCopy = (LIR_OpArrayCopy*)op;

   737 

   738       assert(opArrayCopy->_result->is_illegal(), "unused");

   739       assert(opArrayCopy->_src->is_valid(), "used");          do_input(opArrayCopy->_src);     do_temp(opArrayCopy->_src);

   740       assert(opArrayCopy->_src_pos->is_valid(), "used");      do_input(opArrayCopy->_src_pos); do_temp(opArrayCopy->_src_pos);

   741       assert(opArrayCopy->_dst->is_valid(), "used");          do_input(opArrayCopy->_dst);     do_temp(opArrayCopy->_dst);

   742       assert(opArrayCopy->_dst_pos->is_valid(), "used");      do_input(opArrayCopy->_dst_pos); do_temp(opArrayCopy->_dst_pos);

   743       assert(opArrayCopy->_length->is_valid(), "used");       do_input(opArrayCopy->_length);  do_temp(opArrayCopy->_length);

   744       assert(opArrayCopy->_tmp->is_valid(), "used");          do_temp(opArrayCopy->_tmp);

   745       if (opArrayCopy->_info)                     do_info(opArrayCopy->_info);

   746 

   747       // the implementation of arraycopy always has a call into the runtime

   748       do_call();

   749 

   750       break;

   751     }

   752 

   753 

   754 // LIR_OpLock

   755     case lir_lock:

   756     case lir_unlock: {

   757       assert(op->as_OpLock() != NULL, "must be");

   758       LIR_OpLock* opLock = (LIR_OpLock*)op;

   759 

   760       if (opLock->_info)                          do_info(opLock->_info);

   761 

   762       // TODO: check if these operands really have to be temp

   763       // (or if input is sufficient). This may have influence on the oop map!

   764       assert(opLock->_lock->is_valid(), "used");  do_temp(opLock->_lock);

   765       assert(opLock->_hdr->is_valid(),  "used");  do_temp(opLock->_hdr);

   766       assert(opLock->_obj->is_valid(),  "used");  do_temp(opLock->_obj);

   767 

   768       if (opLock->_scratch->is_valid())           do_temp(opLock->_scratch);

   769       assert(opLock->_result->is_illegal(), "unused");

   770 

   771       do_stub(opLock->_stub);

   772 

   773       break;

   774     }

   775 

   776 

   777 // LIR_OpDelay

   778     case lir_delay_slot: {

   779       assert(op->as_OpDelay() != NULL, "must be");

   780       LIR_OpDelay* opDelay = (LIR_OpDelay*)op;

   781 

   782       visit(opDelay->delay_op());

   783       break;

   784     }

   785 

   786 // LIR_OpTypeCheck

   787     case lir_instanceof:

   788     case lir_checkcast:

   789     case lir_store_check: {

   790       assert(op->as_OpTypeCheck() != NULL, "must be");

   791       LIR_OpTypeCheck* opTypeCheck = (LIR_OpTypeCheck*)op;

   792 

   793       if (opTypeCheck->_info_for_exception)       do_info(opTypeCheck->_info_for_exception);

   794       if (opTypeCheck->_info_for_patch)           do_info(opTypeCheck->_info_for_patch);

   795       if (opTypeCheck->_object->is_valid())       do_input(opTypeCheck->_object);

   796       if (opTypeCheck->_array->is_valid())        do_input(opTypeCheck->_array);

   797       if (opTypeCheck->_tmp1->is_valid())         do_temp(opTypeCheck->_tmp1);

   798       if (opTypeCheck->_tmp2->is_valid())         do_temp(opTypeCheck->_tmp2);

   799       if (opTypeCheck->_tmp3->is_valid())         do_temp(opTypeCheck->_tmp3);

   800       if (opTypeCheck->_result->is_valid())       do_output(opTypeCheck->_result);

   801                                                   do_stub(opTypeCheck->_stub);

   802       break;

   803     }

   804 

   805 // LIR_OpCompareAndSwap

   806     case lir_cas_long:

   807     case lir_cas_obj:

   808     case lir_cas_int: {

   809       assert(op->as_OpCompareAndSwap() != NULL, "must be");

   810       LIR_OpCompareAndSwap* opCompareAndSwap = (LIR_OpCompareAndSwap*)op;

   811 

   812       if (opCompareAndSwap->_info)                    do_info(opCompareAndSwap->_info);

   813       if (opCompareAndSwap->_addr->is_valid())        do_input(opCompareAndSwap->_addr);

   814       if (opCompareAndSwap->_cmp_value->is_valid())   do_input(opCompareAndSwap->_cmp_value);

   815       if (opCompareAndSwap->_new_value->is_valid())   do_input(opCompareAndSwap->_new_value);

   816       if (opCompareAndSwap->_tmp1->is_valid())        do_temp(opCompareAndSwap->_tmp1);

   817       if (opCompareAndSwap->_tmp2->is_valid())        do_temp(opCompareAndSwap->_tmp2);

   818       if (opCompareAndSwap->_result->is_valid())      do_output(opCompareAndSwap->_result);

   819 

   820       break;

   821     }

   822 

   823 

   824 // LIR_OpAllocArray;

   825     case lir_alloc_array: {

   826       assert(op->as_OpAllocArray() != NULL, "must be");

   827       LIR_OpAllocArray* opAllocArray = (LIR_OpAllocArray*)op;

   828 

   829       if (opAllocArray->_info)                        do_info(opAllocArray->_info);

   830       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);

   831       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);

   832       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);

   833       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);

   834       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);

   835       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);

   836       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);

   837                                                       do_stub(opAllocArray->_stub);

   838       break;

   839     }

   840 

   841 // LIR_OpProfileCall:

   842     case lir_profile_call: {

   843       assert(op->as_OpProfileCall() != NULL, "must be");

   844       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;

   845 

   846       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);

   847       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);

   848       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);

   849       break;

   850     }

   851 

   852   default:

   853     ShouldNotReachHere();

   854   }

   855 }

   856 

   857 

   858 void LIR_OpVisitState::do_stub(CodeStub* stub) {

   859   if (stub != NULL) {

   860     stub->visit(this);

   861   }

   862 }

   863 

   864 XHandlers* LIR_OpVisitState::all_xhandler() {

   865   XHandlers* result = NULL;

   866 

   867   int i;

   868   for (i = 0; i < info_count(); i++) {

   869     if (info_at(i)->exception_handlers() != NULL) {

   870       result = info_at(i)->exception_handlers();

   871       break;

   872     }

   873   }

   874 

   875 #ifdef ASSERT

   876   for (i = 0; i < info_count(); i++) {

   877     assert(info_at(i)->exception_handlers() == NULL ||

   878            info_at(i)->exception_handlers() == result,

   879            "only one xhandler list allowed per LIR-operation");

   880   }

   881 #endif

   882 

   883   if (result != NULL) {

   884     return result;

   885   } else {

   886     return new XHandlers();

   887   }

   888 

   889   return result;

   890 }

   891 

   892 

   893 #ifdef ASSERT

   894 bool LIR_OpVisitState::no_operands(LIR_Op* op) {

   895   visit(op);

   896 

   897   return opr_count(inputMode) == 0 &&

   898          opr_count(outputMode) == 0 &&

   899          opr_count(tempMode) == 0 &&

   900          info_count() == 0 &&

   901          !has_call() &&

   902          !has_slow_case();

   903 }

   904 #endif

   905 

   906 //---------------------------------------------------

   907 

   908 

   909 void LIR_OpJavaCall::emit_code(LIR_Assembler* masm) {

   910   masm->emit_call(this);

   911 }

   912 

   913 void LIR_OpRTCall::emit_code(LIR_Assembler* masm) {

   914   masm->emit_rtcall(this);

   915 }

   916 

   917 void LIR_OpLabel::emit_code(LIR_Assembler* masm) {

   918   masm->emit_opLabel(this);

   919 }

   920 

   921 void LIR_OpArrayCopy::emit_code(LIR_Assembler* masm) {

   922   masm->emit_arraycopy(this);

   923   masm->emit_code_stub(stub());

   924 }

   925 

   926 void LIR_Op0::emit_code(LIR_Assembler* masm) {

   927   masm->emit_op0(this);

   928 }

   929 

   930 void LIR_Op1::emit_code(LIR_Assembler* masm) {

   931   masm->emit_op1(this);

   932 }

   933 

   934 void LIR_OpAllocObj::emit_code(LIR_Assembler* masm) {

   935   masm->emit_alloc_obj(this);

   936   masm->emit_code_stub(stub());

   937 }

   938 

   939 void LIR_OpBranch::emit_code(LIR_Assembler* masm) {

   940   masm->emit_opBranch(this);

   941   if (stub()) {

   942     masm->emit_code_stub(stub());

   943   }

   944 }

   945 

   946 void LIR_OpConvert::emit_code(LIR_Assembler* masm) {

   947   masm->emit_opConvert(this);

   948   if (stub() != NULL) {

   949     masm->emit_code_stub(stub());

   950   }

   951 }

   952 

   953 void LIR_Op2::emit_code(LIR_Assembler* masm) {

   954   masm->emit_op2(this);

   955 }

   956 

   957 void LIR_OpAllocArray::emit_code(LIR_Assembler* masm) {

   958   masm->emit_alloc_array(this);

   959   masm->emit_code_stub(stub());

   960 }

   961 

   962 void LIR_OpTypeCheck::emit_code(LIR_Assembler* masm) {

   963   masm->emit_opTypeCheck(this);

   964   if (stub()) {

   965     masm->emit_code_stub(stub());

   966   }

   967 }

   968 

   969 void LIR_OpCompareAndSwap::emit_code(LIR_Assembler* masm) {

   970   masm->emit_compare_and_swap(this);

   971 }

   972 

   973 void LIR_Op3::emit_code(LIR_Assembler* masm) {

   974   masm->emit_op3(this);

   975 }

   976 

   977 void LIR_OpLock::emit_code(LIR_Assembler* masm) {

   978   masm->emit_lock(this);

   979   if (stub()) {

   980     masm->emit_code_stub(stub());

   981   }

   982 }

   983 

   984 

   985 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {

   986   masm->emit_delay(this);

   987 }

   988 

   989 

   990 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {

   991   masm->emit_profile_call(this);

   992 }

   993 

   994 

   995 // LIR_List

   996 LIR_List::LIR_List(Compilation* compilation, BlockBegin* block)

   997   : _operations(8)

   998   , _compilation(compilation)

   999 #ifndef PRODUCT

  1000   , _block(block)

  1001 #endif

  1002 #ifdef ASSERT

  1003   , _file(NULL)

  1004   , _line(0)

  1005 #endif

  1006 { }

  1007 

  1008 

  1009 #ifdef ASSERT

  1010 void LIR_List::set_file_and_line(const char * file, int line) {

  1011   const char * f = strrchr(file, '/');

  1012   if (f == NULL) f = strrchr(file, '\\');

  1013   if (f == NULL) {

  1014     f = file;

  1015   } else {

  1016     f++;

  1017   }

  1018   _file = f;

  1019   _line = line;

  1020 }

  1021 #endif

  1022 

  1023 

  1024 void LIR_List::append(LIR_InsertionBuffer* buffer) {

  1025   assert(this == buffer->lir_list(), "wrong lir list");

  1026   const int n = _operations.length();

  1027 

  1028   if (buffer->number_of_ops() > 0) {

  1029     // increase size of instructions list

  1030     _operations.at_grow(n + buffer->number_of_ops() - 1, NULL);

  1031     // insert ops from buffer into instructions list

  1032     int op_index = buffer->number_of_ops() - 1;

  1033     int ip_index = buffer->number_of_insertion_points() - 1;

  1034     int from_index = n - 1;

  1035     int to_index = _operations.length() - 1;

  1036     for (; ip_index >= 0; ip_index --) {

  1037       int index = buffer->index_at(ip_index);

  1038       // make room after insertion point

  1039       while (index < from_index) {

  1040         _operations.at_put(to_index --, _operations.at(from_index --));

  1041       }

  1042       // insert ops from buffer

  1043       for (int i = buffer->count_at(ip_index); i > 0; i --) {

  1044         _operations.at_put(to_index --, buffer->op_at(op_index --));

  1045       }

  1046     }

  1047   }

  1048 

  1049   buffer->finish();

  1050 }

  1051 

  1052 

  1053 void LIR_List::oop2reg_patch(jobject o, LIR_Opr reg, CodeEmitInfo* info) {

  1054   append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o),  reg, T_OBJECT, lir_patch_normal, info));

  1055 }

  1056 

  1057 

  1058 void LIR_List::load(LIR_Address* addr, LIR_Opr src, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1059   append(new LIR_Op1(

  1060             lir_move,

  1061             LIR_OprFact::address(addr),

  1062             src,

  1063             addr->type(),

  1064             patch_code,

  1065             info));

  1066 }

  1067 

  1068 

  1069 void LIR_List::volatile_load_mem_reg(LIR_Address* address, LIR_Opr dst, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1070   append(new LIR_Op1(

  1071             lir_move,

  1072             LIR_OprFact::address(address),

  1073             dst,

  1074             address->type(),

  1075             patch_code,

  1076             info, lir_move_volatile));

  1077 }

  1078 

  1079 void LIR_List::volatile_load_unsafe_reg(LIR_Opr base, LIR_Opr offset, LIR_Opr dst, BasicType type, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1080   append(new LIR_Op1(

  1081             lir_move,

  1082             LIR_OprFact::address(new LIR_Address(base, offset, type)),

  1083             dst,

  1084             type,

  1085             patch_code,

  1086             info, lir_move_volatile));

  1087 }

  1088 

  1089 

  1090 void LIR_List::prefetch(LIR_Address* addr, bool is_store) {

  1091   append(new LIR_Op1(

  1092             is_store ? lir_prefetchw : lir_prefetchr,

  1093             LIR_OprFact::address(addr)));

  1094 }

  1095 

  1096 

  1097 void LIR_List::store_mem_int(jint v, LIR_Opr base, int offset_in_bytes, BasicType type, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1098   append(new LIR_Op1(

  1099             lir_move,

  1100             LIR_OprFact::intConst(v),

  1101             LIR_OprFact::address(new LIR_Address(base, offset_in_bytes, type)),

  1102             type,

  1103             patch_code,

  1104             info));

  1105 }

  1106 

  1107 

  1108 void LIR_List::store_mem_oop(jobject o, LIR_Opr base, int offset_in_bytes, BasicType type, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1109   append(new LIR_Op1(

  1110             lir_move,

  1111             LIR_OprFact::oopConst(o),

  1112             LIR_OprFact::address(new LIR_Address(base, offset_in_bytes, type)),

  1113             type,

  1114             patch_code,

  1115             info));

  1116 }

  1117 

  1118 

  1119 void LIR_List::store(LIR_Opr src, LIR_Address* addr, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1120   append(new LIR_Op1(

  1121             lir_move,

  1122             src,

  1123             LIR_OprFact::address(addr),

  1124             addr->type(),

  1125             patch_code,

  1126             info));

  1127 }

  1128 

  1129 

  1130 void LIR_List::volatile_store_mem_reg(LIR_Opr src, LIR_Address* addr, CodeEmitInfo* info, LIR_PatchCode patch_code) {

  1131   append(new LIR_Op1(

  1132             lir_move,

  1133             src,

  1134             LIR_OprFact::address(addr),

  1135             addr->type(),