annotate src/cpu/x86/vm/cppInterpreter_x86.cpp @ 2346:e1162778c1c8

7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer. Reviewed-by: kvn, iveresov, never, tonyp, dholmes
author johnc
date Thu, 07 Apr 2011 09:53:20 -0700
parents 638119ce7cfd
children 3d2ab563047a
rev   line source
duke@0 1 /*
twisti@2117 2 * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
duke@0 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 *
duke@0 5 * This code is free software; you can redistribute it and/or modify it
duke@0 6 * under the terms of the GNU General Public License version 2 only, as
duke@0 7 * published by the Free Software Foundation.
duke@0 8 *
duke@0 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@0 13 * accompanied this code).
duke@0 14 *
duke@0 15 * You should have received a copy of the GNU General Public License version
duke@0 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@0 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 18 *
trims@1472 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1472 20 * or visit www.oracle.com if you need additional information or have any
trims@1472 21 * questions.
duke@0 22 *
duke@0 23 */
duke@0 24
stefank@1879 25 #include "precompiled.hpp"
stefank@1879 26 #include "asm/assembler.hpp"
stefank@1879 27 #include "interpreter/bytecodeHistogram.hpp"
stefank@1879 28 #include "interpreter/cppInterpreter.hpp"
stefank@1879 29 #include "interpreter/interpreter.hpp"
stefank@1879 30 #include "interpreter/interpreterGenerator.hpp"
stefank@1879 31 #include "interpreter/interpreterRuntime.hpp"
stefank@1879 32 #include "oops/arrayOop.hpp"
stefank@1879 33 #include "oops/methodDataOop.hpp"
stefank@1879 34 #include "oops/methodOop.hpp"
stefank@1879 35 #include "oops/oop.inline.hpp"
stefank@1879 36 #include "prims/jvmtiExport.hpp"
stefank@1879 37 #include "prims/jvmtiThreadState.hpp"
stefank@1879 38 #include "runtime/arguments.hpp"
stefank@1879 39 #include "runtime/deoptimization.hpp"
stefank@1879 40 #include "runtime/frame.inline.hpp"
stefank@1879 41 #include "runtime/interfaceSupport.hpp"
stefank@1879 42 #include "runtime/sharedRuntime.hpp"
stefank@1879 43 #include "runtime/stubRoutines.hpp"
stefank@1879 44 #include "runtime/synchronizer.hpp"
stefank@1879 45 #include "runtime/timer.hpp"
stefank@1879 46 #include "runtime/vframeArray.hpp"
stefank@1879 47 #include "utilities/debug.hpp"
stefank@1879 48 #ifdef SHARK
stefank@1879 49 #include "shark/shark_globals.hpp"
stefank@1879 50 #endif
duke@0 51
duke@0 52 #ifdef CC_INTERP
duke@0 53
duke@0 54 // Routine exists to make tracebacks look decent in debugger
duke@0 55 // while we are recursed in the frame manager/c++ interpreter.
duke@0 56 // We could use an address in the frame manager but having
duke@0 57 // frames look natural in the debugger is a plus.
duke@0 58 extern "C" void RecursiveInterpreterActivation(interpreterState istate )
duke@0 59 {
duke@0 60 //
duke@0 61 ShouldNotReachHere();
duke@0 62 }
duke@0 63
duke@0 64
duke@0 65 #define __ _masm->
duke@0 66 #define STATE(field_name) (Address(state, byte_offset_of(BytecodeInterpreter, field_name)))
duke@0 67
duke@0 68 Label fast_accessor_slow_entry_path; // fast accessor methods need to be able to jmp to unsynchronized
duke@0 69 // c++ interpreter entry point this holds that entry point label.
duke@0 70
never@304 71 // default registers for state and sender_sp
never@304 72 // state and sender_sp are the same on 32bit because we have no choice.
never@304 73 // state could be rsi on 64bit but it is an arg reg and not callee save
never@304 74 // so r13 is better choice.
never@304 75
never@304 76 const Register state = NOT_LP64(rsi) LP64_ONLY(r13);
never@304 77 const Register sender_sp_on_entry = NOT_LP64(rsi) LP64_ONLY(r13);
never@304 78
duke@0 79 // NEEDED for JVMTI?
duke@0 80 // address AbstractInterpreter::_remove_activation_preserving_args_entry;
duke@0 81
duke@0 82 static address unctrap_frame_manager_entry = NULL;
duke@0 83
duke@0 84 static address deopt_frame_manager_return_atos = NULL;
duke@0 85 static address deopt_frame_manager_return_btos = NULL;
duke@0 86 static address deopt_frame_manager_return_itos = NULL;
duke@0 87 static address deopt_frame_manager_return_ltos = NULL;
duke@0 88 static address deopt_frame_manager_return_ftos = NULL;
duke@0 89 static address deopt_frame_manager_return_dtos = NULL;
duke@0 90 static address deopt_frame_manager_return_vtos = NULL;
duke@0 91
duke@0 92 int AbstractInterpreter::BasicType_as_index(BasicType type) {
duke@0 93 int i = 0;
duke@0 94 switch (type) {
duke@0 95 case T_BOOLEAN: i = 0; break;
duke@0 96 case T_CHAR : i = 1; break;
duke@0 97 case T_BYTE : i = 2; break;
duke@0 98 case T_SHORT : i = 3; break;
duke@0 99 case T_INT : i = 4; break;
duke@0 100 case T_VOID : i = 5; break;
duke@0 101 case T_FLOAT : i = 8; break;
duke@0 102 case T_LONG : i = 9; break;
duke@0 103 case T_DOUBLE : i = 6; break;
duke@0 104 case T_OBJECT : // fall through
duke@0 105 case T_ARRAY : i = 7; break;
duke@0 106 default : ShouldNotReachHere();
duke@0 107 }
duke@0 108 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, "index out of bounds");
duke@0 109 return i;
duke@0 110 }
duke@0 111
duke@0 112 // Is this pc anywhere within code owned by the interpreter?
duke@0 113 // This only works for pc that might possibly be exposed to frame
duke@0 114 // walkers. It clearly misses all of the actual c++ interpreter
duke@0 115 // implementation
duke@0 116 bool CppInterpreter::contains(address pc) {
duke@0 117 return (_code->contains(pc) ||
duke@0 118 pc == CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation));
duke@0 119 }
duke@0 120
duke@0 121
duke@0 122 address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {
duke@0 123 address entry = __ pc();
duke@0 124 switch (type) {
duke@0 125 case T_BOOLEAN: __ c2bool(rax); break;
duke@0 126 case T_CHAR : __ andl(rax, 0xFFFF); break;
duke@0 127 case T_BYTE : __ sign_extend_byte (rax); break;
duke@0 128 case T_SHORT : __ sign_extend_short(rax); break;
duke@0 129 case T_VOID : // fall thru
duke@0 130 case T_LONG : // fall thru
duke@0 131 case T_INT : /* nothing to do */ break;
never@304 132
duke@0 133 case T_DOUBLE :
duke@0 134 case T_FLOAT :
never@304 135 {
never@304 136 const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();
never@304 137 __ pop(t); // remove return address first
duke@0 138 // Must return a result for interpreter or compiler. In SSE
duke@0 139 // mode, results are returned in xmm0 and the FPU stack must
duke@0 140 // be empty.
duke@0 141 if (type == T_FLOAT && UseSSE >= 1) {
never@304 142 #ifndef _LP64
duke@0 143 // Load ST0
duke@0 144 __ fld_d(Address(rsp, 0));
duke@0 145 // Store as float and empty fpu stack
duke@0 146 __ fstp_s(Address(rsp, 0));
never@304 147 #endif // !_LP64
duke@0 148 // and reload
duke@0 149 __ movflt(xmm0, Address(rsp, 0));
duke@0 150 } else if (type == T_DOUBLE && UseSSE >= 2 ) {
duke@0 151 __ movdbl(xmm0, Address(rsp, 0));
duke@0 152 } else {
duke@0 153 // restore ST0
duke@0 154 __ fld_d(Address(rsp, 0));
duke@0 155 }
duke@0 156 // and pop the temp
never@304 157 __ addptr(rsp, 2 * wordSize);
never@304 158 __ push(t); // restore return address
duke@0 159 }
duke@0 160 break;
duke@0 161 case T_OBJECT :
duke@0 162 // retrieve result from frame
never@304 163 __ movptr(rax, STATE(_oop_temp));
duke@0 164 // and verify it
duke@0 165 __ verify_oop(rax);
duke@0 166 break;
duke@0 167 default : ShouldNotReachHere();
duke@0 168 }
duke@0 169 __ ret(0); // return from result handler
duke@0 170 return entry;
duke@0 171 }
duke@0 172
duke@0 173 // tosca based result to c++ interpreter stack based result.
duke@0 174 // Result goes to top of native stack.
duke@0 175
duke@0 176 #undef EXTEND // SHOULD NOT BE NEEDED
duke@0 177 address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {
duke@0 178 // A result is in the tosca (abi result) from either a native method call or compiled
duke@0 179 // code. Place this result on the java expression stack so C++ interpreter can use it.
duke@0 180 address entry = __ pc();
duke@0 181
duke@0 182 const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();
never@304 183 __ pop(t); // remove return address first
duke@0 184 switch (type) {
duke@0 185 case T_VOID:
duke@0 186 break;
duke@0 187 case T_BOOLEAN:
duke@0 188 #ifdef EXTEND
duke@0 189 __ c2bool(rax);
duke@0 190 #endif
never@304 191 __ push(rax);
duke@0 192 break;
duke@0 193 case T_CHAR :
duke@0 194 #ifdef EXTEND
duke@0 195 __ andl(rax, 0xFFFF);
duke@0 196 #endif
never@304 197 __ push(rax);
duke@0 198 break;
duke@0 199 case T_BYTE :
duke@0 200 #ifdef EXTEND
duke@0 201 __ sign_extend_byte (rax);
duke@0 202 #endif
never@304 203 __ push(rax);
duke@0 204 break;
duke@0 205 case T_SHORT :
duke@0 206 #ifdef EXTEND
duke@0 207 __ sign_extend_short(rax);
duke@0 208 #endif
never@304 209 __ push(rax);
duke@0 210 break;
duke@0 211 case T_LONG :
never@304 212 __ push(rdx); // pushes useless junk on 64bit
never@304 213 __ push(rax);
duke@0 214 break;
duke@0 215 case T_INT :
never@304 216 __ push(rax);
duke@0 217 break;
duke@0 218 case T_FLOAT :
never@304 219 // Result is in ST(0)/xmm0
never@304 220 __ subptr(rsp, wordSize);
duke@0 221 if ( UseSSE < 1) {
never@304 222 __ fstp_s(Address(rsp, 0));
duke@0 223 } else {
duke@0 224 __ movflt(Address(rsp, 0), xmm0);
duke@0 225 }
duke@0 226 break;
duke@0 227 case T_DOUBLE :
never@304 228 __ subptr(rsp, 2*wordSize);
duke@0 229 if ( UseSSE < 2 ) {
never@304 230 __ fstp_d(Address(rsp, 0));
duke@0 231 } else {
duke@0 232 __ movdbl(Address(rsp, 0), xmm0);
duke@0 233 }
duke@0 234 break;
duke@0 235 case T_OBJECT :
duke@0 236 __ verify_oop(rax); // verify it
never@304 237 __ push(rax);
duke@0 238 break;
duke@0 239 default : ShouldNotReachHere();
duke@0 240 }
duke@0 241 __ jmp(t); // return from result handler
duke@0 242 return entry;
duke@0 243 }
duke@0 244
duke@0 245 address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {
duke@0 246 // A result is in the java expression stack of the interpreted method that has just
duke@0 247 // returned. Place this result on the java expression stack of the caller.
duke@0 248 //
never@304 249 // The current interpreter activation in rsi/r13 is for the method just returning its
duke@0 250 // result. So we know that the result of this method is on the top of the current
duke@0 251 // execution stack (which is pre-pushed) and will be return to the top of the caller
duke@0 252 // stack. The top of the callers stack is the bottom of the locals of the current
duke@0 253 // activation.
duke@0 254 // Because of the way activation are managed by the frame manager the value of rsp is
duke@0 255 // below both the stack top of the current activation and naturally the stack top
duke@0 256 // of the calling activation. This enable this routine to leave the return address
duke@0 257 // to the frame manager on the stack and do a vanilla return.
duke@0 258 //
never@304 259 // On entry: rsi/r13 - interpreter state of activation returning a (potential) result
never@304 260 // On Return: rsi/r13 - unchanged
duke@0 261 // rax - new stack top for caller activation (i.e. activation in _prev_link)
duke@0 262 //
duke@0 263 // Can destroy rdx, rcx.
duke@0 264 //
duke@0 265
duke@0 266 address entry = __ pc();
duke@0 267 const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();
duke@0 268 switch (type) {
duke@0 269 case T_VOID:
never@304 270 __ movptr(rax, STATE(_locals)); // pop parameters get new stack value
never@304 271 __ addptr(rax, wordSize); // account for prepush before we return
duke@0 272 break;
duke@0 273 case T_FLOAT :
duke@0 274 case T_BOOLEAN:
duke@0 275 case T_CHAR :
duke@0 276 case T_BYTE :
duke@0 277 case T_SHORT :
duke@0 278 case T_INT :
duke@0 279 // 1 word result
never@304 280 __ movptr(rdx, STATE(_stack));
never@304 281 __ movptr(rax, STATE(_locals)); // address for result
duke@0 282 __ movl(rdx, Address(rdx, wordSize)); // get result
never@304 283 __ movptr(Address(rax, 0), rdx); // and store it
duke@0 284 break;
duke@0 285 case T_LONG :
duke@0 286 case T_DOUBLE :
duke@0 287 // return top two words on current expression stack to caller's expression stack
duke@0 288 // The caller's expression stack is adjacent to the current frame manager's intepretState
duke@0 289 // except we allocated one extra word for this intepretState so we won't overwrite it
duke@0 290 // when we return a two word result.
duke@0 291
never@304 292 __ movptr(rax, STATE(_locals)); // address for result
never@304 293 __ movptr(rcx, STATE(_stack));
never@304 294 __ subptr(rax, wordSize); // need addition word besides locals[0]
never@304 295 __ movptr(rdx, Address(rcx, 2*wordSize)); // get result word (junk in 64bit)
never@304 296 __ movptr(Address(rax, wordSize), rdx); // and store it
never@304 297 __ movptr(rdx, Address(rcx, wordSize)); // get result word
never@304 298 __ movptr(Address(rax, 0), rdx); // and store it
duke@0 299 break;
duke@0 300 case T_OBJECT :
never@304 301 __ movptr(rdx, STATE(_stack));
never@304 302 __ movptr(rax, STATE(_locals)); // address for result
never@304 303 __ movptr(rdx, Address(rdx, wordSize)); // get result
duke@0 304 __ verify_oop(rdx); // verify it
never@304 305 __ movptr(Address(rax, 0), rdx); // and store it
duke@0 306 break;
duke@0 307 default : ShouldNotReachHere();
duke@0 308 }
duke@0 309 __ ret(0);
duke@0 310 return entry;
duke@0 311 }
duke@0 312
duke@0 313 address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {
duke@0 314 // A result is in the java expression stack of the interpreted method that has just
duke@0 315 // returned. Place this result in the native abi that the caller expects.
duke@0 316 //
duke@0 317 // Similar to generate_stack_to_stack_converter above. Called at a similar time from the
duke@0 318 // frame manager execept in this situation the caller is native code (c1/c2/call_stub)
duke@0 319 // and so rather than return result onto caller's java expression stack we return the
duke@0 320 // result in the expected location based on the native abi.
never@304 321 // On entry: rsi/r13 - interpreter state of activation returning a (potential) result
never@304 322 // On Return: rsi/r13 - unchanged
duke@0 323 // Other registers changed [rax/rdx/ST(0) as needed for the result returned]
duke@0 324
duke@0 325 address entry = __ pc();
duke@0 326 switch (type) {
duke@0 327 case T_VOID:
duke@0 328 break;
duke@0 329 case T_BOOLEAN:
duke@0 330 case T_CHAR :
duke@0 331 case T_BYTE :
duke@0 332 case T_SHORT :
duke@0 333 case T_INT :
never@304 334 __ movptr(rdx, STATE(_stack)); // get top of stack
duke@0 335 __ movl(rax, Address(rdx, wordSize)); // get result word 1
duke@0 336 break;
duke@0 337 case T_LONG :
never@304 338 __ movptr(rdx, STATE(_stack)); // get top of stack
never@304 339 __ movptr(rax, Address(rdx, wordSize)); // get result low word
never@304 340 NOT_LP64(__ movl(rdx, Address(rdx, 2*wordSize));) // get result high word
duke@0 341 break;
duke@0 342 case T_FLOAT :
never@304 343 __ movptr(rdx, STATE(_stack)); // get top of stack
duke@0 344 if ( UseSSE >= 1) {
duke@0 345 __ movflt(xmm0, Address(rdx, wordSize));
duke@0 346 } else {
duke@0 347 __ fld_s(Address(rdx, wordSize)); // pushd float result
duke@0 348 }
duke@0 349 break;
duke@0 350 case T_DOUBLE :
never@304 351 __ movptr(rdx, STATE(_stack)); // get top of stack
duke@0 352 if ( UseSSE > 1) {
duke@0 353 __ movdbl(xmm0, Address(rdx, wordSize));
duke@0 354 } else {
duke@0 355 __ fld_d(Address(rdx, wordSize)); // push double result
duke@0 356 }
duke@0 357 break;
duke@0 358 case T_OBJECT :
never@304 359 __ movptr(rdx, STATE(_stack)); // get top of stack
never@304 360 __ movptr(rax, Address(rdx, wordSize)); // get result word 1
duke@0 361 __ verify_oop(rax); // verify it
duke@0 362 break;
duke@0 363 default : ShouldNotReachHere();
duke@0 364 }
duke@0 365 __ ret(0);
duke@0 366 return entry;
duke@0 367 }
duke@0 368
duke@0 369 address CppInterpreter::return_entry(TosState state, int length) {
duke@0 370 // make it look good in the debugger
duke@0 371 return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation);
duke@0 372 }
duke@0 373
duke@0 374 address CppInterpreter::deopt_entry(TosState state, int length) {
duke@0 375 address ret = NULL;
duke@0 376 if (length != 0) {
duke@0 377 switch (state) {
duke@0 378 case atos: ret = deopt_frame_manager_return_atos; break;
duke@0 379 case btos: ret = deopt_frame_manager_return_btos; break;
duke@0 380 case ctos:
duke@0 381 case stos:
duke@0 382 case itos: ret = deopt_frame_manager_return_itos; break;
duke@0 383 case ltos: ret = deopt_frame_manager_return_ltos; break;
duke@0 384 case ftos: ret = deopt_frame_manager_return_ftos; break;
duke@0 385 case dtos: ret = deopt_frame_manager_return_dtos; break;
duke@0 386 case vtos: ret = deopt_frame_manager_return_vtos; break;
duke@0 387 }
duke@0 388 } else {
duke@0 389 ret = unctrap_frame_manager_entry; // re-execute the bytecode ( e.g. uncommon trap)
duke@0 390 }
duke@0 391 assert(ret != NULL, "Not initialized");
duke@0 392 return ret;
duke@0 393 }
duke@0 394
duke@0 395 // C++ Interpreter
duke@0 396 void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state,
duke@0 397 const Register locals,
duke@0 398 const Register sender_sp,
duke@0 399 bool native) {
duke@0 400
duke@0 401 // On entry the "locals" argument points to locals[0] (or where it would be in case no locals in
duke@0 402 // a static method). "state" contains any previous frame manager state which we must save a link
duke@0 403 // to in the newly generated state object. On return "state" is a pointer to the newly allocated
duke@0 404 // state object. We must allocate and initialize a new interpretState object and the method
duke@0 405 // expression stack. Because the returned result (if any) of the method will be placed on the caller's
duke@0 406 // expression stack and this will overlap with locals[0] (and locals[1] if double/long) we must
duke@0 407 // be sure to leave space on the caller's stack so that this result will not overwrite values when
duke@0 408 // locals[0] and locals[1] do not exist (and in fact are return address and saved rbp). So when
duke@0 409 // we are non-native we in essence ensure that locals[0-1] exist. We play an extra trick in
duke@0 410 // non-product builds and initialize this last local with the previous interpreterState as
duke@0 411 // this makes things look real nice in the debugger.
duke@0 412
duke@0 413 // State on entry
duke@0 414 // Assumes locals == &locals[0]
duke@0 415 // Assumes state == any previous frame manager state (assuming call path from c++ interpreter)
duke@0 416 // Assumes rax = return address
duke@0 417 // rcx == senders_sp
duke@0 418 // rbx == method
duke@0 419 // Modifies rcx, rdx, rax
duke@0 420 // Returns:
duke@0 421 // state == address of new interpreterState
duke@0 422 // rsp == bottom of method's expression stack.
duke@0 423
duke@0 424 const Address const_offset (rbx, methodOopDesc::const_offset());
duke@0 425
duke@0 426
duke@0 427 // On entry sp is the sender's sp. This includes the space for the arguments
duke@0 428 // that the sender pushed. If the sender pushed no args (a static) and the
duke@0 429 // caller returns a long then we need two words on the sender's stack which
duke@0 430 // are not present (although when we return a restore full size stack the
duke@0 431 // space will be present). If we didn't allocate two words here then when
duke@0 432 // we "push" the result of the caller's stack we would overwrite the return
duke@0 433 // address and the saved rbp. Not good. So simply allocate 2 words now
duke@0 434 // just to be safe. This is the "static long no_params() method" issue.
duke@0 435 // See Lo.java for a testcase.
duke@0 436 // We don't need this for native calls because they return result in
duke@0 437 // register and the stack is expanded in the caller before we store
duke@0 438 // the results on the stack.
duke@0 439
duke@0 440 if (!native) {
duke@0 441 #ifdef PRODUCT
never@304 442 __ subptr(rsp, 2*wordSize);
duke@0 443 #else /* PRODUCT */
never@304 444 __ push((int32_t)NULL_WORD);
never@304 445 __ push(state); // make it look like a real argument
duke@0 446 #endif /* PRODUCT */
duke@0 447 }
duke@0 448
duke@0 449 // Now that we are assure of space for stack result, setup typical linkage
duke@0 450
never@304 451 __ push(rax);
duke@0 452 __ enter();
duke@0 453
never@304 454 __ mov(rax, state); // save current state
never@304 455
never@304 456 __ lea(rsp, Address(rsp, -(int)sizeof(BytecodeInterpreter)));
never@304 457 __ mov(state, rsp);
never@304 458
never@304 459 // rsi/r13 == state/locals rax == prevstate
duke@0 460
duke@0 461 // initialize the "shadow" frame so that use since C++ interpreter not directly
duke@0 462 // recursive. Simpler to recurse but we can't trim expression stack as we call
duke@0 463 // new methods.
never@304 464 __ movptr(STATE(_locals), locals); // state->_locals = locals()
never@304 465 __ movptr(STATE(_self_link), state); // point to self
never@304 466 __ movptr(STATE(_prev_link), rax); // state->_link = state on entry (NULL or previous state)
never@304 467 __ movptr(STATE(_sender_sp), sender_sp); // state->_sender_sp = sender_sp
never@304 468 #ifdef _LP64
never@304 469 __ movptr(STATE(_thread), r15_thread); // state->_bcp = codes()
never@304 470 #else
duke@0 471 __ get_thread(rax); // get vm's javathread*
never@304 472 __ movptr(STATE(_thread), rax); // state->_bcp = codes()
never@304 473 #endif // _LP64
never@304 474 __ movptr(rdx, Address(rbx, methodOopDesc::const_offset())); // get constantMethodOop
never@304 475 __ lea(rdx, Address(rdx, constMethodOopDesc::codes_offset())); // get code base
duke@0 476 if (native) {
never@304 477 __ movptr(STATE(_bcp), (int32_t)NULL_WORD); // state->_bcp = NULL
duke@0 478 } else {
never@304 479 __ movptr(STATE(_bcp), rdx); // state->_bcp = codes()
duke@0 480 }
never@304 481 __ xorptr(rdx, rdx);
never@304 482 __ movptr(STATE(_oop_temp), rdx); // state->_oop_temp = NULL (only really needed for native)
never@304 483 __ movptr(STATE(_mdx), rdx); // state->_mdx = NULL
never@304 484 __ movptr(rdx, Address(rbx, methodOopDesc::constants_offset()));
never@304 485 __ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes()));
never@304 486 __ movptr(STATE(_constants), rdx); // state->_constants = constants()
never@304 487
never@304 488 __ movptr(STATE(_method), rbx); // state->_method = method()
never@304 489 __ movl(STATE(_msg), (int32_t) BytecodeInterpreter::method_entry); // state->_msg = initial method entry
never@304 490 __ movptr(STATE(_result._to_call._callee), (int32_t) NULL_WORD); // state->_result._to_call._callee_callee = NULL
never@304 491
never@304 492
never@304 493 __ movptr(STATE(_monitor_base), rsp); // set monitor block bottom (grows down) this would point to entry [0]
duke@0 494 // entries run from -1..x where &monitor[x] ==
duke@0 495
duke@0 496 {
duke@0 497 // Must not attempt to lock method until we enter interpreter as gc won't be able to find the
duke@0 498 // initial frame. However we allocate a free monitor so we don't have to shuffle the expression stack
duke@0 499 // immediately.
duke@0 500
duke@0 501 // synchronize method
duke@0 502 const Address access_flags (rbx, methodOopDesc::access_flags_offset());
duke@0 503 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
duke@0 504 Label not_synced;
duke@0 505
duke@0 506 __ movl(rax, access_flags);
duke@0 507 __ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@0 508 __ jcc(Assembler::zero, not_synced);
duke@0 509
duke@0 510 // Allocate initial monitor and pre initialize it
duke@0 511 // get synchronization object
duke@0 512
duke@0 513 Label done;
duke@0 514 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
duke@0 515 __ movl(rax, access_flags);
duke@0 516 __ testl(rax, JVM_ACC_STATIC);
never@304 517 __ movptr(rax, Address(locals, 0)); // get receiver (assume this is frequent case)
duke@0 518 __ jcc(Assembler::zero, done);
never@304 519 __ movptr(rax, Address(rbx, methodOopDesc::constants_offset()));
never@304 520 __ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
never@304 521 __ movptr(rax, Address(rax, mirror_offset));
duke@0 522 __ bind(done);
duke@0 523 // add space for monitor & lock
never@304 524 __ subptr(rsp, entry_size); // add space for a monitor entry
never@304 525 __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); // store object
duke@0 526 __ bind(not_synced);
duke@0 527 }
duke@0 528
never@304 529 __ movptr(STATE(_stack_base), rsp); // set expression stack base ( == &monitors[-count])
duke@0 530 if (native) {
never@304 531 __ movptr(STATE(_stack), rsp); // set current expression stack tos
never@304 532 __ movptr(STATE(_stack_limit), rsp);
duke@0 533 } else {
never@304 534 __ subptr(rsp, wordSize); // pre-push stack
never@304 535 __ movptr(STATE(_stack), rsp); // set current expression stack tos
duke@0 536
duke@0 537 // compute full expression stack limit
duke@0 538
duke@0 539 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
jrose@710 540 const int extra_stack = 0; //6815692//methodOopDesc::extra_stack_words();
jrose@622 541 __ load_unsigned_short(rdx, size_of_stack); // get size of expression stack in words
never@304 542 __ negptr(rdx); // so we can subtract in next step
duke@0 543 // Allocate expression stack
jrose@710 544 __ lea(rsp, Address(rsp, rdx, Address::times_ptr, -extra_stack));
never@304 545 __ movptr(STATE(_stack_limit), rsp);
duke@0 546 }
duke@0 547
never@304 548 #ifdef _LP64
never@304 549 // Make sure stack is properly aligned and sized for the abi
never@304 550 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
twisti@605 551 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI)
never@304 552 #endif // _LP64
never@304 553
never@304 554
never@304 555
duke@0 556 }
duke@0 557
duke@0 558 // Helpers for commoning out cases in the various type of method entries.
duke@0 559 //
duke@0 560
duke@0 561 // increment invocation count & check for overflow
duke@0 562 //
duke@0 563 // Note: checking for negative value instead of overflow
duke@0 564 // so we have a 'sticky' overflow test
duke@0 565 //
duke@0 566 // rbx,: method
duke@0 567 // rcx: invocation counter
duke@0 568 //
duke@0 569 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
duke@0 570
duke@0 571 const Address invocation_counter(rbx, methodOopDesc::invocation_counter_offset() + InvocationCounter::counter_offset());
duke@0 572 const Address backedge_counter (rbx, methodOopDesc::backedge_counter_offset() + InvocationCounter::counter_offset());
duke@0 573
duke@0 574 if (ProfileInterpreter) { // %%% Merge this into methodDataOop
never@304 575 __ incrementl(Address(rbx,methodOopDesc::interpreter_invocation_counter_offset()));
duke@0 576 }
duke@0 577 // Update standard invocation counters
duke@0 578 __ movl(rax, backedge_counter); // load backedge counter
duke@0 579
duke@0 580 __ increment(rcx, InvocationCounter::count_increment);
duke@0 581 __ andl(rax, InvocationCounter::count_mask_value); // mask out the status bits
duke@0 582
duke@0 583 __ movl(invocation_counter, rcx); // save invocation count
duke@0 584 __ addl(rcx, rax); // add both counters
duke@0 585
duke@0 586 // profile_method is non-null only for interpreted method so
duke@0 587 // profile_method != NULL == !native_call
duke@0 588 // BytecodeInterpreter only calls for native so code is elided.
duke@0 589
duke@0 590 __ cmp32(rcx,
duke@0 591 ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit));
duke@0 592 __ jcc(Assembler::aboveEqual, *overflow);
duke@0 593
duke@0 594 }
duke@0 595
duke@0 596 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {
duke@0 597
duke@0 598 // C++ interpreter on entry
never@304 599 // rsi/r13 - new interpreter state pointer
duke@0 600 // rbp - interpreter frame pointer
duke@0 601 // rbx - method
duke@0 602
duke@0 603 // On return (i.e. jump to entry_point) [ back to invocation of interpreter ]
duke@0 604 // rbx, - method
duke@0 605 // rcx - rcvr (assuming there is one)
duke@0 606 // top of stack return address of interpreter caller
duke@0 607 // rsp - sender_sp
duke@0 608
duke@0 609 // C++ interpreter only
never@304 610 // rsi/r13 - previous interpreter state pointer
duke@0 611
duke@0 612 const Address size_of_parameters(rbx, methodOopDesc::size_of_parameters_offset());
duke@0 613
duke@0 614 // InterpreterRuntime::frequency_counter_overflow takes one argument
duke@0 615 // indicating if the counter overflow occurs at a backwards branch (non-NULL bcp).
duke@0 616 // The call returns the address of the verified entry point for the method or NULL
duke@0 617 // if the compilation did not complete (either went background or bailed out).
never@304 618 __ movptr(rax, (int32_t)false);
duke@0 619 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), rax);
duke@0 620
duke@0 621 // for c++ interpreter can rsi really be munged?
coleenp@520 622 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter))); // restore state
never@304 623 __ movptr(rbx, Address(state, byte_offset_of(BytecodeInterpreter, _method))); // restore method
never@304 624 __ movptr(rdi, Address(state, byte_offset_of(BytecodeInterpreter, _locals))); // get locals pointer
never@304 625
duke@0 626 __ jmp(*do_continue, relocInfo::none);
duke@0 627
duke@0 628 }
duke@0 629
duke@0 630 void InterpreterGenerator::generate_stack_overflow_check(void) {
duke@0 631 // see if we've got enough room on the stack for locals plus overhead.
duke@0 632 // the expression stack grows down incrementally, so the normal guard
duke@0 633 // page mechanism will work for that.
duke@0 634 //
duke@0 635 // Registers live on entry:
duke@0 636 //
duke@0 637 // Asm interpreter
duke@0 638 // rdx: number of additional locals this frame needs (what we must check)
duke@0 639 // rbx,: methodOop
duke@0 640
duke@0 641 // C++ Interpreter
never@304 642 // rsi/r13: previous interpreter frame state object
duke@0 643 // rdi: &locals[0]
duke@0 644 // rcx: # of locals
duke@0 645 // rdx: number of additional locals this frame needs (what we must check)
duke@0 646 // rbx: methodOop
duke@0 647
duke@0 648 // destroyed on exit
duke@0 649 // rax,
duke@0 650
duke@0 651 // NOTE: since the additional locals are also always pushed (wasn't obvious in
duke@0 652 // generate_method_entry) so the guard should work for them too.
duke@0 653 //
duke@0 654
duke@0 655 // monitor entry size: see picture of stack set (generate_method_entry) and frame_i486.hpp
duke@0 656 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
duke@0 657
duke@0 658 // total overhead size: entry_size + (saved rbp, thru expr stack bottom).
duke@0 659 // be sure to change this if you add/subtract anything to/from the overhead area
duke@0 660 const int overhead_size = (int)sizeof(BytecodeInterpreter);
duke@0 661
duke@0 662 const int page_size = os::vm_page_size();
duke@0 663
duke@0 664 Label after_frame_check;
duke@0 665
duke@0 666 // compute rsp as if this were going to be the last frame on
duke@0 667 // the stack before the red zone
duke@0 668
duke@0 669 Label after_frame_check_pop;
duke@0 670
duke@0 671 // save rsi == caller's bytecode ptr (c++ previous interp. state)
duke@0 672 // QQQ problem here?? rsi overload????
never@304 673 __ push(state);
never@304 674
never@304 675 const Register thread = LP64_ONLY(r15_thread) NOT_LP64(rsi);
never@304 676
never@304 677 NOT_LP64(__ get_thread(thread));
duke@0 678
duke@0 679 const Address stack_base(thread, Thread::stack_base_offset());
duke@0 680 const Address stack_size(thread, Thread::stack_size_offset());
duke@0 681
duke@0 682 // locals + overhead, in bytes
duke@0 683 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
duke@0 684 // Always give one monitor to allow us to start interp if sync method.
duke@0 685 // Any additional monitors need a check when moving the expression stack
coleenp@520 686 const int one_monitor = frame::interpreter_frame_monitor_size() * wordSize;
jrose@710 687 const int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
jrose@622 688 __ load_unsigned_short(rax, size_of_stack); // get size of expression stack in words
jrose@710 689 __ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), extra_stack + one_monitor));
never@304 690 __ lea(rax, Address(rax, rdx, Interpreter::stackElementScale(), overhead_size));
duke@0 691
duke@0 692 #ifdef ASSERT
duke@0 693 Label stack_base_okay, stack_size_okay;
duke@0 694 // verify that thread stack base is non-zero
never@304 695 __ cmpptr(stack_base, (int32_t)0);
duke@0 696 __ jcc(Assembler::notEqual, stack_base_okay);
duke@0 697 __ stop("stack base is zero");
duke@0 698 __ bind(stack_base_okay);
duke@0 699 // verify that thread stack size is non-zero
never@304 700 __ cmpptr(stack_size, (int32_t)0);
duke@0 701 __ jcc(Assembler::notEqual, stack_size_okay);
duke@0 702 __ stop("stack size is zero");
duke@0 703 __ bind(stack_size_okay);
duke@0 704 #endif
duke@0 705
duke@0 706 // Add stack base to locals and subtract stack size
never@304 707 __ addptr(rax, stack_base);
never@304 708 __ subptr(rax, stack_size);
duke@0 709
duke@0 710 // We should have a magic number here for the size of the c++ interpreter frame.
duke@0 711 // We can't actually tell this ahead of time. The debug version size is around 3k
duke@0 712 // product is 1k and fastdebug is 4k
duke@0 713 const int slop = 6 * K;
duke@0 714
duke@0 715 // Use the maximum number of pages we might bang.
duke@0 716 const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages :
duke@0 717 (StackRedPages+StackYellowPages);
duke@0 718 // Only need this if we are stack banging which is temporary while
duke@0 719 // we're debugging.
never@304 720 __ addptr(rax, slop + 2*max_pages * page_size);
duke@0 721
duke@0 722 // check against the current stack bottom
never@304 723 __ cmpptr(rsp, rax);
duke@0 724 __ jcc(Assembler::above, after_frame_check_pop);
duke@0 725
never@304 726 __ pop(state); // get c++ prev state.
duke@0 727
duke@0 728 // throw exception return address becomes throwing pc
duke@0 729 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));
duke@0 730
duke@0 731 // all done with frame size check
duke@0 732 __ bind(after_frame_check_pop);
never@304 733 __ pop(state);
duke@0 734
duke@0 735 __ bind(after_frame_check);
duke@0 736 }
duke@0 737
duke@0 738 // Find preallocated monitor and lock method (C++ interpreter)
duke@0 739 // rbx - methodOop
duke@0 740 //
duke@0 741 void InterpreterGenerator::lock_method(void) {
never@304 742 // assumes state == rsi/r13 == pointer to current interpreterState
never@304 743 // minimally destroys rax, rdx|c_rarg1, rdi
duke@0 744 //
duke@0 745 // synchronize method
duke@0 746 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
duke@0 747 const Address access_flags (rbx, methodOopDesc::access_flags_offset());
duke@0 748
never@304 749 const Register monitor = NOT_LP64(rdx) LP64_ONLY(c_rarg1);
never@304 750
duke@0 751 // find initial monitor i.e. monitors[-1]
never@304 752 __ movptr(monitor, STATE(_monitor_base)); // get monitor bottom limit
never@304 753 __ subptr(monitor, entry_size); // point to initial monitor
duke@0 754
duke@0 755 #ifdef ASSERT
duke@0 756 { Label L;
duke@0 757 __ movl(rax, access_flags);
duke@0 758 __ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@0 759 __ jcc(Assembler::notZero, L);
duke@0 760 __ stop("method doesn't need synchronization");
duke@0 761 __ bind(L);
duke@0 762 }
duke@0 763 #endif // ASSERT
duke@0 764 // get synchronization object
duke@0 765 { Label done;
duke@0 766 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
duke@0 767 __ movl(rax, access_flags);
never@304 768 __ movptr(rdi, STATE(_locals)); // prepare to get receiver (assume common case)
duke@0 769 __ testl(rax, JVM_ACC_STATIC);
never@304 770 __ movptr(rax, Address(rdi, 0)); // get receiver (assume this is frequent case)
duke@0 771 __ jcc(Assembler::zero, done);
never@304 772 __ movptr(rax, Address(rbx, methodOopDesc::constants_offset()));
never@304 773 __ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
never@304 774 __ movptr(rax, Address(rax, mirror_offset));
duke@0 775 __ bind(done);
duke@0 776 }
duke@0 777 #ifdef ASSERT
duke@0 778 { Label L;
never@304 779 __ cmpptr(rax, Address(monitor, BasicObjectLock::obj_offset_in_bytes())); // correct object?
duke@0 780 __ jcc(Assembler::equal, L);
duke@0 781 __ stop("wrong synchronization lobject");
duke@0 782 __ bind(L);
duke@0 783 }
duke@0 784 #endif // ASSERT
never@304 785 // can destroy rax, rdx|c_rarg1, rcx, and (via call_VM) rdi!
never@304 786 __ lock_object(monitor);
duke@0 787 }
duke@0 788
duke@0 789 // Call an accessor method (assuming it is resolved, otherwise drop into vanilla (slow path) entry
duke@0 790
duke@0 791 address InterpreterGenerator::generate_accessor_entry(void) {
duke@0 792
never@304 793 // rbx: methodOop
never@304 794
never@304 795 // rsi/r13: senderSP must preserved for slow path, set SP to it on fast path
duke@0 796
duke@0 797 Label xreturn_path;
duke@0 798
duke@0 799 // do fastpath for resolved accessor methods
duke@0 800 if (UseFastAccessorMethods) {
duke@0 801
duke@0 802 address entry_point = __ pc();
duke@0 803
duke@0 804 Label slow_path;
duke@0 805 // If we need a safepoint check, generate full interpreter entry.
duke@0 806 ExternalAddress state(SafepointSynchronize::address_of_state());
duke@0 807 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
duke@0 808 SafepointSynchronize::_not_synchronized);
duke@0 809
duke@0 810 __ jcc(Assembler::notEqual, slow_path);
duke@0 811 // ASM/C++ Interpreter
duke@0 812 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites thereof; parameter size = 1
duke@0 813 // Note: We can only use this code if the getfield has been resolved
duke@0 814 // and if we don't have a null-pointer exception => check for
duke@0 815 // these conditions first and use slow path if necessary.
duke@0 816 // rbx,: method
duke@0 817 // rcx: receiver
never@304 818 __ movptr(rax, Address(rsp, wordSize));
duke@0 819
duke@0 820 // check if local 0 != NULL and read field
never@304 821 __ testptr(rax, rax);
duke@0 822 __ jcc(Assembler::zero, slow_path);
duke@0 823
never@304 824 __ movptr(rdi, Address(rbx, methodOopDesc::constants_offset()));
duke@0 825 // read first instruction word and extract bytecode @ 1 and index @ 2
never@304 826 __ movptr(rdx, Address(rbx, methodOopDesc::const_offset()));
duke@0 827 __ movl(rdx, Address(rdx, constMethodOopDesc::codes_offset()));
duke@0 828 // Shift codes right to get the index on the right.
duke@0 829 // The bytecode fetched looks like <index><0xb4><0x2a>
duke@0 830 __ shrl(rdx, 2*BitsPerByte);
duke@0 831 __ shll(rdx, exact_log2(in_words(ConstantPoolCacheEntry::size())));
never@304 832 __ movptr(rdi, Address(rdi, constantPoolOopDesc::cache_offset_in_bytes()));
duke@0 833
duke@0 834 // rax,: local 0
duke@0 835 // rbx,: method
duke@0 836 // rcx: receiver - do not destroy since it is needed for slow path!
duke@0 837 // rcx: scratch
duke@0 838 // rdx: constant pool cache index
duke@0 839 // rdi: constant pool cache
never@304 840 // rsi/r13: sender sp
duke@0 841
duke@0 842 // check if getfield has been resolved and read constant pool cache entry
duke@0 843 // check the validity of the cache entry by testing whether _indices field
duke@0 844 // contains Bytecode::_getfield in b1 byte.
duke@0 845 assert(in_words(ConstantPoolCacheEntry::size()) == 4, "adjust shift below");
duke@0 846 __ movl(rcx,
duke@0 847 Address(rdi,
duke@0 848 rdx,
never@304 849 Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::indices_offset()));
duke@0 850 __ shrl(rcx, 2*BitsPerByte);
duke@0 851 __ andl(rcx, 0xFF);
duke@0 852 __ cmpl(rcx, Bytecodes::_getfield);
duke@0 853 __ jcc(Assembler::notEqual, slow_path);
duke@0 854
duke@0 855 // Note: constant pool entry is not valid before bytecode is resolved
never@304 856 __ movptr(rcx,
duke@0 857 Address(rdi,
duke@0 858 rdx,
never@304 859 Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::f2_offset()));
duke@0 860 __ movl(rdx,
duke@0 861 Address(rdi,
duke@0 862 rdx,
never@304 863 Address::times_ptr, constantPoolCacheOopDesc::base_offset() + ConstantPoolCacheEntry::flags_offset()));
duke@0 864
duke@0 865 Label notByte, notShort, notChar;
duke@0 866 const Address field_address (rax, rcx, Address::times_1);
duke@0 867
duke@0 868 // Need to differentiate between igetfield, agetfield, bgetfield etc.
duke@0 869 // because they are different sizes.
duke@0 870 // Use the type from the constant pool cache
duke@0 871 __ shrl(rdx, ConstantPoolCacheEntry::tosBits);
duke@0 872 // Make sure we don't need to mask rdx for tosBits after the above shift
duke@0 873 ConstantPoolCacheEntry::verify_tosBits();
never@304 874 #ifdef _LP64
never@304 875 Label notObj;
never@304 876 __ cmpl(rdx, atos);
never@304 877 __ jcc(Assembler::notEqual, notObj);
never@304 878 // atos
never@304 879 __ movptr(rax, field_address);
never@304 880 __ jmp(xreturn_path);
never@304 881
never@304 882 __ bind(notObj);
never@304 883 #endif // _LP64
duke@0 884 __ cmpl(rdx, btos);
duke@0 885 __ jcc(Assembler::notEqual, notByte);
duke@0 886 __ load_signed_byte(rax, field_address);
duke@0 887 __ jmp(xreturn_path);
duke@0 888
duke@0 889 __ bind(notByte);
duke@0 890 __ cmpl(rdx, stos);
duke@0 891 __ jcc(Assembler::notEqual, notShort);
jrose@622 892 __ load_signed_short(rax, field_address);
duke@0 893 __ jmp(xreturn_path);
duke@0 894
duke@0 895 __ bind(notShort);
duke@0 896 __ cmpl(rdx, ctos);
duke@0 897 __ jcc(Assembler::notEqual, notChar);
jrose@622 898 __ load_unsigned_short(rax, field_address);
duke@0 899 __ jmp(xreturn_path);
duke@0 900
duke@0 901 __ bind(notChar);
duke@0 902 #ifdef ASSERT
duke@0 903 Label okay;
never@304 904 #ifndef _LP64
duke@0 905 __ cmpl(rdx, atos);
duke@0 906 __ jcc(Assembler::equal, okay);
never@304 907 #endif // _LP64
duke@0 908 __ cmpl(rdx, itos);
duke@0 909 __ jcc(Assembler::equal, okay);
duke@0 910 __ stop("what type is this?");
duke@0 911 __ bind(okay);
duke@0 912 #endif // ASSERT
duke@0 913 // All the rest are a 32 bit wordsize
duke@0 914 __ movl(rax, field_address);
duke@0 915
duke@0 916 __ bind(xreturn_path);
duke@0 917
duke@0 918 // _ireturn/_areturn
never@304 919 __ pop(rdi); // get return address
never@304 920 __ mov(rsp, sender_sp_on_entry); // set sp to sender sp
duke@0 921 __ jmp(rdi);
duke@0 922
duke@0 923 // generate a vanilla interpreter entry as the slow path
duke@0 924 __ bind(slow_path);
duke@0 925 // We will enter c++ interpreter looking like it was
duke@0 926 // called by the call_stub this will cause it to return
duke@0 927 // a tosca result to the invoker which might have been
duke@0 928 // the c++ interpreter itself.
duke@0 929
duke@0 930 __ jmp(fast_accessor_slow_entry_path);
duke@0 931 return entry_point;
duke@0 932
duke@0 933 } else {
duke@0 934 return NULL;
duke@0 935 }
duke@0 936
duke@0 937 }
duke@0 938
johnc@2346 939 address InterpreterGenerator::generate_Reference_get_entry(void) {
johnc@2346 940 #ifndef SERIALGC
johnc@2346 941 if (UseG1GC) {
johnc@2346 942 // We need to generate have a routine that generates code to:
johnc@2346 943 // * load the value in the referent field
johnc@2346 944 // * passes that value to the pre-barrier.
johnc@2346 945 //
johnc@2346 946 // In the case of G1 this will record the value of the
johnc@2346 947 // referent in an SATB buffer if marking is active.
johnc@2346 948 // This will cause concurrent marking to mark the referent
johnc@2346 949 // field as live.
johnc@2346 950 Unimplemented();
johnc@2346 951 }
johnc@2346 952 #endif // SERIALGC
johnc@2346 953
johnc@2346 954 // If G1 is not enabled then attempt to go through the accessor entry point
johnc@2346 955 // Reference.get is an accessor
johnc@2346 956 return generate_accessor_entry();
johnc@2346 957 }
johnc@2346 958
duke@0 959 //
duke@0 960 // C++ Interpreter stub for calling a native method.
duke@0 961 // This sets up a somewhat different looking stack for calling the native method
duke@0 962 // than the typical interpreter frame setup but still has the pointer to
duke@0 963 // an interpreter state.
duke@0 964 //
duke@0 965
duke@0 966 address InterpreterGenerator::generate_native_entry(bool synchronized) {
duke@0 967 // determine code generation flags
duke@0 968 bool inc_counter = UseCompiler || CountCompiledCalls;
duke@0 969
duke@0 970 // rbx: methodOop
duke@0 971 // rcx: receiver (unused)
never@304 972 // rsi/r13: previous interpreter state (if called from C++ interpreter) must preserve
never@304 973 // in any case. If called via c1/c2/call_stub rsi/r13 is junk (to use) but harmless
duke@0 974 // to save/restore.
duke@0 975 address entry_point = __ pc();
duke@0 976
duke@0 977 const Address size_of_parameters(rbx, methodOopDesc::size_of_parameters_offset());
duke@0 978 const Address size_of_locals (rbx, methodOopDesc::size_of_locals_offset());
duke@0 979 const Address invocation_counter(rbx, methodOopDesc::invocation_counter_offset() + InvocationCounter::counter_offset());
duke@0 980 const Address access_flags (rbx, methodOopDesc::access_flags_offset());
duke@0 981
never@304 982 // rsi/r13 == state/locals rdi == prevstate
duke@0 983 const Register locals = rdi;
duke@0 984
duke@0 985 // get parameter size (always needed)
jrose@622 986 __ load_unsigned_short(rcx, size_of_parameters);
duke@0 987
duke@0 988 // rbx: methodOop
duke@0 989 // rcx: size of parameters
never@304 990 __ pop(rax); // get return address
duke@0 991 // for natives the size of locals is zero
duke@0 992
duke@0 993 // compute beginning of parameters /locals
never@304 994 __ lea(locals, Address(rsp, rcx, Address::times_ptr, -wordSize));
duke@0 995
duke@0 996 // initialize fixed part of activation frame
duke@0 997
duke@0 998 // Assumes rax = return address
duke@0 999
duke@0 1000 // allocate and initialize new interpreterState and method expression stack
duke@0 1001 // IN(locals) -> locals
duke@0 1002 // IN(state) -> previous frame manager state (NULL from stub/c1/c2)
duke@0 1003 // destroys rax, rcx, rdx
duke@0 1004 // OUT (state) -> new interpreterState
duke@0 1005 // OUT(rsp) -> bottom of methods expression stack
duke@0 1006
duke@0 1007 // save sender_sp
never@304 1008 __ mov(rcx, sender_sp_on_entry);
duke@0 1009 // start with NULL previous state
never@304 1010 __ movptr(state, (int32_t)NULL_WORD);
duke@0 1011 generate_compute_interpreter_state(state, locals, rcx, true);
duke@0 1012
duke@0 1013 #ifdef ASSERT
duke@0 1014 { Label L;
never@304 1015 __ movptr(rax, STATE(_stack_base));
never@304 1016 #ifdef _LP64
never@304 1017 // duplicate the alignment rsp got after setting stack_base
never@304 1018 __ subptr(rax, frame::arg_reg_save_area_bytes); // windows
twisti@605 1019 __ andptr(rax, -16); // must be 16 byte boundary (see amd64 ABI)
never@304 1020 #endif // _LP64
never@304 1021 __ cmpptr(rax, rsp);
duke@0 1022 __ jcc(Assembler::equal, L);
duke@0 1023 __ stop("broken stack frame setup in interpreter");
duke@0 1024 __ bind(L);
duke@0 1025 }
duke@0 1026 #endif
duke@0 1027
duke@0 1028 if (inc_counter) __ movl(rcx, invocation_counter); // (pre-)fetch invocation count
duke@0 1029
never@304 1030 const Register unlock_thread = LP64_ONLY(r15_thread) NOT_LP64(rax);
never@304 1031 NOT_LP64(__ movptr(unlock_thread, STATE(_thread));) // get thread
duke@0 1032 // Since at this point in the method invocation the exception handler
duke@0 1033 // would try to exit the monitor of synchronized methods which hasn't
duke@0 1034 // been entered yet, we set the thread local variable
duke@0 1035 // _do_not_unlock_if_synchronized to true. The remove_activation will
duke@0 1036 // check this flag.
duke@0 1037
never@304 1038 const Address do_not_unlock_if_synchronized(unlock_thread,
duke@0 1039 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
duke@0 1040 __ movbool(do_not_unlock_if_synchronized, true);
duke@0 1041
duke@0 1042 // make sure method is native & not abstract
duke@0 1043 #ifdef ASSERT
duke@0 1044 __ movl(rax, access_flags);
duke@0 1045 {
duke@0 1046 Label L;
duke@0 1047 __ testl(rax, JVM_ACC_NATIVE);
duke@0 1048 __ jcc(Assembler::notZero, L);
duke@0 1049 __ stop("tried to execute non-native method as native");
duke@0 1050 __ bind(L);
duke@0 1051 }
duke@0 1052 { Label L;
duke@0 1053 __ testl(rax, JVM_ACC_ABSTRACT);
duke@0 1054 __ jcc(Assembler::zero, L);
duke@0 1055 __ stop("tried to execute abstract method in interpreter");
duke@0 1056 __ bind(L);
duke@0 1057 }
duke@0 1058 #endif
duke@0 1059
duke@0 1060
duke@0 1061 // increment invocation count & check for overflow
duke@0 1062 Label invocation_counter_overflow;
duke@0 1063 if (inc_counter) {
duke@0 1064 generate_counter_incr(&invocation_counter_overflow, NULL, NULL);
duke@0 1065 }
duke@0 1066
duke@0 1067 Label continue_after_compile;
duke@0 1068
duke@0 1069 __ bind(continue_after_compile);
duke@0 1070
duke@0 1071 bang_stack_shadow_pages(true);
duke@0 1072
duke@0 1073 // reset the _do_not_unlock_if_synchronized flag
never@304 1074 NOT_LP64(__ movl(rax, STATE(_thread));) // get thread
duke@0 1075 __ movbool(do_not_unlock_if_synchronized, false);
duke@0 1076
duke@0 1077
duke@0 1078 // check for synchronized native methods
duke@0 1079 //
duke@0 1080 // Note: This must happen *after* invocation counter check, since
duke@0 1081 // when overflow happens, the method should not be locked.
duke@0 1082 if (synchronized) {
duke@0 1083 // potentially kills rax, rcx, rdx, rdi
duke@0 1084 lock_method();
duke@0 1085 } else {
duke@0 1086 // no synchronization necessary
duke@0 1087 #ifdef ASSERT
duke@0 1088 { Label L;
duke@0 1089 __ movl(rax, access_flags);
duke@0 1090 __ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@0 1091 __ jcc(Assembler::zero, L);
duke@0 1092 __ stop("method needs synchronization");
duke@0 1093 __ bind(L);
duke@0 1094 }
duke@0 1095 #endif
duke@0 1096 }
duke@0 1097
duke@0 1098 // start execution
duke@0 1099
duke@0 1100 // jvmti support
duke@0 1101 __ notify_method_entry();
duke@0 1102
duke@0 1103 // work registers
duke@0 1104 const Register method = rbx;
never@304 1105 const Register thread = LP64_ONLY(r15_thread) NOT_LP64(rdi);
never@304 1106 const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp(); // rcx|rscratch1
duke@0 1107
duke@0 1108 // allocate space for parameters
never@304 1109 __ movptr(method, STATE(_method));
duke@0 1110 __ verify_oop(method);
jrose@622 1111 __ load_unsigned_short(t, Address(method, methodOopDesc::size_of_parameters_offset()));
duke@0 1112 __ shll(t, 2);
never@304 1113 #ifdef _LP64
never@304 1114 __ subptr(rsp, t);
never@304 1115 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
twisti@605 1116 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI)
never@304 1117 #else
never@304 1118 __ addptr(t, 2*wordSize); // allocate two more slots for JNIEnv and possible mirror
never@304 1119 __ subptr(rsp, t);
never@304 1120 __ andptr(rsp, -(StackAlignmentInBytes)); // gcc needs 16 byte aligned stacks to do XMM intrinsics
never@304 1121 #endif // _LP64
duke@0 1122
duke@0 1123 // get signature handler
duke@0 1124 Label pending_exception_present;
duke@0 1125
duke@0 1126 { Label L;
never@304 1127 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
never@304 1128 __ testptr(t, t);
duke@0 1129 __ jcc(Assembler::notZero, L);
duke@0 1130 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method, false);
never@304 1131 __ movptr(method, STATE(_method));
never@304 1132 __ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
duke@0 1133 __ jcc(Assembler::notEqual, pending_exception_present);
duke@0 1134 __ verify_oop(method);
never@304 1135 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
duke@0 1136 __ bind(L);
duke@0 1137 }
duke@0 1138 #ifdef ASSERT
duke@0 1139 {
duke@0 1140 Label L;
never@304 1141 __ push(t);
duke@0 1142 __ get_thread(t); // get vm's javathread*
never@304 1143 __ cmpptr(t, STATE(_thread));
duke@0 1144 __ jcc(Assembler::equal, L);
duke@0 1145 __ int3();
duke@0 1146 __ bind(L);
never@304 1147 __ pop(t);
duke@0 1148 }
duke@0 1149 #endif //
duke@0 1150
never@304 1151 const Register from_ptr = InterpreterRuntime::SignatureHandlerGenerator::from();
duke@0 1152 // call signature handler
duke@0 1153 assert(InterpreterRuntime::SignatureHandlerGenerator::to () == rsp, "adjust this code");
never@304 1154
duke@0 1155 // The generated handlers do not touch RBX (the method oop).
duke@0 1156 // However, large signatures cannot be cached and are generated
duke@0 1157 // each time here. The slow-path generator will blow RBX
duke@0 1158 // sometime, so we must reload it after the call.
never@304 1159 __ movptr(from_ptr, STATE(_locals)); // get the from pointer
duke@0 1160 __ call(t);
never@304 1161 __ movptr(method, STATE(_method));
duke@0 1162 __ verify_oop(method);
duke@0 1163
duke@0 1164 // result handler is in rax
duke@0 1165 // set result handler
never@304 1166 __ movptr(STATE(_result_handler), rax);
never@304 1167
never@304 1168
never@304 1169 // get native function entry point
never@304 1170 { Label L;
never@304 1171 __ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
never@304 1172 __ testptr(rax, rax);
never@304 1173 __ jcc(Assembler::notZero, L);
never@304 1174 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), method);
never@304 1175 __ movptr(method, STATE(_method));
never@304 1176 __ verify_oop(method);
never@304 1177 __ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
never@304 1178 __ bind(L);
never@304 1179 }
duke@0 1180
duke@0 1181 // pass mirror handle if static call
duke@0 1182 { Label L;
duke@0 1183 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();
duke@0 1184 __ movl(t, Address(method, methodOopDesc::access_flags_offset()));
duke@0 1185 __ testl(t, JVM_ACC_STATIC);
duke@0 1186 __ jcc(Assembler::zero, L);
duke@0 1187 // get mirror
never@304 1188 __ movptr(t, Address(method, methodOopDesc:: constants_offset()));
never@304 1189 __ movptr(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes()));
never@304 1190 __ movptr(t, Address(t, mirror_offset));
duke@0 1191 // copy mirror into activation object
never@304 1192 __ movptr(STATE(_oop_temp), t);
duke@0 1193 // pass handle to mirror
never@304 1194 #ifdef _LP64
never@304 1195 __ lea(c_rarg1, STATE(_oop_temp));
never@304 1196 #else
never@304 1197 __ lea(t, STATE(_oop_temp));
never@304 1198 __ movptr(Address(rsp, wordSize), t);
never@304 1199 #endif // _LP64
duke@0 1200 __ bind(L);
duke@0 1201 }
duke@0 1202 #ifdef ASSERT
duke@0 1203 {
duke@0 1204 Label L;
never@304 1205 __ push(t);
duke@0 1206 __ get_thread(t); // get vm's javathread*
never@304 1207 __ cmpptr(t, STATE(_thread));
duke@0 1208 __ jcc(Assembler::equal, L);
duke@0 1209 __ int3();
duke@0 1210 __ bind(L);
never@304 1211 __ pop(t);
duke@0 1212 }
duke@0 1213 #endif //
duke@0 1214
duke@0 1215 // pass JNIEnv
never@304 1216 #ifdef _LP64
never@304 1217 __ lea(c_rarg0, Address(thread, JavaThread::jni_environment_offset()));
never@304 1218 #else
never@304 1219 __ movptr(thread, STATE(_thread)); // get thread
never@304 1220 __ lea(t, Address(thread, JavaThread::jni_environment_offset()));
never@304 1221
never@304 1222 __ movptr(Address(rsp, 0), t);
never@304 1223 #endif // _LP64
never@304 1224
duke@0 1225 #ifdef ASSERT
duke@0 1226 {
duke@0 1227 Label L;
never@304 1228 __ push(t);
duke@0 1229 __ get_thread(t); // get vm's javathread*
never@304 1230 __ cmpptr(t, STATE(_thread));
duke@0 1231 __ jcc(Assembler::equal, L);
duke@0 1232 __ int3();
duke@0 1233 __ bind(L);
never@304 1234 __ pop(t);
duke@0 1235 }
duke@0 1236 #endif //
duke@0 1237
duke@0 1238 #ifdef ASSERT
duke@0 1239 { Label L;
duke@0 1240 __ movl(t, Address(thread, JavaThread::thread_state_offset()));
duke@0 1241 __ cmpl(t, _thread_in_Java);
duke@0 1242 __ jcc(Assembler::equal, L);
duke@0 1243 __ stop("Wrong thread state in native stub");
duke@0 1244 __ bind(L);
duke@0 1245 }
duke@0 1246 #endif
duke@0 1247
duke@0 1248 // Change state to native (we save the return address in the thread, since it might not
duke@0 1249 // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
duke@0 1250 // points into the right code segment. It does not have to be the correct return pc.
duke@0 1251
duke@0 1252 __ set_last_Java_frame(thread, noreg, rbp, __ pc());
duke@0 1253
duke@0 1254 __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_native);
duke@0 1255
duke@0 1256 __ call(rax);
duke@0 1257
duke@0 1258 // result potentially in rdx:rax or ST0
never@304 1259 __ movptr(method, STATE(_method));
never@304 1260 NOT_LP64(__ movptr(thread, STATE(_thread));) // get thread
duke@0 1261
duke@0 1262 // The potential result is in ST(0) & rdx:rax
duke@0 1263 // With C++ interpreter we leave any possible result in ST(0) until we are in result handler and then
duke@0 1264 // we do the appropriate stuff for returning the result. rdx:rax must always be saved because just about
duke@0 1265 // anything we do here will destroy it, st(0) is only saved if we re-enter the vm where it would
duke@0 1266 // be destroyed.
duke@0 1267 // It is safe to do these pushes because state is _thread_in_native and return address will be found
duke@0 1268 // via _last_native_pc and not via _last_jave_sp
duke@0 1269
never@304 1270 // Must save the value of ST(0)/xmm0 since it could be destroyed before we get to result handler
duke@0 1271 { Label Lpush, Lskip;
duke@0 1272 ExternalAddress float_handler(AbstractInterpreter::result_handler(T_FLOAT));
duke@0 1273 ExternalAddress double_handler(AbstractInterpreter::result_handler(T_DOUBLE));
duke@0 1274 __ cmpptr(STATE(_result_handler), float_handler.addr());
duke@0 1275 __ jcc(Assembler::equal, Lpush);
duke@0 1276 __ cmpptr(STATE(_result_handler), double_handler.addr());
duke@0 1277 __ jcc(Assembler::notEqual, Lskip);
duke@0 1278 __ bind(Lpush);
never@304 1279 __ subptr(rsp, 2*wordSize);
never@304 1280 if ( UseSSE < 2 ) {
never@304 1281 __ fstp_d(Address(rsp, 0));
never@304 1282 } else {
never@304 1283 __ movdbl(Address(rsp, 0), xmm0);
never@304 1284 }
duke@0 1285 __ bind(Lskip);
duke@0 1286 }
duke@0 1287
never@304 1288 // save rax:rdx for potential use by result handler.
never@304 1289 __ push(rax);
never@304 1290 #ifndef _LP64
never@304 1291 __ push(rdx);
never@304 1292 #endif // _LP64
duke@0 1293
duke@0 1294 // Either restore the MXCSR register after returning from the JNI Call
duke@0 1295 // or verify that it wasn't changed.
duke@0 1296 if (VM_Version::supports_sse()) {
duke@0 1297 if (RestoreMXCSROnJNICalls) {
duke@0 1298 __ ldmxcsr(ExternalAddress(StubRoutines::addr_mxcsr_std()));
duke@0 1299 }
duke@0 1300 else if (CheckJNICalls ) {
never@304 1301 __ call(RuntimeAddress(StubRoutines::x86::verify_mxcsr_entry()));
duke@0 1302 }
duke@0 1303 }
duke@0 1304
never@304 1305 #ifndef _LP64
duke@0 1306 // Either restore the x87 floating pointer control word after returning
duke@0 1307 // from the JNI call or verify that it wasn't changed.
duke@0 1308 if (CheckJNICalls) {
never@304 1309 __ call(RuntimeAddress(StubRoutines::x86::verify_fpu_cntrl_wrd_entry()));
duke@0 1310 }
never@304 1311 #endif // _LP64
duke@0 1312
duke@0 1313
duke@0 1314 // change thread state
duke@0 1315 __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
duke@0 1316 if(os::is_MP()) {
duke@0 1317 // Write serialization page so VM thread can do a pseudo remote membar.
duke@0 1318 // We use the current thread pointer to calculate a thread specific
duke@0 1319 // offset to write to within the page. This minimizes bus traffic
duke@0 1320 // due to cache line collision.
duke@0 1321 __ serialize_memory(thread, rcx);
duke@0 1322 }
duke@0 1323
duke@0 1324 // check for safepoint operation in progress and/or pending suspend requests
duke@0 1325 { Label Continue;
duke@0 1326
duke@0 1327 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
duke@0 1328 SafepointSynchronize::_not_synchronized);
duke@0 1329
duke@0 1330 // threads running native code and they are expected to self-suspend
duke@0 1331 // when leaving the _thread_in_native state. We need to check for
duke@0 1332 // pending suspend requests here.
duke@0 1333 Label L;
duke@0 1334 __ jcc(Assembler::notEqual, L);
duke@0 1335 __ cmpl(Address(thread, JavaThread::suspend_flags_offset()), 0);
duke@0 1336 __ jcc(Assembler::equal, Continue);
duke@0 1337 __ bind(L);
duke@0 1338
duke@0 1339 // Don't use call_VM as it will see a possible pending exception and forward it
duke@0 1340 // and never return here preventing us from clearing _last_native_pc down below.
duke@0 1341 // Also can't use call_VM_leaf either as it will check to see if rsi & rdi are
never@304 1342 // preserved and correspond to the bcp/locals pointers.
duke@0 1343 //
never@304 1344
never@304 1345 ((MacroAssembler*)_masm)->call_VM_leaf(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans),
never@304 1346 thread);
duke@0 1347 __ increment(rsp, wordSize);
duke@0 1348
never@304 1349 __ movptr(method, STATE(_method));
duke@0 1350 __ verify_oop(method);
never@304 1351 __ movptr(thread, STATE(_thread)); // get thread
duke@0 1352
duke@0 1353 __ bind(Continue);
duke@0 1354 }
duke@0 1355
duke@0 1356 // change thread state
duke@0 1357 __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_Java);
duke@0 1358
duke@0 1359 __ reset_last_Java_frame(thread, true, true);
duke@0 1360
duke@0 1361 // reset handle block
never@304 1362 __ movptr(t, Address(thread, JavaThread::active_handles_offset()));
never@304 1363 __ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
duke@0 1364
duke@0 1365 // If result was an oop then unbox and save it in the frame
duke@0 1366 { Label L;
duke@0 1367 Label no_oop, store_result;
duke@0 1368 ExternalAddress oop_handler(AbstractInterpreter::result_handler(T_OBJECT));
duke@0 1369 __ cmpptr(STATE(_result_handler), oop_handler.addr());
duke@0 1370 __ jcc(Assembler::notEqual, no_oop);
never@304 1371 #ifndef _LP64
never@304 1372 __ pop(rdx);
never@304 1373 #endif // _LP64
never@304 1374 __ pop(rax);
never@304 1375 __ testptr(rax, rax);
duke@0 1376 __ jcc(Assembler::zero, store_result);
duke@0 1377 // unbox
never@304 1378 __ movptr(rax, Address(rax, 0));
duke@0 1379 __ bind(store_result);
never@304 1380 __ movptr(STATE(_oop_temp), rax);
duke@0 1381 // keep stack depth as expected by pushing oop which will eventually be discarded
never@304 1382 __ push(rax);
never@304 1383 #ifndef _LP64
never@304 1384 __ push(rdx);
never@304 1385 #endif // _LP64
duke@0 1386 __ bind(no_oop);
duke@0 1387 }
duke@0 1388
duke@0 1389 {
duke@0 1390 Label no_reguard;
duke@0 1391 __ cmpl(Address(thread, JavaThread::stack_guard_state_offset()), JavaThread::stack_guard_yellow_disabled);
duke@0 1392 __ jcc(Assembler::notEqual, no_reguard);
duke@0 1393
never@304 1394 __ pusha();
duke@0 1395 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages)));
never@304 1396 __ popa();
duke@0 1397
duke@0 1398 __ bind(no_reguard);
duke@0 1399 }
duke@0 1400
duke@0 1401
duke@0 1402 // QQQ Seems like for native methods we simply return and the caller will see the pending
duke@0 1403 // exception and do the right thing. Certainly the interpreter will, don't know about
duke@0 1404 // compiled methods.
duke@0 1405 // Seems that the answer to above is no this is wrong. The old code would see the exception
duke@0 1406 // and forward it before doing the unlocking and notifying jvmdi that method has exited.
duke@0 1407 // This seems wrong need to investigate the spec.
duke@0 1408
duke@0 1409 // handle exceptions (exception handling will handle unlocking!)
duke@0 1410 { Label L;
never@304 1411 __ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
duke@0 1412 __ jcc(Assembler::zero, L);
duke@0 1413 __ bind(pending_exception_present);
duke@0 1414
duke@0 1415 // There are potential results on the stack (rax/rdx, ST(0)) we ignore these and simply
duke@0 1416 // return and let caller deal with exception. This skips the unlocking here which
duke@0 1417 // seems wrong but seems to be what asm interpreter did. Can't find this in the spec.
duke@0 1418 // Note: must preverve method in rbx
duke@0 1419 //
duke@0 1420
duke@0 1421 // remove activation
duke@0 1422
never@304 1423 __ movptr(t, STATE(_sender_sp));
duke@0 1424 __ leave(); // remove frame anchor
never@304 1425 __ pop(rdi); // get return address
never@304 1426 __ movptr(state, STATE(_prev_link)); // get previous state for return
never@304 1427 __ mov(rsp, t); // set sp to sender sp
never@304 1428 __ push(rdi); // push throwing pc
duke@0 1429 // The skips unlocking!! This seems to be what asm interpreter does but seems
duke@0 1430 // very wrong. Not clear if this violates the spec.
duke@0 1431 __ jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
duke@0 1432 __ bind(L);
duke@0 1433 }
duke@0 1434
duke@0 1435 // do unlocking if necessary
duke@0 1436 { Label L;
duke@0 1437 __ movl(t, Address(method, methodOopDesc::access_flags_offset()));
duke@0 1438 __ testl(t, JVM_ACC_SYNCHRONIZED);
duke@0 1439 __ jcc(Assembler::zero, L);
duke@0 1440 // the code below should be shared with interpreter macro assembler implementation
duke@0 1441 { Label unlock;
never@304 1442 const Register monitor = NOT_LP64(rdx) LP64_ONLY(c_rarg1);
duke@0 1443 // BasicObjectLock will be first in list, since this is a synchronized method. However, need
duke@0 1444 // to check that the object has not been unlocked by an explicit monitorexit bytecode.
never@304 1445 __ movptr(monitor, STATE(_monitor_base));
never@304 1446 __ subptr(monitor, frame::interpreter_frame_monitor_size() * wordSize); // address of initial monitor
never@304 1447
never@304 1448 __ movptr(t, Address(monitor, BasicObjectLock::obj_offset_in_bytes()));
never@304 1449 __ testptr(t, t);
duke@0 1450 __ jcc(Assembler::notZero, unlock);
duke@0 1451
duke@0 1452 // Entry already unlocked, need to throw exception
duke@0 1453 __ MacroAssembler::call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_illegal_monitor_state_exception));
duke@0 1454 __ should_not_reach_here();
duke@0 1455
duke@0 1456 __ bind(unlock);
never@304 1457 __ unlock_object(monitor);
duke@0 1458 // unlock can blow rbx so restore it for path that needs it below
never@304 1459 __ movptr(method, STATE(_method));
duke@0 1460 }
duke@0 1461 __ bind(L);
duke@0 1462 }
duke@0 1463
duke@0 1464 // jvmti support
duke@0 1465 // Note: This must happen _after_ handling/throwing any exceptions since
duke@0 1466 // the exception handler code notifies the runtime of method exits
duke@0 1467 // too. If this happens before, method entry/exit notifications are
duke@0 1468 // not properly paired (was bug - gri 11/22/99).
duke@0 1469 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI);
duke@0 1470
duke@0 1471 // restore potential result in rdx:rax, call result handler to restore potential result in ST0 & handle result
never@304 1472 #ifndef _LP64
never@304 1473 __ pop(rdx);
never@304 1474 #endif // _LP64
never@304 1475 __ pop(rax);
never@304 1476 __ movptr(t, STATE(_result_handler)); // get result handler
duke@0 1477 __ call(t); // call result handler to convert to tosca form
duke@0 1478
duke@0 1479 // remove activation
duke@0 1480
never@304 1481 __ movptr(t, STATE(_sender_sp));
duke@0 1482
duke@0 1483 __ leave(); // remove frame anchor
never@304 1484 __ pop(rdi); // get return address
never@304 1485 __ movptr(state, STATE(_prev_link)); // get previous state for return (if c++ interpreter was caller)
never@304 1486 __ mov(rsp, t); // set sp to sender sp
duke@0 1487 __ jmp(rdi);
duke@0 1488
duke@0 1489 // invocation counter overflow
duke@0 1490 if (inc_counter) {
duke@0 1491 // Handle overflow of counter and compile method
duke@0 1492 __ bind(invocation_counter_overflow);
duke@0 1493 generate_counter_overflow(&continue_after_compile);
duke@0 1494 }
duke@0 1495
duke@0 1496 return entry_point;
duke@0 1497 }
duke@0 1498
duke@0 1499 // Generate entries that will put a result type index into rcx
duke@0 1500 void CppInterpreterGenerator::generate_deopt_handling() {
duke@0 1501
duke@0 1502 Label return_from_deopt_common;
duke@0 1503
duke@0 1504 // Generate entries that will put a result type index into rcx
duke@0 1505 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1506 deopt_frame_manager_return_atos = __ pc();
duke@0 1507
duke@0 1508 // rax is live here
duke@0 1509 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_OBJECT)); // Result stub address array index
duke@0 1510 __ jmp(return_from_deopt_common);
duke@0 1511
duke@0 1512
duke@0 1513 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1514 deopt_frame_manager_return_btos = __ pc();
duke@0 1515
duke@0 1516 // rax is live here
duke@0 1517 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_BOOLEAN)); // Result stub address array index
duke@0 1518 __ jmp(return_from_deopt_common);
duke@0 1519
duke@0 1520 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1521 deopt_frame_manager_return_itos = __ pc();
duke@0 1522
duke@0 1523 // rax is live here
duke@0 1524 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_INT)); // Result stub address array index
duke@0 1525 __ jmp(return_from_deopt_common);
duke@0 1526
duke@0 1527 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1528
duke@0 1529 deopt_frame_manager_return_ltos = __ pc();
duke@0 1530 // rax,rdx are live here
duke@0 1531 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_LONG)); // Result stub address array index
duke@0 1532 __ jmp(return_from_deopt_common);
duke@0 1533
duke@0 1534 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1535
duke@0 1536 deopt_frame_manager_return_ftos = __ pc();
duke@0 1537 // st(0) is live here
duke@0 1538 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_FLOAT)); // Result stub address array index
duke@0 1539 __ jmp(return_from_deopt_common);
duke@0 1540
duke@0 1541 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1542 deopt_frame_manager_return_dtos = __ pc();
duke@0 1543
duke@0 1544 // st(0) is live here
duke@0 1545 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_DOUBLE)); // Result stub address array index
duke@0 1546 __ jmp(return_from_deopt_common);
duke@0 1547
duke@0 1548 // deopt needs to jump to here to enter the interpreter (return a result)
duke@0 1549 deopt_frame_manager_return_vtos = __ pc();
duke@0 1550
duke@0 1551 __ movl(rcx, AbstractInterpreter::BasicType_as_index(T_VOID));
duke@0 1552
duke@0 1553 // Deopt return common
duke@0 1554 // an index is present in rcx that lets us move any possible result being
duke@0 1555 // return to the interpreter's stack
duke@0 1556 //
duke@0 1557 // Because we have a full sized interpreter frame on the youngest
duke@0 1558 // activation the stack is pushed too deep to share the tosca to
duke@0 1559 // stack converters directly. We shrink the stack to the desired
duke@0 1560 // amount and then push result and then re-extend the stack.
duke@0 1561 // We could have the code in size_activation layout a short
duke@0 1562 // frame for the top activation but that would look different
duke@0 1563 // than say sparc (which needs a full size activation because
duke@0 1564 // the windows are in the way. Really it could be short? QQQ
duke@0 1565 //
duke@0 1566 __ bind(return_from_deopt_common);
duke@0 1567
never@304 1568 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));
duke@0 1569
duke@0 1570 // setup rsp so we can push the "result" as needed.
never@304 1571 __ movptr(rsp, STATE(_stack)); // trim stack (is prepushed)
never@304 1572 __ addptr(rsp, wordSize); // undo prepush
duke@0 1573
duke@0 1574 ExternalAddress tosca_to_stack((address)CppInterpreter::_tosca_to_stack);
never@304 1575 // Address index(noreg, rcx, Address::times_ptr);
never@304 1576 __ movptr(rcx, ArrayAddress(tosca_to_stack, Address(noreg, rcx, Address::times_ptr)));
never@304 1577 // __ movl(rcx, Address(noreg, rcx, Address::times_ptr, int(AbstractInterpreter::_tosca_to_stack)));
duke@0 1578 __ call(rcx); // call result converter
duke@0 1579
duke@0 1580 __ movl(STATE(_msg), (int)BytecodeInterpreter::deopt_resume);
never@304 1581 __ lea(rsp, Address(rsp, -wordSize)); // prepush stack (result if any already present)
never@304 1582 __ movptr(STATE(_stack), rsp); // inform interpreter of new stack depth (parameters removed,
duke@0 1583 // result if any on stack already )
never@304 1584 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
duke@0 1585 }
duke@0 1586
duke@0 1587 // Generate the code to handle a more_monitors message from the c++ interpreter
duke@0 1588 void CppInterpreterGenerator::generate_more_monitors() {
duke@0 1589
duke@0 1590
duke@0 1591 Label entry, loop;
duke@0 1592 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
never@304 1593 // 1. compute new pointers // rsp: old expression stack top
never@304 1594 __ movptr(rdx, STATE(_stack_base)); // rdx: old expression stack bottom
never@304 1595 __ subptr(rsp, entry_size); // move expression stack top limit
never@304 1596 __ subptr(STATE(_stack), entry_size); // update interpreter stack top
never@304 1597 __ subptr(STATE(_stack_limit), entry_size); // inform interpreter
never@304 1598 __ subptr(rdx, entry_size); // move expression stack bottom
never@304 1599 __ movptr(STATE(_stack_base), rdx); // inform interpreter
never@304 1600 __ movptr(rcx, STATE(_stack)); // set start value for copy loop
duke@0 1601 __ jmp(entry);
duke@0 1602 // 2. move expression stack contents
duke@0 1603 __ bind(loop);
never@304 1604 __ movptr(rbx, Address(rcx, entry_size)); // load expression stack word from old location
never@304 1605 __ movptr(Address(rcx, 0), rbx); // and store it at new location
never@304 1606 __ addptr(rcx, wordSize); // advance to next word
duke@0 1607 __ bind(entry);
never@304 1608 __ cmpptr(rcx, rdx); // check if bottom reached
never@304 1609 __ jcc(Assembler::notEqual, loop); // if not at bottom then copy next word
duke@0 1610 // now zero the slot so we can find it.
never@304 1611 __ movptr(Address(rdx, BasicObjectLock::obj_offset_in_bytes()), (int32_t) NULL_WORD);
duke@0 1612 __ movl(STATE(_msg), (int)BytecodeInterpreter::got_monitors);
duke@0 1613 }
duke@0 1614
duke@0 1615
duke@0 1616 // Initial entry to C++ interpreter from the call_stub.
duke@0 1617 // This entry point is called the frame manager since it handles the generation
duke@0 1618 // of interpreter activation frames via requests directly from the vm (via call_stub)
duke@0 1619 // and via requests from the interpreter. The requests from the call_stub happen
duke@0 1620 // directly thru the entry point. Requests from the interpreter happen via returning
duke@0 1621 // from the interpreter and examining the message the interpreter has returned to
duke@0 1622 // the frame manager. The frame manager can take the following requests:
duke@0 1623
duke@0 1624 // NO_REQUEST - error, should never happen.
duke@0 1625 // MORE_MONITORS - need a new monitor. Shuffle the expression stack on down and
duke@0 1626 // allocate a new monitor.
duke@0 1627 // CALL_METHOD - setup a new activation to call a new method. Very similar to what
duke@0 1628 // happens during entry during the entry via the call stub.
duke@0 1629 // RETURN_FROM_METHOD - remove an activation. Return to interpreter or call stub.
duke@0 1630 //
duke@0 1631 // Arguments:
duke@0 1632 //
duke@0 1633 // rbx: methodOop
duke@0 1634 // rcx: receiver - unused (retrieved from stack as needed)
never@304 1635 // rsi/r13: previous frame manager state (NULL from the call_stub/c1/c2)
duke@0 1636 //
duke@0 1637 //
duke@0 1638 // Stack layout at entry
duke@0 1639 //
duke@0 1640 // [ return address ] <--- rsp
duke@0 1641 // [ parameter n ]
duke@0 1642 // ...
duke@0 1643 // [ parameter 1 ]
duke@0 1644 // [ expression stack ]
duke@0 1645 //
duke@0 1646 //
duke@0 1647 // We are free to blow any registers we like because the call_stub which brought us here
duke@0 1648 // initially has preserved the callee save registers already.
duke@0 1649 //
duke@0 1650 //
duke@0 1651
duke@0 1652 static address interpreter_frame_manager = NULL;
duke@0 1653
duke@0 1654 address InterpreterGenerator::generate_normal_entry(bool synchronized) {
duke@0 1655
duke@0 1656 // rbx: methodOop
never@304 1657 // rsi/r13: sender sp
duke@0 1658
duke@0 1659 // Because we redispatch "recursive" interpreter entries thru this same entry point
duke@0 1660 // the "input" register usage is a little strange and not what you expect coming
duke@0 1661 // from the call_stub. From the call stub rsi/rdi (current/previous) interpreter
duke@0 1662 // state are NULL but on "recursive" dispatches they are what you'd expect.
duke@0 1663 // rsi: current interpreter state (C++ interpreter) must preserve (null from call_stub/c1/c2)
duke@0 1664
duke@0 1665
duke@0 1666 // A single frame manager is plenty as we don't specialize for synchronized. We could and
duke@0 1667 // the code is pretty much ready. Would need to change the test below and for good measure
duke@0 1668 // modify generate_interpreter_state to only do the (pre) sync stuff stuff for synchronized
duke@0 1669 // routines. Not clear this is worth it yet.
duke@0 1670
duke@0 1671 if (interpreter_frame_manager) return interpreter_frame_manager;
duke@0 1672
duke@0 1673 address entry_point = __ pc();
duke@0 1674
duke@0 1675 // Fast accessor methods share this entry point.
duke@0 1676 // This works because frame manager is in the same codelet
duke@0 1677 if (UseFastAccessorMethods && !synchronized) __ bind(fast_accessor_slow_entry_path);
duke@0 1678
duke@0 1679 Label dispatch_entry_2;
never@304 1680 __ movptr(rcx, sender_sp_on_entry);
never@304 1681 __ movptr(state, (int32_t)NULL_WORD); // no current activation
duke@0 1682
duke@0 1683 __ jmp(dispatch_entry_2);
duke@0 1684
duke@0 1685 const Register locals = rdi;
duke@0 1686
duke@0 1687 Label re_dispatch;
duke@0 1688
duke@0 1689 __ bind(re_dispatch);
duke@0 1690
duke@0 1691 // save sender sp (doesn't include return address
never@304 1692 __ lea(rcx, Address(rsp, wordSize));
duke@0 1693
duke@0 1694 __ bind(dispatch_entry_2);
duke@0 1695
duke@0 1696 // save sender sp
never@304 1697 __ push(rcx);
duke@0 1698
duke@0 1699 const Address size_of_parameters(rbx, methodOopDesc::size_of_parameters_offset());
duke@0 1700 const Address size_of_locals (rbx, methodOopDesc::size_of_locals_offset());
duke@0 1701 const Address access_flags (rbx, methodOopDesc::access_flags_offset());
duke@0 1702
duke@0 1703 // const Address monitor_block_top (rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
duke@0 1704 // const Address monitor_block_bot (rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
duke@0 1705 // const Address monitor(rbp, frame::interpreter_frame_initial_sp_offset * wordSize - (int)sizeof(BasicObjectLock));
duke@0 1706
duke@0 1707 // get parameter size (always needed)
jrose@622 1708 __ load_unsigned_short(rcx, size_of_parameters);
duke@0 1709
duke@0 1710 // rbx: methodOop
duke@0 1711 // rcx: size of parameters
jrose@622 1712 __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words
duke@0 1713
never@304 1714 __ subptr(rdx, rcx); // rdx = no. of additional locals
duke@0 1715
duke@0 1716 // see if we've got enough room on the stack for locals plus overhead.
duke@0 1717 generate_stack_overflow_check(); // C++
duke@0 1718
duke@0 1719 // c++ interpreter does not use stack banging or any implicit exceptions
duke@0 1720 // leave for now to verify that check is proper.
duke@0 1721 bang_stack_shadow_pages(false);
duke@0 1722
duke@0 1723
duke@0 1724
duke@0 1725 // compute beginning of parameters (rdi)
never@304 1726 __ lea(locals, Address(rsp, rcx, Address::times_ptr, wordSize));
duke@0 1727
duke@0 1728 // save sender's sp
duke@0 1729 // __ movl(rcx, rsp);
duke@0 1730
duke@0 1731 // get sender's sp
never@304 1732 __ pop(rcx);
duke@0 1733
duke@0 1734 // get return address
never@304 1735 __ pop(rax);
duke@0 1736
duke@0 1737 // rdx - # of additional locals
duke@0 1738 // allocate space for locals
duke@0 1739 // explicitly initialize locals
duke@0 1740 {
duke@0 1741 Label exit, loop;
never@304 1742 __ testl(rdx, rdx); // (32bit ok)
duke@0 1743 __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0
duke@0 1744 __ bind(loop);
never@304 1745 __ push((int32_t)NULL_WORD); // initialize local variables
duke@0 1746 __ decrement(rdx); // until everything initialized
duke@0 1747 __ jcc(Assembler::greater, loop);
duke@0 1748 __ bind(exit);
duke@0 1749 }
duke@0 1750
duke@0 1751
duke@0 1752 // Assumes rax = return address
duke@0 1753
duke@0 1754 // allocate and initialize new interpreterState and method expression stack
duke@0 1755 // IN(locals) -> locals
duke@0 1756 // IN(state) -> any current interpreter activation
duke@0 1757 // destroys rax, rcx, rdx, rdi
duke@0 1758 // OUT (state) -> new interpreterState
duke@0 1759 // OUT(rsp) -> bottom of methods expression stack
duke@0 1760
duke@0 1761 generate_compute_interpreter_state(state, locals, rcx, false);
duke@0 1762
duke@0 1763 // Call interpreter
duke@0 1764
duke@0 1765 Label call_interpreter;
duke@0 1766 __ bind(call_interpreter);
duke@0 1767
duke@0 1768 // c++ interpreter does not use stack banging or any implicit exceptions
duke@0 1769 // leave for now to verify that check is proper.
duke@0 1770 bang_stack_shadow_pages(false);
duke@0 1771
duke@0 1772
duke@0 1773 // Call interpreter enter here if message is
duke@0 1774 // set and we know stack size is valid
duke@0 1775
duke@0 1776 Label call_interpreter_2;
duke@0 1777
duke@0 1778 __ bind(call_interpreter_2);
duke@0 1779
duke@0 1780 {
never@304 1781 const Register thread = NOT_LP64(rcx) LP64_ONLY(r15_thread);
never@304 1782
never@304 1783 #ifdef _LP64
never@304 1784 __ mov(c_rarg0, state);
never@304 1785 #else
never@304 1786 __ push(state); // push arg to interpreter
never@304 1787 __ movptr(thread, STATE(_thread));
never@304 1788 #endif // _LP64
duke@0 1789
duke@0 1790 // We can setup the frame anchor with everything we want at this point
duke@0 1791 // as we are thread_in_Java and no safepoints can occur until we go to
duke@0 1792 // vm mode. We do have to clear flags on return from vm but that is it
duke@0 1793 //
never@304 1794 __ movptr(Address(thread, JavaThread::last_Java_fp_offset()), rbp);
never@304 1795 __ movptr(Address(thread, JavaThread::last_Java_sp_offset()), rsp);
duke@0 1796
duke@0 1797 // Call the interpreter
duke@0 1798
duke@0 1799 RuntimeAddress normal(CAST_FROM_FN_PTR(address, BytecodeInterpreter::run));
duke@0 1800 RuntimeAddress checking(CAST_FROM_FN_PTR(address, BytecodeInterpreter::runWithChecks));
duke@0 1801
duke@0 1802 __ call(JvmtiExport::can_post_interpreter_events() ? checking : normal);
never@304 1803 NOT_LP64(__ pop(rax);) // discard parameter to run
duke@0 1804 //
duke@0 1805 // state is preserved since it is callee saved
duke@0 1806 //
duke@0 1807
duke@0 1808 // reset_last_Java_frame
duke@0 1809
never@304 1810 NOT_LP64(__ movl(thread, STATE(_thread));)
duke@0 1811 __ reset_last_Java_frame(thread, true, true);
duke@0 1812 }
duke@0 1813
duke@0 1814 // examine msg from interpreter to determine next action
duke@0 1815
duke@0 1816 __ movl(rdx, STATE(_msg)); // Get new message
duke@0 1817
duke@0 1818 Label call_method;
duke@0 1819 Label return_from_interpreted_method;
duke@0 1820 Label throw_exception;
duke@0 1821 Label bad_msg;
duke@0 1822 Label do_OSR;
duke@0 1823
never@304 1824 __ cmpl(rdx, (int32_t)BytecodeInterpreter::call_method);
duke@0 1825 __ jcc(Assembler::equal, call_method);
never@304 1826 __ cmpl(rdx, (int32_t)BytecodeInterpreter::return_from_method);
duke@0 1827 __ jcc(Assembler::equal, return_from_interpreted_method);
never@304 1828 __ cmpl(rdx, (int32_t)BytecodeInterpreter::do_osr);
duke@0 1829 __ jcc(Assembler::equal, do_OSR);
never@304 1830 __ cmpl(rdx, (int32_t)BytecodeInterpreter::throwing_exception);
duke@0 1831 __ jcc(Assembler::equal, throw_exception);
never@304 1832 __ cmpl(rdx, (int32_t)BytecodeInterpreter::more_monitors);
duke@0 1833 __ jcc(Assembler::notEqual, bad_msg);
duke@0 1834
duke@0 1835 // Allocate more monitor space, shuffle expression stack....
duke@0 1836
duke@0 1837 generate_more_monitors();
duke@0 1838
duke@0 1839 __ jmp(call_interpreter);
duke@0 1840
duke@0 1841 // uncommon trap needs to jump to here to enter the interpreter (re-execute current bytecode)
duke@0 1842 unctrap_frame_manager_entry = __ pc();
duke@0 1843 //
duke@0 1844 // Load the registers we need.
never@304 1845 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));
never@304 1846 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
duke@0 1847 __ jmp(call_interpreter_2);
duke@0 1848
duke@0 1849
duke@0 1850
duke@0 1851 //=============================================================================
duke@0 1852 // Returning from a compiled method into a deopted method. The bytecode at the
duke@0 1853 // bcp has completed. The result of the bytecode is in the native abi (the tosca
duke@0 1854 // for the template based interpreter). Any stack space that was used by the
duke@0 1855 // bytecode that has completed has been removed (e.g. parameters for an invoke)
duke@0 1856 // so all that we have to do is place any pending result on the expression stack
duke@0 1857 // and resume execution on the next bytecode.
duke@0 1858
duke@0 1859
duke@0 1860 generate_deopt_handling();
duke@0 1861 __ jmp(call_interpreter);
duke@0 1862
duke@0 1863
duke@0 1864 // Current frame has caught an exception we need to dispatch to the
duke@0 1865 // handler. We can get here because a native interpreter frame caught
duke@0 1866 // an exception in which case there is no handler and we must rethrow
duke@0 1867 // If it is a vanilla interpreted frame the we simply drop into the
duke@0 1868 // interpreter and let it do the lookup.
duke@0 1869
duke@0 1870 Interpreter::_rethrow_exception_entry = __ pc();
duke@0 1871 // rax: exception
duke@0 1872 // rdx: return address/pc that threw exception
duke@0 1873
duke@0 1874 Label return_with_exception;
duke@0 1875 Label unwind_and_forward;
duke@0 1876
duke@0 1877 // restore state pointer.
coleenp@520 1878 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));
never@304 1879
never@304 1880 __ movptr(rbx, STATE(_method)); // get method
never@304 1881 #ifdef _LP64
never@304 1882 __ movptr(Address(r15_thread, Thread::pending_exception_offset()), rax);
never@304 1883 #else
duke@0 1884 __ movl(rcx, STATE(_thread)); // get thread
duke@0 1885
duke@0 1886 // Store exception with interpreter will expect it
never@304 1887 __ movptr(Address(rcx, Thread::pending_exception_offset()), rax);
never@304 1888 #endif // _LP64
duke@0 1889
duke@0 1890 // is current frame vanilla or native?
duke@0 1891
duke@0 1892 __ movl(rdx, access_flags);
duke@0 1893 __ testl(rdx, JVM_ACC_NATIVE);
duke@0 1894 __ jcc(Assembler::zero, return_with_exception); // vanilla interpreted frame, handle directly
duke@0 1895
duke@0 1896 // We drop thru to unwind a native interpreted frame with a pending exception
duke@0 1897 // We jump here for the initial interpreter frame with exception pending
duke@0 1898 // We unwind the current acivation and forward it to our caller.
duke@0 1899
duke@0 1900 __ bind(unwind_and_forward);
duke@0 1901
duke@0 1902 // unwind rbp, return stack to unextended value and re-push return address
duke@0 1903
never@304 1904 __ movptr(rcx, STATE(_sender_sp));
duke@0 1905 __ leave();
never@304 1906 __ pop(rdx);
never@304 1907 __ mov(rsp, rcx);
never@304 1908 __ push(rdx);
duke@0 1909 __ jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
duke@0 1910
duke@0 1911 // Return point from a call which returns a result in the native abi
duke@0 1912 // (c1/c2/jni-native). This result must be processed onto the java
duke@0 1913 // expression stack.
duke@0 1914 //
duke@0 1915 // A pending exception may be present in which case there is no result present
duke@0 1916
duke@0 1917 Label resume_interpreter;
duke@0 1918 Label do_float;
duke@0 1919 Label do_double;
duke@0 1920 Label done_conv;
duke@0 1921
duke@0 1922 // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases
duke@0 1923 if (UseSSE < 2) {
coleenp@520 1924 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));
never@304 1925 __ movptr(rbx, STATE(_result._to_call._callee)); // get method just executed
duke@0 1926 __ movl(rcx, Address(rbx, methodOopDesc::result_index_offset()));
duke@0 1927 __ cmpl(rcx, AbstractInterpreter::BasicType_as_index(T_FLOAT)); // Result stub address array index
duke@0 1928 __ jcc(Assembler::equal, do_float);
duke@0 1929 __ cmpl(rcx, AbstractInterpreter::BasicType_as_index(T_DOUBLE)); // Result stub address array index
duke@0 1930 __ jcc(Assembler::equal, do_double);
coleenp@520 1931 #if !defined(_LP64) || defined(COMPILER1) || !defined(COMPILER2)
duke@0 1932 __ empty_FPU_stack();
duke@0 1933 #endif // COMPILER2
duke@0 1934 __ jmp(done_conv);
duke@0 1935
duke@0 1936 __ bind(do_float);
duke@0 1937 #ifdef COMPILER2
duke@0 1938 for (int i = 1; i < 8; i++) {
duke@0 1939 __ ffree(i);
duke@0 1940 }
duke@0 1941 #endif // COMPILER2
duke@0 1942 __ jmp(done_conv);
duke@0 1943 __ bind(do_double);
duke@0 1944 #ifdef COMPILER2
duke@0 1945 for (int i = 1; i < 8; i++) {
duke@0 1946 __ ffree(i);
duke@0 1947 }
duke@0 1948 #endif // COMPILER2
duke@0 1949 __ jmp(done_conv);
duke@0 1950 } else {
duke@0 1951 __ MacroAssembler::verify_FPU(0, "generate_return_entry_for compiled");
duke@0 1952 __ jmp(done_conv);
duke@0 1953 }
duke@0 1954
duke@0 1955 // Return point to interpreter from compiled/native method
duke@0 1956 InternalAddress return_from_native_method(__ pc());
duke@0 1957
duke@0 1958 __ bind(done_conv);
duke@0 1959
duke@0 1960
duke@0 1961 // Result if any is in tosca. The java expression stack is in the state that the
duke@0 1962 // calling convention left it (i.e. params may or may not be present)
duke@0 1963 // Copy the result from tosca and place it on java expression stack.
duke@0 1964
never@304 1965 // Restore rsi/r13 as compiled code may not preserve it
never@304 1966
coleenp@520 1967 __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));
duke@0 1968
duke@0 1969 // restore stack to what we had when we left (in case i2c extended it)
duke@0 1970
never@304 1971 __ movptr(rsp, STATE(_stack));
never@304 1972 __ lea(rsp, Address(rsp, wordSize));
duke@0 1973
duke@0 1974 // If there is a pending exception then we don't really have a result to process
duke@0 1975
never@304 1976 #ifdef _LP64
never@304 1977 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
never@304 1978 #else
never@304 1979 __ movptr(rcx, STATE(_thread)); // get thread
never@304 1980 __ cmpptr(Address(rcx, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
coleenp@520 1981 #endif // _LP64
duke@0 1982 __ jcc(Assembler::notZero, return_with_exception);
duke@0 1983
duke@0 1984 // get method just executed
never@304 1985 __ movptr(rbx, STATE(_result._to_call._callee));
duke@0 1986
duke@0 1987 // callee left args on top of expression stack, remove them
jrose@622 1988 __ load_unsigned_short(rcx, Address(rbx, methodOopDesc::size_of_parameters_offset()));
never@304 1989 __ lea(rsp, Address(rsp, rcx, Address::times_ptr));
duke@0 1990
duke@0 1991 __ movl(rcx, Address(rbx, methodOopDesc::result_index_offset()));
duke@0 1992 ExternalAddress tosca_to_stack((address)CppInterpreter::_tosca_to_stack);
never@304 1993 // Address index(noreg, rax, Address::times_ptr);
never@304 1994 __ movptr(rcx, ArrayAddress(tosca_to_stack, Address(noreg, rcx, Address::times_ptr)));
never@304 1995 // __ movl(rcx, Address(noreg, rcx, Address::times_ptr, int(AbstractInterpreter::_tosca_to_stack)));
duke@0 1996 __ call(rcx); // call result converter
duke@0 1997 __ jmp(resume_interpreter);
duke@0 1998
duke@0 1999 // An exception is being caught on return to a vanilla interpreter frame.
duke@0 2000 // Empty the stack and resume interpreter
duke@0 2001
duke@0 2002 __ bind(return_with_exception);
duke@0 2003
duke@0 2004 // Exception present, empty stack
never@304 2005 __ movptr(rsp, STATE(_stack_base));
duke@0 2006 __ jmp(resume_interpreter);
duke@0 2007
duke@0 2008 // Return from interpreted method we return result appropriate to the caller (i.e. "recursive"
duke@0 2009 // interpreter call, or native) and unwind this interpreter activation.
duke@0 2010 // All monitors should be unlocked.
duke@0 2011
duke@0 2012 __ bind(return_from_interpreted_method);
duke@0 2013
duke@0 2014 Label return_to_initial_caller;
duke@0 2015
never@304 2016 __ movptr(rbx, STATE(_method)); // get method just executed
never@304 2017 __ cmpptr(STATE(_prev_link), (int32_t)NULL_WORD); // returning from "recursive" interpreter call?
duke@0 2018 __ movl(rax, Address(rbx, methodOopDesc::result_index_offset())); // get result type index
duke@0 2019 __ jcc(Assembler::equal, return_to_initial_caller); // back to native code (call_stub/c1/c2)
duke@0 2020
duke@0 2021 // Copy result to callers java stack
duke@0 2022 ExternalAddress stack_to_stack((address)CppInterpreter::_stack_to_stack);
never@304 2023 // Address index(noreg, rax, Address::times_ptr);
never@304 2024
never@304 2025 __ movptr(rax, ArrayAddress(stack_to_stack, Address(noreg, rax, Address::times_ptr)));
never@304 2026 // __ movl(rax, Address(noreg, rax, Address::times_ptr, int(AbstractInterpreter::_stack_to_stack)));
duke@0 2027 __ call(rax); // call result converter
duke@0 2028
duke@0 2029 Label unwind_recursive_activation;
duke@0 2030 __ bind(unwind_recursive_activation);
duke@0 2031
duke@0 2032 // returning to interpreter method from "recursive" interpreter call
duke@0 2033 // result converter left rax pointing to top of the java stack for method we are returning
duke@0 2034 // to. Now all we must do is unwind the state from the completed call
duke@0 2035
never@304 2036 __ movptr(state, STATE(_prev_link)); // unwind state
duke@0 2037 __ leave(); // pop the frame
never@304 2038 __ mov(rsp, rax); // unwind stack to remove args
duke@0 2039
duke@0 2040 // Resume the interpreter. The current frame contains the current interpreter
duke@0 2041 // state object.
duke@0 2042 //
duke@0 2043
duke@0 2044 __ bind(resume_interpreter);
duke@0 2045
duke@0 2046 // state == interpreterState object for method we are resuming
duke@0 2047
duke@0 2048 __ movl(STATE(_msg), (int)BytecodeInterpreter::method_resume);
never@304 2049 __ lea(rsp, Address(rsp, -wordSize)); // prepush stack (result if any already present)
never@304 2050 __ movptr(STATE(_stack), rsp); // inform interpreter of new stack depth (parameters removed,
duke@0 2051 // result if any on stack already )
never@304 2052 __ movptr(rsp, STATE(_stack_limit)); // restore expression stack to full depth
duke@0 2053 __ jmp(call_interpreter_2); // No need to bang
duke@0 2054
duke@0 2055 // interpreter returning to native code (call_stub/c1/c2)
duke@0 2056 // convert result and unwind initial activation
duke@0 2057 // rax - result index
duke@0 2058
duke@0 2059 __ bind(return_to_initial_caller);
duke@0 2060 ExternalAddress stack_to_native((address)CppInterpreter::_stack_to_native_abi);
never@304 2061 // Address index(noreg, rax, Address::times_ptr);
never@304 2062
never@304 2063 __ movptr(rax, ArrayAddress(stack_to_native, Address(noreg, rax, Address::times_ptr)));
duke@0 2064 __ call(rax); // call result converter
duke@0 2065
duke@0 2066 Label unwind_initial_activation;
duke@0 2067 __ bind(unwind_initial_activation);
duke@0 2068
duke@0 2069 // RETURN TO CALL_STUB/C1/C2 code (result if any in rax/rdx ST(0))
duke@0 2070
duke@0 2071 /* Current stack picture
duke@0 2072
duke@0 2073 [ incoming parameters ]
duke@0 2074 [ extra locals ]
duke@0 2075 [ return address to CALL_STUB/C1/C2]
duke@0 2076 fp -> [ CALL_STUB/C1/C2 fp ]
duke@0 2077 BytecodeInterpreter object
duke@0 2078 expression stack
duke@0 2079 sp ->
duke@0 2080
duke@0 2081 */
duke@0 2082
duke@0 2083 // return restoring the stack to the original sender_sp value
duke@0 2084
never@304 2085 __ movptr(rcx, STATE(_sender_sp));
duke@0 2086 __ leave();
never@304 2087 __ pop(rdi); // get return address
duke@0 2088 // set stack to sender's sp
never@304 2089 __ mov(rsp, rcx);
duke@0 2090 __ jmp(rdi); // return to call_stub
duke@0 2091
duke@0 2092 // OSR request, adjust return address to make current frame into adapter frame
duke@0 2093 // and enter OSR nmethod
duke@0 2094
duke@0 2095 __ bind(do_OSR);
duke@0 2096
duke@0 2097 Label remove_initial_frame;
duke@0 2098
duke@0 2099 // We are going to pop this frame. Is there another interpreter frame underneath
duke@0 2100 // it or is it callstub/compiled?
duke@0 2101
duke@0 2102 // Move buffer to the expected parameter location
never@304 2103 __ movptr(rcx, STATE(_result._osr._osr_buf));
never@304 2104
never@304 2105 __ movptr(rax, STATE(_result._osr._osr_entry));
never@304 2106
never@304 2107 __ cmpptr(STATE(_prev_link), (int32_t)NULL_WORD); // returning from "recursive" interpreter call?
duke@0 2108 __ jcc(Assembler::equal, remove_initial_frame); // back to native code (call_stub/c1/c2)
duke@0 2109
never@304 2110 __ movptr(sender_sp_on_entry, STATE(_sender_sp)); // get sender's sp in expected register
duke@0 2111 __ leave(); // pop the frame
never@304 2112 __ mov(rsp, sender_sp_on_entry); // trim any stack expansion
duke@0 2113
duke@0 2114
duke@0 2115 // We know we are calling compiled so push specialized return
duke@0 2116 // method uses specialized entry, push a return so we look like call stub setup
duke@0 2117 // this path will handle fact that result is returned in registers and not
duke@0 2118 // on the java stack.
duke@0 2119
duke@0 2120 __ pushptr(return_from_native_method.addr());
duke@0 2121
duke@0 2122 __ jmp(rax);
duke@0 2123
duke@0 2124 __ bind(remove_initial_frame);
duke@0 2125
never@304 2126 __ movptr(rdx, STATE(_sender_sp));
duke@0 2127 __ leave();
duke@0 2128 // get real return
never@304 2129 __ pop(rsi);
duke@0 2130 // set stack to sender's sp
never@304 2131 __ mov(rsp, rdx);
duke@0 2132 // repush real return
never@304 2133 __ push(rsi);
duke@0 2134 // Enter OSR nmethod
duke@0 2135 __ jmp(rax);
duke@0 2136
duke@0 2137
duke@0 2138
duke@0 2139
duke@0 2140 // Call a new method. All we do is (temporarily) trim the expression stack
duke@0 2141 // push a return address to bring us back to here and leap to the new entry.
duke@0 2142
duke@0 2143 __ bind(call_method);
duke@0 2144
duke@0 2145 // stack points to next free location and not top element on expression stack
duke@0 2146 // method expects sp to be pointing to topmost element
duke@0 2147
never@304 2148 __ movptr(rsp, STATE(_stack)); // pop args to c++ interpreter, set sp to java stack top
never@304 2149 __ lea(rsp, Address(rsp, wordSize));
never@304 2150
never@304 2151 __ movptr(rbx, STATE(_result._to_call._callee)); // get method to execute
duke@0 2152
duke@0 2153 // don't need a return address if reinvoking interpreter
duke@0 2154
duke@0 2155 // Make it look like call_stub calling conventions
duke@0 2156
duke@0 2157 // Get (potential) receiver
jrose@622 2158 __ load_unsigned_short(rcx, size_of_parameters); // get size of parameters in words
duke@0 2159
duke@0 2160 ExternalAddress recursive(CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation));
duke@0 2161 __ pushptr(recursive.addr()); // make it look good in the debugger
duke@0 2162
duke@0 2163 InternalAddress entry(entry_point);
duke@0 2164 __ cmpptr(STATE(_result._to_call._callee_entry_point), entry.addr()); // returning to interpreter?
duke@0 2165 __ jcc(Assembler::equal, re_dispatch); // yes
duke@0 2166
never@304 2167 __ pop(rax); // pop dummy address
duke@0 2168
duke@0 2169
duke@0 2170 // get specialized entry
never@304 2171 __ movptr(rax, STATE(_result._to_call._callee_entry_point));
duke@0 2172 // set sender SP
never@304 2173 __ mov(sender_sp_on_entry, rsp);
duke@0 2174
duke@0 2175 // method uses specialized entry, push a return so we look like call stub setup
duke@0 2176 // this path will handle fact that result is returned in registers and not
duke@0 2177 // on the java stack.
duke@0 2178
duke@0 2179 __ pushptr(return_from_native_method.addr());
duke@0 2180
duke@0 2181 __ jmp(rax);
duke@0 2182
duke@0 2183 __ bind(bad_msg);
duke@0 2184 __ stop("Bad message from interpreter");
duke@0 2185
duke@0 2186 // Interpreted method "returned" with an exception pass it on...
duke@0 2187 // Pass result, unwind activation and continue/return to interpreter/call_stub
duke@0 2188 // We handle result (if any) differently based on return to interpreter or call_stub
duke@0 2189
duke@0 2190 Label unwind_initial_with_pending_exception;
duke@0 2191
duke@0 2192 __ bind(throw_exception);
never@304 2193 __ cmpptr(STATE(_prev_link), (int32_t)NULL_WORD); // returning from recursive interpreter call?
duke@0 2194 __ jcc(Assembler::equal, unwind_initial_with_pending_exception); // no, back to native code (call_stub/c1/c2)
never@304 2195 __ movptr(rax, STATE(_locals)); // pop parameters get new stack value
never@304 2196 __ addptr(rax, wordSize); // account for prepush before we return
duke@0 2197 __ jmp(unwind_recursive_activation);
duke@0 2198
duke@0 2199 __ bind(unwind_initial_with_pending_exception);
duke@0 2200
duke@0 2201 // We will unwind the current (initial) interpreter frame and forward
duke@0 2202 // the exception to the caller. We must put the exception in the
duke@0 2203 // expected register and clear pending exception and then forward.
duke@0 2204
duke@0 2205 __ jmp(unwind_and_forward);
duke@0 2206
duke@0 2207 interpreter_frame_manager = entry_point;
duke@0 2208 return entry_point;
duke@0 2209 }
duke@0 2210
duke@0 2211 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
duke@0 2212 // determine code generation flags
duke@0 2213 bool synchronized = false;
duke@0 2214 address entry_point = NULL;
duke@0 2215
duke@0 2216 switch (kind) {
duke@0 2217 case Interpreter::zerolocals : break;
duke@0 2218 case Interpreter::zerolocals_synchronized: synchronized = true; break;
duke@0 2219 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
duke@0 2220 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
duke@0 2221 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
duke@0 2222 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
duke@0 2223 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
jrose@710 2224 case Interpreter::method_handle : entry_point = ((InterpreterGenerator*)this)->generate_method_handle_entry(); break;
duke@0 2225
duke@0 2226 case Interpreter::java_lang_math_sin : // fall thru
duke@0 2227 case Interpreter::java_lang_math_cos : // fall thru
duke@0 2228 case Interpreter::java_lang_math_tan : // fall thru
duke@0 2229 case Interpreter::java_lang_math_abs : // fall thru
duke@0 2230 case Interpreter::java_lang_math_log : // fall thru
duke@0 2231 case Interpreter::java_lang_math_log10 : // fall thru
duke@0 2232 case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
johnc@2346 2233 case Interpreter::java_lang_ref_reference_get
johnc@2346 2234 : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break;
duke@0 2235 default : ShouldNotReachHere(); break;
duke@0 2236 }
duke@0 2237
duke@0 2238 if (entry_point) return entry_point;
duke@0 2239
duke@0 2240 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
duke@0 2241
duke@0 2242 }
duke@0 2243
duke@0 2244 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
duke@0 2245 : CppInterpreterGenerator(code) {
duke@0 2246 generate_all(); // down here so it can be "virtual"
duke@0 2247 }
duke@0 2248
duke@0 2249 // Deoptimization helpers for C++ interpreter
duke@0 2250
duke@0 2251 // How much stack a method activation needs in words.
duke@0 2252 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
duke@0 2253
duke@0 2254 const int stub_code = 4; // see generate_call_stub
duke@0 2255 // Save space for one monitor to get into the interpreted method in case
duke@0 2256 // the method is synchronized
duke@0 2257 int monitor_size = method->is_synchronized() ?
duke@0 2258 1*frame::interpreter_frame_monitor_size() : 0;
duke@0 2259
duke@0 2260 // total static overhead size. Account for interpreter state object, return
duke@0 2261 // address, saved rbp and 2 words for a "static long no_params() method" issue.
duke@0 2262
duke@0 2263 const int overhead_size = sizeof(BytecodeInterpreter)/wordSize +
duke@0 2264 ( frame::sender_sp_offset - frame::link_offset) + 2;
duke@0 2265
jrose@710 2266 const int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
jrose@710 2267 const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
duke@0 2268 Interpreter::stackElementWords();
duke@0 2269 return overhead_size + method_stack + stub_code;
duke@0 2270 }
duke@0 2271
duke@0 2272 // returns the activation size.
duke@0 2273 static int size_activation_helper(int extra_locals_size, int monitor_size) {
duke@0 2274 return (extra_locals_size + // the addition space for locals
duke@0 2275 2*BytesPerWord + // return address and saved rbp
duke@0 2276 2*BytesPerWord + // "static long no_params() method" issue
duke@0 2277 sizeof(BytecodeInterpreter) + // interpreterState
duke@0 2278 monitor_size); // monitors
duke@0 2279 }
duke@0 2280
duke@0 2281 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
duke@0 2282 frame* caller,
duke@0 2283 frame* current,
duke@0 2284 methodOop method,
duke@0 2285 intptr_t* locals,
duke@0 2286 intptr_t* stack,
duke@0 2287 intptr_t* stack_base,
duke@0 2288 intptr_t* monitor_base,
duke@0 2289 intptr_t* frame_bottom,
duke@0 2290 bool is_top_frame
duke@0 2291 )
duke@0 2292 {
duke@0 2293 // What about any vtable?
duke@0 2294 //
duke@0 2295 to_fill->_thread = JavaThread::current();
duke@0 2296 // This gets filled in later but make it something recognizable for now
duke@0 2297 to_fill->_bcp = method->code_base();
duke@0 2298 to_fill->_locals = locals;
duke@0 2299 to_fill->_constants = method->constants()->cache();
duke@0 2300 to_fill->_method = method;
duke@0 2301 to_fill->_mdx = NULL;
duke@0 2302 to_fill->_stack = stack;
duke@0 2303 if (is_top_frame && JavaThread::current()->popframe_forcing_deopt_reexecution() ) {
duke@0 2304 to_fill->_msg = deopt_resume2;
duke@0 2305 } else {
duke@0 2306 to_fill->_msg = method_resume;
duke@0 2307 }
duke@0 2308 to_fill->_result._to_call._bcp_advance = 0;
duke@0 2309 to_fill->_result._to_call._callee_entry_point = NULL; // doesn't matter to anyone
duke@0 2310 to_fill->_result._to_call._callee = NULL; // doesn't matter to anyone
duke@0 2311 to_fill->_prev_link = NULL;
duke@0 2312
duke@0 2313 to_fill->_sender_sp = caller->unextended_sp();
duke@0 2314
duke@0 2315 if (caller->is_interpreted_frame()) {
duke@0 2316 interpreterState prev = caller->get_interpreterState();
duke@0 2317 to_fill->_prev_link = prev;
duke@0 2318 // *current->register_addr(GR_Iprev_state) = (intptr_t) prev;
duke@0 2319 // Make the prev callee look proper
duke@0 2320 prev->_result._to_call._callee = method;
duke@0 2321 if (*prev->_bcp == Bytecodes::_invokeinterface) {
duke@0 2322 prev->_result._to_call._bcp_advance = 5;
duke@0 2323 } else {
duke@0 2324 prev->_result._to_call._bcp_advance = 3;
duke@0 2325 }
duke@0 2326 }
duke@0 2327 to_fill->_oop_temp = NULL;
duke@0 2328 to_fill->_stack_base = stack_base;
duke@0 2329 // Need +1 here because stack_base points to the word just above the first expr stack entry
duke@0 2330 // and stack_limit is supposed to point to the word just below the last expr stack entry.
duke@0 2331 // See generate_compute_interpreter_state.
jrose@710 2332 int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
jrose@710 2333 to_fill->_stack_limit = stack_base - (method->max_stack() + extra_stack + 1);
duke@0 2334 to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
duke@0 2335
duke@0 2336 to_fill->_self_link = to_fill;
duke@0 2337 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
duke@0 2338 "Stack top out of range");
duke@0 2339 }
duke@0 2340
duke@0 2341 int AbstractInterpreter::layout_activation(methodOop method,
duke@0 2342 int tempcount, //
duke@0 2343 int popframe_extra_args,
duke@0 2344 int moncount,
duke@0 2345 int callee_param_count,
duke@0 2346 int callee_locals,
duke@0 2347 frame* caller,
duke@0 2348 frame* interpreter_frame,
duke@0 2349 bool is_top_frame) {
duke@0 2350
duke@0 2351 assert(popframe_extra_args == 0, "FIX ME");
duke@0 2352 // NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state()
duke@0 2353 // does as far as allocating an interpreter frame.
duke@0 2354 // If interpreter_frame!=NULL, set up the method, locals, and monitors.
duke@0 2355 // The frame interpreter_frame, if not NULL, is guaranteed to be the right size,
duke@0 2356 // as determined by a previous call to this method.
duke@0 2357 // It is also guaranteed to be walkable even though it is in a skeletal state
duke@0 2358 // NOTE: return size is in words not bytes
duke@0 2359 // NOTE: tempcount is the current size of the java expression stack. For top most
duke@0 2360 // frames we will allocate a full sized expression stack and not the curback
duke@0 2361 // version that non-top frames have.
duke@0 2362
duke@0 2363 // Calculate the amount our frame will be adjust by the callee. For top frame
duke@0 2364 // this is zero.
duke@0 2365
duke@0 2366 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it
duke@0 2367 // calculates the extra locals based on itself. Not what the callee does
duke@0 2368 // to it. So it ignores last_frame_adjust value. Seems suspicious as far
duke@0 2369 // as getting sender_sp correct.
duke@0 2370
duke@0 2371 int extra_locals_size = (callee_locals - callee_param_count) * BytesPerWord;
duke@0 2372 int monitor_size = sizeof(BasicObjectLock) * moncount;
duke@0 2373
duke@0 2374 // First calculate the frame size without any java expression stack
duke@0 2375 int short_frame_size = size_activation_helper(extra_locals_size,
duke@0 2376 monitor_size);
duke@0 2377
duke@0 2378 // Now with full size expression stack
jrose@710 2379 int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries();
jrose@710 2380 int full_frame_size = short_frame_size + (method->max_stack() + extra_stack) * BytesPerWord;
duke@0 2381
duke@0 2382 // and now with only live portion of the expression stack
duke@0 2383 short_frame_size = short_frame_size + tempcount * BytesPerWord;
duke@0 2384
duke@0 2385 // the size the activation is right now. Only top frame is full size
duke@0 2386 int frame_size = (is_top_frame ? full_frame_size : short_frame_size);
duke@0 2387
duke@0 2388 if (interpreter_frame != NULL) {
duke@0 2389 #ifdef ASSERT
duke@0 2390 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
duke@0 2391 #endif
duke@0 2392
duke@0 2393 // MUCHO HACK
duke@0 2394
duke@0 2395 intptr_t* frame_bottom = (intptr_t*) ((intptr_t)interpreter_frame->sp() - (full_frame_size - frame_size));
duke@0 2396
duke@0 2397 /* Now fillin the interpreterState object */
duke@0 2398
duke@0 2399 // The state object is the first thing on the frame and easily located
duke@0 2400
duke@0 2401 interpreterState cur_state = (interpreterState) ((intptr_t)interpreter_frame->fp() - sizeof(BytecodeInterpreter));
duke@0 2402
duke@0 2403
duke@0 2404 // Find the locals pointer. This is rather simple on x86 because there is no
duke@0 2405 // confusing rounding at the callee to account for. We can trivially locate
duke@0 2406 // our locals based on the current fp().
duke@0 2407 // Note: the + 2 is for handling the "static long no_params() method" issue.
duke@0 2408 // (too bad I don't really remember that issue well...)
duke@0 2409
duke@0 2410 intptr_t* locals;
duke@0 2411 // If the caller is interpreted we need to make sure that locals points to the first
duke@0 2412 // argument that the caller passed and not in an area where the stack might have been extended.
duke@0 2413 // because the stack to stack to converter needs a proper locals value in order to remove the
duke@0 2414 // arguments from the caller and place the result in the proper location. Hmm maybe it'd be
duke@0 2415 // simpler if we simply stored the result in the BytecodeInterpreter object and let the c++ code
duke@0 2416 // adjust the stack?? HMMM QQQ
duke@0 2417 //
duke@0 2418 if (caller->is_interpreted_frame()) {
duke@0 2419 // locals must agree with the caller because it will be used to set the
duke@0 2420 // caller's tos when we return.
duke@0 2421 interpreterState prev = caller->get_interpreterState();
duke@0 2422 // stack() is prepushed.
duke@0 2423 locals = prev->stack() + method->size_of_parameters();
duke@0 2424 // locals = caller->unextended_sp() + (method->size_of_parameters() - 1);
duke@0 2425 if (locals != interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2) {
duke@0 2426 // os::breakpoint();
duke@0 2427 }
duke@0 2428 } else {
duke@0 2429 // this is where a c2i would have placed locals (except for the +2)
duke@0 2430 locals = interpreter_frame->fp() + frame::sender_sp_offset + (method->max_locals() - 1) + 2;
duke@0 2431 }
duke@0 2432
duke@0 2433 intptr_t* monitor_base = (intptr_t*) cur_state;
duke@0 2434 intptr_t* stack_base = (intptr_t*) ((intptr_t) monitor_base - monitor_size);
duke@0 2435 /* +1 because stack is always prepushed */
duke@0 2436 intptr_t* stack = (intptr_t*) ((intptr_t) stack_base - (tempcount + 1) * BytesPerWord);
duke@0 2437
duke@0 2438
duke@0 2439 BytecodeInterpreter::layout_interpreterState(cur_state,
duke@0 2440 caller,
duke@0 2441 interpreter_frame,
duke@0 2442 method,
duke@0 2443 locals,
duke@0 2444 stack,
duke@0 2445 stack_base,
duke@0 2446 monitor_base,
duke@0 2447 frame_bottom,
duke@0 2448 is_top_frame);
duke@0 2449
duke@0 2450 // BytecodeInterpreter::pd_layout_interpreterState(cur_state, interpreter_return_address, interpreter_frame->fp());
duke@0 2451 }
duke@0 2452 return frame_size/BytesPerWord;
duke@0 2453 }
duke@0 2454
duke@0 2455 #endif // CC_INTERP (all)