What is the 'Unknown Field' in Go Panic Stack Traces?

Understanding the "Unknown Field" in Panic Stack Traces

In the pursuit of deciphering panic stack traces, encountering unfamiliar elements can arise. One such instance occurs within the second argument of function calls in a panic stack trace.

Let's consider the following code to illustrate this:

<code class="go">package main

func F(a int) {
    panic(nil)
}

func main() {
    F(1)
}</code>

When run, this code outputs:

panic: nil

goroutine 1 [running]:
main.F(0x1, 0x10436000)
    /tmp/sandbox090887108/main.go:4 +0x20
main.main()
    /tmp/sandbox090887108/main.go:8 +0x20

The second argument (0x10436000) in main.F(0x1, 0x10436000) is what needs clarification.

Decoding the Unknown Field

The values displayed in the stack trace are the function's arguments, but they don't directly correspond to the passed-in values. Instead, they represent the raw data stored in pointer-sized values.

In the given case, the playground runs on a 64-bit architecture with 32-bit pointers (GOARCH=amd64p32). In such a setup, each value is stored in a 64-bit word, while pointers are 32-bit.

The function F(a int) takes a single argument of type int. The stack trace argument is stored in a 64-bit word. Since the pointer size is 32-bit, the first 32 bits contain the pointer to the argument (0x1), and the remaining 32 bits (0x10436000) are unused.

Further Examples

To demonstrate this concept further, let's consider another example:

<code class="go">func F(a uint8) {
    panic(nil)
}

func main() {
    F(1)
}</code>

This code outputs:

panic: nil

goroutine 1 [running]:
main.F(0x97301, 0x10436000)

Here, the argument a is of type uint8, which occupies 8 bits. The first 8 bits of the 64-bit word contain the value of a (1), while the remaining 56 bits (0x97300 and 0x10436000) are unused.

Return Values

In addition to arguments, stack frames also show return values, which are allocated on the stack. For example, the function signature:

<code class="go">func F(a int64) (int, int)</code>

on amd64 systems, would display the stack frame arguments as:

main.F(0xa, 0x1054d60, 0xc420078058)

The first value represents the argument, while the two subsequent values represent the return values (int and int). However, since return values are not initialized, they don't provide much useful information.

The above is the detailed content of What is the 'Unknown Field' in Go Panic Stack Traces?. For more information, please follow other related articles on the PHP Chinese website!