annotate src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 5604:bd3237e0e18d

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