jdk-sandbox: comparison hotspot/src/cpu/x86/vm/templateTable_x86

equal deleted inserted replaced

-:0e4c848d5c06
+:201c5cde25bb
 if (os::is_MP()) { // Not needed on single CPU
 __ membar(order_constraint);
 }
 }
-void TemplateTable::resolve_cache_and_index(int byte_no, Register Rcache, Register index) {
+void TemplateTable::resolve_cache_and_index(int byte_no,
-assert(byte_no == 1 || byte_no == 2, "byte_no out of range");
+Register result,
-bool is_invokedynamic = (bytecode() == Bytecodes::_invokedynamic);
+Register Rcache,
+Register index,
+size_t index_size) {
 const Register temp = rbx;
-assert_different_registers(Rcache, index, temp);
+assert_different_registers(result, Rcache, index, temp);
-const int shift_count = (1 + byte_no) * BitsPerByte;
 Label resolved;
-__ get_cache_and_index_at_bcp(Rcache, index, 1, is_invokedynamic);
+__ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
-if (is_invokedynamic) {
+if (byte_no == f1_oop) {
-// we are resolved if the f1 field contains a non-null CallSite object
+// We are resolved if the f1 field contains a non-null object (CallSite, etc.)
-__ cmpptr(Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()), (int32_t) NULL_WORD);
+// This kind of CP cache entry does not need to match the flags byte, because
+// there is a 1-1 relation between bytecode type and CP entry type.
+assert(result != noreg, ""); //else do cmpptr(Address(...), (int32_t) NULL_WORD)
+__ movptr(result, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()));
+__ testptr(result, result);
 __ jcc(Assembler::notEqual, resolved);
 } else {
+assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
+assert(result == noreg, "");  //else change code for setting result
+const int shift_count = (1 + byte_no) * BitsPerByte;
 __ movl(temp, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset()));
 __ shrl(temp, shift_count);
 // have we resolved this bytecode?
 __ andl(temp, 0xFF);
 __ cmpl(temp, (int) bytecode());
 }
 __ movl(temp, (int) bytecode());
 __ call_VM(noreg, entry, temp);
 // Update registers with resolved info
-__ get_cache_and_index_at_bcp(Rcache, index, 1, is_invokedynamic);
+__ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
+if (result != noreg)
+__ movptr(result, Address(Rcache, index, Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f1_offset()));
 __ bind(resolved);
 }
 // The Rcache and index registers must be set before call
 void TemplateTable::load_field_cp_cache_entry(Register obj,
 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);
 ConstantPoolCacheEntry::flags_offset());
 // access constant pool cache fields
 const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
 ConstantPoolCacheEntry::f2_offset());
-resolve_cache_and_index(byte_no, cache, index);
+if (byte_no == f1_oop) {
+// Resolved f1_oop goes directly into 'method' register.
-assert(wordSize == 8, "adjust code below");
+assert(is_invokedynamic, "");
-__ movptr(method, Address(cache, index, Address::times_8, method_offset));
+resolve_cache_and_index(byte_no, method, cache, index, sizeof(u4));
+} 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) {
-__ movptr(itable_index,
+__ movptr(itable_index, Address(cache, index, Address::times_ptr, index_offset));
-Address(cache, index, Address::times_8, index_offset));
+}
-}
+__ movl(flags, Address(cache, index, Address::times_ptr, flags_offset));
-__ movl(flags , Address(cache, index, Address::times_8, flags_offset));
 }
 // The registers cache and index expected to be set before call.
 // Correct values of the cache and index registers are preserved.
 const Register obj   = c_rarg3;
 const Register off   = rbx;
 const Register flags = rax;
 const Register bc = c_rarg3; // uses same reg as obj, so don't mix them
-resolve_cache_and_index(byte_no, cache, index);
+resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
 jvmti_post_field_access(cache, index, is_static, false);
 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
 if (!is_static) {
 // obj is on the stack
 const Register obj   = rcx;
 const Register off   = rbx;
 const Register flags = rax;
 const Register bc    = c_rarg3;
-resolve_cache_and_index(byte_no, cache, index);
+resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
 jvmti_post_field_mod(cache, index, is_static);
 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
 // [jk] not needed currently
 // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
 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);
+load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
 // load receiver if needed (note: no return address pushed yet)
 if (load_receiver) {
+assert(!is_invokedynamic, "");
 __ movl(recv, flags);
 __ andl(recv, 0xFF);
 Address recv_addr(rsp, recv, Address::times_8, -Interpreter::expr_offset_in_bytes(1));
 __ movptr(recv, recv_addr);
 __ verify_oop(recv);
 }
 void TemplateTable::invokevirtual(int byte_no) {
 transition(vtos, vtos);
+assert(byte_no == f2_byte, "use this argument");
 prepare_invoke(rbx, noreg, byte_no);
 // rbx: index
 // rcx: receiver
 // rdx: flags
 }
 void TemplateTable::invokespecial(int byte_no) {
 transition(vtos, vtos);
+assert(byte_no == f1_byte, "use this argument");
 prepare_invoke(rbx, noreg, byte_no);
 // 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);
 // do the call
 __ verify_oop(rbx);
 __ profile_call(rax);
 __ jump_from_interpreted(rbx, rax);
 }
 void TemplateTable::fast_invokevfinal(int byte_no) {
 transition(vtos, vtos);
+assert(byte_no == f2_byte, "use this argument");
 __ stop("fast_invokevfinal not used on amd64");
 }
 void TemplateTable::invokeinterface(int byte_no) {
 transition(vtos, vtos);
+assert(byte_no == f1_byte, "use this argument");
 prepare_invoke(rax, rbx, byte_no);
 // rax: Interface
 // rbx: index
 // rcx: receiver
 return;
 }
 void TemplateTable::invokedynamic(int byte_no) {
 transition(vtos, vtos);
+assert(byte_no == f1_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;
 }
+assert(byte_no == f1_oop, "use this argument");
 prepare_invoke(rax, rbx, byte_no);
 // rax: CallSite object (f1)
 // rbx: unused (f2)
 // rcx: receiver address

changeset 5702	201c5cde25bb
parent 5547	f4b087cbb361
parent 5688	9052dc91ea67
child 5882	6b2aecc4f7d8