jdk8-mips64-public/hotspot: comparison src/cpu/mips/vm/c1_LIRGenerator

-:e4aeef458496
+:ffcdff41a92f
 return new LIR_Address(base, 0, type);
 }
 }
 }
-LIR_Address* LIRGenerator::emit_array_address(LIR_Opr array_opr, LIR_Opr index_opr,BasicType type, bool needs_card_mark) {
+LIR_Address* LIRGenerator::emit_array_address(LIR_Opr array_opr, LIR_Opr index_opr,
-int offset_in_bytes = arrayOopDesc::base_offset_in_bytes(type);
+BasicType type, bool needs_card_mark) {
+int elem_size = type2aelembytes(type);
-LIR_Address* addr;
+int shift = exact_log2(elem_size);
+LIR_Opr base_opr;
+int offset = arrayOopDesc::base_offset_in_bytes(type);
 if (index_opr->is_constant()) {
-int elem_size = _type2aelembytes[type];
+int i = index_opr->as_constant_ptr()->as_jint();
-addr = new LIR_Address(array_opr,
+int array_offset = i * elem_size;
-offset_in_bytes + index_opr->as_jint() * elem_size, type);
+if (Assembler::is_simm16(array_offset + offset)) {
-} else if( index_opr->is_register()){
+base_opr = array_opr;
+offset = array_offset + offset;
+} else {
+base_opr = new_pointer_register();
+if (Assembler::is_simm16(array_offset)) {
+__ add(array_opr, LIR_OprFact::intptrConst(array_offset), base_opr);
+} else {
+__ move(LIR_OprFact::intptrConst(array_offset), base_opr);
+__ add(base_opr, array_opr, base_opr);
+}
+}
+} else {
 #ifdef _LP64
-LIR_Opr tmp = new_register(T_LONG);
+if (index_opr->type() == T_INT) {
-#else
+LIR_Opr tmp = new_register(T_LONG);
-LIR_Opr tmp = new_register(T_INT);
+__ convert(Bytecodes::_i2l, index_opr, tmp);
+index_opr = tmp;
+}
 #endif
-__ move(index_opr, tmp);
-__ shift_left(tmp, LIR_Address::scale(type),tmp);
+base_opr = new_pointer_register();
-__ add(tmp, array_opr, tmp);
+assert (index_opr->is_register(), "Must be register");
-addr =  new LIR_Address(tmp, offset_in_bytes,type);
+if (shift > 0) {
+__ shift_left(index_opr, shift, base_opr);
-}
+__ add(base_opr, array_opr, base_opr);
-else{
+} else {
-addr = new LIR_Address(array_opr,
+__ add(index_opr, array_opr, base_opr);
-offset_in_bytes, type);
+}
 }
 if (needs_card_mark) {
 // This store will need a precise card mark, so go ahead and
 // compute the full adddres instead of computing once for the
 // store and again for the card mark.
-#ifdef _LP64
+LIR_Opr ptr = new_pointer_register();
-LIR_Opr tmp = new_register(T_ADDRESS);
+__ add(base_opr, LIR_OprFact::intptrConst(offset), ptr);
-#else
+return new LIR_Address(ptr, type);
-LIR_Opr tmp = new_register(T_INT);
+} else {
-#endif
+return new LIR_Address(base_opr, offset, type);
-__ leal(LIR_OprFact::address(addr), tmp);
+}
-return new LIR_Address(tmp, 0, type);
-} else {
-return addr;
-}
 }
 LIR_Opr LIRGenerator::load_immediate(int x, BasicType type) {
 LIR_Opr r;
 }
 return r;
 }
 void LIRGenerator::increment_counter(address counter, BasicType type, int step) {
-LIR_Opr temp = new_register(T_INT);
+#ifdef _LP64
+LIR_Opr pointer = new_register(T_LONG);
+#else
 LIR_Opr pointer = new_register(T_INT);
-#ifndef _LP64
-__ move(LIR_OprFact::intConst((int)counter), pointer);
-#else
-__ move(LIR_OprFact::longConst((long)counter), pointer);
 #endif
-LIR_Opr addr = (LIR_Opr)new LIR_Address(pointer, type);
+__ move(LIR_OprFact::intptrConst(counter), pointer);
-LIR_Opr c = LIR_OprFact::intConst((int)step);
+LIR_Address* addr = new LIR_Address(pointer, type);
-__ add(addr, c, addr);
+increment_counter(addr, step);
 }
+//void LIRGenerator::increment_counter(address counter, BasicType type, int step) {
+//  LIR_Opr pointer = new_register(T_LONG);
+//  __ move(LIR_OprFact::longConst((long)counter), pointer);
+//  LIR_Opr addr = (LIR_Opr)new LIR_Address(pointer, type);
+//  LIR_Opr c = LIR_OprFact::intConst((int)step);
+//  __ add(addr, c, addr);
+//}
 void LIRGenerator::increment_counter(LIR_Address* addr, int step) {
-Unimplemented();
+LIR_Opr temp = new_register(addr->type());
+__ move(addr, temp);
+__ add(temp, load_immediate(step, addr->type()), temp);
+__ move(temp, addr);
 }
 bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, int c, LIR_Opr result, LIR_Opr tmp) {
 if (tmp->is_valid()) {
 entry = CAST_FROM_FN_PTR(address, SharedRuntime::lmul);
 break;
 default:
 ShouldNotReachHere();
 }
 // order of arguments to runtime call is reversed.
 LIR_Opr result = call_runtime(x->y(), x->x(), entry, x->type(), NULL);
 set_result(x, result);
 break;
 }
-/* _ladd, _lsub is delete in sharedRuntime.hpp
 case Bytecodes::_ladd:
-case Bytecodes::_lsub:  {
+case Bytecodes::_lsub: {
-address entry;
-switch (x->op()) {
-case Bytecodes::_ladd:
-entry = CAST_FROM_FN_PTR(address, SharedRuntime::ladd);
-break; // check if dividend is 0 is done elsewhere
-case Bytecodes::_lsub:
-entry = CAST_FROM_FN_PTR(address, SharedRuntime::lsub);
-break; // check if dividend is 0 is done elsewhere
-default:
-ShouldNotReachHere();
-}
-// order of arguments to runtime call is reversed.
-LIR_Opr result = call_runtime(x->y(), x->x(), entry, x->type(), NULL);
-set_result(x, result);
-break;
-}*/
-/*  {
 LIRItem left(x->x(), this);
 LIRItem right(x->y(), this);
 left.load_item();
 right.load_item();
 rlock_result(x);
 arithmetic_op_long(x->op(), x->operand(), left.result(), right.result(), NULL);
 break;
 }
-*/
+default:
-default: ShouldNotReachHere();
+ShouldNotReachHere();
 }
 }
 }
 // _ishl, _lshl, _ishr, _lshr, _iushr, _lushr
 void LIRGenerator::do_ShiftOp(ShiftOp* x) {
-if(x->op() == Bytecodes::_lshl
-||  x->op() == Bytecodes::_lshr
-||  x->op() == Bytecodes::_lushr) {
-address entry;
-/* lushr, lshr, lshl, is delete in ShredRuntime.hpp
-switch (x->op()) {
-case Bytecodes::_lshl:
-entry = CAST_FROM_FN_PTR(address, SharedRuntime::lshl);
-break; // check if dividend is 0 is done elsewhere
-case Bytecodes::_lshr:
-entry = CAST_FROM_FN_PTR(address, SharedRuntime::lshr);
-break; // check if dividend is 0 is done elsewhere
-case Bytecodes::_lushr:
-entry = CAST_FROM_FN_PTR(address, SharedRuntime::lushr);
-break;
-default:
-ShouldNotReachHere();
-}
-*/
-// order of arguments to runtime call is reversed.
-LIR_Opr result = call_runtime(x->y(), x->x(), entry, x->type(), NULL);
-set_result(x, result);
-return;
-}
 // count must always be in rcx
 LIRItem value(x->x(), this);
 LIRItem count(x->y(), this);
 ValueTag elemType = x->type()->tag();
 __ arraycopy(src.result(), src_pos.result(), dst.result(), dst_pos.result(), length.result(), rlock_callee_saved(T_INT), expected_type, flags, info);
 set_no_result(x);
 }
 void LIRGenerator::do_update_CRC32(Intrinsic* x) {    // Fu: 20130832
-tty->print_cr("LIRGenerator::do_update_CRC32 unimplemented yet !");
 Unimplemented();
 }
 // _i2l, _i2f, _i2d, _l2i, _l2f, _l2d, _f2i, _f2l, _f2d, _d2i, _d2l, _d2f
 // _i2b, _i2c, _i2s
 case Bytecodes::_d2l:
 fixed_input  = true;
 fixed_result = true;
 round_result = false;
 needs_stub   = false; break;
-default: ShouldNotReachHere();
+default:
+ShouldNotReachHere();
 }
 LIRItem value(x->value(), this);
 value.load_item();
 LIR_Opr input = value.result();
 //  LIR_Opr tmp1 = new_register(T_INT);
 //  LIR_Opr tmp2 = new_register(T_INT);
 //  LIR_Opr tmp3 = new_register(T_INT);
 //  LIR_Opr tmp4 = new_register(T_INT);
 #ifndef _LP64
-LIR_Opr klass_reg = FrameMap::_t4_oop_opr;
+LIR_Opr klass_reg = FrameMap::_t4_metadata_opr;
 #else
-LIR_Opr klass_reg = FrameMap::_a4_oop_opr;
+LIR_Opr klass_reg = FrameMap::_a4_metadata_opr;
 #endif
-//  new_instance(reg, x->klass(), FrameMap::_t0_oop_opr, FrameMap::_t1_oop_opr,FrameMap::_t2_oop_opr, LIR_OprFact::illegalOpr, klass_reg, info);
-guarantee(false, "not implemented yet.");
-/*
 new_instance(reg,
 x->klass(),
+x->is_unresolved(),
 FrameMap::_t0_oop_opr,
 FrameMap::_t1_oop_opr,
 FrameMap::_t2_oop_opr,
 FrameMap::_t3_oop_opr,
 #ifndef _LP64
 FrameMap::_a5_oop_opr,
 FrameMap::_a6_oop_opr,
 #endif
 klass_reg,
 info);
-*/
 LIR_Opr result = rlock_result(x);
 __ move(reg, result);
 }
 LIR_Opr tmp5 = FrameMap::_t6_oop_opr;
 LIR_Opr klass_reg = FrameMap::_t4_oop_opr;
 #else
 LIR_Opr tmp4 = FrameMap::_a5_oop_opr;
 LIR_Opr tmp5 = FrameMap::_a6_oop_opr;
-LIR_Opr klass_reg = FrameMap::_a4_oop_opr;
+LIR_Opr klass_reg = FrameMap::_a4_metadata_opr;
 #endif
 LIR_Opr len = length.result();
 BasicType elem_type = x->elt_type();
 __ metadata2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg);
 LIR_Opr tmp5 = FrameMap::_t6_oop_opr;
 LIR_Opr klass_reg = FrameMap::_t4_oop_opr;
 #else
 LIR_Opr tmp4 = FrameMap::_a5_oop_opr;
 LIR_Opr tmp5 = FrameMap::_a6_oop_opr;
-LIR_Opr klass_reg = FrameMap::_a4_oop_opr;
+LIR_Opr klass_reg = FrameMap::_a4_metadata_opr;
 #endif
 length.load_item_force(FrameMap::_t2_opr);
 LIR_Opr len = length.result();
 LIRItem* size = items->at(i);
 size->load_nonconstant();
 store_stack_parameter(size->result(), in_ByteSize(i*4));
 }
-LIR_Opr reg = result_register_for(x->type());
+LIR_Opr klass_reg = FrameMap::_v0_metadata_opr;
-klass2reg_with_patching(reg, x->klass(), patching_info);
+klass2reg_with_patching(klass_reg, x->klass(), patching_info);
 //  LIR_Opr rank = FrameMap::ebx_opr;
 LIR_Opr rank = FrameMap::_t2_opr;
 __ move(LIR_OprFact::intConst(x->rank()), rank);
 //  LIR_Opr varargs = FrameMap::ecx_opr;
 LIR_Opr varargs = FrameMap::_t0_opr;
 __ move(FrameMap::_sp_opr, varargs);
 LIR_OprList* args = new LIR_OprList(3);
-args->append(reg);
+args->append(klass_reg);
 args->append(rank);
 args->append(varargs);
+LIR_Opr reg = result_register_for(x->type());
 __ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id),
 LIR_OprFact::illegalOpr,
 reg, args, info);
 LIR_Opr result = rlock_result(x);
 __ move(reg, result);
 }
 void LIRGenerator::do_BlockBegin(BlockBegin* x) {

comparison: src/cpu/mips/vm/c1_LIRGenerator_mips.cpp

src/cpu/mips/vm/c1_LIRGenerator_mips.cpp

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

comparison: src/cpu/mips/vm/c1_LIRGenerator_mips.cpp

src/cpu/mips/vm/c1_LIRGenerator_mips.cpp