truffle: src/share/vm/prims/forte.cpp annotate

annotate src/share/vm/prims/forte.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	ce8f6bb717c9
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17467 55fb97c4c58d 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 11146 diff changeset	2 * Copyright (c) 2003, 2013, 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: 1489 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1489 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: 1489 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: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "code/debugInfoRec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "code/pcDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/space.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "prims/forte.hpp"
11146 e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	34 #include "runtime/javaCalls.hpp"
20197 ce8f6bb717c9 8042195: Introduce umbrella header orderAccess.inline.hpp. goetz parents: 17795 diff changeset	35 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #include "runtime/vframeArray.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	38
10354 dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	39 // call frame copied from old .h file and renamed
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	40 typedef struct {
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	41 jint lineno; // line number in the source file
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	42 jmethodID method_id; // method executed in this frame
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	43 } ASGCT_CallFrame;
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	44
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	45 // call trace copied from old .h file and renamed
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	46 typedef struct {
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	47 JNIEnv *env_id; // Env where trace was recorded
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	48 jint num_frames; // number of frames in this trace
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	49 ASGCT_CallFrame *frames; // frames
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	50 } ASGCT_CallTrace;
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	51
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	52 // These name match the names reported by the forte quality kit
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	53 enum {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	54 ticks_no_Java_frame = 0,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	55 ticks_no_class_load = -1,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	56 ticks_GC_active = -2,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	57 ticks_unknown_not_Java = -3,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	58 ticks_not_walkable_not_Java = -4,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	59 ticks_unknown_Java = -5,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	60 ticks_not_walkable_Java = -6,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	61 ticks_unknown_state = -7,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	62 ticks_thread_exit = -8,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	63 ticks_deopt = -9,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	64 ticks_safepoint = -10
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	65 };
0 a61af66fc99e Initial load duke parents: diff changeset	66
10354 dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	67 #if INCLUDE_JVMTI
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	68
0 a61af66fc99e Initial load duke parents: diff changeset	69 //-------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	70
a61af66fc99e Initial load duke parents: diff changeset	71 // Native interfaces for use by Forte tools.
a61af66fc99e Initial load duke parents: diff changeset	72
a61af66fc99e Initial load duke parents: diff changeset	73
14403 75ef1a499665 8019973: PPC64 (part 11): Fix IA64 preprocessor conditionals on AIX. goetz parents: 10973 diff changeset	74 #if !defined(IA64) && !defined(PPC64)
0 a61af66fc99e Initial load duke parents: diff changeset	75
a61af66fc99e Initial load duke parents: diff changeset	76 class vframeStreamForte : public vframeStreamCommon {
a61af66fc99e Initial load duke parents: diff changeset	77 public:
a61af66fc99e Initial load duke parents: diff changeset	78 // constructor that starts with sender of frame fr (top_frame)
a61af66fc99e Initial load duke parents: diff changeset	79 vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
a61af66fc99e Initial load duke parents: diff changeset	80 void forte_next();
a61af66fc99e Initial load duke parents: diff changeset	81 };
a61af66fc99e Initial load duke parents: diff changeset	82
a61af66fc99e Initial load duke parents: diff changeset	83
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	84 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm);
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	85 static bool is_decipherable_interpreted_frame(JavaThread* thread,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	86 frame* fr,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	87 Method** method_p,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	88 int* bci_p);
0 a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90
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 vframeStreamForte::vframeStreamForte(JavaThread *jt,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	94 frame fr,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	95 bool stop_at_java_call_stub) : vframeStreamCommon(jt) {
0 a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 _stop_at_java_call_stub = stop_at_java_call_stub;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	98 _frame = fr;
0 a61af66fc99e Initial load duke parents: diff changeset	99
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	100 // We must always have a valid frame to start filling
0 a61af66fc99e Initial load duke parents: diff changeset	101
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	102 bool filled_in = fill_from_frame();
0 a61af66fc99e Initial load duke parents: diff changeset	103
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	104 assert(filled_in, "invariant");
0 a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 }
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 // Solaris SPARC Compiler1 needs an additional check on the grandparent
a61af66fc99e Initial load duke parents: diff changeset	110 // of the top_frame when the parent of the top_frame is interpreted and
a61af66fc99e Initial load duke parents: diff changeset	111 // the grandparent is compiled. However, in this method we do not know
a61af66fc99e Initial load duke parents: diff changeset	112 // the relationship of the current _frame relative to the top_frame so
a61af66fc99e Initial load duke parents: diff changeset	113 // we implement a more broad sanity check. When the previous callee is
a61af66fc99e Initial load duke parents: diff changeset	114 // interpreted and the current sender is compiled, we verify that the
a61af66fc99e Initial load duke parents: diff changeset	115 // current sender is also walkable. If it is not walkable, then we mark
a61af66fc99e Initial load duke parents: diff changeset	116 // the current vframeStream as at the end.
a61af66fc99e Initial load duke parents: diff changeset	117 void vframeStreamForte::forte_next() {
a61af66fc99e Initial load duke parents: diff changeset	118 // handle frames with inlining
a61af66fc99e Initial load duke parents: diff changeset	119 if (_mode == compiled_mode &&
a61af66fc99e Initial load duke parents: diff changeset	120 vframeStreamCommon::fill_in_compiled_inlined_sender()) {
a61af66fc99e Initial load duke parents: diff changeset	121 return;
a61af66fc99e Initial load duke parents: diff changeset	122 }
a61af66fc99e Initial load duke parents: diff changeset	123
a61af66fc99e Initial load duke parents: diff changeset	124 // handle general case
a61af66fc99e Initial load duke parents: diff changeset	125
a61af66fc99e Initial load duke parents: diff changeset	126 int loop_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	127 int loop_max = MaxJavaStackTraceDepth * 2;
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130 do {
a61af66fc99e Initial load duke parents: diff changeset	131
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	132 loop_count++;
0 a61af66fc99e Initial load duke parents: diff changeset	133
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	134 // By the time we get here we should never see unsafe but better
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	135 // safe then segv'd
0 a61af66fc99e Initial load duke parents: diff changeset	136
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	137 if (loop_count > loop_max \|\| !_frame.safe_for_sender(_thread)) {
0 a61af66fc99e Initial load duke parents: diff changeset	138 _mode = at_end_mode;
a61af66fc99e Initial load duke parents: diff changeset	139 return;
a61af66fc99e Initial load duke parents: diff changeset	140 }
a61af66fc99e Initial load duke parents: diff changeset	141
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	142 _frame = _frame.sender(&_reg_map);
0 a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 } while (!fill_from_frame());
a61af66fc99e Initial load duke parents: diff changeset	145 }
a61af66fc99e Initial load duke parents: diff changeset	146
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	147 // Determine if 'fr' is a decipherable compiled frame. We are already
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	148 // assured that fr is for a java nmethod.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	149
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	150 static bool is_decipherable_compiled_frame(JavaThread* thread, frame* fr, nmethod* nm) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	151 assert(nm->is_java_method(), "invariant");
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	152
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	153 if (thread->has_last_Java_frame() && thread->last_Java_pc() == fr->pc()) {
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	154 // We're stopped at a call into the JVM so look for a PcDesc with
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	155 // the actual pc reported by the frame.
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	156 PcDesc* pc_desc = nm->pc_desc_at(fr->pc());
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	157
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	158 // Did we find a useful PcDesc?
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	159 if (pc_desc != NULL &&
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	160 pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	161 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	164
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	165 // We're at some random pc in the nmethod so search for the PcDesc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	166 // whose pc is greater than the current PC. It's done this way
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	167 // because the extra PcDescs that are recorded for improved debug
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	168 // info record the end of the region covered by the ScopeDesc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	169 // instead of the beginning.
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	170 PcDesc* pc_desc = nm->pc_desc_near(fr->pc() + 1);
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	171
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	172 // Now do we have a useful PcDesc?
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	173 if (pc_desc == NULL \|\|
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	174 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	175 // No debug information available for this pc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	176 // vframeStream would explode if we try and walk the frames.
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	177 return false;
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	178 }
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	179
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	180 // This PcDesc is useful however we must adjust the frame's pc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	181 // so that the vframeStream lookups will use this same pc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	182 fr->set_pc(pc_desc->real_pc(nm));
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	183 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	186
0 a61af66fc99e Initial load duke parents: diff changeset	187 // Determine if 'fr' is a walkable interpreted frame. Returns false
a61af66fc99e Initial load duke parents: diff changeset	188 // if it is not. method_p, and bci_p are not set when false is
a61af66fc99e Initial load duke parents: diff changeset	189 // returned. *method_p is non-NULL if frame was executing a Java
a61af66fc99e Initial load duke parents: diff changeset	190 // method. *bci_p is != -1 if a valid BCI in the Java method could
a61af66fc99e Initial load duke parents: diff changeset	191 // be found.
a61af66fc99e Initial load duke parents: diff changeset	192 // Note: this method returns true when a valid Java method is found
a61af66fc99e Initial load duke parents: diff changeset	193 // even if a valid BCI cannot be found.
a61af66fc99e Initial load duke parents: diff changeset	194
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	195 static bool is_decipherable_interpreted_frame(JavaThread* thread,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	196 frame* fr,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	197 Method** method_p,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	198 int* bci_p) {
0 a61af66fc99e Initial load duke parents: diff changeset	199 assert(fr->is_interpreted_frame(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 // top frame is an interpreted frame
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	202 // check if it is walkable (i.e. valid Method* and valid bci)
107 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 // Because we may be racing a gc thread the method and/or bci
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	205 // of a valid interpreter frame may look bad causing us to
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	206 // fail the is_interpreted_frame_valid test. If the thread
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	207 // is in any of the following states we are assured that the
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	208 // frame is in fact valid and we must have hit the race.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	209
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	210 JavaThreadState state = thread->thread_state();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	211 bool known_valid = (state == _thread_in_native \|\|
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	212 state == _thread_in_vm \|\|
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	213 state == _thread_blocked );
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 if (known_valid \|\| fr->is_interpreted_frame_valid(thread)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	216
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	217 // The frame code should completely validate the frame so that
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	218 // references to Method* and bci are completely safe to access
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	219 // If they aren't the frame code should be fixed not this
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	220 // code. However since gc isn't locked out the values could be
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	221 // stale. This is a race we can never completely win since we can't
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	222 // lock out gc so do one last check after retrieving their values
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	223 // from the frame for additional safety
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	224
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	225 Method* method = fr->interpreter_frame_method();
107 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 // We've at least found a method.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	228 // NOTE: there is something to be said for the approach that
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	229 // if we don't find a valid bci then the method is not likely
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	230 // a valid method. Then again we may have caught an interpreter
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	231 // frame in the middle of construction and the bci field is
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	232 // not yet valid.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	233
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	234 *method_p = method;
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6725 diff changeset	235 if (!method->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	236
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	237 intptr_t bcx = fr->interpreter_frame_bcx();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	238
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	239 int bci = method->validate_bci_from_bcx(bcx);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	240
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	241 // note: bci is set to -1 if not a valid bci
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	242 *bci_p = bci;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	243 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	244 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	245
0 a61af66fc99e Initial load duke parents: diff changeset	246 return false;
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
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 // Determine if 'fr' can be used to find an initial Java frame.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	251 // Return false if it can not find a fully decipherable Java frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	252 // (in other words a frame that isn't safe to use in a vframe stream).
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	253 // Obviously if it can't even find a Java frame false will also be returned.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	254 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	255 // If we find a Java frame decipherable or not then by definition we have
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	256 // identified a method and that will be returned to the caller via method_p.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	257 // If we can determine a bci that is returned also. (Hmm is it possible
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	258 // to return a method and bci and still return false? )
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 // The initial Java frame we find (if any) is return via initial_frame_p.
0 a61af66fc99e Initial load duke parents: diff changeset	261 //
107 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 static bool find_initial_Java_frame(JavaThread* thread,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	264 frame* fr,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	265 frame* initial_frame_p,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	266 Method** method_p,
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	267 int* bci_p) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	268
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	269 // It is possible that for a frame containing an nmethod
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	270 // we can capture the method but no bci. If we get no
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	271 // bci the frame isn't walkable but the method is usable.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	272 // Therefore we init the returned Method* to NULL so the
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	273 // caller can make the distinction.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	274
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	275 *method_p = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	276
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	277 // On the initial call to this method the frame we get may not be
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	278 // recognizable to us. This should only happen if we are in a JRT_LEAF
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	279 // or something called by a JRT_LEAF method.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	280
0 a61af66fc99e Initial load duke parents: diff changeset	281
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	282
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	283 frame candidate = *fr;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	284
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	285 // If the starting frame we were given has no codeBlob associated with
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	286 // it see if we can find such a frame because only frames with codeBlobs
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	287 // are possible Java frames.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	288
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	289 if (fr->cb() == NULL) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	290
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	291 // See if we can find a useful frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	292 int loop_count;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	293 int loop_max = MaxJavaStackTraceDepth * 2;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	294 RegisterMap map(thread, false);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	295
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	296 for (loop_count = 0; loop_count < loop_max; loop_count++) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	297 if (!candidate.safe_for_sender(thread)) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	298 candidate = candidate.sender(&map);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	299 if (candidate.cb() != NULL) break;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	300 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	301 if (candidate.cb() == NULL) return false;
0 a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	304 // We have a frame known to be in the codeCache
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	305 // We will hopefully be able to figure out something to do with it.
0 a61af66fc99e Initial load duke parents: diff changeset	306 int loop_count;
a61af66fc99e Initial load duke parents: diff changeset	307 int loop_max = MaxJavaStackTraceDepth * 2;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	308 RegisterMap map(thread, false);
0 a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 for (loop_count = 0; loop_count < loop_max; loop_count++) {
a61af66fc99e Initial load duke parents: diff changeset	311
11146 e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	312 if (candidate.is_entry_frame()) {
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	313 // jcw is NULL if the java call wrapper couldn't be found
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	314 JavaCallWrapper *jcw = candidate.entry_frame_call_wrapper_if_safe(thread);
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	315 // If initial frame is frame from StubGenerator and there is no
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	316 // previous anchor, there are no java frames associated with a method
11146 e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	317 if (jcw == NULL \|\| jcw->is_first_frame()) {
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	318 return false;
e619a2766bcc 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()' rbackman parents: 10973 diff changeset	319 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	320 }
0 a61af66fc99e Initial load duke parents: diff changeset	321
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	322 if (candidate.is_interpreted_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	323 if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	324 *initial_frame_p = candidate;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	325 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	326 }
0 a61af66fc99e Initial load duke parents: diff changeset	327
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	328 // Hopefully we got some data
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	329 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	330 }
a61af66fc99e Initial load duke parents: diff changeset	331
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	332 if (candidate.cb()->is_nmethod()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	333
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	334 nmethod* nm = (nmethod*) candidate.cb();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	335 *method_p = nm->method();
0 a61af66fc99e Initial load duke parents: diff changeset	336
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	337 // If the frame isn't fully decipherable then the default
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	338 // value for the bci is a signal that we don't have a bci.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	339 // If we have a decipherable frame this bci value will
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	340 // not be used.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	341
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	342 *bci_p = -1;
0 a61af66fc99e Initial load duke parents: diff changeset	343
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	344 *initial_frame_p = candidate;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	345
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	346 // Native wrapper code is trivial to decode by vframeStream
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	347
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	348 if (nm->is_native_method()) return true;
0 a61af66fc99e Initial load duke parents: diff changeset	349
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	350 // If it isn't decipherable then we have found a pc that doesn't
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	351 // have a PCDesc that can get us a bci however we did find
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	352 // a method
0 a61af66fc99e Initial load duke parents: diff changeset	353
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	354 if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {
0 a61af66fc99e Initial load duke parents: diff changeset	355 return false;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	356 }
0 a61af66fc99e Initial load duke parents: diff changeset	357
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	358 // is_decipherable_compiled_frame may modify candidate's pc
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	359 *initial_frame_p = candidate;
0 a61af66fc99e Initial load duke parents: diff changeset	360
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	361 assert(nm->pc_desc_at(candidate.pc()) != NULL, "if it's decipherable then pc must be valid");
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	362
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	363 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	364 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	365
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	366 // Must be some stub frame that we don't care about
0 a61af66fc99e Initial load duke parents: diff changeset	367
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	368 if (!candidate.safe_for_sender(thread)) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	369 candidate = candidate.sender(&map);
0 a61af66fc99e Initial load duke parents: diff changeset	370
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	371 // If it isn't in the code cache something is wrong
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	372 // since once we find a frame in the code cache they
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	373 // all should be there.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	374
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	375 if (candidate.cb() == NULL) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	376
0 a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	379 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	380
0 a61af66fc99e Initial load duke parents: diff changeset	381 }
a61af66fc99e Initial load duke parents: diff changeset	382
a61af66fc99e Initial load duke parents: diff changeset	383 static void forte_fill_call_trace_given_top(JavaThread* thd,
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	384 ASGCT_CallTrace* trace,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	385 int depth,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	386 frame top_frame) {
0 a61af66fc99e Initial load duke parents: diff changeset	387 NoHandleMark nhm;
a61af66fc99e Initial load duke parents: diff changeset	388
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	389 frame initial_Java_frame;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	390 Method* method;
0 a61af66fc99e Initial load duke parents: diff changeset	391 int bci;
a61af66fc99e Initial load duke parents: diff changeset	392 int count;
a61af66fc99e Initial load duke parents: diff changeset	393
a61af66fc99e Initial load duke parents: diff changeset	394 count = 0;
a61af66fc99e Initial load duke parents: diff changeset	395 assert(trace->frames != NULL, "trace->frames must be non-NULL");
a61af66fc99e Initial load duke parents: diff changeset	396
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	397 bool fully_decipherable = find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	398
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	399 // The frame might not be walkable but still recovered a method
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6725 diff changeset	400 // (e.g. an nmethod with no scope info for the pc)
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	401
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	402 if (method == NULL) return;
0 a61af66fc99e Initial load duke parents: diff changeset	403
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6725 diff changeset	404 if (!method->is_valid_method()) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	405 trace->num_frames = ticks_GC_active; // -2
0 a61af66fc99e Initial load duke parents: diff changeset	406 return;
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	409 // We got a Java frame however it isn't fully decipherable
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	410 // so it won't necessarily be safe to use it for the
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	411 // initial frame in the vframe stream.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	412
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	413 if (!fully_decipherable) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	414 // Take whatever method the top-frame decoder managed to scrape up.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	415 // We look further at the top frame only if non-safepoint
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	416 // debugging information is available.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	417 count++;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	418 trace->num_frames = count;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	419 trace->frames[0].method_id = method->find_jmethod_id_or_null();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	420 if (!method->is_native()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	421 trace->frames[0].lineno = bci;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	422 } else {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	423 trace->frames[0].lineno = -3;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	424 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	425
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	426 if (!initial_Java_frame.safe_for_sender(thd)) return;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	427
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	428 RegisterMap map(thd, false);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	429 initial_Java_frame = initial_Java_frame.sender(&map);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	430 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	431
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	432 vframeStreamForte st(thd, initial_Java_frame, false);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	433
0 a61af66fc99e Initial load duke parents: diff changeset	434 for (; !st.at_end() && count < depth; st.forte_next(), count++) {
a61af66fc99e Initial load duke parents: diff changeset	435 bci = st.bci();
a61af66fc99e Initial load duke parents: diff changeset	436 method = st.method();
a61af66fc99e Initial load duke parents: diff changeset	437
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6725 diff changeset	438 if (!method->is_valid_method()) {
0 a61af66fc99e Initial load duke parents: diff changeset	439 // we throw away everything we've gathered in this sample since
a61af66fc99e Initial load duke parents: diff changeset	440 // none of it is safe
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	441 trace->num_frames = ticks_GC_active; // -2
0 a61af66fc99e Initial load duke parents: diff changeset	442 return;
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 trace->frames[count].method_id = method->find_jmethod_id_or_null();
a61af66fc99e Initial load duke parents: diff changeset	446 if (!method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	447 trace->frames[count].lineno = bci;
a61af66fc99e Initial load duke parents: diff changeset	448 } else {
a61af66fc99e Initial load duke parents: diff changeset	449 trace->frames[count].lineno = -3;
a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 trace->num_frames = count;
a61af66fc99e Initial load duke parents: diff changeset	453 return;
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
a61af66fc99e Initial load duke parents: diff changeset	458 // on Linux X86, Solaris SPARC and Solaris X86.
a61af66fc99e Initial load duke parents: diff changeset	459 //
a61af66fc99e Initial load duke parents: diff changeset	460 // Async-safe version of GetCallTrace being called from a signal handler
a61af66fc99e Initial load duke parents: diff changeset	461 // when a LWP gets interrupted by SIGPROF but the stack traces are filled
a61af66fc99e Initial load duke parents: diff changeset	462 // with different content (see below).
a61af66fc99e Initial load duke parents: diff changeset	463 //
a61af66fc99e Initial load duke parents: diff changeset	464 // This function must only be called when JVM/TI
a61af66fc99e Initial load duke parents: diff changeset	465 // CLASS_LOAD events have been enabled since agent startup. The enabled
a61af66fc99e Initial load duke parents: diff changeset	466 // event will cause the jmethodIDs to be allocated at class load time.
a61af66fc99e Initial load duke parents: diff changeset	467 // The jmethodIDs cannot be allocated in a signal handler because locks
a61af66fc99e Initial load duke parents: diff changeset	468 // cannot be grabbed in a signal handler safely.
a61af66fc99e Initial load duke parents: diff changeset	469 //
a61af66fc99e Initial load duke parents: diff changeset	470 // void (AsyncGetCallTrace)(ASGCT_CallTrace trace, jint depth, void* ucontext)
a61af66fc99e Initial load duke parents: diff changeset	471 //
a61af66fc99e Initial load duke parents: diff changeset	472 // Called by the profiler to obtain the current method call stack trace for
a61af66fc99e Initial load duke parents: diff changeset	473 // a given thread. The thread is identified by the env_id field in the
a61af66fc99e Initial load duke parents: diff changeset	474 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
a61af66fc99e Initial load duke parents: diff changeset	475 // structure with enough memory for the requested stack depth. The VM fills in
a61af66fc99e Initial load duke parents: diff changeset	476 // the frames buffer and the num_frames field.
a61af66fc99e Initial load duke parents: diff changeset	477 //
a61af66fc99e Initial load duke parents: diff changeset	478 // Arguments:
a61af66fc99e Initial load duke parents: diff changeset	479 //
a61af66fc99e Initial load duke parents: diff changeset	480 // trace - trace data structure to be filled by the VM.
a61af66fc99e Initial load duke parents: diff changeset	481 // depth - depth of the call stack trace.
a61af66fc99e Initial load duke parents: diff changeset	482 // ucontext - ucontext_t of the LWP
a61af66fc99e Initial load duke parents: diff changeset	483 //
a61af66fc99e Initial load duke parents: diff changeset	484 // ASGCT_CallTrace:
a61af66fc99e Initial load duke parents: diff changeset	485 // typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	486 // JNIEnv *env_id;
a61af66fc99e Initial load duke parents: diff changeset	487 // jint num_frames;
a61af66fc99e Initial load duke parents: diff changeset	488 // ASGCT_CallFrame *frames;
a61af66fc99e Initial load duke parents: diff changeset	489 // } ASGCT_CallTrace;
a61af66fc99e Initial load duke parents: diff changeset	490 //
a61af66fc99e Initial load duke parents: diff changeset	491 // Fields:
a61af66fc99e Initial load duke parents: diff changeset	492 // env_id - ID of thread which executed this trace.
a61af66fc99e Initial load duke parents: diff changeset	493 // num_frames - number of frames in the trace.
a61af66fc99e Initial load duke parents: diff changeset	494 // (< 0 indicates the frame is not walkable).
a61af66fc99e Initial load duke parents: diff changeset	495 // frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
a61af66fc99e Initial load duke parents: diff changeset	496 //
a61af66fc99e Initial load duke parents: diff changeset	497 // ASGCT_CallFrame:
a61af66fc99e Initial load duke parents: diff changeset	498 // typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	499 // jint lineno;
a61af66fc99e Initial load duke parents: diff changeset	500 // jmethodID method_id;
a61af66fc99e Initial load duke parents: diff changeset	501 // } ASGCT_CallFrame;
a61af66fc99e Initial load duke parents: diff changeset	502 //
a61af66fc99e Initial load duke parents: diff changeset	503 // Fields:
a61af66fc99e Initial load duke parents: diff changeset	504 // 1) For Java frame (interpreted and compiled),
a61af66fc99e Initial load duke parents: diff changeset	505 // lineno - bci of the method being executed or -1 if bci is not available
a61af66fc99e Initial load duke parents: diff changeset	506 // method_id - jmethodID of the method being executed
a61af66fc99e Initial load duke parents: diff changeset	507 // 2) For native method
a61af66fc99e Initial load duke parents: diff changeset	508 // lineno - (-3)
a61af66fc99e Initial load duke parents: diff changeset	509 // method_id - jmethodID of the method being executed
a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 extern "C" {
2191 d70fe6ab4436 6588413: Use -fvisibility=hidden for gcc compiles coleenp parents: 1972 diff changeset	512 JNIEXPORT
0 a61af66fc99e Initial load duke parents: diff changeset	513 void AsyncGetCallTrace(ASGCT_CallTrace trace, jint depth, void ucontext) {
a61af66fc99e Initial load duke parents: diff changeset	514 JavaThread* thread;
a61af66fc99e Initial load duke parents: diff changeset	515
a61af66fc99e Initial load duke parents: diff changeset	516 if (trace->env_id == NULL \|\|
a61af66fc99e Initial load duke parents: diff changeset	517 (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL \|\|
a61af66fc99e Initial load duke parents: diff changeset	518 thread->is_exiting()) {
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 // bad env_id, thread has exited or thread is exiting
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	521 trace->num_frames = ticks_thread_exit; // -8
0 a61af66fc99e Initial load duke parents: diff changeset	522 return;
a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 if (thread->in_deopt_handler()) {
a61af66fc99e Initial load duke parents: diff changeset	526 // thread is in the deoptimization handler so return no frames
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	527 trace->num_frames = ticks_deopt; // -9
0 a61af66fc99e Initial load duke parents: diff changeset	528 return;
a61af66fc99e Initial load duke parents: diff changeset	529 }
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 assert(JavaThread::current() == thread,
a61af66fc99e Initial load duke parents: diff changeset	532 "AsyncGetCallTrace must be called by the current interrupted thread");
a61af66fc99e Initial load duke parents: diff changeset	533
a61af66fc99e Initial load duke parents: diff changeset	534 if (!JvmtiExport::should_post_class_load()) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	535 trace->num_frames = ticks_no_class_load; // -1
0 a61af66fc99e Initial load duke parents: diff changeset	536 return;
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 if (Universe::heap()->is_gc_active()) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	540 trace->num_frames = ticks_GC_active; // -2
0 a61af66fc99e Initial load duke parents: diff changeset	541 return;
a61af66fc99e Initial load duke parents: diff changeset	542 }
a61af66fc99e Initial load duke parents: diff changeset	543
a61af66fc99e Initial load duke parents: diff changeset	544 switch (thread->thread_state()) {
a61af66fc99e Initial load duke parents: diff changeset	545 case _thread_new:
a61af66fc99e Initial load duke parents: diff changeset	546 case _thread_uninitialized:
a61af66fc99e Initial load duke parents: diff changeset	547 case _thread_new_trans:
a61af66fc99e Initial load duke parents: diff changeset	548 // We found the thread on the threads list above, but it is too
a61af66fc99e Initial load duke parents: diff changeset	549 // young to be useful so return that there are no Java frames.
a61af66fc99e Initial load duke parents: diff changeset	550 trace->num_frames = 0;
a61af66fc99e Initial load duke parents: diff changeset	551 break;
a61af66fc99e Initial load duke parents: diff changeset	552 case _thread_in_native:
a61af66fc99e Initial load duke parents: diff changeset	553 case _thread_in_native_trans:
a61af66fc99e Initial load duke parents: diff changeset	554 case _thread_blocked:
a61af66fc99e Initial load duke parents: diff changeset	555 case _thread_blocked_trans:
a61af66fc99e Initial load duke parents: diff changeset	556 case _thread_in_vm:
a61af66fc99e Initial load duke parents: diff changeset	557 case _thread_in_vm_trans:
a61af66fc99e Initial load duke parents: diff changeset	558 {
a61af66fc99e Initial load duke parents: diff changeset	559 frame fr;
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 // param isInJava == false - indicate we aren't in Java code
a61af66fc99e Initial load duke parents: diff changeset	562 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	563 trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	564 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	565 if (!thread->has_last_Java_frame()) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	566 trace->num_frames = 0; // No Java frames
0 a61af66fc99e Initial load duke parents: diff changeset	567 } else {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	568 trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	569 forte_fill_call_trace_given_top(thread, trace, depth, fr);
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 // This assert would seem to be valid but it is not.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	572 // It would be valid if we weren't possibly racing a gc
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	573 // thread. A gc thread can make a valid interpreted frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	574 // look invalid. It's a small window but it does happen.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	575 // The assert is left here commented out as a reminder.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	576 // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	577
0 a61af66fc99e Initial load duke parents: diff changeset	578 }
a61af66fc99e Initial load duke parents: diff changeset	579 }
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581 break;
a61af66fc99e Initial load duke parents: diff changeset	582 case _thread_in_Java:
a61af66fc99e Initial load duke parents: diff changeset	583 case _thread_in_Java_trans:
a61af66fc99e Initial load duke parents: diff changeset	584 {
a61af66fc99e Initial load duke parents: diff changeset	585 frame fr;
a61af66fc99e Initial load duke parents: diff changeset	586
a61af66fc99e Initial load duke parents: diff changeset	587 // param isInJava == true - indicate we are in Java code
a61af66fc99e Initial load duke parents: diff changeset	588 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	589 trace->num_frames = ticks_unknown_Java; // -5 unknown frame
0 a61af66fc99e Initial load duke parents: diff changeset	590 } else {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	591 trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default
0 a61af66fc99e Initial load duke parents: diff changeset	592 forte_fill_call_trace_given_top(thread, trace, depth, fr);
a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595 break;
a61af66fc99e Initial load duke parents: diff changeset	596 default:
a61af66fc99e Initial load duke parents: diff changeset	597 // Unknown thread state
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	598 trace->num_frames = ticks_unknown_state; // -7
0 a61af66fc99e Initial load duke parents: diff changeset	599 break;
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601 }
a61af66fc99e Initial load duke parents: diff changeset	602
a61af66fc99e Initial load duke parents: diff changeset	603
a61af66fc99e Initial load duke parents: diff changeset	604 #ifndef _WINDOWS
a61af66fc99e Initial load duke parents: diff changeset	605 // Support for the Forte(TM) Peformance Tools collector.
a61af66fc99e Initial load duke parents: diff changeset	606 //
a61af66fc99e Initial load duke parents: diff changeset	607 // The method prototype is derived from libcollector.h. For more
a61af66fc99e Initial load duke parents: diff changeset	608 // information, please see the libcollect man page.
a61af66fc99e Initial load duke parents: diff changeset	609
a61af66fc99e Initial load duke parents: diff changeset	610 // Method to let libcollector know about a dynamically loaded function.
a61af66fc99e Initial load duke parents: diff changeset	611 // Because it is weakly bound, the calls become NOP's when the library
a61af66fc99e Initial load duke parents: diff changeset	612 // isn't present.
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	613 #ifdef __APPLE__
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	614 // XXXDARWIN: Link errors occur even when __attribute__((weak_import))
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	615 // is added
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	616 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) (0)
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	617 #else
0 a61af66fc99e Initial load duke parents: diff changeset	618 void collector_func_load(char* name,
a61af66fc99e Initial load duke parents: diff changeset	619 void* null_argument_1,
a61af66fc99e Initial load duke parents: diff changeset	620 void* null_argument_2,
a61af66fc99e Initial load duke parents: diff changeset	621 void *vaddr,
a61af66fc99e Initial load duke parents: diff changeset	622 int size,
a61af66fc99e Initial load duke parents: diff changeset	623 int zero_argument,
a61af66fc99e Initial load duke parents: diff changeset	624 void* null_argument_3);
a61af66fc99e Initial load duke parents: diff changeset	625 #pragma weak collector_func_load
a61af66fc99e Initial load duke parents: diff changeset	626 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
10973 ef57c43512d6 8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux ccheung parents: 10354 diff changeset	627 ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),(void)0 : (void)0 )
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	628 #endif // __APPLE__
0 a61af66fc99e Initial load duke parents: diff changeset	629 #endif // !_WINDOWS
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631 } // end extern "C"
14403 75ef1a499665 8019973: PPC64 (part 11): Fix IA64 preprocessor conditionals on AIX. goetz parents: 10973 diff changeset	632 #endif // !IA64 && !PPC64
0 a61af66fc99e Initial load duke parents: diff changeset	633
a61af66fc99e Initial load duke parents: diff changeset	634 void Forte::register_stub(const char* name, address start, address end) {
14403 75ef1a499665 8019973: PPC64 (part 11): Fix IA64 preprocessor conditionals on AIX. goetz parents: 10973 diff changeset	635 #if !defined(_WINDOWS) && !defined(IA64) && !defined(PPC64)
0 a61af66fc99e Initial load duke parents: diff changeset	636 assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,
1489 cff162798819 6888953: some calls to function-like macros are missing semicolons jcoomes parents: 1349 diff changeset	637 "Code size exceeds maximum range");
0 a61af66fc99e Initial load duke parents: diff changeset	638
a61af66fc99e Initial load duke parents: diff changeset	639 collector_func_load((char*)name, NULL, NULL, start,
a61af66fc99e Initial load duke parents: diff changeset	640 pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
14403 75ef1a499665 8019973: PPC64 (part 11): Fix IA64 preprocessor conditionals on AIX. goetz parents: 10973 diff changeset	641 #endif // !_WINDOWS && !IA64 && !PPC64
0 a61af66fc99e Initial load duke parents: diff changeset	642 }
10354 dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	643
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	644 #else // INCLUDE_JVMTI
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	645 extern "C" {
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	646 JNIEXPORT
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	647 void AsyncGetCallTrace(ASGCT_CallTrace trace, jint depth, void ucontext) {
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	648 trace->num_frames = ticks_no_class_load; // -1
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	649 }
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	650 }
dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release jprovino parents: 7176 diff changeset	651 #endif // INCLUDE_JVMTI

Mercurial > hg > truffle

annotate src/share/vm/prims/forte.cpp @ 20543:e7d0505c8a30