graal-jvmci-8: src/cpu/x86/vm/templateTable_x86

comparison src/cpu/x86/vm/templateTable_x86_32.cpp @ 6266:1d7922586cf6

7023639: JSR 292 method handle invocation needs a fast path for compiled code 6984705: JSR 292 method handle creation should not go through JNI Summary: remove assembly code for JDK 7 chained method handles Reviewed-by: jrose, twisti, kvn, mhaupt Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>

author	twisti
date	Tue, 24 Jul 2012 10:51:00 -0700
parents	19e197e2a1af
children	da91efe96a93

comparison

equal deleted inserted replaced

-:aba91a731143
+:1d7922586cf6
 }
 const Register cache = rcx;
 const Register index = rdx;
-resolve_cache_and_index(f1_oop, rax, cache, index, wide ? sizeof(u2) : sizeof(u1));
+resolve_cache_and_index(f12_oop, rax, cache, index, wide ? sizeof(u2) : sizeof(u1));
 if (VerifyOops) {
 __ verify_oop(rax);
 }
 Label L_done, L_throw_exception;
-const Register con_klass_temp = rcx;  // same as Rcache
+const Register con_klass_temp = rcx;  // same as cache
 __ load_klass(con_klass_temp, rax);
 __ cmpptr(con_klass_temp, ExternalAddress((address)Universe::systemObjArrayKlassObj_addr()));
 __ jcc(Assembler::notEqual, L_done);
 __ cmpl(Address(rax, arrayOopDesc::length_offset_in_bytes()), 0);
 __ jcc(Assembler::notEqual, L_throw_exception);
 void TemplateTable::resolve_cache_and_index(int byte_no,
 Register result,
 Register Rcache,
 Register index,
 size_t index_size) {
-Register temp = rbx;
+const Register temp = rbx;
 assert_different_registers(result, Rcache, index, temp);
 Label resolved;
-if (byte_no == f1_oop) {
+if (byte_no == f12_oop) {
-// We are resolved if the f1 field contains a non-null object (CallSite, etc.)
+// We are resolved if the f1 field contains a non-null object (CallSite, MethodType, etc.)
-// This kind of CP cache entry does not need to match the flags byte, because
+// This kind of CP cache entry does not need to match bytecode_1 or bytecode_2, because
 // there is a 1-1 relation between bytecode type and CP entry type.
+// The caller will also load a methodOop from f2.
 assert(result != noreg, ""); //else do cmpptr(Address(...), (int32_t) NULL_WORD)
 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
 __ movptr(result, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()));
 __ testptr(result, result);
 __ jcc(Assembler::notEqual, resolved);
 address entry;
 switch (bytecode()) {
 case Bytecodes::_getstatic      : // fall through
 case Bytecodes::_putstatic      : // fall through
 case Bytecodes::_getfield       : // fall through
-case Bytecodes::_putfield       : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put); break;
+case Bytecodes::_putfield       : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put);        break;
 case Bytecodes::_invokevirtual  : // fall through
 case Bytecodes::_invokespecial  : // fall through
 case Bytecodes::_invokestatic   : // fall through
-case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);  break;
+case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);         break;
-case Bytecodes::_invokedynamic  : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic); break;
+case Bytecodes::_invokehandle   : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokehandle);   break;
-case Bytecodes::_fast_aldc      : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);     break;
+case Bytecodes::_invokedynamic  : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic);  break;
-case Bytecodes::_fast_aldc_w    : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);     break;
+case Bytecodes::_fast_aldc      : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);            break;
-default                         : ShouldNotReachHere();                                 break;
+case Bytecodes::_fast_aldc_w    : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);            break;
+default:
+fatal(err_msg("unexpected bytecode: %s", Bytecodes::name(bytecode())));
+break;
 }
 __ movl(temp, (int)bytecode());
 __ call_VM(noreg, entry, temp);
 // Update registers with resolved info
 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
 in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset())));
 // Flags
 __ movl(flags, Address(cache, index, Address::times_ptr,
 in_bytes(cp_base_offset + ConstantPoolCacheEntry::flags_offset())));
-// klass     overwrite register
+// klass overwrite register
 if (is_static) {
 __ movptr(obj, Address(cache, index, Address::times_ptr,
 in_bytes(cp_base_offset + ConstantPoolCacheEntry::f1_offset())));
 }
 }
 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
 Register method,
 Register itable_index,
 Register flags,
 bool is_invokevirtual,
-bool is_invokevfinal /*unused*/,
+bool is_invokevfinal, /*unused*/
 bool is_invokedynamic) {
 // setup registers
 const Register cache = rcx;
 const Register index = rdx;
 assert_different_registers(method, flags);
 assert_different_registers(method, cache, index);
 assert_different_registers(itable_index, flags);
 assert_different_registers(itable_index, cache, index);
 // determine constant pool cache field offsets
+assert(is_invokevirtual == (byte_no == f2_byte), "is_invokevirtual flag redundant");
 const int method_offset = in_bytes(
 constantPoolCacheOopDesc::base_offset() +
-(is_invokevirtual
+((byte_no == f2_byte)
 ? ConstantPoolCacheEntry::f2_offset()
-: ConstantPoolCacheEntry::f1_offset()
+: ConstantPoolCacheEntry::f1_offset()));
-)
-);
 const int flags_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::flags_offset());
 // access constant pool cache fields
 const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::f2_offset());
-if (byte_no == f1_oop) {
+if (byte_no == f12_oop) {
-// Resolved f1_oop goes directly into 'method' register.
+// Resolved f1_oop (CallSite, MethodType, etc.) goes into 'itable_index'.
-assert(is_invokedynamic, "");
+// Resolved f2_oop (methodOop invoker) will go into 'method' (at index_offset).
-resolve_cache_and_index(byte_no, method, cache, index, sizeof(u4));
+// See ConstantPoolCacheEntry::set_dynamic_call and set_method_handle.
+size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
+resolve_cache_and_index(byte_no, itable_index, cache, index, index_size);
+__ movptr(method, Address(cache, index, Address::times_ptr, index_offset));
+itable_index = noreg;  // hack to disable load below
 } else {
 resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
 __ movptr(method, Address(cache, index, Address::times_ptr, method_offset));
 }
 if (itable_index != noreg) {
+// pick up itable index from f2 also:
+assert(byte_no == f1_byte, "already picked up f1");
 __ movptr(itable_index, Address(cache, index, Address::times_ptr, index_offset));
 }
 __ movl(flags, Address(cache, index, Address::times_ptr, flags_offset));
 }
 const Address lo(obj, off, Address::times_1, 0*wordSize);
 const Address hi(obj, off, Address::times_1, 1*wordSize);
 Label Done, notByte, notInt, notShort, notChar, notLong, notFloat, notObj, notDouble;
-__ shrl(flags, ConstantPoolCacheEntry::tosBits);
+__ shrl(flags, ConstantPoolCacheEntry::tos_state_shift);
 assert(btos == 0, "change code, btos != 0");
 // btos
-__ andptr(flags, 0x0f);
+__ andptr(flags, ConstantPoolCacheEntry::tos_state_mask);
 __ jcc(Assembler::notZero, notByte);
 __ load_signed_byte(rax, lo );
 __ push(btos);
 // Rewrite bytecode to be faster
 // the object is.
 Label two_word, valsize_known;
 __ movl(rcx, Address(rax, rdx, Address::times_ptr, in_bytes(cp_base_offset +
 ConstantPoolCacheEntry::flags_offset())));
 __ mov(rbx, rsp);
-__ shrl(rcx, ConstantPoolCacheEntry::tosBits);
+__ shrl(rcx, ConstantPoolCacheEntry::tos_state_shift);
-// Make sure we don't need to mask rcx for tosBits after the above shift
+// Make sure we don't need to mask rcx after the above shift
-ConstantPoolCacheEntry::verify_tosBits();
+ConstantPoolCacheEntry::verify_tos_state_shift();
 __ cmpl(rcx, ltos);
 __ jccb(Assembler::equal, two_word);
 __ cmpl(rcx, dtos);
 __ jccb(Assembler::equal, two_word);
 __ addptr(rbx, Interpreter::expr_offset_in_bytes(1)); // one word jvalue (not ltos, dtos)
 // Doug Lea believes this is not needed with current Sparcs (TSO) and Intel (PSO).
 // volatile_barrier( );
 Label notVolatile, Done;
 __ movl(rdx, flags);
-__ shrl(rdx, ConstantPoolCacheEntry::volatileField);
+__ shrl(rdx, ConstantPoolCacheEntry::is_volatile_shift);
 __ andl(rdx, 0x1);
 // field addresses
 const Address lo(obj, off, Address::times_1, 0*wordSize);
 const Address hi(obj, off, Address::times_1, 1*wordSize);
 Label notByte, notInt, notShort, notChar, notLong, notFloat, notObj, notDouble;
-__ shrl(flags, ConstantPoolCacheEntry::tosBits);
+__ shrl(flags, ConstantPoolCacheEntry::tos_state_shift);
 assert(btos == 0, "change code, btos != 0");
-__ andl(flags, 0x0f);
+__ andl(flags, ConstantPoolCacheEntry::tos_state_mask);
 __ jcc(Assembler::notZero, notByte);
 // btos
 {
 __ pop(btos);
 // Doug Lea believes this is not needed with current Sparcs (TSO) and Intel (PSO).
 // volatile_barrier( );
 Label notVolatile, Done;
-__ shrl(rdx, ConstantPoolCacheEntry::volatileField);
+__ shrl(rdx, ConstantPoolCacheEntry::is_volatile_shift);
 __ andl(rdx, 0x1);
 // Check for volatile store
 __ testl(rdx, rdx);
 __ jcc(Assembler::zero, notVolatile);
 // implemented elsewhere
 ShouldNotReachHere();
 }
-void TemplateTable::prepare_invoke(Register method, Register index, int byte_no) {
+void TemplateTable::prepare_invoke(int byte_no,
+Register method,  // linked method (or i-klass)
+Register index,   // itable index, MethodType, etc.
+Register recv,    // if caller wants to see it
+Register flags    // if caller wants to test it
+) {
 // determine flags
-Bytecodes::Code code = bytecode();
+const Bytecodes::Code code = bytecode();
 const bool is_invokeinterface  = code == Bytecodes::_invokeinterface;
 const bool is_invokedynamic    = code == Bytecodes::_invokedynamic;
+const bool is_invokehandle     = code == Bytecodes::_invokehandle;
 const bool is_invokevirtual    = code == Bytecodes::_invokevirtual;
 const bool is_invokespecial    = code == Bytecodes::_invokespecial;
-const bool load_receiver      = (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic);
+const bool load_receiver       = (recv  != noreg);
-const bool receiver_null_check = is_invokespecial;
+const bool save_flags          = (flags != noreg);
-const bool save_flags = is_invokeinterface || is_invokevirtual;
+assert(load_receiver == (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic), "");
+assert(save_flags    == (is_invokeinterface || is_invokevirtual), "need flags for vfinal");
+assert(flags == noreg || flags == rdx, "");
+assert(recv  == noreg || recv  == rcx, "");
 // setup registers & access constant pool cache
-const Register recv   = rcx;
+if (recv  == noreg)  recv  = rcx;
-const Register flags  = rdx;
+if (flags == noreg)  flags = rdx;
 assert_different_registers(method, index, recv, flags);
 // save 'interpreter return address'
 __ save_bcp();
 load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
+// maybe push appendix to arguments (just before return address)
+if (is_invokedynamic || is_invokehandle) {
+Label L_no_push;
+__ verify_oop(index);
+__ testl(flags, (1 << ConstantPoolCacheEntry::has_appendix_shift));
+__ jccb(Assembler::zero, L_no_push);
+// Push the appendix as a trailing parameter.
+// This must be done before we get the receiver,
+// since the parameter_size includes it.
+__ push(index);  // push appendix (MethodType, CallSite, etc.)
+__ bind(L_no_push);
+}
 // load receiver if needed (note: no return address pushed yet)
 if (load_receiver) {
-assert(!is_invokedynamic, "");
 __ movl(recv, flags);
-__ andl(recv, 0xFF);
+__ andl(recv, ConstantPoolCacheEntry::parameter_size_mask);
-// recv count is 0 based?
+const int no_return_pc_pushed_yet = -1;  // argument slot correction before we push return address
-Address recv_addr(rsp, recv, Interpreter::stackElementScale(), -Interpreter::expr_offset_in_bytes(1));
+const int receiver_is_at_end      = -1;  // back off one slot to get receiver
+Address recv_addr = __ argument_address(recv, no_return_pc_pushed_yet + receiver_is_at_end);
 __ movptr(recv, recv_addr);
 __ verify_oop(recv);
 }
-// do null check if needed
-if (receiver_null_check) {
-__ null_check(recv);
-}
 if (save_flags) {
 __ mov(rsi, flags);
 }
 // compute return type
-__ shrl(flags, ConstantPoolCacheEntry::tosBits);
+__ shrl(flags, ConstantPoolCacheEntry::tos_state_shift);
-// Make sure we don't need to mask flags for tosBits after the above shift
+// Make sure we don't need to mask flags after the above shift
-ConstantPoolCacheEntry::verify_tosBits();
+ConstantPoolCacheEntry::verify_tos_state_shift();
 // load return address
 {
-address table_addr;
+const address table_addr = (is_invokeinterface || is_invokedynamic) ?
-if (is_invokeinterface || is_invokedynamic)
+(address)Interpreter::return_5_addrs_by_index_table() :
-table_addr = (address)Interpreter::return_5_addrs_by_index_table();
+(address)Interpreter::return_3_addrs_by_index_table();
-else
-table_addr = (address)Interpreter::return_3_addrs_by_index_table();
 ExternalAddress table(table_addr);
 __ movptr(flags, ArrayAddress(table, Address(noreg, flags, Address::times_ptr)));
 }
 // push return address
 __ push(flags);
-// Restore flag value from the constant pool cache, and restore rsi
+// Restore flags value from the constant pool cache, and restore rsi
 // for later null checks.  rsi is the bytecode pointer
 if (save_flags) {
 __ mov(flags, rsi);
 __ restore_bcp();
 }
 }
-void TemplateTable::invokevirtual_helper(Register index, Register recv,
+void TemplateTable::invokevirtual_helper(Register index,
-Register flags) {
+Register recv,
+Register flags) {
 // Uses temporary registers rax, rdx
 assert_different_registers(index, recv, rax, rdx);
+assert(index == rbx, "");
+assert(recv  == rcx, "");
 // Test for an invoke of a final method
 Label notFinal;
 __ movl(rax, flags);
-__ andl(rax, (1 << ConstantPoolCacheEntry::vfinalMethod));
+__ andl(rax, (1 << ConstantPoolCacheEntry::is_vfinal_shift));
 __ jcc(Assembler::zero, notFinal);
-Register method = index;  // method must be rbx,
+const Register method = index;  // method must be rbx
-assert(method == rbx, "methodOop must be rbx, for interpreter calling convention");
+assert(method == rbx,
+"methodOop must be rbx for interpreter calling convention");
 // do the call - the index is actually the method to call
+// that is, f2 is a vtable index if !is_vfinal, else f2 is a methodOop
 __ verify_oop(method);
 // It's final, need a null check here!
 __ null_check(recv);
 __ bind(notFinal);
 // get receiver klass
 __ null_check(recv, oopDesc::klass_offset_in_bytes());
-// Keep recv in rcx for callee expects it there
 __ load_klass(rax, recv);
 __ verify_oop(rax);
 // profile this call
 __ profile_virtual_call(rax, rdi, rdx);
 // get target methodOop & entry point
-const int base = instanceKlass::vtable_start_offset() * wordSize;
+__ lookup_virtual_method(rax, index, method);
-assert(vtableEntry::size() * wordSize == 4, "adjust the scaling in the code below");
-__ movptr(method, Address(rax, index, Address::times_ptr, base + vtableEntry::method_offset_in_bytes()));
 __ jump_from_interpreted(method, rdx);
 }
 void TemplateTable::invokevirtual(int byte_no) {
 transition(vtos, vtos);
 assert(byte_no == f2_byte, "use this argument");
-prepare_invoke(rbx, noreg, byte_no);
+prepare_invoke(byte_no,
+rbx,    // method or vtable index
-// rbx,: index
+noreg,  // unused itable index
+rcx, rdx); // recv, flags
+// rbx: index
 // rcx: receiver
 // rdx: flags
 invokevirtual_helper(rbx, rcx, rdx);
 }
 void TemplateTable::invokespecial(int byte_no) {
 transition(vtos, vtos);
 assert(byte_no == f1_byte, "use this argument");
-prepare_invoke(rbx, noreg, byte_no);
+prepare_invoke(byte_no, rbx, noreg,  // get f1 methodOop
+rcx);  // get receiver also for null check
+__ verify_oop(rcx);
+__ null_check(rcx);
 // do the call
 __ verify_oop(rbx);
 __ profile_call(rax);
 __ jump_from_interpreted(rbx, rax);
 }
 void TemplateTable::invokestatic(int byte_no) {
 transition(vtos, vtos);
 assert(byte_no == f1_byte, "use this argument");
-prepare_invoke(rbx, noreg, byte_no);
+prepare_invoke(byte_no, rbx);  // get f1 methodOop
 // do the call
 __ verify_oop(rbx);
 __ profile_call(rax);
 __ jump_from_interpreted(rbx, rax);
 }
 void TemplateTable::invokeinterface(int byte_no) {
 transition(vtos, vtos);
 assert(byte_no == f1_byte, "use this argument");
-prepare_invoke(rax, rbx, byte_no);
+prepare_invoke(byte_no, rax, rbx,  // get f1 klassOop, f2 itable index
+rcx, rdx); // recv, flags
-// rax,: Interface
-// rbx,: index
+// rax: interface klass (from f1)
+// rbx: itable index (from f2)
 // rcx: receiver
 // rdx: flags
 // Special case of invokeinterface called for virtual method of
 // java.lang.Object.  See cpCacheOop.cpp for details.
 // This code isn't produced by javac, but could be produced by
 // another compliant java compiler.
 Label notMethod;
 __ movl(rdi, rdx);
-__ andl(rdi, (1 << ConstantPoolCacheEntry::methodInterface));
+__ andl(rdi, (1 << ConstantPoolCacheEntry::is_forced_virtual_shift));
 __ jcc(Assembler::zero, notMethod);
 invokevirtual_helper(rbx, rcx, rdx);
 __ bind(notMethod);
 // Get receiver klass into rdx - also a null check
 __ restore_locals();  // restore rdi
+__ null_check(rcx, oopDesc::klass_offset_in_bytes());
 __ load_klass(rdx, rcx);
 __ verify_oop(rdx);
 // profile this call
 __ profile_virtual_call(rdx, rsi, rdi);
 rdx, rax, rbx,
 // outputs: method, scan temp. reg
 rbx, rsi,
 no_such_interface);
-// rbx,: methodOop to call
+// rbx: methodOop to call
 // rcx: receiver
 // Check for abstract method error
 // Note: This should be done more efficiently via a throw_abstract_method_error
 //       interpreter entry point and a conditional jump to it in case of a null
 //       method.
 InterpreterRuntime::throw_IncompatibleClassChangeError));
 // the call_VM checks for exception, so we should never return here.
 __ should_not_reach_here();
 }
+void TemplateTable::invokehandle(int byte_no) {
+transition(vtos, vtos);
+assert(byte_no == f12_oop, "use this argument");
+const Register rbx_method = rbx;  // (from f2)
+const Register rax_mtype  = rax;  // (from f1)
+const Register rcx_recv   = rcx;
+const Register rdx_flags  = rdx;
+if (!EnableInvokeDynamic) {
+// rewriter does not generate this bytecode
+__ should_not_reach_here();
+return;
+}
+prepare_invoke(byte_no,
+rbx_method, rax_mtype,  // get f2 methodOop, f1 MethodType
+rcx_recv);
+__ verify_oop(rbx_method);
+__ verify_oop(rcx_recv);
+__ null_check(rcx_recv);
+// Note:  rax_mtype is already pushed (if necessary) by prepare_invoke
+// FIXME: profile the LambdaForm also
+__ profile_final_call(rax);
+__ jump_from_interpreted(rbx_method, rdx);
+}
 void TemplateTable::invokedynamic(int byte_no) {
 transition(vtos, vtos);
-assert(byte_no == f1_oop, "use this argument");
+assert(byte_no == f12_oop, "use this argument");
 if (!EnableInvokeDynamic) {
 // We should not encounter this bytecode if !EnableInvokeDynamic.
 // The verifier will stop it.  However, if we get past the verifier,
 // this will stop the thread in a reasonable way, without crashing the JVM.
 // the call_VM checks for exception, so we should never return here.
 __ should_not_reach_here();
 return;
 }
-prepare_invoke(rax, rbx, byte_no);
+const Register rbx_method   = rbx;
+const Register rax_callsite = rax;
-// rax: CallSite object (f1)
-// rbx: unused (f2)
+prepare_invoke(byte_no, rbx_method, rax_callsite);
-// rcx: receiver address
-// rdx: flags (unused)
+// rax: CallSite object (from f1)
+// rbx: MH.linkToCallSite method (from f2)
-Register rax_callsite      = rax;
-Register rcx_method_handle = rcx;
+// Note:  rax_callsite is already pushed by prepare_invoke
 // %%% should make a type profile for any invokedynamic that takes a ref argument
 // profile this call
 __ profile_call(rsi);
 __ verify_oop(rax_callsite);
-__ load_heap_oop(rcx_method_handle, Address(rax_callsite, __ delayed_value(java_lang_invoke_CallSite::target_offset_in_bytes, rdx)));
-__ null_check(rcx_method_handle);
+__ jump_from_interpreted(rbx_method, rdx);
-__ verify_oop(rcx_method_handle);
-__ prepare_to_jump_from_interpreted();
-__ jump_to_method_handle_entry(rcx_method_handle, rdx);
 }
 //----------------------------------------------------------------------------------------------------
 // Allocation

Mercurial > hg > graal-jvmci-8

comparison src/cpu/x86/vm/templateTable_x86_32.cpp @ 6266:1d7922586cf6