496 __ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
497 __ movptr(rax, Address(rax, mirror_offset));
498 __ bind(done);
499 // add space for monitor & lock
500 __ subptr(rsp, entry_size); // add space for a monitor entry
501 __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); // store object
502 __ bind(not_synced);
503 }
504
505 __ movptr(STATE(_stack_base), rsp); // set expression stack base ( == &monitors[-count])
506 if (native) {
507 __ movptr(STATE(_stack), rsp); // set current expression stack tos
508 __ movptr(STATE(_stack_limit), rsp);
509 } else {
510 __ subptr(rsp, wordSize); // pre-push stack
511 __ movptr(STATE(_stack), rsp); // set current expression stack tos
512
513 // compute full expression stack limit
514
515 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
516 __ load_unsigned_word(rdx, size_of_stack); // get size of expression stack in words
517 __ negptr(rdx); // so we can subtract in next step
518 // Allocate expression stack
519 __ lea(rsp, Address(rsp, rdx, Address::times_ptr));
520 __ movptr(STATE(_stack_limit), rsp);
521 }
522
523 #ifdef _LP64
524 // Make sure stack is properly aligned and sized for the abi
525 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
526 __ andptr(rsp, -16); // must be 16 byte boundry (see amd64 ABI)
527 #endif // _LP64
528
529
530
531 }
532
533 // Helpers for commoning out cases in the various type of method entries.
534 //
535
536 // increment invocation count & check for overflow
537 //
538 // Note: checking for negative value instead of overflow
539 // so we have a 'sticky' overflow test
642 // the stack before the red zone
643
644 Label after_frame_check_pop;
645
646 // save rsi == caller's bytecode ptr (c++ previous interp. state)
647 // QQQ problem here?? rsi overload????
648 __ push(state);
649
650 const Register thread = LP64_ONLY(r15_thread) NOT_LP64(rsi);
651
652 NOT_LP64(__ get_thread(thread));
653
654 const Address stack_base(thread, Thread::stack_base_offset());
655 const Address stack_size(thread, Thread::stack_size_offset());
656
657 // locals + overhead, in bytes
658 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
659 // Always give one monitor to allow us to start interp if sync method.
660 // Any additional monitors need a check when moving the expression stack
661 const int one_monitor = frame::interpreter_frame_monitor_size() * wordSize;
662 __ load_unsigned_word(rax, size_of_stack); // get size of expression stack in words
663 __ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), one_monitor));
664 __ lea(rax, Address(rax, rdx, Interpreter::stackElementScale(), overhead_size));
665
666 #ifdef ASSERT
667 Label stack_base_okay, stack_size_okay;
668 // verify that thread stack base is non-zero
669 __ cmpptr(stack_base, (int32_t)0);
670 __ jcc(Assembler::notEqual, stack_base_okay);
671 __ stop("stack base is zero");
672 __ bind(stack_base_okay);
673 // verify that thread stack size is non-zero
674 __ cmpptr(stack_size, (int32_t)0);
675 __ jcc(Assembler::notEqual, stack_size_okay);
676 __ stop("stack size is zero");
677 __ bind(stack_size_okay);
678 #endif
679
680 // Add stack base to locals and subtract stack size
681 __ addptr(rax, stack_base);
682 __ subptr(rax, stack_size);
683
2168
2169 __ jmp(unwind_and_forward);
2170
2171 interpreter_frame_manager = entry_point;
2172 return entry_point;
2173 }
2174
2175 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
2176 // determine code generation flags
2177 bool synchronized = false;
2178 address entry_point = NULL;
2179
2180 switch (kind) {
2181 case Interpreter::zerolocals : break;
2182 case Interpreter::zerolocals_synchronized: synchronized = true; break;
2183 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
2184 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
2185 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
2186 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
2187 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
2188
2189 case Interpreter::java_lang_math_sin : // fall thru
2190 case Interpreter::java_lang_math_cos : // fall thru
2191 case Interpreter::java_lang_math_tan : // fall thru
2192 case Interpreter::java_lang_math_abs : // fall thru
2193 case Interpreter::java_lang_math_log : // fall thru
2194 case Interpreter::java_lang_math_log10 : // fall thru
2195 case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
2196 default : ShouldNotReachHere(); break;
2197 }
2198
2199 if (entry_point) return entry_point;
2200
2201 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
2202
2203 }
2204
2205 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
2206 : CppInterpreterGenerator(code) {
2207 generate_all(); // down here so it can be "virtual"
2208 }
2209
2210 // Deoptimization helpers for C++ interpreter
2211
2212 // How much stack a method activation needs in words.
2213 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
2214
2215 const int stub_code = 4; // see generate_call_stub
2216 // Save space for one monitor to get into the interpreted method in case
2217 // the method is synchronized
2218 int monitor_size = method->is_synchronized() ?
2219 1*frame::interpreter_frame_monitor_size() : 0;
2220
2221 // total static overhead size. Account for interpreter state object, return
2222 // address, saved rbp and 2 words for a "static long no_params() method" issue.
2223
2224 const int overhead_size = sizeof(BytecodeInterpreter)/wordSize +
2225 ( frame::sender_sp_offset - frame::link_offset) + 2;
2226
2227 const int method_stack = (method->max_locals() + method->max_stack()) *
2228 Interpreter::stackElementWords();
2229 return overhead_size + method_stack + stub_code;
2230 }
2231
2232 // returns the activation size.
2233 static int size_activation_helper(int extra_locals_size, int monitor_size) {
2234 return (extra_locals_size + // the addition space for locals
2235 2*BytesPerWord + // return address and saved rbp
2236 2*BytesPerWord + // "static long no_params() method" issue
2237 sizeof(BytecodeInterpreter) + // interpreterState
2238 monitor_size); // monitors
2239 }
2240
2241 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
2242 frame* caller,
2243 frame* current,
2244 methodOop method,
2245 intptr_t* locals,
2246 intptr_t* stack,
2247 intptr_t* stack_base,
2272
2273 to_fill->_sender_sp = caller->unextended_sp();
2274
2275 if (caller->is_interpreted_frame()) {
2276 interpreterState prev = caller->get_interpreterState();
2277 to_fill->_prev_link = prev;
2278 // *current->register_addr(GR_Iprev_state) = (intptr_t) prev;
2279 // Make the prev callee look proper
2280 prev->_result._to_call._callee = method;
2281 if (*prev->_bcp == Bytecodes::_invokeinterface) {
2282 prev->_result._to_call._bcp_advance = 5;
2283 } else {
2284 prev->_result._to_call._bcp_advance = 3;
2285 }
2286 }
2287 to_fill->_oop_temp = NULL;
2288 to_fill->_stack_base = stack_base;
2289 // Need +1 here because stack_base points to the word just above the first expr stack entry
2290 // and stack_limit is supposed to point to the word just below the last expr stack entry.
2291 // See generate_compute_interpreter_state.
2292 to_fill->_stack_limit = stack_base - (method->max_stack() + 1);
2293 to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
2294
2295 to_fill->_self_link = to_fill;
2296 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
2297 "Stack top out of range");
2298 }
2299
2300 int AbstractInterpreter::layout_activation(methodOop method,
2301 int tempcount, //
2302 int popframe_extra_args,
2303 int moncount,
2304 int callee_param_count,
2305 int callee_locals,
2306 frame* caller,
2307 frame* interpreter_frame,
2308 bool is_top_frame) {
2309
2310 assert(popframe_extra_args == 0, "FIX ME");
2311 // NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state()
2312 // does as far as allocating an interpreter frame.
2318 // NOTE: tempcount is the current size of the java expression stack. For top most
2319 // frames we will allocate a full sized expression stack and not the curback
2320 // version that non-top frames have.
2321
2322 // Calculate the amount our frame will be adjust by the callee. For top frame
2323 // this is zero.
2324
2325 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it
2326 // calculates the extra locals based on itself. Not what the callee does
2327 // to it. So it ignores last_frame_adjust value. Seems suspicious as far
2328 // as getting sender_sp correct.
2329
2330 int extra_locals_size = (callee_locals - callee_param_count) * BytesPerWord;
2331 int monitor_size = sizeof(BasicObjectLock) * moncount;
2332
2333 // First calculate the frame size without any java expression stack
2334 int short_frame_size = size_activation_helper(extra_locals_size,
2335 monitor_size);
2336
2337 // Now with full size expression stack
2338 int full_frame_size = short_frame_size + method->max_stack() * BytesPerWord;
2339
2340 // and now with only live portion of the expression stack
2341 short_frame_size = short_frame_size + tempcount * BytesPerWord;
2342
2343 // the size the activation is right now. Only top frame is full size
2344 int frame_size = (is_top_frame ? full_frame_size : short_frame_size);
2345
2346 if (interpreter_frame != NULL) {
2347 #ifdef ASSERT
2348 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
2349 #endif
2350
2351 // MUCHO HACK
2352
2353 intptr_t* frame_bottom = (intptr_t*) ((intptr_t)interpreter_frame->sp() - (full_frame_size - frame_size));
2354
2355 /* Now fillin the interpreterState object */
2356
2357 // The state object is the first thing on the frame and easily located
2358
|
496 __ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));
497 __ movptr(rax, Address(rax, mirror_offset));
498 __ bind(done);
499 // add space for monitor & lock
500 __ subptr(rsp, entry_size); // add space for a monitor entry
501 __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); // store object
502 __ bind(not_synced);
503 }
504
505 __ movptr(STATE(_stack_base), rsp); // set expression stack base ( == &monitors[-count])
506 if (native) {
507 __ movptr(STATE(_stack), rsp); // set current expression stack tos
508 __ movptr(STATE(_stack_limit), rsp);
509 } else {
510 __ subptr(rsp, wordSize); // pre-push stack
511 __ movptr(STATE(_stack), rsp); // set current expression stack tos
512
513 // compute full expression stack limit
514
515 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
516 const int extra_stack = methodOopDesc::extra_stack() * Interpreter::stackElementSize;
517 __ load_unsigned_word(rdx, size_of_stack); // get size of expression stack in words
518 __ negptr(rdx); // so we can subtract in next step
519 // Allocate expression stack
520 __ lea(rsp, Address(rsp, rdx, Address::times_ptr, -extra_stack));
521 __ movptr(STATE(_stack_limit), rsp);
522 }
523
524 #ifdef _LP64
525 // Make sure stack is properly aligned and sized for the abi
526 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
527 __ andptr(rsp, -16); // must be 16 byte boundry (see amd64 ABI)
528 #endif // _LP64
529
530
531
532 }
533
534 // Helpers for commoning out cases in the various type of method entries.
535 //
536
537 // increment invocation count & check for overflow
538 //
539 // Note: checking for negative value instead of overflow
540 // so we have a 'sticky' overflow test
643 // the stack before the red zone
644
645 Label after_frame_check_pop;
646
647 // save rsi == caller's bytecode ptr (c++ previous interp. state)
648 // QQQ problem here?? rsi overload????
649 __ push(state);
650
651 const Register thread = LP64_ONLY(r15_thread) NOT_LP64(rsi);
652
653 NOT_LP64(__ get_thread(thread));
654
655 const Address stack_base(thread, Thread::stack_base_offset());
656 const Address stack_size(thread, Thread::stack_size_offset());
657
658 // locals + overhead, in bytes
659 const Address size_of_stack (rbx, methodOopDesc::max_stack_offset());
660 // Always give one monitor to allow us to start interp if sync method.
661 // Any additional monitors need a check when moving the expression stack
662 const int one_monitor = frame::interpreter_frame_monitor_size() * wordSize;
663 const int extra_stack = methodOopDesc::extra_stack() * Interpreter::stackElementSize;
664 __ load_unsigned_word(rax, size_of_stack); // get size of expression stack in words
665 __ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), extra_stack + one_monitor));
666 __ lea(rax, Address(rax, rdx, Interpreter::stackElementScale(), overhead_size));
667
668 #ifdef ASSERT
669 Label stack_base_okay, stack_size_okay;
670 // verify that thread stack base is non-zero
671 __ cmpptr(stack_base, (int32_t)0);
672 __ jcc(Assembler::notEqual, stack_base_okay);
673 __ stop("stack base is zero");
674 __ bind(stack_base_okay);
675 // verify that thread stack size is non-zero
676 __ cmpptr(stack_size, (int32_t)0);
677 __ jcc(Assembler::notEqual, stack_size_okay);
678 __ stop("stack size is zero");
679 __ bind(stack_size_okay);
680 #endif
681
682 // Add stack base to locals and subtract stack size
683 __ addptr(rax, stack_base);
684 __ subptr(rax, stack_size);
685
2170
2171 __ jmp(unwind_and_forward);
2172
2173 interpreter_frame_manager = entry_point;
2174 return entry_point;
2175 }
2176
2177 address AbstractInterpreterGenerator::generate_method_entry(AbstractInterpreter::MethodKind kind) {
2178 // determine code generation flags
2179 bool synchronized = false;
2180 address entry_point = NULL;
2181
2182 switch (kind) {
2183 case Interpreter::zerolocals : break;
2184 case Interpreter::zerolocals_synchronized: synchronized = true; break;
2185 case Interpreter::native : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(false); break;
2186 case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*)this)->generate_native_entry(true); break;
2187 case Interpreter::empty : entry_point = ((InterpreterGenerator*)this)->generate_empty_entry(); break;
2188 case Interpreter::accessor : entry_point = ((InterpreterGenerator*)this)->generate_accessor_entry(); break;
2189 case Interpreter::abstract : entry_point = ((InterpreterGenerator*)this)->generate_abstract_entry(); break;
2190 case Interpreter::method_handle : entry_point = ((InterpreterGenerator*)this)->generate_method_handle_entry(); break;
2191
2192 case Interpreter::java_lang_math_sin : // fall thru
2193 case Interpreter::java_lang_math_cos : // fall thru
2194 case Interpreter::java_lang_math_tan : // fall thru
2195 case Interpreter::java_lang_math_abs : // fall thru
2196 case Interpreter::java_lang_math_log : // fall thru
2197 case Interpreter::java_lang_math_log10 : // fall thru
2198 case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*)this)->generate_math_entry(kind); break;
2199 default : ShouldNotReachHere(); break;
2200 }
2201
2202 if (entry_point) return entry_point;
2203
2204 return ((InterpreterGenerator*)this)->generate_normal_entry(synchronized);
2205
2206 }
2207
2208 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
2209 : CppInterpreterGenerator(code) {
2210 generate_all(); // down here so it can be "virtual"
2211 }
2212
2213 // Deoptimization helpers for C++ interpreter
2214
2215 // How much stack a method activation needs in words.
2216 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
2217
2218 const int stub_code = 4; // see generate_call_stub
2219 // Save space for one monitor to get into the interpreted method in case
2220 // the method is synchronized
2221 int monitor_size = method->is_synchronized() ?
2222 1*frame::interpreter_frame_monitor_size() : 0;
2223
2224 // total static overhead size. Account for interpreter state object, return
2225 // address, saved rbp and 2 words for a "static long no_params() method" issue.
2226
2227 const int overhead_size = sizeof(BytecodeInterpreter)/wordSize +
2228 ( frame::sender_sp_offset - frame::link_offset) + 2;
2229
2230 const int extra_stack = methodOopDesc::extra_stack();
2231 const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
2232 Interpreter::stackElementWords();
2233 return overhead_size + method_stack + stub_code;
2234 }
2235
2236 // returns the activation size.
2237 static int size_activation_helper(int extra_locals_size, int monitor_size) {
2238 return (extra_locals_size + // the addition space for locals
2239 2*BytesPerWord + // return address and saved rbp
2240 2*BytesPerWord + // "static long no_params() method" issue
2241 sizeof(BytecodeInterpreter) + // interpreterState
2242 monitor_size); // monitors
2243 }
2244
2245 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
2246 frame* caller,
2247 frame* current,
2248 methodOop method,
2249 intptr_t* locals,
2250 intptr_t* stack,
2251 intptr_t* stack_base,
2276
2277 to_fill->_sender_sp = caller->unextended_sp();
2278
2279 if (caller->is_interpreted_frame()) {
2280 interpreterState prev = caller->get_interpreterState();
2281 to_fill->_prev_link = prev;
2282 // *current->register_addr(GR_Iprev_state) = (intptr_t) prev;
2283 // Make the prev callee look proper
2284 prev->_result._to_call._callee = method;
2285 if (*prev->_bcp == Bytecodes::_invokeinterface) {
2286 prev->_result._to_call._bcp_advance = 5;
2287 } else {
2288 prev->_result._to_call._bcp_advance = 3;
2289 }
2290 }
2291 to_fill->_oop_temp = NULL;
2292 to_fill->_stack_base = stack_base;
2293 // Need +1 here because stack_base points to the word just above the first expr stack entry
2294 // and stack_limit is supposed to point to the word just below the last expr stack entry.
2295 // See generate_compute_interpreter_state.
2296 int extra_stack = methodOopDesc::extra_stack();
2297 to_fill->_stack_limit = stack_base - (method->max_stack() + extra_stack + 1);
2298 to_fill->_monitor_base = (BasicObjectLock*) monitor_base;
2299
2300 to_fill->_self_link = to_fill;
2301 assert(stack >= to_fill->_stack_limit && stack < to_fill->_stack_base,
2302 "Stack top out of range");
2303 }
2304
2305 int AbstractInterpreter::layout_activation(methodOop method,
2306 int tempcount, //
2307 int popframe_extra_args,
2308 int moncount,
2309 int callee_param_count,
2310 int callee_locals,
2311 frame* caller,
2312 frame* interpreter_frame,
2313 bool is_top_frame) {
2314
2315 assert(popframe_extra_args == 0, "FIX ME");
2316 // NOTE this code must exactly mimic what InterpreterGenerator::generate_compute_interpreter_state()
2317 // does as far as allocating an interpreter frame.
2323 // NOTE: tempcount is the current size of the java expression stack. For top most
2324 // frames we will allocate a full sized expression stack and not the curback
2325 // version that non-top frames have.
2326
2327 // Calculate the amount our frame will be adjust by the callee. For top frame
2328 // this is zero.
2329
2330 // NOTE: ia64 seems to do this wrong (or at least backwards) in that it
2331 // calculates the extra locals based on itself. Not what the callee does
2332 // to it. So it ignores last_frame_adjust value. Seems suspicious as far
2333 // as getting sender_sp correct.
2334
2335 int extra_locals_size = (callee_locals - callee_param_count) * BytesPerWord;
2336 int monitor_size = sizeof(BasicObjectLock) * moncount;
2337
2338 // First calculate the frame size without any java expression stack
2339 int short_frame_size = size_activation_helper(extra_locals_size,
2340 monitor_size);
2341
2342 // Now with full size expression stack
2343 int extra_stack = methodOopDesc::extra_stack();
2344 int full_frame_size = short_frame_size + (method->max_stack() + extra_stack) * BytesPerWord;
2345
2346 // and now with only live portion of the expression stack
2347 short_frame_size = short_frame_size + tempcount * BytesPerWord;
2348
2349 // the size the activation is right now. Only top frame is full size
2350 int frame_size = (is_top_frame ? full_frame_size : short_frame_size);
2351
2352 if (interpreter_frame != NULL) {
2353 #ifdef ASSERT
2354 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable");
2355 #endif
2356
2357 // MUCHO HACK
2358
2359 intptr_t* frame_bottom = (intptr_t*) ((intptr_t)interpreter_frame->sp() - (full_frame_size - frame_size));
2360
2361 /* Now fillin the interpreterState object */
2362
2363 // The state object is the first thing on the frame and easily located
2364
|