Mercurial > hg > graal-jvmci-8
annotate src/cpu/sparc/vm/cppInterpreter_sparc.cpp @ 3249:e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
| author | johnc |
|---|---|
| date | Thu, 07 Apr 2011 09:53:20 -0700 |
| parents | 8033953d67ff |
| children | 92add02409c9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
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 "shadow" interpreter frames are on stack. It is also | |
| 56 // used to distinguish interpreter frames. | |
| 57 | |
| 58 extern "C" void RecursiveInterpreterActivation(interpreterState istate) { | |
| 59 ShouldNotReachHere(); | |
| 60 } | |
| 61 | |
| 62 bool CppInterpreter::contains(address pc) { | |
| 63 return ( _code->contains(pc) || | |
| 64 ( pc == (CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset))); | |
| 65 } | |
| 66 | |
| 67 #define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name)) | |
| 68 #define __ _masm-> | |
| 69 | |
| 70 Label frame_manager_entry; | |
| 71 Label fast_accessor_slow_entry_path; // fast accessor methods need to be able to jmp to unsynchronized | |
| 72 // c++ interpreter entry point this holds that entry point label. | |
| 73 | |
| 74 static address unctrap_frame_manager_entry = NULL; | |
| 75 | |
| 76 static address interpreter_return_address = NULL; | |
| 77 static address deopt_frame_manager_return_atos = NULL; | |
| 78 static address deopt_frame_manager_return_btos = NULL; | |
| 79 static address deopt_frame_manager_return_itos = NULL; | |
| 80 static address deopt_frame_manager_return_ltos = NULL; | |
| 81 static address deopt_frame_manager_return_ftos = NULL; | |
| 82 static address deopt_frame_manager_return_dtos = NULL; | |
| 83 static address deopt_frame_manager_return_vtos = NULL; | |
| 84 | |
| 85 const Register prevState = G1_scratch; | |
| 86 | |
| 87 void InterpreterGenerator::save_native_result(void) { | |
| 88 // result potentially in O0/O1: save it across calls | |
| 89 __ stf(FloatRegisterImpl::D, F0, STATE(_native_fresult)); | |
| 90 #ifdef _LP64 | |
| 91 __ stx(O0, STATE(_native_lresult)); | |
| 92 #else | |
| 93 __ std(O0, STATE(_native_lresult)); | |
| 94 #endif | |
| 95 } | |
| 96 | |
| 97 void InterpreterGenerator::restore_native_result(void) { | |
| 98 | |
| 99 // Restore any method result value | |
| 100 __ ldf(FloatRegisterImpl::D, STATE(_native_fresult), F0); | |
| 101 #ifdef _LP64 | |
| 102 __ ldx(STATE(_native_lresult), O0); | |
| 103 #else | |
| 104 __ ldd(STATE(_native_lresult), O0); | |
| 105 #endif | |
| 106 } | |
| 107 | |
| 108 // A result handler converts/unboxes a native call result into | |
| 109 // a java interpreter/compiler result. The current frame is an | |
| 110 // interpreter frame. The activation frame unwind code must be | |
| 111 // consistent with that of TemplateTable::_return(...). In the | |
| 112 // case of native methods, the caller's SP was not modified. | |
| 113 address CppInterpreterGenerator::generate_result_handler_for(BasicType type) { | |
| 114 address entry = __ pc(); | |
| 115 Register Itos_i = Otos_i ->after_save(); | |
| 116 Register Itos_l = Otos_l ->after_save(); | |
| 117 Register Itos_l1 = Otos_l1->after_save(); | |
| 118 Register Itos_l2 = Otos_l2->after_save(); | |
| 119 switch (type) { | |
| 120 case T_BOOLEAN: __ subcc(G0, O0, G0); __ addc(G0, 0, Itos_i); break; // !0 => true; 0 => false | |
| 121 case T_CHAR : __ sll(O0, 16, O0); __ srl(O0, 16, Itos_i); break; // cannot use and3, 0xFFFF too big as immediate value! | |
| 122 case T_BYTE : __ sll(O0, 24, O0); __ sra(O0, 24, Itos_i); break; | |
| 123 case T_SHORT : __ sll(O0, 16, O0); __ sra(O0, 16, Itos_i); break; | |
| 124 case T_LONG : | |
| 125 #ifndef _LP64 | |
| 126 __ mov(O1, Itos_l2); // move other half of long | |
| 127 #endif // ifdef or no ifdef, fall through to the T_INT case | |
| 128 case T_INT : __ mov(O0, Itos_i); break; | |
| 129 case T_VOID : /* nothing to do */ break; | |
| 130 case T_FLOAT : assert(F0 == Ftos_f, "fix this code" ); break; | |
| 131 case T_DOUBLE : assert(F0 == Ftos_d, "fix this code" ); break; | |
| 132 case T_OBJECT : | |
| 133 __ ld_ptr(STATE(_oop_temp), Itos_i); | |
| 134 __ verify_oop(Itos_i); | |
| 135 break; | |
| 136 default : ShouldNotReachHere(); | |
| 137 } | |
| 138 __ ret(); // return from interpreter activation | |
| 139 __ delayed()->restore(I5_savedSP, G0, SP); // remove interpreter frame | |
| 140 NOT_PRODUCT(__ emit_long(0);) // marker for disassembly | |
| 141 return entry; | |
| 142 } | |
| 143 | |
| 144 // tosca based result to c++ interpreter stack based result. | |
| 145 // Result goes to address in L1_scratch | |
| 146 | |
| 147 address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) { | |
| 148 // A result is in the native abi result register from a native method call. | |
| 149 // We need to return this result to the interpreter by pushing the result on the interpreter's | |
| 150 // stack. This is relatively simple the destination is in L1_scratch | |
| 151 // i.e. L1_scratch is the first free element on the stack. If we "push" a return value we must | |
| 152 // adjust L1_scratch | |
| 153 address entry = __ pc(); | |
| 154 switch (type) { | |
| 155 case T_BOOLEAN: | |
| 156 // !0 => true; 0 => false | |
| 157 __ subcc(G0, O0, G0); | |
| 158 __ addc(G0, 0, O0); | |
| 159 __ st(O0, L1_scratch, 0); | |
| 160 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 161 break; | |
| 162 | |
| 163 // cannot use and3, 0xFFFF too big as immediate value! | |
| 164 case T_CHAR : | |
| 165 __ sll(O0, 16, O0); | |
| 166 __ srl(O0, 16, O0); | |
| 167 __ st(O0, L1_scratch, 0); | |
| 168 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 169 break; | |
| 170 | |
| 171 case T_BYTE : | |
| 172 __ sll(O0, 24, O0); | |
| 173 __ sra(O0, 24, O0); | |
| 174 __ st(O0, L1_scratch, 0); | |
| 175 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 176 break; | |
| 177 | |
| 178 case T_SHORT : | |
| 179 __ sll(O0, 16, O0); | |
| 180 __ sra(O0, 16, O0); | |
| 181 __ st(O0, L1_scratch, 0); | |
| 182 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 183 break; | |
| 184 case T_LONG : | |
| 185 #ifndef _LP64 | |
| 123 | 186 #if defined(COMPILER2) |
| 0 | 187 // All return values are where we want them, except for Longs. C2 returns |
| 188 // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1. | |
| 189 // Since the interpreter will return longs in G1 and O0/O1 in the 32bit | |
| 190 // build even if we are returning from interpreted we just do a little | |
| 191 // stupid shuffing. | |
| 192 // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to | |
| 193 // do this here. Unfortunately if we did a rethrow we'd see an machepilog node | |
| 194 // first which would move g1 -> O0/O1 and destroy the exception we were throwing. | |
| 195 __ stx(G1, L1_scratch, -wordSize); | |
| 196 #else | |
| 197 // native result is in O0, O1 | |
| 198 __ st(O1, L1_scratch, 0); // Low order | |
| 199 __ st(O0, L1_scratch, -wordSize); // High order | |
| 123 | 200 #endif /* COMPILER2 */ |
| 0 | 201 #else |
| 123 | 202 __ stx(O0, L1_scratch, -wordSize); |
| 0 | 203 #endif |
| 204 __ sub(L1_scratch, 2*wordSize, L1_scratch); | |
| 205 break; | |
| 206 | |
| 207 case T_INT : | |
| 208 __ st(O0, L1_scratch, 0); | |
| 209 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 210 break; | |
| 211 | |
| 212 case T_VOID : /* nothing to do */ | |
| 213 break; | |
| 214 | |
| 215 case T_FLOAT : | |
| 216 __ stf(FloatRegisterImpl::S, F0, L1_scratch, 0); | |
| 217 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 218 break; | |
| 219 | |
| 220 case T_DOUBLE : | |
| 221 // Every stack slot is aligned on 64 bit, However is this | |
| 222 // the correct stack slot on 64bit?? QQQ | |
| 223 __ stf(FloatRegisterImpl::D, F0, L1_scratch, -wordSize); | |
| 224 __ sub(L1_scratch, 2*wordSize, L1_scratch); | |
| 225 break; | |
| 226 case T_OBJECT : | |
| 227 __ verify_oop(O0); | |
| 228 __ st_ptr(O0, L1_scratch, 0); | |
| 229 __ sub(L1_scratch, wordSize, L1_scratch); | |
| 230 break; | |
| 231 default : ShouldNotReachHere(); | |
| 232 } | |
| 233 __ retl(); // return from interpreter activation | |
| 234 __ delayed()->nop(); // schedule this better | |
| 235 NOT_PRODUCT(__ emit_long(0);) // marker for disassembly | |
| 236 return entry; | |
| 237 } | |
| 238 | |
| 239 address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) { | |
| 240 // A result is in the java expression stack of the interpreted method that has just | |
| 241 // returned. Place this result on the java expression stack of the caller. | |
| 242 // | |
| 243 // The current interpreter activation in Lstate is for the method just returning its | |
| 244 // result. So we know that the result of this method is on the top of the current | |
| 245 // execution stack (which is pre-pushed) and will be return to the top of the caller | |
| 246 // stack. The top of the callers stack is the bottom of the locals of the current | |
| 247 // activation. | |
| 248 // Because of the way activation are managed by the frame manager the value of esp is | |
| 249 // below both the stack top of the current activation and naturally the stack top | |
| 250 // of the calling activation. This enable this routine to leave the return address | |
| 251 // to the frame manager on the stack and do a vanilla return. | |
| 252 // | |
| 253 // On entry: O0 - points to source (callee stack top) | |
| 254 // O1 - points to destination (caller stack top [i.e. free location]) | |
| 255 // destroys O2, O3 | |
| 256 // | |
| 257 | |
| 258 address entry = __ pc(); | |
| 259 switch (type) { | |
| 260 case T_VOID: break; | |
| 261 break; | |
| 262 case T_FLOAT : | |
| 263 case T_BOOLEAN: | |
| 264 case T_CHAR : | |
| 265 case T_BYTE : | |
| 266 case T_SHORT : | |
| 267 case T_INT : | |
| 268 // 1 word result | |
| 269 __ ld(O0, 0, O2); | |
| 270 __ st(O2, O1, 0); | |
| 271 __ sub(O1, wordSize, O1); | |
| 272 break; | |
| 273 case T_DOUBLE : | |
| 274 case T_LONG : | |
| 275 // return top two words on current expression stack to caller's expression stack | |
| 276 // The caller's expression stack is adjacent to the current frame manager's intepretState | |
| 277 // except we allocated one extra word for this intepretState so we won't overwrite it | |
| 278 // when we return a two word result. | |
| 279 #ifdef _LP64 | |
| 280 __ ld_ptr(O0, 0, O2); | |
| 281 __ st_ptr(O2, O1, -wordSize); | |
| 282 #else | |
| 283 __ ld(O0, 0, O2); | |
| 284 __ ld(O0, wordSize, O3); | |
| 285 __ st(O3, O1, 0); | |
| 286 __ st(O2, O1, -wordSize); | |
| 287 #endif | |
| 288 __ sub(O1, 2*wordSize, O1); | |
| 289 break; | |
| 290 case T_OBJECT : | |
| 291 __ ld_ptr(O0, 0, O2); | |
| 292 __ verify_oop(O2); // verify it | |
| 293 __ st_ptr(O2, O1, 0); | |
| 294 __ sub(O1, wordSize, O1); | |
| 295 break; | |
| 296 default : ShouldNotReachHere(); | |
| 297 } | |
| 298 __ retl(); | |
| 299 __ delayed()->nop(); // QQ schedule this better | |
| 300 return entry; | |
| 301 } | |
| 302 | |
| 303 address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) { | |
| 304 // A result is in the java expression stack of the interpreted method that has just | |
| 305 // returned. Place this result in the native abi that the caller expects. | |
| 306 // We are in a new frame registers we set must be in caller (i.e. callstub) frame. | |
| 307 // | |
| 308 // Similar to generate_stack_to_stack_converter above. Called at a similar time from the | |
| 309 // frame manager execept in this situation the caller is native code (c1/c2/call_stub) | |
| 310 // and so rather than return result onto caller's java expression stack we return the | |
| 311 // result in the expected location based on the native abi. | |
| 312 // On entry: O0 - source (stack top) | |
| 313 // On exit result in expected output register | |
| 314 // QQQ schedule this better | |
| 315 | |
| 316 address entry = __ pc(); | |
| 317 switch (type) { | |
| 318 case T_VOID: break; | |
| 319 break; | |
| 320 case T_FLOAT : | |
| 321 __ ldf(FloatRegisterImpl::S, O0, 0, F0); | |
| 322 break; | |
| 323 case T_BOOLEAN: | |
| 324 case T_CHAR : | |
| 325 case T_BYTE : | |
| 326 case T_SHORT : | |
| 327 case T_INT : | |
| 328 // 1 word result | |
| 329 __ ld(O0, 0, O0->after_save()); | |
| 330 break; | |
| 331 case T_DOUBLE : | |
| 332 __ ldf(FloatRegisterImpl::D, O0, 0, F0); | |
| 333 break; | |
| 334 case T_LONG : | |
| 335 // return top two words on current expression stack to caller's expression stack | |
| 336 // The caller's expression stack is adjacent to the current frame manager's interpretState | |
| 337 // except we allocated one extra word for this intepretState so we won't overwrite it | |
| 338 // when we return a two word result. | |
| 339 #ifdef _LP64 | |
| 340 __ ld_ptr(O0, 0, O0->after_save()); | |
| 341 #else | |
| 342 __ ld(O0, wordSize, O1->after_save()); | |
| 343 __ ld(O0, 0, O0->after_save()); | |
| 344 #endif | |
| 345 #if defined(COMPILER2) && !defined(_LP64) | |
| 346 // C2 expects long results in G1 we can't tell if we're returning to interpreted | |
| 347 // or compiled so just be safe use G1 and O0/O1 | |
| 348 | |
| 349 // Shift bits into high (msb) of G1 | |
| 350 __ sllx(Otos_l1->after_save(), 32, G1); | |
| 351 // Zero extend low bits | |
| 352 __ srl (Otos_l2->after_save(), 0, Otos_l2->after_save()); | |
| 353 __ or3 (Otos_l2->after_save(), G1, G1); | |
| 354 #endif /* COMPILER2 */ | |
| 355 break; | |
| 356 case T_OBJECT : | |
| 357 __ ld_ptr(O0, 0, O0->after_save()); | |
| 358 __ verify_oop(O0->after_save()); // verify it | |
| 359 break; | |
| 360 default : ShouldNotReachHere(); | |
| 361 } | |
| 362 __ retl(); | |
| 363 __ delayed()->nop(); | |
| 364 return entry; | |
| 365 } | |
| 366 | |
| 367 address CppInterpreter::return_entry(TosState state, int length) { | |
| 368 // make it look good in the debugger | |
| 369 return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset; | |
| 370 } | |
| 371 | |
| 372 address CppInterpreter::deopt_entry(TosState state, int length) { | |
| 373 address ret = NULL; | |
| 374 if (length != 0) { | |
| 375 switch (state) { | |
| 376 case atos: ret = deopt_frame_manager_return_atos; break; | |
| 377 case btos: ret = deopt_frame_manager_return_btos; break; | |
| 378 case ctos: | |
| 379 case stos: | |
| 380 case itos: ret = deopt_frame_manager_return_itos; break; | |
| 381 case ltos: ret = deopt_frame_manager_return_ltos; break; | |
| 382 case ftos: ret = deopt_frame_manager_return_ftos; break; | |
| 383 case dtos: ret = deopt_frame_manager_return_dtos; break; | |
| 384 case vtos: ret = deopt_frame_manager_return_vtos; break; | |
| 385 } | |
| 386 } else { | |
| 387 ret = unctrap_frame_manager_entry; // re-execute the bytecode ( e.g. uncommon trap) | |
| 388 } | |
| 389 assert(ret != NULL, "Not initialized"); | |
| 390 return ret; | |
| 391 } | |
| 392 | |
| 393 // | |
| 394 // Helpers for commoning out cases in the various type of method entries. | |
| 395 // | |
| 396 | |
| 397 // increment invocation count & check for overflow | |
| 398 // | |
| 399 // Note: checking for negative value instead of overflow | |
| 400 // so we have a 'sticky' overflow test | |
| 401 // | |
| 402 // Lmethod: method | |
| 403 // ??: invocation counter | |
| 404 // | |
| 405 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) { | |
| 406 // Update standard invocation counters | |
| 407 __ increment_invocation_counter(O0, G3_scratch); | |
| 408 if (ProfileInterpreter) { // %%% Merge this into methodDataOop | |
| 409 __ ld_ptr(STATE(_method), G3_scratch); | |
| 410 Address interpreter_invocation_counter(G3_scratch, 0, in_bytes(methodOopDesc::interpreter_invocation_counter_offset())); | |
| 411 __ ld(interpreter_invocation_counter, G3_scratch); | |
| 412 __ inc(G3_scratch); | |
| 413 __ st(G3_scratch, interpreter_invocation_counter); | |
| 414 } | |
| 415 | |
| 416 Address invocation_limit(G3_scratch, (address)&InvocationCounter::InterpreterInvocationLimit); | |
| 417 __ sethi(invocation_limit); | |
| 418 __ ld(invocation_limit, G3_scratch); | |
| 419 __ cmp(O0, G3_scratch); | |
| 420 __ br(Assembler::greaterEqualUnsigned, false, Assembler::pn, *overflow); | |
| 421 __ delayed()->nop(); | |
| 422 | |
| 423 } | |
| 424 | |
| 425 address InterpreterGenerator::generate_empty_entry(void) { | |
| 426 | |
| 427 // A method that does nothing but return... | |
| 428 | |
| 429 address entry = __ pc(); | |
| 430 Label slow_path; | |
| 431 | |
| 432 __ verify_oop(G5_method); | |
| 433 | |
| 434 // do nothing for empty methods (do not even increment invocation counter) | |
| 435 if ( UseFastEmptyMethods) { | |
| 436 // If we need a safepoint check, generate full interpreter entry. | |
| 437 Address sync_state(G3_scratch, SafepointSynchronize::address_of_state()); | |
| 438 __ load_contents(sync_state, G3_scratch); | |
| 439 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized); | |
| 440 __ br(Assembler::notEqual, false, Assembler::pn, frame_manager_entry); | |
| 441 __ delayed()->nop(); | |
| 442 | |
| 443 // Code: _return | |
| 444 __ retl(); | |
| 445 __ delayed()->mov(O5_savedSP, SP); | |
| 446 return entry; | |
| 447 } | |
| 448 return NULL; | |
| 449 } | |
| 450 | |
| 451 // Call an accessor method (assuming it is resolved, otherwise drop into | |
| 452 // vanilla (slow path) entry | |
| 453 | |
| 454 // Generates code to elide accessor methods | |
| 455 // Uses G3_scratch and G1_scratch as scratch | |
| 456 address InterpreterGenerator::generate_accessor_entry(void) { | |
| 457 | |
| 458 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites thereof; | |
| 459 // parameter size = 1 | |
| 460 // Note: We can only use this code if the getfield has been resolved | |
| 461 // and if we don't have a null-pointer exception => check for | |
| 462 // these conditions first and use slow path if necessary. | |
| 463 address entry = __ pc(); | |
| 464 Label slow_path; | |
| 465 | |
| 466 if ( UseFastAccessorMethods) { | |
| 467 // Check if we need to reach a safepoint and generate full interpreter | |
| 468 // frame if so. | |
| 469 Address sync_state(G3_scratch, SafepointSynchronize::address_of_state()); | |
| 470 __ load_contents(sync_state, G3_scratch); | |
| 471 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized); | |
| 472 __ br(Assembler::notEqual, false, Assembler::pn, slow_path); | |
| 473 __ delayed()->nop(); | |
| 474 | |
| 475 // Check if local 0 != NULL | |
| 476 __ ld_ptr(Gargs, G0, Otos_i ); // get local 0 | |
| 477 __ tst(Otos_i); // check if local 0 == NULL and go the slow path | |
| 478 __ brx(Assembler::zero, false, Assembler::pn, slow_path); | |
| 479 __ delayed()->nop(); | |
| 480 | |
| 481 | |
| 482 // read first instruction word and extract bytecode @ 1 and index @ 2 | |
| 483 // get first 4 bytes of the bytecodes (big endian!) | |
| 484 __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::const_offset())), G1_scratch); | |
| 485 __ ld(Address(G1_scratch, 0, in_bytes(constMethodOopDesc::codes_offset())), G1_scratch); | |
| 486 | |
| 487 // move index @ 2 far left then to the right most two bytes. | |
| 488 __ sll(G1_scratch, 2*BitsPerByte, G1_scratch); | |
| 489 __ srl(G1_scratch, 2*BitsPerByte - exact_log2(in_words( | |
| 490 ConstantPoolCacheEntry::size()) * BytesPerWord), G1_scratch); | |
| 491 | |
| 492 // get constant pool cache | |
| 493 __ ld_ptr(G5_method, in_bytes(methodOopDesc::constants_offset()), G3_scratch); | |
| 494 __ ld_ptr(G3_scratch, constantPoolOopDesc::cache_offset_in_bytes(), G3_scratch); | |
| 495 | |
| 496 // get specific constant pool cache entry | |
| 497 __ add(G3_scratch, G1_scratch, G3_scratch); | |
| 498 | |
| 499 // Check the constant Pool cache entry to see if it has been resolved. | |
| 500 // If not, need the slow path. | |
| 501 ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset(); | |
| 502 __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::indices_offset()), G1_scratch); | |
| 503 __ srl(G1_scratch, 2*BitsPerByte, G1_scratch); | |
| 504 __ and3(G1_scratch, 0xFF, G1_scratch); | |
| 505 __ cmp(G1_scratch, Bytecodes::_getfield); | |
| 506 __ br(Assembler::notEqual, false, Assembler::pn, slow_path); | |
| 507 __ delayed()->nop(); | |
| 508 | |
| 509 // Get the type and return field offset from the constant pool cache | |
| 510 __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::flags_offset()), G1_scratch); | |
| 511 __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset()), G3_scratch); | |
| 512 | |
| 513 Label xreturn_path; | |
| 514 // Need to differentiate between igetfield, agetfield, bgetfield etc. | |
| 515 // because they are different sizes. | |
| 516 // Get the type from the constant pool cache | |
| 517 __ srl(G1_scratch, ConstantPoolCacheEntry::tosBits, G1_scratch); | |
| 518 // Make sure we don't need to mask G1_scratch for tosBits after the above shift | |
| 519 ConstantPoolCacheEntry::verify_tosBits(); | |
| 520 __ cmp(G1_scratch, atos ); | |
| 521 __ br(Assembler::equal, true, Assembler::pt, xreturn_path); | |
| 522 __ delayed()->ld_ptr(Otos_i, G3_scratch, Otos_i); | |
| 523 __ cmp(G1_scratch, itos); | |
| 524 __ br(Assembler::equal, true, Assembler::pt, xreturn_path); | |
| 525 __ delayed()->ld(Otos_i, G3_scratch, Otos_i); | |
| 526 __ cmp(G1_scratch, stos); | |
| 527 __ br(Assembler::equal, true, Assembler::pt, xreturn_path); | |
| 528 __ delayed()->ldsh(Otos_i, G3_scratch, Otos_i); | |
| 529 __ cmp(G1_scratch, ctos); | |
| 530 __ br(Assembler::equal, true, Assembler::pt, xreturn_path); | |
| 531 __ delayed()->lduh(Otos_i, G3_scratch, Otos_i); | |
| 532 #ifdef ASSERT | |
| 533 __ cmp(G1_scratch, btos); | |
| 534 __ br(Assembler::equal, true, Assembler::pt, xreturn_path); | |
| 535 __ delayed()->ldsb(Otos_i, G3_scratch, Otos_i); | |
| 536 __ should_not_reach_here(); | |
| 537 #endif | |
| 538 __ ldsb(Otos_i, G3_scratch, Otos_i); | |
| 539 __ bind(xreturn_path); | |
| 540 | |
| 541 // _ireturn/_areturn | |
| 542 __ retl(); // return from leaf routine | |
| 543 __ delayed()->mov(O5_savedSP, SP); | |
| 544 | |
| 545 // Generate regular method entry | |
| 546 __ bind(slow_path); | |
| 547 __ ba(false, fast_accessor_slow_entry_path); | |
| 548 __ delayed()->nop(); | |
| 549 return entry; | |
| 550 } | |
| 551 return NULL; | |
| 552 } | |
| 553 | |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
554 address InterpreterGenerator::generate_Reference_get_entry(void) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
555 #ifndef SERIALGC |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
556 if (UseG1GC) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
557 // We need to generate have a routine that generates code to: |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
558 // * load the value in the referent field |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
559 // * passes that value to the pre-barrier. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
560 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
561 // In the case of G1 this will record the value of the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
562 // referent in an SATB buffer if marking is active. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
563 // This will cause concurrent marking to mark the referent |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
564 // field as live. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
565 Unimplemented(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
566 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
567 #endif // SERIALGC |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
568 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
569 // If G1 is not enabled then attempt to go through the accessor entry point |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
570 // Reference.get is an accessor |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
571 return generate_accessor_entry(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
572 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
573 |
| 0 | 574 // |
| 575 // Interpreter stub for calling a native method. (C++ interpreter) | |
| 576 // This sets up a somewhat different looking stack for calling the native method | |
| 577 // than the typical interpreter frame setup. | |
| 578 // | |
| 579 | |
| 580 address InterpreterGenerator::generate_native_entry(bool synchronized) { | |
| 581 address entry = __ pc(); | |
| 582 | |
| 583 // the following temporary registers are used during frame creation | |
| 584 const Register Gtmp1 = G3_scratch ; | |
| 585 const Register Gtmp2 = G1_scratch; | |
| 586 const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())); | |
| 587 | |
| 588 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 589 | |
| 590 // make sure registers are different! | |
| 591 assert_different_registers(G2_thread, G5_method, Gargs, Gtmp1, Gtmp2); | |
| 592 | |
| 593 const Address access_flags (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset())); | |
| 594 | |
| 595 Label Lentry; | |
| 596 __ bind(Lentry); | |
| 597 | |
| 598 __ verify_oop(G5_method); | |
| 599 | |
| 600 const Register Glocals_size = G3; | |
| 601 assert_different_registers(Glocals_size, G4_scratch, Gframe_size); | |
| 602 | |
| 603 // make sure method is native & not abstract | |
| 604 // rethink these assertions - they can be simplified and shared (gri 2/25/2000) | |
| 605 #ifdef ASSERT | |
| 606 __ ld(access_flags, Gtmp1); | |
| 607 { | |
| 608 Label L; | |
| 609 __ btst(JVM_ACC_NATIVE, Gtmp1); | |
| 610 __ br(Assembler::notZero, false, Assembler::pt, L); | |
| 611 __ delayed()->nop(); | |
| 612 __ stop("tried to execute non-native method as native"); | |
| 613 __ bind(L); | |
| 614 } | |
| 615 { Label L; | |
| 616 __ btst(JVM_ACC_ABSTRACT, Gtmp1); | |
| 617 __ br(Assembler::zero, false, Assembler::pt, L); | |
| 618 __ delayed()->nop(); | |
| 619 __ stop("tried to execute abstract method as non-abstract"); | |
| 620 __ bind(L); | |
| 621 } | |
| 622 #endif // ASSERT | |
| 623 | |
| 624 __ lduh(size_of_parameters, Gtmp1); | |
| 625 __ sll(Gtmp1, LogBytesPerWord, Gtmp2); // parameter size in bytes | |
| 626 __ add(Gargs, Gtmp2, Gargs); // points to first local + BytesPerWord | |
| 627 // NEW | |
| 628 __ add(Gargs, -wordSize, Gargs); // points to first local[0] | |
| 629 // generate the code to allocate the interpreter stack frame | |
| 630 // NEW FRAME ALLOCATED HERE | |
| 631 // save callers original sp | |
| 632 // __ mov(SP, I5_savedSP->after_restore()); | |
| 633 | |
| 634 generate_compute_interpreter_state(Lstate, G0, true); | |
| 635 | |
| 636 // At this point Lstate points to new interpreter state | |
| 637 // | |
| 638 | |
| 639 const Address do_not_unlock_if_synchronized(G2_thread, 0, | |
| 640 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 641 // Since at this point in the method invocation the exception handler | |
| 642 // would try to exit the monitor of synchronized methods which hasn't | |
| 643 // been entered yet, we set the thread local variable | |
| 644 // _do_not_unlock_if_synchronized to true. If any exception was thrown by | |
| 645 // runtime, exception handling i.e. unlock_if_synchronized_method will | |
| 646 // check this thread local flag. | |
| 647 // This flag has two effects, one is to force an unwind in the topmost | |
| 648 // interpreter frame and not perform an unlock while doing so. | |
| 649 | |
| 650 __ movbool(true, G3_scratch); | |
| 651 __ stbool(G3_scratch, do_not_unlock_if_synchronized); | |
| 652 | |
| 653 | |
| 654 // increment invocation counter and check for overflow | |
| 655 // | |
| 656 // Note: checking for negative value instead of overflow | |
| 657 // so we have a 'sticky' overflow test (may be of | |
| 658 // importance as soon as we have true MT/MP) | |
| 659 Label invocation_counter_overflow; | |
| 660 if (inc_counter) { | |
| 661 generate_counter_incr(&invocation_counter_overflow, NULL, NULL); | |
| 662 } | |
| 663 Label Lcontinue; | |
| 664 __ bind(Lcontinue); | |
| 665 | |
| 666 bang_stack_shadow_pages(true); | |
| 667 // reset the _do_not_unlock_if_synchronized flag | |
| 668 __ stbool(G0, do_not_unlock_if_synchronized); | |
| 669 | |
| 670 // check for synchronized methods | |
| 671 // Must happen AFTER invocation_counter check, so method is not locked | |
| 672 // if counter overflows. | |
| 673 | |
| 674 if (synchronized) { | |
| 675 lock_method(); | |
| 676 // Don't see how G2_thread is preserved here... | |
| 677 // __ verify_thread(); QQQ destroys L0,L1 can't use | |
| 678 } else { | |
| 679 #ifdef ASSERT | |
| 680 { Label ok; | |
| 681 __ ld_ptr(STATE(_method), G5_method); | |
| 682 __ ld(access_flags, O0); | |
| 683 __ btst(JVM_ACC_SYNCHRONIZED, O0); | |
| 684 __ br( Assembler::zero, false, Assembler::pt, ok); | |
| 685 __ delayed()->nop(); | |
| 686 __ stop("method needs synchronization"); | |
| 687 __ bind(ok); | |
| 688 } | |
| 689 #endif // ASSERT | |
| 690 } | |
| 691 | |
| 692 // start execution | |
| 693 | |
| 694 // __ verify_thread(); kills L1,L2 can't use at the moment | |
| 695 | |
| 696 // jvmti/jvmpi support | |
| 697 __ notify_method_entry(); | |
| 698 | |
| 699 // native call | |
| 700 | |
| 701 // (note that O0 is never an oop--at most it is a handle) | |
| 702 // It is important not to smash any handles created by this call, | |
| 703 // until any oop handle in O0 is dereferenced. | |
| 704 | |
| 705 // (note that the space for outgoing params is preallocated) | |
| 706 | |
| 707 // get signature handler | |
| 708 | |
| 709 Label pending_exception_present; | |
| 710 | |
| 711 { Label L; | |
| 712 __ ld_ptr(STATE(_method), G5_method); | |
| 713 __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::signature_handler_offset())), G3_scratch); | |
| 714 __ tst(G3_scratch); | |
| 715 __ brx(Assembler::notZero, false, Assembler::pt, L); | |
| 716 __ delayed()->nop(); | |
| 717 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), G5_method, false); | |
| 718 __ ld_ptr(STATE(_method), G5_method); | |
| 719 | |
| 720 Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset())); | |
| 721 __ ld_ptr(exception_addr, G3_scratch); | |
| 722 __ br_notnull(G3_scratch, false, Assembler::pn, pending_exception_present); | |
| 723 __ delayed()->nop(); | |
| 724 __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::signature_handler_offset())), G3_scratch); | |
| 725 __ bind(L); | |
| 726 } | |
| 727 | |
| 728 // Push a new frame so that the args will really be stored in | |
| 729 // Copy a few locals across so the new frame has the variables | |
| 730 // we need but these values will be dead at the jni call and | |
| 731 // therefore not gc volatile like the values in the current | |
| 732 // frame (Lstate in particular) | |
| 733 | |
| 734 // Flush the state pointer to the register save area | |
| 735 // Which is the only register we need for a stack walk. | |
| 736 __ st_ptr(Lstate, SP, (Lstate->sp_offset_in_saved_window() * wordSize) + STACK_BIAS); | |
| 737 | |
| 738 __ mov(Lstate, O1); // Need to pass the state pointer across the frame | |
| 739 | |
| 740 // Calculate current frame size | |
| 741 __ sub(SP, FP, O3); // Calculate negative of current frame size | |
| 742 __ save(SP, O3, SP); // Allocate an identical sized frame | |
| 743 | |
| 744 __ mov(I1, Lstate); // In the "natural" register. | |
| 745 | |
| 746 // Note I7 has leftover trash. Slow signature handler will fill it in | |
| 747 // should we get there. Normal jni call will set reasonable last_Java_pc | |
| 748 // below (and fix I7 so the stack trace doesn't have a meaningless frame | |
| 749 // in it). | |
| 750 | |
| 751 | |
| 752 // call signature handler | |
| 753 __ ld_ptr(STATE(_method), Lmethod); | |
| 754 __ ld_ptr(STATE(_locals), Llocals); | |
| 755 | |
| 756 __ callr(G3_scratch, 0); | |
| 757 __ delayed()->nop(); | |
| 758 __ ld_ptr(STATE(_thread), G2_thread); // restore thread (shouldn't be needed) | |
| 759 | |
| 760 { Label not_static; | |
| 761 | |
| 762 __ ld_ptr(STATE(_method), G5_method); | |
| 763 __ ld(access_flags, O0); | |
| 764 __ btst(JVM_ACC_STATIC, O0); | |
| 765 __ br( Assembler::zero, false, Assembler::pt, not_static); | |
| 766 __ delayed()-> | |
| 767 // get native function entry point(O0 is a good temp until the very end) | |
| 768 ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::native_function_offset())), O0); | |
| 769 // for static methods insert the mirror argument | |
| 770 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes(); | |
| 771 | |
| 772 __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc:: constants_offset())), O1); | |
| 773 __ ld_ptr(Address(O1, 0, constantPoolOopDesc::pool_holder_offset_in_bytes()), O1); | |
| 774 __ ld_ptr(O1, mirror_offset, O1); | |
| 775 // where the mirror handle body is allocated: | |
| 776 #ifdef ASSERT | |
| 777 if (!PrintSignatureHandlers) // do not dirty the output with this | |
| 778 { Label L; | |
| 779 __ tst(O1); | |
| 780 __ brx(Assembler::notZero, false, Assembler::pt, L); | |
| 781 __ delayed()->nop(); | |
| 782 __ stop("mirror is missing"); | |
| 783 __ bind(L); | |
| 784 } | |
| 785 #endif // ASSERT | |
| 786 __ st_ptr(O1, STATE(_oop_temp)); | |
| 787 __ add(STATE(_oop_temp), O1); // this is really an LEA not an add | |
| 788 __ bind(not_static); | |
| 789 } | |
| 790 | |
| 791 // At this point, arguments have been copied off of stack into | |
| 792 // their JNI positions, which are O1..O5 and SP[68..]. | |
| 793 // Oops are boxed in-place on the stack, with handles copied to arguments. | |
| 794 // The result handler is in Lscratch. O0 will shortly hold the JNIEnv*. | |
| 795 | |
| 796 #ifdef ASSERT | |
| 797 { Label L; | |
| 798 __ tst(O0); | |
| 799 __ brx(Assembler::notZero, false, Assembler::pt, L); | |
| 800 __ delayed()->nop(); | |
| 801 __ stop("native entry point is missing"); | |
| 802 __ bind(L); | |
| 803 } | |
| 804 #endif // ASSERT | |
| 805 | |
| 806 // | |
| 807 // setup the java frame anchor | |
| 808 // | |
| 809 // The scavenge function only needs to know that the PC of this frame is | |
| 810 // in the interpreter method entry code, it doesn't need to know the exact | |
| 811 // PC and hence we can use O7 which points to the return address from the | |
| 812 // previous call in the code stream (signature handler function) | |
| 813 // | |
| 814 // The other trick is we set last_Java_sp to FP instead of the usual SP because | |
| 815 // we have pushed the extra frame in order to protect the volatile register(s) | |
| 816 // in that frame when we return from the jni call | |
| 817 // | |
| 818 | |
| 819 | |
| 820 __ set_last_Java_frame(FP, O7); | |
| 821 __ mov(O7, I7); // make dummy interpreter frame look like one above, | |
| 822 // not meaningless information that'll confuse me. | |
| 823 | |
| 824 // flush the windows now. We don't care about the current (protection) frame | |
| 825 // only the outer frames | |
| 826 | |
| 827 __ flush_windows(); | |
| 828 | |
| 829 // mark windows as flushed | |
| 830 Address flags(G2_thread, | |
| 831 0, | |
| 832 in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::flags_offset())); | |
| 833 __ set(JavaFrameAnchor::flushed, G3_scratch); | |
| 834 __ st(G3_scratch, flags); | |
| 835 | |
| 836 // Transition from _thread_in_Java to _thread_in_native. We are already safepoint ready. | |
| 837 | |
| 838 Address thread_state(G2_thread, 0, in_bytes(JavaThread::thread_state_offset())); | |
| 839 #ifdef ASSERT | |
| 840 { Label L; | |
| 841 __ ld(thread_state, G3_scratch); | |
| 842 __ cmp(G3_scratch, _thread_in_Java); | |
| 843 __ br(Assembler::equal, false, Assembler::pt, L); | |
| 844 __ delayed()->nop(); | |
| 845 __ stop("Wrong thread state in native stub"); | |
| 846 __ bind(L); | |
| 847 } | |
| 848 #endif // ASSERT | |
| 849 __ set(_thread_in_native, G3_scratch); | |
| 850 __ st(G3_scratch, thread_state); | |
| 851 | |
| 852 // Call the jni method, using the delay slot to set the JNIEnv* argument. | |
| 853 __ callr(O0, 0); | |
| 854 __ delayed()-> | |
| 855 add(G2_thread, in_bytes(JavaThread::jni_environment_offset()), O0); | |
| 856 __ ld_ptr(STATE(_thread), G2_thread); // restore thread | |
| 857 | |
| 858 // must we block? | |
| 859 | |
| 860 // Block, if necessary, before resuming in _thread_in_Java state. | |
| 861 // In order for GC to work, don't clear the last_Java_sp until after blocking. | |
| 862 { Label no_block; | |
| 863 Address sync_state(G3_scratch, SafepointSynchronize::address_of_state()); | |
| 864 | |
| 865 // Switch thread to "native transition" state before reading the synchronization state. | |
| 866 // This additional state is necessary because reading and testing the synchronization | |
| 867 // state is not atomic w.r.t. GC, as this scenario demonstrates: | |
| 868 // Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted. | |
| 869 // VM thread changes sync state to synchronizing and suspends threads for GC. | |
| 870 // Thread A is resumed to finish this native method, but doesn't block here since it | |
| 871 // didn't see any synchronization is progress, and escapes. | |
| 872 __ set(_thread_in_native_trans, G3_scratch); | |
| 873 __ st(G3_scratch, thread_state); | |
| 874 if(os::is_MP()) { | |
| 875 // Write serialization page so VM thread can do a pseudo remote membar. | |
| 876 // We use the current thread pointer to calculate a thread specific | |
| 877 // offset to write to within the page. This minimizes bus traffic | |
| 878 // due to cache line collision. | |
| 879 __ serialize_memory(G2_thread, G1_scratch, G3_scratch); | |
| 880 } | |
| 881 __ load_contents(sync_state, G3_scratch); | |
| 882 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized); | |
| 883 | |
| 884 | |
| 885 Label L; | |
| 886 Address suspend_state(G2_thread, 0, in_bytes(JavaThread::suspend_flags_offset())); | |
| 887 __ br(Assembler::notEqual, false, Assembler::pn, L); | |
| 888 __ delayed()-> | |
| 889 ld(suspend_state, G3_scratch); | |
| 890 __ cmp(G3_scratch, 0); | |
| 891 __ br(Assembler::equal, false, Assembler::pt, no_block); | |
| 892 __ delayed()->nop(); | |
| 893 __ bind(L); | |
| 894 | |
| 895 // Block. Save any potential method result value before the operation and | |
| 896 // use a leaf call to leave the last_Java_frame setup undisturbed. | |
| 897 save_native_result(); | |
| 898 __ call_VM_leaf(noreg, | |
| 899 CAST_FROM_FN_PTR(address, JavaThread::check_safepoint_and_suspend_for_native_trans), | |
| 900 G2_thread); | |
| 901 __ ld_ptr(STATE(_thread), G2_thread); // restore thread | |
| 902 // Restore any method result value | |
| 903 restore_native_result(); | |
| 904 __ bind(no_block); | |
| 905 } | |
| 906 | |
| 907 // Clear the frame anchor now | |
| 908 | |
| 909 __ reset_last_Java_frame(); | |
| 910 | |
| 911 // Move the result handler address | |
| 912 __ mov(Lscratch, G3_scratch); | |
| 913 // return possible result to the outer frame | |
| 914 #ifndef __LP64 | |
| 915 __ mov(O0, I0); | |
| 916 __ restore(O1, G0, O1); | |
| 917 #else | |
| 918 __ restore(O0, G0, O0); | |
| 919 #endif /* __LP64 */ | |
| 920 | |
| 921 // Move result handler to expected register | |
| 922 __ mov(G3_scratch, Lscratch); | |
| 923 | |
| 924 | |
| 925 // thread state is thread_in_native_trans. Any safepoint blocking has | |
| 926 // happened in the trampoline we are ready to switch to thread_in_Java. | |
| 927 | |
| 928 __ set(_thread_in_Java, G3_scratch); | |
| 929 __ st(G3_scratch, thread_state); | |
| 930 | |
| 931 // If we have an oop result store it where it will be safe for any further gc | |
| 932 // until we return now that we've released the handle it might be protected by | |
| 933 | |
| 934 { | |
| 935 Label no_oop, store_result; | |
| 936 | |
| 937 __ set((intptr_t)AbstractInterpreter::result_handler(T_OBJECT), G3_scratch); | |
| 938 __ cmp(G3_scratch, Lscratch); | |
| 939 __ brx(Assembler::notEqual, false, Assembler::pt, no_oop); | |
| 940 __ delayed()->nop(); | |
| 941 __ addcc(G0, O0, O0); | |
| 942 __ brx(Assembler::notZero, true, Assembler::pt, store_result); // if result is not NULL: | |
| 943 __ delayed()->ld_ptr(O0, 0, O0); // unbox it | |
| 944 __ mov(G0, O0); | |
| 945 | |
| 946 __ bind(store_result); | |
| 947 // Store it where gc will look for it and result handler expects it. | |
| 948 __ st_ptr(O0, STATE(_oop_temp)); | |
| 949 | |
| 950 __ bind(no_oop); | |
| 951 | |
| 952 } | |
| 953 | |
| 954 // reset handle block | |
| 955 __ ld_ptr(G2_thread, in_bytes(JavaThread::active_handles_offset()), G3_scratch); | |
| 956 __ st_ptr(G0, G3_scratch, JNIHandleBlock::top_offset_in_bytes()); | |
| 957 | |
| 958 | |
| 959 // handle exceptions (exception handling will handle unlocking!) | |
| 960 { Label L; | |
| 961 Address exception_addr (G2_thread, 0, in_bytes(Thread::pending_exception_offset())); | |
| 962 | |
| 963 __ ld_ptr(exception_addr, Gtemp); | |
| 964 __ tst(Gtemp); | |
| 965 __ brx(Assembler::equal, false, Assembler::pt, L); | |
| 966 __ delayed()->nop(); | |
| 967 __ bind(pending_exception_present); | |
| 968 // With c++ interpreter we just leave it pending caller will do the correct thing. However... | |
| 969 // Like x86 we ignore the result of the native call and leave the method locked. This | |
| 970 // seems wrong to leave things locked. | |
| 971 | |
| 972 __ br(Assembler::always, false, Assembler::pt, StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type); | |
| 973 __ delayed()->restore(I5_savedSP, G0, SP); // remove interpreter frame | |
| 974 | |
| 975 __ bind(L); | |
| 976 } | |
| 977 | |
| 978 // jvmdi/jvmpi support (preserves thread register) | |
| 979 __ notify_method_exit(true, ilgl, InterpreterMacroAssembler::NotifyJVMTI); | |
| 980 | |
| 981 if (synchronized) { | |
| 982 // save and restore any potential method result value around the unlocking operation | |
| 983 save_native_result(); | |
| 984 | |
| 985 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 986 // Get the initial monitor we allocated | |
| 987 __ sub(Lstate, entry_size, O1); // initial monitor | |
| 988 __ unlock_object(O1); | |
| 989 restore_native_result(); | |
| 990 } | |
| 991 | |
| 992 #if defined(COMPILER2) && !defined(_LP64) | |
| 993 | |
| 994 // C2 expects long results in G1 we can't tell if we're returning to interpreted | |
| 995 // or compiled so just be safe. | |
| 996 | |
| 997 __ sllx(O0, 32, G1); // Shift bits into high G1 | |
| 998 __ srl (O1, 0, O1); // Zero extend O1 | |
| 999 __ or3 (O1, G1, G1); // OR 64 bits into G1 | |
| 1000 | |
| 1001 #endif /* COMPILER2 && !_LP64 */ | |
| 1002 | |
| 1003 #ifdef ASSERT | |
| 1004 { | |
| 1005 Label ok; | |
| 1006 __ cmp(I5_savedSP, FP); | |
| 1007 __ brx(Assembler::greaterEqualUnsigned, false, Assembler::pt, ok); | |
| 1008 __ delayed()->nop(); | |
| 1009 __ stop("bad I5_savedSP value"); | |
| 1010 __ should_not_reach_here(); | |
| 1011 __ bind(ok); | |
| 1012 } | |
| 1013 #endif | |
| 1014 // Calls result handler which POPS FRAME | |
| 1015 if (TraceJumps) { | |
| 1016 // Move target to register that is recordable | |
| 1017 __ mov(Lscratch, G3_scratch); | |
| 1018 __ JMP(G3_scratch, 0); | |
| 1019 } else { | |
| 1020 __ jmp(Lscratch, 0); | |
| 1021 } | |
| 1022 __ delayed()->nop(); | |
| 1023 | |
| 1024 if (inc_counter) { | |
| 1025 // handle invocation counter overflow | |
| 1026 __ bind(invocation_counter_overflow); | |
| 1027 generate_counter_overflow(Lcontinue); | |
| 1028 } | |
| 1029 | |
| 1030 | |
| 1031 return entry; | |
| 1032 } | |
| 1033 | |
| 1034 void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state, | |
| 1035 const Register prev_state, | |
| 1036 bool native) { | |
| 1037 | |
| 1038 // On entry | |
| 1039 // G5_method - caller's method | |
| 1040 // Gargs - points to initial parameters (i.e. locals[0]) | |
| 1041 // G2_thread - valid? (C1 only??) | |
| 1042 // "prev_state" - contains any previous frame manager state which we must save a link | |
| 1043 // | |
| 1044 // On return | |
| 1045 // "state" is a pointer to the newly allocated state object. We must allocate and initialize | |
| 1046 // a new interpretState object and the method expression stack. | |
| 1047 | |
| 1048 assert_different_registers(state, prev_state); | |
| 1049 assert_different_registers(prev_state, G3_scratch); | |
| 1050 const Register Gtmp = G3_scratch; | |
| 1051 const Address constants (G5_method, 0, in_bytes(methodOopDesc::constants_offset())); | |
| 1052 const Address access_flags (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset())); | |
| 1053 const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())); | |
| 1054 const Address max_stack (G5_method, 0, in_bytes(methodOopDesc::max_stack_offset())); | |
| 1055 const Address size_of_locals (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset())); | |
| 1056 | |
| 1057 // slop factor is two extra slots on the expression stack so that | |
| 1058 // we always have room to store a result when returning from a call without parameters | |
| 1059 // that returns a result. | |
| 1060 | |
| 1061 const int slop_factor = 2*wordSize; | |
| 1062 | |
| 1063 const int fixed_size = ((sizeof(BytecodeInterpreter) + slop_factor) >> LogBytesPerWord) + // what is the slop factor? | |
| 710 | 1064 //6815692//methodOopDesc::extra_stack_words() + // extra push slots for MH adapters |
| 0 | 1065 frame::memory_parameter_word_sp_offset + // register save area + param window |
| 1066 (native ? frame::interpreter_frame_extra_outgoing_argument_words : 0); // JNI, class | |
| 1067 | |
| 1068 // XXX G5_method valid | |
| 1069 | |
| 1070 // Now compute new frame size | |
| 1071 | |
| 1072 if (native) { | |
| 1073 __ lduh( size_of_parameters, Gtmp ); | |
| 1074 __ calc_mem_param_words(Gtmp, Gtmp); // space for native call parameters passed on the stack in words | |
| 1075 } else { | |
| 1076 __ lduh(max_stack, Gtmp); // Full size expression stack | |
| 1077 } | |
| 1078 __ add(Gtmp, fixed_size, Gtmp); // plus the fixed portion | |
| 1079 | |
| 1080 __ neg(Gtmp); // negative space for stack/parameters in words | |
| 1081 __ and3(Gtmp, -WordsPerLong, Gtmp); // make multiple of 2 (SP must be 2-word aligned) | |
| 1082 __ sll(Gtmp, LogBytesPerWord, Gtmp); // negative space for frame in bytes | |
| 1083 | |
| 1084 // Need to do stack size check here before we fault on large frames | |
| 1085 | |
| 1086 Label stack_ok; | |
| 1087 | |
| 1088 const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages : | |
| 1089 (StackRedPages+StackYellowPages); | |
| 1090 | |
| 1091 | |
| 1092 __ ld_ptr(G2_thread, in_bytes(Thread::stack_base_offset()), O0); | |
| 1093 __ ld_ptr(G2_thread, in_bytes(Thread::stack_size_offset()), O1); | |
| 1094 // compute stack bottom | |
| 1095 __ sub(O0, O1, O0); | |
| 1096 | |
| 1097 // Avoid touching the guard pages | |
| 1098 // Also a fudge for frame size of BytecodeInterpreter::run | |
| 1099 // It varies from 1k->4k depending on build type | |
| 1100 const int fudge = 6 * K; | |
| 1101 | |
| 1102 __ set(fudge + (max_pages * os::vm_page_size()), O1); | |
| 1103 | |
| 1104 __ add(O0, O1, O0); | |
| 1105 __ sub(O0, Gtmp, O0); | |
| 1106 __ cmp(SP, O0); | |
| 1107 __ brx(Assembler::greaterUnsigned, false, Assembler::pt, stack_ok); | |
| 1108 __ delayed()->nop(); | |
| 1109 | |
| 1110 // throw exception return address becomes throwing pc | |
| 1111 | |
| 1112 __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError)); | |
| 1113 __ stop("never reached"); | |
| 1114 | |
| 1115 __ bind(stack_ok); | |
| 1116 | |
| 1117 __ save(SP, Gtmp, SP); // setup new frame and register window | |
| 1118 | |
| 1119 // New window I7 call_stub or previous activation | |
| 1120 // O6 - register save area, BytecodeInterpreter just below it, args/locals just above that | |
| 1121 // | |
| 1122 __ sub(FP, sizeof(BytecodeInterpreter), state); // Point to new Interpreter state | |
| 1123 __ add(state, STACK_BIAS, state ); // Account for 64bit bias | |
| 1124 | |
| 1125 #define XXX_STATE(field_name) state, in_bytes(byte_offset_of(BytecodeInterpreter, field_name)) | |
| 1126 | |
| 1127 // Initialize a new Interpreter state | |
| 1128 // orig_sp - caller's original sp | |
| 1129 // G2_thread - thread | |
| 1130 // Gargs - &locals[0] (unbiased?) | |
| 1131 // G5_method - method | |
| 1132 // SP (biased) - accounts for full size java stack, BytecodeInterpreter object, register save area, and register parameter save window | |
| 1133 | |
| 1134 | |
| 1135 __ set(0xdead0004, O1); | |
| 1136 | |
| 1137 | |
| 1138 __ st_ptr(Gargs, XXX_STATE(_locals)); | |
| 1139 __ st_ptr(G0, XXX_STATE(_oop_temp)); | |
| 1140 | |
| 1141 __ st_ptr(state, XXX_STATE(_self_link)); // point to self | |
| 1142 __ st_ptr(prev_state->after_save(), XXX_STATE(_prev_link)); // Chain interpreter states | |
| 1143 __ st_ptr(G2_thread, XXX_STATE(_thread)); // Store javathread | |
| 1144 | |
| 1145 if (native) { | |
| 1146 __ st_ptr(G0, XXX_STATE(_bcp)); | |
| 1147 } else { | |
| 1148 __ ld_ptr(G5_method, in_bytes(methodOopDesc::const_offset()), O2); // get constMethodOop | |
| 1149 __ add(O2, in_bytes(constMethodOopDesc::codes_offset()), O2); // get bcp | |
| 1150 __ st_ptr(O2, XXX_STATE(_bcp)); | |
| 1151 } | |
| 1152 | |
| 1153 __ st_ptr(G0, XXX_STATE(_mdx)); | |
| 1154 __ st_ptr(G5_method, XXX_STATE(_method)); | |
| 1155 | |
| 1156 __ set((int) BytecodeInterpreter::method_entry, O1); | |
| 1157 __ st(O1, XXX_STATE(_msg)); | |
| 1158 | |
| 1159 __ ld_ptr(constants, O3); | |
| 1160 __ ld_ptr(O3, constantPoolOopDesc::cache_offset_in_bytes(), O2); | |
| 1161 __ st_ptr(O2, XXX_STATE(_constants)); | |
| 1162 | |
| 1163 __ st_ptr(G0, XXX_STATE(_result._to_call._callee)); | |
| 1164 | |
| 1165 // Monitor base is just start of BytecodeInterpreter object; | |
| 1166 __ mov(state, O2); | |
| 1167 __ st_ptr(O2, XXX_STATE(_monitor_base)); | |
| 1168 | |
| 1169 // Do we need a monitor for synchonized method? | |
| 1170 { | |
| 1171 __ ld(access_flags, O1); | |
| 1172 Label done; | |
| 1173 Label got_obj; | |
| 1174 __ btst(JVM_ACC_SYNCHRONIZED, O1); | |
| 1175 __ br( Assembler::zero, false, Assembler::pt, done); | |
| 1176 | |
| 1177 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes(); | |
| 1178 __ delayed()->btst(JVM_ACC_STATIC, O1); | |
| 1179 __ ld_ptr(XXX_STATE(_locals), O1); | |
| 1180 __ br( Assembler::zero, true, Assembler::pt, got_obj); | |
| 1181 __ delayed()->ld_ptr(O1, 0, O1); // get receiver for not-static case | |
| 1182 __ ld_ptr(constants, O1); | |
| 1183 __ ld_ptr( O1, constantPoolOopDesc::pool_holder_offset_in_bytes(), O1); | |
| 1184 // lock the mirror, not the klassOop | |
| 1185 __ ld_ptr( O1, mirror_offset, O1); | |
| 1186 | |
| 1187 __ bind(got_obj); | |
| 1188 | |
| 1189 #ifdef ASSERT | |
| 1190 __ tst(O1); | |
| 1191 __ breakpoint_trap(Assembler::zero); | |
| 1192 #endif // ASSERT | |
| 1193 | |
| 1194 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 1195 __ sub(SP, entry_size, SP); // account for initial monitor | |
| 1196 __ sub(O2, entry_size, O2); // initial monitor | |
| 1197 __ st_ptr(O1, O2, BasicObjectLock::obj_offset_in_bytes()); // and allocate it for interpreter use | |
| 1198 __ bind(done); | |
| 1199 } | |
| 1200 | |
| 1201 // Remember initial frame bottom | |
| 1202 | |
| 1203 __ st_ptr(SP, XXX_STATE(_frame_bottom)); | |
| 1204 | |
| 1205 __ st_ptr(O2, XXX_STATE(_stack_base)); | |
| 1206 | |
| 1207 __ sub(O2, wordSize, O2); // prepush | |
| 1208 __ st_ptr(O2, XXX_STATE(_stack)); // PREPUSH | |
| 1209 | |
| 1210 __ lduh(max_stack, O3); // Full size expression stack | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
1972
diff
changeset
|
1211 guarantee(!EnableMethodHandles, "no support yet for java.lang.invoke.MethodHandle"); //6815692 |
| 710 | 1212 //6815692//if (EnableMethodHandles) |
| 1213 //6815692// __ inc(O3, methodOopDesc::extra_stack_entries()); | |
| 0 | 1214 __ sll(O3, LogBytesPerWord, O3); |
| 1215 __ sub(O2, O3, O3); | |
| 1216 // __ sub(O3, wordSize, O3); // so prepush doesn't look out of bounds | |
| 1217 __ st_ptr(O3, XXX_STATE(_stack_limit)); | |
| 1218 | |
| 1219 if (!native) { | |
| 1220 // | |
| 1221 // Code to initialize locals | |
| 1222 // | |
| 1223 Register init_value = noreg; // will be G0 if we must clear locals | |
| 1224 // Now zero locals | |
| 1225 if (true /* zerolocals */ || ClearInterpreterLocals) { | |
| 1226 // explicitly initialize locals | |
| 1227 init_value = G0; | |
| 1228 } else { | |
| 1229 #ifdef ASSERT | |
| 1230 // initialize locals to a garbage pattern for better debugging | |
| 1231 init_value = O3; | |
| 1232 __ set( 0x0F0F0F0F, init_value ); | |
| 1233 #endif // ASSERT | |
| 1234 } | |
| 1235 if (init_value != noreg) { | |
| 1236 Label clear_loop; | |
| 1237 | |
| 1238 // NOTE: If you change the frame layout, this code will need to | |
| 1239 // be updated! | |
| 1240 __ lduh( size_of_locals, O2 ); | |
| 1241 __ lduh( size_of_parameters, O1 ); | |
| 1242 __ sll( O2, LogBytesPerWord, O2); | |
| 1243 __ sll( O1, LogBytesPerWord, O1 ); | |
| 1244 __ ld_ptr(XXX_STATE(_locals), L2_scratch); | |
| 1245 __ sub( L2_scratch, O2, O2 ); | |
| 1246 __ sub( L2_scratch, O1, O1 ); | |
| 1247 | |
| 1248 __ bind( clear_loop ); | |
| 1249 __ inc( O2, wordSize ); | |
| 1250 | |
| 1251 __ cmp( O2, O1 ); | |
| 1252 __ br( Assembler::lessEqualUnsigned, true, Assembler::pt, clear_loop ); | |
| 1253 __ delayed()->st_ptr( init_value, O2, 0 ); | |
| 1254 } | |
| 1255 } | |
| 1256 } | |
| 1257 // Find preallocated monitor and lock method (C++ interpreter) | |
| 1258 // | |
| 1259 void InterpreterGenerator::lock_method(void) { | |
| 1260 // Lock the current method. | |
| 1261 // Destroys registers L2_scratch, L3_scratch, O0 | |
| 1262 // | |
| 1263 // Find everything relative to Lstate | |
| 1264 | |
| 1265 #ifdef ASSERT | |
| 1266 __ ld_ptr(STATE(_method), L2_scratch); | |
| 1267 __ ld(L2_scratch, in_bytes(methodOopDesc::access_flags_offset()), O0); | |
| 1268 | |
| 1269 { Label ok; | |
| 1270 __ btst(JVM_ACC_SYNCHRONIZED, O0); | |
| 1271 __ br( Assembler::notZero, false, Assembler::pt, ok); | |
| 1272 __ delayed()->nop(); | |
| 1273 __ stop("method doesn't need synchronization"); | |
| 1274 __ bind(ok); | |
| 1275 } | |
| 1276 #endif // ASSERT | |
| 1277 | |
| 1278 // monitor is already allocated at stack base | |
| 1279 // and the lockee is already present | |
| 1280 __ ld_ptr(STATE(_stack_base), L2_scratch); | |
| 1281 __ ld_ptr(L2_scratch, BasicObjectLock::obj_offset_in_bytes(), O0); // get object | |
| 1282 __ lock_object(L2_scratch, O0); | |
| 1283 | |
| 1284 } | |
| 1285 | |
| 1286 // Generate code for handling resuming a deopted method | |
| 1287 void CppInterpreterGenerator::generate_deopt_handling() { | |
| 1288 | |
| 1289 Label return_from_deopt_common; | |
| 1290 | |
| 1291 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1292 deopt_frame_manager_return_atos = __ pc(); | |
| 1293 | |
| 1294 // O0/O1 live | |
| 1295 __ ba(false, return_from_deopt_common); | |
| 1296 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_OBJECT), L3_scratch); // Result stub address array index | |
| 1297 | |
| 1298 | |
| 1299 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1300 deopt_frame_manager_return_btos = __ pc(); | |
| 1301 | |
| 1302 // O0/O1 live | |
| 1303 __ ba(false, return_from_deopt_common); | |
| 1304 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_BOOLEAN), L3_scratch); // Result stub address array index | |
| 1305 | |
| 1306 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1307 deopt_frame_manager_return_itos = __ pc(); | |
| 1308 | |
| 1309 // O0/O1 live | |
| 1310 __ ba(false, return_from_deopt_common); | |
| 1311 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_INT), L3_scratch); // Result stub address array index | |
| 1312 | |
| 1313 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1314 | |
| 1315 deopt_frame_manager_return_ltos = __ pc(); | |
| 1316 #if !defined(_LP64) && defined(COMPILER2) | |
| 1317 // All return values are where we want them, except for Longs. C2 returns | |
| 1318 // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1. | |
| 1319 // Since the interpreter will return longs in G1 and O0/O1 in the 32bit | |
| 1320 // build even if we are returning from interpreted we just do a little | |
| 1321 // stupid shuffing. | |
| 1322 // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to | |
| 1323 // do this here. Unfortunately if we did a rethrow we'd see an machepilog node | |
| 1324 // first which would move g1 -> O0/O1 and destroy the exception we were throwing. | |
| 1325 | |
| 1326 __ srl (G1, 0,O1); | |
| 1327 __ srlx(G1,32,O0); | |
| 1328 #endif /* !_LP64 && COMPILER2 */ | |
| 1329 // O0/O1 live | |
| 1330 __ ba(false, return_from_deopt_common); | |
| 1331 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_LONG), L3_scratch); // Result stub address array index | |
| 1332 | |
| 1333 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1334 | |
| 1335 deopt_frame_manager_return_ftos = __ pc(); | |
| 1336 // O0/O1 live | |
| 1337 __ ba(false, return_from_deopt_common); | |
| 1338 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_FLOAT), L3_scratch); // Result stub address array index | |
| 1339 | |
| 1340 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1341 deopt_frame_manager_return_dtos = __ pc(); | |
| 1342 | |
| 1343 // O0/O1 live | |
| 1344 __ ba(false, return_from_deopt_common); | |
| 1345 __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_DOUBLE), L3_scratch); // Result stub address array index | |
| 1346 | |
| 1347 // deopt needs to jump to here to enter the interpreter (return a result) | |
| 1348 deopt_frame_manager_return_vtos = __ pc(); | |
| 1349 | |
| 1350 // O0/O1 live | |
| 1351 __ set(AbstractInterpreter::BasicType_as_index(T_VOID), L3_scratch); | |
| 1352 | |
| 1353 // Deopt return common | |
| 1354 // an index is present that lets us move any possible result being | |
| 1355 // return to the interpreter's stack | |
| 1356 // | |
| 1357 __ bind(return_from_deopt_common); | |
| 1358 | |
| 1359 // Result if any is in native abi result (O0..O1/F0..F1). The java expression | |
| 1360 // stack is in the state that the calling convention left it. | |
| 1361 // Copy the result from native abi result and place it on java expression stack. | |
| 1362 | |
| 1363 // Current interpreter state is present in Lstate | |
| 1364 | |
| 1365 // Get current pre-pushed top of interpreter stack | |
| 1366 // Any result (if any) is in native abi | |
| 1367 // result type index is in L3_scratch | |
| 1368 | |
| 1369 __ ld_ptr(STATE(_stack), L1_scratch); // get top of java expr stack | |
| 1370 | |
| 1371 __ set((intptr_t)CppInterpreter::_tosca_to_stack, L4_scratch); | |
| 1372 __ sll(L3_scratch, LogBytesPerWord, L3_scratch); | |
| 1373 __ ld_ptr(L4_scratch, L3_scratch, Lscratch); // get typed result converter address | |
| 1374 __ jmpl(Lscratch, G0, O7); // and convert it | |
| 1375 __ delayed()->nop(); | |
| 1376 | |
| 1377 // L1_scratch points to top of stack (prepushed) | |
| 1378 __ st_ptr(L1_scratch, STATE(_stack)); | |
| 1379 } | |
| 1380 | |
| 1381 // Generate the code to handle a more_monitors message from the c++ interpreter | |
| 1382 void CppInterpreterGenerator::generate_more_monitors() { | |
| 1383 | |
| 1384 Label entry, loop; | |
| 1385 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 1386 // 1. compute new pointers // esp: old expression stack top | |
| 1387 __ delayed()->ld_ptr(STATE(_stack_base), L4_scratch); // current expression stack bottom | |
| 1388 __ sub(L4_scratch, entry_size, L4_scratch); | |
| 1389 __ st_ptr(L4_scratch, STATE(_stack_base)); | |
| 1390 | |
| 1391 __ sub(SP, entry_size, SP); // Grow stack | |
| 1392 __ st_ptr(SP, STATE(_frame_bottom)); | |
| 1393 | |
| 1394 __ ld_ptr(STATE(_stack_limit), L2_scratch); | |
| 1395 __ sub(L2_scratch, entry_size, L2_scratch); | |
| 1396 __ st_ptr(L2_scratch, STATE(_stack_limit)); | |
| 1397 | |
| 1398 __ ld_ptr(STATE(_stack), L1_scratch); // Get current stack top | |
| 1399 __ sub(L1_scratch, entry_size, L1_scratch); | |
| 1400 __ st_ptr(L1_scratch, STATE(_stack)); | |
| 1401 __ ba(false, entry); | |
| 1402 __ delayed()->add(L1_scratch, wordSize, L1_scratch); // first real entry (undo prepush) | |
| 1403 | |
| 1404 // 2. move expression stack | |
| 1405 | |
| 1406 __ bind(loop); | |
| 1407 __ st_ptr(L3_scratch, Address(L1_scratch, 0)); | |
| 1408 __ add(L1_scratch, wordSize, L1_scratch); | |
| 1409 __ bind(entry); | |
| 1410 __ cmp(L1_scratch, L4_scratch); | |
| 1411 __ br(Assembler::notEqual, false, Assembler::pt, loop); | |
| 1412 __ delayed()->ld_ptr(L1_scratch, entry_size, L3_scratch); | |
| 1413 | |
| 1414 // now zero the slot so we can find it. | |
| 123 | 1415 __ st_ptr(G0, L4_scratch, BasicObjectLock::obj_offset_in_bytes()); |
| 0 | 1416 |
| 1417 } | |
| 1418 | |
| 1419 // Initial entry to C++ interpreter from the call_stub. | |
| 1420 // This entry point is called the frame manager since it handles the generation | |
| 1421 // of interpreter activation frames via requests directly from the vm (via call_stub) | |
| 1422 // and via requests from the interpreter. The requests from the call_stub happen | |
| 1423 // directly thru the entry point. Requests from the interpreter happen via returning | |
| 1424 // from the interpreter and examining the message the interpreter has returned to | |
| 1425 // the frame manager. The frame manager can take the following requests: | |
| 1426 | |
| 1427 // NO_REQUEST - error, should never happen. | |
| 1428 // MORE_MONITORS - need a new monitor. Shuffle the expression stack on down and | |
| 1429 // allocate a new monitor. | |
| 1430 // CALL_METHOD - setup a new activation to call a new method. Very similar to what | |
| 1431 // happens during entry during the entry via the call stub. | |
| 1432 // RETURN_FROM_METHOD - remove an activation. Return to interpreter or call stub. | |
| 1433 // | |
| 1434 // Arguments: | |
| 1435 // | |
| 1436 // ebx: methodOop | |
| 1437 // ecx: receiver - unused (retrieved from stack as needed) | |
| 1438 // esi: previous frame manager state (NULL from the call_stub/c1/c2) | |
| 1439 // | |
| 1440 // | |
| 1441 // Stack layout at entry | |
| 1442 // | |
| 1443 // [ return address ] <--- esp | |
| 1444 // [ parameter n ] | |
| 1445 // ... | |
| 1446 // [ parameter 1 ] | |
| 1447 // [ expression stack ] | |
| 1448 // | |
| 1449 // | |
| 1450 // We are free to blow any registers we like because the call_stub which brought us here | |
| 1451 // initially has preserved the callee save registers already. | |
| 1452 // | |
| 1453 // | |
| 1454 | |
| 1455 static address interpreter_frame_manager = NULL; | |
| 1456 | |
| 1457 #ifdef ASSERT | |
| 1458 #define VALIDATE_STATE(scratch, marker) \ | |
| 1459 { \ | |
| 1460 Label skip; \ | |
| 1461 __ ld_ptr(STATE(_self_link), scratch); \ | |
| 1462 __ cmp(Lstate, scratch); \ | |
| 1463 __ brx(Assembler::equal, false, Assembler::pt, skip); \ | |
| 1464 __ delayed()->nop(); \ | |
| 1465 __ breakpoint_trap(); \ | |
| 1466 __ emit_long(marker); \ | |
| 1467 __ bind(skip); \ | |
| 1468 } | |
| 1469 #else | |
| 1470 #define VALIDATE_STATE(scratch, marker) | |
| 1471 #endif /* ASSERT */ | |
| 1472 | |
| 1473 void CppInterpreterGenerator::adjust_callers_stack(Register args) { | |
| 1474 // | |
| 1475 // Adjust caller's stack so that all the locals can be contiguous with | |
| 1476 // the parameters. | |
| 1477 // Worries about stack overflow make this a pain. | |
| 1478 // | |
| 1479 // Destroys args, G3_scratch, G3_scratch | |
| 1480 // In/Out O5_savedSP (sender's original SP) | |
| 1481 // | |
| 1482 // assert_different_registers(state, prev_state); | |
| 1483 const Register Gtmp = G3_scratch; | |
| 1484 const Register tmp = O2; | |
| 1485 const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())); | |
| 1486 const Address size_of_locals (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset())); | |
| 1487 | |
| 1488 __ lduh(size_of_parameters, tmp); | |
| 1489 __ sll(tmp, LogBytesPerWord, Gtmp); // parameter size in bytes | |
| 1490 __ add(args, Gtmp, Gargs); // points to first local + BytesPerWord | |
| 1491 // NEW | |
| 1492 __ add(Gargs, -wordSize, Gargs); // points to first local[0] | |
| 1493 // determine extra space for non-argument locals & adjust caller's SP | |
| 1494 // Gtmp1: parameter size in words | |
| 1495 __ lduh(size_of_locals, Gtmp); | |
| 1496 __ compute_extra_locals_size_in_bytes(tmp, Gtmp, Gtmp); | |
| 1497 | |
| 1498 #if 1 | |
| 1499 // c2i adapters place the final interpreter argument in the register save area for O0/I0 | |
| 1500 // the call_stub will place the final interpreter argument at | |
| 1501 // frame::memory_parameter_word_sp_offset. This is mostly not noticable for either asm | |
| 1502 // or c++ interpreter. However with the c++ interpreter when we do a recursive call | |
| 1503 // and try to make it look good in the debugger we will store the argument to | |
| 1504 // RecursiveInterpreterActivation in the register argument save area. Without allocating | |
| 1505 // extra space for the compiler this will overwrite locals in the local array of the | |
| 1506 // interpreter. | |
| 1507 // QQQ still needed with frameless adapters??? | |
| 1508 | |
| 1509 const int c2i_adjust_words = frame::memory_parameter_word_sp_offset - frame::callee_register_argument_save_area_sp_offset; | |
| 1510 | |
| 1511 __ add(Gtmp, c2i_adjust_words*wordSize, Gtmp); | |
| 1512 #endif // 1 | |
| 1513 | |
| 1514 | |
| 1515 __ sub(SP, Gtmp, SP); // just caller's frame for the additional space we need. | |
| 1516 } | |
| 1517 | |
| 1518 address InterpreterGenerator::generate_normal_entry(bool synchronized) { | |
| 1519 | |
| 1520 // G5_method: methodOop | |
| 1521 // G2_thread: thread (unused) | |
| 1522 // Gargs: bottom of args (sender_sp) | |
| 1523 // O5: sender's sp | |
| 1524 | |
| 1525 // A single frame manager is plenty as we don't specialize for synchronized. We could and | |
| 1526 // the code is pretty much ready. Would need to change the test below and for good measure | |
| 1527 // modify generate_interpreter_state to only do the (pre) sync stuff stuff for synchronized | |
| 1528 // routines. Not clear this is worth it yet. | |
| 1529 | |
| 1530 if (interpreter_frame_manager) { | |
| 1531 return interpreter_frame_manager; | |
| 1532 } | |
| 1533 | |
| 1534 __ bind(frame_manager_entry); | |
| 1535 | |
| 1536 // the following temporary registers are used during frame creation | |
| 1537 const Register Gtmp1 = G3_scratch; | |
| 1538 // const Register Lmirror = L1; // native mirror (native calls only) | |
| 1539 | |
| 1540 const Address constants (G5_method, 0, in_bytes(methodOopDesc::constants_offset())); | |
| 1541 const Address access_flags (G5_method, 0, in_bytes(methodOopDesc::access_flags_offset())); | |
| 1542 const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset())); | |
| 1543 const Address max_stack (G5_method, 0, in_bytes(methodOopDesc::max_stack_offset())); | |
| 1544 const Address size_of_locals (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset())); | |
| 1545 | |
| 1546 address entry_point = __ pc(); | |
| 1547 __ mov(G0, prevState); // no current activation | |
| 1548 | |
| 1549 | |
| 1550 Label re_dispatch; | |
| 1551 | |
| 1552 __ bind(re_dispatch); | |
| 1553 | |
| 1554 // Interpreter needs to have locals completely contiguous. In order to do that | |
| 1555 // We must adjust the caller's stack pointer for any locals beyond just the | |
| 1556 // parameters | |
| 1557 adjust_callers_stack(Gargs); | |
| 1558 | |
| 1559 // O5_savedSP still contains sender's sp | |
| 1560 | |
| 1561 // NEW FRAME | |
| 1562 | |
| 1563 generate_compute_interpreter_state(Lstate, prevState, false); | |
| 1564 | |
| 1565 // At this point a new interpreter frame and state object are created and initialized | |
| 1566 // Lstate has the pointer to the new activation | |
| 1567 // Any stack banging or limit check should already be done. | |
| 1568 | |
| 1569 Label call_interpreter; | |
| 1570 | |
| 1571 __ bind(call_interpreter); | |
| 1572 | |
| 1573 | |
| 1574 #if 1 | |
| 1575 __ set(0xdead002, Lmirror); | |
| 1576 __ set(0xdead002, L2_scratch); | |
| 1577 __ set(0xdead003, L3_scratch); | |
| 1578 __ set(0xdead004, L4_scratch); | |
| 1579 __ set(0xdead005, Lscratch); | |
| 1580 __ set(0xdead006, Lscratch2); | |
| 1581 __ set(0xdead007, L7_scratch); | |
| 1582 | |
| 1583 __ set(0xdeaf002, O2); | |
| 1584 __ set(0xdeaf003, O3); | |
| 1585 __ set(0xdeaf004, O4); | |
| 1586 __ set(0xdeaf005, O5); | |
| 1587 #endif | |
| 1588 | |
| 1589 // Call interpreter (stack bang complete) enter here if message is | |
| 1590 // set and we know stack size is valid | |
| 1591 | |
| 1592 Label call_interpreter_2; | |
| 1593 | |
| 1594 __ bind(call_interpreter_2); | |
| 1595 | |
| 1596 #ifdef ASSERT | |
| 1597 { | |
| 1598 Label skip; | |
| 1599 __ ld_ptr(STATE(_frame_bottom), G3_scratch); | |
| 1600 __ cmp(G3_scratch, SP); | |
| 1601 __ brx(Assembler::equal, false, Assembler::pt, skip); | |
| 1602 __ delayed()->nop(); | |
| 1603 __ stop("SP not restored to frame bottom"); | |
| 1604 __ bind(skip); | |
| 1605 } | |
| 1606 #endif | |
| 1607 | |
| 1608 VALIDATE_STATE(G3_scratch, 4); | |
| 1609 __ set_last_Java_frame(SP, noreg); | |
| 1610 __ mov(Lstate, O0); // (arg) pointer to current state | |
| 1611 | |
| 1612 __ call(CAST_FROM_FN_PTR(address, | |
| 1613 JvmtiExport::can_post_interpreter_events() ? | |
| 1614 BytecodeInterpreter::runWithChecks | |
| 1615 : BytecodeInterpreter::run), | |
| 1616 relocInfo::runtime_call_type); | |
| 1617 | |
| 1618 __ delayed()->nop(); | |
| 1619 | |
| 1620 __ ld_ptr(STATE(_thread), G2_thread); | |
| 1621 __ reset_last_Java_frame(); | |
| 1622 | |
| 1623 // examine msg from interpreter to determine next action | |
| 1624 __ ld_ptr(STATE(_thread), G2_thread); // restore G2_thread | |
| 1625 | |
| 1626 __ ld(STATE(_msg), L1_scratch); // Get new message | |
| 1627 | |
| 1628 Label call_method; | |
| 1629 Label return_from_interpreted_method; | |
| 1630 Label throw_exception; | |
| 1631 Label do_OSR; | |
| 1632 Label bad_msg; | |
| 1633 Label resume_interpreter; | |
| 1634 | |
| 1635 __ cmp(L1_scratch, (int)BytecodeInterpreter::call_method); | |
| 1636 __ br(Assembler::equal, false, Assembler::pt, call_method); | |
| 1637 __ delayed()->cmp(L1_scratch, (int)BytecodeInterpreter::return_from_method); | |
| 1638 __ br(Assembler::equal, false, Assembler::pt, return_from_interpreted_method); | |
| 1639 __ delayed()->cmp(L1_scratch, (int)BytecodeInterpreter::throwing_exception); | |
| 1640 __ br(Assembler::equal, false, Assembler::pt, throw_exception); | |
| 1641 __ delayed()->cmp(L1_scratch, (int)BytecodeInterpreter::do_osr); | |
| 1642 __ br(Assembler::equal, false, Assembler::pt, do_OSR); | |
| 1643 __ delayed()->cmp(L1_scratch, (int)BytecodeInterpreter::more_monitors); | |
| 1644 __ br(Assembler::notEqual, false, Assembler::pt, bad_msg); | |
| 1645 | |
| 1646 // Allocate more monitor space, shuffle expression stack.... | |
| 1647 | |
| 1648 generate_more_monitors(); | |
| 1649 | |
| 1650 // new monitor slot allocated, resume the interpreter. | |
| 1651 | |
| 1652 __ set((int)BytecodeInterpreter::got_monitors, L1_scratch); | |
| 1653 VALIDATE_STATE(G3_scratch, 5); | |
| 1654 __ ba(false, call_interpreter); | |
| 1655 __ delayed()->st(L1_scratch, STATE(_msg)); | |
| 1656 | |
| 1657 // uncommon trap needs to jump to here to enter the interpreter (re-execute current bytecode) | |
| 1658 unctrap_frame_manager_entry = __ pc(); | |
| 1659 | |
| 1660 // QQQ what message do we send | |
| 1661 | |
| 1662 __ ba(false, call_interpreter); | |
| 1663 __ delayed()->ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame | |
| 1664 | |
| 1665 //============================================================================= | |
| 1666 // Returning from a compiled method into a deopted method. The bytecode at the | |
| 1667 // bcp has completed. The result of the bytecode is in the native abi (the tosca | |
| 1668 // for the template based interpreter). Any stack space that was used by the | |
| 1669 // bytecode that has completed has been removed (e.g. parameters for an invoke) | |
| 1670 // so all that we have to do is place any pending result on the expression stack | |
| 1671 // and resume execution on the next bytecode. | |
| 1672 | |
| 1673 generate_deopt_handling(); | |
| 1674 | |
| 1675 // ready to resume the interpreter | |
| 1676 | |
| 1677 __ set((int)BytecodeInterpreter::deopt_resume, L1_scratch); | |
| 1678 __ ba(false, call_interpreter); | |
| 1679 __ delayed()->st(L1_scratch, STATE(_msg)); | |
| 1680 | |
| 1681 // Current frame has caught an exception we need to dispatch to the | |
| 1682 // handler. We can get here because a native interpreter frame caught | |
| 1683 // an exception in which case there is no handler and we must rethrow | |
| 1684 // If it is a vanilla interpreted frame the we simply drop into the | |
| 1685 // interpreter and let it do the lookup. | |
| 1686 | |
| 1687 Interpreter::_rethrow_exception_entry = __ pc(); | |
| 1688 | |
| 1689 Label return_with_exception; | |
| 1690 Label unwind_and_forward; | |
| 1691 | |
| 1692 // O0: exception | |
| 1693 // O7: throwing pc | |
| 1694 | |
| 1695 // We want exception in the thread no matter what we ultimately decide about frame type. | |
| 1696 | |
| 1697 Address exception_addr (G2_thread, 0, in_bytes(Thread::pending_exception_offset())); | |
| 1698 __ verify_thread(); | |
| 1699 __ st_ptr(O0, exception_addr); | |
| 1700 | |
| 1701 // get the methodOop | |
| 1702 __ ld_ptr(STATE(_method), G5_method); | |
| 1703 | |
| 1704 // if this current frame vanilla or native? | |
| 1705 | |
| 1706 __ ld(access_flags, Gtmp1); | |
| 1707 __ btst(JVM_ACC_NATIVE, Gtmp1); | |
| 1708 __ br(Assembler::zero, false, Assembler::pt, return_with_exception); // vanilla interpreted frame handle directly | |
| 1709 __ delayed()->nop(); | |
| 1710 | |
| 1711 // We drop thru to unwind a native interpreted frame with a pending exception | |
| 1712 // We jump here for the initial interpreter frame with exception pending | |
| 1713 // We unwind the current acivation and forward it to our caller. | |
| 1714 | |
| 1715 __ bind(unwind_and_forward); | |
| 1716 | |
| 1717 // Unwind frame and jump to forward exception. unwinding will place throwing pc in O7 | |
| 1718 // as expected by forward_exception. | |
| 1719 | |
| 1720 __ restore(FP, G0, SP); // unwind interpreter state frame | |
| 1721 __ br(Assembler::always, false, Assembler::pt, StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type); | |
| 1722 __ delayed()->mov(I5_savedSP->after_restore(), SP); | |
| 1723 | |
| 1724 // Return point from a call which returns a result in the native abi | |
| 1725 // (c1/c2/jni-native). This result must be processed onto the java | |
| 1726 // expression stack. | |
| 1727 // | |
| 1728 // A pending exception may be present in which case there is no result present | |
| 1729 | |
| 1730 address return_from_native_method = __ pc(); | |
| 1731 | |
| 1732 VALIDATE_STATE(G3_scratch, 6); | |
| 1733 | |
| 1734 // Result if any is in native abi result (O0..O1/F0..F1). The java expression | |
| 1735 // stack is in the state that the calling convention left it. | |
| 1736 // Copy the result from native abi result and place it on java expression stack. | |
| 1737 | |
| 1738 // Current interpreter state is present in Lstate | |
| 1739 | |
| 1740 // Exception pending? | |
| 1741 | |
| 1742 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame | |
| 1743 __ ld_ptr(exception_addr, Lscratch); // get any pending exception | |
| 1744 __ tst(Lscratch); // exception pending? | |
| 1745 __ brx(Assembler::notZero, false, Assembler::pt, return_with_exception); | |
| 1746 __ delayed()->nop(); | |
| 1747 | |
| 1748 // Process the native abi result to java expression stack | |
| 1749 | |
| 1750 __ ld_ptr(STATE(_result._to_call._callee), L4_scratch); // called method | |
| 1751 __ ld_ptr(STATE(_stack), L1_scratch); // get top of java expr stack | |
| 1752 __ lduh(L4_scratch, in_bytes(methodOopDesc::size_of_parameters_offset()), L2_scratch); // get parameter size | |
| 1753 __ sll(L2_scratch, LogBytesPerWord, L2_scratch ); // parameter size in bytes | |
| 1754 __ add(L1_scratch, L2_scratch, L1_scratch); // stack destination for result | |
| 123 | 1755 __ ld(L4_scratch, in_bytes(methodOopDesc::result_index_offset()), L3_scratch); // called method result type index |
| 0 | 1756 |
| 1757 // tosca is really just native abi | |
| 1758 __ set((intptr_t)CppInterpreter::_tosca_to_stack, L4_scratch); | |
| 1759 __ sll(L3_scratch, LogBytesPerWord, L3_scratch); | |
| 1760 __ ld_ptr(L4_scratch, L3_scratch, Lscratch); // get typed result converter address | |
| 1761 __ jmpl(Lscratch, G0, O7); // and convert it | |
| 1762 __ delayed()->nop(); | |
| 1763 | |
| 1764 // L1_scratch points to top of stack (prepushed) | |
| 1765 | |
| 1766 __ ba(false, resume_interpreter); | |
| 1767 __ delayed()->mov(L1_scratch, O1); | |
| 1768 | |
| 1769 // An exception is being caught on return to a vanilla interpreter frame. | |
| 1770 // Empty the stack and resume interpreter | |
| 1771 | |
| 1772 __ bind(return_with_exception); | |
| 1773 | |
| 1774 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame | |
| 1775 __ ld_ptr(STATE(_stack_base), O1); // empty java expression stack | |
| 1776 __ ba(false, resume_interpreter); | |
| 1777 __ delayed()->sub(O1, wordSize, O1); // account for prepush | |
| 1778 | |
| 1779 // Return from interpreted method we return result appropriate to the caller (i.e. "recursive" | |
| 1780 // interpreter call, or native) and unwind this interpreter activation. | |
| 1781 // All monitors should be unlocked. | |
| 1782 | |
| 1783 __ bind(return_from_interpreted_method); | |
| 1784 | |
| 1785 VALIDATE_STATE(G3_scratch, 7); | |
| 1786 | |
| 1787 Label return_to_initial_caller; | |
| 1788 | |
| 1789 // Interpreted result is on the top of the completed activation expression stack. | |
| 1790 // We must return it to the top of the callers stack if caller was interpreted | |
| 1791 // otherwise we convert to native abi result and return to call_stub/c1/c2 | |
| 1792 // The caller's expression stack was truncated by the call however the current activation | |
| 1793 // has enough stuff on the stack that we have usable space there no matter what. The | |
| 1794 // other thing that makes it easy is that the top of the caller's stack is stored in STATE(_locals) | |
| 1795 // for the current activation | |
| 1796 | |
| 1797 __ ld_ptr(STATE(_prev_link), L1_scratch); | |
| 1798 __ ld_ptr(STATE(_method), L2_scratch); // get method just executed | |
| 123 | 1799 __ ld(L2_scratch, in_bytes(methodOopDesc::result_index_offset()), L2_scratch); |
| 0 | 1800 __ tst(L1_scratch); |
| 1801 __ brx(Assembler::zero, false, Assembler::pt, return_to_initial_caller); | |
| 1802 __ delayed()->sll(L2_scratch, LogBytesPerWord, L2_scratch); | |
| 1803 | |
| 1804 // Copy result to callers java stack | |
| 1805 | |
| 1806 __ set((intptr_t)CppInterpreter::_stack_to_stack, L4_scratch); | |
| 1807 __ ld_ptr(L4_scratch, L2_scratch, Lscratch); // get typed result converter address | |
| 1808 __ ld_ptr(STATE(_stack), O0); // current top (prepushed) | |
| 1809 __ ld_ptr(STATE(_locals), O1); // stack destination | |
| 1810 | |
| 1811 // O0 - will be source, O1 - will be destination (preserved) | |
| 1812 __ jmpl(Lscratch, G0, O7); // and convert it | |
| 1813 __ delayed()->add(O0, wordSize, O0); // get source (top of current expr stack) | |
| 1814 | |
| 1815 // O1 == &locals[0] | |
| 1816 | |
| 1817 // Result is now on caller's stack. Just unwind current activation and resume | |
| 1818 | |
| 1819 Label unwind_recursive_activation; | |
| 1820 | |
| 1821 | |
| 1822 __ bind(unwind_recursive_activation); | |
| 1823 | |
| 1824 // O1 == &locals[0] (really callers stacktop) for activation now returning | |
| 1825 // returning to interpreter method from "recursive" interpreter call | |
| 1826 // result converter left O1 pointing to top of the( prepushed) java stack for method we are returning | |
| 1827 // to. Now all we must do is unwind the state from the completed call | |
| 1828 | |
| 1829 // Must restore stack | |
| 1830 VALIDATE_STATE(G3_scratch, 8); | |
| 1831 | |
| 1832 // Return to interpreter method after a method call (interpreted/native/c1/c2) has completed. | |
| 1833 // Result if any is already on the caller's stack. All we must do now is remove the now dead | |
| 1834 // frame and tell interpreter to resume. | |
| 1835 | |
| 1836 | |
| 1837 __ mov(O1, I1); // pass back new stack top across activation | |
| 1838 // POP FRAME HERE ================================== | |
| 1839 __ restore(FP, G0, SP); // unwind interpreter state frame | |
| 1840 __ ld_ptr(STATE(_frame_bottom), SP); // restore to full stack frame | |
| 1841 | |
| 1842 | |
| 1843 // Resume the interpreter. The current frame contains the current interpreter | |
| 1844 // state object. | |
| 1845 // | |
| 1846 // O1 == new java stack pointer | |
| 1847 | |
| 1848 __ bind(resume_interpreter); | |
| 1849 VALIDATE_STATE(G3_scratch, 10); | |
| 1850 | |
| 1851 // A frame we have already used before so no need to bang stack so use call_interpreter_2 entry | |
| 1852 | |
| 1853 __ set((int)BytecodeInterpreter::method_resume, L1_scratch); | |
| 1854 __ st(L1_scratch, STATE(_msg)); | |
| 1855 __ ba(false, call_interpreter_2); | |
| 1856 __ delayed()->st_ptr(O1, STATE(_stack)); | |
| 1857 | |
| 1858 | |
| 1859 // Fast accessor methods share this entry point. | |
| 1860 // This works because frame manager is in the same codelet | |
| 1861 // This can either be an entry via call_stub/c1/c2 or a recursive interpreter call | |
| 1862 // we need to do a little register fixup here once we distinguish the two of them | |
| 1863 if (UseFastAccessorMethods && !synchronized) { | |
| 1864 // Call stub_return address still in O7 | |
| 1865 __ bind(fast_accessor_slow_entry_path); | |
| 1866 __ set((intptr_t)return_from_native_method - 8, Gtmp1); | |
| 1867 __ cmp(Gtmp1, O7); // returning to interpreter? | |
| 1868 __ brx(Assembler::equal, true, Assembler::pt, re_dispatch); // yep | |
| 1869 __ delayed()->nop(); | |
| 1870 __ ba(false, re_dispatch); | |
| 1871 __ delayed()->mov(G0, prevState); // initial entry | |
| 1872 | |
| 1873 } | |
| 1874 | |
| 1875 // interpreter returning to native code (call_stub/c1/c2) | |
| 1876 // convert result and unwind initial activation | |
| 1877 // L2_scratch - scaled result type index | |
| 1878 | |
| 1879 __ bind(return_to_initial_caller); | |
| 1880 | |
| 1881 __ set((intptr_t)CppInterpreter::_stack_to_native_abi, L4_scratch); | |
| 1882 __ ld_ptr(L4_scratch, L2_scratch, Lscratch); // get typed result converter address | |
| 1883 __ ld_ptr(STATE(_stack), O0); // current top (prepushed) | |
| 1884 __ jmpl(Lscratch, G0, O7); // and convert it | |
| 1885 __ delayed()->add(O0, wordSize, O0); // get source (top of current expr stack) | |
| 1886 | |
| 1887 Label unwind_initial_activation; | |
| 1888 __ bind(unwind_initial_activation); | |
| 1889 | |
| 1890 // RETURN TO CALL_STUB/C1/C2 code (result if any in I0..I1/(F0/..F1) | |
| 1891 // we can return here with an exception that wasn't handled by interpreted code | |
| 1892 // how does c1/c2 see it on return? | |
| 1893 | |
| 1894 // compute resulting sp before/after args popped depending upon calling convention | |
| 1895 // __ ld_ptr(STATE(_saved_sp), Gtmp1); | |
| 1896 // | |
| 1897 // POP FRAME HERE ================================== | |
| 1898 __ restore(FP, G0, SP); | |
| 1899 __ retl(); | |
| 1900 __ delayed()->mov(I5_savedSP->after_restore(), SP); | |
| 1901 | |
| 1902 // OSR request, unwind the current frame and transfer to the OSR entry | |
| 1903 // and enter OSR nmethod | |
| 1904 | |
| 1905 __ bind(do_OSR); | |
| 1906 Label remove_initial_frame; | |
| 1907 __ ld_ptr(STATE(_prev_link), L1_scratch); | |
| 1908 __ ld_ptr(STATE(_result._osr._osr_buf), G1_scratch); | |
| 1909 | |
| 1910 // We are going to pop this frame. Is there another interpreter frame underneath | |
| 1911 // it or is it callstub/compiled? | |
| 1912 | |
| 1913 __ tst(L1_scratch); | |
| 1914 __ brx(Assembler::zero, false, Assembler::pt, remove_initial_frame); | |
| 1915 __ delayed()->ld_ptr(STATE(_result._osr._osr_entry), G3_scratch); | |
| 1916 | |
| 1917 // Frame underneath is an interpreter frame simply unwind | |
| 1918 // POP FRAME HERE ================================== | |
| 1919 __ restore(FP, G0, SP); // unwind interpreter state frame | |
| 1920 __ mov(I5_savedSP->after_restore(), SP); | |
| 1921 | |
| 1922 // Since we are now calling native need to change our "return address" from the | |
| 1923 // dummy RecursiveInterpreterActivation to a return from native | |
| 1924 | |
| 1925 __ set((intptr_t)return_from_native_method - 8, O7); | |
| 1926 | |
| 1927 __ jmpl(G3_scratch, G0, G0); | |
| 1928 __ delayed()->mov(G1_scratch, O0); | |
| 1929 | |
| 1930 __ bind(remove_initial_frame); | |
| 1931 | |
| 1932 // POP FRAME HERE ================================== | |
| 1933 __ restore(FP, G0, SP); | |
| 1934 __ mov(I5_savedSP->after_restore(), SP); | |
| 1935 __ jmpl(G3_scratch, G0, G0); | |
| 1936 __ delayed()->mov(G1_scratch, O0); | |
| 1937 | |
| 1938 // Call a new method. All we do is (temporarily) trim the expression stack | |
| 1939 // push a return address to bring us back to here and leap to the new entry. | |
| 1940 // At this point we have a topmost frame that was allocated by the frame manager | |
| 1941 // which contains the current method interpreted state. We trim this frame | |
| 1942 // of excess java expression stack entries and then recurse. | |
| 1943 | |
| 1944 __ bind(call_method); | |
| 1945 | |
| 1946 // stack points to next free location and not top element on expression stack | |
| 1947 // method expects sp to be pointing to topmost element | |
| 1948 | |
| 1949 __ ld_ptr(STATE(_thread), G2_thread); | |
| 1950 __ ld_ptr(STATE(_result._to_call._callee), G5_method); | |
| 1951 | |
| 1952 | |
| 1953 // SP already takes in to account the 2 extra words we use for slop | |
| 1954 // when we call a "static long no_params()" method. So if | |
| 1955 // we trim back sp by the amount of unused java expression stack | |
| 1956 // there will be automagically the 2 extra words we need. | |
| 1957 // We also have to worry about keeping SP aligned. | |
| 1958 | |
| 1959 __ ld_ptr(STATE(_stack), Gargs); | |
| 1960 __ ld_ptr(STATE(_stack_limit), L1_scratch); | |
| 1961 | |
| 1962 // compute the unused java stack size | |
| 1963 __ sub(Gargs, L1_scratch, L2_scratch); // compute unused space | |
| 1964 | |
| 123 | 1965 // Round down the unused space to that stack is always 16-byte aligned |
| 1966 // by making the unused space a multiple of the size of two longs. | |
| 0 | 1967 |
| 123 | 1968 __ and3(L2_scratch, -2*BytesPerLong, L2_scratch); |
| 0 | 1969 |
| 1970 // Now trim the stack | |
| 1971 __ add(SP, L2_scratch, SP); | |
| 1972 | |
| 1973 | |
| 1974 // Now point to the final argument (account for prepush) | |
| 1975 __ add(Gargs, wordSize, Gargs); | |
| 1976 #ifdef ASSERT | |
| 1977 // Make sure we have space for the window | |
| 1978 __ sub(Gargs, SP, L1_scratch); | |
| 1979 __ cmp(L1_scratch, 16*wordSize); | |
| 1980 { | |
| 1981 Label skip; | |
| 1982 __ brx(Assembler::greaterEqual, false, Assembler::pt, skip); | |
| 1983 __ delayed()->nop(); | |
| 1984 __ stop("killed stack"); | |
| 1985 __ bind(skip); | |
| 1986 } | |
| 1987 #endif // ASSERT | |
| 1988 | |
| 1989 // Create a new frame where we can store values that make it look like the interpreter | |
| 1990 // really recursed. | |
| 1991 | |
| 1992 // prepare to recurse or call specialized entry | |
| 1993 | |
| 1994 // First link the registers we need | |
| 1995 | |
| 1996 // make the pc look good in debugger | |
| 1997 __ set(CAST_FROM_FN_PTR(intptr_t, RecursiveInterpreterActivation), O7); | |
| 1998 // argument too | |
| 1999 __ mov(Lstate, I0); | |
| 2000 | |
| 2001 // Record our sending SP | |
| 2002 __ mov(SP, O5_savedSP); | |
| 2003 | |
| 2004 __ ld_ptr(STATE(_result._to_call._callee_entry_point), L2_scratch); | |
| 2005 __ set((intptr_t) entry_point, L1_scratch); | |
| 2006 __ cmp(L1_scratch, L2_scratch); | |
| 2007 __ brx(Assembler::equal, false, Assembler::pt, re_dispatch); | |
| 2008 __ delayed()->mov(Lstate, prevState); // link activations | |
| 2009 | |
| 2010 // method uses specialized entry, push a return so we look like call stub setup | |
| 2011 // this path will handle fact that result is returned in registers and not | |
| 2012 // on the java stack. | |
| 2013 | |
| 2014 __ set((intptr_t)return_from_native_method - 8, O7); | |
| 2015 __ jmpl(L2_scratch, G0, G0); // Do specialized entry | |
| 2016 __ delayed()->nop(); | |
| 2017 | |
| 2018 // | |
| 2019 // Bad Message from interpreter | |
| 2020 // | |
| 2021 __ bind(bad_msg); | |
| 2022 __ stop("Bad message from interpreter"); | |
| 2023 | |
| 2024 // Interpreted method "returned" with an exception pass it on... | |
| 2025 // Pass result, unwind activation and continue/return to interpreter/call_stub | |
| 2026 // We handle result (if any) differently based on return to interpreter or call_stub | |
| 2027 | |
| 2028 __ bind(throw_exception); | |
| 2029 __ ld_ptr(STATE(_prev_link), L1_scratch); | |
| 2030 __ tst(L1_scratch); | |
| 2031 __ brx(Assembler::zero, false, Assembler::pt, unwind_and_forward); | |
| 2032 __ delayed()->nop(); | |
| 2033 | |
| 2034 __ ld_ptr(STATE(_locals), O1); // get result of popping callee's args | |
| 2035 __ ba(false, unwind_recursive_activation); | |
| 2036 __ delayed()->nop(); | |
| 2037 | |
| 2038 interpreter_frame_manager = entry_point; | |
| 2039 return entry_point; | |
| 2040 } | |
| 2041 | |
| 2042 InterpreterGenerator::InterpreterGenerator(StubQueue* code) | |
| 2043 : CppInterpreterGenerator(code) { | |
| 2044 generate_all(); // down here so it can be "virtual" | |
| 2045 } | |
| 2046 | |
| 2047 | |
| 2048 static int size_activation_helper(int callee_extra_locals, int max_stack, int monitor_size) { | |
| 2049 | |
| 2050 // Figure out the size of an interpreter frame (in words) given that we have a fully allocated | |
| 2051 // expression stack, the callee will have callee_extra_locals (so we can account for | |
| 2052 // frame extension) and monitor_size for monitors. Basically we need to calculate | |
| 2053 // this exactly like generate_fixed_frame/generate_compute_interpreter_state. | |
| 2054 // | |
| 2055 // | |
| 2056 // The big complicating thing here is that we must ensure that the stack stays properly | |
| 2057 // aligned. This would be even uglier if monitor size wasn't modulo what the stack | |
| 2058 // needs to be aligned for). We are given that the sp (fp) is already aligned by | |
| 2059 // the caller so we must ensure that it is properly aligned for our callee. | |
| 2060 // | |
| 2061 // Ths c++ interpreter always makes sure that we have a enough extra space on the | |
| 2062 // stack at all times to deal with the "stack long no_params()" method issue. This | |
| 2063 // is "slop_factor" here. | |
| 2064 const int slop_factor = 2; | |
| 2065 | |
| 2066 const int fixed_size = sizeof(BytecodeInterpreter)/wordSize + // interpreter state object | |
| 2067 frame::memory_parameter_word_sp_offset; // register save area + param window | |
| 710 | 2068 const int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries(); |
| 0 | 2069 return (round_to(max_stack + |
| 710 | 2070 extra_stack + |
| 0 | 2071 slop_factor + |
| 2072 fixed_size + | |
| 2073 monitor_size + | |
| 2074 (callee_extra_locals * Interpreter::stackElementWords()), WordsPerLong)); | |
| 2075 | |
| 2076 } | |
| 2077 | |
| 2078 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) { | |
| 2079 | |
| 2080 // See call_stub code | |
| 2081 int call_stub_size = round_to(7 + frame::memory_parameter_word_sp_offset, | |
| 2082 WordsPerLong); // 7 + register save area | |
| 2083 | |
| 2084 // Save space for one monitor to get into the interpreted method in case | |
| 2085 // the method is synchronized | |
| 2086 int monitor_size = method->is_synchronized() ? | |
| 2087 1*frame::interpreter_frame_monitor_size() : 0; | |
| 2088 return size_activation_helper(method->max_locals(), method->max_stack(), | |
| 2089 monitor_size) + call_stub_size; | |
| 2090 } | |
| 2091 | |
| 2092 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill, | |
| 2093 frame* caller, | |
| 2094 frame* current, | |
| 2095 methodOop method, | |
| 2096 intptr_t* locals, | |
| 2097 intptr_t* stack, | |
| 2098 intptr_t* stack_base, | |
| 2099 intptr_t* monitor_base, | |
| 2100 intptr_t* frame_bottom, | |
| 2101 bool is_top_frame | |
| 2102 ) | |
| 2103 { | |
| 2104 // What about any vtable? | |
| 2105 // | |
| 2106 to_fill->_thread = JavaThread::current(); | |
| 2107 // This gets filled in later but make it something recognizable for now | |
| 2108 to_fill->_bcp = method->code_base(); | |
| 2109 to_fill->_locals = locals; | |
| 2110 to_fill->_constants = method->constants()->cache(); | |
| 2111 to_fill->_method = method; | |
| 2112 to_fill->_mdx = NULL; | |
| 2113 to_fill->_stack = stack; | |
| 2114 if (is_top_frame && JavaThread::current()->popframe_forcing_deopt_reexecution() ) { | |
| 2115 to_fill->_msg = deopt_resume2; | |
| 2116 } else { | |
| 2117 to_fill->_msg = method_resume; | |
| 2118 } | |
| 2119 to_fill->_result._to_call._bcp_advance = 0; | |
| 2120 to_fill->_result._to_call._callee_entry_point = NULL; // doesn't matter to anyone | |
| 2121 to_fill->_result._to_call._callee = NULL; // doesn't matter to anyone | |
| 2122 to_fill->_prev_link = NULL; | |
| 2123 | |
| 2124 // Fill in the registers for the frame | |
| 2125 | |
| 2126 // Need to install _sender_sp. Actually not too hard in C++! | |
| 2127 // When the skeletal frames are layed out we fill in a value | |
| 2128 // for _sender_sp. That value is only correct for the oldest | |
| 2129 // skeletal frame constructed (because there is only a single | |
| 2130 // entry for "caller_adjustment". While the skeletal frames | |
| 2131 // exist that is good enough. We correct that calculation | |
| 2132 // here and get all the frames correct. | |
| 2133 | |
| 2134 // to_fill->_sender_sp = locals - (method->size_of_parameters() - 1); | |
| 2135 | |
| 2136 *current->register_addr(Lstate) = (intptr_t) to_fill; | |
| 2137 // skeletal already places a useful value here and this doesn't account | |
| 2138 // for alignment so don't bother. | |
| 2139 // *current->register_addr(I5_savedSP) = (intptr_t) locals - (method->size_of_parameters() - 1); | |
| 2140 | |
| 2141 if (caller->is_interpreted_frame()) { | |
| 2142 interpreterState prev = caller->get_interpreterState(); | |
| 2143 to_fill->_prev_link = prev; | |
| 2144 // Make the prev callee look proper | |
| 2145 prev->_result._to_call._callee = method; | |
| 2146 if (*prev->_bcp == Bytecodes::_invokeinterface) { | |
| 2147 prev->_result._to_call._bcp_advance = 5; | |
| 2148 } else { | |
| 2149 prev->_result._to_call._bcp_advance = 3; | |
| 2150 } | |
| 2151 } | |
| 2152 to_fill->_oop_temp = NULL; | |
| 2153 to_fill->_stack_base = stack_base; | |
| 2154 // Need +1 here because stack_base points to the word just above the first expr stack entry | |
| 2155 // and stack_limit is supposed to point to the word just below the last expr stack entry. | |
| 2156 // See generate_compute_interpreter_state. | |
| 710 | 2157 int extra_stack = 0; //6815692//methodOopDesc::extra_stack_entries(); |
| 2158 to_fill->_stack_limit = stack_base - (method->max_stack() + 1 + extra_stack); | |
| 0 | 2159 to_fill->_monitor_base = (BasicObjectLock*) monitor_base; |
| 2160 | |
| 2161 // sparc specific | |
| 2162 to_fill->_frame_bottom = frame_bottom; | |
| 2163 to_fill->_self_link = to_fill; | |
| 2164 #ifdef ASSERT | |
| 2165 to_fill->_native_fresult = 123456.789; | |
| 2166 to_fill->_native_lresult = CONST64(0xdeadcafedeafcafe); | |
| 2167 #endif | |
| 2168 } | |
| 2169 | |
| 2170 void BytecodeInterpreter::pd_layout_interpreterState(interpreterState istate, address last_Java_pc, intptr_t* last_Java_fp) { | |
| 2171 istate->_last_Java_pc = (intptr_t*) last_Java_pc; | |
| 2172 } | |
| 2173 | |
| 2174 | |
| 2175 int AbstractInterpreter::layout_activation(methodOop method, | |
| 2176 int tempcount, // Number of slots on java expression stack in use | |
| 2177 int popframe_extra_args, | |
| 2178 int moncount, // Number of active monitors | |
| 2179 int callee_param_size, | |
| 2180 int callee_locals_size, | |
| 2181 frame* caller, | |
| 2182 frame* interpreter_frame, | |
| 2183 bool is_top_frame) { | |
| 2184 | |
| 2185 assert(popframe_extra_args == 0, "NEED TO FIX"); | |
| 2186 // NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state() | |
| 2187 // does as far as allocating an interpreter frame. | |
| 2188 // If interpreter_frame!=NULL, set up the method, locals, and monitors. | |
| 2189 // The frame interpreter_frame, if not NULL, is guaranteed to be the right size, | |
| 2190 // as determined by a previous call to this method. | |
| 2191 // It is also guaranteed to be walkable even though it is in a skeletal state | |
| 2192 // NOTE: return size is in words not bytes | |
| 2193 // NOTE: tempcount is the current size of the java expression stack. For top most | |
| 2194 // frames we will allocate a full sized expression stack and not the curback | |
| 2195 // version that non-top frames have. | |
| 2196 | |
| 2197 // Calculate the amount our frame will be adjust by the callee. For top frame | |
| 2198 // this is zero. | |
| 2199 | |
| 2200 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it | |
| 2201 // calculates the extra locals based on itself. Not what the callee does | |
| 2202 // to it. So it ignores last_frame_adjust value. Seems suspicious as far | |
| 2203 // as getting sender_sp correct. | |
| 2204 | |
| 2205 int extra_locals_size = callee_locals_size - callee_param_size; | |
| 2206 int monitor_size = (sizeof(BasicObjectLock) * moncount) / wordSize; | |
| 2207 int full_frame_words = size_activation_helper(extra_locals_size, method->max_stack(), monitor_size); | |
| 2208 int short_frame_words = size_activation_helper(extra_locals_size, method->max_stack(), monitor_size); | |
| 2209 int frame_words = is_top_frame ? full_frame_words : short_frame_words; | |
| 2210 | |
| 2211 | |
| 2212 /* | |
| 2213 if we actually have a frame to layout we must now fill in all the pieces. This means both | |
| 2214 the interpreterState and the registers. | |
| 2215 */ | |
| 2216 if (interpreter_frame != NULL) { | |
| 2217 | |
| 2218 // MUCHO HACK | |
| 2219 | |
| 2220 intptr_t* frame_bottom = interpreter_frame->sp() - (full_frame_words - frame_words); | |
| 123 | 2221 // 'interpreter_frame->sp()' is unbiased while 'frame_bottom' must be a biased value in 64bit mode. |
| 2222 assert(((intptr_t)frame_bottom & 0xf) == 0, "SP biased in layout_activation"); | |
| 2223 frame_bottom = (intptr_t*)((intptr_t)frame_bottom - STACK_BIAS); | |
| 0 | 2224 |
| 2225 /* Now fillin the interpreterState object */ | |
| 2226 | |
| 2227 interpreterState cur_state = (interpreterState) ((intptr_t)interpreter_frame->fp() - sizeof(BytecodeInterpreter)); | |
| 2228 | |
| 2229 | |
| 2230 intptr_t* locals; | |
| 2231 | |
| 2232 // Calculate the postion of locals[0]. This is painful because of | |
| 2233 // stack alignment (same as ia64). The problem is that we can | |
| 2234 // not compute the location of locals from fp(). fp() will account | |
| 2235 // for the extra locals but it also accounts for aligning the stack | |
| 2236 // and we can't determine if the locals[0] was misaligned but max_locals | |
| 2237 // was enough to have the | |
| 2238 // calculate postion of locals. fp already accounts for extra locals. | |
| 2239 // +2 for the static long no_params() issue. | |
| 2240 | |
| 2241 if (caller->is_interpreted_frame()) { | |
| 2242 // locals must agree with the caller because it will be used to set the | |
| 2243 // caller's tos when we return. | |
| 2244 interpreterState prev = caller->get_interpreterState(); | |
| 2245 // stack() is prepushed. | |
| 2246 locals = prev->stack() + method->size_of_parameters(); | |
| 2247 } else { | |
| 2248 // Lay out locals block in the caller adjacent to the register window save area. | |
| 2249 // | |
| 2250 // Compiled frames do not allocate a varargs area which is why this if | |
| 2251 // statement is needed. | |
| 2252 // | |
| 2253 intptr_t* fp = interpreter_frame->fp(); | |
| 2254 int local_words = method->max_locals() * Interpreter::stackElementWords(); | |
| 2255 | |
| 2256 if (caller->is_compiled_frame()) { | |
| 2257 locals = fp + frame::register_save_words + local_words - 1; | |
| 2258 } else { | |
| 2259 locals = fp + frame::memory_parameter_word_sp_offset + local_words - 1; | |
| 2260 } | |
| 2261 | |
| 2262 } | |
| 2263 // END MUCHO HACK | |
| 2264 | |
| 2265 intptr_t* monitor_base = (intptr_t*) cur_state; | |
| 2266 intptr_t* stack_base = monitor_base - monitor_size; | |
| 2267 /* +1 because stack is always prepushed */ | |
| 2268 intptr_t* stack = stack_base - (tempcount + 1); | |
| 2269 | |
| 2270 | |
| 2271 BytecodeInterpreter::layout_interpreterState(cur_state, | |
| 2272 caller, | |
| 2273 interpreter_frame, | |
| 2274 method, | |
| 2275 locals, | |
| 2276 stack, | |
| 2277 stack_base, | |
| 2278 monitor_base, | |
| 2279 frame_bottom, | |
| 2280 is_top_frame); | |
| 2281 | |
| 2282 BytecodeInterpreter::pd_layout_interpreterState(cur_state, interpreter_return_address, interpreter_frame->fp()); | |
| 2283 | |
| 2284 } | |
| 2285 return frame_words; | |
| 2286 } | |
| 2287 | |
| 2288 #endif // CC_INTERP |