truffle: src/cpu/x86/vm/frame

annotate src/cpu/x86/vm/frame_x86.cpp @ 20304:a22acf6d7598

8048112: G1 Full GC needs to support the case when the very first region is not available Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett. Reviewed-by: brutisso

author	tschatzl
date	Mon, 21 Jul 2014 10:00:31 +0200
parents	78bbf4d43a14
children	52b4284cb496

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13432 diff changeset	2 * Copyright (c) 1997, 2014, 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"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	29 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	30 #include "oops/oop.inline.hpp"
4868 5f17b16b3219 7141059: 7116795 broke pure c2 builds iveresov parents: 4824 diff changeset	31 #include "prims/methodHandles.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	32 #include "runtime/frame.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	33 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	34 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	35 #include "runtime/monitorChunk.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	36 #include "runtime/os.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	37 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	38 #include "runtime/stubCodeGenerator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	39 #include "runtime/stubRoutines.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	40 #include "vmreg_x86.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	41 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	42 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	43 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1748 diff changeset	44 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	47 void RegisterMap::check_location_valid() {
a61af66fc99e Initial load duke parents: diff changeset	48 }
a61af66fc99e Initial load duke parents: diff changeset	49 #endif
a61af66fc99e Initial load duke parents: diff changeset	50
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13432 diff changeset	51 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
0 a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 // Profiling/safepoint support
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 bool frame::safe_for_sender(JavaThread *thread) {
a61af66fc99e Initial load duke parents: diff changeset	56 address sp = (address)_sp;
a61af66fc99e Initial load duke parents: diff changeset	57 address fp = (address)_fp;
a61af66fc99e Initial load duke parents: diff changeset	58 address unextended_sp = (address)_unextended_sp;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	59
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	60 // consider stack guards when trying to determine "safe" stack pointers
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	61 static size_t stack_guard_size = os::uses_stack_guard_pages() ? (StackYellowPages + StackRedPages) * os::vm_page_size() : 0;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	62 size_t usable_stack_size = thread->stack_size() - stack_guard_size;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	63
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	64 // sp must be within the usable part of the stack (not in guards)
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	65 bool sp_safe = (sp < thread->stack_base()) &&
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	66 (sp >= thread->stack_base() - usable_stack_size);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	67
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	68
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	69 if (!sp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	70 return false;
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
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	73 // unextended sp must be within the stack and above or equal sp
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	74 bool unextended_sp_safe = (unextended_sp < thread->stack_base()) &&
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	75 (unextended_sp >= sp);
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 (!unextended_sp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	78 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	79 }
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 // an fp must be within the stack and above (but not equal) sp
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	82 // second evaluation on fp+ is added to handle situation where fp is -1
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	83 bool fp_safe = (fp < thread->stack_base() && (fp > sp) && (((fp + (return_addr_offset * sizeof(void*))) < thread->stack_base())));
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	84
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	85 // 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	86
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	87 // 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	88 // 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	89 // 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	90
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	91 if (_cb != NULL ) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	92
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	93 // First check if frame is complete and tester is reliable
0 a61af66fc99e Initial load duke parents: diff changeset	94 // Unfortunately we can only check frame complete for runtime stubs and nmethod
a61af66fc99e Initial load duke parents: diff changeset	95 // other generic buffer blobs are more problematic so we just assume they are
a61af66fc99e Initial load duke parents: diff changeset	96 // 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	97
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	98 if (!_cb->is_frame_complete_at(_pc)) {
0 a61af66fc99e Initial load duke parents: diff changeset	99 if (_cb->is_nmethod() \|\| _cb->is_adapter_blob() \|\| _cb->is_runtime_stub()) {
a61af66fc99e Initial load duke parents: diff changeset	100 return false;
a61af66fc99e Initial load duke parents: diff changeset	101 }
a61af66fc99e Initial load duke parents: diff changeset	102 }
8106 ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	103
ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	104 // Could just be some random pointer within the codeBlob
ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	105 if (!_cb->code_contains(_pc)) {
ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	106 return false;
ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	107 }
ec2eddfed950 8008340: [sampling] assert(upper->pc_offset() >= pc_offset) failed: sanity rbackman parents: 7176 diff changeset	108
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	109 // Entry frame checks
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	110 if (is_entry_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	111 // 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	112
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	113 if (!fp_safe) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	114
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	115 // 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	116
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	117 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	118
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	119 bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > fp);
107 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 return jcw_safe;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	122
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	123 }
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 intptr_t* sender_sp = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	126 address sender_pc = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	127
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	128 if (is_interpreted_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	129 // fp must be safe
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	130 if (!fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	131 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	132 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	133
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	134 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	135 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	136
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	137 } else {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	138 // 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	139 // 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	140
13432 c586f8a7322f 8028412: AsyncGetCallTrace() is broken on x86 in JDK 7u40 mgronlun parents: 12316 diff changeset	141 // check for a valid frame_size, otherwise we are unlikely to get a valid sender_pc
c586f8a7322f 8028412: AsyncGetCallTrace() is broken on x86 in JDK 7u40 mgronlun parents: 12316 diff changeset	142 if (_cb->frame_size() <= 0) {
c586f8a7322f 8028412: AsyncGetCallTrace() is broken on x86 in JDK 7u40 mgronlun parents: 12316 diff changeset	143 return false;
c586f8a7322f 8028412: AsyncGetCallTrace() is broken on x86 in JDK 7u40 mgronlun parents: 12316 diff changeset	144 }
c586f8a7322f 8028412: AsyncGetCallTrace() is broken on x86 in JDK 7u40 mgronlun parents: 12316 diff changeset	145
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	146 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	147 // 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	148 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	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
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	152 // 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	153 if (Interpreter::contains(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 // 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	156 // 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	157 // is really a frame pointer.
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 intptr_t saved_fp = (intptr_t)*(sender_sp - frame::sender_sp_offset);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	160 bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	161
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	162 if (!saved_fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	163 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	164 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	165
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	166 // construct the potential sender
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 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	169
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	170 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	171
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	172 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	173
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	174 // We must always be able to find a recognizable pc
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	175 CodeBlob* sender_blob = CodeCache::find_blob_unsafe(sender_pc);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	176 if (sender_pc == NULL \|\| sender_blob == NULL) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	177 return false;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	178 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	179
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	180 // Could be a zombie method
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	181 if (sender_blob->is_zombie() \|\| sender_blob->is_unloaded()) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	182 return false;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	183 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	184
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	185 // Could just be some random pointer within the codeBlob
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	186 if (!sender_blob->code_contains(sender_pc)) {
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	187 return false;
3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	188 }
107 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 // 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	191 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	192 return false;
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
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	195 // Could be the call_stub
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	196 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	197 intptr_t saved_fp = (intptr_t)*(sender_sp - frame::sender_sp_offset);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	198 bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	199
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	200 if (!saved_fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	201 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	202 }
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 // construct the potential sender
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 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	207
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	208 // 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	209 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	210
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	211 bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > (address)sender.fp());
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	212
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	213 return jcw_safe;
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
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	216 if (sender_blob->is_nmethod()) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	217 nmethod* nm = sender_blob->as_nmethod_or_null();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	218 if (nm != NULL) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	219 if (nm->is_deopt_mh_entry(sender_pc) \|\| nm->is_deopt_entry(sender_pc)) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	220 return false;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	221 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	222 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	223 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	224
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	225 // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	226 // 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	227
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	228 if (sender_blob->frame_size() <= 0) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	229 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	230 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	231 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	232
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	233 // 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	234 // 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	235 // 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	236 // or an nmethod.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	237
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	238 if (!sender_blob->is_nmethod()) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	239 return false;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8721 diff changeset	240 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	241
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	242 // 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	243 // 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	244
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	245 // 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	246
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	247 // We've validated the potential sender that would be created
0 a61af66fc99e Initial load duke parents: diff changeset	248 return true;
a61af66fc99e Initial load duke parents: diff changeset	249 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	250
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	251 // 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	252 // linkages it must be safe
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	253
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	254 if (!fp_safe) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	255 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	256 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	257
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	258 // 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	259
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	260 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	261
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	262
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	263 // 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	264
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	265 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	266
0 a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 void frame::patch_pc(Thread* thread, address pc) {
4000 0abefdb54d21 7081938: JSR292: assert(magic_number_2() == MAGIC_NUMBER_2) failed twisti parents: 3931 diff changeset	271 address* pc_addr = &(((address*) sp())[-1]);
0 a61af66fc99e Initial load duke parents: diff changeset	272 if (TracePcPatching) {
4056 448691f285a5 7106944: assert(_pc == pc_addr) failed may be too strong twisti* parents: 4000 diff changeset	273 tty->print_cr("patch_pc at address " INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "]",
4000 0abefdb54d21 7081938: JSR292: assert(magic_number_2() == MAGIC_NUMBER_2) failed twisti parents: 3931 diff changeset	274 pc_addr, *pc_addr, pc);
0 a61af66fc99e Initial load duke parents: diff changeset	275 }
4056 448691f285a5 7106944: assert(_pc == pc_addr) failed may be too strong twisti* parents: 4000 diff changeset	276 // Either the return address is the original one or we are going to
448691f285a5 7106944: assert(_pc == pc_addr) failed may be too strong twisti* parents: 4000 diff changeset	277 // patch in the same address that's already there.
448691f285a5 7106944: assert(_pc == pc_addr) failed may be too strong twisti* parents: 4000 diff changeset	278 assert(_pc == pc_addr \|\| pc == pc_addr, "must be");
4000 0abefdb54d21 7081938: JSR292: assert(magic_number_2() == MAGIC_NUMBER_2) failed twisti parents: 3931 diff changeset	279 *pc_addr = pc;
0 a61af66fc99e Initial load duke parents: diff changeset	280 _cb = CodeCache::find_blob(pc);
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	281 address original_pc = nmethod::get_deopt_original_pc(this);
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	282 if (original_pc != NULL) {
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	283 assert(original_pc == _pc, "expected original PC to be stored before patching");
0 a61af66fc99e Initial load duke parents: diff changeset	284 _deopt_state = is_deoptimized;
a61af66fc99e Initial load duke parents: diff changeset	285 // leave _pc as is
a61af66fc99e Initial load duke parents: diff changeset	286 } else {
a61af66fc99e Initial load duke parents: diff changeset	287 _deopt_state = not_deoptimized;
a61af66fc99e Initial load duke parents: diff changeset	288 _pc = pc;
a61af66fc99e Initial load duke parents: diff changeset	289 }
a61af66fc99e Initial load duke parents: diff changeset	290 }
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 bool frame::is_interpreted_frame() const {
a61af66fc99e Initial load duke parents: diff changeset	293 return Interpreter::contains(pc());
a61af66fc99e Initial load duke parents: diff changeset	294 }
a61af66fc99e Initial load duke parents: diff changeset	295
793 eacd97c88873 6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization cfang parents: 304 diff changeset	296 int frame::frame_size(RegisterMap* map) const {
eacd97c88873 6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization cfang parents: 304 diff changeset	297 frame sender = this->sender(map);
0 a61af66fc99e Initial load duke parents: diff changeset	298 return sender.sp() - sp();
a61af66fc99e Initial load duke parents: diff changeset	299 }
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 intptr_t* frame::entry_frame_argument_at(int offset) const {
a61af66fc99e Initial load duke parents: diff changeset	302 // convert offset to index to deal with tsi
a61af66fc99e Initial load duke parents: diff changeset	303 int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize);
a61af66fc99e Initial load duke parents: diff changeset	304 // Entry frame's arguments are always in relation to unextended_sp()
a61af66fc99e Initial load duke parents: diff changeset	305 return &unextended_sp()[index];
a61af66fc99e Initial load duke parents: diff changeset	306 }
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 // sender_sp
a61af66fc99e Initial load duke parents: diff changeset	309 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	310 intptr_t* frame::interpreter_frame_sender_sp() const {
a61af66fc99e Initial load duke parents: diff changeset	311 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	312 // QQQ why does this specialize method exist if frame::sender_sp() does same thing?
a61af66fc99e Initial load duke parents: diff changeset	313 // seems odd and if we always know interpreted vs. non then sender_sp() is really
a61af66fc99e Initial load duke parents: diff changeset	314 // doing too much work.
a61af66fc99e Initial load duke parents: diff changeset	315 return get_interpreterState()->sender_sp();
a61af66fc99e Initial load duke parents: diff changeset	316 }
a61af66fc99e Initial load duke parents: diff changeset	317
a61af66fc99e Initial load duke parents: diff changeset	318 // monitor elements
a61af66fc99e Initial load duke parents: diff changeset	319
a61af66fc99e Initial load duke parents: diff changeset	320 BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
a61af66fc99e Initial load duke parents: diff changeset	321 return get_interpreterState()->monitor_base();
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
a61af66fc99e Initial load duke parents: diff changeset	325 return (BasicObjectLock*) get_interpreterState()->stack_base();
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 #else // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 intptr_t* frame::interpreter_frame_sender_sp() const {
a61af66fc99e Initial load duke parents: diff changeset	331 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	332 return (intptr_t*) at(interpreter_frame_sender_sp_offset);
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 void frame::set_interpreter_frame_sender_sp(intptr_t* sender_sp) {
a61af66fc99e Initial load duke parents: diff changeset	336 assert(is_interpreted_frame(), "interpreted frame expected");
a61af66fc99e Initial load duke parents: diff changeset	337 ptr_at_put(interpreter_frame_sender_sp_offset, (intptr_t) sender_sp);
a61af66fc99e Initial load duke parents: diff changeset	338 }
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 // monitor elements
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
a61af66fc99e Initial load duke parents: diff changeset	344 return (BasicObjectLock*) addr_at(interpreter_frame_monitor_block_bottom_offset);
a61af66fc99e Initial load duke parents: diff changeset	345 }
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
a61af66fc99e Initial load duke parents: diff changeset	348 BasicObjectLock* result = (BasicObjectLock) addr_at(interpreter_frame_monitor_block_top_offset);
a61af66fc99e Initial load duke parents: diff changeset	349 // 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	350 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	351 assert((intptr_t*) result < fp(), "monitor end should be strictly below the frame pointer");
0 a61af66fc99e Initial load duke parents: diff changeset	352 return result;
a61af66fc99e Initial load duke parents: diff changeset	353 }
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
a61af66fc99e Initial load duke parents: diff changeset	356 ((BasicObjectLock*)addr_at(interpreter_frame_monitor_block_top_offset)) = value;
a61af66fc99e Initial load duke parents: diff changeset	357 }
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 // Used by template based interpreter deoptimization
a61af66fc99e Initial load duke parents: diff changeset	360 void frame::interpreter_frame_set_last_sp(intptr_t* sp) {
a61af66fc99e Initial load duke parents: diff changeset	361 ((intptr_t*)addr_at(interpreter_frame_last_sp_offset)) = sp;
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	364
a61af66fc99e Initial load duke parents: diff changeset	365 frame frame::sender_for_entry_frame(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	366 assert(map != NULL, "map must be set");
a61af66fc99e Initial load duke parents: diff changeset	367 // Java frame called from C; skip all C frames and return top C
a61af66fc99e Initial load duke parents: diff changeset	368 // frame of that chunk as the sender
a61af66fc99e Initial load duke parents: diff changeset	369 JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();
a61af66fc99e Initial load duke parents: diff changeset	370 assert(!entry_frame_is_first(), "next Java fp must be non zero");
a61af66fc99e Initial load duke parents: diff changeset	371 assert(jfa->last_Java_sp() > sp(), "must be above this frame on stack");
a61af66fc99e Initial load duke parents: diff changeset	372 map->clear();
a61af66fc99e Initial load duke parents: diff changeset	373 assert(map->include_argument_oops(), "should be set by clear");
a61af66fc99e Initial load duke parents: diff changeset	374 if (jfa->last_Java_pc() != NULL ) {
a61af66fc99e Initial load duke parents: diff changeset	375 frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc());
a61af66fc99e Initial load duke parents: diff changeset	376 return fr;
a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378 frame fr(jfa->last_Java_sp(), jfa->last_Java_fp());
a61af66fc99e Initial load duke parents: diff changeset	379 return fr;
a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381
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 // frame::verify_deopt_original_pc
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	384 //
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	385 // 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	386 // 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	387 // for MethodHandle call sites.
8721 47bc9800972c 8006498: #if <symbol> is wrong in the code. jprovino parents: 8106 diff changeset	388 #ifdef ASSERT
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	389 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	390 frame fr;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	391
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	392 // 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	393 // 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	394 // method anyway.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	395 fr._unextended_sp = unextended_sp;
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	396
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	397 address original_pc = nm->get_original_pc(&fr);
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1681 diff changeset	398 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	399 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	400 }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	401 #endif
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	402
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	403 //------------------------------------------------------------------------------
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	404 // frame::adjust_unextended_sp
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	405 void frame::adjust_unextended_sp() {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	406 // If we are returning to a compiled MethodHandle call site, the
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	407 // saved_fp will in fact be a saved value of the unextended SP. The
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	408 // simplest way to tell whether we are returning to such a call site
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	409 // is as follows:
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	410
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	411 nmethod* sender_nm = (_cb == NULL) ? NULL : _cb->as_nmethod_or_null();
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	412 if (sender_nm != NULL) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	413 // If the sender PC is a deoptimization point, get the original
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	414 // PC. For MethodHandle call site the unextended_sp is stored in
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	415 // saved_fp.
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	416 if (sender_nm->is_deopt_mh_entry(_pc)) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	417 DEBUG_ONLY(verify_deopt_mh_original_pc(sender_nm, _fp));
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	418 _unextended_sp = _fp;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	419 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	420 else if (sender_nm->is_deopt_entry(_pc)) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	421 DEBUG_ONLY(verify_deopt_original_pc(sender_nm, _unextended_sp));
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	422 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	423 else if (sender_nm->is_method_handle_return(_pc)) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	424 _unextended_sp = _fp;
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	425 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	426 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	427 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	428
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	429 //------------------------------------------------------------------------------
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	430 // frame::update_map_with_saved_link
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	431 void frame::update_map_with_saved_link(RegisterMap* map, intptr_t** link_addr) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	432 // The interpreter and compiler(s) always save EBP/RBP in a known
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	433 // location on entry. We must record where that location is
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	434 // so this if EBP/RBP was live on callout from c2 we can find
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	435 // the saved copy no matter what it called.
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	436
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	437 // Since the interpreter always saves EBP/RBP if we record where it is then
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	438 // we don't have to always save EBP/RBP on entry and exit to c2 compiled
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	439 // code, on entry will be enough.
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	440 map->set_location(rbp->as_VMReg(), (address) link_addr);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	441 #ifdef AMD64
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	442 // this is weird "H" ought to be at a higher address however the
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	443 // oopMaps seems to have the "H" regs at the same address and the
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	444 // vanilla register.
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	445 // XXXX make this go away
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	446 if (true) {
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	447 map->set_location(rbp->as_VMReg()->next(), (address) link_addr);
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	448 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	449 #endif // AMD64
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	450 }
167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	451
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	452
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	453 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	454 // frame::sender_for_interpreter_frame
0 a61af66fc99e Initial load duke parents: diff changeset	455 frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	456 // 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	457 // extension.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	458 intptr_t* sender_sp = this->sender_sp();
0 a61af66fc99e Initial load duke parents: diff changeset	459
a61af66fc99e Initial load duke parents: diff changeset	460 // This is the sp before any possible extension (adapter/locals).
a61af66fc99e Initial load duke parents: diff changeset	461 intptr_t* unextended_sp = interpreter_frame_sender_sp();
a61af66fc99e Initial load duke parents: diff changeset	462
a61af66fc99e Initial load duke parents: diff changeset	463 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	464 if (map->update_map()) {
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	465 update_map_with_saved_link(map, (intptr_t**) addr_at(link_offset));
0 a61af66fc99e Initial load duke parents: diff changeset	466 }
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	467 #endif // COMPILER2
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	468
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	469 return frame(sender_sp, unextended_sp, link(), sender_pc());
0 a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	473 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	474 // frame::sender_for_compiled_frame
0 a61af66fc99e Initial load duke parents: diff changeset	475 frame frame::sender_for_compiled_frame(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	476 assert(map != NULL, "map must be set");
a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 // frame owned by optimizing compiler
a61af66fc99e Initial load duke parents: diff changeset	479 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	480 intptr_t* sender_sp = unextended_sp() + _cb->frame_size();
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	481 intptr_t* unextended_sp = sender_sp;
0 a61af66fc99e Initial load duke parents: diff changeset	482
a61af66fc99e Initial load duke parents: diff changeset	483 // On Intel the return_address is always the word on the stack
a61af66fc99e Initial load duke parents: diff changeset	484 address sender_pc = (address) *(sender_sp-1);
a61af66fc99e Initial load duke parents: diff changeset	485
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	486 // 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	487 // It is only an FP if the sender is an interpreter frame (or C1?).
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	488 intptr_t saved_fp_addr = (intptr_t) (sender_sp - frame::sender_sp_offset);
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 844 diff changeset	489
0 a61af66fc99e Initial load duke parents: diff changeset	490 if (map->update_map()) {
a61af66fc99e Initial load duke parents: diff changeset	491 // Tell GC to use argument oopmaps for some runtime stubs that need it.
a61af66fc99e Initial load duke parents: diff changeset	492 // For C1, the runtime stub might not have oop maps, so set this flag
a61af66fc99e Initial load duke parents: diff changeset	493 // outside of update_register_map.
a61af66fc99e Initial load duke parents: diff changeset	494 map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
a61af66fc99e Initial load duke parents: diff changeset	495 if (_cb->oop_maps() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	496 OopMapSet::update_register_map(this, map);
a61af66fc99e Initial load duke parents: diff changeset	497 }
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	498
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	499 // Since the prolog does the save and restore of EBP there is no oopmap
0 a61af66fc99e Initial load duke parents: diff changeset	500 // for it so we must fill in its location as if there was an oopmap entry
a61af66fc99e Initial load duke parents: diff changeset	501 // since if our caller was compiled code there could be live jvm state in it.
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	502 update_map_with_saved_link(map, saved_fp_addr);
0 a61af66fc99e Initial load duke parents: diff changeset	503 }
a61af66fc99e Initial load duke parents: diff changeset	504
a61af66fc99e Initial load duke parents: diff changeset	505 assert(sender_sp != sp(), "must have changed");
3363 167b70ff3abc 6939861: JVM should handle more conversion operations never parents: 3336 diff changeset	506 return frame(sender_sp, unextended_sp, *saved_fp_addr, sender_pc);
0 a61af66fc99e Initial load duke parents: diff changeset	507 }
a61af66fc99e Initial load duke parents: diff changeset	508
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	509
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	510 //------------------------------------------------------------------------------
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	511 // frame::sender
0 a61af66fc99e Initial load duke parents: diff changeset	512 frame frame::sender(RegisterMap* map) const {
a61af66fc99e Initial load duke parents: diff changeset	513 // Default is we done have to follow them. The sender_for_xxx will
a61af66fc99e Initial load duke parents: diff changeset	514 // update it accordingly
a61af66fc99e Initial load duke parents: diff changeset	515 map->set_include_argument_oops(false);
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517 if (is_entry_frame()) return sender_for_entry_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	518 if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	519 assert(_cb == CodeCache::find_blob(pc()),"Must be the same");
a61af66fc99e Initial load duke parents: diff changeset	520
a61af66fc99e Initial load duke parents: diff changeset	521 if (_cb != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	522 return sender_for_compiled_frame(map);
a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524 // Must be native-compiled frame, i.e. the marshaling code for native
a61af66fc99e Initial load duke parents: diff changeset	525 // methods that exists in the core system.
a61af66fc99e Initial load duke parents: diff changeset	526 return frame(sender_sp(), link(), sender_pc());
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529
a61af66fc99e Initial load duke parents: diff changeset	530 bool frame::interpreter_frame_equals_unpacked_fp(intptr_t* fp) {
a61af66fc99e Initial load duke parents: diff changeset	531 assert(is_interpreted_frame(), "must be interpreter frame");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	532 Method* method = interpreter_frame_method();
0 a61af66fc99e Initial load duke parents: diff changeset	533 // When unpacking an optimized frame the frame pointer is
a61af66fc99e Initial load duke parents: diff changeset	534 // adjusted with:
a61af66fc99e Initial load duke parents: diff changeset	535 int diff = (method->max_locals() - method->size_of_parameters()) *
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	536 Interpreter::stackElementWords;
0 a61af66fc99e Initial load duke parents: diff changeset	537 return _fp == (fp - diff);
a61af66fc99e Initial load duke parents: diff changeset	538 }
a61af66fc99e Initial load duke parents: diff changeset	539
a61af66fc99e Initial load duke parents: diff changeset	540 void frame::pd_gc_epilog() {
a61af66fc99e Initial load duke parents: diff changeset	541 // nothing done here now
a61af66fc99e Initial load duke parents: diff changeset	542 }
a61af66fc99e Initial load duke parents: diff changeset	543
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	544 bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
0 a61af66fc99e Initial load duke parents: diff changeset	545 // QQQ
a61af66fc99e Initial load duke parents: diff changeset	546 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	547 #else
a61af66fc99e Initial load duke parents: diff changeset	548 assert(is_interpreted_frame(), "Not an interpreted frame");
a61af66fc99e Initial load duke parents: diff changeset	549 // These are reasonable sanity checks
a61af66fc99e Initial load duke parents: diff changeset	550 if (fp() == 0 \|\| (intptr_t(fp()) & (wordSize-1)) != 0) {
a61af66fc99e Initial load duke parents: diff changeset	551 return false;
a61af66fc99e Initial load duke parents: diff changeset	552 }
a61af66fc99e Initial load duke parents: diff changeset	553 if (sp() == 0 \|\| (intptr_t(sp()) & (wordSize-1)) != 0) {
a61af66fc99e Initial load duke parents: diff changeset	554 return false;
a61af66fc99e Initial load duke parents: diff changeset	555 }
a61af66fc99e Initial load duke parents: diff changeset	556 if (fp() + interpreter_frame_initial_sp_offset < sp()) {
a61af66fc99e Initial load duke parents: diff changeset	557 return false;
a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559 // These are hacks to keep us out of trouble.
a61af66fc99e Initial load duke parents: diff changeset	560 // The problem with these is that they mask other problems
a61af66fc99e Initial load duke parents: diff changeset	561 if (fp() <= sp()) { // this attempts to deal with unsigned comparison above
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 // 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	566
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	567 // first the method
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	568
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	569 Method* m = *interpreter_frame_method_addr();
107 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 // validate the method we'd find in this potential sender
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6725 diff changeset	572 if (!m->is_valid_method()) return false;
107 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 // 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	575
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	576 if (fp() - sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
0 a61af66fc99e Initial load duke parents: diff changeset	577 return false;
a61af66fc99e Initial load duke parents: diff changeset	578 }
107 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 bci/bcx
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 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	583 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	584 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
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	587 // validate ConstantPoolCache*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	588 ConstantPoolCache* cp = *interpreter_frame_cache_addr();
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10405 diff changeset	589 if (cp == NULL \|\| !cp->is_metaspace_object()) return false;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	590
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	591 // validate locals
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	592
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	593 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	594
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	595 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	596
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	597 // 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	598
0 a61af66fc99e Initial load duke parents: diff changeset	599 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	600 return true;
a61af66fc99e Initial load duke parents: diff changeset	601 }
a61af66fc99e Initial load duke parents: diff changeset	602
a61af66fc99e Initial load duke parents: diff changeset	603 BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
a61af66fc99e Initial load duke parents: diff changeset	604 #ifdef CC_INTERP
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	605 // Needed for JVMTI. The result should always be in the
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	606 // interpreterState object
0 a61af66fc99e Initial load duke parents: diff changeset	607 interpreterState istate = get_interpreterState();
a61af66fc99e Initial load duke parents: diff changeset	608 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	609 assert(is_interpreted_frame(), "interpreted frame expected");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	610 Method* method = interpreter_frame_method();
0 a61af66fc99e Initial load duke parents: diff changeset	611 BasicType type = method->result_type();
a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 intptr_t* tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	614 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	615 // Prior to calling into the runtime to report the method_exit the possible
a61af66fc99e Initial load duke parents: diff changeset	616 // return value is pushed to the native stack. If the result is a jfloat/jdouble
a61af66fc99e Initial load duke parents: diff changeset	617 // then ST0 is saved before EAX/EDX. See the note in generate_native_result
a61af66fc99e Initial load duke parents: diff changeset	618 tos_addr = (intptr_t*)sp();
a61af66fc99e Initial load duke parents: diff changeset	619 if (type == T_FLOAT \|\| type == T_DOUBLE) {
a61af66fc99e Initial load duke parents: diff changeset	620 // QQQ seems like this code is equivalent on the two platforms
a61af66fc99e Initial load duke parents: diff changeset	621 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	622 // This is times two because we do a push(ltos) after pushing XMM0
a61af66fc99e Initial load duke parents: diff changeset	623 // and that takes two interpreter stack slots.
1506 2338d41fbd81 6943304: remove tagged stack interpreter twisti parents: 1204 diff changeset	624 tos_addr += 2 * Interpreter::stackElementWords;
0 a61af66fc99e Initial load duke parents: diff changeset	625 #else
a61af66fc99e Initial load duke parents: diff changeset	626 tos_addr += 2;
a61af66fc99e Initial load duke parents: diff changeset	627 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	628 }
a61af66fc99e Initial load duke parents: diff changeset	629 } else {
a61af66fc99e Initial load duke parents: diff changeset	630 tos_addr = (intptr_t*)interpreter_frame_tos_address();
a61af66fc99e Initial load duke parents: diff changeset	631 }
a61af66fc99e Initial load duke parents: diff changeset	632
a61af66fc99e Initial load duke parents: diff changeset	633 switch (type) {
a61af66fc99e Initial load duke parents: diff changeset	634 case T_OBJECT :
a61af66fc99e Initial load duke parents: diff changeset	635 case T_ARRAY : {
a61af66fc99e Initial load duke parents: diff changeset	636 oop obj;
a61af66fc99e Initial load duke parents: diff changeset	637 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	638 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	639 obj = istate->_oop_temp;
a61af66fc99e Initial load duke parents: diff changeset	640 #else
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 11034 diff changeset	641 obj = cast_to_oop(at(interpreter_frame_oop_temp_offset));
0 a61af66fc99e Initial load duke parents: diff changeset	642 #endif // CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	643 } else {
a61af66fc99e Initial load duke parents: diff changeset	644 oop* obj_p = (oop*)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	645 obj = (obj_p == NULL) ? (oop)NULL : *obj_p;
a61af66fc99e Initial load duke parents: diff changeset	646 }
a61af66fc99e Initial load duke parents: diff changeset	647 assert(obj == NULL \|\| Universe::heap()->is_in(obj), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	648 *oop_result = obj;
a61af66fc99e Initial load duke parents: diff changeset	649 break;
a61af66fc99e Initial load duke parents: diff changeset	650 }
a61af66fc99e Initial load duke parents: diff changeset	651 case T_BOOLEAN : value_result->z = (jboolean)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	652 case T_BYTE : value_result->b = (jbyte)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	653 case T_CHAR : value_result->c = (jchar)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	654 case T_SHORT : value_result->s = (jshort)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	655 case T_INT : value_result->i = (jint)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	656 case T_LONG : value_result->j = (jlong)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	657 case T_FLOAT : {
a61af66fc99e Initial load duke parents: diff changeset	658 #ifdef AMD64
a61af66fc99e Initial load duke parents: diff changeset	659 value_result->f = (jfloat)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	660 #else
a61af66fc99e Initial load duke parents: diff changeset	661 if (method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	662 jdouble d = (jdouble)tos_addr; // Result was in ST0 so need to convert to jfloat
a61af66fc99e Initial load duke parents: diff changeset	663 value_result->f = (jfloat)d;
a61af66fc99e Initial load duke parents: diff changeset	664 } else {
a61af66fc99e Initial load duke parents: diff changeset	665 value_result->f = (jfloat)tos_addr;
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667 #endif // AMD64
a61af66fc99e Initial load duke parents: diff changeset	668 break;
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670 case T_DOUBLE : value_result->d = (jdouble)tos_addr; break;
a61af66fc99e Initial load duke parents: diff changeset	671 case T_VOID : /* Nothing to do */ break;
a61af66fc99e Initial load duke parents: diff changeset	672 default : ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674
a61af66fc99e Initial load duke parents: diff changeset	675 return type;
a61af66fc99e Initial load duke parents: diff changeset	676 }
a61af66fc99e Initial load duke parents: diff changeset	677
a61af66fc99e Initial load duke parents: diff changeset	678
a61af66fc99e Initial load duke parents: diff changeset	679 intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
a61af66fc99e Initial load duke parents: diff changeset	680 int index = (Interpreter::expr_offset_in_bytes(offset)/wordSize);
a61af66fc99e Initial load duke parents: diff changeset	681 return &interpreter_frame_tos_address()[index];
a61af66fc99e Initial load duke parents: diff changeset	682 }
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	683
4824 5dbed2f542ff 7120468: SPARC/x86: use frame::describe to enhance trace_method_handle bdelsart parents: 4818 diff changeset	684 #ifndef PRODUCT
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	685
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	686 #define DESCRIBE_FP_OFFSET(name) \
3365 3cfb240033d1 7043301: assert(locals < caller->fp() \|\| locals > (caller->fp() + 16)) failed: locals in save area never parents: 3363 diff changeset	687 values.describe(frame_no, fp() + frame::name##_offset, #name)
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	688
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	689 void frame::describe_pd(FrameValues& values, int frame_no) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4868 diff changeset	690 if (is_interpreted_frame()) {
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	691 DESCRIBE_FP_OFFSET(interpreter_frame_sender_sp);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	692 DESCRIBE_FP_OFFSET(interpreter_frame_last_sp);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	693 DESCRIBE_FP_OFFSET(interpreter_frame_method);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	694 DESCRIBE_FP_OFFSET(interpreter_frame_mdx);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	695 DESCRIBE_FP_OFFSET(interpreter_frame_cache);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	696 DESCRIBE_FP_OFFSET(interpreter_frame_locals);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	697 DESCRIBE_FP_OFFSET(interpreter_frame_bcx);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	698 DESCRIBE_FP_OFFSET(interpreter_frame_initial_sp);
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	699 }
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	700 }
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 1972 diff changeset	701 #endif
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3365 diff changeset	702
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3365 diff changeset	703 intptr_t *frame::initial_deoptimization_info() {
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3365 diff changeset	704 // used to reset the saved FP
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3365 diff changeset	705 return fp();
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3365 diff changeset	706 }
4806 eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	707
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	708 intptr_t* frame::real_fp() const {
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	709 if (_cb != NULL) {
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	710 // use the frame size if valid
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	711 int size = _cb->frame_size();
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4868 diff changeset	712 if (size > 0) {
4806 eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	713 return unextended_sp() + size;
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	714 }
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	715 }
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	716 // else rely on fp()
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	717 assert(! is_compiled_frame(), "unknown compiled frame size");
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	718 return fp();
eaa9557116a2 7120448: Fix FP values for compiled frames in frame::describe bdelsart parents: 4056 diff changeset	719 }

Mercurial > hg > truffle

annotate src/cpu/x86/vm/frame_x86.cpp @ 20304:a22acf6d7598