Mercurial > hg > graal-compiler
annotate src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 3249:e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
| author | johnc |
|---|---|
| date | Thu, 07 Apr 2011 09:53:20 -0700 |
| parents | 638119ce7cfd |
| 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 | |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
760 // Method entry for java.lang.ref.Reference.get. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
761 address InterpreterGenerator::generate_Reference_get_entry(void) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
762 #ifndef SERIALGC |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
763 // Code: _aload_0, _getfield, _areturn |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
764 // parameter size = 1 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
765 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
766 // The code that gets generated by this routine is split into 2 parts: |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
767 // 1. The "intrinsified" code for G1 (or any SATB based GC), |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
768 // 2. The slow path - which is an expansion of the regular method entry. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
769 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
770 // Notes:- |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
771 // * In the G1 code we do not check whether we need to block for |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
772 // a safepoint. If G1 is enabled then we must execute the specialized |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
773 // code for Reference.get (except when the Reference object is null) |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
774 // so that we can log the value in the referent field with an SATB |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
775 // update buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
776 // If the code for the getfield template is modified so that the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
777 // G1 pre-barrier code is executed when the current method is |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
778 // Reference.get() then going through the normal method entry |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
779 // will be fine. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
780 // * The G1 code can, however, check the receiver object (the instance |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
781 // of java.lang.Reference) and jump to the slow path if null. If the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
782 // Reference object is null then we obviously cannot fetch the referent |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
783 // and so we don't need to call the G1 pre-barrier. Thus we can use the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
784 // regular method entry code to generate the NPE. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
785 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
786 // This code is based on generate_accessor_enty. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
787 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
788 // rbx: methodOop |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
789 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
790 // r13: senderSP must preserve for slow path, set SP to it on fast path |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
791 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
792 address entry = __ pc(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
793 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
794 const int referent_offset = java_lang_ref_Reference::referent_offset; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
795 guarantee(referent_offset > 0, "referent offset not initialized"); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
796 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
797 if (UseG1GC) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
798 Label slow_path; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
799 // rbx: method |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
800 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
801 // Check if local 0 != NULL |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
802 // If the receiver is null then it is OK to jump to the slow path. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
803 __ movptr(rax, Address(rsp, wordSize)); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
804 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
805 __ testptr(rax, rax); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
806 __ jcc(Assembler::zero, slow_path); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
807 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
808 // rax: local 0 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
809 // rbx: method (but can be used as scratch now) |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
810 // rdx: scratch |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
811 // rdi: scratch |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
812 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
813 // Generate the G1 pre-barrier code to log the value of |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
814 // the referent field in an SATB buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
815 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
816 // Load the value of the referent field. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
817 const Address field_address(rax, referent_offset); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
818 __ load_heap_oop(rax, field_address); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
819 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
820 // Generate the G1 pre-barrier code to log the value of |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
821 // the referent field in an SATB buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
822 __ g1_write_barrier_pre(noreg /* obj */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
823 rax /* pre_val */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
824 r15_thread /* thread */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
825 rbx /* tmp */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
826 true /* tosca_live */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
827 true /* expand_call */); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
828 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
829 // _areturn |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
830 __ pop(rdi); // get return address |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
831 __ mov(rsp, r13); // set sp to sender sp |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
832 __ jmp(rdi); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
833 __ ret(0); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
834 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
835 // generate a vanilla interpreter entry as the slow path |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
836 __ bind(slow_path); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
837 (void) generate_normal_entry(false); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
838 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
839 return entry; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
840 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
841 #endif // SERIALGC |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
842 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
843 // If G1 is not enabled then attempt to go through the accessor entry point |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
844 // Reference.get is an accessor |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
845 return generate_accessor_entry(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
846 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
847 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
848 |
| 0 | 849 // Interpreter stub for calling a native method. (asm interpreter) |
| 850 // This sets up a somewhat different looking stack for calling the | |
| 851 // native method than the typical interpreter frame setup. | |
| 852 address InterpreterGenerator::generate_native_entry(bool synchronized) { | |
| 853 // determine code generation flags | |
| 854 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 855 | |
| 856 // rbx: methodOop | |
| 857 // r13: sender sp | |
| 858 | |
| 859 address entry_point = __ pc(); | |
| 860 | |
| 861 const Address size_of_parameters(rbx, methodOopDesc:: | |
| 862 size_of_parameters_offset()); | |
| 863 const Address invocation_counter(rbx, methodOopDesc:: | |
| 864 invocation_counter_offset() + | |
| 865 InvocationCounter::counter_offset()); | |
| 866 const Address access_flags (rbx, methodOopDesc::access_flags_offset()); | |
| 867 | |
| 868 // get parameter size (always needed) | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
869 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 870 |
| 871 // native calls don't need the stack size check since they have no | |
| 872 // expression stack and the arguments are already on the stack and | |
| 873 // we only add a handful of words to the stack | |
| 874 | |
| 875 // rbx: methodOop | |
| 876 // rcx: size of parameters | |
| 877 // r13: sender sp | |
| 304 | 878 __ pop(rax); // get return address |
| 0 | 879 |
| 880 // for natives the size of locals is zero | |
| 881 | |
| 882 // compute beginning of parameters (r14) | |
| 304 | 883 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 884 |
| 885 // add 2 zero-initialized slots for native calls | |
| 886 // initialize result_handler slot | |
| 304 | 887 __ push((int) NULL_WORD); |
| 0 | 888 // slot for oop temp |
| 889 // (static native method holder mirror/jni oop result) | |
| 304 | 890 __ push((int) NULL_WORD); |
| 0 | 891 |
| 892 if (inc_counter) { | |
| 893 __ movl(rcx, invocation_counter); // (pre-)fetch invocation count | |
| 894 } | |
| 895 | |
| 896 // initialize fixed part of activation frame | |
| 897 generate_fixed_frame(true); | |
| 898 | |
| 899 // make sure method is native & not abstract | |
| 900 #ifdef ASSERT | |
| 901 __ movl(rax, access_flags); | |
| 902 { | |
| 903 Label L; | |
| 904 __ testl(rax, JVM_ACC_NATIVE); | |
| 905 __ jcc(Assembler::notZero, L); | |
| 906 __ stop("tried to execute non-native method as native"); | |
| 907 __ bind(L); | |
| 908 } | |
| 909 { | |
| 910 Label L; | |
| 911 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 912 __ jcc(Assembler::zero, L); | |
| 913 __ stop("tried to execute abstract method in interpreter"); | |
| 914 __ bind(L); | |
| 915 } | |
| 916 #endif | |
| 917 | |
| 918 // Since at this point in the method invocation the exception handler | |
| 919 // would try to exit the monitor of synchronized methods which hasn't | |
| 920 // been entered yet, we set the thread local variable | |
| 921 // _do_not_unlock_if_synchronized to true. The remove_activation will | |
| 922 // check this flag. | |
| 923 | |
| 924 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 925 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 926 __ movbool(do_not_unlock_if_synchronized, true); | |
| 927 | |
| 928 // increment invocation count & check for overflow | |
| 929 Label invocation_counter_overflow; | |
| 930 if (inc_counter) { | |
| 931 generate_counter_incr(&invocation_counter_overflow, NULL, NULL); | |
| 932 } | |
| 933 | |
| 934 Label continue_after_compile; | |
| 935 __ bind(continue_after_compile); | |
| 936 | |
| 937 bang_stack_shadow_pages(true); | |
| 938 | |
| 939 // reset the _do_not_unlock_if_synchronized flag | |
| 940 __ movbool(do_not_unlock_if_synchronized, false); | |
| 941 | |
| 942 // check for synchronized methods | |
| 943 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 944 // so method is not locked if overflows. | |
| 945 if (synchronized) { | |
| 946 lock_method(); | |
| 947 } else { | |
| 948 // no synchronization necessary | |
| 949 #ifdef ASSERT | |
| 950 { | |
| 951 Label L; | |
| 952 __ movl(rax, access_flags); | |
| 953 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 954 __ jcc(Assembler::zero, L); | |
| 955 __ stop("method needs synchronization"); | |
| 956 __ bind(L); | |
| 957 } | |
| 958 #endif | |
| 959 } | |
| 960 | |
| 961 // start execution | |
| 962 #ifdef ASSERT | |
| 963 { | |
| 964 Label L; | |
| 965 const Address monitor_block_top(rbp, | |
| 966 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 967 __ movptr(rax, monitor_block_top); |
| 968 __ cmpptr(rax, rsp); | |
| 0 | 969 __ jcc(Assembler::equal, L); |
| 970 __ stop("broken stack frame setup in interpreter"); | |
| 971 __ bind(L); | |
| 972 } | |
| 973 #endif | |
| 974 | |
| 975 // jvmti support | |
| 976 __ notify_method_entry(); | |
| 977 | |
| 978 // work registers | |
| 979 const Register method = rbx; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
980 const Register t = r11; |
| 0 | 981 |
| 982 // allocate space for parameters | |
| 983 __ get_method(method); | |
| 984 __ verify_oop(method); | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
985 __ load_unsigned_short(t, |
|
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
986 Address(method, |
|
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
987 methodOopDesc::size_of_parameters_offset())); |
| 1506 | 988 __ shll(t, Interpreter::logStackElementSize); |
| 0 | 989 |
| 304 | 990 __ subptr(rsp, t); |
| 991 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows | |
| 605 | 992 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) |
| 0 | 993 |
| 994 // get signature handler | |
| 995 { | |
| 996 Label L; | |
| 304 | 997 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset())); |
| 998 __ testptr(t, t); | |
| 0 | 999 __ jcc(Assembler::notZero, L); |
| 1000 __ call_VM(noreg, | |
| 1001 CAST_FROM_FN_PTR(address, | |
| 1002 InterpreterRuntime::prepare_native_call), | |
| 1003 method); | |
| 1004 __ get_method(method); | |
| 304 | 1005 __ movptr(t, Address(method, methodOopDesc::signature_handler_offset())); |
| 0 | 1006 __ bind(L); |
| 1007 } | |
| 1008 | |
| 1009 // call signature handler | |
| 1010 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == r14, | |
| 1011 "adjust this code"); | |
| 1012 assert(InterpreterRuntime::SignatureHandlerGenerator::to() == rsp, | |
| 1013 "adjust this code"); | |
| 1014 assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == rscratch1, | |
| 1015 "adjust this code"); | |
| 1016 | |
| 1017 // The generated handlers do not touch RBX (the method oop). | |
| 1018 // However, large signatures cannot be cached and are generated | |
| 1019 // each time here. The slow-path generator can do a GC on return, | |
| 1020 // so we must reload it after the call. | |
| 1021 __ call(t); | |
| 1022 __ get_method(method); // slow path can do a GC, reload RBX | |
| 1023 | |
| 1024 | |
| 1025 // result handler is in rax | |
| 1026 // set result handler | |
| 304 | 1027 __ movptr(Address(rbp, |
| 1028 (frame::interpreter_frame_result_handler_offset) * wordSize), | |
| 1029 rax); | |
| 0 | 1030 |
| 1031 // pass mirror handle if static call | |
| 1032 { | |
| 1033 Label L; | |
| 1034 const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + | |
| 1035 Klass::java_mirror_offset_in_bytes(); | |
| 1036 __ movl(t, Address(method, methodOopDesc::access_flags_offset())); | |
| 1037 __ testl(t, JVM_ACC_STATIC); | |
| 1038 __ jcc(Assembler::zero, L); | |
| 1039 // get mirror | |
| 304 | 1040 __ movptr(t, Address(method, methodOopDesc::constants_offset())); |
| 1041 __ movptr(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes())); | |
| 1042 __ movptr(t, Address(t, mirror_offset)); | |
| 0 | 1043 // copy mirror into activation frame |
| 304 | 1044 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), |
| 0 | 1045 t); |
| 1046 // pass handle to mirror | |
| 304 | 1047 __ lea(c_rarg1, |
| 1048 Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize)); | |
| 0 | 1049 __ bind(L); |
| 1050 } | |
| 1051 | |
| 1052 // get native function entry point | |
| 1053 { | |
| 1054 Label L; | |
| 304 | 1055 __ movptr(rax, Address(method, methodOopDesc::native_function_offset())); |
| 0 | 1056 ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry()); |
| 1057 __ movptr(rscratch2, unsatisfied.addr()); | |
| 304 | 1058 __ cmpptr(rax, rscratch2); |
| 0 | 1059 __ jcc(Assembler::notEqual, L); |
| 1060 __ call_VM(noreg, | |
| 1061 CAST_FROM_FN_PTR(address, | |
| 1062 InterpreterRuntime::prepare_native_call), | |
| 1063 method); | |
| 1064 __ get_method(method); | |
| 1065 __ verify_oop(method); | |
| 304 | 1066 __ movptr(rax, Address(method, methodOopDesc::native_function_offset())); |
| 0 | 1067 __ bind(L); |
| 1068 } | |
| 1069 | |
| 1070 // pass JNIEnv | |
| 304 | 1071 __ lea(c_rarg0, Address(r15_thread, JavaThread::jni_environment_offset())); |
| 0 | 1072 |
| 1073 // It is enough that the pc() points into the right code | |
| 1074 // segment. It does not have to be the correct return pc. | |
| 1075 __ set_last_Java_frame(rsp, rbp, (address) __ pc()); | |
| 1076 | |
| 1077 // change thread state | |
| 1078 #ifdef ASSERT | |
| 1079 { | |
| 1080 Label L; | |
| 1081 __ movl(t, Address(r15_thread, JavaThread::thread_state_offset())); | |
| 1082 __ cmpl(t, _thread_in_Java); | |
| 1083 __ jcc(Assembler::equal, L); | |
| 1084 __ stop("Wrong thread state in native stub"); | |
| 1085 __ bind(L); | |
| 1086 } | |
| 1087 #endif | |
| 1088 | |
| 1089 // Change state to native | |
| 1090 | |
| 1091 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1092 _thread_in_native); | |
| 1093 | |
| 1094 // Call the native method. | |
| 1095 __ call(rax); | |
| 1096 // result potentially in rax or xmm0 | |
| 1097 | |
| 1098 // Depending on runtime options, either restore the MXCSR | |
| 1099 // register after returning from the JNI Call or verify that | |
| 1100 // it wasn't changed during -Xcheck:jni. | |
| 1101 if (RestoreMXCSROnJNICalls) { | |
| 304 | 1102 __ ldmxcsr(ExternalAddress(StubRoutines::x86::mxcsr_std())); |
| 0 | 1103 } |
| 1104 else if (CheckJNICalls) { | |
| 304 | 1105 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, StubRoutines::x86::verify_mxcsr_entry()))); |
| 0 | 1106 } |
| 1107 | |
| 1108 // NOTE: The order of these pushes is known to frame::interpreter_frame_result | |
| 1109 // in order to extract the result of a method call. If the order of these | |
| 1110 // pushes change or anything else is added to the stack then the code in | |
| 1111 // interpreter_frame_result must also change. | |
| 1112 | |
| 1113 __ push(dtos); | |
| 1114 __ push(ltos); | |
| 1115 | |
| 1116 // change thread state | |
| 1117 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1118 _thread_in_native_trans); | |
| 1119 | |
| 1120 if (os::is_MP()) { | |
| 1121 if (UseMembar) { | |
| 1122 // Force this write out before the read below | |
| 1123 __ membar(Assembler::Membar_mask_bits( | |
| 1124 Assembler::LoadLoad | Assembler::LoadStore | | |
| 1125 Assembler::StoreLoad | Assembler::StoreStore)); | |
| 1126 } else { | |
| 1127 // Write serialization page so VM thread can do a pseudo remote membar. | |
| 1128 // We use the current thread pointer to calculate a thread specific | |
| 1129 // offset to write to within the page. This minimizes bus traffic | |
| 1130 // due to cache line collision. | |
| 1131 __ serialize_memory(r15_thread, rscratch2); | |
| 1132 } | |
| 1133 } | |
| 1134 | |
| 1135 // check for safepoint operation in progress and/or pending suspend requests | |
| 1136 { | |
| 1137 Label Continue; | |
| 1138 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), | |
| 1139 SafepointSynchronize::_not_synchronized); | |
| 1140 | |
| 1141 Label L; | |
| 1142 __ jcc(Assembler::notEqual, L); | |
| 1143 __ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0); | |
| 1144 __ jcc(Assembler::equal, Continue); | |
| 1145 __ bind(L); | |
| 1146 | |
| 1147 // Don't use call_VM as it will see a possible pending exception | |
| 1148 // and forward it and never return here preventing us from | |
| 1149 // clearing _last_native_pc down below. Also can't use | |
| 1150 // call_VM_leaf either as it will check to see if r13 & r14 are | |
| 1151 // preserved and correspond to the bcp/locals pointers. So we do a | |
| 1152 // runtime call by hand. | |
| 1153 // | |
| 304 | 1154 __ mov(c_rarg0, r15_thread); |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1155 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1156 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1157 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1158 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans))); |
| 304 | 1159 __ 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
|
1160 __ reinit_heapbase(); |
| 0 | 1161 __ bind(Continue); |
| 1162 } | |
| 1163 | |
| 1164 // change thread state | |
| 1165 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java); | |
| 1166 | |
| 1167 // reset_last_Java_frame | |
| 1168 __ reset_last_Java_frame(true, true); | |
| 1169 | |
| 1170 // reset handle block | |
| 304 | 1171 __ movptr(t, Address(r15_thread, JavaThread::active_handles_offset())); |
| 1172 __ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD); | |
| 0 | 1173 |
| 1174 // If result is an oop unbox and store it in frame where gc will see it | |
| 1175 // and result handler will pick it up | |
| 1176 | |
| 1177 { | |
| 1178 Label no_oop, store_result; | |
| 1179 __ lea(t, ExternalAddress(AbstractInterpreter::result_handler(T_OBJECT))); | |
| 304 | 1180 __ cmpptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize)); |
| 0 | 1181 __ jcc(Assembler::notEqual, no_oop); |
| 1182 // retrieve result | |
| 1183 __ pop(ltos); | |
| 304 | 1184 __ testptr(rax, rax); |
| 0 | 1185 __ jcc(Assembler::zero, store_result); |
| 304 | 1186 __ movptr(rax, Address(rax, 0)); |
| 0 | 1187 __ bind(store_result); |
| 304 | 1188 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize), rax); |
| 0 | 1189 // keep stack depth as expected by pushing oop which will eventually be discarde |
| 1190 __ push(ltos); | |
| 1191 __ bind(no_oop); | |
| 1192 } | |
| 1193 | |
| 1194 | |
| 1195 { | |
| 1196 Label no_reguard; | |
| 1197 __ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()), | |
| 1198 JavaThread::stack_guard_yellow_disabled); | |
| 1199 __ jcc(Assembler::notEqual, no_reguard); | |
| 1200 | |
| 304 | 1201 __ pusha(); // XXX only save smashed registers |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1202 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1203 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1204 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1205 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages))); |
| 304 | 1206 __ mov(rsp, r12); // restore sp |
| 1207 __ 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
|
1208 __ reinit_heapbase(); |
| 0 | 1209 |
| 1210 __ bind(no_reguard); | |
| 1211 } | |
| 1212 | |
| 1213 | |
| 1214 // The method register is junk from after the thread_in_native transition | |
| 1215 // until here. Also can't call_VM until the bcp has been | |
| 1216 // restored. Need bcp for throwing exception below so get it now. | |
| 1217 __ get_method(method); | |
| 1218 __ verify_oop(method); | |
| 1219 | |
| 1220 // restore r13 to have legal interpreter frame, i.e., bci == 0 <=> | |
| 1221 // r13 == code_base() | |
| 304 | 1222 __ movptr(r13, Address(method, methodOopDesc::const_offset())); // get constMethodOop |
| 1223 __ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase | |
| 0 | 1224 // handle exceptions (exception handling will handle unlocking!) |
| 1225 { | |
| 1226 Label L; | |
| 304 | 1227 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD); |
| 0 | 1228 __ jcc(Assembler::zero, L); |
| 1229 // Note: At some point we may want to unify this with the code | |
| 1230 // used in call_VM_base(); i.e., we should use the | |
| 1231 // StubRoutines::forward_exception code. For now this doesn't work | |
| 1232 // here because the rsp is not correctly set at this point. | |
| 1233 __ MacroAssembler::call_VM(noreg, | |
| 1234 CAST_FROM_FN_PTR(address, | |
| 1235 InterpreterRuntime::throw_pending_exception)); | |
| 1236 __ should_not_reach_here(); | |
| 1237 __ bind(L); | |
| 1238 } | |
| 1239 | |
| 1240 // do unlocking if necessary | |
| 1241 { | |
| 1242 Label L; | |
| 1243 __ movl(t, Address(method, methodOopDesc::access_flags_offset())); | |
| 1244 __ testl(t, JVM_ACC_SYNCHRONIZED); | |
| 1245 __ jcc(Assembler::zero, L); | |
| 1246 // the code below should be shared with interpreter macro | |
| 1247 // assembler implementation | |
| 1248 { | |
| 1249 Label unlock; | |
| 1250 // BasicObjectLock will be first in list, since this is a | |
| 1251 // synchronized method. However, need to check that the object | |
| 1252 // has not been unlocked by an explicit monitorexit bytecode. | |
| 1253 const Address monitor(rbp, | |
| 1254 (intptr_t)(frame::interpreter_frame_initial_sp_offset * | |
| 1255 wordSize - sizeof(BasicObjectLock))); | |
| 1256 | |
| 1257 // monitor expect in c_rarg1 for slow unlock path | |
| 304 | 1258 __ lea(c_rarg1, monitor); // address of first monitor |
| 0 | 1259 |
| 304 | 1260 __ movptr(t, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes())); |
| 1261 __ testptr(t, t); | |
| 0 | 1262 __ jcc(Assembler::notZero, unlock); |
| 1263 | |
| 1264 // Entry already unlocked, need to throw exception | |
| 1265 __ MacroAssembler::call_VM(noreg, | |
| 1266 CAST_FROM_FN_PTR(address, | |
| 1267 InterpreterRuntime::throw_illegal_monitor_state_exception)); | |
| 1268 __ should_not_reach_here(); | |
| 1269 | |
| 1270 __ bind(unlock); | |
| 1271 __ unlock_object(c_rarg1); | |
| 1272 } | |
| 1273 __ bind(L); | |
| 1274 } | |
| 1275 | |
| 1276 // jvmti support | |
| 1277 // Note: This must happen _after_ handling/throwing any exceptions since | |
| 1278 // the exception handler code notifies the runtime of method exits | |
| 1279 // too. If this happens before, method entry/exit notifications are | |
| 1280 // not properly paired (was bug - gri 11/22/99). | |
| 1281 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI); | |
| 1282 | |
| 1283 // restore potential result in edx:eax, call result handler to | |
| 1284 // restore potential result in ST0 & handle result | |
| 1285 | |
| 1286 __ pop(ltos); | |
| 1287 __ pop(dtos); | |
| 1288 | |
| 304 | 1289 __ movptr(t, Address(rbp, |
| 1290 (frame::interpreter_frame_result_handler_offset) * wordSize)); | |
| 0 | 1291 __ call(t); |
| 1292 | |
| 1293 // remove activation | |
| 304 | 1294 __ movptr(t, Address(rbp, |
| 1295 frame::interpreter_frame_sender_sp_offset * | |
| 1296 wordSize)); // get sender sp | |
| 0 | 1297 __ leave(); // remove frame anchor |
| 304 | 1298 __ pop(rdi); // get return address |
| 1299 __ mov(rsp, t); // set sp to sender sp | |
| 0 | 1300 __ jmp(rdi); |
| 1301 | |
| 1302 if (inc_counter) { | |
| 1303 // Handle overflow of counter and compile method | |
| 1304 __ bind(invocation_counter_overflow); | |
| 1305 generate_counter_overflow(&continue_after_compile); | |
| 1306 } | |
| 1307 | |
| 1308 return entry_point; | |
| 1309 } | |
| 1310 | |
| 1311 // | |
| 1312 // Generic interpreted method entry to (asm) interpreter | |
| 1313 // | |
| 1314 address InterpreterGenerator::generate_normal_entry(bool synchronized) { | |
| 1315 // determine code generation flags | |
| 1316 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 1317 | |
| 1318 // ebx: methodOop | |
| 1319 // r13: sender sp | |
| 1320 address entry_point = __ pc(); | |
| 1321 | |
| 1322 const Address size_of_parameters(rbx, | |
| 1323 methodOopDesc::size_of_parameters_offset()); | |
| 1324 const Address size_of_locals(rbx, methodOopDesc::size_of_locals_offset()); | |
| 1325 const Address invocation_counter(rbx, | |
| 1326 methodOopDesc::invocation_counter_offset() + | |
| 1327 InvocationCounter::counter_offset()); | |
| 1328 const Address access_flags(rbx, methodOopDesc::access_flags_offset()); | |
| 1329 | |
| 1330 // get parameter size (always needed) | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1331 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 1332 |
| 1333 // rbx: methodOop | |
| 1334 // rcx: size of parameters | |
| 1335 // r13: sender_sp (could differ from sp+wordSize if we were called via c2i ) | |
| 1336 | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1337 __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words |
| 0 | 1338 __ subl(rdx, rcx); // rdx = no. of additional locals |
| 1339 | |
| 1340 // YYY | |
| 1341 // __ incrementl(rdx); | |
| 1342 // __ andl(rdx, -2); | |
| 1343 | |
| 1344 // see if we've got enough room on the stack for locals plus overhead. | |
| 1345 generate_stack_overflow_check(); | |
| 1346 | |
| 1347 // get return address | |
| 304 | 1348 __ pop(rax); |
| 0 | 1349 |
| 1350 // compute beginning of parameters (r14) | |
| 304 | 1351 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 1352 |
| 1353 // rdx - # of additional locals | |
| 1354 // allocate space for locals | |
| 1355 // explicitly initialize locals | |
| 1356 { | |
| 1357 Label exit, loop; | |
| 1358 __ testl(rdx, rdx); | |
| 1359 __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0 | |
| 1360 __ bind(loop); | |
| 304 | 1361 __ push((int) NULL_WORD); // initialize local variables |
| 0 | 1362 __ decrementl(rdx); // until everything initialized |
| 1363 __ jcc(Assembler::greater, loop); | |
| 1364 __ bind(exit); | |
| 1365 } | |
| 1366 | |
| 1367 // (pre-)fetch invocation count | |
| 1368 if (inc_counter) { | |
| 1369 __ movl(rcx, invocation_counter); | |
| 1370 } | |
| 1371 // initialize fixed part of activation frame | |
| 1372 generate_fixed_frame(false); | |
| 1373 | |
| 1374 // make sure method is not native & not abstract | |
| 1375 #ifdef ASSERT | |
| 1376 __ movl(rax, access_flags); | |
| 1377 { | |
| 1378 Label L; | |
| 1379 __ testl(rax, JVM_ACC_NATIVE); | |
| 1380 __ jcc(Assembler::zero, L); | |
| 1381 __ stop("tried to execute native method as non-native"); | |
| 1382 __ bind(L); | |
| 1383 } | |
| 1384 { | |
| 1385 Label L; | |
| 1386 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 1387 __ jcc(Assembler::zero, L); | |
| 1388 __ stop("tried to execute abstract method in interpreter"); | |
| 1389 __ bind(L); | |
| 1390 } | |
| 1391 #endif | |
| 1392 | |
| 1393 // Since at this point in the method invocation the exception | |
| 1394 // handler would try to exit the monitor of synchronized methods | |
| 1395 // which hasn't been entered yet, we set the thread local variable | |
| 1396 // _do_not_unlock_if_synchronized to true. The remove_activation | |
| 1397 // will check this flag. | |
| 1398 | |
| 1399 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 1400 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 1401 __ movbool(do_not_unlock_if_synchronized, true); | |
| 1402 | |
| 1403 // increment invocation count & check for overflow | |
| 1404 Label invocation_counter_overflow; | |
| 1405 Label profile_method; | |
| 1406 Label profile_method_continue; | |
| 1407 if (inc_counter) { | |
| 1408 generate_counter_incr(&invocation_counter_overflow, | |
| 1409 &profile_method, | |
| 1410 &profile_method_continue); | |
| 1411 if (ProfileInterpreter) { | |
| 1412 __ bind(profile_method_continue); | |
| 1413 } | |
| 1414 } | |
| 1415 | |
| 1416 Label continue_after_compile; | |
| 1417 __ bind(continue_after_compile); | |
| 1418 | |
| 1419 // check for synchronized interpreted methods | |
| 1420 bang_stack_shadow_pages(false); | |
| 1421 | |
| 1422 // reset the _do_not_unlock_if_synchronized flag | |
| 1423 __ movbool(do_not_unlock_if_synchronized, false); | |
| 1424 | |
| 1425 // check for synchronized methods | |
| 1426 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 1427 // so method is not locked if overflows. | |
| 1428 if (synchronized) { | |
| 1429 // Allocate monitor and lock method | |
| 1430 lock_method(); | |
| 1431 } else { | |
| 1432 // no synchronization necessary | |
| 1433 #ifdef ASSERT | |
| 1434 { | |
| 1435 Label L; | |
| 1436 __ movl(rax, access_flags); | |
| 1437 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 1438 __ jcc(Assembler::zero, L); | |
| 1439 __ stop("method needs synchronization"); | |
| 1440 __ bind(L); | |
| 1441 } | |
| 1442 #endif | |
| 1443 } | |
| 1444 | |
| 1445 // start execution | |
| 1446 #ifdef ASSERT | |
| 1447 { | |
| 1448 Label L; | |
| 1449 const Address monitor_block_top (rbp, | |
| 1450 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 1451 __ movptr(rax, monitor_block_top); |
| 1452 __ cmpptr(rax, rsp); | |
| 0 | 1453 __ jcc(Assembler::equal, L); |
| 1454 __ stop("broken stack frame setup in interpreter"); | |
| 1455 __ bind(L); | |
| 1456 } | |
| 1457 #endif | |
| 1458 | |
| 1459 // jvmti support | |
| 1460 __ notify_method_entry(); | |
| 1461 | |
| 1462 __ dispatch_next(vtos); | |
| 1463 | |
| 1464 // invocation counter overflow | |
| 1465 if (inc_counter) { | |
| 1466 if (ProfileInterpreter) { | |
| 1467 // We have decided to profile this method in the interpreter | |
| 1468 __ bind(profile_method); | |
|
2118
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
1469 __ 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
|
1470 __ set_method_data_pointer_for_bcp(); |
|
2141
b599a4c6c2df
7012766: assert(false) failed: DEBUG MESSAGE in MacroAssembler::debug32
iveresov
parents:
2118
diff
changeset
|
1471 __ get_method(rbx); |
| 0 | 1472 __ jmp(profile_method_continue); |
| 1473 } | |
| 1474 // Handle overflow of counter and compile method | |
| 1475 __ bind(invocation_counter_overflow); | |
| 1476 generate_counter_overflow(&continue_after_compile); | |
| 1477 } | |
| 1478 | |
| 1479 return entry_point; | |
| 1480 } | |
| 1481 | |
| 1482 // Entry points | |
| 1483 // | |
| 1484 // Here we generate the various kind of entries into the interpreter. | |
| 1485 // The two main entry type are generic bytecode methods and native | |
| 1486 // call method. These both come in synchronized and non-synchronized | |
| 1487 // versions but the frame layout they create is very similar. The | |
| 1488 // other method entry types are really just special purpose entries | |
| 1489 // that are really entry and interpretation all in one. These are for | |
| 1490 // trivial methods like accessor, empty, or special math methods. | |
| 1491 // | |
| 1492 // When control flow reaches any of the entry types for the interpreter | |
| 1493 // the following holds -> | |
| 1494 // | |
| 1495 // Arguments: | |
| 1496 // | |
| 1497 // rbx: methodOop | |
| 1498 // | |
| 1499 // Stack layout immediately at entry | |
| 1500 // | |
| 1501 // [ return address ] <--- rsp | |
| 1502 // [ parameter n ] | |
| 1503 // ... | |
| 1504 // [ parameter 1 ] | |
| 1505 // [ expression stack ] (caller's java expression stack) | |
| 1506 | |
| 1507 // Assuming that we don't go to one of the trivial specialized entries | |
| 1508 // the stack will look like below when we are ready to execute the | |
| 1509 // first bytecode (or call the native routine). The register usage | |
| 1510 // will be as the template based interpreter expects (see | |
| 1511 // interpreter_amd64.hpp). | |
| 1512 // | |
| 1513 // local variables follow incoming parameters immediately; i.e. | |
| 1514 // the return address is moved to the end of the locals). | |
| 1515 // | |
| 1516 // [ monitor entry ] <--- rsp | |
| 1517 // ... | |
| 1518 // [ monitor entry ] | |
| 1519 // [ expr. stack bottom ] | |
| 1520 // [ saved r13 ] | |
| 1521 // [ current r14 ] | |
| 1522 // [ methodOop ] | |
| 1523 // [ saved ebp ] <--- rbp | |
| 1524 // [ return address ] | |
| 1525 // [ local variable m ] | |
| 1526 // ... | |
| 1527 // [ local variable 1 ] | |
| 1528 // [ parameter n ] | |
| 1529 // ... | |
| 1530 // [ parameter 1 ] <--- r14 | |
| 1531 | |
| 1532 address AbstractInterpreterGenerator::generate_method_entry( | |
| 1533 AbstractInterpreter::MethodKind kind) { | |
| 1534 // determine code generation flags | |
| 1535 bool synchronized = false; | |
| 1536 address entry_point = NULL; | |
| 1537 | |
| 1538 switch (kind) { | |
| 1539 case Interpreter::zerolocals : break; | |
| 1540 case Interpreter::zerolocals_synchronized: synchronized = true; break; | |
| 1541 case Interpreter::native : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false); break; | |
| 1542 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(true); break; | |
| 1543 case Interpreter::empty : entry_point = ((InterpreterGenerator*) this)->generate_empty_entry(); break; | |
| 1544 case Interpreter::accessor : entry_point = ((InterpreterGenerator*) this)->generate_accessor_entry(); break; | |
| 1545 case Interpreter::abstract : entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); break; | |
| 710 | 1546 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
|
1547 |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1548 case Interpreter::java_lang_math_sin : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1549 case Interpreter::java_lang_math_cos : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1550 case Interpreter::java_lang_math_tan : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1551 case Interpreter::java_lang_math_abs : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1552 case Interpreter::java_lang_math_log : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1553 case Interpreter::java_lang_math_log10 : // fall thru |
| 0 | 1554 case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); break; |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
1555 case Interpreter::java_lang_ref_reference_get |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
1556 : entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); break; |
| 0 | 1557 default : ShouldNotReachHere(); break; |
| 1558 } | |
| 1559 | |
| 1560 if (entry_point) { | |
| 1561 return entry_point; | |
| 1562 } | |
| 1563 | |
| 1564 return ((InterpreterGenerator*) this)-> | |
| 1565 generate_normal_entry(synchronized); | |
| 1566 } | |
| 1567 | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1568 // 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
|
1569 // the compiled version to the intrinsic version. |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1570 bool AbstractInterpreter::can_be_compiled(methodHandle m) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1571 switch (method_kind(m)) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1572 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
|
1573 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
|
1574 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
|
1575 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
|
1576 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
|
1577 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
|
1578 case Interpreter::java_lang_math_sqrt : |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1579 return false; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1580 default: |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1581 return true; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1582 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1583 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1584 |
| 0 | 1585 // How much stack a method activation needs in words. |
| 1586 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) { | |
| 1587 const int entry_size = frame::interpreter_frame_monitor_size(); | |
| 1588 | |
| 1589 // total overhead size: entry_size + (saved rbp thru expr stack | |
| 1590 // bottom). be sure to change this if you add/subtract anything | |
| 1591 // to/from the overhead area | |
| 1592 const int overhead_size = | |
| 1593 -(frame::interpreter_frame_initial_sp_offset) + entry_size; | |
| 1594 | |
| 1595 const int stub_code = frame::entry_frame_after_call_words; | |
| 710 | 1596 const int extra_stack = methodOopDesc::extra_stack_entries(); |
| 1597 const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) * | |
| 1506 | 1598 Interpreter::stackElementWords; |
| 0 | 1599 return (overhead_size + method_stack + stub_code); |
| 1600 } | |
| 1601 | |
| 1602 int AbstractInterpreter::layout_activation(methodOop method, | |
| 1603 int tempcount, | |
| 1604 int popframe_extra_args, | |
| 1605 int moncount, | |
| 1606 int callee_param_count, | |
| 1607 int callee_locals, | |
| 1608 frame* caller, | |
| 1609 frame* interpreter_frame, | |
| 1610 bool is_top_frame) { | |
| 1611 // Note: This calculation must exactly parallel the frame setup | |
| 1612 // in AbstractInterpreterGenerator::generate_method_entry. | |
| 1613 // If interpreter_frame!=NULL, set up the method, locals, and monitors. | |
| 1614 // The frame interpreter_frame, if not NULL, is guaranteed to be the | |
| 1615 // right size, as determined by a previous call to this method. | |
| 1616 // It is also guaranteed to be walkable even though it is in a skeletal state | |
| 1617 | |
| 1618 // fixed size of an interpreter frame: | |
| 1506 | 1619 int max_locals = method->max_locals() * Interpreter::stackElementWords; |
| 0 | 1620 int extra_locals = (method->max_locals() - method->size_of_parameters()) * |
| 1506 | 1621 Interpreter::stackElementWords; |
| 0 | 1622 |
| 1623 int overhead = frame::sender_sp_offset - | |
| 1624 frame::interpreter_frame_initial_sp_offset; | |
| 1625 // Our locals were accounted for by the caller (or last_frame_adjust | |
| 1626 // on the transistion) Since the callee parameters already account | |
| 1627 // for the callee's params we only need to account for the extra | |
| 1628 // locals. | |
| 1629 int size = overhead + | |
| 1506 | 1630 (callee_locals - callee_param_count)*Interpreter::stackElementWords + |
| 0 | 1631 moncount * frame::interpreter_frame_monitor_size() + |
| 1506 | 1632 tempcount* Interpreter::stackElementWords + popframe_extra_args; |
| 0 | 1633 if (interpreter_frame != NULL) { |
| 1634 #ifdef ASSERT | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1635 if (!EnableMethodHandles) |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1636 // @@@ 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
|
1637 // Probably, since deoptimization doesn't work yet. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1638 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable"); |
| 0 | 1639 assert(caller->sp() == interpreter_frame->sender_sp(), "Frame not properly walkable(2)"); |
| 1640 #endif | |
| 1641 | |
| 1642 interpreter_frame->interpreter_frame_set_method(method); | |
| 1643 // NOTE the difference in using sender_sp and | |
| 1644 // interpreter_frame_sender_sp interpreter_frame_sender_sp is | |
| 1645 // the original sp of the caller (the unextended_sp) and | |
| 1646 // sender_sp is fp+16 XXX | |
| 1647 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1; | |
| 1648 | |
| 1649 interpreter_frame->interpreter_frame_set_locals(locals); | |
| 1650 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin(); | |
| 1651 BasicObjectLock* monbot = montop - moncount; | |
| 1652 interpreter_frame->interpreter_frame_set_monitor_end(monbot); | |
| 1653 | |
| 1654 // Set last_sp | |
| 1655 intptr_t* esp = (intptr_t*) monbot - | |
| 1506 | 1656 tempcount*Interpreter::stackElementWords - |
| 0 | 1657 popframe_extra_args; |
| 1658 interpreter_frame->interpreter_frame_set_last_sp(esp); | |
| 1659 | |
| 1660 // All frames but the initial (oldest) interpreter frame we fill in have | |
| 1661 // a value for sender_sp that allows walking the stack but isn't | |
| 1662 // truly correct. Correct the value here. | |
| 1663 if (extra_locals != 0 && | |
| 1664 interpreter_frame->sender_sp() == | |
| 1665 interpreter_frame->interpreter_frame_sender_sp()) { | |
| 1666 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() + | |
| 1667 extra_locals); | |
| 1668 } | |
| 1669 *interpreter_frame->interpreter_frame_cache_addr() = | |
| 1670 method->constants()->cache(); | |
| 1671 } | |
| 1672 return size; | |
| 1673 } | |
| 1674 | |
| 1675 //----------------------------------------------------------------------------- | |
| 1676 // Exceptions | |
| 1677 | |
| 1678 void TemplateInterpreterGenerator::generate_throw_exception() { | |
| 1679 // Entry point in previous activation (i.e., if the caller was | |
| 1680 // interpreted) | |
| 1681 Interpreter::_rethrow_exception_entry = __ pc(); | |
| 1682 // Restore sp to interpreter_frame_last_sp even though we are going | |
| 1683 // to empty the expression stack for the exception processing. | |
| 304 | 1684 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 1685 // rax: exception |
| 1686 // rdx: return address/pc that threw exception | |
| 1687 __ restore_bcp(); // r13 points to call/send | |
| 1688 __ restore_locals(); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1689 __ reinit_heapbase(); // restore r12 as heapbase. |
| 0 | 1690 // Entry point for exceptions thrown within interpreter code |
| 1691 Interpreter::_throw_exception_entry = __ pc(); | |
| 1692 // expression stack is undefined here | |
| 1693 // rax: exception | |
| 1694 // r13: exception bcp | |
| 1695 __ verify_oop(rax); | |
| 304 | 1696 __ mov(c_rarg1, rax); |
| 0 | 1697 |
| 1698 // expression stack must be empty before entering the VM in case of | |
| 1699 // an exception | |
| 1700 __ empty_expression_stack(); | |
| 1701 // find exception handler address and preserve exception oop | |
| 1702 __ call_VM(rdx, | |
| 1703 CAST_FROM_FN_PTR(address, | |
| 1704 InterpreterRuntime::exception_handler_for_exception), | |
| 1705 c_rarg1); | |
| 1706 // rax: exception handler entry point | |
| 1707 // rdx: preserved exception oop | |
| 1708 // r13: bcp for exception handler | |
| 1709 __ push_ptr(rdx); // push exception which is now the only value on the stack | |
| 1710 __ jmp(rax); // jump to exception handler (may be _remove_activation_entry!) | |
| 1711 | |
| 1712 // If the exception is not handled in the current frame the frame is | |
| 1713 // removed and the exception is rethrown (i.e. exception | |
| 1714 // continuation is _rethrow_exception). | |
| 1715 // | |
| 1716 // Note: At this point the bci is still the bxi for the instruction | |
| 1717 // which caused the exception and the expression stack is | |
| 1718 // empty. Thus, for any VM calls at this point, GC will find a legal | |
| 1719 // oop map (with empty expression stack). | |
| 1720 | |
| 1721 // In current activation | |
| 1722 // tos: exception | |
| 1723 // esi: exception bcp | |
| 1724 | |
| 1725 // | |
| 1726 // JVMTI PopFrame support | |
| 1727 // | |
| 1728 | |
| 1729 Interpreter::_remove_activation_preserving_args_entry = __ pc(); | |
| 1730 __ empty_expression_stack(); | |
| 1731 // Set the popframe_processing bit in pending_popframe_condition | |
| 1732 // indicating that we are currently handling popframe, so that | |
| 1733 // call_VMs that may happen later do not trigger new popframe | |
| 1734 // handling cycles. | |
| 1735 __ movl(rdx, Address(r15_thread, JavaThread::popframe_condition_offset())); | |
| 1736 __ orl(rdx, JavaThread::popframe_processing_bit); | |
| 1737 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), rdx); | |
| 1738 | |
| 1739 { | |
| 1740 // Check to see whether we are returning to a deoptimized frame. | |
| 1741 // (The PopFrame call ensures that the caller of the popped frame is | |
| 1742 // either interpreted or compiled and deoptimizes it if compiled.) | |
| 1743 // In this case, we can't call dispatch_next() after the frame is | |
| 1744 // popped, but instead must save the incoming arguments and restore | |
| 1745 // them after deoptimization has occurred. | |
| 1746 // | |
| 1747 // Note that we don't compare the return PC against the | |
| 1748 // deoptimization blob's unpack entry because of the presence of | |
| 1749 // adapter frames in C2. | |
| 1750 Label caller_not_deoptimized; | |
| 304 | 1751 __ movptr(c_rarg1, Address(rbp, frame::return_addr_offset * wordSize)); |
| 0 | 1752 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1753 InterpreterRuntime::interpreter_contains), c_rarg1); | |
| 1754 __ testl(rax, rax); | |
| 1755 __ jcc(Assembler::notZero, caller_not_deoptimized); | |
| 1756 | |
| 1757 // Compute size of arguments for saving when returning to | |
| 1758 // deoptimized caller | |
| 1759 __ get_method(rax); | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1760 __ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc:: |
| 0 | 1761 size_of_parameters_offset()))); |
| 1506 | 1762 __ shll(rax, Interpreter::logStackElementSize); |
| 0 | 1763 __ restore_locals(); // XXX do we need this? |
| 304 | 1764 __ subptr(r14, rax); |
| 1765 __ addptr(r14, wordSize); | |
| 0 | 1766 // Save these arguments |
| 1767 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, | |
| 1768 Deoptimization:: | |
| 1769 popframe_preserve_args), | |
| 1770 r15_thread, rax, r14); | |
| 1771 | |
| 1772 __ remove_activation(vtos, rdx, | |
| 1773 /* throw_monitor_exception */ false, | |
| 1774 /* install_monitor_exception */ false, | |
| 1775 /* notify_jvmdi */ false); | |
| 1776 | |
| 1777 // Inform deoptimization that it is responsible for restoring | |
| 1778 // these arguments | |
| 1779 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1780 JavaThread::popframe_force_deopt_reexecution_bit); | |
| 1781 | |
| 1782 // Continue in deoptimization handler | |
| 1783 __ jmp(rdx); | |
| 1784 | |
| 1785 __ bind(caller_not_deoptimized); | |
| 1786 } | |
| 1787 | |
| 1788 __ remove_activation(vtos, rdx, /* rdx result (retaddr) is not used */ | |
| 1789 /* throw_monitor_exception */ false, | |
| 1790 /* install_monitor_exception */ false, | |
| 1791 /* notify_jvmdi */ false); | |
| 1792 | |
| 1793 // Finish with popframe handling | |
| 1794 // A previous I2C followed by a deoptimization might have moved the | |
| 1795 // outgoing arguments further up the stack. PopFrame expects the | |
| 1796 // mutations to those outgoing arguments to be preserved and other | |
| 1797 // constraints basically require this frame to look exactly as | |
| 1798 // though it had previously invoked an interpreted activation with | |
| 1799 // no space between the top of the expression stack (current | |
| 1800 // last_sp) and the top of stack. Rather than force deopt to | |
| 1801 // maintain this kind of invariant all the time we call a small | |
| 1802 // fixup routine to move the mutated arguments onto the top of our | |
| 1803 // expression stack if necessary. | |
| 304 | 1804 __ mov(c_rarg1, rsp); |
| 1805 __ movptr(c_rarg2, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); | |
| 0 | 1806 // PC must point into interpreter here |
| 1807 __ set_last_Java_frame(noreg, rbp, __ pc()); | |
| 1808 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), r15_thread, c_rarg1, c_rarg2); | |
| 1809 __ reset_last_Java_frame(true, true); | |
| 1810 // Restore the last_sp and null it out | |
| 304 | 1811 __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); |
| 1812 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); | |
| 0 | 1813 |
| 1814 __ restore_bcp(); // XXX do we need this? | |
| 1815 __ restore_locals(); // XXX do we need this? | |
| 1816 // The method data pointer was incremented already during | |
| 1817 // call profiling. We have to restore the mdp for the current bcp. | |
| 1818 if (ProfileInterpreter) { | |
| 1819 __ set_method_data_pointer_for_bcp(); | |
| 1820 } | |
| 1821 | |
| 1822 // Clear the popframe condition flag | |
| 1823 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1824 JavaThread::popframe_inactive); | |
| 1825 | |
| 1826 __ dispatch_next(vtos); | |
| 1827 // end of PopFrame support | |
| 1828 | |
| 1829 Interpreter::_remove_activation_entry = __ pc(); | |
| 1830 | |
| 1831 // preserve exception over this code sequence | |
| 1832 __ pop_ptr(rax); | |
| 304 | 1833 __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), rax); |
| 0 | 1834 // remove the activation (without doing throws on illegalMonitorExceptions) |
| 1835 __ remove_activation(vtos, rdx, false, true, false); | |
| 1836 // restore exception | |
| 304 | 1837 __ movptr(rax, Address(r15_thread, JavaThread::vm_result_offset())); |
| 1838 __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), (int32_t)NULL_WORD); | |
| 0 | 1839 __ verify_oop(rax); |
| 1840 | |
| 1841 // In between activations - previous activation type unknown yet | |
| 1842 // compute continuation point - the continuation point expects the | |
| 1843 // following registers set up: | |
| 1844 // | |
| 1845 // rax: exception | |
| 1846 // rdx: return address/pc that threw exception | |
| 1847 // rsp: expression stack of caller | |
| 1848 // rbp: ebp of caller | |
| 304 | 1849 __ push(rax); // save exception |
| 1850 __ push(rdx); // save return address | |
| 0 | 1851 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1852 SharedRuntime::exception_handler_for_return_address), | |
| 1295 | 1853 r15_thread, rdx); |
| 304 | 1854 __ mov(rbx, rax); // save exception handler |
| 1855 __ pop(rdx); // restore return address | |
| 1856 __ pop(rax); // restore exception | |
| 0 | 1857 // Note that an "issuing PC" is actually the next PC after the call |
| 1858 __ jmp(rbx); // jump to exception | |
| 1859 // handler of caller | |
| 1860 } | |
| 1861 | |
| 1862 | |
| 1863 // | |
| 1864 // JVMTI ForceEarlyReturn support | |
| 1865 // | |
| 1866 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) { | |
| 1867 address entry = __ pc(); | |
| 1868 | |
| 1869 __ restore_bcp(); | |
| 1870 __ restore_locals(); | |
| 1871 __ empty_expression_stack(); | |
| 1872 __ load_earlyret_value(state); | |
| 1873 | |
| 304 | 1874 __ movptr(rdx, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); |
| 0 | 1875 Address cond_addr(rdx, JvmtiThreadState::earlyret_state_offset()); |
| 1876 | |
| 1877 // Clear the earlyret state | |
| 1878 __ movl(cond_addr, JvmtiThreadState::earlyret_inactive); | |
| 1879 | |
| 1880 __ remove_activation(state, rsi, | |
| 1881 false, /* throw_monitor_exception */ | |
| 1882 false, /* install_monitor_exception */ | |
| 1883 true); /* notify_jvmdi */ | |
| 1884 __ jmp(rsi); | |
| 1885 | |
| 1886 return entry; | |
| 1887 } // end of ForceEarlyReturn support | |
| 1888 | |
| 1889 | |
| 1890 //----------------------------------------------------------------------------- | |
| 1891 // Helper for vtos entry point generation | |
| 1892 | |
| 1893 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t, | |
| 1894 address& bep, | |
| 1895 address& cep, | |
| 1896 address& sep, | |
| 1897 address& aep, | |
| 1898 address& iep, | |
| 1899 address& lep, | |
| 1900 address& fep, | |
| 1901 address& dep, | |
| 1902 address& vep) { | |
| 1903 assert(t->is_valid() && t->tos_in() == vtos, "illegal template"); | |
| 1904 Label L; | |
| 1905 aep = __ pc(); __ push_ptr(); __ jmp(L); | |
| 1906 fep = __ pc(); __ push_f(); __ jmp(L); | |
| 1907 dep = __ pc(); __ push_d(); __ jmp(L); | |
| 1908 lep = __ pc(); __ push_l(); __ jmp(L); | |
| 1909 bep = cep = sep = | |
| 1910 iep = __ pc(); __ push_i(); | |
| 1911 vep = __ pc(); | |
| 1912 __ bind(L); | |
| 1913 generate_and_dispatch(t); | |
| 1914 } | |
| 1915 | |
| 1916 | |
| 1917 //----------------------------------------------------------------------------- | |
| 1918 // Generation of individual instructions | |
| 1919 | |
| 1920 // helpers for generate_and_dispatch | |
| 1921 | |
| 1922 | |
| 1923 InterpreterGenerator::InterpreterGenerator(StubQueue* code) | |
| 1924 : TemplateInterpreterGenerator(code) { | |
| 1925 generate_all(); // down here so it can be "virtual" | |
| 1926 } | |
| 1927 | |
| 1928 //----------------------------------------------------------------------------- | |
| 1929 | |
| 1930 // Non-product code | |
| 1931 #ifndef PRODUCT | |
| 1932 address TemplateInterpreterGenerator::generate_trace_code(TosState state) { | |
| 1933 address entry = __ pc(); | |
| 1934 | |
| 1935 __ push(state); | |
| 304 | 1936 __ push(c_rarg0); |
| 1937 __ push(c_rarg1); | |
| 1938 __ push(c_rarg2); | |
| 1939 __ push(c_rarg3); | |
| 1940 __ mov(c_rarg2, rax); // Pass itos | |
| 0 | 1941 #ifdef _WIN64 |
| 1942 __ movflt(xmm3, xmm0); // Pass ftos | |
| 1943 #endif | |
| 1944 __ call_VM(noreg, | |
| 1945 CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), | |
| 1946 c_rarg1, c_rarg2, c_rarg3); | |
| 304 | 1947 __ pop(c_rarg3); |
| 1948 __ pop(c_rarg2); | |
| 1949 __ pop(c_rarg1); | |
| 1950 __ pop(c_rarg0); | |
| 0 | 1951 __ pop(state); |
| 1952 __ ret(0); // return from result handler | |
| 1953 | |
| 1954 return entry; | |
| 1955 } | |
| 1956 | |
| 1957 void TemplateInterpreterGenerator::count_bytecode() { | |
| 1958 __ incrementl(ExternalAddress((address) &BytecodeCounter::_counter_value)); | |
| 1959 } | |
| 1960 | |
| 1961 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { | |
| 1962 __ incrementl(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()])); | |
| 1963 } | |
| 1964 | |
| 1965 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { | |
| 1966 __ mov32(rbx, ExternalAddress((address) &BytecodePairHistogram::_index)); | |
| 1967 __ shrl(rbx, BytecodePairHistogram::log2_number_of_codes); | |
| 1968 __ orl(rbx, | |
| 1969 ((int) t->bytecode()) << | |
| 1970 BytecodePairHistogram::log2_number_of_codes); | |
| 1971 __ mov32(ExternalAddress((address) &BytecodePairHistogram::_index), rbx); | |
| 1972 __ lea(rscratch1, ExternalAddress((address) BytecodePairHistogram::_counters)); | |
| 1973 __ incrementl(Address(rscratch1, rbx, Address::times_4)); | |
| 1974 } | |
| 1975 | |
| 1976 | |
| 1977 void TemplateInterpreterGenerator::trace_bytecode(Template* t) { | |
| 1978 // Call a little run-time stub to avoid blow-up for each bytecode. | |
| 1979 // The run-time runtime saves the right registers, depending on | |
| 1980 // the tosca in-state for the given template. | |
| 1981 | |
| 1982 assert(Interpreter::trace_code(t->tos_in()) != NULL, | |
| 1983 "entry must have been generated"); | |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1984 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1985 __ andptr(rsp, -16); // align stack as required by ABI |
| 0 | 1986 __ call(RuntimeAddress(Interpreter::trace_code(t->tos_in()))); |
| 304 | 1987 __ 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
|
1988 __ reinit_heapbase(); |
| 0 | 1989 } |
| 1990 | |
| 1991 | |
| 1992 void TemplateInterpreterGenerator::stop_interpreter_at() { | |
| 1993 Label L; | |
| 1994 __ cmp32(ExternalAddress((address) &BytecodeCounter::_counter_value), | |
| 1995 StopInterpreterAt); | |
| 1996 __ jcc(Assembler::notEqual, L); | |
| 1997 __ int3(); | |
| 1998 __ bind(L); | |
| 1999 } | |
| 2000 #endif // !PRODUCT | |
| 304 | 2001 #endif // ! CC_INTERP |