How does Java maintain function StackTrace internally

Question

How does Java generate a thread's stack trace?

Example:

Consider functionA calls functionB calls functionC calls functionD. If at any point in functionD getStackTraceElementArray is used it would give the array of functionCalls:

functionC->functionB->functionA

How does Java fill the StackTraceElement array at runtime? Assuming it fills the calling function when it reaches inside the called function, how does the JVM get the reference of the calling method inside the called method?

@Robby Cornelissen: This is not a duplicate question, it is quite different, I am not asking how to get a Stack trace, but how does Java create one internally, where is the hook in the program where it gets instantiated and populated. — Bay Max, May 18 '16 at 04:04
Please reword your question then. _if there is a handler to the method stack area, which can be used to mannually create or fill a StackTraceElement Array in a Java program_ makes it sound like you're looking for a way to get the current stack trace. — Sotirios Delimanolis, May 18 '16 at 04:15
Reopened. Now see [here](http://stackoverflow.com/questions/12865180/how-do-stack-traces-get-generated). — Sotirios Delimanolis, May 18 '16 at 05:26

score 4 · Accepted Answer · answered May 18 '16 at 22:51

In the simplest case the stack trace is obtained from... the stack!
Each thread has a frame pointer (FP) register that points to the base address of a current stack frame. When a Java method is called, it first creates a new stack frame, i.e. it pushes a bunch of information onto the stack:

return address (where the method was called from);
current FP (which points to the caller frame);
method ID of the method being called;
pointers to the constant pool cache etc.

Then it updates FP to point to the newly created frame.

This way, you see, the frame pointers make a linked list: if I read a value pointed by FP, I get the base address of the previous frame.

Now notice that for each frame a method ID is always at the same offset from FP. So the stack walking is as easy as a while loop (written in pseudo-code):

address fp = currentThread.getFP();
while (fp != null) {
    methodID m = (methodID) read_stack_at(fp + METHOD_OFFSET);
    print_method(m);
    fp = (address) read_stack_at(fp);
}

That's how it works inside JVM for interpreted methods. Compiled methods are a bit more complicated. They do not usually save a method reference on the stack. Instead there is a structure that maps addresses of compiled code to the metadata that contains compiled method info. But the idea of stack walking is still the same.

How does Java maintain function StackTrace internally

1 Answers1