truffle: src/share/vm/c1/c1_LIRGenerator.cpp comparison

comparison src/share/vm/c1/c1_LIRGenerator.cpp @ 1579:e9ff18c4ace7

Merge

author	jrose
date	Wed, 02 Jun 2010 22:45:42 -0700
parents	c18cbe5936b8 87fc6aca31ab
children	b812ff5abc73

comparison

equal deleted inserted replaced

-:dfe27f03244a
+:e9ff18c4ace7
 LIR_Opr pre_val = new_register(T_OBJECT);
 __ cmp(lir_cond_notEqual, flag_val, LIR_OprFact::intConst(0));
 if (!addr_opr->is_address()) {
 assert(addr_opr->is_register(), "must be");
-addr_opr = LIR_OprFact::address(new LIR_Address(addr_opr, 0, T_OBJECT));
+addr_opr = LIR_OprFact::address(new LIR_Address(addr_opr, T_OBJECT));
 }
 CodeStub* slow = new G1PreBarrierStub(addr_opr, pre_val, pre_val_patch_code,
 info);
 __ branch(lir_cond_notEqual, T_INT, slow);
 __ branch_destination(slow->continuation());
 // If the "new_val" is a constant NULL, no barrier is necessary.
 if (new_val->is_constant() &&
 new_val->as_constant_ptr()->as_jobject() == NULL) return;
 if (!new_val->is_register()) {
-LIR_Opr new_val_reg = new_pointer_register();
+LIR_Opr new_val_reg = new_register(T_OBJECT);
 if (new_val->is_constant()) {
 __ move(new_val, new_val_reg);
 } else {
 __ leal(new_val, new_val_reg);
 }
 }
 assert(new_val->is_register(), "must be a register at this point");
 if (addr->is_address()) {
 LIR_Address* address = addr->as_address_ptr();
-LIR_Opr ptr = new_pointer_register();
+LIR_Opr ptr = new_register(T_OBJECT);
 if (!address->index()->is_valid() && address->disp() == 0) {
 __ move(address->base(), ptr);
 } else {
 assert(address->disp() != max_jint, "lea doesn't support patched addresses!");
 __ leal(addr, ptr);
 }
 assert(addr->is_register(), "must be a register at this point");
 LIR_Opr xor_res = new_pointer_register();
 LIR_Opr xor_shift_res = new_pointer_register();
 if (TwoOperandLIRForm ) {
 __ move(addr, xor_res);
 __ logical_xor(xor_res, new_val, xor_res);
 __ move(xor_res, xor_shift_res);
 __ unsigned_shift_right(xor_shift_res,
 xor_shift_res,
 LIR_OprDesc::illegalOpr());
 }
 if (!new_val->is_register()) {
-LIR_Opr new_val_reg = new_pointer_register();
+LIR_Opr new_val_reg = new_register(T_OBJECT);
 __ leal(new_val, new_val_reg);
 new_val = new_val_reg;
 }
 assert(new_val->is_register(), "must be a register at this point");
 __ cmp(lir_cond_notEqual, xor_shift_res, LIR_OprFact::intptrConst(NULL_WORD));
 CodeStub* slow = new G1PostBarrierStub(addr, new_val);
-__ branch(lir_cond_notEqual, T_INT, slow);
+__ branch(lir_cond_notEqual, LP64_ONLY(T_LONG) NOT_LP64(T_INT), slow);
 __ branch_destination(slow->continuation());
 }
 #endif // SERIALGC
 ////////////////////////////////////////////////////////////////////////
 // emit invoke code
 bool optimized = x->target_is_loaded() && x->target_is_final();
 assert(receiver->is_illegal() || receiver->is_equal(LIR_Assembler::receiverOpr()), "must match");
+// JSR 292
+// Preserve the SP over MethodHandle call sites.
+ciMethod* target = x->target();
+if (target->is_method_handle_invoke()) {
+info->set_is_method_handle_invoke(true);
+__ move(FrameMap::stack_pointer(), FrameMap::method_handle_invoke_SP_save_opr());
+}
 switch (x->code()) {
 case Bytecodes::_invokestatic:
-__ call_static(x->target(), result_register,
+__ call_static(target, result_register,
 SharedRuntime::get_resolve_static_call_stub(),
 arg_list, info);
 break;
 case Bytecodes::_invokespecial:
 case Bytecodes::_invokevirtual:
 case Bytecodes::_invokeinterface:
 // for final target we still produce an inline cache, in order
 // to be able to call mixed mode
 if (x->code() == Bytecodes::_invokespecial || optimized) {
-__ call_opt_virtual(x->target(), receiver, result_register,
+__ call_opt_virtual(target, receiver, result_register,
 SharedRuntime::get_resolve_opt_virtual_call_stub(),
 arg_list, info);
 } else if (x->vtable_index() < 0) {
-__ call_icvirtual(x->target(), receiver, result_register,
+__ call_icvirtual(target, receiver, result_register,
 SharedRuntime::get_resolve_virtual_call_stub(),
 arg_list, info);
 } else {
 int entry_offset = instanceKlass::vtable_start_offset() + x->vtable_index() * vtableEntry::size();
 int vtable_offset = entry_offset * wordSize + vtableEntry::method_offset_in_bytes();
-__ call_virtual(x->target(), receiver, result_register, vtable_offset, arg_list, info);
+__ call_virtual(target, receiver, result_register, vtable_offset, arg_list, info);
 }
 break;
 case Bytecodes::_invokedynamic: {
 ciBytecodeStream bcs(x->scope()->method());
 bcs.force_bci(x->bci());
 __ load(new LIR_Address(tmp, call_site_offset, T_OBJECT), tmp);
 // Load target MethodHandle from CallSite object.
 __ load(new LIR_Address(tmp, java_dyn_CallSite::target_offset_in_bytes(), T_OBJECT), receiver);
-__ call_dynamic(x->target(), receiver, result_register,
+__ call_dynamic(target, receiver, result_register,
 SharedRuntime::get_resolve_opt_virtual_call_stub(),
 arg_list, info);
 break;
 }
 default:
 ShouldNotReachHere();
 break;
+}
+// JSR 292
+// Restore the SP after MethodHandle call sites.
+if (target->is_method_handle_invoke()) {
+__ move(FrameMap::method_handle_invoke_SP_save_opr(), FrameMap::stack_pointer());
 }
 if (x->type()->is_float() || x->type()->is_double()) {
 // Force rounding of results from non-strictfp when in strictfp
 // scope (or when we don't know the strictness of the callee, to

Mercurial > hg > truffle

comparison src/share/vm/c1/c1_LIRGenerator.cpp @ 1579:e9ff18c4ace7