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