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

equal deleted inserted replaced

-:c4955cb6ed33
+:f2e8cc8c12ea
 __ movl(rbx, Address(rbx, rcx,
 Address::times_ptr,
 in_bytes(constantPoolCacheOopDesc::base_offset()) +
 3 * wordSize));
 __ andl(rbx, 0xFF);
-if (TaggedStackInterpreter) __ shll(rbx, 1); // 2 slots per parameter.
 __ lea(rsp, Address(rsp, rbx, Address::times_8));
 __ dispatch_next(state, step);
 // out of the main line of code...
 if (EnableInvokeDynamic) {
 Label after_frame_check;
 // see if the frame is greater than one page in size. If so,
 // then we need to verify there is enough stack space remaining
 // for the additional locals.
-__ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize());
+__ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize);
 __ jcc(Assembler::belowEqual, after_frame_check);
 // compute rsp as if this were going to be the last frame on
 // the stack before the red zone
 const Address stack_base(r15_thread, Thread::stack_base_offset());
 const Address stack_size(r15_thread, Thread::stack_size_offset());
 // locals + overhead, in bytes
 __ mov(rax, rdx);
-__ shlptr(rax, Interpreter::logStackElementSize()); // 2 slots per parameter.
+__ shlptr(rax, Interpreter::logStackElementSize);  // 2 slots per parameter.
 __ addptr(rax, overhead_size);
 #ifdef ASSERT
 Label stack_base_okay, stack_size_okay;
 // verify that thread stack base is non-zero
 __ pop(rax);                                       // get return address
 // for natives the size of locals is zero
 // compute beginning of parameters (r14)
-if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
 // add 2 zero-initialized slots for native calls
 // initialize result_handler slot
 __ push((int) NULL_WORD);
 __ get_method(method);
 __ verify_oop(method);
 __ load_unsigned_short(t,
 Address(method,
 methodOopDesc::size_of_parameters_offset()));
-__ shll(t, Interpreter::logStackElementSize());
+__ shll(t, Interpreter::logStackElementSize);
 __ subptr(rsp, t);
 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI)
 // get return address
 __ pop(rax);
 // compute beginning of parameters (r14)
-if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
 // rdx - # of additional locals
 // allocate space for locals
 // explicitly initialize locals
 {
 Label exit, loop;
 __ testl(rdx, rdx);
 __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0
 __ bind(loop);
-if (TaggedStackInterpreter) __ push((int) NULL_WORD);  // push tag
 __ push((int) NULL_WORD); // initialize local variables
 __ decrementl(rdx); // until everything initialized
 __ jcc(Assembler::greater, loop);
 __ bind(exit);
 }
 -(frame::interpreter_frame_initial_sp_offset) + entry_size;
 const int stub_code = frame::entry_frame_after_call_words;
 const int extra_stack = methodOopDesc::extra_stack_entries();
 const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
-Interpreter::stackElementWords();
+Interpreter::stackElementWords;
 return (overhead_size + method_stack + stub_code);
 }
 int AbstractInterpreter::layout_activation(methodOop method,
 int tempcount,
 // The frame interpreter_frame, if not NULL, is guaranteed to be the
 // right size, as determined by a previous call to this method.
 // It is also guaranteed to be walkable even though it is in a skeletal state
 // fixed size of an interpreter frame:
-int max_locals = method->max_locals() * Interpreter::stackElementWords();
+int max_locals = method->max_locals() * Interpreter::stackElementWords;
 int extra_locals = (method->max_locals() - method->size_of_parameters()) *
-Interpreter::stackElementWords();
+Interpreter::stackElementWords;
 int overhead = frame::sender_sp_offset -
 frame::interpreter_frame_initial_sp_offset;
 // Our locals were accounted for by the caller (or last_frame_adjust
 // on the transistion) Since the callee parameters already account
 // for the callee's params we only need to account for the extra
 // locals.
 int size = overhead +
-(callee_locals - callee_param_count)*Interpreter::stackElementWords() +
+(callee_locals - callee_param_count)*Interpreter::stackElementWords +
 moncount * frame::interpreter_frame_monitor_size() +
-tempcount* Interpreter::stackElementWords() + popframe_extra_args;
+tempcount* Interpreter::stackElementWords + popframe_extra_args;
 if (interpreter_frame != NULL) {
 #ifdef ASSERT
 if (!EnableMethodHandles)
 // @@@ FIXME: Should we correct interpreter_frame_sender_sp in the calling sequences?
 // Probably, since deoptimization doesn't work yet.
 BasicObjectLock* monbot = montop - moncount;
 interpreter_frame->interpreter_frame_set_monitor_end(monbot);
 // Set last_sp
 intptr_t*  esp = (intptr_t*) monbot -
-tempcount*Interpreter::stackElementWords() -
+tempcount*Interpreter::stackElementWords -
 popframe_extra_args;
 interpreter_frame->interpreter_frame_set_last_sp(esp);
 // All frames but the initial (oldest) interpreter frame we fill in have
 // a value for sender_sp that allows walking the stack but isn't
 // Compute size of arguments for saving when returning to
 // deoptimized caller
 __ get_method(rax);
 __ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc::
 size_of_parameters_offset())));
-__ shll(rax, Interpreter::logStackElementSize());
+__ shll(rax, Interpreter::logStackElementSize);
 __ restore_locals(); // XXX do we need this?
 __ subptr(r14, rax);
 __ addptr(r14, wordSize);
 // Save these arguments
 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address,

changeset 5419	f2e8cc8c12ea
parent 5046	27e801a857cb
child 5688	9052dc91ea67
child 5547	f4b087cbb361