truffle: src/cpu/sparc/vm/templateInterpreter

comparison src/cpu/sparc/vm/templateInterpreter_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	b2dbd323c668 f0c2369fda5a

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "interpreter/templateTable.hpp"
 #include "oops/arrayOop.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 __ ldub(Address(Lbcp, 0), G1_scratch);  // Load current bytecode.
 __ cmp_and_br_short(G1_scratch, Bytecodes::_invokedynamic, Assembler::equal, Assembler::pn, L_giant_index);
 }
 __ get_cache_and_index_at_bcp(cache, G1_scratch, 1);
 __ bind(L_got_cache);
-__ ld_ptr(cache, constantPoolCacheOopDesc::base_offset() +
+__ ld_ptr(cache, ConstantPoolCache::base_offset() +
 ConstantPoolCacheEntry::flags_offset(), size);
 __ and3(size, 0xFF, size);                   // argument size in words
 __ sll(size, Interpreter::logStackElementSize, size); // each argument size in bytes
 __ add(Lesp, size, Lesp);                    // pop arguments
 __ dispatch_next(state, step);
 //
 // Lmethod: method
 // ??: invocation counter
 //
 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
-// Note: In tiered we increment either counters in methodOop or in MDO depending if we're profiling or not.
+// Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.
 if (TieredCompilation) {
 const int increment = InvocationCounter::count_increment;
 const int mask = ((1 << Tier0InvokeNotifyFreqLog) - 1) << InvocationCounter::count_shift;
 Label no_mdo, done;
 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, no_mdo);
 // Increment counter
 Address mdo_invocation_counter(G4_scratch,
-in_bytes(methodDataOopDesc::invocation_counter_offset()) +
+in_bytes(MethodData::invocation_counter_offset()) +
 in_bytes(InvocationCounter::counter_offset()));
 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask,
 G3_scratch, Lscratch,
 Assembler::zero, overflow);
 __ ba_short(done);
 }
-// Increment counter in methodOop
+// Increment counter in Method*
 __ bind(no_mdo);
 Address invocation_counter(Lmethod,
-in_bytes(methodOopDesc::invocation_counter_offset()) +
+in_bytes(Method::invocation_counter_offset()) +
 in_bytes(InvocationCounter::counter_offset()));
 __ increment_mask_and_jump(invocation_counter, increment, mask,
 G3_scratch, Lscratch,
 Assembler::zero, overflow);
 __ bind(done);
 } else {
 // Update standard invocation counters
 __ increment_invocation_counter(O0, G3_scratch);
-if (ProfileInterpreter) {  // %%% Merge this into methodDataOop
+if (ProfileInterpreter) {  // %%% Merge this into MethodData*
-Address interpreter_invocation_counter(Lmethod,in_bytes(methodOopDesc::interpreter_invocation_counter_offset()));
+Address interpreter_invocation_counter(Lmethod,in_bytes(Method::interpreter_invocation_counter_offset()));
 __ ld(interpreter_invocation_counter, G3_scratch);
 __ inc(G3_scratch);
 __ st(G3_scratch, interpreter_invocation_counter);
 }
 }
 }
 // Allocate monitor and lock method (asm interpreter)
-// ebx - methodOop
+// ebx - Method*
 //
 void InterpreterGenerator::lock_method(void) {
-__ ld(Lmethod, in_bytes(methodOopDesc::access_flags_offset()), O0);  // Load access flags.
+__ ld(Lmethod, in_bytes(Method::access_flags_offset()), O0);  // Load access flags.
 #ifdef ASSERT
 { Label ok;
 __ btst(JVM_ACC_SYNCHRONIZED, O0);
 __ br( Assembler::notZero, false, Assembler::pt, ok);
 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
 __ btst(JVM_ACC_STATIC, O0);
 __ br( Assembler::zero, true, Assembler::pt, done);
 __ delayed()->ld_ptr(Llocals, Interpreter::local_offset_in_bytes(0), O0); // get receiver for not-static case
-__ ld_ptr( Lmethod, in_bytes(methodOopDesc::const_offset()), O0);
+__ ld_ptr( Lmethod, in_bytes(Method::const_offset()), O0);
-__ ld_ptr( O0, in_bytes(constMethodOopDesc::constants_offset()), O0);
+__ ld_ptr( O0, in_bytes(ConstMethod::constants_offset()), O0);
-__ ld_ptr( O0, constantPoolOopDesc::pool_holder_offset_in_bytes(), O0);
+__ ld_ptr( O0, ConstantPool::pool_holder_offset_in_bytes(), O0);
-// lock the mirror, not the klassOop
+// lock the mirror, not the Klass*
 __ ld_ptr( O0, mirror_offset, O0);
 #ifdef ASSERT
 __ tst(O0);
 __ breakpoint_trap(Assembler::zero, Assembler::ptr_cc);
 //    is necessary.
 //
 // (gri - 2/25/2000)
-const Address size_of_parameters(G5_method, methodOopDesc::size_of_parameters_offset());
+const Address size_of_parameters(G5_method, Method::size_of_parameters_offset());
-const Address size_of_locals    (G5_method, methodOopDesc::size_of_locals_offset());
+const Address size_of_locals    (G5_method, Method::size_of_locals_offset());
-const Address max_stack         (G5_method, methodOopDesc::max_stack_offset());
+const Address max_stack         (G5_method, Method::max_stack_offset());
 int rounded_vm_local_words = round_to( frame::interpreter_frame_vm_local_words, WordsPerLong );
 const int extra_space =
 rounded_vm_local_words +                   // frame local scratch space
-//6815692//methodOopDesc::extra_stack_words() +       // extra push slots for MH adapters
+//6815692//Method::extra_stack_words() +       // extra push slots for MH adapters
 frame::memory_parameter_word_sp_offset +   // register save area
 (native_call ? frame::interpreter_frame_extra_outgoing_argument_words : 0);
 const Register Glocals_size = G3;
 const Register Otmp1 = O3;
 // that all present references to Lbyte_code initialize the register
 // immediately before use
 if (native_call) {
 __ mov(G0, Lbcp);
 } else {
-__ ld_ptr(G5_method, methodOopDesc::const_offset(), Lbcp);
+__ ld_ptr(G5_method, Method::const_offset(), Lbcp);
-__ add(Lbcp, in_bytes(constMethodOopDesc::codes_offset()), Lbcp);
+__ add(Lbcp, in_bytes(ConstMethod::codes_offset()), Lbcp);
 }
 __ mov( G5_method, Lmethod);                 // set Lmethod
 __ get_constant_pool_cache( LcpoolCache );   // set LcpoolCache
 __ sub(FP, rounded_vm_local_words * BytesPerWord, Lmonitors ); // set Lmonitors
 #ifdef _LP64
 // A method that does nother but return...
 address entry = __ pc();
 Label slow_path;
-__ verify_oop(G5_method);
 // do nothing for empty methods (do not even increment invocation counter)
 if ( UseFastEmptyMethods) {
 // If we need a safepoint check, generate full interpreter entry.
 AddressLiteral sync_state(SafepointSynchronize::address_of_state());
 __ br_null_short(Otos_i, Assembler::pn, slow_path);
 // read first instruction word and extract bytecode @ 1 and index @ 2
 // get first 4 bytes of the bytecodes (big endian!)
-__ ld_ptr(G5_method, methodOopDesc::const_offset(), G1_scratch);
+__ ld_ptr(G5_method, Method::const_offset(), G1_scratch);
-__ ld(G1_scratch, constMethodOopDesc::codes_offset(), G1_scratch);
+__ ld(G1_scratch, ConstMethod::codes_offset(), G1_scratch);
 // move index @ 2 far left then to the right most two bytes.
 __ sll(G1_scratch, 2*BitsPerByte, G1_scratch);
 __ srl(G1_scratch, 2*BitsPerByte - exact_log2(in_words(
 ConstantPoolCacheEntry::size()) * BytesPerWord), G1_scratch);
 // get constant pool cache
-__ ld_ptr(G5_method, methodOopDesc::const_offset(), G3_scratch);
+__ ld_ptr(G5_method, Method::const_offset(), G3_scratch);
-__ ld_ptr(G3_scratch, constMethodOopDesc::constants_offset(), G3_scratch);
+__ ld_ptr(G3_scratch, ConstMethod::constants_offset(), G3_scratch);
-__ ld_ptr(G3_scratch, constantPoolOopDesc::cache_offset_in_bytes(), G3_scratch);
+__ ld_ptr(G3_scratch, ConstantPool::cache_offset_in_bytes(), G3_scratch);
 // get specific constant pool cache entry
 __ add(G3_scratch, G1_scratch, G3_scratch);
 // Check the constant Pool cache entry to see if it has been resolved.
 // If not, need the slow path.
-ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
+ByteSize cp_base_offset = ConstantPoolCache::base_offset();
 __ ld_ptr(G3_scratch, cp_base_offset + ConstantPoolCacheEntry::indices_offset(), G1_scratch);
 __ srl(G1_scratch, 2*BitsPerByte, G1_scratch);
 __ and3(G1_scratch, 0xFF, G1_scratch);
 __ cmp_and_br_short(G1_scratch, Bytecodes::_getfield, Assembler::notEqual, Assembler::pn, slow_path);
 bool inc_counter  = UseCompiler || CountCompiledCalls;
 // make sure registers are different!
 assert_different_registers(G2_thread, G5_method, Gargs, Gtmp1, Gtmp2);
-const Address Laccess_flags(Lmethod, methodOopDesc::access_flags_offset());
+const Address Laccess_flags(Lmethod, Method::access_flags_offset());
-__ verify_oop(G5_method);
 const Register Glocals_size = G3;
 assert_different_registers(Glocals_size, G4_scratch, Gframe_size);
 // make sure method is native & not abstract
 // rethink these assertions - they can be simplified and shared (gri 2/25/2000)
 #ifdef ASSERT
-__ ld(G5_method, methodOopDesc::access_flags_offset(), Gtmp1);
+__ ld(G5_method, Method::access_flags_offset(), Gtmp1);
 {
 Label L;
 __ btst(JVM_ACC_NATIVE, Gtmp1);
 __ br(Assembler::notZero, false, Assembler::pt, L);
 __ delayed()->nop();
 // (note that the space for outgoing params is preallocated)
 // get signature handler
 { Label L;
-Address signature_handler(Lmethod, methodOopDesc::signature_handler_offset());
+Address signature_handler(Lmethod, Method::signature_handler_offset());
 __ ld_ptr(signature_handler, G3_scratch);
 __ br_notnull_short(G3_scratch, Assembler::pt, L);
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), Lmethod);
 __ ld_ptr(signature_handler, G3_scratch);
 __ bind(L);
 __ ld(Laccess_flags, O0);
 __ btst(JVM_ACC_STATIC, O0);
 __ br( Assembler::zero, false, Assembler::pt, not_static);
 // get native function entry point(O0 is a good temp until the very end)
-__ delayed()->ld_ptr(Lmethod, in_bytes(methodOopDesc::native_function_offset()), O0);
+__ delayed()->ld_ptr(Lmethod, in_bytes(Method::native_function_offset()), O0);
 // for static methods insert the mirror argument
 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
-__ ld_ptr(Lmethod, methodOopDesc:: const_offset(), O1);
+__ ld_ptr(Lmethod, Method:: const_offset(), O1);
-__ ld_ptr(O1, constMethodOopDesc::constants_offset(), O1);
+__ ld_ptr(O1, ConstMethod::constants_offset(), O1);
-__ ld_ptr(O1, constantPoolOopDesc::pool_holder_offset_in_bytes(), O1);
+__ ld_ptr(O1, ConstantPool::pool_holder_offset_in_bytes(), O1);
 __ ld_ptr(O1, mirror_offset, O1);
 #ifdef ASSERT
 if (!PrintSignatureHandlers)  // do not dirty the output with this
 { Label L;
 __ br_notnull_short(O1, Assembler::pt, L);
 const Register Gtmp2 = G1_scratch;
 // make sure registers are different!
 assert_different_registers(G2_thread, G5_method, Gargs, Gtmp1, Gtmp2);
-const Address size_of_parameters(G5_method, methodOopDesc::size_of_parameters_offset());
+const Address size_of_parameters(G5_method, Method::size_of_parameters_offset());
-const Address size_of_locals    (G5_method, methodOopDesc::size_of_locals_offset());
+const Address size_of_locals    (G5_method, Method::size_of_locals_offset());
 // Seems like G5_method is live at the point this is used. So we could make this look consistent
 // and use in the asserts.
-const Address access_flags      (Lmethod,   methodOopDesc::access_flags_offset());
+const Address access_flags      (Lmethod,   Method::access_flags_offset());
-__ verify_oop(G5_method);
 const Register Glocals_size = G3;
 assert_different_registers(Glocals_size, G4_scratch, Gframe_size);
 // make sure method is not native & not abstract
 // rethink these assertions - they can be simplified and shared (gri 2/25/2000)
 #ifdef ASSERT
-__ ld(G5_method, methodOopDesc::access_flags_offset(), Gtmp1);
+__ ld(G5_method, Method::access_flags_offset(), Gtmp1);
 {
 Label L;
 __ btst(JVM_ACC_NATIVE, Gtmp1);
 __ br(Assembler::zero, false, Assembler::pt, L);
 __ delayed()->nop();
 //
 // C2 Calling Conventions:
 //
 // The entry code below assumes that the following registers are set
 // when coming in:
-//    G5_method: holds the methodOop of the method to call
+//    G5_method: holds the Method* of the method to call
 //    Lesp:    points to the TOS of the callers expression stack
 //             after having pushed all the parameters
 //
 // The entry code does the following to setup an interpreter frame
 //   pop parameters from the callers stack by adjusting Lesp
 // callee_locals and max_stack are counts, not the size in frame.
 const int locals_size =
 round_to(callee_extra_locals * Interpreter::stackElementWords, WordsPerLong);
 const int max_stack_words = max_stack * Interpreter::stackElementWords;
 return (round_to((max_stack_words
-//6815692//+ methodOopDesc::extra_stack_words()
+//6815692//+ Method::extra_stack_words()
 + rounded_vm_local_words
 + frame::memory_parameter_word_sp_offset), WordsPerLong)
 // already rounded
 + locals_size + monitor_size);
 }
 // How much stack a method top interpreter activation needs in words.
-int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
+int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
 // See call_stub code
 int call_stub_size  = round_to(7 + frame::memory_parameter_word_sp_offset,
 WordsPerLong);    // 7 + register save area
 1*frame::interpreter_frame_monitor_size() : 0;
 return size_activation_helper(method->max_locals(), method->max_stack(),
 monitor_size) + call_stub_size;
 }
-int AbstractInterpreter::layout_activation(methodOop method,
+int AbstractInterpreter::layout_activation(Method* method,
 int tempcount,
 int popframe_extra_args,
 int moncount,
 int caller_actual_parameters,
 int callee_param_count,
 const Register Gtmp1 = G3_scratch;
 const Register Gtmp2 = G1_scratch;
 // Compute size of arguments for saving when returning to deoptimized caller
-__ lduh(Lmethod, in_bytes(methodOopDesc::size_of_parameters_offset()), Gtmp1);
+__ lduh(Lmethod, in_bytes(Method::size_of_parameters_offset()), Gtmp1);
 __ sll(Gtmp1, Interpreter::logStackElementSize, Gtmp1);
 __ sub(Llocals, Gtmp1, Gtmp2);
 __ add(Gtmp2, wordSize, Gtmp2);
 // Save these arguments
 __ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args), G2_thread, Gtmp1, Gtmp2);
 // Intel has the following comment:
 //// remove the activation (without doing throws on illegalMonitorExceptions)
 // They remove the activation without checking for bad monitor state.
 // %%% We should make sure this is the right semantics before implementing.
-// %%% changed set_vm_result_2 to set_vm_result and get_vm_result_2 to get_vm_result. Is there a bug here?
 __ set_vm_result(Oexception);
 __ unlock_if_synchronized_method(vtos, /* throw_monitor_exception */ false);
 __ notify_method_exit(false, vtos, InterpreterMacroAssembler::SkipNotifyJVMTI);

Mercurial > hg > truffle

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