jdk8-mips64-public/hotspot: comparison src/cpu/sparc/vm/cppInterpreter

-:36d1d483d5d6
+:da91efe96a93
 #include "interpreter/cppInterpreter.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.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"
 // ??: invocation counter
 //
 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
 // Update standard invocation counters
 __ increment_invocation_counter(O0, G3_scratch);
-if (ProfileInterpreter) {  // %%% Merge this into methodDataOop
+if (ProfileInterpreter) {  // %%% Merge this into MethodData*
 __ ld_ptr(STATE(_method), G3_scratch);
-Address interpreter_invocation_counter(G3_scratch, 0, in_bytes(methodOopDesc::interpreter_invocation_counter_offset()));
+Address interpreter_invocation_counter(G3_scratch, 0, in_bytes(Method::interpreter_invocation_counter_offset()));
 __ ld(interpreter_invocation_counter, G3_scratch);
 __ inc(G3_scratch);
 __ st(G3_scratch, interpreter_invocation_counter);
 }
 // A method that does nothing 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.
 Address sync_state(G3_scratch, SafepointSynchronize::address_of_state());
 __ delayed()->nop();
 // read first instruction word and extract bytecode @ 1 and index @ 2
 // get first 4 bytes of the bytecodes (big endian!)
-__ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::const_offset())), G1_scratch);
+__ ld_ptr(Address(G5_method, 0, in_bytes(Method::const_offset())), G1_scratch);
-__ ld(Address(G1_scratch, 0, in_bytes(constMethodOopDesc::codes_offset())), G1_scratch);
+__ ld(Address(G1_scratch, 0, in_bytes(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, in_bytes(methodOopDesc::const_offset()), G3_scratch);
+__ ld_ptr(G5_method, in_bytes(Method::const_offset()), G3_scratch);
-__ ld_ptr(G3_scratch, in_bytes(constMethodOopDesc::constants_offset()), G3_scratch);
+__ ld_ptr(G3_scratch, in_bytes(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, in_bytes(cp_base_offset + ConstantPoolCacheEntry::indices_offset()), G1_scratch);
 __ srl(G1_scratch, 2*BitsPerByte, G1_scratch);
 __ and3(G1_scratch, 0xFF, G1_scratch);
 __ cmp(G1_scratch, Bytecodes::_getfield);
 __ br(Assembler::notEqual, false, Assembler::pn, slow_path);
 address entry = __ pc();
 // the following temporary registers are used during frame creation
 const Register Gtmp1 = G3_scratch ;
 const Register Gtmp2 = G1_scratch;
-const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset()));
+const Address size_of_parameters(G5_method, 0, in_bytes(Method::size_of_parameters_offset()));
 bool inc_counter  = UseCompiler || CountCompiledCalls;
 // make sure registers are different!
 assert_different_registers(G2_thread, G5_method, Gargs, Gtmp1, Gtmp2);
-const Address access_flags      (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset()));
+const Address access_flags      (G5_method, 0, in_bytes(Method::access_flags_offset()));
 Label Lentry;
 __ bind(Lentry);
-__ 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
 Label pending_exception_present;
 { Label L;
 __ ld_ptr(STATE(_method), G5_method);
-__ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::signature_handler_offset())), G3_scratch);
+__ ld_ptr(Address(G5_method, 0, in_bytes(Method::signature_handler_offset())), G3_scratch);
 __ tst(G3_scratch);
 __ brx(Assembler::notZero, false, Assembler::pt, L);
 __ delayed()->nop();
 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), G5_method, false);
 __ ld_ptr(STATE(_method), G5_method);
 Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset()));
 __ ld_ptr(exception_addr, G3_scratch);
 __ br_notnull_short(G3_scratch, Assembler::pn, pending_exception_present);
-__ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::signature_handler_offset())), G3_scratch);
+__ ld_ptr(Address(G5_method, 0, in_bytes(Method::signature_handler_offset())), G3_scratch);
 __ bind(L);
 }
 // Push a new frame so that the args will really be stored in
 // Copy a few locals across so the new frame has the variables
 __ ld(access_flags, O0);
 __ btst(JVM_ACC_STATIC, O0);
 __ br( Assembler::zero, false, Assembler::pt, not_static);
 __ delayed()->
 // get native function entry point(O0 is a good temp until the very end)
-ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::native_function_offset())), O0);
+ld_ptr(Address(G5_method, 0, 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(Address(G5_method, 0, in_bytes(methodOopDesc:: const_offset())), O1);
+__ ld_ptr(Address(G5_method, 0, in_bytes(Method:: const_offset())), O1);
-__ ld_ptr(Address(O1, 0, in_bytes(constMethodOopDesc::constants_offset())), O1);
+__ ld_ptr(Address(O1, 0, in_bytes(ConstMethod::constants_offset())), O1);
-__ ld_ptr(Address(O1, 0, constantPoolOopDesc::pool_holder_offset_in_bytes()), O1);
+__ ld_ptr(Address(O1, 0, ConstantPool::pool_holder_offset_in_bytes()), O1);
 __ ld_ptr(O1, mirror_offset, O1);
 // where the mirror handle body is allocated:
 #ifdef ASSERT
 if (!PrintSignatureHandlers)  // do not dirty the output with this
 { Label L;
 // a new interpretState object and the method expression stack.
 assert_different_registers(state, prev_state);
 assert_different_registers(prev_state, G3_scratch);
 const Register Gtmp = G3_scratch;
-const Address constMethod       (G5_method, 0, in_bytes(methodOopDesc::const_offset()));
+const Address constMethod       (G5_method, 0, in_bytes(Method::const_offset()));
-const Address access_flags      (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset()));
+const Address access_flags      (G5_method, 0, in_bytes(Method::access_flags_offset()));
-const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset()));
+const Address size_of_parameters(G5_method, 0, in_bytes(Method::size_of_parameters_offset()));
-const Address max_stack         (G5_method, 0, in_bytes(methodOopDesc::max_stack_offset()));
+const Address max_stack         (G5_method, 0, in_bytes(Method::max_stack_offset()));
-const Address size_of_locals    (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset()));
+const Address size_of_locals    (G5_method, 0, in_bytes(Method::size_of_locals_offset()));
 // slop factor is two extra slots on the expression stack so that
 // we always have room to store a result when returning from a call without parameters
 // that returns a result.
 const int slop_factor = 2*wordSize;
 const int fixed_size = ((sizeof(BytecodeInterpreter) + slop_factor) >> LogBytesPerWord) + // what is the slop factor?
-//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 + param window
 (native ?  frame::interpreter_frame_extra_outgoing_argument_words : 0); // JNI, class
 // XXX G5_method valid
 __ st_ptr(G2_thread, XXX_STATE(_thread));               // Store javathread
 if (native) {
 __ st_ptr(G0, XXX_STATE(_bcp));
 } else {
-__ ld_ptr(G5_method, in_bytes(methodOopDesc::const_offset()), O2); // get constMethodOop
+__ ld_ptr(G5_method, in_bytes(Method::const_offset()), O2); // get ConstMethod*
-__ add(O2, in_bytes(constMethodOopDesc::codes_offset()), O2);        // get bcp
+__ add(O2, in_bytes(ConstMethod::codes_offset()), O2);        // get bcp
 __ st_ptr(O2, XXX_STATE(_bcp));
 }
 __ st_ptr(G0, XXX_STATE(_mdx));
 __ st_ptr(G5_method, XXX_STATE(_method));
 __ set((int) BytecodeInterpreter::method_entry, O1);
 __ st(O1, XXX_STATE(_msg));
 __ ld_ptr(constMethod, O3);
-__ ld_ptr(O3, in_bytes(constMethodOopDesc::constants_offset()), O3);
+__ ld_ptr(O3, in_bytes(ConstMethod::constants_offset()), O3);
-__ ld_ptr(O3, constantPoolOopDesc::cache_offset_in_bytes(), O2);
+__ ld_ptr(O3, ConstantPool::cache_offset_in_bytes(), O2);
 __ st_ptr(O2, XXX_STATE(_constants));
 __ st_ptr(G0, XXX_STATE(_result._to_call._callee));
 // Monitor base is just start of BytecodeInterpreter object;
 __ delayed()->btst(JVM_ACC_STATIC, O1);
 __ ld_ptr(XXX_STATE(_locals), O1);
 __ br( Assembler::zero, true, Assembler::pt, got_obj);
 __ delayed()->ld_ptr(O1, 0, O1);                  // get receiver for not-static case
 __ ld_ptr(constMethod, O1);
-__ ld_ptr( O1, in_bytes(constMethodOopDesc::constants_offset()), O1);
+__ ld_ptr( O1, in_bytes(ConstMethod::constants_offset()), O1);
-__ ld_ptr( O1, constantPoolOopDesc::pool_holder_offset_in_bytes(), O1);
+__ ld_ptr( O1, ConstantPool::pool_holder_offset_in_bytes(), O1);
-// lock the mirror, not the klassOop
+// lock the mirror, not the Klass*
 __ ld_ptr( O1, mirror_offset, O1);
 __ bind(got_obj);
 #ifdef ASSERT
 __ st_ptr(O2, XXX_STATE(_stack));                // PREPUSH
 __ lduh(max_stack, O3);                      // Full size expression stack
 guarantee(!EnableInvokeDynamic, "no support yet for java.lang.invoke.MethodHandle"); //6815692
 //6815692//if (EnableInvokeDynamic)
-//6815692//  __ inc(O3, methodOopDesc::extra_stack_entries());
+//6815692//  __ inc(O3, Method::extra_stack_entries());
 __ sll(O3, LogBytesPerWord, O3);
 __ sub(O2, O3, O3);
 //  __ sub(O3, wordSize, O3);                    // so prepush doesn't look out of bounds
 __ st_ptr(O3, XXX_STATE(_stack_limit));
 //
 // Find everything relative to Lstate
 #ifdef ASSERT
 __ ld_ptr(STATE(_method), L2_scratch);
-__ ld(L2_scratch, in_bytes(methodOopDesc::access_flags_offset()), O0);
+__ ld(L2_scratch, in_bytes(Method::access_flags_offset()), O0);
 { Label ok;
 __ btst(JVM_ACC_SYNCHRONIZED, O0);
 __ br( Assembler::notZero, false, Assembler::pt, ok);
 __ delayed()->nop();
 //               happens during entry during the entry via the call stub.
 // RETURN_FROM_METHOD - remove an activation. Return to interpreter or call stub.
 //
 // Arguments:
 //
-// ebx: methodOop
+// ebx: Method*
 // ecx: receiver - unused (retrieved from stack as needed)
 // esi: previous frame manager state (NULL from the call_stub/c1/c2)
 //
 //
 // Stack layout at entry
 // In/Out O5_savedSP (sender's original SP)
 //
 //  assert_different_registers(state, prev_state);
 const Register Gtmp = G3_scratch;
 const Register tmp = O2;
-const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset()));
+const Address size_of_parameters(G5_method, 0, in_bytes(Method::size_of_parameters_offset()));
-const Address size_of_locals    (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset()));
+const Address size_of_locals    (G5_method, 0, in_bytes(Method::size_of_locals_offset()));
 __ lduh(size_of_parameters, tmp);
 __ sll(tmp, LogBytesPerWord, Gtmp);       // parameter size in bytes
 __ add(args, Gtmp, Gargs);                // points to first local + BytesPerWord
 // NEW
 __ sub(SP, Gtmp, SP);                      // just caller's frame for the additional space we need.
 }
 address InterpreterGenerator::generate_normal_entry(bool synchronized) {
-// G5_method: methodOop
+// G5_method: Method*
 // G2_thread: thread (unused)
 // Gargs:   bottom of args (sender_sp)
 // O5: sender's sp
 // A single frame manager is plenty as we don't specialize for synchronized. We could and
 // the following temporary registers are used during frame creation
 const Register Gtmp1 = G3_scratch;
 // const Register Lmirror = L1;     // native mirror (native calls only)
-const Address constMethod       (G5_method, 0, in_bytes(methodOopDesc::const_offset()));
+const Address constMethod       (G5_method, 0, in_bytes(Method::const_offset()));
-const Address access_flags      (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset()));
+const Address access_flags      (G5_method, 0, in_bytes(Method::access_flags_offset()));
-const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset()));
+const Address size_of_parameters(G5_method, 0, in_bytes(Method::size_of_parameters_offset()));
-const Address max_stack         (G5_method, 0, in_bytes(methodOopDesc::max_stack_offset()));
+const Address max_stack         (G5_method, 0, in_bytes(Method::max_stack_offset()));
-const Address size_of_locals    (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset()));
+const Address size_of_locals    (G5_method, 0, in_bytes(Method::size_of_locals_offset()));
 address entry_point = __ pc();
 __ mov(G0, prevState);                                                 // no current activation
 Address exception_addr (G2_thread, 0, in_bytes(Thread::pending_exception_offset()));
 __ verify_thread();
 __ st_ptr(O0, exception_addr);
-// get the methodOop
+// get the Method*
 __ ld_ptr(STATE(_method), G5_method);
 // if this current frame vanilla or native?
 __ ld(access_flags, Gtmp1);
 // Process the native abi result to java expression stack
 __ ld_ptr(STATE(_result._to_call._callee), L4_scratch);                        // called method
 __ ld_ptr(STATE(_stack), L1_scratch);                                          // get top of java expr stack
-__ lduh(L4_scratch, in_bytes(methodOopDesc::size_of_parameters_offset()), L2_scratch); // get parameter size
+__ lduh(L4_scratch, in_bytes(Method::size_of_parameters_offset()), L2_scratch); // get parameter size
 __ sll(L2_scratch, LogBytesPerWord, L2_scratch     );                           // parameter size in bytes
 __ add(L1_scratch, L2_scratch, L1_scratch);                                      // stack destination for result
-__ ld(L4_scratch, in_bytes(methodOopDesc::result_index_offset()), L3_scratch); // called method result type index
+__ ld(L4_scratch, in_bytes(Method::result_index_offset()), L3_scratch); // called method result type index
 // tosca is really just native abi
 __ set((intptr_t)CppInterpreter::_tosca_to_stack, L4_scratch);
 __ sll(L3_scratch, LogBytesPerWord, L3_scratch);
 __ ld_ptr(L4_scratch, L3_scratch, Lscratch);                                       // get typed result converter address
 // other thing that makes it easy is that the top of the caller's stack is stored in STATE(_locals)
 // for the current activation
 __ ld_ptr(STATE(_prev_link), L1_scratch);
 __ ld_ptr(STATE(_method), L2_scratch);                               // get method just executed
-__ ld(L2_scratch, in_bytes(methodOopDesc::result_index_offset()), L2_scratch);
+__ ld(L2_scratch, in_bytes(Method::result_index_offset()), L2_scratch);
 __ tst(L1_scratch);
 __ brx(Assembler::zero, false, Assembler::pt, return_to_initial_caller);
 __ delayed()->sll(L2_scratch, LogBytesPerWord, L2_scratch);
 // Copy result to callers java stack
 // is "slop_factor" here.
 const int slop_factor = 2;
 const int fixed_size = sizeof(BytecodeInterpreter)/wordSize +           // interpreter state object
 frame::memory_parameter_word_sp_offset;   // register save area + param window
-const int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
+const int extra_stack = 0; //6815692//Method::extra_stack_entries();
 return (round_to(max_stack +
 extra_stack +
 slop_factor +
 fixed_size +
 monitor_size +
-(callee_extra_locals * Interpreter::stackElementWords()), WordsPerLong));
+(callee_extra_locals * Interpreter::stackElementWords), WordsPerLong));
 }
-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
 }
 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
 frame* caller,
 frame* current,
-methodOop method,
+Method* method,
 intptr_t* locals,
 intptr_t* stack,
 intptr_t* stack_base,
 intptr_t* monitor_base,
 intptr_t* frame_bottom,
 to_fill->_oop_temp = NULL;
 to_fill->_stack_base = stack_base;
 // Need +1 here because stack_base points to the word just above the first expr stack entry
 // and stack_limit is supposed to point to the word just below the last expr stack entry.
 // See generate_compute_interpreter_state.
-int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
+int extra_stack = 0; //6815692//Method::extra_stack_entries();
 to_fill->_stack_limit = stack_base - (method->max_stack() + 1 + extra_stack);
 to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
 // sparc specific
 to_fill->_frame_bottom = frame_bottom;
 void BytecodeInterpreter::pd_layout_interpreterState(interpreterState istate, address last_Java_pc, intptr_t* last_Java_fp) {
 istate->_last_Java_pc = (intptr_t*) last_Java_pc;
 }
-int AbstractInterpreter::layout_activation(methodOop method,
+int AbstractInterpreter::layout_activation(Method* method,
 int tempcount, // Number of slots on java expression stack in use
 int popframe_extra_args,
 int moncount,  // Number of active monitors
 int caller_actual_parameters,
 int callee_param_size,
 //
 // Compiled frames do not allocate a varargs area which is why this if
 // statement is needed.
 //
 intptr_t* fp = interpreter_frame->fp();
-int local_words = method->max_locals() * Interpreter::stackElementWords();
+int local_words = method->max_locals() * Interpreter::stackElementWords;
 if (caller->is_compiled_frame()) {
 locals = fp + frame::register_save_words + local_words - 1;
 } else {
 locals = fp + frame::memory_parameter_word_sp_offset + local_words - 1;

comparison: src/cpu/sparc/vm/cppInterpreter_sparc.cpp

src/cpu/sparc/vm/cppInterpreter_sparc.cpp

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/cpu/sparc/vm/cppInterpreter_sparc.cpp

src/cpu/sparc/vm/cppInterpreter_sparc.cpp