--- a/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Aug 31 16:39:35 2012 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Sat Sep 01 13:25:18 2012 -0400
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,7 +27,7 @@
#include "interpreter/interpreterRuntime.hpp"
#include "interpreter/templateTable.hpp"
#include "memory/universe.inline.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
#include "oops/objArrayKlass.hpp"
#include "oops/oop.inline.hpp"
#include "prims/methodHandles.hpp"
@@ -152,7 +152,7 @@
void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
int byte_no) {
- // With sharing on, may need to test methodOop flag.
+ // With sharing on, may need to test Method* flag.
if (!RewriteBytecodes) return;
Label L_patch_done;
@@ -304,14 +304,12 @@
}
__ get_cpool_and_tags(O0, O2);
- const int base_offset = constantPoolOopDesc::header_size() * wordSize;
- const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
+ const int base_offset = ConstantPool::header_size() * wordSize;
+ const int tags_offset = Array<u1>::base_offset_in_bytes();
// get type from tags
__ add(O2, tags_offset, O2);
__ ldub(O2, O1, O2);
- // unresolved string? If so, must resolve
- __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedString, Assembler::equal, Assembler::pt, call_ldc);
// unresolved class? If so, must resolve
__ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClass, Assembler::equal, Assembler::pt, call_ldc);
@@ -346,9 +344,7 @@
__ brx(Assembler::notEqual, true, Assembler::pt, notString);
__ delayed()->ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);
__ bind(isString);
- __ ld_ptr(O0, O1, Otos_i);
- __ verify_oop(Otos_i);
- __ push(atos);
+ __ stop("string should be rewritten to fast_aldc");
__ ba_short(exit);
__ bind(notString);
@@ -364,53 +360,36 @@
void TemplateTable::fast_aldc(bool wide) {
transition(vtos, atos);
- 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.
- __ call_VM(noreg, CAST_FROM_FN_PTR(address,
- InterpreterRuntime::throw_IncompatibleClassChangeError));
- // the call_VM checks for exception, so we should never return here.
- __ should_not_reach_here();
- return;
- }
-
- Register Rcache = G3_scratch;
- Register Rscratch = G4_scratch;
-
- resolve_cache_and_index(f12_oop, Otos_i, Rcache, Rscratch, wide ? sizeof(u2) : sizeof(u1));
-
+ int index_size = wide ? sizeof(u2) : sizeof(u1);
+ Label resolved;
+
+ // We are resolved if the resolved reference cache entry contains a
+ // non-null object (CallSite, etc.)
+ assert_different_registers(Otos_i, G3_scratch);
+ __ get_cache_index_at_bcp(Otos_i, G3_scratch, 1, index_size); // load index => G3_scratch
+ __ load_resolved_reference_at_index(Otos_i, G3_scratch);
+ __ tst(Otos_i);
+ __ br(Assembler::notEqual, false, Assembler::pt, resolved);
+ __ delayed()->set((int)bytecode(), O1);
+
+ address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
+
+ // first time invocation - must resolve first
+ __ call_VM(Otos_i, entry, O1);
+ __ bind(resolved);
__ verify_oop(Otos_i);
-
- Label L_done;
- const Register Rcon_klass = G3_scratch; // same as Rcache
- const Register Rarray_klass = G4_scratch; // same as Rscratch
- __ load_klass(Otos_i, Rcon_klass);
- AddressLiteral array_klass_addr((address)Universe::systemObjArrayKlassObj_addr());
- __ load_contents(array_klass_addr, Rarray_klass);
- __ cmp_and_brx_short(Rarray_klass, Rcon_klass, Assembler::notEqual, Assembler::pt, L_done);
- __ ld(Address(Otos_i, arrayOopDesc::length_offset_in_bytes()), Rcon_klass);
- __ tst(Rcon_klass);
- __ brx(Assembler::zero, true, Assembler::pt, L_done);
- __ delayed()->clr(Otos_i); // executed only if branch is taken
-
- // Load the exception from the system-array which wraps it:
- __ load_heap_oop(Otos_i, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i);
- __ throw_if_not_x(Assembler::never, Interpreter::throw_exception_entry(), G3_scratch);
-
- __ bind(L_done);
}
+
void TemplateTable::ldc2_w() {
transition(vtos, vtos);
- Label retry, resolved, Long, exit;
-
- __ bind(retry);
+ Label Long, exit;
+
__ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned);
__ get_cpool_and_tags(O0, O2);
- const int base_offset = constantPoolOopDesc::header_size() * wordSize;
- const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
+ const int base_offset = ConstantPool::header_size() * wordSize;
+ const int tags_offset = Array<u1>::base_offset_in_bytes();
// get type from tags
__ add(O2, tags_offset, O2);
__ ldub(O2, O1, O2);
@@ -421,7 +400,7 @@
__ cmp_and_brx_short(O2, JVM_CONSTANT_Double, Assembler::notEqual, Assembler::pt, Long);
// A double can be placed at word-aligned locations in the constant pool.
// Check out Conversions.java for an example.
- // Also constantPoolOopDesc::header_size() is 20, which makes it very difficult
+ // Also ConstantPool::header_size() is 20, which makes it very difficult
// to double-align double on the constant pool. SG, 11/7/97
#ifdef _LP64
__ ldf(FloatRegisterImpl::D, G3_scratch, base_offset, Ftos_d);
@@ -1595,7 +1574,6 @@
void TemplateTable::branch(bool is_jsr, bool is_wide) {
// Note: on SPARC, we use InterpreterMacroAssembler::if_cmp also.
- __ verify_oop(Lmethod);
__ verify_thread();
const Register O2_bumped_count = O2;
@@ -1611,9 +1589,9 @@
// non-JSR normal-branch stuff occurring below.
if( is_jsr ) {
// compute return address as bci in Otos_i
- __ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
+ __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
__ sub(Lbcp, G3_scratch, G3_scratch);
- __ sub(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()) - (is_wide ? 5 : 3), Otos_i);
+ __ sub(G3_scratch, in_bytes(ConstMethod::codes_offset()) - (is_wide ? 5 : 3), Otos_i);
// Bump Lbcp to target of JSR
__ add(Lbcp, O1_disp, Lbcp);
@@ -1645,20 +1623,20 @@
int mask = ((1 << Tier0BackedgeNotifyFreqLog) - 1) << InvocationCounter::count_shift;
if (ProfileInterpreter) {
// If no method data exists, go to profile_continue.
- __ ld_ptr(Lmethod, methodOopDesc::method_data_offset(), G4_scratch);
+ __ ld_ptr(Lmethod, Method::method_data_offset(), G4_scratch);
__ br_null_short(G4_scratch, Assembler::pn, Lno_mdo);
// Increment backedge counter in the MDO
- Address mdo_backedge_counter(G4_scratch, in_bytes(methodDataOopDesc::backedge_counter_offset()) +
+ Address mdo_backedge_counter(G4_scratch, in_bytes(MethodData::backedge_counter_offset()) +
in_bytes(InvocationCounter::counter_offset()));
__ increment_mask_and_jump(mdo_backedge_counter, increment, mask, G3_scratch, Lscratch,
Assembler::notZero, &Lforward);
__ ba_short(Loverflow);
}
- // If there's no MDO, increment counter in methodOop
+ // If there's no MDO, increment counter in Method*
__ bind(Lno_mdo);
- Address backedge_counter(Lmethod, in_bytes(methodOopDesc::backedge_counter_offset()) +
+ Address backedge_counter(Lmethod, in_bytes(Method::backedge_counter_offset()) +
in_bytes(InvocationCounter::counter_offset()));
__ increment_mask_and_jump(backedge_counter, increment, mask, G3_scratch, Lscratch,
Assembler::notZero, &Lforward);
@@ -1791,9 +1769,9 @@
__ profile_ret(vtos, Otos_i, G4_scratch);
- __ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
+ __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
__ add(G3_scratch, Otos_i, G3_scratch);
- __ add(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()), Lbcp);
+ __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp);
__ dispatch_next(vtos);
}
@@ -1806,9 +1784,9 @@
__ profile_ret(vtos, Otos_i, G4_scratch);
- __ ld_ptr(Lmethod, methodOopDesc::const_offset(), G3_scratch);
+ __ ld_ptr(Lmethod, Method::const_offset(), G3_scratch);
__ add(G3_scratch, Otos_i, G3_scratch);
- __ add(G3_scratch, in_bytes(constMethodOopDesc::codes_offset()), Lbcp);
+ __ add(G3_scratch, in_bytes(ConstMethod::codes_offset()), Lbcp);
__ dispatch_next(vtos);
}
@@ -2086,34 +2064,17 @@
// ----------------------------------------------------------------------------
void TemplateTable::resolve_cache_and_index(int byte_no,
- Register result,
Register Rcache,
Register index,
size_t index_size) {
// Depends on cpCacheOop layout!
Label resolved;
- if (byte_no == f12_oop) {
- // 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 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, "");
- assert_different_registers(result, Rcache);
- __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
- __ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() +
- ConstantPoolCacheEntry::f1_offset(), result);
- __ tst(result);
- __ br(Assembler::notEqual, false, Assembler::pt, resolved);
- __ delayed()->set((int)bytecode(), O1);
- } else {
assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
- assert(result == noreg, ""); //else change code for setting result
__ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, Lbyte_code, byte_no, 1, index_size);
__ cmp(Lbyte_code, (int) bytecode()); // have we resolved this bytecode?
__ br(Assembler::equal, false, Assembler::pt, resolved);
__ delayed()->set((int)bytecode(), O1);
- }
address entry;
switch (bytecode()) {
@@ -2127,8 +2088,6 @@
case Bytecodes::_invokeinterface: entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke); break;
case Bytecodes::_invokehandle : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokehandle); break;
case Bytecodes::_invokedynamic : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invokedynamic); break;
- case Bytecodes::_fast_aldc : entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc); 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;
@@ -2137,9 +2096,6 @@
__ call_VM(noreg, entry, O1);
// Update registers with resolved info
__ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
- if (result != noreg)
- __ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() +
- ConstantPoolCacheEntry::f1_offset(), result);
__ bind(resolved);
}
@@ -2158,37 +2114,29 @@
// 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() +
+ ConstantPoolCache::base_offset() +
((byte_no == f2_byte)
? ConstantPoolCacheEntry::f2_offset()
: ConstantPoolCacheEntry::f1_offset()
)
);
- const int flags_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
+ const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
ConstantPoolCacheEntry::flags_offset());
// access constant pool cache fields
- const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
+ const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
ConstantPoolCacheEntry::f2_offset());
if (is_invokevfinal) {
__ get_cache_and_index_at_bcp(cache, index, 1);
__ ld_ptr(Address(cache, method_offset), method);
- } else if (byte_no == f12_oop) {
- // Resolved f1_oop (CallSite, MethodType, etc.) goes into 'itable_index'.
- // Resolved f2_oop (methodOop invoker) will go into 'method' (at index_offset).
- // See ConstantPoolCacheEntry::set_dynamic_call and set_method_handle.
+ } else {
size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
- resolve_cache_and_index(byte_no, itable_index, cache, index, index_size);
- __ ld_ptr(Address(cache, index_offset), method);
- itable_index = noreg; // hack to disable load below
- } else {
- resolve_cache_and_index(byte_no, noreg, cache, index, sizeof(u2));
+ resolve_cache_and_index(byte_no, cache, index, index_size);
__ ld_ptr(Address(cache, method_offset), method);
}
if (itable_index != noreg) {
- // pick up itable index from f2 also:
- assert(byte_no == f1_byte, "already picked up f1");
+ // pick up itable or appendix index from f2 also:
__ ld_ptr(Address(cache, index_offset), itable_index);
}
__ ld_ptr(Address(cache, flags_offset), flags);
@@ -2203,12 +2151,14 @@
bool is_static) {
assert_different_registers(Rcache, Rflags, Roffset);
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::flags_offset(), Rflags);
__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
if (is_static) {
__ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f1_offset(), Robj);
+ const int mirror_offset = in_bytes(Klass::java_mirror_offset());
+ __ ld_ptr( Robj, mirror_offset, Robj);
}
}
@@ -2218,7 +2168,7 @@
Register index,
bool is_static,
bool has_tos) {
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
if (JvmtiExport::can_post_field_access()) {
// Check to see if a field access watch has been set before we take
@@ -2264,9 +2214,9 @@
Register Rclass = Rcache;
Register Roffset= G4_scratch;
Register Rflags = G1_scratch;
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
-
- resolve_cache_and_index(byte_no, noreg, Rcache, index, sizeof(u2));
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
+
+ resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2));
jvmti_post_field_access(Rcache, index, is_static, false);
load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static);
@@ -2439,7 +2389,7 @@
Register index = G4_scratch;
Register Roffset = G4_scratch;
Register Rflags = Rcache;
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
__ get_cache_and_index_at_bcp(Rcache, index, 1);
jvmti_post_field_access(Rcache, index, /*is_static*/false, /*has_tos*/true);
@@ -2550,7 +2500,7 @@
// The registers Rcache and index expected to be set before call.
// The function may destroy various registers, just not the Rcache and index registers.
void TemplateTable::jvmti_post_field_mod(Register Rcache, Register index, bool is_static) {
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
if (JvmtiExport::can_post_field_modification()) {
// Check to see if a field modification watch has been set before we take
@@ -2624,9 +2574,9 @@
Register Rclass = Rcache;
Register Roffset= G4_scratch;
Register Rflags = G1_scratch;
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
-
- resolve_cache_and_index(byte_no, noreg, Rcache, index, sizeof(u2));
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
+
+ resolve_cache_and_index(byte_no, Rcache, index, sizeof(u2));
jvmti_post_field_mod(Rcache, index, is_static);
load_field_cp_cache_entry(Rclass, Rcache, index, Roffset, Rflags, is_static);
@@ -2831,7 +2781,7 @@
Register Rclass = Rcache;
Register Roffset= G4_scratch;
Register Rflags = G1_scratch;
- ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ ByteSize cp_base_offset = ConstantPoolCache::base_offset();
jvmti_post_fast_field_mod();
@@ -2903,7 +2853,7 @@
// access constant pool cache (is resolved)
__ get_cache_and_index_at_bcp(Rcache, G4_scratch, 2);
- __ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset(), Roffset);
+ __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::f2_offset(), Roffset);
__ add(Lbcp, 1, Lbcp); // needed to report exception at the correct bcp
__ verify_oop(Rreceiver);
@@ -2923,7 +2873,7 @@
if (__ membar_has_effect(membar_bits)) {
// Get is_volatile value in Rflags and check if membar is needed
- __ ld_ptr(Rcache, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset(), Rflags);
+ __ ld_ptr(Rcache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset(), Rflags);
// Test volatile
Label notVolatile;
@@ -2947,7 +2897,6 @@
ShouldNotReachHere();
}
-
void TemplateTable::prepare_invoke(int byte_no,
Register method, // linked method (or i-klass)
Register ra, // return address
@@ -2980,7 +2929,6 @@
// maybe push appendix to arguments
if (is_invokedynamic || is_invokehandle) {
Label L_no_push;
- __ verify_oop(index);
__ set((1 << ConstantPoolCacheEntry::has_appendix_shift), temp);
__ btst(flags, temp);
__ br(Assembler::zero, false, Assembler::pt, L_no_push);
@@ -2988,7 +2936,9 @@
// Push the appendix as a trailing parameter.
// This must be done before we get the receiver,
// since the parameter_size includes it.
- __ push_ptr(index); // push appendix (MethodType, CallSite, etc.)
+ __ load_resolved_reference_at_index(temp, index);
+ __ verify_oop(temp);
+ __ push_ptr(temp); // push appendix (MethodType, CallSite, etc.)
__ bind(L_no_push);
}
@@ -3021,7 +2971,7 @@
Register Rcall = Rindex;
assert_different_registers(Rcall, G5_method, Gargs, Rret);
- // get target methodOop & entry point
+ // get target Method* & entry point
__ lookup_virtual_method(Rrecv, Rindex, G5_method);
__ call_from_interpreter(Rcall, Gargs, Rret);
}
@@ -3088,10 +3038,8 @@
void TemplateTable::invokevfinal_helper(Register Rscratch, Register Rret) {
Register Rtemp = G4_scratch;
- __ verify_oop(G5_method);
-
// Load receiver from stack slot
- __ lduh(G5_method, in_bytes(methodOopDesc::size_of_parameters_offset()), G4_scratch);
+ __ lduh(G5_method, in_bytes(Method::size_of_parameters_offset()), G4_scratch);
__ load_receiver(G4_scratch, O0);
// receiver NULL check
@@ -3126,7 +3074,6 @@
__ null_check(O0_recv);
// do the call
- __ verify_oop(G5_method);
__ profile_call(O4);
__ call_from_interpreter(Rscratch, Gargs, Rret);
}
@@ -3139,16 +3086,14 @@
const Register Rret = Lscratch;
const Register Rscratch = G3_scratch;
- prepare_invoke(byte_no, G5_method, Rret); // get f1 methodOop
+ prepare_invoke(byte_no, G5_method, Rret); // get f1 Method*
// do the call
- __ verify_oop(G5_method);
__ profile_call(O4);
__ call_from_interpreter(Rscratch, Gargs, Rret);
}
-
-void TemplateTable::invokeinterface_object_method(Register RklassOop,
+void TemplateTable::invokeinterface_object_method(Register RKlass,
Register Rcall,
Register Rret,
Register Rflags) {
@@ -3167,14 +3112,14 @@
__ profile_final_call(O4);
- // do the call - the index (f2) contains the methodOop
+ // do the call - the index (f2) contains the Method*
assert_different_registers(G5_method, Gargs, Rcall);
__ mov(Rindex, G5_method);
__ call_from_interpreter(Rcall, Gargs, Rret);
__ bind(notFinal);
- __ profile_virtual_call(RklassOop, O4);
- generate_vtable_call(RklassOop, Rindex, Rret);
+ __ profile_virtual_call(RKlass, O4);
+ generate_vtable_call(RKlass, Rindex, Rret);
}
@@ -3187,7 +3132,7 @@
const Register Rindex = Lscratch;
const Register O0_recv = O0;
const Register O1_flags = O1;
- const Register O2_klassOop = O2;
+ const Register O2_Klass = O2;
const Register Rscratch = G4_scratch;
assert_different_registers(Rscratch, G5_method);
@@ -3195,8 +3140,7 @@
// get receiver klass
__ null_check(O0_recv, oopDesc::klass_offset_in_bytes());
- __ load_klass(O0_recv, O2_klassOop);
- __ verify_oop(O2_klassOop);
+ __ load_klass(O0_recv, O2_Klass);
// Special case of invokeinterface called for virtual method of
// java.lang.Object. See cpCacheOop.cpp for details.
@@ -3208,22 +3152,22 @@
__ br(Assembler::zero, false, Assembler::pt, notMethod);
__ delayed()->nop();
- invokeinterface_object_method(O2_klassOop, Rinterface, Rret, O1_flags);
+ invokeinterface_object_method(O2_Klass, Rinterface, Rret, O1_flags);
__ bind(notMethod);
- __ profile_virtual_call(O2_klassOop, O4);
+ __ profile_virtual_call(O2_Klass, O4);
//
// find entry point to call
//
// compute start of first itableOffsetEntry (which is at end of vtable)
- const int base = instanceKlass::vtable_start_offset() * wordSize;
+ const int base = InstanceKlass::vtable_start_offset() * wordSize;
Label search;
Register Rtemp = O1_flags;
- __ ld(O2_klassOop, instanceKlass::vtable_length_offset() * wordSize, Rtemp);
+ __ ld(O2_Klass, InstanceKlass::vtable_length_offset() * wordSize, Rtemp);
if (align_object_offset(1) > 1) {
__ round_to(Rtemp, align_object_offset(1));
}
@@ -3234,7 +3178,7 @@
__ set(base, Rscratch);
__ add(Rscratch, Rtemp, Rtemp);
}
- __ add(O2_klassOop, Rtemp, Rscratch);
+ __ add(O2_Klass, Rtemp, Rscratch);
__ bind(search);
@@ -3251,11 +3195,8 @@
call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError));
__ should_not_reach_here();
__ bind(ok);
- __ verify_oop(Rtemp);
}
- __ verify_oop(Rinterface);
-
__ cmp(Rinterface, Rtemp);
__ brx(Assembler::notEqual, true, Assembler::pn, search);
__ delayed()->add(Rscratch, itableOffsetEntry::size() * wordSize, Rscratch);
@@ -3266,7 +3207,7 @@
assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust instruction below");
__ sll(Rindex, exact_log2(itableMethodEntry::size() * wordSize), Rindex); // Rindex *= 8;
__ add(Rscratch, Rindex, Rscratch);
- __ ld_ptr(O2_klassOop, Rscratch, G5_method);
+ __ ld_ptr(O2_Klass, Rscratch, G5_method);
// Check for abstract method error.
{
@@ -3280,14 +3221,12 @@
Register Rcall = Rinterface;
assert_different_registers(Rcall, G5_method, Gargs, Rret);
- __ verify_oop(G5_method);
__ call_from_interpreter(Rcall, Gargs, Rret);
}
-
void TemplateTable::invokehandle(int byte_no) {
transition(vtos, vtos);
- assert(byte_no == f12_oop, "use this argument");
+ assert(byte_no == f1_byte, "use this argument");
if (!EnableInvokeDynamic) {
// rewriter does not generate this bytecode
@@ -3303,13 +3242,13 @@
prepare_invoke(byte_no, G5_method, Rret, G4_mtype, O0_recv);
__ null_check(O0_recv);
- // G4: MethodType object (from f1)
+ // G4: MethodType object (from cpool->resolved_references[])
// G5: MH.linkToCallSite method (from f2)
// Note: G4_mtype is already pushed (if necessary) by prepare_invoke
// do the call
- __ verify_oop(G5_method);
+ __ verify_oop(G4_mtype);
__ profile_final_call(O4); // FIXME: profile the LambdaForm also
__ call_from_interpreter(Rscratch, Gargs, Rret);
}
@@ -3317,7 +3256,7 @@
void TemplateTable::invokedynamic(int byte_no) {
transition(vtos, vtos);
- assert(byte_no == f12_oop, "use this argument");
+ assert(byte_no == f1_byte, "use this argument");
if (!EnableInvokeDynamic) {
// We should not encounter this bytecode if !EnableInvokeDynamic.
@@ -3336,8 +3275,8 @@
prepare_invoke(byte_no, G5_method, Rret, G4_callsite);
- // G4: CallSite object (from f1)
- // G5: MH.linkToCallSite method (from f2)
+ // G4: CallSite object (from cpool->resolved_references[])
+ // G5: MH.linkToCallSite method (from f1)
// Note: G4_callsite is already pushed by prepare_invoke
@@ -3346,7 +3285,7 @@
__ profile_call(O4);
// do the call
- __ verify_oop(G5_method);
+ __ verify_oop(G4_callsite);
__ call_from_interpreter(Rscratch, Gargs, Rret);
}
@@ -3370,25 +3309,25 @@
__ get_2_byte_integer_at_bcp(1, Rscratch, Roffset, InterpreterMacroAssembler::Unsigned);
__ get_cpool_and_tags(Rscratch, G3_scratch);
// make sure the class we're about to instantiate has been resolved
- // This is done before loading instanceKlass to be consistent with the order
- // how Constant Pool is updated (see constantPoolOopDesc::klass_at_put)
- __ add(G3_scratch, typeArrayOopDesc::header_size(T_BYTE) * wordSize, G3_scratch);
+ // This is done before loading InstanceKlass to be consistent with the order
+ // how Constant Pool is updated (see ConstantPool::klass_at_put)
+ __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
__ ldub(G3_scratch, Roffset, G3_scratch);
__ cmp(G3_scratch, JVM_CONSTANT_Class);
__ br(Assembler::notEqual, false, Assembler::pn, slow_case);
__ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
- // get instanceKlass
+ // get InstanceKlass
//__ sll(Roffset, LogBytesPerWord, Roffset); // executed in delay slot
- __ add(Roffset, sizeof(constantPoolOopDesc), Roffset);
+ __ add(Roffset, sizeof(ConstantPool), Roffset);
__ ld_ptr(Rscratch, Roffset, RinstanceKlass);
// make sure klass is fully initialized:
- __ ldub(RinstanceKlass, in_bytes(instanceKlass::init_state_offset()), G3_scratch);
- __ cmp(G3_scratch, instanceKlass::fully_initialized);
+ __ ldub(RinstanceKlass, in_bytes(InstanceKlass::init_state_offset()), G3_scratch);
+ __ cmp(G3_scratch, InstanceKlass::fully_initialized);
__ br(Assembler::notEqual, false, Assembler::pn, slow_case);
__ delayed()->ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset);
- // get instance_size in instanceKlass (already aligned)
+ // get instance_size in InstanceKlass (already aligned)
//__ ld(RinstanceKlass, in_bytes(Klass::layout_helper_offset()), Roffset);
// make sure klass does not have has_finalizer, or is abstract, or interface or java/lang/Class
@@ -3584,21 +3523,22 @@
// See if the checkcast has been quickened
__ get_cpool_and_tags(Lscratch, G3_scratch);
- __ add(G3_scratch, typeArrayOopDesc::header_size(T_BYTE) * wordSize, G3_scratch);
+ __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
__ ldub(G3_scratch, Roffset, G3_scratch);
__ cmp(G3_scratch, JVM_CONSTANT_Class);
__ br(Assembler::equal, true, Assembler::pt, quicked);
__ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
__ push_ptr(); // save receiver for result, and for GC
- call_VM(RspecifiedKlass, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
+ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
+ __ get_vm_result_2(RspecifiedKlass);
__ pop_ptr(Otos_i, G3_scratch); // restore receiver
__ ba_short(resolved);
// Extract target class from constant pool
__ bind(quicked);
- __ add(Roffset, sizeof(constantPoolOopDesc), Roffset);
+ __ add(Roffset, sizeof(ConstantPool), Roffset);
__ ld_ptr(Lscratch, Roffset, RspecifiedKlass);
__ bind(resolved);
__ load_klass(Otos_i, RobjKlass); // get value klass
@@ -3639,21 +3579,22 @@
// See if the checkcast has been quickened
__ get_cpool_and_tags(Lscratch, G3_scratch);
- __ add(G3_scratch, typeArrayOopDesc::header_size(T_BYTE) * wordSize, G3_scratch);
+ __ add(G3_scratch, Array<u1>::base_offset_in_bytes(), G3_scratch);
__ ldub(G3_scratch, Roffset, G3_scratch);
__ cmp(G3_scratch, JVM_CONSTANT_Class);
__ br(Assembler::equal, true, Assembler::pt, quicked);
__ delayed()->sll(Roffset, LogBytesPerWord, Roffset);
__ push_ptr(); // save receiver for result, and for GC
- call_VM(RspecifiedKlass, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
+ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc) );
+ __ get_vm_result_2(RspecifiedKlass);
__ pop_ptr(Otos_i, G3_scratch); // restore receiver
__ ba_short(resolved);
// Extract target class from constant pool
__ bind(quicked);
- __ add(Roffset, sizeof(constantPoolOopDesc), Roffset);
+ __ add(Roffset, sizeof(ConstantPool), Roffset);
__ get_constant_pool(Lscratch);
__ ld_ptr(Lscratch, Roffset, RspecifiedKlass);
__ bind(resolved);