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

annotate src/share/vm/prims/forte.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	61b6c57421c2 ce8f6bb717c9
children

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14223 de6a9e811145 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
18734 61b6c57421c2 Add cast to void to fix compilation warning. Tom Rodriguez <tom.rodriguez@oracle.com> parents: 18041 diff changeset	616 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) ((void) 0)
3960 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 @ 20804:7848fc12602b