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