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

annotate src/share/vm/prims/forte.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	da91efe96a93
children	59c790074993

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	2 * Copyright (c) 2003, 2012, 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"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "runtime/thread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "runtime/vframeArray.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	37
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	38 // 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	39 enum {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	40 ticks_no_Java_frame = 0,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	41 ticks_no_class_load = -1,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	42 ticks_GC_active = -2,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	43 ticks_unknown_not_Java = -3,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	44 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	45 ticks_unknown_Java = -5,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	46 ticks_not_walkable_Java = -6,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	47 ticks_unknown_state = -7,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	48 ticks_thread_exit = -8,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	49 ticks_deopt = -9,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	50 ticks_safepoint = -10
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	51 };
0 a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 //-------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 // Native interfaces for use by Forte tools.
a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57
a61af66fc99e Initial load duke parents: diff changeset	58 #ifndef IA64
a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 class vframeStreamForte : public vframeStreamCommon {
a61af66fc99e Initial load duke parents: diff changeset	61 public:
a61af66fc99e Initial load duke parents: diff changeset	62 // constructor that starts with sender of frame fr (top_frame)
a61af66fc99e Initial load duke parents: diff changeset	63 vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
a61af66fc99e Initial load duke parents: diff changeset	64 void forte_next();
a61af66fc99e Initial load duke parents: diff changeset	65 };
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	68 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	69 static bool is_decipherable_interpreted_frame(JavaThread* thread,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	70 frame* fr,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	71 Method** method_p,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	72 int* bci_p);
0 a61af66fc99e Initial load duke parents: diff changeset	73
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75
a61af66fc99e Initial load duke parents: diff changeset	76
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	77 vframeStreamForte::vframeStreamForte(JavaThread *jt,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	78 frame fr,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	79 bool stop_at_java_call_stub) : vframeStreamCommon(jt) {
0 a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 _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	82 _frame = fr;
0 a61af66fc99e Initial load duke parents: diff changeset	83
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	84 // We must always have a valid frame to start filling
0 a61af66fc99e Initial load duke parents: diff changeset	85
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	86 bool filled_in = fill_from_frame();
0 a61af66fc99e Initial load duke parents: diff changeset	87
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	88 assert(filled_in, "invariant");
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
a61af66fc99e Initial load duke parents: diff changeset	93 // Solaris SPARC Compiler1 needs an additional check on the grandparent
a61af66fc99e Initial load duke parents: diff changeset	94 // of the top_frame when the parent of the top_frame is interpreted and
a61af66fc99e Initial load duke parents: diff changeset	95 // the grandparent is compiled. However, in this method we do not know
a61af66fc99e Initial load duke parents: diff changeset	96 // the relationship of the current _frame relative to the top_frame so
a61af66fc99e Initial load duke parents: diff changeset	97 // we implement a more broad sanity check. When the previous callee is
a61af66fc99e Initial load duke parents: diff changeset	98 // interpreted and the current sender is compiled, we verify that the
a61af66fc99e Initial load duke parents: diff changeset	99 // current sender is also walkable. If it is not walkable, then we mark
a61af66fc99e Initial load duke parents: diff changeset	100 // the current vframeStream as at the end.
a61af66fc99e Initial load duke parents: diff changeset	101 void vframeStreamForte::forte_next() {
a61af66fc99e Initial load duke parents: diff changeset	102 // handle frames with inlining
a61af66fc99e Initial load duke parents: diff changeset	103 if (_mode == compiled_mode &&
a61af66fc99e Initial load duke parents: diff changeset	104 vframeStreamCommon::fill_in_compiled_inlined_sender()) {
a61af66fc99e Initial load duke parents: diff changeset	105 return;
a61af66fc99e Initial load duke parents: diff changeset	106 }
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108 // handle general case
a61af66fc99e Initial load duke parents: diff changeset	109
a61af66fc99e Initial load duke parents: diff changeset	110 int loop_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	111 int loop_max = MaxJavaStackTraceDepth * 2;
a61af66fc99e Initial load duke parents: diff changeset	112
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 do {
a61af66fc99e Initial load duke parents: diff changeset	115
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	116 loop_count++;
0 a61af66fc99e Initial load duke parents: diff changeset	117
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	118 // 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	119 // safe then segv'd
0 a61af66fc99e Initial load duke parents: diff changeset	120
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	121 if (loop_count > loop_max \|\| !_frame.safe_for_sender(_thread)) {
0 a61af66fc99e Initial load duke parents: diff changeset	122 _mode = at_end_mode;
a61af66fc99e Initial load duke parents: diff changeset	123 return;
a61af66fc99e Initial load duke parents: diff changeset	124 }
a61af66fc99e Initial load duke parents: diff changeset	125
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	126 _frame = _frame.sender(&_reg_map);
0 a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 } while (!fill_from_frame());
a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	131 // 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	132 // 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	133
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	134 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	135 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	136
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	137 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	138 // 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	139 // the actual pc reported by the frame.
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	140 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	141
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	142 // 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	143 if (pc_desc != NULL &&
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	144 pc_desc->scope_decode_offset() != DebugInformationRecorder::serialized_null) {
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	145 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	146 }
a61af66fc99e Initial load duke parents: diff changeset	147 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	148
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	149 // 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	150 // 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	151 // 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	152 // 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	153 // instead of the beginning.
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	154 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	155
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	156 // Now do we have a useful PcDesc?
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	157 if (pc_desc == NULL \|\|
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	158 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	159 // No debug information available for this pc
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	160 // 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	161 return false;
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	162 }
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	163
547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	164 // 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	165 // 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	166 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	167 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	170
0 a61af66fc99e Initial load duke parents: diff changeset	171 // Determine if 'fr' is a walkable interpreted frame. Returns false
a61af66fc99e Initial load duke parents: diff changeset	172 // if it is not. method_p, and bci_p are not set when false is
a61af66fc99e Initial load duke parents: diff changeset	173 // returned. *method_p is non-NULL if frame was executing a Java
a61af66fc99e Initial load duke parents: diff changeset	174 // method. *bci_p is != -1 if a valid BCI in the Java method could
a61af66fc99e Initial load duke parents: diff changeset	175 // be found.
a61af66fc99e Initial load duke parents: diff changeset	176 // Note: this method returns true when a valid Java method is found
a61af66fc99e Initial load duke parents: diff changeset	177 // even if a valid BCI cannot be found.
a61af66fc99e Initial load duke parents: diff changeset	178
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	179 static bool is_decipherable_interpreted_frame(JavaThread* thread,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	180 frame* fr,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	181 Method** method_p,
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	182 int* bci_p) {
0 a61af66fc99e Initial load duke parents: diff changeset	183 assert(fr->is_interpreted_frame(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 // top frame is an interpreted frame
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	186 // 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	187
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	188 // 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	189 // 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	190 // 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	191 // 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	192 // 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	193
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	194 JavaThreadState state = thread->thread_state();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	195 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	196 state == _thread_in_vm \|\|
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	197 state == _thread_blocked );
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	198
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	199 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	200
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	201 // 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	202 // 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	203 // 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	204 // 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	205 // 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	206 // 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	207 // 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	208
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	209 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	210
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	211 // 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	212 // 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	213 // 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	214 // 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	215 // 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	216 // not yet valid.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	217
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	218 *method_p = method;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	219
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	220 // See if gc may have invalidated method since we validated frame
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	221
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	222 if (!Universe::heap()->is_valid_method(method)) return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	223
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	224 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	225
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	226 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	227
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	228 // 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	229 *bci_p = bci;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	230 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	231 }
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	232
0 a61af66fc99e Initial load duke parents: diff changeset	233 return false;
a61af66fc99e Initial load duke parents: diff changeset	234 }
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	237 // 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	238 // 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	239 // (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	240 // 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	241 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	242 // 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	243 // 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	244 // 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	245 // 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	246 //
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	247 // The initial Java frame we find (if any) is return via initial_frame_p.
0 a61af66fc99e Initial load duke parents: diff changeset	248 //
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	249
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	250 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	251 frame* fr,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	252 frame* initial_frame_p,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	253 Method** method_p,
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	254 int* bci_p) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	255
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	256 // 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	257 // 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	258 // 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	259 // 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	260 // caller can make the distinction.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	261
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	262 *method_p = NULL;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	263
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	264 // 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	265 // 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	266 // 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	267
0 a61af66fc99e Initial load duke parents: diff changeset	268
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	269
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	270 frame candidate = *fr;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	271
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	272 // 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	273 // 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	274 // are possible Java frames.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	275
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	276 if (fr->cb() == NULL) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	277
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	278 // 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	279 int loop_count;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	280 int loop_max = MaxJavaStackTraceDepth * 2;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	281 RegisterMap map(thread, false);
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 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	284 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	285 candidate = candidate.sender(&map);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	286 if (candidate.cb() != NULL) break;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	287 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	288 if (candidate.cb() == NULL) return false;
0 a61af66fc99e Initial load duke parents: diff changeset	289 }
a61af66fc99e Initial load duke parents: diff changeset	290
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	291 // 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	292 // We will hopefully be able to figure out something to do with it.
0 a61af66fc99e Initial load duke parents: diff changeset	293 int loop_count;
a61af66fc99e Initial load duke parents: diff changeset	294 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	295 RegisterMap map(thread, false);
0 a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 for (loop_count = 0; loop_count < loop_max; loop_count++) {
a61af66fc99e Initial load duke parents: diff changeset	298
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	299 if (candidate.is_first_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	300 // 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	301 // previous anchor, there are no java frames associated with a method
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	302 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	303 }
0 a61af66fc99e Initial load duke parents: diff changeset	304
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	305 if (candidate.is_interpreted_frame()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	306 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	307 *initial_frame_p = candidate;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	308 return true;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	309 }
0 a61af66fc99e Initial load duke parents: diff changeset	310
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	311 // Hopefully we got some data
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	312 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	315 if (candidate.cb()->is_nmethod()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	316
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	317 nmethod* nm = (nmethod*) candidate.cb();
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	318 *method_p = nm->method();
0 a61af66fc99e Initial load duke parents: diff changeset	319
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	320 // 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	321 // 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	322 // 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	323 // not be used.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	324
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	325 *bci_p = -1;
0 a61af66fc99e Initial load duke parents: diff changeset	326
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	327 *initial_frame_p = candidate;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	328
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	329 // 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	330
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	331 if (nm->is_native_method()) return true;
0 a61af66fc99e Initial load duke parents: diff changeset	332
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	333 // 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	334 // 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	335 // a method
0 a61af66fc99e Initial load duke parents: diff changeset	336
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	337 if (!is_decipherable_compiled_frame(thread, &candidate, nm)) {
0 a61af66fc99e Initial load duke parents: diff changeset	338 return false;
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	339 }
0 a61af66fc99e Initial load duke parents: diff changeset	340
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	341 // 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	342 *initial_frame_p = candidate;
0 a61af66fc99e Initial load duke parents: diff changeset	343
1349 547cbe6dacc5 6936709: AsyncGetCallTrace doesn't handle inexact stack walking properly never parents: 196 diff changeset	344 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	345
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	346 return true;
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
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	349 // Must be some stub frame that we don't care about
0 a61af66fc99e Initial load duke parents: diff changeset	350
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	351 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	352 candidate = candidate.sender(&map);
0 a61af66fc99e Initial load duke parents: diff changeset	353
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	354 // 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	355 // 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	356 // all should be there.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	357
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	358 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	359
0 a61af66fc99e Initial load duke parents: diff changeset	360 }
a61af66fc99e Initial load duke parents: diff changeset	361
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	362 return false;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	363
0 a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 // call frame copied from old .h file and renamed
a61af66fc99e Initial load duke parents: diff changeset	368 typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	369 jint lineno; // line number in the source file
a61af66fc99e Initial load duke parents: diff changeset	370 jmethodID method_id; // method executed in this frame
a61af66fc99e Initial load duke parents: diff changeset	371 } ASGCT_CallFrame;
a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373 // call trace copied from old .h file and renamed
a61af66fc99e Initial load duke parents: diff changeset	374 typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	375 JNIEnv *env_id; // Env where trace was recorded
a61af66fc99e Initial load duke parents: diff changeset	376 jint num_frames; // number of frames in this trace
a61af66fc99e Initial load duke parents: diff changeset	377 ASGCT_CallFrame *frames; // frames
a61af66fc99e Initial load duke parents: diff changeset	378 } ASGCT_CallTrace;
a61af66fc99e Initial load duke parents: diff changeset	379
a61af66fc99e Initial load duke parents: diff changeset	380 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	381 ASGCT_CallTrace* trace,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	382 int depth,
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	383 frame top_frame) {
0 a61af66fc99e Initial load duke parents: diff changeset	384 NoHandleMark nhm;
a61af66fc99e Initial load duke parents: diff changeset	385
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	386 frame initial_Java_frame;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	387 Method* method;
0 a61af66fc99e Initial load duke parents: diff changeset	388 int bci;
a61af66fc99e Initial load duke parents: diff changeset	389 int count;
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 count = 0;
a61af66fc99e Initial load duke parents: diff changeset	392 assert(trace->frames != NULL, "trace->frames must be non-NULL");
a61af66fc99e Initial load duke parents: diff changeset	393
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	394 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	395
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	396 // The frame might not be walkable but still recovered a method
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	397 // (e.g. an nmethod with no scope info for the pc
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 if (method == NULL) return;
0 a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 CollectedHeap* ch = Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	402
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	403 // The method is not stored GC safe so see if GC became active
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	404 // after we entered AsyncGetCallTrace() and before we try to
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	405 // use the Method*.
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	406 // Yes, there is still a window after this check and before
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	407 // we use Method* below, but we can't lock out GC so that
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	408 // has to be an acceptable risk.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	409 if (!ch->is_valid_method(method)) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	410 trace->num_frames = ticks_GC_active; // -2
0 a61af66fc99e Initial load duke parents: diff changeset	411 return;
a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	414 // 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	415 // 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	416 // 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	417
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	418 if (!fully_decipherable) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	419 // 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	420 // 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	421 // debugging information is available.
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	422 count++;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	423 trace->num_frames = count;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	424 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	425 if (!method->is_native()) {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	426 trace->frames[0].lineno = bci;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	427 } else {
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	428 trace->frames[0].lineno = -3;
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	429 }
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 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	432
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	433 RegisterMap map(thd, false);
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	434 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	435 }
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	436
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	437 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	438
0 a61af66fc99e Initial load duke parents: diff changeset	439 for (; !st.at_end() && count < depth; st.forte_next(), count++) {
a61af66fc99e Initial load duke parents: diff changeset	440 bci = st.bci();
a61af66fc99e Initial load duke parents: diff changeset	441 method = st.method();
a61af66fc99e Initial load duke parents: diff changeset	442
a61af66fc99e Initial load duke parents: diff changeset	443 // The method is not stored GC safe so see if GC became active
a61af66fc99e Initial load duke parents: diff changeset	444 // after we entered AsyncGetCallTrace() and before we try to
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	445 // use the Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	446 // Yes, there is still a window after this check and before
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	447 // we use Method* below, but we can't lock out GC so that
0 a61af66fc99e Initial load duke parents: diff changeset	448 // has to be an acceptable risk.
a61af66fc99e Initial load duke parents: diff changeset	449 if (!ch->is_valid_method(method)) {
a61af66fc99e Initial load duke parents: diff changeset	450 // we throw away everything we've gathered in this sample since
a61af66fc99e Initial load duke parents: diff changeset	451 // 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	452 trace->num_frames = ticks_GC_active; // -2
0 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 trace->frames[count].method_id = method->find_jmethod_id_or_null();
a61af66fc99e Initial load duke parents: diff changeset	457 if (!method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	458 trace->frames[count].lineno = bci;
a61af66fc99e Initial load duke parents: diff changeset	459 } else {
a61af66fc99e Initial load duke parents: diff changeset	460 trace->frames[count].lineno = -3;
a61af66fc99e Initial load duke parents: diff changeset	461 }
a61af66fc99e Initial load duke parents: diff changeset	462 }
a61af66fc99e Initial load duke parents: diff changeset	463 trace->num_frames = count;
a61af66fc99e Initial load duke parents: diff changeset	464 return;
a61af66fc99e Initial load duke parents: diff changeset	465 }
a61af66fc99e Initial load duke parents: diff changeset	466
a61af66fc99e Initial load duke parents: diff changeset	467
a61af66fc99e Initial load duke parents: diff changeset	468 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
a61af66fc99e Initial load duke parents: diff changeset	469 // on Linux X86, Solaris SPARC and Solaris X86.
a61af66fc99e Initial load duke parents: diff changeset	470 //
a61af66fc99e Initial load duke parents: diff changeset	471 // Async-safe version of GetCallTrace being called from a signal handler
a61af66fc99e Initial load duke parents: diff changeset	472 // when a LWP gets interrupted by SIGPROF but the stack traces are filled
a61af66fc99e Initial load duke parents: diff changeset	473 // with different content (see below).
a61af66fc99e Initial load duke parents: diff changeset	474 //
a61af66fc99e Initial load duke parents: diff changeset	475 // This function must only be called when JVM/TI
a61af66fc99e Initial load duke parents: diff changeset	476 // CLASS_LOAD events have been enabled since agent startup. The enabled
a61af66fc99e Initial load duke parents: diff changeset	477 // event will cause the jmethodIDs to be allocated at class load time.
a61af66fc99e Initial load duke parents: diff changeset	478 // The jmethodIDs cannot be allocated in a signal handler because locks
a61af66fc99e Initial load duke parents: diff changeset	479 // cannot be grabbed in a signal handler safely.
a61af66fc99e Initial load duke parents: diff changeset	480 //
a61af66fc99e Initial load duke parents: diff changeset	481 // void (AsyncGetCallTrace)(ASGCT_CallTrace trace, jint depth, void* ucontext)
a61af66fc99e Initial load duke parents: diff changeset	482 //
a61af66fc99e Initial load duke parents: diff changeset	483 // Called by the profiler to obtain the current method call stack trace for
a61af66fc99e Initial load duke parents: diff changeset	484 // a given thread. The thread is identified by the env_id field in the
a61af66fc99e Initial load duke parents: diff changeset	485 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
a61af66fc99e Initial load duke parents: diff changeset	486 // structure with enough memory for the requested stack depth. The VM fills in
a61af66fc99e Initial load duke parents: diff changeset	487 // the frames buffer and the num_frames field.
a61af66fc99e Initial load duke parents: diff changeset	488 //
a61af66fc99e Initial load duke parents: diff changeset	489 // Arguments:
a61af66fc99e Initial load duke parents: diff changeset	490 //
a61af66fc99e Initial load duke parents: diff changeset	491 // trace - trace data structure to be filled by the VM.
a61af66fc99e Initial load duke parents: diff changeset	492 // depth - depth of the call stack trace.
a61af66fc99e Initial load duke parents: diff changeset	493 // ucontext - ucontext_t of the LWP
a61af66fc99e Initial load duke parents: diff changeset	494 //
a61af66fc99e Initial load duke parents: diff changeset	495 // ASGCT_CallTrace:
a61af66fc99e Initial load duke parents: diff changeset	496 // typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	497 // JNIEnv *env_id;
a61af66fc99e Initial load duke parents: diff changeset	498 // jint num_frames;
a61af66fc99e Initial load duke parents: diff changeset	499 // ASGCT_CallFrame *frames;
a61af66fc99e Initial load duke parents: diff changeset	500 // } ASGCT_CallTrace;
a61af66fc99e Initial load duke parents: diff changeset	501 //
a61af66fc99e Initial load duke parents: diff changeset	502 // Fields:
a61af66fc99e Initial load duke parents: diff changeset	503 // env_id - ID of thread which executed this trace.
a61af66fc99e Initial load duke parents: diff changeset	504 // num_frames - number of frames in the trace.
a61af66fc99e Initial load duke parents: diff changeset	505 // (< 0 indicates the frame is not walkable).
a61af66fc99e Initial load duke parents: diff changeset	506 // frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
a61af66fc99e Initial load duke parents: diff changeset	507 //
a61af66fc99e Initial load duke parents: diff changeset	508 // ASGCT_CallFrame:
a61af66fc99e Initial load duke parents: diff changeset	509 // typedef struct {
a61af66fc99e Initial load duke parents: diff changeset	510 // jint lineno;
a61af66fc99e Initial load duke parents: diff changeset	511 // jmethodID method_id;
a61af66fc99e Initial load duke parents: diff changeset	512 // } ASGCT_CallFrame;
a61af66fc99e Initial load duke parents: diff changeset	513 //
a61af66fc99e Initial load duke parents: diff changeset	514 // Fields:
a61af66fc99e Initial load duke parents: diff changeset	515 // 1) For Java frame (interpreted and compiled),
a61af66fc99e Initial load duke parents: diff changeset	516 // lineno - bci of the method being executed or -1 if bci is not available
a61af66fc99e Initial load duke parents: diff changeset	517 // method_id - jmethodID of the method being executed
a61af66fc99e Initial load duke parents: diff changeset	518 // 2) For native method
a61af66fc99e Initial load duke parents: diff changeset	519 // lineno - (-3)
a61af66fc99e Initial load duke parents: diff changeset	520 // method_id - jmethodID of the method being executed
a61af66fc99e Initial load duke parents: diff changeset	521
a61af66fc99e Initial load duke parents: diff changeset	522 extern "C" {
2191 d70fe6ab4436 6588413: Use -fvisibility=hidden for gcc compiles coleenp parents: 1972 diff changeset	523 JNIEXPORT
0 a61af66fc99e Initial load duke parents: diff changeset	524 void AsyncGetCallTrace(ASGCT_CallTrace trace, jint depth, void ucontext) {
a61af66fc99e Initial load duke parents: diff changeset	525 JavaThread* thread;
a61af66fc99e Initial load duke parents: diff changeset	526
a61af66fc99e Initial load duke parents: diff changeset	527 if (trace->env_id == NULL \|\|
a61af66fc99e Initial load duke parents: diff changeset	528 (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL \|\|
a61af66fc99e Initial load duke parents: diff changeset	529 thread->is_exiting()) {
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 // 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	532 trace->num_frames = ticks_thread_exit; // -8
0 a61af66fc99e Initial load duke parents: diff changeset	533 return;
a61af66fc99e Initial load duke parents: diff changeset	534 }
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 if (thread->in_deopt_handler()) {
a61af66fc99e Initial load duke parents: diff changeset	537 // 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	538 trace->num_frames = ticks_deopt; // -9
0 a61af66fc99e Initial load duke parents: diff changeset	539 return;
a61af66fc99e Initial load duke parents: diff changeset	540 }
a61af66fc99e Initial load duke parents: diff changeset	541
a61af66fc99e Initial load duke parents: diff changeset	542 assert(JavaThread::current() == thread,
a61af66fc99e Initial load duke parents: diff changeset	543 "AsyncGetCallTrace must be called by the current interrupted thread");
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 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	546 trace->num_frames = ticks_no_class_load; // -1
0 a61af66fc99e Initial load duke parents: diff changeset	547 return;
a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550 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	551 trace->num_frames = ticks_GC_active; // -2
0 a61af66fc99e Initial load duke parents: diff changeset	552 return;
a61af66fc99e Initial load duke parents: diff changeset	553 }
a61af66fc99e Initial load duke parents: diff changeset	554
a61af66fc99e Initial load duke parents: diff changeset	555 switch (thread->thread_state()) {
a61af66fc99e Initial load duke parents: diff changeset	556 case _thread_new:
a61af66fc99e Initial load duke parents: diff changeset	557 case _thread_uninitialized:
a61af66fc99e Initial load duke parents: diff changeset	558 case _thread_new_trans:
a61af66fc99e Initial load duke parents: diff changeset	559 // We found the thread on the threads list above, but it is too
a61af66fc99e Initial load duke parents: diff changeset	560 // young to be useful so return that there are no Java frames.
a61af66fc99e Initial load duke parents: diff changeset	561 trace->num_frames = 0;
a61af66fc99e Initial load duke parents: diff changeset	562 break;
a61af66fc99e Initial load duke parents: diff changeset	563 case _thread_in_native:
a61af66fc99e Initial load duke parents: diff changeset	564 case _thread_in_native_trans:
a61af66fc99e Initial load duke parents: diff changeset	565 case _thread_blocked:
a61af66fc99e Initial load duke parents: diff changeset	566 case _thread_blocked_trans:
a61af66fc99e Initial load duke parents: diff changeset	567 case _thread_in_vm:
a61af66fc99e Initial load duke parents: diff changeset	568 case _thread_in_vm_trans:
a61af66fc99e Initial load duke parents: diff changeset	569 {
a61af66fc99e Initial load duke parents: diff changeset	570 frame fr;
a61af66fc99e Initial load duke parents: diff changeset	571
a61af66fc99e Initial load duke parents: diff changeset	572 // param isInJava == false - indicate we aren't in Java code
a61af66fc99e Initial load duke parents: diff changeset	573 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	574 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	575 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	576 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	577 trace->num_frames = 0; // No Java frames
0 a61af66fc99e Initial load duke parents: diff changeset	578 } else {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	579 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	580 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	581
93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	582 // 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	583 // 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	584 // 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	585 // 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	586 // 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	587 // 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	588
0 a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590 }
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592 break;
a61af66fc99e Initial load duke parents: diff changeset	593 case _thread_in_Java:
a61af66fc99e Initial load duke parents: diff changeset	594 case _thread_in_Java_trans:
a61af66fc99e Initial load duke parents: diff changeset	595 {
a61af66fc99e Initial load duke parents: diff changeset	596 frame fr;
a61af66fc99e Initial load duke parents: diff changeset	597
a61af66fc99e Initial load duke parents: diff changeset	598 // param isInJava == true - indicate we are in Java code
a61af66fc99e Initial load duke parents: diff changeset	599 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	600 trace->num_frames = ticks_unknown_Java; // -5 unknown frame
0 a61af66fc99e Initial load duke parents: diff changeset	601 } else {
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	602 trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default
0 a61af66fc99e Initial load duke parents: diff changeset	603 forte_fill_call_trace_given_top(thread, trace, depth, fr);
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605 }
a61af66fc99e Initial load duke parents: diff changeset	606 break;
a61af66fc99e Initial load duke parents: diff changeset	607 default:
a61af66fc99e Initial load duke parents: diff changeset	608 // Unknown thread state
107 93b6525e3b82 6603919: Stackwalking crash on x86 -server with Sun Studio's collect -j on sgoldman parents: 0 diff changeset	609 trace->num_frames = ticks_unknown_state; // -7
0 a61af66fc99e Initial load duke parents: diff changeset	610 break;
a61af66fc99e Initial load duke parents: diff changeset	611 }
a61af66fc99e Initial load duke parents: diff changeset	612 }
a61af66fc99e Initial load duke parents: diff changeset	613
a61af66fc99e Initial load duke parents: diff changeset	614
a61af66fc99e Initial load duke parents: diff changeset	615 #ifndef _WINDOWS
a61af66fc99e Initial load duke parents: diff changeset	616 // Support for the Forte(TM) Peformance Tools collector.
a61af66fc99e Initial load duke parents: diff changeset	617 //
a61af66fc99e Initial load duke parents: diff changeset	618 // The method prototype is derived from libcollector.h. For more
a61af66fc99e Initial load duke parents: diff changeset	619 // information, please see the libcollect man page.
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621 // Method to let libcollector know about a dynamically loaded function.
a61af66fc99e Initial load duke parents: diff changeset	622 // Because it is weakly bound, the calls become NOP's when the library
a61af66fc99e Initial load duke parents: diff changeset	623 // isn't present.
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	624 #ifdef __APPLE__
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	625 // XXXDARWIN: Link errors occur even when __attribute__((weak_import))
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	626 // is added
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	627 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) (0)
f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	628 #else
0 a61af66fc99e Initial load duke parents: diff changeset	629 void collector_func_load(char* name,
a61af66fc99e Initial load duke parents: diff changeset	630 void* null_argument_1,
a61af66fc99e Initial load duke parents: diff changeset	631 void* null_argument_2,
a61af66fc99e Initial load duke parents: diff changeset	632 void *vaddr,
a61af66fc99e Initial load duke parents: diff changeset	633 int size,
a61af66fc99e Initial load duke parents: diff changeset	634 int zero_argument,
a61af66fc99e Initial load duke parents: diff changeset	635 void* null_argument_3);
a61af66fc99e Initial load duke parents: diff changeset	636 #pragma weak collector_func_load
a61af66fc99e Initial load duke parents: diff changeset	637 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
a61af66fc99e Initial load duke parents: diff changeset	638 ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),0 : 0 )
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3899 diff changeset	639 #endif // __APPLE__
0 a61af66fc99e Initial load duke parents: diff changeset	640 #endif // !_WINDOWS
a61af66fc99e Initial load duke parents: diff changeset	641
a61af66fc99e Initial load duke parents: diff changeset	642 } // end extern "C"
a61af66fc99e Initial load duke parents: diff changeset	643 #endif // !IA64
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 void Forte::register_stub(const char* name, address start, address end) {
a61af66fc99e Initial load duke parents: diff changeset	646 #if !defined(_WINDOWS) && !defined(IA64)
a61af66fc99e Initial load duke parents: diff changeset	647 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	648 "Code size exceeds maximum range");
0 a61af66fc99e Initial load duke parents: diff changeset	649
a61af66fc99e Initial load duke parents: diff changeset	650 collector_func_load((char*)name, NULL, NULL, start,
a61af66fc99e Initial load duke parents: diff changeset	651 pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
a61af66fc99e Initial load duke parents: diff changeset	652 #endif // !_WINDOWS && !IA64
a61af66fc99e Initial load duke parents: diff changeset	653 }

Mercurial > hg > truffle

annotate src/share/vm/prims/forte.cpp @ 6862:8a5ea0a9ccc4