graal-compiler: src/cpu/sparc/vm/templateTable

comparison src/cpu/sparc/vm/templateTable_sparc.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	1d7922586cf6
children	75f33eecc1b3

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 /*
-* 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "precompiled.hpp"
 #include "interpreter/interpreter.hpp"
 #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"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubRoutines.hpp"
 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;
 switch (bc) {
 case Bytecodes::_fast_aputfield:
 } else {
 __ ldub(Lbcp, 1, O1);
 }
 __ get_cpool_and_tags(O0, O2);
-const int base_offset = constantPoolOopDesc::header_size() * wordSize;
+const int base_offset = ConstantPool::header_size() * wordSize;
-const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * 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);
 // unresolved class in error state
 __ brx(Assembler::equal, true, Assembler::pt, isString);
 __ delayed()->cmp(O2, JVM_CONSTANT_Object);
 __ brx(Assembler::notEqual, true, Assembler::pt, notString);
 __ delayed()->ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);
 __ bind(isString);
-__ ld_ptr(O0, O1, Otos_i);
+__ stop("string should be rewritten to fast_aldc");
-__ verify_oop(Otos_i);
-__ push(atos);
 __ ba_short(exit);
 __ bind(notString);
 // __ ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);
 __ push(ftos);
 // %%% We should use this to handle Class and String constants also.
 // %%% It will simplify the ldc/primitive path considerably.
 void TemplateTable::fast_aldc(bool wide) {
 transition(vtos, atos);
-if (!EnableInvokeDynamic) {
+int index_size = wide ? sizeof(u2) : sizeof(u1);
-// We should not encounter this bytecode if !EnableInvokeDynamic.
+Label resolved;
-// 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.
+// We are resolved if the resolved reference cache entry contains a
-__ call_VM(noreg, CAST_FROM_FN_PTR(address,
+// non-null object (CallSite, etc.)
-InterpreterRuntime::throw_IncompatibleClassChangeError));
+assert_different_registers(Otos_i, G3_scratch);
-// the call_VM checks for exception, so we should never return here.
+__ get_cache_index_at_bcp(Otos_i, G3_scratch, 1, index_size);  // load index => G3_scratch
-__ should_not_reach_here();
+__ load_resolved_reference_at_index(Otos_i, G3_scratch);
-return;
+__ tst(Otos_i);
-}
+__ br(Assembler::notEqual, false, Assembler::pt, resolved);
+__ delayed()->set((int)bytecode(), O1);
-Register Rcache = G3_scratch;
-Register Rscratch = G4_scratch;
+address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
-resolve_cache_and_index(f12_oop, Otos_i, Rcache, Rscratch, wide ? sizeof(u2) : sizeof(u1));
+// 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;
+Label Long, exit;
-__ bind(retry);
 __ 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 base_offset = ConstantPool::header_size() * wordSize;
-const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
+const int tags_offset = Array<u1>::base_offset_in_bytes();
 // get type from tags
 __ add(O2, tags_offset, O2);
 __ ldub(O2, O1, O2);
 __ sll(O1, LogBytesPerWord, O1);
 __ add(O0, O1, G3_scratch);
 __ 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);
 #else
 FloatRegister f = Ftos_d;
 __ float_cmp( is_float, unordered_result, F2, F0, Otos_i );
 }
 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;
 __ profile_taken_branch(G3_scratch, O2_bumped_count);
 // Handle all the JSR stuff here, then exit.
 // It's much shorter and cleaner than intermingling with the
 // 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);
 // Push returnAddress for "ret" on stack
 __ push_ptr(Otos_i);
 Label Lno_mdo, Loverflow;
 int increment = InvocationCounter::count_increment;
 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);
 __ bind(Loverflow);
 #endif
 #endif
 __ 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);
 }
 void TemplateTable::wide_ret() {
 __ access_local_returnAddress(G3_scratch, Otos_i);
 // Otos_i contains the bci, compute the bcp from that
 __ 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);
 }
 void TemplateTable::tableswitch() {
 __ membar( order_constraint );
 }
 // ----------------------------------------------------------------------------
 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()) {
 case Bytecodes::_getstatic      : // fall through
 case Bytecodes::_putstatic      : // 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::_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;
 }
 // first time invocation - must resolve first
 __ 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);
 }
 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
 Register method,
 assert_different_registers(cache, method, itable_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() +
+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) {
+} else {
-// 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.
 size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
-resolve_cache_and_index(byte_no, itable_index, cache, index, index_size);
+resolve_cache_and_index(byte_no, 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));
 __ ld_ptr(Address(cache, method_offset), method);
 }
 if (itable_index != noreg) {
-// pick up itable index from f2 also:
+// pick up itable or appendix index from f2 also:
-assert(byte_no == f1_byte, "already picked up f1");
 __ ld_ptr(Address(cache, index_offset), itable_index);
 }
 __ ld_ptr(Address(cache, flags_offset), flags);
 }
 Register Roffset,
 Register Rflags,
 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);
 }
 }
 // The registers Rcache and index expected to be set before call.
 // Correct values of the Rcache and index registers are preserved.
 void TemplateTable::jvmti_post_field_access(Register Rcache,
 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
 // the time to call into the VM.
 Label Label1;
 Register Rcache = G3_scratch;
 Register index  = G4_scratch;
 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();
-resolve_cache_and_index(byte_no, noreg, Rcache, index, sizeof(u2));
+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);
 if (!is_static) {
 pop_and_check_object(Rclass);
 transition(atos, state);
 Register Rcache  = G3_scratch;
 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);
 __ ld_ptr(Rcache, cp_base_offset + ConstantPoolCacheEntry::f2_offset(), Roffset);
 }
 // 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
 // the time to call into the VM.
 Label Label1;
 Register Rcache = G3_scratch;
 Register index  = G4_scratch;
 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();
-resolve_cache_and_index(byte_no, noreg, Rcache, index, sizeof(u2));
+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);
 Assembler::Membar_mask_bits read_bits =
 Assembler::Membar_mask_bits(Assembler::LoadStore | Assembler::StoreStore);
 transition(state, vtos);
 Register Rcache = G3_scratch;
 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();
 __ get_cache_and_index_at_bcp(Rcache, G4_scratch, 1);
 __ ld_ptr(Llocals, 0, Rreceiver);
 // 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);
 __ null_check(Rreceiver);
 if (state == atos) {
 Assembler::Membar_mask_bits membar_bits =
 Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore);
 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;
 __ set((1 << ConstantPoolCacheEntry::is_volatile_shift), Lscratch);
 __ btst(Rflags, Lscratch);
 void TemplateTable::count_calls(Register method, Register temp) {
 // implemented elsewhere
 ShouldNotReachHere();
 }
 void TemplateTable::prepare_invoke(int byte_no,
 Register method,  // linked method (or i-klass)
 Register ra,      // return address
 Register index,   // itable index, MethodType, etc.
 __ mov(SP, O5_savedSP);  // record SP that we wanted the callee to restore
 // 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);
 __ delayed()->nop();
 // 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);
 }
 // load receiver if needed (after appendix is pushed so parameter size is correct)
 if (load_receiver) {
 void TemplateTable::generate_vtable_call(Register Rrecv, Register Rindex, Register Rret) {
 Register Rtemp = G4_scratch;
 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);
 }
 void TemplateTable::invokevirtual(int byte_no) {
 }
 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
 __ null_check(O0);
 prepare_invoke(byte_no, G5_method, Rret, noreg, O0_recv);  // get receiver also for null check
 __ null_check(O0_recv);
 // do the call
-__ verify_oop(G5_method);
 __ profile_call(O4);
 __ call_from_interpreter(Rscratch, Gargs, Rret);
 }
 assert(byte_no == f1_byte, "use this argument");
 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 RKlass,
-void TemplateTable::invokeinterface_object_method(Register RklassOop,
 Register Rcall,
 Register Rret,
 Register Rflags) {
 Register Rscratch = G4_scratch;
 Register Rindex = Lscratch;
 __ br(Assembler::zero, false, Assembler::pt, notFinal);
 __ delayed()->nop();
 __ 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);
+__ profile_virtual_call(RKlass, O4);
-generate_vtable_call(RklassOop, Rindex, Rret);
+generate_vtable_call(RKlass, Rindex, Rret);
 }
 void TemplateTable::invokeinterface(int byte_no) {
 transition(vtos, vtos);
 const Register Rinterface  = G1_scratch;
 const Register Rret        = G3_scratch;
 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);
 prepare_invoke(byte_no, Rinterface, Rret, Rindex, O0_recv, O1_flags);
 // get receiver klass
 __ null_check(O0_recv, oopDesc::klass_offset_in_bytes());
-__ load_klass(O0_recv, O2_klassOop);
+__ load_klass(O0_recv, O2_Klass);
-__ verify_oop(O2_klassOop);
 // 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.
 __ set((1 << ConstantPoolCacheEntry::is_forced_virtual_shift), Rscratch);
 __ btst(O1_flags, Rscratch);
 __ 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));
 }
 __ sll(Rtemp, LogBytesPerWord, Rtemp);   // Rscratch *= 4;
 if (Assembler::is_simm13(base)) {
 __ add(Rtemp, base, Rtemp);
 } else {
 __ set(base, Rscratch);
 __ add(Rscratch, Rtemp, Rtemp);
 }
-__ add(O2_klassOop, Rtemp, Rscratch);
+__ add(O2_Klass, Rtemp, Rscratch);
 __ bind(search);
 __ ld_ptr(Rscratch, itableOffsetEntry::interface_offset_in_bytes(), Rtemp);
 {
 // need to check again.
 __ br_notnull_short( Rtemp, Assembler::pt, ok);
 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);
 __ ld(Rscratch, itableOffsetEntry::offset_offset_in_bytes(), Rscratch);
 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.
 {
 Label ok;
 __ br_notnull_short(G5_method, Assembler::pt, ok);
 }
 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
 __ should_not_reach_here();
 return;
 const Register Rscratch   = G3_scratch;
 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);
 }
 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.
 // 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.
 const Register G4_callsite = G4_scratch;
 const Register Rscratch    = G3_scratch;
 prepare_invoke(byte_no, G5_method, Rret, G4_callsite);
-// G4: CallSite object (from f1)
+// G4: CallSite object (from cpool->resolved_references[])
-// G5: MH.linkToCallSite method (from f2)
+// G5: MH.linkToCallSite method (from f1)
 // Note:  G4_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(O4);
 // do the call
-__ verify_oop(G5_method);
+__ verify_oop(G4_callsite);
 __ call_from_interpreter(Rscratch, Gargs, Rret);
 }
 //----------------------------------------------------------------------------------------------------
 Register Rscratch = O4;
 __ 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
+// This is done before loading InstanceKlass to be consistent with the order
-// how Constant Pool is updated (see constantPoolOopDesc::klass_at_put)
+// how Constant Pool is updated (see ConstantPool::klass_at_put)
-__ 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::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);
+__ ldub(RinstanceKlass, in_bytes(InstanceKlass::init_state_offset()), G3_scratch);
-__ cmp(G3_scratch, instanceKlass::fully_initialized);
+__ 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
 __ btst(Klass::_lh_instance_slow_path_bit, Roffset);
 __ br(Assembler::notZero, false, Assembler::pn, slow_case);
 // Get constant pool tag
 __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned);
 // 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
 // Generate a fast subtype check.  Branch to cast_ok if no
 // Get constant pool tag
 __ get_2_byte_integer_at_bcp(1, Lscratch, Roffset, InterpreterMacroAssembler::Unsigned);
 // 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);
 __ load_klass(Otos_i, RobjKlass); // get value klass

Mercurial > hg > graal-compiler

comparison src/cpu/sparc/vm/templateTable_sparc.cpp @ 6725:da91efe96a93