Mercurial > hg > truffle
annotate src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 3096:8073f5ad1d87
IdealGraphVisualizer: Rename predecessors to "Nodes Above" and successors to "Nodes Below" and actions "Expand Predecessors" and "Expand Successors" to "Expand Above" and "Expand Below" to avoid ambiguity with the Graal concept of successors and predecessors
| author | Peter Hofer <peter.hofer@jku.at> |
|---|---|
| date | Wed, 29 Jun 2011 18:27:14 +0200 |
| parents | 38fea01eb669 |
| children | 92add02409c9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2118
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "asm/assembler.hpp" | |
| 27 #include "interpreter/bytecodeHistogram.hpp" | |
| 28 #include "interpreter/interpreter.hpp" | |
| 29 #include "interpreter/interpreterGenerator.hpp" | |
| 30 #include "interpreter/interpreterRuntime.hpp" | |
| 31 #include "interpreter/templateTable.hpp" | |
| 32 #include "oops/arrayOop.hpp" | |
| 33 #include "oops/methodDataOop.hpp" | |
| 34 #include "oops/methodOop.hpp" | |
| 35 #include "oops/oop.inline.hpp" | |
| 36 #include "prims/jvmtiExport.hpp" | |
| 37 #include "prims/jvmtiThreadState.hpp" | |
| 38 #include "runtime/arguments.hpp" | |
| 39 #include "runtime/deoptimization.hpp" | |
| 40 #include "runtime/frame.inline.hpp" | |
| 41 #include "runtime/sharedRuntime.hpp" | |
| 42 #include "runtime/stubRoutines.hpp" | |
| 43 #include "runtime/synchronizer.hpp" | |
| 44 #include "runtime/timer.hpp" | |
| 45 #include "runtime/vframeArray.hpp" | |
| 46 #include "utilities/debug.hpp" | |
| 0 | 47 |
| 48 #define __ _masm-> | |
| 49 | |
| 304 | 50 #ifndef CC_INTERP |
| 51 | |
| 0 | 52 const int method_offset = frame::interpreter_frame_method_offset * wordSize; |
| 53 const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize; | |
| 54 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize; | |
| 55 | |
| 56 //----------------------------------------------------------------------------- | |
| 57 | |
| 58 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() { | |
| 59 address entry = __ pc(); | |
| 60 | |
| 61 #ifdef ASSERT | |
| 62 { | |
| 63 Label L; | |
| 304 | 64 __ lea(rax, Address(rbp, |
| 65 frame::interpreter_frame_monitor_block_top_offset * | |
| 66 wordSize)); | |
| 67 __ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack | |
| 68 // grows negative) | |
| 0 | 69 __ jcc(Assembler::aboveEqual, L); // check if frame is complete |
| 70 __ stop ("interpreter frame not set up"); | |
| 71 __ bind(L); | |
| 72 } | |
| 73 #endif // ASSERT | |
| 74 // Restore bcp under the assumption that the current frame is still | |
| 75 // interpreted | |
| 76 __ restore_bcp(); | |
| 77 | |
| 78 // expression stack must be empty before entering the VM if an | |
| 79 // exception happened | |
| 80 __ empty_expression_stack(); | |
| 81 // throw exception | |
| 82 __ call_VM(noreg, | |
| 83 CAST_FROM_FN_PTR(address, | |
| 84 InterpreterRuntime::throw_StackOverflowError)); | |
| 85 return entry; | |
| 86 } | |
| 87 | |
| 88 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler( | |
| 89 const char* name) { | |
| 90 address entry = __ pc(); | |
| 91 // expression stack must be empty before entering the VM if an | |
| 92 // exception happened | |
| 93 __ empty_expression_stack(); | |
| 94 // setup parameters | |
| 95 // ??? convention: expect aberrant index in register ebx | |
| 96 __ lea(c_rarg1, ExternalAddress((address)name)); | |
| 97 __ call_VM(noreg, | |
| 98 CAST_FROM_FN_PTR(address, | |
| 99 InterpreterRuntime:: | |
| 100 throw_ArrayIndexOutOfBoundsException), | |
| 101 c_rarg1, rbx); | |
| 102 return entry; | |
| 103 } | |
| 104 | |
| 105 address TemplateInterpreterGenerator::generate_ClassCastException_handler() { | |
| 106 address entry = __ pc(); | |
| 107 | |
| 108 // object is at TOS | |
| 304 | 109 __ pop(c_rarg1); |
| 0 | 110 |
| 111 // expression stack must be empty before entering the VM if an | |
| 112 // exception happened | |
| 113 __ empty_expression_stack(); | |
| 114 | |
| 115 __ call_VM(noreg, | |
| 116 CAST_FROM_FN_PTR(address, | |
| 117 InterpreterRuntime:: | |
| 118 throw_ClassCastException), | |
| 119 c_rarg1); | |
| 120 return entry; | |
| 121 } | |
| 122 | |
| 1108 | 123 // Arguments are: required type at TOS+8, failing object (or NULL) at TOS+4. |
| 710 | 124 address TemplateInterpreterGenerator::generate_WrongMethodType_handler() { |
| 125 address entry = __ pc(); | |
| 126 | |
| 127 __ pop(c_rarg2); // failing object is at TOS | |
| 128 __ pop(c_rarg1); // required type is at TOS+8 | |
| 129 | |
| 1108 | 130 __ verify_oop(c_rarg1); |
| 131 __ verify_oop(c_rarg2); | |
| 132 | |
| 133 // Various method handle types use interpreter registers as temps. | |
| 134 __ restore_bcp(); | |
| 135 __ restore_locals(); | |
| 136 | |
| 137 // Expression stack must be empty before entering the VM for an exception. | |
| 710 | 138 __ empty_expression_stack(); |
| 139 | |
| 140 __ call_VM(noreg, | |
| 141 CAST_FROM_FN_PTR(address, | |
| 1108 | 142 InterpreterRuntime::throw_WrongMethodTypeException), |
| 710 | 143 // pass required type, failing object (or NULL) |
| 144 c_rarg1, c_rarg2); | |
| 145 return entry; | |
| 146 } | |
| 147 | |
| 0 | 148 address TemplateInterpreterGenerator::generate_exception_handler_common( |
| 149 const char* name, const char* message, bool pass_oop) { | |
| 150 assert(!pass_oop || message == NULL, "either oop or message but not both"); | |
| 151 address entry = __ pc(); | |
| 152 if (pass_oop) { | |
| 153 // object is at TOS | |
| 304 | 154 __ pop(c_rarg2); |
| 0 | 155 } |
| 156 // expression stack must be empty before entering the VM if an | |
| 157 // exception happened | |
| 158 __ empty_expression_stack(); | |
| 159 // setup parameters | |
| 160 __ lea(c_rarg1, ExternalAddress((address)name)); | |
| 161 if (pass_oop) { | |
| 162 __ call_VM(rax, CAST_FROM_FN_PTR(address, | |
| 163 InterpreterRuntime:: | |
| 164 create_klass_exception), | |
| 165 c_rarg1, c_rarg2); | |
| 166 } else { | |
| 167 // kind of lame ExternalAddress can't take NULL because | |
| 168 // external_word_Relocation will assert. | |
| 169 if (message != NULL) { | |
| 170 __ lea(c_rarg2, ExternalAddress((address)message)); | |
| 171 } else { | |
| 172 __ movptr(c_rarg2, NULL_WORD); | |
| 173 } | |
| 174 __ call_VM(rax, | |
| 175 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), | |
| 176 c_rarg1, c_rarg2); | |
| 177 } | |
| 178 // throw exception | |
| 179 __ jump(ExternalAddress(Interpreter::throw_exception_entry())); | |
| 180 return entry; | |
| 181 } | |
| 182 | |
| 183 | |
| 184 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) { | |
| 185 address entry = __ pc(); | |
| 186 // NULL last_sp until next java call | |
| 304 | 187 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 188 __ dispatch_next(state); |
| 189 return entry; | |
| 190 } | |
| 191 | |
| 192 | |
|
2245
638119ce7cfd
7009309: JSR 292: compiler/6991596/Test6991596.java crashes on fastdebug JDK7/b122
twisti
parents:
2141
diff
changeset
|
193 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step) { |
| 0 | 194 address entry = __ pc(); |
| 195 | |
| 196 // Restore stack bottom in case i2c adjusted stack | |
| 304 | 197 __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); |
| 0 | 198 // and NULL it as marker that esp is now tos until next java call |
| 304 | 199 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 200 |
| 201 __ restore_bcp(); | |
| 202 __ restore_locals(); | |
| 304 | 203 |
| 1108 | 204 Label L_got_cache, L_giant_index; |
| 205 if (EnableInvokeDynamic) { | |
| 206 __ cmpb(Address(r13, 0), Bytecodes::_invokedynamic); | |
| 207 __ jcc(Assembler::equal, L_giant_index); | |
| 208 } | |
| 1565 | 209 __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u2)); |
| 1108 | 210 __ bind(L_got_cache); |
| 0 | 211 __ movl(rbx, Address(rbx, rcx, |
| 1108 | 212 Address::times_ptr, |
| 0 | 213 in_bytes(constantPoolCacheOopDesc::base_offset()) + |
| 214 3 * wordSize)); | |
| 215 __ andl(rbx, 0xFF); | |
| 304 | 216 __ lea(rsp, Address(rsp, rbx, Address::times_8)); |
| 0 | 217 __ dispatch_next(state, step); |
| 1108 | 218 |
| 219 // out of the main line of code... | |
| 220 if (EnableInvokeDynamic) { | |
| 221 __ bind(L_giant_index); | |
| 1565 | 222 __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u4)); |
| 1108 | 223 __ jmp(L_got_cache); |
| 224 } | |
| 225 | |
| 0 | 226 return entry; |
| 227 } | |
| 228 | |
| 229 | |
| 230 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, | |
| 231 int step) { | |
| 232 address entry = __ pc(); | |
| 233 // NULL last_sp until next java call | |
| 304 | 234 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 235 __ restore_bcp(); |
| 236 __ restore_locals(); | |
| 237 // handle exceptions | |
| 238 { | |
| 239 Label L; | |
| 304 | 240 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD); |
| 0 | 241 __ jcc(Assembler::zero, L); |
| 242 __ call_VM(noreg, | |
| 243 CAST_FROM_FN_PTR(address, | |
| 244 InterpreterRuntime::throw_pending_exception)); | |
| 245 __ should_not_reach_here(); | |
| 246 __ bind(L); | |
| 247 } | |
| 248 __ dispatch_next(state, step); | |
| 249 return entry; | |
| 250 } | |
| 251 | |
| 252 int AbstractInterpreter::BasicType_as_index(BasicType type) { | |
| 253 int i = 0; | |
| 254 switch (type) { | |
| 255 case T_BOOLEAN: i = 0; break; | |
| 256 case T_CHAR : i = 1; break; | |
| 257 case T_BYTE : i = 2; break; | |
| 258 case T_SHORT : i = 3; break; | |
| 259 case T_INT : i = 4; break; | |
| 260 case T_LONG : i = 5; break; | |
| 261 case T_VOID : i = 6; break; | |
| 262 case T_FLOAT : i = 7; break; | |
| 263 case T_DOUBLE : i = 8; break; | |
| 264 case T_OBJECT : i = 9; break; | |
| 265 case T_ARRAY : i = 9; break; | |
| 266 default : ShouldNotReachHere(); | |
| 267 } | |
| 268 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, | |
| 269 "index out of bounds"); | |
| 270 return i; | |
| 271 } | |
| 272 | |
| 273 | |
| 274 address TemplateInterpreterGenerator::generate_result_handler_for( | |
| 275 BasicType type) { | |
| 276 address entry = __ pc(); | |
| 277 switch (type) { | |
| 278 case T_BOOLEAN: __ c2bool(rax); break; | |
| 279 case T_CHAR : __ movzwl(rax, rax); break; | |
| 280 case T_BYTE : __ sign_extend_byte(rax); break; | |
| 281 case T_SHORT : __ sign_extend_short(rax); break; | |
| 282 case T_INT : /* nothing to do */ break; | |
| 283 case T_LONG : /* nothing to do */ break; | |
| 284 case T_VOID : /* nothing to do */ break; | |
| 285 case T_FLOAT : /* nothing to do */ break; | |
| 286 case T_DOUBLE : /* nothing to do */ break; | |
| 287 case T_OBJECT : | |
| 288 // retrieve result from frame | |
| 304 | 289 __ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize)); |
| 0 | 290 // and verify it |
| 291 __ verify_oop(rax); | |
| 292 break; | |
| 293 default : ShouldNotReachHere(); | |
| 294 } | |
| 295 __ ret(0); // return from result handler | |
| 296 return entry; | |
| 297 } | |
| 298 | |
| 299 address TemplateInterpreterGenerator::generate_safept_entry_for( | |
| 300 TosState state, | |
| 301 address runtime_entry) { | |
| 302 address entry = __ pc(); | |
| 303 __ push(state); | |
| 304 __ call_VM(noreg, runtime_entry); | |
| 305 __ dispatch_via(vtos, Interpreter::_normal_table.table_for(vtos)); | |
| 306 return entry; | |
| 307 } | |
| 308 | |
| 309 | |
| 310 | |
| 311 // Helpers for commoning out cases in the various type of method entries. | |
| 312 // | |
| 313 | |
| 314 | |
| 315 // increment invocation count & check for overflow | |
| 316 // | |
| 317 // Note: checking for negative value instead of overflow | |
| 318 // so we have a 'sticky' overflow test | |
| 319 // | |
| 320 // rbx: method | |
| 321 // ecx: invocation counter | |
| 322 // | |
| 323 void InterpreterGenerator::generate_counter_incr( | |
| 324 Label* overflow, | |
| 325 Label* profile_method, | |
| 326 Label* profile_method_continue) { | |
| 1783 | 327 const Address invocation_counter(rbx, in_bytes(methodOopDesc::invocation_counter_offset()) + |
| 328 in_bytes(InvocationCounter::counter_offset())); | |
| 329 // Note: In tiered we increment either counters in methodOop or in MDO depending if we're profiling or not. | |
| 330 if (TieredCompilation) { | |
| 331 int increment = InvocationCounter::count_increment; | |
| 332 int mask = ((1 << Tier0InvokeNotifyFreqLog) - 1) << InvocationCounter::count_shift; | |
| 333 Label no_mdo, done; | |
| 334 if (ProfileInterpreter) { | |
| 335 // Are we profiling? | |
| 336 __ movptr(rax, Address(rbx, methodOopDesc::method_data_offset())); | |
| 337 __ testptr(rax, rax); | |
| 338 __ jccb(Assembler::zero, no_mdo); | |
| 339 // Increment counter in the MDO | |
| 340 const Address mdo_invocation_counter(rax, in_bytes(methodDataOopDesc::invocation_counter_offset()) + | |
| 341 in_bytes(InvocationCounter::counter_offset())); | |
| 342 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, rcx, false, Assembler::zero, overflow); | |
| 343 __ jmpb(done); | |
| 344 } | |
| 345 __ bind(no_mdo); | |
| 346 // Increment counter in methodOop (we don't need to load it, it's in ecx). | |
| 347 __ increment_mask_and_jump(invocation_counter, increment, mask, rcx, true, Assembler::zero, overflow); | |
| 348 __ bind(done); | |
| 349 } else { | |
| 350 const Address backedge_counter(rbx, | |
| 351 methodOopDesc::backedge_counter_offset() + | |
| 0 | 352 InvocationCounter::counter_offset()); |
| 353 | |
| 1783 | 354 if (ProfileInterpreter) { // %%% Merge this into methodDataOop |
| 355 __ incrementl(Address(rbx, | |
| 356 methodOopDesc::interpreter_invocation_counter_offset())); | |
| 357 } | |
| 358 // Update standard invocation counters | |
| 359 __ movl(rax, backedge_counter); // load backedge counter | |
| 0 | 360 |
| 1783 | 361 __ incrementl(rcx, InvocationCounter::count_increment); |
| 362 __ andl(rax, InvocationCounter::count_mask_value); // mask out the status bits | |
| 0 | 363 |
| 1783 | 364 __ movl(invocation_counter, rcx); // save invocation count |
| 365 __ addl(rcx, rax); // add both counters | |
| 0 | 366 |
| 1783 | 367 // profile_method is non-null only for interpreted method so |
| 368 // profile_method != NULL == !native_call | |
| 369 | |
| 370 if (ProfileInterpreter && profile_method != NULL) { | |
| 371 // Test to see if we should create a method data oop | |
| 372 __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterProfileLimit)); | |
| 373 __ jcc(Assembler::less, *profile_method_continue); | |
| 0 | 374 |
| 1783 | 375 // if no method data exists, go to profile_method |
| 376 __ test_method_data_pointer(rax, *profile_method); | |
| 377 } | |
| 378 | |
| 379 __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit)); | |
| 380 __ jcc(Assembler::aboveEqual, *overflow); | |
| 0 | 381 } |
| 382 } | |
| 383 | |
| 384 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) { | |
| 385 | |
| 386 // Asm interpreter on entry | |
| 387 // r14 - locals | |
| 388 // r13 - bcp | |
| 389 // rbx - method | |
| 390 // edx - cpool --- DOES NOT APPEAR TO BE TRUE | |
| 391 // rbp - interpreter frame | |
| 392 | |
| 393 // On return (i.e. jump to entry_point) [ back to invocation of interpreter ] | |
| 394 // Everything as it was on entry | |
| 395 // rdx is not restored. Doesn't appear to really be set. | |
| 396 | |
| 397 const Address size_of_parameters(rbx, | |
| 398 methodOopDesc::size_of_parameters_offset()); | |
| 399 | |
| 400 // InterpreterRuntime::frequency_counter_overflow takes two | |
| 401 // arguments, the first (thread) is passed by call_VM, the second | |
| 402 // indicates if the counter overflow occurs at a backwards branch | |
| 403 // (NULL bcp). We pass zero for it. The call returns the address | |
| 404 // of the verified entry point for the method or NULL if the | |
| 405 // compilation did not complete (either went background or bailed | |
| 406 // out). | |
| 407 __ movl(c_rarg1, 0); | |
| 408 __ call_VM(noreg, | |
| 409 CAST_FROM_FN_PTR(address, | |
| 410 InterpreterRuntime::frequency_counter_overflow), | |
| 411 c_rarg1); | |
| 412 | |
| 304 | 413 __ movptr(rbx, Address(rbp, method_offset)); // restore methodOop |
| 0 | 414 // Preserve invariant that r13/r14 contain bcp/locals of sender frame |
| 415 // and jump to the interpreted entry. | |
| 416 __ jmp(*do_continue, relocInfo::none); | |
| 417 } | |
| 418 | |
| 419 // See if we've got enough room on the stack for locals plus overhead. | |
| 420 // The expression stack grows down incrementally, so the normal guard | |
| 421 // page mechanism will work for that. | |
| 422 // | |
| 423 // NOTE: Since the additional locals are also always pushed (wasn't | |
| 424 // obvious in generate_method_entry) so the guard should work for them | |
| 425 // too. | |
| 426 // | |
| 427 // Args: | |
| 428 // rdx: number of additional locals this frame needs (what we must check) | |
| 429 // rbx: methodOop | |
| 430 // | |
| 431 // Kills: | |
| 432 // rax | |
| 433 void InterpreterGenerator::generate_stack_overflow_check(void) { | |
| 434 | |
| 435 // monitor entry size: see picture of stack set | |
| 436 // (generate_method_entry) and frame_amd64.hpp | |
| 437 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 438 | |
| 439 // total overhead size: entry_size + (saved rbp through expr stack | |
| 440 // bottom). be sure to change this if you add/subtract anything | |
| 441 // to/from the overhead area | |
| 442 const int overhead_size = | |
| 443 -(frame::interpreter_frame_initial_sp_offset * wordSize) + entry_size; | |
| 444 | |
| 445 const int page_size = os::vm_page_size(); | |
| 446 | |
| 447 Label after_frame_check; | |
| 448 | |
| 449 // see if the frame is greater than one page in size. If so, | |
| 450 // then we need to verify there is enough stack space remaining | |
| 451 // for the additional locals. | |
| 1506 | 452 __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize); |
| 0 | 453 __ jcc(Assembler::belowEqual, after_frame_check); |
| 454 | |
| 455 // compute rsp as if this were going to be the last frame on | |
| 456 // the stack before the red zone | |
| 457 | |
| 458 const Address stack_base(r15_thread, Thread::stack_base_offset()); | |
| 459 const Address stack_size(r15_thread, Thread::stack_size_offset()); | |
| 460 | |
| 461 // locals + overhead, in bytes | |
| 304 | 462 __ mov(rax, rdx); |
| 1506 | 463 __ shlptr(rax, Interpreter::logStackElementSize); // 2 slots per parameter. |
| 304 | 464 __ addptr(rax, overhead_size); |
| 0 | 465 |
| 466 #ifdef ASSERT | |
| 467 Label stack_base_okay, stack_size_okay; | |
| 468 // verify that thread stack base is non-zero | |
| 304 | 469 __ cmpptr(stack_base, (int32_t)NULL_WORD); |
| 0 | 470 __ jcc(Assembler::notEqual, stack_base_okay); |
| 471 __ stop("stack base is zero"); | |
| 472 __ bind(stack_base_okay); | |
| 473 // verify that thread stack size is non-zero | |
| 304 | 474 __ cmpptr(stack_size, 0); |
| 0 | 475 __ jcc(Assembler::notEqual, stack_size_okay); |
| 476 __ stop("stack size is zero"); | |
| 477 __ bind(stack_size_okay); | |
| 478 #endif | |
| 479 | |
| 480 // Add stack base to locals and subtract stack size | |
| 304 | 481 __ addptr(rax, stack_base); |
| 482 __ subptr(rax, stack_size); | |
| 0 | 483 |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
484 // Use the maximum number of pages we might bang. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
485 const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages : |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
486 (StackRedPages+StackYellowPages); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
487 |
| 0 | 488 // add in the red and yellow zone sizes |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
489 __ addptr(rax, max_pages * page_size); |
| 0 | 490 |
| 491 // check against the current stack bottom | |
| 304 | 492 __ cmpptr(rsp, rax); |
| 0 | 493 __ jcc(Assembler::above, after_frame_check); |
| 494 | |
| 304 | 495 __ pop(rax); // get return address |
| 0 | 496 __ jump(ExternalAddress(Interpreter::throw_StackOverflowError_entry())); |
| 497 | |
| 498 // all done with frame size check | |
| 499 __ bind(after_frame_check); | |
| 500 } | |
| 501 | |
| 502 // Allocate monitor and lock method (asm interpreter) | |
| 503 // | |
| 504 // Args: | |
| 505 // rbx: methodOop | |
| 506 // r14: locals | |
| 507 // | |
| 508 // Kills: | |
| 509 // rax | |
| 510 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs) | |
| 511 // rscratch1, rscratch2 (scratch regs) | |
| 512 void InterpreterGenerator::lock_method(void) { | |
| 513 // synchronize method | |
| 514 const Address access_flags(rbx, methodOopDesc::access_flags_offset()); | |
| 515 const Address monitor_block_top( | |
| 516 rbp, | |
| 517 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 518 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 519 | |
| 520 #ifdef ASSERT | |
| 521 { | |
| 522 Label L; | |
| 523 __ movl(rax, access_flags); | |
| 524 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 525 __ jcc(Assembler::notZero, L); | |
| 526 __ stop("method doesn't need synchronization"); | |
| 527 __ bind(L); | |
| 528 } | |
| 529 #endif // ASSERT | |
| 530 | |
| 531 // get synchronization object | |
| 532 { | |
| 533 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + | |
| 534 Klass::java_mirror_offset_in_bytes(); | |
| 535 Label done; | |
| 536 __ movl(rax, access_flags); | |
| 537 __ testl(rax, JVM_ACC_STATIC); | |
| 538 // get receiver (assume this is frequent case) | |
| 304 | 539 __ movptr(rax, Address(r14, Interpreter::local_offset_in_bytes(0))); |
| 0 | 540 __ jcc(Assembler::zero, done); |
| 304 | 541 __ movptr(rax, Address(rbx, methodOopDesc::constants_offset())); |
| 542 __ movptr(rax, Address(rax, | |
| 543 constantPoolOopDesc::pool_holder_offset_in_bytes())); | |
| 544 __ movptr(rax, Address(rax, mirror_offset)); | |
| 0 | 545 |
| 546 #ifdef ASSERT | |
| 547 { | |
| 548 Label L; | |
| 304 | 549 __ testptr(rax, rax); |
| 0 | 550 __ jcc(Assembler::notZero, L); |
| 551 __ stop("synchronization object is NULL"); | |
| 552 __ bind(L); | |
| 553 } | |
| 554 #endif // ASSERT | |
| 555 | |
| 556 __ bind(done); | |
| 557 } | |
| 558 | |
| 559 // add space for monitor & lock | |
| 304 | 560 __ subptr(rsp, entry_size); // add space for a monitor entry |
| 561 __ movptr(monitor_block_top, rsp); // set new monitor block top | |
| 0 | 562 // store object |
| 304 | 563 __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); |
| 564 __ movptr(c_rarg1, rsp); // object address | |
| 0 | 565 __ lock_object(c_rarg1); |
| 566 } | |
| 567 | |
| 568 // Generate a fixed interpreter frame. This is identical setup for | |
| 569 // interpreted methods and for native methods hence the shared code. | |
| 570 // | |
| 571 // Args: | |
| 572 // rax: return address | |
| 573 // rbx: methodOop | |
| 574 // r14: pointer to locals | |
| 575 // r13: sender sp | |
| 576 // rdx: cp cache | |
| 577 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) { | |
| 578 // initialize fixed part of activation frame | |
| 304 | 579 __ push(rax); // save return address |
| 0 | 580 __ enter(); // save old & set new rbp |
| 304 | 581 __ push(r13); // set sender sp |
| 582 __ push((int)NULL_WORD); // leave last_sp as null | |
| 583 __ movptr(r13, Address(rbx, methodOopDesc::const_offset())); // get constMethodOop | |
| 584 __ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase | |
| 585 __ push(rbx); // save methodOop | |
| 0 | 586 if (ProfileInterpreter) { |
| 587 Label method_data_continue; | |
| 304 | 588 __ movptr(rdx, Address(rbx, in_bytes(methodOopDesc::method_data_offset()))); |
| 589 __ testptr(rdx, rdx); | |
| 0 | 590 __ jcc(Assembler::zero, method_data_continue); |
| 304 | 591 __ addptr(rdx, in_bytes(methodDataOopDesc::data_offset())); |
| 0 | 592 __ bind(method_data_continue); |
| 304 | 593 __ push(rdx); // set the mdp (method data pointer) |
| 0 | 594 } else { |
| 304 | 595 __ push(0); |
| 0 | 596 } |
| 597 | |
| 304 | 598 __ movptr(rdx, Address(rbx, methodOopDesc::constants_offset())); |
| 599 __ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes())); | |
| 600 __ push(rdx); // set constant pool cache | |
| 601 __ push(r14); // set locals pointer | |
| 0 | 602 if (native_call) { |
| 304 | 603 __ push(0); // no bcp |
| 0 | 604 } else { |
| 304 | 605 __ push(r13); // set bcp |
| 0 | 606 } |
| 304 | 607 __ push(0); // reserve word for pointer to expression stack bottom |
| 608 __ movptr(Address(rsp, 0), rsp); // set expression stack bottom | |
| 0 | 609 } |
| 610 | |
| 611 // End of helpers | |
| 612 | |
| 304 | 613 // Various method entries |
| 614 //------------------------------------------------------------------------------------------------------------------------ | |
| 615 // | |
| 616 // | |
| 617 | |
| 618 // Call an accessor method (assuming it is resolved, otherwise drop | |
| 619 // into vanilla (slow path) entry | |
| 620 address InterpreterGenerator::generate_accessor_entry(void) { | |
| 621 // rbx: methodOop | |
| 622 | |
| 623 // r13: senderSP must preserver for slow path, set SP to it on fast path | |
| 624 | |
| 625 address entry_point = __ pc(); | |
| 626 Label xreturn_path; | |
| 627 | |
| 628 // do fastpath for resolved accessor methods | |
| 629 if (UseFastAccessorMethods) { | |
| 630 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites | |
| 631 // thereof; parameter size = 1 | |
| 632 // Note: We can only use this code if the getfield has been resolved | |
| 633 // and if we don't have a null-pointer exception => check for | |
| 634 // these conditions first and use slow path if necessary. | |
| 635 Label slow_path; | |
| 636 // If we need a safepoint check, generate full interpreter entry. | |
| 637 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), | |
| 638 SafepointSynchronize::_not_synchronized); | |
| 639 | |
| 640 __ jcc(Assembler::notEqual, slow_path); | |
| 641 // rbx: method | |
| 642 __ movptr(rax, Address(rsp, wordSize)); | |
| 643 | |
| 644 // check if local 0 != NULL and read field | |
| 645 __ testptr(rax, rax); | |
| 646 __ jcc(Assembler::zero, slow_path); | |
| 647 | |
| 648 __ movptr(rdi, Address(rbx, methodOopDesc::constants_offset())); | |
| 649 // read first instruction word and extract bytecode @ 1 and index @ 2 | |
| 650 __ movptr(rdx, Address(rbx, methodOopDesc::const_offset())); | |
| 651 __ movl(rdx, Address(rdx, constMethodOopDesc::codes_offset())); | |
| 652 // Shift codes right to get the index on the right. | |
| 653 // The bytecode fetched looks like <index><0xb4><0x2a> | |
| 654 __ shrl(rdx, 2 * BitsPerByte); | |
| 655 __ shll(rdx, exact_log2(in_words(ConstantPoolCacheEntry::size()))); | |
| 656 __ movptr(rdi, Address(rdi, constantPoolOopDesc::cache_offset_in_bytes())); | |
| 657 | |
| 658 // rax: local 0 | |
| 659 // rbx: method | |
| 660 // rdx: constant pool cache index | |
| 661 // rdi: constant pool cache | |
| 662 | |
| 663 // check if getfield has been resolved and read constant pool cache entry | |
| 664 // check the validity of the cache entry by testing whether _indices field | |
| 665 // contains Bytecode::_getfield in b1 byte. | |
| 666 assert(in_words(ConstantPoolCacheEntry::size()) == 4, | |
| 667 "adjust shift below"); | |
| 668 __ movl(rcx, | |
| 669 Address(rdi, | |
| 670 rdx, | |
| 671 Address::times_8, | |
| 672 constantPoolCacheOopDesc::base_offset() + | |
| 673 ConstantPoolCacheEntry::indices_offset())); | |
| 674 __ shrl(rcx, 2 * BitsPerByte); | |
| 675 __ andl(rcx, 0xFF); | |
| 676 __ cmpl(rcx, Bytecodes::_getfield); | |
| 677 __ jcc(Assembler::notEqual, slow_path); | |
| 678 | |
| 679 // Note: constant pool entry is not valid before bytecode is resolved | |
| 680 __ movptr(rcx, | |
| 681 Address(rdi, | |
| 682 rdx, | |
| 683 Address::times_8, | |
| 684 constantPoolCacheOopDesc::base_offset() + | |
| 685 ConstantPoolCacheEntry::f2_offset())); | |
| 686 // edx: flags | |
| 687 __ movl(rdx, | |
| 688 Address(rdi, | |
| 689 rdx, | |
| 690 Address::times_8, | |
| 691 constantPoolCacheOopDesc::base_offset() + | |
| 692 ConstantPoolCacheEntry::flags_offset())); | |
| 693 | |
| 694 Label notObj, notInt, notByte, notShort; | |
| 695 const Address field_address(rax, rcx, Address::times_1); | |
| 696 | |
| 697 // Need to differentiate between igetfield, agetfield, bgetfield etc. | |
| 698 // because they are different sizes. | |
| 699 // Use the type from the constant pool cache | |
| 700 __ shrl(rdx, ConstantPoolCacheEntry::tosBits); | |
| 701 // Make sure we don't need to mask edx for tosBits after the above shift | |
| 702 ConstantPoolCacheEntry::verify_tosBits(); | |
| 703 | |
| 704 __ cmpl(rdx, atos); | |
| 705 __ jcc(Assembler::notEqual, notObj); | |
| 706 // atos | |
| 707 __ load_heap_oop(rax, field_address); | |
| 708 __ jmp(xreturn_path); | |
| 709 | |
| 710 __ bind(notObj); | |
| 711 __ cmpl(rdx, itos); | |
| 712 __ jcc(Assembler::notEqual, notInt); | |
| 713 // itos | |
| 714 __ movl(rax, field_address); | |
| 715 __ jmp(xreturn_path); | |
| 716 | |
| 717 __ bind(notInt); | |
| 718 __ cmpl(rdx, btos); | |
| 719 __ jcc(Assembler::notEqual, notByte); | |
| 720 // btos | |
| 721 __ load_signed_byte(rax, field_address); | |
| 722 __ jmp(xreturn_path); | |
| 723 | |
| 724 __ bind(notByte); | |
| 725 __ cmpl(rdx, stos); | |
| 726 __ jcc(Assembler::notEqual, notShort); | |
| 727 // stos | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
728 __ load_signed_short(rax, field_address); |
| 304 | 729 __ jmp(xreturn_path); |
| 730 | |
| 731 __ bind(notShort); | |
| 732 #ifdef ASSERT | |
| 733 Label okay; | |
| 734 __ cmpl(rdx, ctos); | |
| 735 __ jcc(Assembler::equal, okay); | |
| 736 __ stop("what type is this?"); | |
| 737 __ bind(okay); | |
| 738 #endif | |
| 739 // ctos | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
740 __ load_unsigned_short(rax, field_address); |
| 304 | 741 |
| 742 __ bind(xreturn_path); | |
| 743 | |
| 744 // _ireturn/_areturn | |
| 745 __ pop(rdi); | |
| 746 __ mov(rsp, r13); | |
| 747 __ jmp(rdi); | |
| 748 __ ret(0); | |
| 749 | |
| 750 // generate a vanilla interpreter entry as the slow path | |
| 751 __ bind(slow_path); | |
| 752 (void) generate_normal_entry(false); | |
| 753 } else { | |
| 754 (void) generate_normal_entry(false); | |
| 755 } | |
| 756 | |
| 757 return entry_point; | |
| 758 } | |
| 759 | |
| 0 | 760 // Interpreter stub for calling a native method. (asm interpreter) |
| 761 // This sets up a somewhat different looking stack for calling the | |
| 762 // native method than the typical interpreter frame setup. | |
| 763 address InterpreterGenerator::generate_native_entry(bool synchronized) { | |
| 764 // determine code generation flags | |
| 765 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 766 | |
| 767 // rbx: methodOop | |
| 768 // r13: sender sp | |
| 769 | |
| 770 address entry_point = __ pc(); | |
| 771 | |
| 772 const Address size_of_parameters(rbx, methodOopDesc:: | |
| 773 size_of_parameters_offset()); | |
| 774 const Address invocation_counter(rbx, methodOopDesc:: | |
| 775 invocation_counter_offset() + | |
| 776 InvocationCounter::counter_offset()); | |
| 777 const Address access_flags (rbx, methodOopDesc::access_flags_offset()); | |
| 778 | |
| 779 // get parameter size (always needed) | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
780 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 781 |
| 782 // native calls don't need the stack size check since they have no | |
| 783 // expression stack and the arguments are already on the stack and | |
| 784 // we only add a handful of words to the stack | |
| 785 | |
| 786 // rbx: methodOop | |
| 787 // rcx: size of parameters | |
| 788 // r13: sender sp | |
| 304 | 789 __ pop(rax); // get return address |
| 0 | 790 |
| 791 // for natives the size of locals is zero | |
| 792 | |
| 793 // compute beginning of parameters (r14) | |
| 304 | 794 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 795 |
| 796 // add 2 zero-initialized slots for native calls | |
| 797 // initialize result_handler slot | |
| 304 | 798 __ push((int) NULL_WORD); |
| 0 | 799 // slot for oop temp |
| 800 // (static native method holder mirror/jni oop result) | |
| 304 | 801 __ push((int) NULL_WORD); |
| 0 | 802 |
| 803 if (inc_counter) { | |
| 804 __ movl(rcx, invocation_counter); // (pre-)fetch invocation count | |
| 805 } | |
| 806 | |
| 807 // initialize fixed part of activation frame | |
| 808 generate_fixed_frame(true); | |
| 809 | |
| 810 // make sure method is native & not abstract | |
| 811 #ifdef ASSERT | |
| 812 __ movl(rax, access_flags); | |
| 813 { | |
| 814 Label L; | |
| 815 __ testl(rax, JVM_ACC_NATIVE); | |
| 816 __ jcc(Assembler::notZero, L); | |
| 817 __ stop("tried to execute non-native method as native"); | |
| 818 __ bind(L); | |
| 819 } | |
| 820 { | |
| 821 Label L; | |
| 822 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 823 __ jcc(Assembler::zero, L); | |
| 824 __ stop("tried to execute abstract method in interpreter"); | |
| 825 __ bind(L); | |
| 826 } | |
| 827 #endif | |
| 828 | |
| 829 // Since at this point in the method invocation the exception handler | |
| 830 // would try to exit the monitor of synchronized methods which hasn't | |
| 831 // been entered yet, we set the thread local variable | |
| 832 // _do_not_unlock_if_synchronized to true. The remove_activation will | |
| 833 // check this flag. | |
| 834 | |
| 835 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 836 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 837 __ movbool(do_not_unlock_if_synchronized, true); | |
| 838 | |
| 839 // increment invocation count & check for overflow | |
| 840 Label invocation_counter_overflow; | |
| 841 if (inc_counter) { | |
| 842 generate_counter_incr(&invocation_counter_overflow, NULL, NULL); | |
| 843 } | |
| 844 | |
| 845 Label continue_after_compile; | |
| 846 __ bind(continue_after_compile); | |
| 847 | |
| 848 bang_stack_shadow_pages(true); | |
| 849 | |
| 850 // reset the _do_not_unlock_if_synchronized flag | |
| 851 __ movbool(do_not_unlock_if_synchronized, false); | |
| 852 | |
| 853 // check for synchronized methods | |
| 854 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 855 // so method is not locked if overflows. | |
| 856 if (synchronized) { | |
| 857 lock_method(); | |
| 858 } else { | |
| 859 // no synchronization necessary | |
| 860 #ifdef ASSERT | |
| 861 { | |
| 862 Label L; | |
| 863 __ movl(rax, access_flags); | |
| 864 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 865 __ jcc(Assembler::zero, L); | |
| 866 __ stop("method needs synchronization"); | |
| 867 __ bind(L); | |
| 868 } | |
| 869 #endif | |
| 870 } | |
| 871 | |
| 872 // start execution | |
| 873 #ifdef ASSERT | |
| 874 { | |
| 875 Label L; | |
| 876 const Address monitor_block_top(rbp, | |
| 877 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 878 __ movptr(rax, monitor_block_top); |
| 879 __ cmpptr(rax, rsp); | |
| 0 | 880 __ jcc(Assembler::equal, L); |
| 881 __ stop("broken stack frame setup in interpreter"); | |
| 882 __ bind(L); | |
| 883 } | |
| 884 #endif | |
| 885 | |
| 886 // jvmti support | |
| 887 __ notify_method_entry(); | |
| 888 | |
| 889 // work registers | |
| 890 const Register method = rbx; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
891 const Register t = r11; |
| 0 | 892 |
| 893 // allocate space for parameters | |
| 894 __ get_method(method); | |
| 895 __ verify_oop(method); | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
896 __ load_unsigned_short(t, |
|
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
897 Address(method, |
|
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
898 methodOopDesc::size_of_parameters_offset())); |
| 1506 | 899 __ shll(t, Interpreter::logStackElementSize); |
| 0 | 900 |
| 304 | 901 __ subptr(rsp, t); |
| 902 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows | |
| 605 | 903 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) |
| 0 | 904 |
| 905 // get signature handler | |
| 906 { | |
| 907 Label L; | |
| 304 | 908 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset())); |
| 909 __ testptr(t, t); | |
| 0 | 910 __ jcc(Assembler::notZero, L); |
| 911 __ call_VM(noreg, | |
| 912 CAST_FROM_FN_PTR(address, | |
| 913 InterpreterRuntime::prepare_native_call), | |
| 914 method); | |
| 915 __ get_method(method); | |
| 304 | 916 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset())); |
| 0 | 917 __ bind(L); |
| 918 } | |
| 919 | |
| 920 // call signature handler | |
| 921 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == r14, | |
| 922 "adjust this code"); | |
| 923 assert(InterpreterRuntime::SignatureHandlerGenerator::to() == rsp, | |
| 924 "adjust this code"); | |
| 925 assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == rscratch1, | |
| 926 "adjust this code"); | |
| 927 | |
| 928 // The generated handlers do not touch RBX (the method oop). | |
| 929 // However, large signatures cannot be cached and are generated | |
| 930 // each time here. The slow-path generator can do a GC on return, | |
| 931 // so we must reload it after the call. | |
| 932 __ call(t); | |
| 933 __ get_method(method); // slow path can do a GC, reload RBX | |
| 934 | |
| 935 | |
| 936 // result handler is in rax | |
| 937 // set result handler | |
| 304 | 938 __ movptr(Address(rbp, |
| 939 (frame::interpreter_frame_result_handler_offset) * wordSize), | |
| 940 rax); | |
| 0 | 941 |
| 942 // pass mirror handle if static call | |
| 943 { | |
| 944 Label L; | |
| 945 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + | |
| 946 Klass::java_mirror_offset_in_bytes(); | |
| 947 __ movl(t, Address(method, methodOopDesc::access_flags_offset())); | |
| 948 __ testl(t, JVM_ACC_STATIC); | |
| 949 __ jcc(Assembler::zero, L); | |
| 950 // get mirror | |
| 304 | 951 __ movptr(t, Address(method, methodOopDesc::constants_offset())); |
| 952 __ movptr(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes())); | |
| 953 __ movptr(t, Address(t, mirror_offset)); | |
| 0 | 954 // copy mirror into activation frame |
| 304 | 955 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), |
| 0 | 956 t); |
| 957 // pass handle to mirror | |
| 304 | 958 __ lea(c_rarg1, |
| 959 Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize)); | |
| 0 | 960 __ bind(L); |
| 961 } | |
| 962 | |
| 963 // get native function entry point | |
| 964 { | |
| 965 Label L; | |
| 304 | 966 __ movptr(rax, Address(method, methodOopDesc::native_function_offset())); |
| 0 | 967 ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry()); |
| 968 __ movptr(rscratch2, unsatisfied.addr()); | |
| 304 | 969 __ cmpptr(rax, rscratch2); |
| 0 | 970 __ jcc(Assembler::notEqual, L); |
| 971 __ call_VM(noreg, | |
| 972 CAST_FROM_FN_PTR(address, | |
| 973 InterpreterRuntime::prepare_native_call), | |
| 974 method); | |
| 975 __ get_method(method); | |
| 976 __ verify_oop(method); | |
| 304 | 977 __ movptr(rax, Address(method, methodOopDesc::native_function_offset())); |
| 0 | 978 __ bind(L); |
| 979 } | |
| 980 | |
| 981 // pass JNIEnv | |
| 304 | 982 __ lea(c_rarg0, Address(r15_thread, JavaThread::jni_environment_offset())); |
| 0 | 983 |
| 984 // It is enough that the pc() points into the right code | |
| 985 // segment. It does not have to be the correct return pc. | |
| 986 __ set_last_Java_frame(rsp, rbp, (address) __ pc()); | |
| 987 | |
| 988 // change thread state | |
| 989 #ifdef ASSERT | |
| 990 { | |
| 991 Label L; | |
| 992 __ movl(t, Address(r15_thread, JavaThread::thread_state_offset())); | |
| 993 __ cmpl(t, _thread_in_Java); | |
| 994 __ jcc(Assembler::equal, L); | |
| 995 __ stop("Wrong thread state in native stub"); | |
| 996 __ bind(L); | |
| 997 } | |
| 998 #endif | |
| 999 | |
| 1000 // Change state to native | |
| 1001 | |
| 1002 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1003 _thread_in_native); | |
| 1004 | |
| 1005 // Call the native method. | |
| 1006 __ call(rax); | |
| 1007 // result potentially in rax or xmm0 | |
| 1008 | |
| 1009 // Depending on runtime options, either restore the MXCSR | |
| 1010 // register after returning from the JNI Call or verify that | |
| 1011 // it wasn't changed during -Xcheck:jni. | |
| 1012 if (RestoreMXCSROnJNICalls) { | |
| 304 | 1013 __ ldmxcsr(ExternalAddress(StubRoutines::x86::mxcsr_std())); |
| 0 | 1014 } |
| 1015 else if (CheckJNICalls) { | |
| 304 | 1016 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, StubRoutines::x86::verify_mxcsr_entry()))); |
| 0 | 1017 } |
| 1018 | |
| 1019 // NOTE: The order of these pushes is known to frame::interpreter_frame_result | |
| 1020 // in order to extract the result of a method call. If the order of these | |
| 1021 // pushes change or anything else is added to the stack then the code in | |
| 1022 // interpreter_frame_result must also change. | |
| 1023 | |
| 1024 __ push(dtos); | |
| 1025 __ push(ltos); | |
| 1026 | |
| 1027 // change thread state | |
| 1028 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1029 _thread_in_native_trans); | |
| 1030 | |
| 1031 if (os::is_MP()) { | |
| 1032 if (UseMembar) { | |
| 1033 // Force this write out before the read below | |
| 1034 __ membar(Assembler::Membar_mask_bits( | |
| 1035 Assembler::LoadLoad | Assembler::LoadStore | | |
| 1036 Assembler::StoreLoad | Assembler::StoreStore)); | |
| 1037 } else { | |
| 1038 // Write serialization page so VM thread can do a pseudo remote membar. | |
| 1039 // We use the current thread pointer to calculate a thread specific | |
| 1040 // offset to write to within the page. This minimizes bus traffic | |
| 1041 // due to cache line collision. | |
| 1042 __ serialize_memory(r15_thread, rscratch2); | |
| 1043 } | |
| 1044 } | |
| 1045 | |
| 1046 // check for safepoint operation in progress and/or pending suspend requests | |
| 1047 { | |
| 1048 Label Continue; | |
| 1049 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), | |
| 1050 SafepointSynchronize::_not_synchronized); | |
| 1051 | |
| 1052 Label L; | |
| 1053 __ jcc(Assembler::notEqual, L); | |
| 1054 __ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0); | |
| 1055 __ jcc(Assembler::equal, Continue); | |
| 1056 __ bind(L); | |
| 1057 | |
| 1058 // Don't use call_VM as it will see a possible pending exception | |
| 1059 // and forward it and never return here preventing us from | |
| 1060 // clearing _last_native_pc down below. Also can't use | |
| 1061 // call_VM_leaf either as it will check to see if r13 & r14 are | |
| 1062 // preserved and correspond to the bcp/locals pointers. So we do a | |
| 1063 // runtime call by hand. | |
| 1064 // | |
| 304 | 1065 __ mov(c_rarg0, r15_thread); |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1066 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1067 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1068 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1069 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans))); |
| 304 | 1070 __ mov(rsp, r12); // restore sp |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1071 __ reinit_heapbase(); |
| 0 | 1072 __ bind(Continue); |
| 1073 } | |
| 1074 | |
| 1075 // change thread state | |
| 1076 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java); | |
| 1077 | |
| 1078 // reset_last_Java_frame | |
| 1079 __ reset_last_Java_frame(true, true); | |
| 1080 | |
| 1081 // reset handle block | |
| 304 | 1082 __ movptr(t, Address(r15_thread, JavaThread::active_handles_offset())); |
| 1083 __ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD); | |
| 0 | 1084 |
| 1085 // If result is an oop unbox and store it in frame where gc will see it | |
| 1086 // and result handler will pick it up | |
| 1087 | |
| 1088 { | |
| 1089 Label no_oop, store_result; | |
| 1090 __ lea(t, ExternalAddress(AbstractInterpreter::result_handler(T_OBJECT))); | |
| 304 | 1091 __ cmpptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize)); |
| 0 | 1092 __ jcc(Assembler::notEqual, no_oop); |
| 1093 // retrieve result | |
| 1094 __ pop(ltos); | |
| 304 | 1095 __ testptr(rax, rax); |
| 0 | 1096 __ jcc(Assembler::zero, store_result); |
| 304 | 1097 __ movptr(rax, Address(rax, 0)); |
| 0 | 1098 __ bind(store_result); |
| 304 | 1099 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize), rax); |
| 0 | 1100 // keep stack depth as expected by pushing oop which will eventually be discarde |
| 1101 __ push(ltos); | |
| 1102 __ bind(no_oop); | |
| 1103 } | |
| 1104 | |
| 1105 | |
| 1106 { | |
| 1107 Label no_reguard; | |
| 1108 __ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()), | |
| 1109 JavaThread::stack_guard_yellow_disabled); | |
| 1110 __ jcc(Assembler::notEqual, no_reguard); | |
| 1111 | |
| 304 | 1112 __ pusha(); // XXX only save smashed registers |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1113 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1114 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1115 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1116 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages))); |
| 304 | 1117 __ mov(rsp, r12); // restore sp |
| 1118 __ popa(); // XXX only restore smashed registers | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1119 __ reinit_heapbase(); |
| 0 | 1120 |
| 1121 __ bind(no_reguard); | |
| 1122 } | |
| 1123 | |
| 1124 | |
| 1125 // The method register is junk from after the thread_in_native transition | |
| 1126 // until here. Also can't call_VM until the bcp has been | |
| 1127 // restored. Need bcp for throwing exception below so get it now. | |
| 1128 __ get_method(method); | |
| 1129 __ verify_oop(method); | |
| 1130 | |
| 1131 // restore r13 to have legal interpreter frame, i.e., bci == 0 <=> | |
| 1132 // r13 == code_base() | |
| 304 | 1133 __ movptr(r13, Address(method, methodOopDesc::const_offset())); // get constMethodOop |
| 1134 __ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase | |
| 0 | 1135 // handle exceptions (exception handling will handle unlocking!) |
| 1136 { | |
| 1137 Label L; | |
| 304 | 1138 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD); |
| 0 | 1139 __ jcc(Assembler::zero, L); |
| 1140 // Note: At some point we may want to unify this with the code | |
| 1141 // used in call_VM_base(); i.e., we should use the | |
| 1142 // StubRoutines::forward_exception code. For now this doesn't work | |
| 1143 // here because the rsp is not correctly set at this point. | |
| 1144 __ MacroAssembler::call_VM(noreg, | |
| 1145 CAST_FROM_FN_PTR(address, | |
| 1146 InterpreterRuntime::throw_pending_exception)); | |
| 1147 __ should_not_reach_here(); | |
| 1148 __ bind(L); | |
| 1149 } | |
| 1150 | |
| 1151 // do unlocking if necessary | |
| 1152 { | |
| 1153 Label L; | |
| 1154 __ movl(t, Address(method, methodOopDesc::access_flags_offset())); | |
| 1155 __ testl(t, JVM_ACC_SYNCHRONIZED); | |
| 1156 __ jcc(Assembler::zero, L); | |
| 1157 // the code below should be shared with interpreter macro | |
| 1158 // assembler implementation | |
| 1159 { | |
| 1160 Label unlock; | |
| 1161 // BasicObjectLock will be first in list, since this is a | |
| 1162 // synchronized method. However, need to check that the object | |
| 1163 // has not been unlocked by an explicit monitorexit bytecode. | |
| 1164 const Address monitor(rbp, | |
| 1165 (intptr_t)(frame::interpreter_frame_initial_sp_offset * | |
| 1166 wordSize - sizeof(BasicObjectLock))); | |
| 1167 | |
| 1168 // monitor expect in c_rarg1 for slow unlock path | |
| 304 | 1169 __ lea(c_rarg1, monitor); // address of first monitor |
| 0 | 1170 |
| 304 | 1171 __ movptr(t, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes())); |
| 1172 __ testptr(t, t); | |
| 0 | 1173 __ jcc(Assembler::notZero, unlock); |
| 1174 | |
| 1175 // Entry already unlocked, need to throw exception | |
| 1176 __ MacroAssembler::call_VM(noreg, | |
| 1177 CAST_FROM_FN_PTR(address, | |
| 1178 InterpreterRuntime::throw_illegal_monitor_state_exception)); | |
| 1179 __ should_not_reach_here(); | |
| 1180 | |
| 1181 __ bind(unlock); | |
| 1182 __ unlock_object(c_rarg1); | |
| 1183 } | |
| 1184 __ bind(L); | |
| 1185 } | |
| 1186 | |
| 1187 // jvmti support | |
| 1188 // Note: This must happen _after_ handling/throwing any exceptions since | |
| 1189 // the exception handler code notifies the runtime of method exits | |
| 1190 // too. If this happens before, method entry/exit notifications are | |
| 1191 // not properly paired (was bug - gri 11/22/99). | |
| 1192 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI); | |
| 1193 | |
| 1194 // restore potential result in edx:eax, call result handler to | |
| 1195 // restore potential result in ST0 & handle result | |
| 1196 | |
| 1197 __ pop(ltos); | |
| 1198 __ pop(dtos); | |
| 1199 | |
| 304 | 1200 __ movptr(t, Address(rbp, |
| 1201 (frame::interpreter_frame_result_handler_offset) * wordSize)); | |
| 0 | 1202 __ call(t); |
| 1203 | |
| 1204 // remove activation | |
| 304 | 1205 __ movptr(t, Address(rbp, |
| 1206 frame::interpreter_frame_sender_sp_offset * | |
| 1207 wordSize)); // get sender sp | |
| 0 | 1208 __ leave(); // remove frame anchor |
| 304 | 1209 __ pop(rdi); // get return address |
| 1210 __ mov(rsp, t); // set sp to sender sp | |
| 0 | 1211 __ jmp(rdi); |
| 1212 | |
| 1213 if (inc_counter) { | |
| 1214 // Handle overflow of counter and compile method | |
| 1215 __ bind(invocation_counter_overflow); | |
| 1216 generate_counter_overflow(&continue_after_compile); | |
| 1217 } | |
| 1218 | |
| 1219 return entry_point; | |
| 1220 } | |
| 1221 | |
| 1222 // | |
| 1223 // Generic interpreted method entry to (asm) interpreter | |
| 1224 // | |
| 1225 address InterpreterGenerator::generate_normal_entry(bool synchronized) { | |
| 1226 // determine code generation flags | |
| 1227 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 1228 | |
| 1229 // ebx: methodOop | |
| 1230 // r13: sender sp | |
| 1231 address entry_point = __ pc(); | |
| 1232 | |
| 1233 const Address size_of_parameters(rbx, | |
| 1234 methodOopDesc::size_of_parameters_offset()); | |
| 1235 const Address size_of_locals(rbx, methodOopDesc::size_of_locals_offset()); | |
| 1236 const Address invocation_counter(rbx, | |
| 1237 methodOopDesc::invocation_counter_offset() + | |
| 1238 InvocationCounter::counter_offset()); | |
| 1239 const Address access_flags(rbx, methodOopDesc::access_flags_offset()); | |
| 1240 | |
| 1241 // get parameter size (always needed) | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1242 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 1243 |
| 1244 // rbx: methodOop | |
| 1245 // rcx: size of parameters | |
| 1246 // r13: sender_sp (could differ from sp+wordSize if we were called via c2i ) | |
| 1247 | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1248 __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words |
| 0 | 1249 __ subl(rdx, rcx); // rdx = no. of additional locals |
| 1250 | |
| 1251 // YYY | |
| 1252 // __ incrementl(rdx); | |
| 1253 // __ andl(rdx, -2); | |
| 1254 | |
| 1255 // see if we've got enough room on the stack for locals plus overhead. | |
| 1256 generate_stack_overflow_check(); | |
| 1257 | |
| 1258 // get return address | |
| 304 | 1259 __ pop(rax); |
| 0 | 1260 |
| 1261 // compute beginning of parameters (r14) | |
| 304 | 1262 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 1263 |
| 1264 // rdx - # of additional locals | |
| 1265 // allocate space for locals | |
| 1266 // explicitly initialize locals | |
| 1267 { | |
| 1268 Label exit, loop; | |
| 1269 __ testl(rdx, rdx); | |
| 1270 __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0 | |
| 1271 __ bind(loop); | |
| 304 | 1272 __ push((int) NULL_WORD); // initialize local variables |
| 0 | 1273 __ decrementl(rdx); // until everything initialized |
| 1274 __ jcc(Assembler::greater, loop); | |
| 1275 __ bind(exit); | |
| 1276 } | |
| 1277 | |
| 1278 // (pre-)fetch invocation count | |
| 1279 if (inc_counter) { | |
| 1280 __ movl(rcx, invocation_counter); | |
| 1281 } | |
| 1282 // initialize fixed part of activation frame | |
| 1283 generate_fixed_frame(false); | |
| 1284 | |
| 1285 // make sure method is not native & not abstract | |
| 1286 #ifdef ASSERT | |
| 1287 __ movl(rax, access_flags); | |
| 1288 { | |
| 1289 Label L; | |
| 1290 __ testl(rax, JVM_ACC_NATIVE); | |
| 1291 __ jcc(Assembler::zero, L); | |
| 1292 __ stop("tried to execute native method as non-native"); | |
| 1293 __ bind(L); | |
| 1294 } | |
| 1295 { | |
| 1296 Label L; | |
| 1297 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 1298 __ jcc(Assembler::zero, L); | |
| 1299 __ stop("tried to execute abstract method in interpreter"); | |
| 1300 __ bind(L); | |
| 1301 } | |
| 1302 #endif | |
| 1303 | |
| 1304 // Since at this point in the method invocation the exception | |
| 1305 // handler would try to exit the monitor of synchronized methods | |
| 1306 // which hasn't been entered yet, we set the thread local variable | |
| 1307 // _do_not_unlock_if_synchronized to true. The remove_activation | |
| 1308 // will check this flag. | |
| 1309 | |
| 1310 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 1311 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 1312 __ movbool(do_not_unlock_if_synchronized, true); | |
| 1313 | |
| 1314 // increment invocation count & check for overflow | |
| 1315 Label invocation_counter_overflow; | |
| 1316 Label profile_method; | |
| 1317 Label profile_method_continue; | |
| 1318 if (inc_counter) { | |
| 1319 generate_counter_incr(&invocation_counter_overflow, | |
| 1320 &profile_method, | |
| 1321 &profile_method_continue); | |
| 1322 if (ProfileInterpreter) { | |
| 1323 __ bind(profile_method_continue); | |
| 1324 } | |
| 1325 } | |
| 1326 | |
| 1327 Label continue_after_compile; | |
| 1328 __ bind(continue_after_compile); | |
| 1329 | |
| 1330 // check for synchronized interpreted methods | |
| 1331 bang_stack_shadow_pages(false); | |
| 1332 | |
| 1333 // reset the _do_not_unlock_if_synchronized flag | |
| 1334 __ movbool(do_not_unlock_if_synchronized, false); | |
| 1335 | |
| 1336 // check for synchronized methods | |
| 1337 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 1338 // so method is not locked if overflows. | |
| 1339 if (synchronized) { | |
| 1340 // Allocate monitor and lock method | |
| 1341 lock_method(); | |
| 1342 } else { | |
| 1343 // no synchronization necessary | |
| 1344 #ifdef ASSERT | |
| 1345 { | |
| 1346 Label L; | |
| 1347 __ movl(rax, access_flags); | |
| 1348 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 1349 __ jcc(Assembler::zero, L); | |
| 1350 __ stop("method needs synchronization"); | |
| 1351 __ bind(L); | |
| 1352 } | |
| 1353 #endif | |
| 1354 } | |
| 1355 | |
| 1356 // start execution | |
| 1357 #ifdef ASSERT | |
| 1358 { | |
| 1359 Label L; | |
| 1360 const Address monitor_block_top (rbp, | |
| 1361 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 1362 __ movptr(rax, monitor_block_top); |
| 1363 __ cmpptr(rax, rsp); | |
| 0 | 1364 __ jcc(Assembler::equal, L); |
| 1365 __ stop("broken stack frame setup in interpreter"); | |
| 1366 __ bind(L); | |
| 1367 } | |
| 1368 #endif | |
| 1369 | |
| 1370 // jvmti support | |
| 1371 __ notify_method_entry(); | |
| 1372 | |
| 1373 __ dispatch_next(vtos); | |
| 1374 | |
| 1375 // invocation counter overflow | |
| 1376 if (inc_counter) { | |
| 1377 if (ProfileInterpreter) { | |
| 1378 // We have decided to profile this method in the interpreter | |
| 1379 __ bind(profile_method); | |
|
2118
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
1380 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method)); |
|
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
1381 __ set_method_data_pointer_for_bcp(); |
|
2141
b599a4c6c2df
7012766: assert(false) failed: DEBUG MESSAGE in MacroAssembler::debug32
iveresov
parents:
2118
diff
changeset
|
1382 __ get_method(rbx); |
| 0 | 1383 __ jmp(profile_method_continue); |
| 1384 } | |
| 1385 // Handle overflow of counter and compile method | |
| 1386 __ bind(invocation_counter_overflow); | |
| 1387 generate_counter_overflow(&continue_after_compile); | |
| 1388 } | |
| 1389 | |
| 1390 return entry_point; | |
| 1391 } | |
| 1392 | |
| 1393 // Entry points | |
| 1394 // | |
| 1395 // Here we generate the various kind of entries into the interpreter. | |
| 1396 // The two main entry type are generic bytecode methods and native | |
| 1397 // call method. These both come in synchronized and non-synchronized | |
| 1398 // versions but the frame layout they create is very similar. The | |
| 1399 // other method entry types are really just special purpose entries | |
| 1400 // that are really entry and interpretation all in one. These are for | |
| 1401 // trivial methods like accessor, empty, or special math methods. | |
| 1402 // | |
| 1403 // When control flow reaches any of the entry types for the interpreter | |
| 1404 // the following holds -> | |
| 1405 // | |
| 1406 // Arguments: | |
| 1407 // | |
| 1408 // rbx: methodOop | |
| 1409 // | |
| 1410 // Stack layout immediately at entry | |
| 1411 // | |
| 1412 // [ return address ] <--- rsp | |
| 1413 // [ parameter n ] | |
| 1414 // ... | |
| 1415 // [ parameter 1 ] | |
| 1416 // [ expression stack ] (caller's java expression stack) | |
| 1417 | |
| 1418 // Assuming that we don't go to one of the trivial specialized entries | |
| 1419 // the stack will look like below when we are ready to execute the | |
| 1420 // first bytecode (or call the native routine). The register usage | |
| 1421 // will be as the template based interpreter expects (see | |
| 1422 // interpreter_amd64.hpp). | |
| 1423 // | |
| 1424 // local variables follow incoming parameters immediately; i.e. | |
| 1425 // the return address is moved to the end of the locals). | |
| 1426 // | |
| 1427 // [ monitor entry ] <--- rsp | |
| 1428 // ... | |
| 1429 // [ monitor entry ] | |
| 1430 // [ expr. stack bottom ] | |
| 1431 // [ saved r13 ] | |
| 1432 // [ current r14 ] | |
| 1433 // [ methodOop ] | |
| 1434 // [ saved ebp ] <--- rbp | |
| 1435 // [ return address ] | |
| 1436 // [ local variable m ] | |
| 1437 // ... | |
| 1438 // [ local variable 1 ] | |
| 1439 // [ parameter n ] | |
| 1440 // ... | |
| 1441 // [ parameter 1 ] <--- r14 | |
| 1442 | |
| 1443 address AbstractInterpreterGenerator::generate_method_entry( | |
| 1444 AbstractInterpreter::MethodKind kind) { | |
| 1445 // determine code generation flags | |
| 1446 bool synchronized = false; | |
| 1447 address entry_point = NULL; | |
| 1448 | |
| 1449 switch (kind) { | |
| 1450 case Interpreter::zerolocals : break; | |
| 1451 case Interpreter::zerolocals_synchronized: synchronized = true; break; | |
| 1452 case Interpreter::native : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false); break; | |
| 1453 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(true); break; | |
| 1454 case Interpreter::empty : entry_point = ((InterpreterGenerator*) this)->generate_empty_entry(); break; | |
| 1455 case Interpreter::accessor : entry_point = ((InterpreterGenerator*) this)->generate_accessor_entry(); break; | |
| 1456 case Interpreter::abstract : entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); break; | |
| 710 | 1457 case Interpreter::method_handle : entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry();break; |
|
706
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1458 |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1459 case Interpreter::java_lang_math_sin : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1460 case Interpreter::java_lang_math_cos : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1461 case Interpreter::java_lang_math_tan : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1462 case Interpreter::java_lang_math_abs : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1463 case Interpreter::java_lang_math_log : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1464 case Interpreter::java_lang_math_log10 : // fall thru |
| 0 | 1465 case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); break; |
| 1466 default : ShouldNotReachHere(); break; | |
| 1467 } | |
| 1468 | |
| 1469 if (entry_point) { | |
| 1470 return entry_point; | |
| 1471 } | |
| 1472 | |
| 1473 return ((InterpreterGenerator*) this)-> | |
| 1474 generate_normal_entry(synchronized); | |
| 1475 } | |
| 1476 | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1477 // These should never be compiled since the interpreter will prefer |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1478 // the compiled version to the intrinsic version. |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1479 bool AbstractInterpreter::can_be_compiled(methodHandle m) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1480 switch (method_kind(m)) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1481 case Interpreter::java_lang_math_sin : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1482 case Interpreter::java_lang_math_cos : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1483 case Interpreter::java_lang_math_tan : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1484 case Interpreter::java_lang_math_abs : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1485 case Interpreter::java_lang_math_log : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1486 case Interpreter::java_lang_math_log10 : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1487 case Interpreter::java_lang_math_sqrt : |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1488 return false; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1489 default: |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1490 return true; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1491 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1492 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1493 |
| 0 | 1494 // How much stack a method activation needs in words. |
| 1495 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) { | |
| 1496 const int entry_size = frame::interpreter_frame_monitor_size(); | |
| 1497 | |
| 1498 // total overhead size: entry_size + (saved rbp thru expr stack | |
| 1499 // bottom). be sure to change this if you add/subtract anything | |
| 1500 // to/from the overhead area | |
| 1501 const int overhead_size = | |
| 1502 -(frame::interpreter_frame_initial_sp_offset) + entry_size; | |
| 1503 | |
| 1504 const int stub_code = frame::entry_frame_after_call_words; | |
| 710 | 1505 const int extra_stack = methodOopDesc::extra_stack_entries(); |
| 1506 const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) * | |
| 1506 | 1507 Interpreter::stackElementWords; |
| 0 | 1508 return (overhead_size + method_stack + stub_code); |
| 1509 } | |
| 1510 | |
| 1511 int AbstractInterpreter::layout_activation(methodOop method, | |
| 1512 int tempcount, | |
| 1513 int popframe_extra_args, | |
| 1514 int moncount, | |
| 1515 int callee_param_count, | |
| 1516 int callee_locals, | |
| 1517 frame* caller, | |
| 1518 frame* interpreter_frame, | |
| 1519 bool is_top_frame) { | |
| 1520 // Note: This calculation must exactly parallel the frame setup | |
| 1521 // in AbstractInterpreterGenerator::generate_method_entry. | |
| 1522 // If interpreter_frame!=NULL, set up the method, locals, and monitors. | |
| 1523 // The frame interpreter_frame, if not NULL, is guaranteed to be the | |
| 1524 // right size, as determined by a previous call to this method. | |
| 1525 // It is also guaranteed to be walkable even though it is in a skeletal state | |
| 1526 | |
| 1527 // fixed size of an interpreter frame: | |
| 1506 | 1528 int max_locals = method->max_locals() * Interpreter::stackElementWords; |
| 0 | 1529 int extra_locals = (method->max_locals() - method->size_of_parameters()) * |
| 1506 | 1530 Interpreter::stackElementWords; |
| 0 | 1531 |
| 1532 int overhead = frame::sender_sp_offset - | |
| 1533 frame::interpreter_frame_initial_sp_offset; | |
| 1534 // Our locals were accounted for by the caller (or last_frame_adjust | |
| 1535 // on the transistion) Since the callee parameters already account | |
| 1536 // for the callee's params we only need to account for the extra | |
| 1537 // locals. | |
| 1538 int size = overhead + | |
| 1506 | 1539 (callee_locals - callee_param_count)*Interpreter::stackElementWords + |
| 0 | 1540 moncount * frame::interpreter_frame_monitor_size() + |
| 1506 | 1541 tempcount* Interpreter::stackElementWords + popframe_extra_args; |
| 0 | 1542 if (interpreter_frame != NULL) { |
| 1543 #ifdef ASSERT | |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2245
diff
changeset
|
1544 if (!EnableInvokeDynamic) |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1545 // @@@ FIXME: Should we correct interpreter_frame_sender_sp in the calling sequences? |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1546 // Probably, since deoptimization doesn't work yet. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1547 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable"); |
| 0 | 1548 assert(caller->sp() == interpreter_frame->sender_sp(), "Frame not properly walkable(2)"); |
| 1549 #endif | |
| 1550 | |
| 1551 interpreter_frame->interpreter_frame_set_method(method); | |
| 1552 // NOTE the difference in using sender_sp and | |
| 1553 // interpreter_frame_sender_sp interpreter_frame_sender_sp is | |
| 1554 // the original sp of the caller (the unextended_sp) and | |
| 1555 // sender_sp is fp+16 XXX | |
| 1556 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1; | |
| 1557 | |
| 1558 interpreter_frame->interpreter_frame_set_locals(locals); | |
| 1559 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin(); | |
| 1560 BasicObjectLock* monbot = montop - moncount; | |
| 1561 interpreter_frame->interpreter_frame_set_monitor_end(monbot); | |
| 1562 | |
| 1563 // Set last_sp | |
| 1564 intptr_t* esp = (intptr_t*) monbot - | |
| 1506 | 1565 tempcount*Interpreter::stackElementWords - |
| 0 | 1566 popframe_extra_args; |
| 1567 interpreter_frame->interpreter_frame_set_last_sp(esp); | |
| 1568 | |
| 1569 // All frames but the initial (oldest) interpreter frame we fill in have | |
| 1570 // a value for sender_sp that allows walking the stack but isn't | |
| 1571 // truly correct. Correct the value here. | |
| 1572 if (extra_locals != 0 && | |
| 1573 interpreter_frame->sender_sp() == | |
| 1574 interpreter_frame->interpreter_frame_sender_sp()) { | |
| 1575 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() + | |
| 1576 extra_locals); | |
| 1577 } | |
| 1578 *interpreter_frame->interpreter_frame_cache_addr() = | |
| 1579 method->constants()->cache(); | |
| 1580 } | |
| 1581 return size; | |
| 1582 } | |
| 1583 | |
| 1584 //----------------------------------------------------------------------------- | |
| 1585 // Exceptions | |
| 1586 | |
| 1587 void TemplateInterpreterGenerator::generate_throw_exception() { | |
| 1588 // Entry point in previous activation (i.e., if the caller was | |
| 1589 // interpreted) | |
| 1590 Interpreter::_rethrow_exception_entry = __ pc(); | |
| 1591 // Restore sp to interpreter_frame_last_sp even though we are going | |
| 1592 // to empty the expression stack for the exception processing. | |
| 304 | 1593 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 1594 // rax: exception |
| 1595 // rdx: return address/pc that threw exception | |
| 1596 __ restore_bcp(); // r13 points to call/send | |
| 1597 __ restore_locals(); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1598 __ reinit_heapbase(); // restore r12 as heapbase. |
| 0 | 1599 // Entry point for exceptions thrown within interpreter code |
| 1600 Interpreter::_throw_exception_entry = __ pc(); | |
| 1601 // expression stack is undefined here | |
| 1602 // rax: exception | |
| 1603 // r13: exception bcp | |
| 1604 __ verify_oop(rax); | |
| 304 | 1605 __ mov(c_rarg1, rax); |
| 0 | 1606 |
| 1607 // expression stack must be empty before entering the VM in case of | |
| 1608 // an exception | |
| 1609 __ empty_expression_stack(); | |
| 1610 // find exception handler address and preserve exception oop | |
| 1611 __ call_VM(rdx, | |
| 1612 CAST_FROM_FN_PTR(address, | |
| 1613 InterpreterRuntime::exception_handler_for_exception), | |
| 1614 c_rarg1); | |
| 1615 // rax: exception handler entry point | |
| 1616 // rdx: preserved exception oop | |
| 1617 // r13: bcp for exception handler | |
| 1618 __ push_ptr(rdx); // push exception which is now the only value on the stack | |
| 1619 __ jmp(rax); // jump to exception handler (may be _remove_activation_entry!) | |
| 1620 | |
| 1621 // If the exception is not handled in the current frame the frame is | |
| 1622 // removed and the exception is rethrown (i.e. exception | |
| 1623 // continuation is _rethrow_exception). | |
| 1624 // | |
| 1625 // Note: At this point the bci is still the bxi for the instruction | |
| 1626 // which caused the exception and the expression stack is | |
| 1627 // empty. Thus, for any VM calls at this point, GC will find a legal | |
| 1628 // oop map (with empty expression stack). | |
| 1629 | |
| 1630 // In current activation | |
| 1631 // tos: exception | |
| 1632 // esi: exception bcp | |
| 1633 | |
| 1634 // | |
| 1635 // JVMTI PopFrame support | |
| 1636 // | |
| 1637 | |
| 1638 Interpreter::_remove_activation_preserving_args_entry = __ pc(); | |
| 1639 __ empty_expression_stack(); | |
| 1640 // Set the popframe_processing bit in pending_popframe_condition | |
| 1641 // indicating that we are currently handling popframe, so that | |
| 1642 // call_VMs that may happen later do not trigger new popframe | |
| 1643 // handling cycles. | |
| 1644 __ movl(rdx, Address(r15_thread, JavaThread::popframe_condition_offset())); | |
| 1645 __ orl(rdx, JavaThread::popframe_processing_bit); | |
| 1646 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), rdx); | |
| 1647 | |
| 1648 { | |
| 1649 // Check to see whether we are returning to a deoptimized frame. | |
| 1650 // (The PopFrame call ensures that the caller of the popped frame is | |
| 1651 // either interpreted or compiled and deoptimizes it if compiled.) | |
| 1652 // In this case, we can't call dispatch_next() after the frame is | |
| 1653 // popped, but instead must save the incoming arguments and restore | |
| 1654 // them after deoptimization has occurred. | |
| 1655 // | |
| 1656 // Note that we don't compare the return PC against the | |
| 1657 // deoptimization blob's unpack entry because of the presence of | |
| 1658 // adapter frames in C2. | |
| 1659 Label caller_not_deoptimized; | |
| 304 | 1660 __ movptr(c_rarg1, Address(rbp, frame::return_addr_offset * wordSize)); |
| 0 | 1661 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1662 InterpreterRuntime::interpreter_contains), c_rarg1); | |
| 1663 __ testl(rax, rax); | |
| 1664 __ jcc(Assembler::notZero, caller_not_deoptimized); | |
| 1665 | |
| 1666 // Compute size of arguments for saving when returning to | |
| 1667 // deoptimized caller | |
| 1668 __ get_method(rax); | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1669 __ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc:: |
| 0 | 1670 size_of_parameters_offset()))); |
| 1506 | 1671 __ shll(rax, Interpreter::logStackElementSize); |
| 0 | 1672 __ restore_locals(); // XXX do we need this? |
| 304 | 1673 __ subptr(r14, rax); |
| 1674 __ addptr(r14, wordSize); | |
| 0 | 1675 // Save these arguments |
| 1676 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, | |
| 1677 Deoptimization:: | |
| 1678 popframe_preserve_args), | |
| 1679 r15_thread, rax, r14); | |
| 1680 | |
| 1681 __ remove_activation(vtos, rdx, | |
| 1682 /* throw_monitor_exception */ false, | |
| 1683 /* install_monitor_exception */ false, | |
| 1684 /* notify_jvmdi */ false); | |
| 1685 | |
| 1686 // Inform deoptimization that it is responsible for restoring | |
| 1687 // these arguments | |
| 1688 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1689 JavaThread::popframe_force_deopt_reexecution_bit); | |
| 1690 | |
| 1691 // Continue in deoptimization handler | |
| 1692 __ jmp(rdx); | |
| 1693 | |
| 1694 __ bind(caller_not_deoptimized); | |
| 1695 } | |
| 1696 | |
| 1697 __ remove_activation(vtos, rdx, /* rdx result (retaddr) is not used */ | |
| 1698 /* throw_monitor_exception */ false, | |
| 1699 /* install_monitor_exception */ false, | |
| 1700 /* notify_jvmdi */ false); | |
| 1701 | |
| 1702 // Finish with popframe handling | |
| 1703 // A previous I2C followed by a deoptimization might have moved the | |
| 1704 // outgoing arguments further up the stack. PopFrame expects the | |
| 1705 // mutations to those outgoing arguments to be preserved and other | |
| 1706 // constraints basically require this frame to look exactly as | |
| 1707 // though it had previously invoked an interpreted activation with | |
| 1708 // no space between the top of the expression stack (current | |
| 1709 // last_sp) and the top of stack. Rather than force deopt to | |
| 1710 // maintain this kind of invariant all the time we call a small | |
| 1711 // fixup routine to move the mutated arguments onto the top of our | |
| 1712 // expression stack if necessary. | |
| 304 | 1713 __ mov(c_rarg1, rsp); |
| 1714 __ movptr(c_rarg2, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); | |
| 0 | 1715 // PC must point into interpreter here |
| 1716 __ set_last_Java_frame(noreg, rbp, __ pc()); | |
| 1717 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), r15_thread, c_rarg1, c_rarg2); | |
| 1718 __ reset_last_Java_frame(true, true); | |
| 1719 // Restore the last_sp and null it out | |
| 304 | 1720 __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); |
| 1721 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); | |
| 0 | 1722 |
| 1723 __ restore_bcp(); // XXX do we need this? | |
| 1724 __ restore_locals(); // XXX do we need this? | |
| 1725 // The method data pointer was incremented already during | |
| 1726 // call profiling. We have to restore the mdp for the current bcp. | |
| 1727 if (ProfileInterpreter) { | |
| 1728 __ set_method_data_pointer_for_bcp(); | |
| 1729 } | |
| 1730 | |
| 1731 // Clear the popframe condition flag | |
| 1732 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1733 JavaThread::popframe_inactive); | |
| 1734 | |
| 1735 __ dispatch_next(vtos); | |
| 1736 // end of PopFrame support | |
| 1737 | |
| 1738 Interpreter::_remove_activation_entry = __ pc(); | |
| 1739 | |
| 1740 // preserve exception over this code sequence | |
| 1741 __ pop_ptr(rax); | |
| 304 | 1742 __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), rax); |
| 0 | 1743 // remove the activation (without doing throws on illegalMonitorExceptions) |
| 1744 __ remove_activation(vtos, rdx, false, true, false); | |
| 1745 // restore exception | |
| 304 | 1746 __ movptr(rax, Address(r15_thread, JavaThread::vm_result_offset())); |
| 1747 __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), (int32_t)NULL_WORD); | |
| 0 | 1748 __ verify_oop(rax); |
| 1749 | |
| 1750 // In between activations - previous activation type unknown yet | |
| 1751 // compute continuation point - the continuation point expects the | |
| 1752 // following registers set up: | |
| 1753 // | |
| 1754 // rax: exception | |
| 1755 // rdx: return address/pc that threw exception | |
| 1756 // rsp: expression stack of caller | |
| 1757 // rbp: ebp of caller | |
| 304 | 1758 __ push(rax); // save exception |
| 1759 __ push(rdx); // save return address | |
| 0 | 1760 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1761 SharedRuntime::exception_handler_for_return_address), | |
| 1295 | 1762 r15_thread, rdx); |
| 304 | 1763 __ mov(rbx, rax); // save exception handler |
| 1764 __ pop(rdx); // restore return address | |
| 1765 __ pop(rax); // restore exception | |
| 0 | 1766 // Note that an "issuing PC" is actually the next PC after the call |
| 1767 __ jmp(rbx); // jump to exception | |
| 1768 // handler of caller | |
| 1769 } | |
| 1770 | |
| 1771 | |
| 1772 // | |
| 1773 // JVMTI ForceEarlyReturn support | |
| 1774 // | |
| 1775 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) { | |
| 1776 address entry = __ pc(); | |
| 1777 | |
| 1778 __ restore_bcp(); | |
| 1779 __ restore_locals(); | |
| 1780 __ empty_expression_stack(); | |
| 1781 __ load_earlyret_value(state); | |
| 1782 | |
| 304 | 1783 __ movptr(rdx, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); |
| 0 | 1784 Address cond_addr(rdx, JvmtiThreadState::earlyret_state_offset()); |
| 1785 | |
| 1786 // Clear the earlyret state | |
| 1787 __ movl(cond_addr, JvmtiThreadState::earlyret_inactive); | |
| 1788 | |
| 1789 __ remove_activation(state, rsi, | |
| 1790 false, /* throw_monitor_exception */ | |
| 1791 false, /* install_monitor_exception */ | |
| 1792 true); /* notify_jvmdi */ | |
| 1793 __ jmp(rsi); | |
| 1794 | |
| 1795 return entry; | |
| 1796 } // end of ForceEarlyReturn support | |
| 1797 | |
| 1798 | |
| 1799 //----------------------------------------------------------------------------- | |
| 1800 // Helper for vtos entry point generation | |
| 1801 | |
| 1802 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t, | |
| 1803 address& bep, | |
| 1804 address& cep, | |
| 1805 address& sep, | |
| 1806 address& aep, | |
| 1807 address& iep, | |
| 1808 address& lep, | |
| 1809 address& fep, | |
| 1810 address& dep, | |
| 1811 address& vep) { | |
| 1812 assert(t->is_valid() && t->tos_in() == vtos, "illegal template"); | |
| 1813 Label L; | |
| 1814 aep = __ pc(); __ push_ptr(); __ jmp(L); | |
| 1815 fep = __ pc(); __ push_f(); __ jmp(L); | |
| 1816 dep = __ pc(); __ push_d(); __ jmp(L); | |
| 1817 lep = __ pc(); __ push_l(); __ jmp(L); | |
| 1818 bep = cep = sep = | |
| 1819 iep = __ pc(); __ push_i(); | |
| 1820 vep = __ pc(); | |
| 1821 __ bind(L); | |
| 1822 generate_and_dispatch(t); | |
| 1823 } | |
| 1824 | |
| 1825 | |
| 1826 //----------------------------------------------------------------------------- | |
| 1827 // Generation of individual instructions | |
| 1828 | |
| 1829 // helpers for generate_and_dispatch | |
| 1830 | |
| 1831 | |
| 1832 InterpreterGenerator::InterpreterGenerator(StubQueue* code) | |
| 1833 : TemplateInterpreterGenerator(code) { | |
| 1834 generate_all(); // down here so it can be "virtual" | |
| 1835 } | |
| 1836 | |
| 1837 //----------------------------------------------------------------------------- | |
| 1838 | |
| 1839 // Non-product code | |
| 1840 #ifndef PRODUCT | |
| 1841 address TemplateInterpreterGenerator::generate_trace_code(TosState state) { | |
| 1842 address entry = __ pc(); | |
| 1843 | |
| 1844 __ push(state); | |
| 304 | 1845 __ push(c_rarg0); |
| 1846 __ push(c_rarg1); | |
| 1847 __ push(c_rarg2); | |
| 1848 __ push(c_rarg3); | |
| 1849 __ mov(c_rarg2, rax); // Pass itos | |
| 0 | 1850 #ifdef _WIN64 |
| 1851 __ movflt(xmm3, xmm0); // Pass ftos | |
| 1852 #endif | |
| 1853 __ call_VM(noreg, | |
| 1854 CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), | |
| 1855 c_rarg1, c_rarg2, c_rarg3); | |
| 304 | 1856 __ pop(c_rarg3); |
| 1857 __ pop(c_rarg2); | |
| 1858 __ pop(c_rarg1); | |
| 1859 __ pop(c_rarg0); | |
| 0 | 1860 __ pop(state); |
| 1861 __ ret(0); // return from result handler | |
| 1862 | |
| 1863 return entry; | |
| 1864 } | |
| 1865 | |
| 1866 void TemplateInterpreterGenerator::count_bytecode() { | |
| 1867 __ incrementl(ExternalAddress((address) &BytecodeCounter::_counter_value)); | |
| 1868 } | |
| 1869 | |
| 1870 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { | |
| 1871 __ incrementl(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()])); | |
| 1872 } | |
| 1873 | |
| 1874 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { | |
| 1875 __ mov32(rbx, ExternalAddress((address) &BytecodePairHistogram::_index)); | |
| 1876 __ shrl(rbx, BytecodePairHistogram::log2_number_of_codes); | |
| 1877 __ orl(rbx, | |
| 1878 ((int) t->bytecode()) << | |
| 1879 BytecodePairHistogram::log2_number_of_codes); | |
| 1880 __ mov32(ExternalAddress((address) &BytecodePairHistogram::_index), rbx); | |
| 1881 __ lea(rscratch1, ExternalAddress((address) BytecodePairHistogram::_counters)); | |
| 1882 __ incrementl(Address(rscratch1, rbx, Address::times_4)); | |
| 1883 } | |
| 1884 | |
| 1885 | |
| 1886 void TemplateInterpreterGenerator::trace_bytecode(Template* t) { | |
| 1887 // Call a little run-time stub to avoid blow-up for each bytecode. | |
| 1888 // The run-time runtime saves the right registers, depending on | |
| 1889 // the tosca in-state for the given template. | |
| 1890 | |
| 1891 assert(Interpreter::trace_code(t->tos_in()) != NULL, | |
| 1892 "entry must have been generated"); | |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1893 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1894 __ andptr(rsp, -16); // align stack as required by ABI |
| 0 | 1895 __ call(RuntimeAddress(Interpreter::trace_code(t->tos_in()))); |
| 304 | 1896 __ mov(rsp, r12); // restore sp |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1897 __ reinit_heapbase(); |
| 0 | 1898 } |
| 1899 | |
| 1900 | |
| 1901 void TemplateInterpreterGenerator::stop_interpreter_at() { | |
| 1902 Label L; | |
| 1903 __ cmp32(ExternalAddress((address) &BytecodeCounter::_counter_value), | |
| 1904 StopInterpreterAt); | |
| 1905 __ jcc(Assembler::notEqual, L); | |
| 1906 __ int3(); | |
| 1907 __ bind(L); | |
| 1908 } | |
| 1909 #endif // !PRODUCT | |
| 304 | 1910 #endif // ! CC_INTERP |