frame_x86.cpp revision 4802:f2110083203d
11590Srgrimes/* 21590Srgrimes * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. 31590Srgrimes * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 41590Srgrimes * 51590Srgrimes * This code is free software; you can redistribute it and/or modify it 61590Srgrimes * under the terms of the GNU General Public License version 2 only, as 71590Srgrimes * published by the Free Software Foundation. 81590Srgrimes * 91590Srgrimes * This code is distributed in the hope that it will be useful, but WITHOUT 101590Srgrimes * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 111590Srgrimes * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 121590Srgrimes * version 2 for more details (a copy is included in the LICENSE file that 131590Srgrimes * accompanied this code). 141590Srgrimes * 151590Srgrimes * You should have received a copy of the GNU General Public License version 161590Srgrimes * 2 along with this work; if not, write to the Free Software Foundation, 171590Srgrimes * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 181590Srgrimes * 191590Srgrimes * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 201590Srgrimes * or visit www.oracle.com if you need additional information or have any 211590Srgrimes * questions. 221590Srgrimes * 231590Srgrimes */ 241590Srgrimes 251590Srgrimes#include "precompiled.hpp" 261590Srgrimes#include "interpreter/interpreter.hpp" 271590Srgrimes#include "memory/resourceArea.hpp" 281590Srgrimes#include "oops/markOop.hpp" 291590Srgrimes#include "oops/method.hpp" 301590Srgrimes#include "oops/oop.inline.hpp" 311590Srgrimes#include "prims/methodHandles.hpp" 321590Srgrimes#include "runtime/frame.inline.hpp" 331590Srgrimes#include "runtime/handles.inline.hpp" 3487690Smarkm#include "runtime/javaCalls.hpp" 3587690Smarkm#include "runtime/monitorChunk.hpp" 3687690Smarkm#include "runtime/os.hpp" 3787690Smarkm#include "runtime/signature.hpp" 381590Srgrimes#include "runtime/stubCodeGenerator.hpp" 3928693Scharnier#include "runtime/stubRoutines.hpp" 401590Srgrimes#include "vmreg_x86.inline.hpp" 411590Srgrimes#ifdef COMPILER1 4287690Smarkm#include "c1/c1_Runtime1.hpp" 431590Srgrimes#include "runtime/vframeArray.hpp" 441590Srgrimes#endif 4587690Smarkm 4628693Scharnier#ifdef ASSERT 471590Srgrimesvoid RegisterMap::check_location_valid() { 481590Srgrimes} 491590Srgrimes#endif 501590Srgrimes 5112811Sbde 521590Srgrimes// Profiling/safepoint support 531590Srgrimes 541590Srgrimesbool frame::safe_for_sender(JavaThread *thread) { 551590Srgrimes address sp = (address)_sp; 561590Srgrimes address fp = (address)_fp; 57111008Sphk address unextended_sp = (address)_unextended_sp; 581590Srgrimes 5912804Speter // consider stack guards when trying to determine "safe" stack pointers 6012811Sbde static size_t stack_guard_size = os::uses_stack_guard_pages() ? (StackYellowPages + StackRedPages) * os::vm_page_size() : 0; 6112811Sbde size_t usable_stack_size = thread->stack_size() - stack_guard_size; 6212811Sbde 6328693Scharnier // sp must be within the usable part of the stack (not in guards) 6487690Smarkm bool sp_safe = (sp < thread->stack_base()) && 6528693Scharnier (sp >= thread->stack_base() - usable_stack_size); 6628693Scharnier 6728693Scharnier 6828693Scharnier if (!sp_safe) { 691590Srgrimes return false; 7028693Scharnier } 711590Srgrimes 721590Srgrimes // unextended sp must be within the stack and above or equal sp 731590Srgrimes bool unextended_sp_safe = (unextended_sp < thread->stack_base()) && 7430180Sdima (unextended_sp >= sp); 7528693Scharnier 7628693Scharnier if (!unextended_sp_safe) { 771590Srgrimes return false; 7887690Smarkm } 7987690Smarkm 8087690Smarkm // an fp must be within the stack and above (but not equal) sp 811590Srgrimes // second evaluation on fp+ is added to handle situation where fp is -1 821590Srgrimes bool fp_safe = (fp < thread->stack_base() && (fp > sp) && (((fp + (return_addr_offset * sizeof(void*))) < thread->stack_base()))); 8339230Sgibbs 841590Srgrimes // We know sp/unextended_sp are safe only fp is questionable here 8539230Sgibbs 861590Srgrimes // If the current frame is known to the code cache then we can attempt to 8739230Sgibbs // to construct the sender and do some validation of it. This goes a long way 881590Srgrimes // toward eliminating issues when we get in frame construction code 8939230Sgibbs 901590Srgrimes if (_cb != NULL ) { 9139230Sgibbs 921590Srgrimes // First check if frame is complete and tester is reliable 9339230Sgibbs // Unfortunately we can only check frame complete for runtime stubs and nmethod 941590Srgrimes // other generic buffer blobs are more problematic so we just assume they are 9539230Sgibbs // ok. adapter blobs never have a frame complete and are never ok. 961590Srgrimes 9739230Sgibbs // check for a valid frame_size, otherwise we are unlikely to get a valid sender_pc 981590Srgrimes 9939230Sgibbs if (!Interpreter::contains(_pc) && _cb->frame_size() <= 0) { 1001590Srgrimes //assert(0, "Invalid frame_size"); 10130180Sdima return false; 10294729Sjeff } 1031590Srgrimes 104113460Stjr if (!_cb->is_frame_complete_at(_pc)) { 1051590Srgrimes if (_cb->is_nmethod() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) { 106113460Stjr return false; 1071590Srgrimes } 108113460Stjr } 1091590Srgrimes 110113460Stjr // Could just be some random pointer within the codeBlob 11192653Sjeff if (!_cb->code_contains(_pc)) { 11294729Sjeff return false; 1131590Srgrimes } 1141590Srgrimes 1151590Srgrimes // Entry frame checks 1161590Srgrimes if (is_entry_frame()) { 117123250Sdes // an entry frame must have a valid fp. 118123250Sdes 119123250Sdes if (!fp_safe) return false; 120123250Sdes 121123250Sdes // Validate the JavaCallWrapper an entry frame must have 122123250Sdes 123123250Sdes address jcw = (address)entry_frame_call_wrapper(); 124123250Sdes 125123250Sdes bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > fp); 126123250Sdes 127123250Sdes return jcw_safe; 1281590Srgrimes 129123250Sdes } 1301590Srgrimes 131123250Sdes intptr_t* sender_sp = NULL; 132123250Sdes address sender_pc = NULL; 133123250Sdes 1341590Srgrimes if (is_interpreted_frame()) { 135123250Sdes // fp must be safe 1361590Srgrimes if (!fp_safe) { 1371590Srgrimes return false; 1381590Srgrimes } 1391590Srgrimes 1401590Srgrimes sender_pc = (address) this->fp()[return_addr_offset]; 1411590Srgrimes sender_sp = (intptr_t*) addr_at(sender_sp_offset); 1421590Srgrimes 14343962Sdillon } else { 1441590Srgrimes // must be some sort of compiled/runtime frame 14592922Simp // fp does not have to be safe (although it could be check for c1?) 14692922Simp 147122300Sjmg sender_sp = _unextended_sp + _cb->frame_size(); 14892922Simp // On Intel the return_address is always the word on the stack 14992922Simp sender_pc = (address) *(sender_sp-1); 15092922Simp } 151123401Sdwmalone 152123407Sdes 15392922Simp // If the potential sender is the interpreter then we can do some more checking 15492922Simp if (Interpreter::contains(sender_pc)) { 15592922Simp 15692922Simp // ebp is always saved in a recognizable place in any code we generate. However 15792922Simp // only if the sender is interpreted/call_stub (c1 too?) are we certain that the saved ebp 1581590Srgrimes // is really a frame pointer. 15992922Simp 16092922Simp intptr_t *saved_fp = (intptr_t*)*(sender_sp - frame::sender_sp_offset); 16187690Smarkm bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp); 162123250Sdes 16387690Smarkm if (!saved_fp_safe) { 16428693Scharnier return false; 165123250Sdes } 1661590Srgrimes 16787690Smarkm // construct the potential sender 168123407Sdes 1691590Srgrimes frame sender(sender_sp, saved_fp, sender_pc); 1701590Srgrimes 17178474Sschweikh return sender.is_interpreted_frame_valid(thread); 1721590Srgrimes 1731590Srgrimes } 1741590Srgrimes 17543822Sken // We must always be able to find a recognizable pc 176123250Sdes CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc); 1771590Srgrimes if (sender_pc == NULL || sender_blob == NULL) { 178123250Sdes return false; 179123250Sdes } 180123250Sdes 1811590Srgrimes // Could be a zombie method 1821590Srgrimes if (sender_blob->is_zombie() || sender_blob->is_unloaded()) { 1831590Srgrimes return false; 1841590Srgrimes } 185113460Stjr 1861590Srgrimes // Could just be some random pointer within the codeBlob 1871590Srgrimes if (!sender_blob->code_contains(sender_pc)) { 1881590Srgrimes return false; 1891590Srgrimes } 1901590Srgrimes 1911590Srgrimes // We should never be able to see an adapter if the current frame is something from code cache 1921590Srgrimes if (sender_blob->is_adapter_blob()) { 1931590Srgrimes return false; 1941590Srgrimes } 1951590Srgrimes 1961590Srgrimes // Could be the call_stub 1971590Srgrimes if (StubRoutines::returns_to_call_stub(sender_pc)) { 1981590Srgrimes intptr_t *saved_fp = (intptr_t*)*(sender_sp - frame::sender_sp_offset); 19939230Sgibbs bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp); 20039372Sdillon 20139230Sgibbs if (!saved_fp_safe) { 20239230Sgibbs return false; 20339230Sgibbs } 20439230Sgibbs 20539230Sgibbs // construct the potential sender 20639230Sgibbs 207112284Sphk frame sender(sender_sp, saved_fp, sender_pc); 20839230Sgibbs 20939230Sgibbs // Validate the JavaCallWrapper an entry frame must have 2101590Srgrimes address jcw = (address)sender.entry_frame_call_wrapper(); 2111590Srgrimes 2121590Srgrimes bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > (address)sender.fp()); 2131590Srgrimes 21430180Sdima return jcw_safe; 2151590Srgrimes } 21630180Sdima 21730180Sdima if (sender_blob->is_nmethod()) { 21830180Sdima nmethod* nm = sender_blob->as_nmethod_or_null(); 2191590Srgrimes if (nm != NULL) { 2201590Srgrimes if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc)) { 2211590Srgrimes return false; 2221590Srgrimes } 22344067Sbde } 22444067Sbde } 22544067Sbde 2261590Srgrimes // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size 2271590Srgrimes // because the return address counts against the callee's frame. 2281590Srgrimes 2291590Srgrimes if (sender_blob->frame_size() <= 0) { 2301590Srgrimes assert(!sender_blob->is_nmethod(), "should count return address at least"); 2311590Srgrimes return false; 2321590Srgrimes } 2331590Srgrimes 2341590Srgrimes // We should never be able to see anything here except an nmethod. If something in the 2351590Srgrimes // code cache (current frame) is called by an entity within the code cache that entity 2361590Srgrimes // should not be anything but the call stub (already covered), the interpreter (already covered) 237123250Sdes // or an nmethod. 238123250Sdes 239123250Sdes if (!sender_blob->is_nmethod()) { 240123250Sdes return false; 241123250Sdes } 2421590Srgrimes 243123250Sdes // Could put some more validation for the potential non-interpreted sender 2441590Srgrimes // frame we'd create by calling sender if I could think of any. Wait for next crash in forte... 24528693Scharnier 2461590Srgrimes // One idea is seeing if the sender_pc we have is one that we'd expect to call to current cb 247123250Sdes 248123250Sdes // We've validated the potential sender that would be created 2491590Srgrimes return true; 25081537Sken } 2511590Srgrimes 2521590Srgrimes // Must be native-compiled frame. Since sender will try and use fp to find 2531590Srgrimes // linkages it must be safe 25428693Scharnier 2551590Srgrimes if (!fp_safe) { 2561590Srgrimes return false; 2571590Srgrimes } 2581590Srgrimes 2591590Srgrimes // Will the pc we fetch be non-zero (which we'll find at the oldest frame) 2601590Srgrimes 26143819Sken if ( (address) this->fp()[return_addr_offset] == NULL) return false; 26243819Sken 26343819Sken 26443819Sken // could try and do some more potential verification of native frame if we could think of some... 26543819Sken 266112284Sphk return true; 26743819Sken 26843819Sken} 26943819Sken 2701590Srgrimes 2711590Srgrimesvoid frame::patch_pc(Thread* thread, address pc) { 2721590Srgrimes address* pc_addr = &(((address*) sp())[-1]); 2731590Srgrimes if (TracePcPatching) { 2741590Srgrimes tty->print_cr("patch_pc at address " INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "]", 2751590Srgrimes pc_addr, *pc_addr, pc); 2761590Srgrimes } 2771590Srgrimes // Either the return address is the original one or we are going to 2781590Srgrimes // patch in the same address that's already there. 2791590Srgrimes assert(_pc == *pc_addr || pc == *pc_addr, "must be"); 2801590Srgrimes *pc_addr = pc; 2811590Srgrimes _cb = CodeCache::find_blob(pc); 2821590Srgrimes address original_pc = nmethod::get_deopt_original_pc(this); 2831590Srgrimes if (original_pc != NULL) { 2841590Srgrimes assert(original_pc == _pc, "expected original PC to be stored before patching"); 2851590Srgrimes _deopt_state = is_deoptimized; 2861590Srgrimes // leave _pc as is 2871590Srgrimes } else { 2881590Srgrimes _deopt_state = not_deoptimized; 2891590Srgrimes _pc = pc; 2901590Srgrimes } 2911590Srgrimes} 2921590Srgrimes 2931590Srgrimesbool frame::is_interpreted_frame() const { 2941590Srgrimes return Interpreter::contains(pc()); 2951590Srgrimes} 2961590Srgrimes 29743962Sdillonint frame::frame_size(RegisterMap* map) const { 29843962Sdillon frame sender = this->sender(map); 2991590Srgrimes return sender.sp() - sp(); 3001590Srgrimes} 30130180Sdima 3021590Srgrimesintptr_t* frame::entry_frame_argument_at(int offset) const { 3031590Srgrimes // convert offset to index to deal with tsi 3041590Srgrimes int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize); 3051590Srgrimes // Entry frame's arguments are always in relation to unextended_sp() 3061590Srgrimes return &unextended_sp()[index]; 3071590Srgrimes} 3081590Srgrimes 3091590Srgrimes// sender_sp 3101590Srgrimes#ifdef CC_INTERP 3111590Srgrimesintptr_t* frame::interpreter_frame_sender_sp() const { 312123250Sdes assert(is_interpreted_frame(), "interpreted frame expected"); 313123250Sdes // QQQ why does this specialize method exist if frame::sender_sp() does same thing? 314123250Sdes // seems odd and if we always know interpreted vs. non then sender_sp() is really 3151590Srgrimes // doing too much work. 316123250Sdes return get_interpreterState()->sender_sp(); 317123250Sdes} 318123250Sdes 319123250Sdes// monitor elements 320123250Sdes 321123250SdesBasicObjectLock* frame::interpreter_frame_monitor_begin() const { 322123250Sdes return get_interpreterState()->monitor_base(); 323123250Sdes} 324123250Sdes 325123250SdesBasicObjectLock* frame::interpreter_frame_monitor_end() const { 326123250Sdes return (BasicObjectLock*) get_interpreterState()->stack_base(); 327112284Sphk} 32839230Sgibbs 3291590Srgrimes#else // CC_INTERP 33039230Sgibbs 33139230Sgibbsintptr_t* frame::interpreter_frame_sender_sp() const { 33239230Sgibbs assert(is_interpreted_frame(), "interpreted frame expected"); 33339230Sgibbs return (intptr_t*) at(interpreter_frame_sender_sp_offset); 33439230Sgibbs} 335112284Sphk 33639230Sgibbsvoid frame::set_interpreter_frame_sender_sp(intptr_t* sender_sp) { 33739230Sgibbs assert(is_interpreted_frame(), "interpreted frame expected"); 33839230Sgibbs ptr_at_put(interpreter_frame_sender_sp_offset, (intptr_t) sender_sp); 33939230Sgibbs} 34039230Sgibbs 34139230Sgibbs 34239230Sgibbs// monitor elements 3431590Srgrimes 3441590SrgrimesBasicObjectLock* frame::interpreter_frame_monitor_begin() const { 34539230Sgibbs return (BasicObjectLock*) addr_at(interpreter_frame_monitor_block_bottom_offset); 34639230Sgibbs} 34739230Sgibbs 34839230SgibbsBasicObjectLock* frame::interpreter_frame_monitor_end() const { 34939230Sgibbs BasicObjectLock* result = (BasicObjectLock*) *addr_at(interpreter_frame_monitor_block_top_offset); 3501590Srgrimes // make sure the pointer points inside the frame 35139230Sgibbs assert(sp() <= (intptr_t*) result, "monitor end should be above the stack pointer"); 35239230Sgibbs assert((intptr_t*) result < fp(), "monitor end should be strictly below the frame pointer"); 35339372Sdillon return result; 35439372Sdillon} 35539372Sdillon 35639230Sgibbsvoid frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) { 35739230Sgibbs *((BasicObjectLock**)addr_at(interpreter_frame_monitor_block_top_offset)) = value; 35839230Sgibbs} 35939230Sgibbs 36039230Sgibbs// Used by template based interpreter deoptimization 36139230Sgibbsvoid frame::interpreter_frame_set_last_sp(intptr_t* sp) { 36239230Sgibbs *((intptr_t**)addr_at(interpreter_frame_last_sp_offset)) = sp; 36339230Sgibbs} 36439230Sgibbs#endif // CC_INTERP 36539230Sgibbs 36639230Sgibbsframe frame::sender_for_entry_frame(RegisterMap* map) const { 367112284Sphk assert(map != NULL, "map must be set"); 36839230Sgibbs // Java frame called from C; skip all C frames and return top C 36939230Sgibbs // frame of that chunk as the sender 37039230Sgibbs JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor(); 37139230Sgibbs assert(!entry_frame_is_first(), "next Java fp must be non zero"); 37239230Sgibbs assert(jfa->last_Java_sp() > sp(), "must be above this frame on stack"); 37339230Sgibbs map->clear(); 37439230Sgibbs assert(map->include_argument_oops(), "should be set by clear"); 37539230Sgibbs if (jfa->last_Java_pc() != NULL ) { 37639230Sgibbs frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc()); 37739230Sgibbs return fr; 37839230Sgibbs } 379112284Sphk frame fr(jfa->last_Java_sp(), jfa->last_Java_fp()); 38039230Sgibbs return fr; 38139230Sgibbs} 38239230Sgibbs 38339230Sgibbs//------------------------------------------------------------------------------ 38439230Sgibbs// frame::verify_deopt_original_pc 38539230Sgibbs// 3861590Srgrimes// Verifies the calculated original PC of a deoptimization PC for the 3871590Srgrimes// given unextended SP. The unextended SP might also be the saved SP 3881590Srgrimes// for MethodHandle call sites. 389123250Sdes#ifdef ASSERT 390123250Sdesvoid frame::verify_deopt_original_pc(nmethod* nm, intptr_t* unextended_sp, bool is_method_handle_return) { 3911590Srgrimes frame fr; 392101590Stmm 393101590Stmm // This is ugly but it's better than to change {get,set}_original_pc 3941590Srgrimes // to take an SP value as argument. And it's only a debugging 3951590Srgrimes // method anyway. 396123250Sdes fr._unextended_sp = unextended_sp; 397123250Sdes 398123250Sdes address original_pc = nm->get_original_pc(&fr); 399123250Sdes assert(nm->insts_contains(original_pc), "original PC must be in nmethod"); 400123250Sdes assert(nm->is_method_handle_return(original_pc) == is_method_handle_return, "must be"); 401123250Sdes} 402123250Sdes#endif 403123250Sdes 404123250Sdes//------------------------------------------------------------------------------ 405123250Sdes// frame::adjust_unextended_sp 406123250Sdesvoid frame::adjust_unextended_sp() { 407123250Sdes // If we are returning to a compiled MethodHandle call site, the 4081590Srgrimes // saved_fp will in fact be a saved value of the unextended SP. The 409101590Stmm // simplest way to tell whether we are returning to such a call site 41028693Scharnier // is as follows: 41128693Scharnier 4121590Srgrimes nmethod* sender_nm = (_cb == NULL) ? NULL : _cb->as_nmethod_or_null(); 4131590Srgrimes if (sender_nm != NULL) { 4141590Srgrimes // If the sender PC is a deoptimization point, get the original 415123250Sdes // PC. For MethodHandle call site the unextended_sp is stored in 416123250Sdes // saved_fp. 417123250Sdes if (sender_nm->is_deopt_mh_entry(_pc)) { 418123250Sdes DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, _fp)); 419123250Sdes _unextended_sp = _fp; 420123250Sdes } 421123250Sdes else if (sender_nm->is_deopt_entry(_pc)) { 422123250Sdes DEBUG_ONLY(verify_deopt_original_pc(sender_nm, _unextended_sp)); 423123250Sdes } 424123250Sdes else if (sender_nm->is_method_handle_return(_pc)) { 425123250Sdes _unextended_sp = _fp; 426123250Sdes } 427123250Sdes } 428123250Sdes} 429123250Sdes 4301590Srgrimes//------------------------------------------------------------------------------ 431123250Sdes// frame::update_map_with_saved_link 432123250Sdesvoid frame::update_map_with_saved_link(RegisterMap* map, intptr_t** link_addr) { 433123250Sdes // The interpreter and compiler(s) always save EBP/RBP in a known 434123250Sdes // location on entry. We must record where that location is 435123250Sdes // so this if EBP/RBP was live on callout from c2 we can find 436123250Sdes // the saved copy no matter what it called. 437123250Sdes 438123250Sdes // Since the interpreter always saves EBP/RBP if we record where it is then 439123250Sdes // we don't have to always save EBP/RBP on entry and exit to c2 compiled 440123250Sdes // code, on entry will be enough. 441123250Sdes map->set_location(rbp->as_VMReg(), (address) link_addr); 442123250Sdes#ifdef AMD64 443123250Sdes // this is weird "H" ought to be at a higher address however the 444123250Sdes // oopMaps seems to have the "H" regs at the same address and the 445123250Sdes // vanilla register. 446123250Sdes // XXXX make this go away 447123250Sdes if (true) { 448123250Sdes map->set_location(rbp->as_VMReg()->next(), (address) link_addr); 449123250Sdes } 450123250Sdes#endif // AMD64 451123250Sdes} 452123250Sdes 453123250Sdes 454123250Sdes//------------------------------------------------------------------------------ 455123250Sdes// frame::sender_for_interpreter_frame 456123250Sdesframe frame::sender_for_interpreter_frame(RegisterMap* map) const { 457123250Sdes // SP is the raw SP from the sender after adapter or interpreter 458123250Sdes // extension. 459123250Sdes intptr_t* sender_sp = this->sender_sp(); 460123250Sdes 461123250Sdes // This is the sp before any possible extension (adapter/locals). 462123250Sdes intptr_t* unextended_sp = interpreter_frame_sender_sp(); 463123250Sdes 464123250Sdes#ifdef COMPILER2 465123250Sdes if (map->update_map()) { 466123250Sdes update_map_with_saved_link(map, (intptr_t**) addr_at(link_offset)); 467123250Sdes } 468123250Sdes#endif // COMPILER2 469123250Sdes 470123250Sdes return frame(sender_sp, unextended_sp, link(), sender_pc()); 471123250Sdes} 472123250Sdes 473123250Sdes 474123250Sdes//------------------------------------------------------------------------------ 475123250Sdes// frame::sender_for_compiled_frame 476123250Sdesframe frame::sender_for_compiled_frame(RegisterMap* map) const { 477123250Sdes assert(map != NULL, "map must be set"); 478123250Sdes 479123250Sdes // frame owned by optimizing compiler 480123250Sdes assert(_cb->frame_size() >= 0, "must have non-zero frame size"); 481123250Sdes intptr_t* sender_sp = unextended_sp() + _cb->frame_size(); 4821590Srgrimes intptr_t* unextended_sp = sender_sp; 483123250Sdes 484123250Sdes // On Intel the return_address is always the word on the stack 485123250Sdes address sender_pc = (address) *(sender_sp-1); 486123250Sdes 487123250Sdes // This is the saved value of EBP which may or may not really be an FP. 488123250Sdes // It is only an FP if the sender is an interpreter frame (or C1?). 489123250Sdes intptr_t** saved_fp_addr = (intptr_t**) (sender_sp - frame::sender_sp_offset); 490123250Sdes 491123250Sdes if (map->update_map()) { 492123250Sdes // Tell GC to use argument oopmaps for some runtime stubs that need it. 493123250Sdes // For C1, the runtime stub might not have oop maps, so set this flag 494123250Sdes // outside of update_register_map. 495123250Sdes map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread())); 496123250Sdes if (_cb->oop_maps() != NULL) { 497123407Sdes OopMapSet::update_register_map(this, map); 498123250Sdes } 4991590Srgrimes 5001590Srgrimes // Since the prolog does the save and restore of EBP there is no oopmap 50139230Sgibbs // for it so we must fill in its location as if there was an oopmap entry 50280551Stmm // since if our caller was compiled code there could be live jvm state in it. 5031590Srgrimes update_map_with_saved_link(map, saved_fp_addr); 5041590Srgrimes } 5051590Srgrimes 5061590Srgrimes assert(sender_sp != sp(), "must have changed"); 5071590Srgrimes return frame(sender_sp, unextended_sp, *saved_fp_addr, sender_pc); 508123250Sdes} 509123250Sdes 510123250Sdes 511123250Sdes//------------------------------------------------------------------------------ 512123250Sdes// frame::sender 513123250Sdesframe frame::sender(RegisterMap* map) const { 514123250Sdes // Default is we done have to follow them. The sender_for_xxx will 515123250Sdes // update it accordingly 5161590Srgrimes map->set_include_argument_oops(false); 517123250Sdes 518123250Sdes if (is_entry_frame()) return sender_for_entry_frame(map); 519123250Sdes if (is_interpreted_frame()) return sender_for_interpreter_frame(map); 520123250Sdes assert(_cb == CodeCache::find_blob(pc()),"Must be the same"); 521123250Sdes 522123250Sdes if (_cb != NULL) { 523123250Sdes return sender_for_compiled_frame(map); 5241590Srgrimes } 5251590Srgrimes // Must be native-compiled frame, i.e. the marshaling code for native 5261590Srgrimes // methods that exists in the core system. 527123250Sdes return frame(sender_sp(), link(), sender_pc()); 528123250Sdes} 529123250Sdes 530123250Sdes 531123250Sdesbool frame::interpreter_frame_equals_unpacked_fp(intptr_t* fp) { 532123250Sdes assert(is_interpreted_frame(), "must be interpreter frame"); 533123250Sdes Method* method = interpreter_frame_method(); 534123250Sdes // When unpacking an optimized frame the frame pointer is 53539230Sgibbs // adjusted with: 53639230Sgibbs int diff = (method->max_locals() - method->size_of_parameters()) * 53739230Sgibbs Interpreter::stackElementWords; 53839230Sgibbs return _fp == (fp - diff); 539112288Sphk} 54039230Sgibbs 54139230Sgibbsvoid frame::pd_gc_epilog() { 54239230Sgibbs // nothing done here now 54339230Sgibbs} 54439230Sgibbs 54539230Sgibbsbool frame::is_interpreted_frame_valid(JavaThread* thread) const { 54639230Sgibbs// QQQ 54739230Sgibbs#ifdef CC_INTERP 548112284Sphk#else 54939230Sgibbs assert(is_interpreted_frame(), "Not an interpreted frame"); 55039230Sgibbs // These are reasonable sanity checks 55139230Sgibbs if (fp() == 0 || (intptr_t(fp()) & (wordSize-1)) != 0) { 55239230Sgibbs return false; 55339230Sgibbs } 55439230Sgibbs if (sp() == 0 || (intptr_t(sp()) & (wordSize-1)) != 0) { 55539230Sgibbs return false; 55639230Sgibbs } 55739230Sgibbs if (fp() + interpreter_frame_initial_sp_offset < sp()) { 558112284Sphk return false; 55939230Sgibbs } 56039230Sgibbs // These are hacks to keep us out of trouble. 56139230Sgibbs // The problem with these is that they mask other problems 56239230Sgibbs if (fp() <= sp()) { // this attempts to deal with unsigned comparison above 56339230Sgibbs return false; 56439230Sgibbs } 56539230Sgibbs 56639230Sgibbs // do some validation of frame elements 56739230Sgibbs 56839230Sgibbs // first the method 56939230Sgibbs 57039230Sgibbs Method* m = *interpreter_frame_method_addr(); 57139230Sgibbs 57239230Sgibbs // validate the method we'd find in this potential sender 57339230Sgibbs if (!m->is_valid_method()) return false; 57439230Sgibbs 57539230Sgibbs // stack frames shouldn't be much larger than max_stack elements 57639230Sgibbs 57739230Sgibbs if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) { 57839230Sgibbs return false; 57939230Sgibbs } 580123250Sdes 581123250Sdes // validate bci/bcx 58278672Sschweikh 5831590Srgrimes intptr_t bcx = interpreter_frame_bcx(); 58472887Salfred if (m->validate_bci_from_bcx(bcx) < 0) { 5851590Srgrimes return false; 58681537Sken } 58781537Sken 58837453Sbde // validate ConstantPoolCache* 589123407Sdes ConstantPoolCache* cp = *interpreter_frame_cache_addr(); 5901590Srgrimes if (cp == NULL || !cp->is_metadata()) return false; 591123407Sdes 59237453Sbde // validate locals 593123407Sdes 5943659Sdg address locals = (address) *interpreter_frame_locals_addr(); 59537453Sbde 596123407Sdes if (locals > thread->stack_base() || locals < (address) fp()) return false; 5973693Sdg 59837453Sbde // We'd have to be pretty unlucky to be mislead at this point 599123407Sdes 60037453Sbde#endif // CC_INTERP 601123407Sdes return true; 60239230Sgibbs} 6031590Srgrimes 604123407SdesBasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) { 605123407Sdes#ifdef CC_INTERP 606123407Sdes // Needed for JVMTI. The result should always be in the 6071590Srgrimes // interpreterState object 6081590Srgrimes interpreterState istate = get_interpreterState(); 6091590Srgrimes#endif // CC_INTERP 6101590Srgrimes assert(is_interpreted_frame(), "interpreted frame expected"); 6111590Srgrimes Method* method = interpreter_frame_method(); 6121590Srgrimes BasicType type = method->result_type(); 6131590Srgrimes 6141590Srgrimes intptr_t* tos_addr; 6151590Srgrimes if (method->is_native()) { 6161590Srgrimes // Prior to calling into the runtime to report the method_exit the possible 6171590Srgrimes // return value is pushed to the native stack. If the result is a jfloat/jdouble 6183659Sdg // then ST0 is saved before EAX/EDX. See the note in generate_native_result 6193659Sdg tos_addr = (intptr_t*)sp(); 6203659Sdg if (type == T_FLOAT || type == T_DOUBLE) { 6213659Sdg // QQQ seems like this code is equivalent on the two platforms 6221590Srgrimes#ifdef AMD64 6231590Srgrimes // This is times two because we do a push(ltos) after pushing XMM0 6241590Srgrimes // and that takes two interpreter stack slots. 6251590Srgrimes tos_addr += 2 * Interpreter::stackElementWords; 626123250Sdes#else 627123250Sdes tos_addr += 2; 6281590Srgrimes#endif // AMD64 62943822Sken } 6301590Srgrimes } else { 63143822Sken tos_addr = (intptr_t*)interpreter_frame_tos_address(); 63278672Sschweikh } 63343822Sken 63443822Sken switch (type) { 63543822Sken case T_OBJECT : 63643822Sken case T_ARRAY : { 63743822Sken oop obj; 63878672Sschweikh if (method->is_native()) { 63939230Sgibbs#ifdef CC_INTERP 64039230Sgibbs obj = istate->_oop_temp; 64139230Sgibbs#else 64239230Sgibbs obj = (oop) at(interpreter_frame_oop_temp_offset); 64339230Sgibbs#endif // CC_INTERP 64439230Sgibbs } else { 6451590Srgrimes oop* obj_p = (oop*)tos_addr; 6461590Srgrimes obj = (obj_p == NULL) ? (oop)NULL : *obj_p; 6471590Srgrimes } 6481590Srgrimes assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check"); 6491590Srgrimes *oop_result = obj; 6501590Srgrimes break; 6511590Srgrimes } 652123250Sdes case T_BOOLEAN : value_result->z = *(jboolean*)tos_addr; break; 653123250Sdes case T_BYTE : value_result->b = *(jbyte*)tos_addr; break; 6541590Srgrimes case T_CHAR : value_result->c = *(jchar*)tos_addr; break; 6551590Srgrimes case T_SHORT : value_result->s = *(jshort*)tos_addr; break; 6561590Srgrimes case T_INT : value_result->i = *(jint*)tos_addr; break; 6571590Srgrimes case T_LONG : value_result->j = *(jlong*)tos_addr; break; 6581590Srgrimes case T_FLOAT : { 65930180Sdima#ifdef AMD64 660123250Sdes value_result->f = *(jfloat*)tos_addr; 661123250Sdes#else 6621590Srgrimes if (method->is_native()) { 663123407Sdes jdouble d = *(jdouble*)tos_addr; // Result was in ST0 so need to convert to jfloat 6641590Srgrimes value_result->f = (jfloat)d; 6651590Srgrimes } else { 6661590Srgrimes value_result->f = *(jfloat*)tos_addr; 6671590Srgrimes } 6681590Srgrimes#endif // AMD64 6691590Srgrimes break; 6701590Srgrimes } 6711590Srgrimes case T_DOUBLE : value_result->d = *(jdouble*)tos_addr; break; 6721590Srgrimes case T_VOID : /* Nothing to do */ break; 6731590Srgrimes default : ShouldNotReachHere(); 6741590Srgrimes } 6751590Srgrimes 6761590Srgrimes return type; 6771590Srgrimes} 6781590Srgrimes 679123250Sdes 680123250Sdesintptr_t* frame::interpreter_frame_tos_at(jint offset) const { 6811590Srgrimes int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize); 6821590Srgrimes return &interpreter_frame_tos_address()[index]; 6831590Srgrimes} 6841590Srgrimes 6851590Srgrimes#ifndef PRODUCT 6861590Srgrimes 6871590Srgrimes#define DESCRIBE_FP_OFFSET(name) \ 6881590Srgrimes values.describe(frame_no, fp() + frame::name##_offset, #name) 6891590Srgrimes 6901590Srgrimesvoid frame::describe_pd(FrameValues& values, int frame_no) { 6911590Srgrimes if (is_interpreted_frame()) { 692123250Sdes DESCRIBE_FP_OFFSET(interpreter_frame_sender_sp); 693123250Sdes DESCRIBE_FP_OFFSET(interpreter_frame_last_sp); 6941590Srgrimes DESCRIBE_FP_OFFSET(interpreter_frame_method); 69587690Smarkm DESCRIBE_FP_OFFSET(interpreter_frame_mdx); 6961590Srgrimes DESCRIBE_FP_OFFSET(interpreter_frame_cache); 6971590Srgrimes DESCRIBE_FP_OFFSET(interpreter_frame_locals); 698123250Sdes DESCRIBE_FP_OFFSET(interpreter_frame_bcx); 6991590Srgrimes DESCRIBE_FP_OFFSET(interpreter_frame_initial_sp); 7001590Srgrimes } 7011590Srgrimes} 7021590Srgrimes#endif 7031590Srgrimes 70471429Sumeintptr_t *frame::initial_deoptimization_info() { 70571429Sume // used to reset the saved FP 70671429Sume return fp(); 70771429Sume} 7083659Sdg 7093693Sdgintptr_t* frame::real_fp() const { 7103659Sdg if (_cb != NULL) { 7113659Sdg // use the frame size if valid 7123659Sdg int size = _cb->frame_size(); 7133693Sdg if (size > 0) { 7143659Sdg return unextended_sp() + size; 7153659Sdg } 7163693Sdg } 7173693Sdg // else rely on fp() 7181590Srgrimes assert(! is_compiled_frame(), "unknown compiled frame size"); 7197351Sdg return fp(); 72034214Sdyson} 7217351Sdg