truffle: src/cpu/x86/vm/frame

annotate src/cpu/x86/vm/frame_x86.cpp @ 3101:6ccb95c97e6d

IdealGraphVisualizer: Work around a problem with JSplitPane and the NetBeans editor: setDividerLocation() doesn't work when the split pane has not been layouted and painted yet. JSplitPane then initially uses a tiny width for the left editor component, which causes the editor to calculate invalid offsets and constantly throw exceptions, particularly on mouse events. Thus, defer adding the two components and setting the divider's location.

author	Peter Hofer <peter.hofer@jku.at>
date	Thu, 30 Jun 2011 12:17:27 +0200
parents	d9e4d0aefc90
children	be4ca325525a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1513 diff changeset	2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1513 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1513 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1513 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	26 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	27 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	28 #include "oops/markOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	29 #include "oops/methodOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	30 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	31 #include "runtime/frame.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	32 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	33 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	34 #include "runtime/monitorChunk.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	35 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	36 #include "runtime/stubCodeGenerator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	37 #include "runtime/stubRoutines.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	38 #include "vmreg_x86.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	39 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	40 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	41 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	42 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	45 void RegisterMap::check_location_valid() {
a61af66fc99e Initial load duke parents: diff changeset	46 }
a61af66fc99e Initial load duke parents: diff changeset	47 #endif
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 // Profiling/safepoint support
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 bool frame::safe_for_sender(JavaThread *thread) {
a61af66fc99e Initial load duke parents: diff changeset	53 address sp = (address)_sp;
a61af66fc99e Initial load duke parents: diff changeset	54 address fp = (address)_fp;
a61af66fc99e Initial load duke parents: diff changeset	55 address unextended_sp = (address)_unextended_sp;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	56 // sp must be within the stack
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	57 bool sp_safe = (sp <= thread->stack_base()) &&
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	58 (sp >= thread->stack_base() - thread->stack_size());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	59
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	60 if (!sp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	61 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	62 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	63
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	64 // unextended sp must be within the stack and above or equal sp
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	65 bool unextended_sp_safe = (unextended_sp <= thread->stack_base()) &&
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	66 (unextended_sp >= sp);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	67
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	68 if (!unextended_sp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	69 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	70 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	71
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	72 // an fp must be within the stack and above (but not equal) sp
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	73 bool fp_safe = (fp <= thread->stack_base()) && (fp > sp);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	74
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	75 // We know sp/unextended_sp are safe only fp is questionable here
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	76
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	77 // If the current frame is known to the code cache then we can attempt to
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	78 // to construct the sender and do some validation of it. This goes a long way
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	79 // toward eliminating issues when we get in frame construction code
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	80
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	81 if (_cb != NULL ) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	82
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	83 // First check if frame is complete and tester is reliable
0 a61af66fc99e Initial load duke parents: diff changeset	84 // Unfortunately we can only check frame complete for runtime stubs and nmethod
a61af66fc99e Initial load duke parents: diff changeset	85 // other generic buffer blobs are more problematic so we just assume they are
a61af66fc99e Initial load duke parents: diff changeset	86 // ok. adapter blobs never have a frame complete and are never ok.
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	87
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	88 if (!_cb->is_frame_complete_at(_pc)) {
0 a61af66fc99e Initial load duke parents: diff changeset	89 if (_cb->is_nmethod() \|\| _cb->is_adapter_blob() \|\| _cb->is_runtime_stub()) {
a61af66fc99e Initial load duke parents: diff changeset	90 return false;
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	93 // Entry frame checks
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	94 if (is_entry_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	95 // an entry frame must have a valid fp.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	96
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	97 if (!fp_safe) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	98
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	99 // Validate the JavaCallWrapper an entry frame must have
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	100
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	101 address jcw = (address)entry_frame_call_wrapper();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	102
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	103 bool jcw_safe = (jcw <= thread->stack_base()) && ( jcw > fp);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	104
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	105 return jcw_safe;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	106
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	107 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	108
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	109 intptr_t* sender_sp = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	110 address sender_pc = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	111
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	112 if (is_interpreted_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	113 // fp must be safe
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	114 if (!fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	115 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	116 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	117
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	118 sender_pc = (address) this->fp()[return_addr_offset];
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	119 sender_sp = (intptr_t*) addr_at(sender_sp_offset);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	120
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	121 } else {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	122 // must be some sort of compiled/runtime frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	123 // fp does not have to be safe (although it could be check for c1?)
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	124
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	125 sender_sp = _unextended_sp + _cb->frame_size();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	126 // On Intel the return_address is always the word on the stack
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	127 sender_pc = (address) *(sender_sp-1);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	128 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	129
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	130 // We must always be able to find a recognizable pc
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	131 CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	132 if (sender_pc == NULL \|\| sender_blob == NULL) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	133 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	134 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	135
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	136
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	137 // If the potential sender is the interpreter then we can do some more checking
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	138 if (Interpreter::contains(sender_pc)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	139
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	140 // ebp is always saved in a recognizable place in any code we generate. However
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	141 // only if the sender is interpreted/call_stub (c1 too?) are we certain that the saved ebp
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	142 // is really a frame pointer.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	143
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	144 intptr_t saved_fp = (intptr_t)*(sender_sp - frame::sender_sp_offset);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	145 bool saved_fp_safe = ((address)saved_fp <= thread->stack_base()) && (saved_fp > sender_sp);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	146
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	147 if (!saved_fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	148 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	149 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	150
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	151 // construct the potential sender
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	152
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	153 frame sender(sender_sp, saved_fp, sender_pc);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	154
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	155 return sender.is_interpreted_frame_valid(thread);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	156
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	157 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	158
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	159 // Could just be some random pointer within the codeBlob
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	160 if (!sender_blob->code_contains(sender_pc)) {
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	161 return false;
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	162 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	163
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	164 // We should never be able to see an adapter if the current frame is something from code cache
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	165 if (sender_blob->is_adapter_blob()) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	166 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	167 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	168
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	169 // Could be the call_stub
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	170
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	171 if (StubRoutines::returns_to_call_stub(sender_pc)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	172 intptr_t saved_fp = (intptr_t)*(sender_sp - frame::sender_sp_offset);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	173 bool saved_fp_safe = ((address)saved_fp <= thread->stack_base()) && (saved_fp > sender_sp);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	174
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	175 if (!saved_fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	176 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	177 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	178
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	179 // construct the potential sender
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	180
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	181 frame sender(sender_sp, saved_fp, sender_pc);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	182
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	183 // Validate the JavaCallWrapper an entry frame must have
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	184 address jcw = (address)sender.entry_frame_call_wrapper();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	185
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	186 bool jcw_safe = (jcw <= thread->stack_base()) && ( jcw > (address)sender.fp());
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	187
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	188 return jcw_safe;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	189 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	190
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	191 // If the frame size is 0 something is bad because every nmethod has a non-zero frame size
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	192 // because the return address counts against the callee's frame.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	193
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	194 if (sender_blob->frame_size() == 0) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	195 assert(!sender_blob->is_nmethod(), "should count return address at least");
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	196 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	197 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	198
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	199 // We should never be able to see anything here except an nmethod. If something in the
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	200 // code cache (current frame) is called by an entity within the code cache that entity
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	201 // should not be anything but the call stub (already covered), the interpreter (already covered)
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	202 // or an nmethod.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	203
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	204 assert(sender_blob->is_nmethod(), "Impossible call chain");
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	205
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	206 // Could put some more validation for the potential non-interpreted sender
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	207 // frame we'd create by calling sender if I could think of any. Wait for next crash in forte...
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	208
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	209 // One idea is seeing if the sender_pc we have is one that we'd expect to call to current cb
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	210
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	211 // We've validated the potential sender that would be created
0 a61af66fc99e Initial load duke parents: diff changeset	212 return true;
a61af66fc99e Initial load duke parents: diff changeset	213 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	214
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	215 // Must be native-compiled frame. Since sender will try and use fp to find
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	216 // linkages it must be safe
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	217
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	218 if (!fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	219 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	220 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	221
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	222 // Will the pc we fetch be non-zero (which we'll find at the oldest frame)
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	223
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	224 if ( (address) this->fp()[return_addr_offset] == NULL) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	225
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	226
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	227 // could try and do some more potential verification of native frame if we could think of some...
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	228
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	229 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	230
0 a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 void frame::patch_pc(Thread* thread, address pc) {
a61af66fc99e Initial load duke parents: diff changeset	235 if (TracePcPatching) {
304 dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 196 diff changeset	236 tty->print_cr("patch_pc at address" INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "] ",
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories never parents: 196 diff changeset	237 &((address )sp())[-1], ((address )sp())[-1], pc);
0 a61af66fc99e Initial load duke parents: diff changeset	238 }
a61af66fc99e Initial load duke parents: diff changeset	239 ((address *)sp())[-1] = pc;
a61af66fc99e Initial load duke parents: diff changeset	240 _cb = CodeCache::find_blob(pc);
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	241 address original_pc = nmethod::get_deopt_original_pc(this);
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	242 if (original_pc != NULL) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	243 assert(original_pc == _pc, "expected original PC to be stored before patching");
0 a61af66fc99e Initial load duke parents: diff changeset	244 _deopt_state = is_deoptimized;
a61af66fc99e Initial load duke parents: diff changeset	245 // leave _pc as is
a61af66fc99e Initial load duke parents: diff changeset	246 } else {
a61af66fc99e Initial load duke parents: diff changeset	247 _deopt_state = not_deoptimized;
a61af66fc99e Initial load duke parents: diff changeset	248 _pc = pc;
a61af66fc99e Initial load duke parents: diff changeset	249 }
a61af66fc99e Initial load duke parents: diff changeset	250 }
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 bool frame::is_interpreted_frame() const {
a61af66fc99e Initial load duke parents: diff changeset	253 return Interpreter::contains(pc());
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
793 eacd97c88873 6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization cfang parents: 304 diff changeset	256 int frame::frame_size(RegisterMap* map) const {
eacd97c88873 6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization cfang parents: 304 diff changeset	257 frame sender = this->sender(map);
0 a61af66fc99e Initial load duke parents: diff changeset	258 return sender.sp() - sp();
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 intptr_t* frame::entry_frame_argument_at(int offset) const {
a61af66fc99e Initial load duke parents: diff changeset	262 // convert offset to index to deal with tsi
a61af66fc99e Initial load duke parents: diff changeset	263 int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize);
a61af66fc99e Initial load duke parents: diff changeset	264 // Entry frame's arguments are always in relation to unextended_sp()
a61af66fc99e Initial load duke parents: diff changeset	265 return &unextended_sp()[index];
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // sender_sp
a61af66fc99e Initial load duke parents: diff changeset	269 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	270 intptr_t* frame::interpreter_frame_sender_sp() const {
a61af66fc99e Initial load duke parents: diff changeset	271 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	272 // QQQ why does this specialize method exist if frame::sender_sp() does same thing?
a61af66fc99e Initial load duke parents: diff changeset	273 // seems odd and if we always know interpreted vs. non then sender_sp() is really
a61af66fc99e Initial load duke parents: diff changeset	274 // doing too much work.
a61af66fc99e Initial load duke parents: diff changeset	275 return get_interpreterState()->sender_sp();
a61af66fc99e Initial load duke parents: diff changeset	276 }
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 // monitor elements
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
a61af66fc99e Initial load duke parents: diff changeset	281 return get_interpreterState()->monitor_base();
a61af66fc99e Initial load duke parents: diff changeset	282 }
a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
a61af66fc99e Initial load duke parents: diff changeset	285 return (BasicObjectLock*) get_interpreterState()->stack_base();
a61af66fc99e Initial load duke parents: diff changeset	286 }
a61af66fc99e Initial load duke parents: diff changeset	287
a61af66fc99e Initial load duke parents: diff changeset	288 #else // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 intptr_t* frame::interpreter_frame_sender_sp() const {
a61af66fc99e Initial load duke parents: diff changeset	291 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	292 return (intptr_t*) at(interpreter_frame_sender_sp_offset);
a61af66fc99e Initial load duke parents: diff changeset	293 }
a61af66fc99e Initial load duke parents: diff changeset	294
a61af66fc99e Initial load duke parents: diff changeset	295 void frame::set_interpreter_frame_sender_sp(intptr_t* sender_sp) {
a61af66fc99e Initial load duke parents: diff changeset	296 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	297 ptr_at_put(interpreter_frame_sender_sp_offset, (intptr_t) sender_sp);
a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 // monitor elements
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
a61af66fc99e Initial load duke parents: diff changeset	304 return (BasicObjectLock*) addr_at(interpreter_frame_monitor_block_bottom_offset);
a61af66fc99e Initial load duke parents: diff changeset	305 }
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
a61af66fc99e Initial load duke parents: diff changeset	308 BasicObjectLock* result = (BasicObjectLock) addr_at(interpreter_frame_monitor_block_top_offset);
a61af66fc99e Initial load duke parents: diff changeset	309 // make sure the pointer points inside the frame
1488 615a9d95d265 6946056: assert((intptr_t) sp()<=(intptr_t) result,"result must>=than stack pointer"), frame_x86.cpp:295 johnc parents: 1204 diff changeset	310 assert(sp() <= (intptr_t*) result, "monitor end should be above the stack pointer");
615a9d95d265 6946056: assert((intptr_t) sp()<=(intptr_t) result,"result must>=than stack pointer"), frame_x86.cpp:295 johnc parents: 1204 diff changeset	311 assert((intptr_t*) result < fp(), "monitor end should be strictly below the frame pointer");
0 a61af66fc99e Initial load duke parents: diff changeset	312 return result;
a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
a61af66fc99e Initial load duke parents: diff changeset	316 ((BasicObjectLock*)addr_at(interpreter_frame_monitor_block_top_offset)) = value;
a61af66fc99e Initial load duke parents: diff changeset	317 }
a61af66fc99e Initial load duke parents: diff changeset	318
a61af66fc99e Initial load duke parents: diff changeset	319 // Used by template based interpreter deoptimization
a61af66fc99e Initial load duke parents: diff changeset	320 void frame::interpreter_frame_set_last_sp(intptr_t* sp) {
a61af66fc99e Initial load duke parents: diff changeset	321 ((intptr_t*)addr_at(interpreter_frame_last_sp_offset)) = sp;
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 frame frame::sender_for_entry_frame(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	326 assert(map != NULL, "map must be set");
a61af66fc99e Initial load duke parents: diff changeset	327 // Java frame called from C; skip all C frames and return top C
a61af66fc99e Initial load duke parents: diff changeset	328 // frame of that chunk as the sender
a61af66fc99e Initial load duke parents: diff changeset	329 JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();
a61af66fc99e Initial load duke parents: diff changeset	330 assert(!entry_frame_is_first(), "next Java fp must be non zero");
a61af66fc99e Initial load duke parents: diff changeset	331 assert(jfa->last_Java_sp() > sp(), "must be above this frame on stack");
a61af66fc99e Initial load duke parents: diff changeset	332 map->clear();
a61af66fc99e Initial load duke parents: diff changeset	333 assert(map->include_argument_oops(), "should be set by clear");
a61af66fc99e Initial load duke parents: diff changeset	334 if (jfa->last_Java_pc() != NULL ) {
a61af66fc99e Initial load duke parents: diff changeset	335 frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc());
a61af66fc99e Initial load duke parents: diff changeset	336 return fr;
a61af66fc99e Initial load duke parents: diff changeset	337 }
a61af66fc99e Initial load duke parents: diff changeset	338 frame fr(jfa->last_Java_sp(), jfa->last_Java_fp());
a61af66fc99e Initial load duke parents: diff changeset	339 return fr;
a61af66fc99e Initial load duke parents: diff changeset	340 }
a61af66fc99e Initial load duke parents: diff changeset	341
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	342
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	343 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	344 // frame::verify_deopt_original_pc
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	345 //
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	346 // Verifies the calculated original PC of a deoptimization PC for the
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	347 // given unextended SP. The unextended SP might also be the saved SP
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	348 // for MethodHandle call sites.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	349 #if ASSERT
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	350 void frame::verify_deopt_original_pc(nmethod* nm, intptr_t* unextended_sp, bool is_method_handle_return) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	351 frame fr;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	352
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	353 // This is ugly but it's better than to change {get,set}_original_pc
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	354 // to take an SP value as argument. And it's only a debugging
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	355 // method anyway.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	356 fr._unextended_sp = unextended_sp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	357
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	358 address original_pc = nm->get_original_pc(&fr);
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	359 assert(nm->insts_contains(original_pc), "original PC must be in nmethod");
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	360 assert(nm->is_method_handle_return(original_pc) == is_method_handle_return, "must be");
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	361 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	362 #endif
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	363
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	364
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	365 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	366 // frame::sender_for_interpreter_frame
0 a61af66fc99e Initial load duke parents: diff changeset	367 frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	368 // SP is the raw SP from the sender after adapter or interpreter
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	369 // extension.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	370 intptr_t* sender_sp = this->sender_sp();
0 a61af66fc99e Initial load duke parents: diff changeset	371
a61af66fc99e Initial load duke parents: diff changeset	372 // This is the sp before any possible extension (adapter/locals).
a61af66fc99e Initial load duke parents: diff changeset	373 intptr_t* unextended_sp = interpreter_frame_sender_sp();
a61af66fc99e Initial load duke parents: diff changeset	374
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	375 // Stored FP.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	376 intptr_t* saved_fp = link();
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	377
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	378 address sender_pc = this->sender_pc();
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	379 CodeBlob* sender_cb = CodeCache::find_blob_unsafe(sender_pc);
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	380 assert(sender_cb, "sanity");
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	381 nmethod* sender_nm = sender_cb->as_nmethod_or_null();
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	382
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	383 if (sender_nm != NULL) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	384 // If the sender PC is a deoptimization point, get the original
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	385 // PC. For MethodHandle call site the unextended_sp is stored in
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	386 // saved_fp.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	387 if (sender_nm->is_deopt_mh_entry(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	388 DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, saved_fp));
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	389 unextended_sp = saved_fp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	390 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	391 else if (sender_nm->is_deopt_entry(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	392 DEBUG_ONLY(verify_deopt_original_pc(sender_nm, unextended_sp));
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	393 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	394 else if (sender_nm->is_method_handle_return(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	395 unextended_sp = saved_fp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	396 }
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	397 }
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	398
0 a61af66fc99e Initial load duke parents: diff changeset	399 // The interpreter and compiler(s) always save EBP/RBP in a known
a61af66fc99e Initial load duke parents: diff changeset	400 // location on entry. We must record where that location is
a61af66fc99e Initial load duke parents: diff changeset	401 // so this if EBP/RBP was live on callout from c2 we can find
a61af66fc99e Initial load duke parents: diff changeset	402 // the saved copy no matter what it called.
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 // Since the interpreter always saves EBP/RBP if we record where it is then
a61af66fc99e Initial load duke parents: diff changeset	405 // we don't have to always save EBP/RBP on entry and exit to c2 compiled
a61af66fc99e Initial load duke parents: diff changeset	406 // code, on entry will be enough.
a61af66fc99e Initial load duke parents: diff changeset	407 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	408 if (map->update_map()) {
a61af66fc99e Initial load duke parents: diff changeset	409 map->set_location(rbp->as_VMReg(), (address) addr_at(link_offset));
a61af66fc99e Initial load duke parents: diff changeset	410 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	411 // this is weird "H" ought to be at a higher address however the
a61af66fc99e Initial load duke parents: diff changeset	412 // oopMaps seems to have the "H" regs at the same address and the
a61af66fc99e Initial load duke parents: diff changeset	413 // vanilla register.
a61af66fc99e Initial load duke parents: diff changeset	414 // XXXX make this go away
a61af66fc99e Initial load duke parents: diff changeset	415 if (true) {
a61af66fc99e Initial load duke parents: diff changeset	416 map->set_location(rbp->as_VMReg()->next(), (address)addr_at(link_offset));
a61af66fc99e Initial load duke parents: diff changeset	417 }
a61af66fc99e Initial load duke parents: diff changeset	418 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	419 }
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	420 #endif // COMPILER2
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	421
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	422 return frame(sender_sp, unextended_sp, saved_fp, sender_pc);
0 a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	426 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	427 // frame::sender_for_compiled_frame
0 a61af66fc99e Initial load duke parents: diff changeset	428 frame frame::sender_for_compiled_frame(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	429 assert(map != NULL, "map must be set");
a61af66fc99e Initial load duke parents: diff changeset	430
a61af66fc99e Initial load duke parents: diff changeset	431 // frame owned by optimizing compiler
a61af66fc99e Initial load duke parents: diff changeset	432 assert(_cb->frame_size() >= 0, "must have non-zero frame size");
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	433 intptr_t* sender_sp = unextended_sp() + _cb->frame_size();
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	434 intptr_t* unextended_sp = sender_sp;
0 a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 // On Intel the return_address is always the word on the stack
a61af66fc99e Initial load duke parents: diff changeset	437 address sender_pc = (address) *(sender_sp-1);
a61af66fc99e Initial load duke parents: diff changeset	438
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	439 // This is the saved value of EBP which may or may not really be an FP.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	440 // It is only an FP if the sender is an interpreter frame (or C1?).
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	441 intptr_t* saved_fp = (intptr_t) (sender_sp - frame::sender_sp_offset);
0 a61af66fc99e Initial load duke parents: diff changeset	442
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	443 // If we are returning to a compiled MethodHandle call site, the
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	444 // saved_fp will in fact be a saved value of the unextended SP. The
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	445 // simplest way to tell whether we are returning to such a call site
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	446 // is as follows:
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	447 CodeBlob* sender_cb = CodeCache::find_blob_unsafe(sender_pc);
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	448 assert(sender_cb, "sanity");
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	449 nmethod* sender_nm = sender_cb->as_nmethod_or_null();
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	450
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	451 if (sender_nm != NULL) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	452 // If the sender PC is a deoptimization point, get the original
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	453 // PC. For MethodHandle call site the unextended_sp is stored in
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	454 // saved_fp.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	455 if (sender_nm->is_deopt_mh_entry(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	456 DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, saved_fp));
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	457 unextended_sp = saved_fp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	458 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	459 else if (sender_nm->is_deopt_entry(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	460 DEBUG_ONLY(verify_deopt_original_pc(sender_nm, unextended_sp));
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	461 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	462 else if (sender_nm->is_method_handle_return(sender_pc)) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	463 unextended_sp = saved_fp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	464 }
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	465 }
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	466
0 a61af66fc99e Initial load duke parents: diff changeset	467 if (map->update_map()) {
a61af66fc99e Initial load duke parents: diff changeset	468 // Tell GC to use argument oopmaps for some runtime stubs that need it.
a61af66fc99e Initial load duke parents: diff changeset	469 // For C1, the runtime stub might not have oop maps, so set this flag
a61af66fc99e Initial load duke parents: diff changeset	470 // outside of update_register_map.
a61af66fc99e Initial load duke parents: diff changeset	471 map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
a61af66fc99e Initial load duke parents: diff changeset	472 if (_cb->oop_maps() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	473 OopMapSet::update_register_map(this, map);
a61af66fc99e Initial load duke parents: diff changeset	474 }
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	475 // Since the prolog does the save and restore of EBP there is no oopmap
0 a61af66fc99e Initial load duke parents: diff changeset	476 // for it so we must fill in its location as if there was an oopmap entry
a61af66fc99e Initial load duke parents: diff changeset	477 // since if our caller was compiled code there could be live jvm state in it.
a61af66fc99e Initial load duke parents: diff changeset	478 map->set_location(rbp->as_VMReg(), (address) (sender_sp - frame::sender_sp_offset));
a61af66fc99e Initial load duke parents: diff changeset	479 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	480 // this is weird "H" ought to be at a higher address however the
a61af66fc99e Initial load duke parents: diff changeset	481 // oopMaps seems to have the "H" regs at the same address and the
a61af66fc99e Initial load duke parents: diff changeset	482 // vanilla register.
a61af66fc99e Initial load duke parents: diff changeset	483 // XXXX make this go away
a61af66fc99e Initial load duke parents: diff changeset	484 if (true) {
a61af66fc99e Initial load duke parents: diff changeset	485 map->set_location(rbp->as_VMReg()->next(), (address) (sender_sp - frame::sender_sp_offset));
a61af66fc99e Initial load duke parents: diff changeset	486 }
a61af66fc99e Initial load duke parents: diff changeset	487 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	488 }
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490 assert(sender_sp != sp(), "must have changed");
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	491 return frame(sender_sp, unextended_sp, saved_fp, sender_pc);
0 a61af66fc99e Initial load duke parents: diff changeset	492 }
a61af66fc99e Initial load duke parents: diff changeset	493
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	494
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	495 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	496 // frame::sender
0 a61af66fc99e Initial load duke parents: diff changeset	497 frame frame::sender(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	498 // Default is we done have to follow them. The sender_for_xxx will
a61af66fc99e Initial load duke parents: diff changeset	499 // update it accordingly
a61af66fc99e Initial load duke parents: diff changeset	500 map->set_include_argument_oops(false);
a61af66fc99e Initial load duke parents: diff changeset	501
a61af66fc99e Initial load duke parents: diff changeset	502 if (is_entry_frame()) return sender_for_entry_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	503 if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	504 assert(_cb == CodeCache::find_blob(pc()),"Must be the same");
a61af66fc99e Initial load duke parents: diff changeset	505
a61af66fc99e Initial load duke parents: diff changeset	506 if (_cb != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	507 return sender_for_compiled_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	508 }
a61af66fc99e Initial load duke parents: diff changeset	509 // Must be native-compiled frame, i.e. the marshaling code for native
a61af66fc99e Initial load duke parents: diff changeset	510 // methods that exists in the core system.
a61af66fc99e Initial load duke parents: diff changeset	511 return frame(sender_sp(), link(), sender_pc());
a61af66fc99e Initial load duke parents: diff changeset	512 }
a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 bool frame::interpreter_frame_equals_unpacked_fp(intptr_t* fp) {
a61af66fc99e Initial load duke parents: diff changeset	516 assert(is_interpreted_frame(), "must be interpreter frame");
a61af66fc99e Initial load duke parents: diff changeset	517 methodOop method = interpreter_frame_method();
a61af66fc99e Initial load duke parents: diff changeset	518 // When unpacking an optimized frame the frame pointer is
a61af66fc99e Initial load duke parents: diff changeset	519 // adjusted with:
a61af66fc99e Initial load duke parents: diff changeset	520 int diff = (method->max_locals() - method->size_of_parameters()) *
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	521 Interpreter::stackElementWords;
0 a61af66fc99e Initial load duke parents: diff changeset	522 return _fp == (fp - diff);
a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 void frame::pd_gc_epilog() {
a61af66fc99e Initial load duke parents: diff changeset	526 // nothing done here now
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	529 bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
0 a61af66fc99e Initial load duke parents: diff changeset	530 // QQQ
a61af66fc99e Initial load duke parents: diff changeset	531 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	532 #else
a61af66fc99e Initial load duke parents: diff changeset	533 assert(is_interpreted_frame(), "Not an interpreted frame");
a61af66fc99e Initial load duke parents: diff changeset	534 // These are reasonable sanity checks
a61af66fc99e Initial load duke parents: diff changeset	535 if (fp() == 0 \|\| (intptr_t(fp()) & (wordSize-1)) != 0) {
a61af66fc99e Initial load duke parents: diff changeset	536 return false;
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538 if (sp() == 0 \|\| (intptr_t(sp()) & (wordSize-1)) != 0) {
a61af66fc99e Initial load duke parents: diff changeset	539 return false;
a61af66fc99e Initial load duke parents: diff changeset	540 }
a61af66fc99e Initial load duke parents: diff changeset	541 if (fp() + interpreter_frame_initial_sp_offset < sp()) {
a61af66fc99e Initial load duke parents: diff changeset	542 return false;
a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544 // These are hacks to keep us out of trouble.
a61af66fc99e Initial load duke parents: diff changeset	545 // The problem with these is that they mask other problems
a61af66fc99e Initial load duke parents: diff changeset	546 if (fp() <= sp()) { // this attempts to deal with unsigned comparison above
a61af66fc99e Initial load duke parents: diff changeset	547 return false;
a61af66fc99e Initial load duke parents: diff changeset	548 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	549
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	550 // do some validation of frame elements
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	551
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	552 // first the method
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	553
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	554 methodOop m = *interpreter_frame_method_addr();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	555
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	556 // validate the method we'd find in this potential sender
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	557 if (!Universe::heap()->is_valid_method(m)) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	558
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	559 // stack frames shouldn't be much larger than max_stack elements
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	560
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	561 if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
0 a61af66fc99e Initial load duke parents: diff changeset	562 return false;
a61af66fc99e Initial load duke parents: diff changeset	563 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	564
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	565 // validate bci/bcx
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	566
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	567 intptr_t bcx = interpreter_frame_bcx();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	568 if (m->validate_bci_from_bcx(bcx) < 0) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	569 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	570 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	571
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	572 // validate constantPoolCacheOop
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	573
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	574 constantPoolCacheOop cp = *interpreter_frame_cache_addr();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	575
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	576 if (cp == NULL \|\|
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	577 !Space::is_aligned(cp) \|\|
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	578 !Universe::heap()->is_permanent((void*)cp)) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	579
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	580 // validate locals
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	581
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	582 address locals = (address) *interpreter_frame_locals_addr();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	583
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	584 if (locals > thread->stack_base() \|\| locals < (address) fp()) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	585
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	586 // We'd have to be pretty unlucky to be mislead at this point
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	587
0 a61af66fc99e Initial load duke parents: diff changeset	588 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	589 return true;
a61af66fc99e Initial load duke parents: diff changeset	590 }
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
a61af66fc99e Initial load duke parents: diff changeset	593 #ifdef CC_INTERP
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	594 // Needed for JVMTI. The result should always be in the
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	595 // interpreterState object
0 a61af66fc99e Initial load duke parents: diff changeset	596 interpreterState istate = get_interpreterState();
a61af66fc99e Initial load duke parents: diff changeset	597 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	598 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	599 methodOop method = interpreter_frame_method();
a61af66fc99e Initial load duke parents: diff changeset	600 BasicType type = method->result_type();
a61af66fc99e Initial load duke parents: diff changeset	601
a61af66fc99e Initial load duke parents: diff changeset	602 intptr_t* tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	603 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	604 // Prior to calling into the runtime to report the method_exit the possible
a61af66fc99e Initial load duke parents: diff changeset	605 // return value is pushed to the native stack. If the result is a jfloat/jdouble
a61af66fc99e Initial load duke parents: diff changeset	606 // then ST0 is saved before EAX/EDX. See the note in generate_native_result
a61af66fc99e Initial load duke parents: diff changeset	607 tos_addr = (intptr_t*)sp();
a61af66fc99e Initial load duke parents: diff changeset	608 if (type == T_FLOAT \|\| type == T_DOUBLE) {
a61af66fc99e Initial load duke parents: diff changeset	609 // QQQ seems like this code is equivalent on the two platforms
a61af66fc99e Initial load duke parents: diff changeset	610 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	611 // This is times two because we do a push(ltos) after pushing XMM0
a61af66fc99e Initial load duke parents: diff changeset	612 // and that takes two interpreter stack slots.
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	613 tos_addr += 2 * Interpreter::stackElementWords;
0 a61af66fc99e Initial load duke parents: diff changeset	614 #else
a61af66fc99e Initial load duke parents: diff changeset	615 tos_addr += 2;
a61af66fc99e Initial load duke parents: diff changeset	616 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	617 }
a61af66fc99e Initial load duke parents: diff changeset	618 } else {
a61af66fc99e Initial load duke parents: diff changeset	619 tos_addr = (intptr_t*)interpreter_frame_tos_address();
a61af66fc99e Initial load duke parents: diff changeset	620 }
a61af66fc99e Initial load duke parents: diff changeset	621
a61af66fc99e Initial load duke parents: diff changeset	622 switch (type) {
a61af66fc99e Initial load duke parents: diff changeset	623 case T_OBJECT :
a61af66fc99e Initial load duke parents: diff changeset	624 case T_ARRAY : {
a61af66fc99e Initial load duke parents: diff changeset	625 oop obj;
a61af66fc99e Initial load duke parents: diff changeset	626 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	627 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	628 obj = istate->_oop_temp;
a61af66fc99e Initial load duke parents: diff changeset	629 #else
a61af66fc99e Initial load duke parents: diff changeset	630 obj = (oop) at(interpreter_frame_oop_temp_offset);
a61af66fc99e Initial load duke parents: diff changeset	631 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	632 } else {
a61af66fc99e Initial load duke parents: diff changeset	633 oop* obj_p = (oop*)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	634 obj = (obj_p == NULL) ? (oop)NULL : *obj_p;
a61af66fc99e Initial load duke parents: diff changeset	635 }
a61af66fc99e Initial load duke parents: diff changeset	636 assert(obj == NULL \|\| Universe::heap()->is_in(obj), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	637 *oop_result = obj;
a61af66fc99e Initial load duke parents: diff changeset	638 break;
a61af66fc99e Initial load duke parents: diff changeset	639 }
a61af66fc99e Initial load duke parents: diff changeset	640 case T_BOOLEAN : value_result->z = (jboolean)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	641 case T_BYTE : value_result->b = (jbyte)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	642 case T_CHAR : value_result->c = (jchar)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	643 case T_SHORT : value_result->s = (jshort)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	644 case T_INT : value_result->i = (jint)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	645 case T_LONG : value_result->j = (jlong)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	646 case T_FLOAT : {
a61af66fc99e Initial load duke parents: diff changeset	647 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	648 value_result->f = (jfloat)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	649 #else
a61af66fc99e Initial load duke parents: diff changeset	650 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	651 jdouble d = (jdouble)tos_addr; // Result was in ST0 so need to convert to jfloat
a61af66fc99e Initial load duke parents: diff changeset	652 value_result->f = (jfloat)d;
a61af66fc99e Initial load duke parents: diff changeset	653 } else {
a61af66fc99e Initial load duke parents: diff changeset	654 value_result->f = (jfloat)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	655 }
a61af66fc99e Initial load duke parents: diff changeset	656 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	657 break;
a61af66fc99e Initial load duke parents: diff changeset	658 }
a61af66fc99e Initial load duke parents: diff changeset	659 case T_DOUBLE : value_result->d = (jdouble)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	660 case T_VOID : /* Nothing to do */ break;
a61af66fc99e Initial load duke parents: diff changeset	661 default : ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	662 }
a61af66fc99e Initial load duke parents: diff changeset	663
a61af66fc99e Initial load duke parents: diff changeset	664 return type;
a61af66fc99e Initial load duke parents: diff changeset	665 }
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
a61af66fc99e Initial load duke parents: diff changeset	669 int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize);
a61af66fc99e Initial load duke parents: diff changeset	670 return &interpreter_frame_tos_address()[index];
a61af66fc99e Initial load duke parents: diff changeset	671 }

Mercurial > hg > truffle

annotate src/cpu/x86/vm/frame_x86.cpp @ 3101:6ccb95c97e6d