org.jikesrvm.runtime

Class StackTrace

java.lang.Object

org.jikesrvm.runtime.StackTrace

public class StackTrace
extends Object

A list of compiled method and instructionOffset pairs that describe the state of the call stack at a particular instant.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	StackTrace.Element Class to wrap up a stack frame element
(package private) static class	StackTrace.InternalStackTraceElement A stack trace element that contains additional debugging information, namely machine code offsets and byte code indexes.

Field Summary

Fields

Modifier and Type	Field and Description
private int[]	compiledMethods The compiled method ids of the stack trace.
private int[]	instructionOffsets The offset of the instruction within the compiled method
private static int	lastTraceIndex Index of the last stack trace; only used to support VM.VerboseStackTracePeriod
private static boolean	PRINT_INTERNAL_STACK_TRACE Prints an internal stack trace for every stack trace obtained via getStackTrace(Throwable).

Constructor Summary

Constructors

Constructor and Description
StackTrace() Create a trace for the call stack of the current thread
StackTrace(RVMThread rvmThread) Constructs a stack trace.

Method Summary

Modifier and Type	Method and Description
private void	assertThreadBlockedOrCurrent(RVMThread rvmThread)
private StackTrace.Element[]	buildStackTrace(int first, int last)
private int	countFrames(int first, int last) Count number of stack frames including those inlined by the opt compiler
private int	countFramesUninterruptible(RVMThread stackTraceThread) Walk the stack counting the number of stack frames encountered.
private StackTrace.Element	createOptStackTraceElement(RVMMethod m, int ln, Offset mcOffset, int bci)
private StackTrace.Element	createStandardStackTraceElement(CompiledMethod cm, int off)
private int	firstRealMethod() Finds the first non-VM method in the stack trace.
private int	firstRealMethod(Throwable cause) Find the first non-VM method/exception initializer method in the stack trace.
private CompiledMethod	getCompiledMethod(int element)
StackTrace.Element[]	getStackTrace(Throwable cause)
private int	lastRealMethod(int first) Find the first non-VM method at the end of the stack trace
private void	recordFramesUninterruptible(RVMThread stackTraceThread) Walk the stack recording the stack frames encountered The stack being walked is our stack, so code is Uninterrupible to stop the stack moving.
private int	removeStackTraceFrames(int element) Removes all frames from the StackTrace class (i.e. this class) from the stack trace by skipping them.
StackTrace.Element[]	stackTraceNoException(int framesToSkip) Gets a stack trace at the current point in time, assuming the thread didn't throw any exception.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

PRINT_INTERNAL_STACK_TRACE

private static final boolean PRINT_INTERNAL_STACK_TRACE

Prints an internal stack trace for every stack trace obtained via getStackTrace(Throwable). The internal stack trace has machine code offsets and bytecode index information for methods.

See Also:

Constant Field Values

compiledMethods

private final int[] compiledMethods

The compiled method ids of the stack trace. Ordered with the top of the stack at 0 and the bottom of the stack at the end of the array

instructionOffsets

private final int[] instructionOffsets

The offset of the instruction within the compiled method

lastTraceIndex

private static int lastTraceIndex

Index of the last stack trace; only used to support VM.VerboseStackTracePeriod

Constructor Detail

StackTrace

public StackTrace()

Create a trace for the call stack of the current thread

StackTrace

public StackTrace(RVMThread rvmThread)

Constructs a stack trace.

Note: no inlining directives here because they aren't necessary for correctness. This class removes all frames belonging to its methods.

Parameters:

rvmThread - the thread whose stack is examined. It is the caller's responsibility to block that thread if required.

Method Detail

assertThreadBlockedOrCurrent

private void assertThreadBlockedOrCurrent(RVMThread rvmThread)

countFramesUninterruptible

private int countFramesUninterruptible(RVMThread stackTraceThread)

Walk the stack counting the number of stack frames encountered. The stack being walked is our stack, so code is Uninterruptible to stop the stack moving.

Parameters:

stackTraceThread - the thread whose stack is walked

Returns:

number of stack frames encountered

recordFramesUninterruptible

private void recordFramesUninterruptible(RVMThread stackTraceThread)

Walk the stack recording the stack frames encountered The stack being walked is our stack, so code is Uninterrupible to stop the stack moving.

Parameters:

stackTraceThread - the thread whose stack is walked

getCompiledMethod

private CompiledMethod getCompiledMethod(int element)

getStackTrace

public StackTrace.Element[] getStackTrace(Throwable cause)

Parameters:

cause - the throwable that caused the stack trace

Returns:

the stack trace for use by the Throwable API

createStandardStackTraceElement

private StackTrace.Element createStandardStackTraceElement(CompiledMethod cm,
                                                           int off)

createOptStackTraceElement

private StackTrace.Element createOptStackTraceElement(RVMMethod m,
                                                      int ln,
                                                      Offset mcOffset,
                                                      int bci)

buildStackTrace

private StackTrace.Element[] buildStackTrace(int first,
                                             int last)

countFrames

private int countFrames(int first,
                        int last)

Count number of stack frames including those inlined by the opt compiler

Parameters:

first - the first compiled method to look from

last - the last compiled method to look to

Returns:

the number of stack frames

firstRealMethod

private int firstRealMethod(Throwable cause)

Find the first non-VM method/exception initializer method in the stack trace. As we're working with the compiled methods we're assuming the constructor of the exception won't have been inlined into the throwing method.

Parameters:

cause - the cause of generating the stack trace marking the end of the frames to elide

Returns:

the index of the method throwing the exception or else 0

firstRealMethod

private int firstRealMethod()

Finds the first non-VM method in the stack trace. In this case, the assumption is that no exception occurred which makes the job of this method much easier than of firstRealMethod(Throwable): it is only necessary to skip frames from this class.

Returns:

the index of the method or else 0

removeStackTraceFrames

private int removeStackTraceFrames(int element)

Removes all frames from the StackTrace class (i.e. this class) from the stack trace by skipping them.

Note: Callers must update all data relating to the element index themselves.

Parameters:

element - the element index

Returns:

an updated element index

lastRealMethod

private int lastRealMethod(int first)

Find the first non-VM method at the end of the stack trace

Parameters:

first - the first real method of the stack trace

Returns:

compiledMethods.length-1 if no non-VM methods found else the index of the method

stackTraceNoException

public StackTrace.Element[] stackTraceNoException(int framesToSkip)

Gets a stack trace at the current point in time, assuming the thread didn't throw any exception.

Parameters:

framesToSkip - count of frames to skip. Note: frames from this class are always skipped and thus not included in the count. For example, if the caller were foo() and you wanted to skip foo's frame, you would pass 1.

Returns:

a stack trace