blob: d316ee97a1a9edb620916cc377c80f07561d24b9 [file] [log] [blame]
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package runtime_test
import (
"reflect"
"runtime"
"strings"
"testing"
)
func f1(pan bool) []uintptr {
return f2(pan) // line 15
}
func f2(pan bool) []uintptr {
return f3(pan) // line 19
}
func f3(pan bool) []uintptr {
if pan {
panic("f3") // line 24
}
ret := make([]uintptr, 20)
return ret[:runtime.Callers(0, ret)] // line 27
}
func testCallers(t *testing.T, pcs []uintptr, pan bool) {
m := make(map[string]int, len(pcs))
frames := runtime.CallersFrames(pcs)
for {
frame, more := frames.Next()
if frame.Function != "" {
m[frame.Function] = frame.Line
}
if !more {
break
}
}
var seen []string
for k := range m {
seen = append(seen, k)
}
t.Logf("functions seen: %s", strings.Join(seen, " "))
var f3Line int
if pan {
f3Line = 24
} else {
f3Line = 27
}
want := []struct {
name string
line int
}{
{"f1", 15},
{"f2", 19},
{"f3", f3Line},
}
for _, w := range want {
if got := m["runtime_test."+w.name]; got != w.line {
t.Errorf("%s is line %d, want %d", w.name, got, w.line)
}
}
}
func testCallersEqual(t *testing.T, pcs []uintptr, want []string) {
t.Helper()
got := make([]string, 0, len(want))
frames := runtime.CallersFrames(pcs)
for {
frame, more := frames.Next()
if !more || len(got) >= len(want) {
break
}
got = append(got, frame.Function)
}
if !reflect.DeepEqual(want, got) {
t.Fatalf("wanted %v, got %v", want, got)
}
}
func TestCallers(t *testing.T) {
testCallers(t, f1(false), false)
}
func TestCallersPanic(t *testing.T) {
// Make sure we don't have any extra frames on the stack (due to
// open-coded defer processing)
want := []string{"runtime.Callers", "runtime_test.TestCallersPanic.func1",
"runtime.gopanic", "runtime_test.f3", "runtime_test.f2", "runtime_test.f1",
"runtime_test.TestCallersPanic"}
defer func() {
if r := recover(); r == nil {
t.Fatal("did not panic")
}
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallers(t, pcs, true)
testCallersEqual(t, pcs, want)
}()
f1(true)
}
func TestCallersDoublePanic(t *testing.T) {
// Make sure we don't have any extra frames on the stack (due to
// open-coded defer processing)
want := []string{"runtime.Callers", "runtime_test.TestCallersDoublePanic.func1.1",
"runtime.gopanic", "runtime_test.TestCallersDoublePanic.func1", "runtime.gopanic", "runtime_test.TestCallersDoublePanic"}
defer func() {
defer func() {
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
if recover() == nil {
t.Fatal("did not panic")
}
testCallersEqual(t, pcs, want)
}()
if recover() == nil {
t.Fatal("did not panic")
}
panic(2)
}()
panic(1)
}
// Test that a defer after a successful recovery looks like it is called directly
// from the function with the defers.
func TestCallersAfterRecovery(t *testing.T) {
want := []string{"runtime.Callers", "runtime_test.TestCallersAfterRecovery.func1", "runtime_test.TestCallersAfterRecovery"}
defer func() {
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
}()
defer func() {
if recover() == nil {
t.Fatal("did not recover from panic")
}
}()
panic(1)
}
func TestCallersAbortedPanic(t *testing.T) {
want := []string{"runtime.Callers", "runtime_test.TestCallersAbortedPanic.func2", "runtime_test.TestCallersAbortedPanic"}
defer func() {
r := recover()
if r != nil {
t.Fatalf("should be no panic remaining to recover")
}
}()
defer func() {
// panic2 was aborted/replaced by panic1, so when panic2 was
// recovered, there is no remaining panic on the stack.
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
}()
defer func() {
r := recover()
if r != "panic2" {
t.Fatalf("got %v, wanted %v", r, "panic2")
}
}()
defer func() {
// panic2 aborts/replaces panic1, because it is a recursive panic
// that is not recovered within the defer function called by
// panic1 panicking sequence
panic("panic2")
}()
panic("panic1")
}
func TestCallersAbortedPanic2(t *testing.T) {
want := []string{"runtime.Callers", "runtime_test.TestCallersAbortedPanic2.func2", "runtime_test.TestCallersAbortedPanic2"}
defer func() {
r := recover()
if r != nil {
t.Fatalf("should be no panic remaining to recover")
}
}()
defer func() {
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
}()
func() {
defer func() {
r := recover()
if r != "panic2" {
t.Fatalf("got %v, wanted %v", r, "panic2")
}
}()
func() {
defer func() {
// Again, panic2 aborts/replaces panic1
panic("panic2")
}()
panic("panic1")
}()
}()
}
func TestCallersNilPointerPanic(t *testing.T) {
// Make sure we don't have any extra frames on the stack (due to
// open-coded defer processing)
want := []string{"runtime.Callers", "runtime_test.TestCallersNilPointerPanic.func1",
"runtime.gopanic", "runtime.panicmem", "runtime.sigpanic",
"runtime_test.TestCallersNilPointerPanic"}
defer func() {
if r := recover(); r == nil {
t.Fatal("did not panic")
}
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
}()
var p *int
if *p == 3 {
t.Fatal("did not see nil pointer panic")
}
}
func TestCallersDivZeroPanic(t *testing.T) {
// Make sure we don't have any extra frames on the stack (due to
// open-coded defer processing)
want := []string{"runtime.Callers", "runtime_test.TestCallersDivZeroPanic.func1",
"runtime.gopanic", "runtime.panicdivide",
"runtime_test.TestCallersDivZeroPanic"}
defer func() {
if r := recover(); r == nil {
t.Fatal("did not panic")
}
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
}()
var n int
if 5/n == 1 {
t.Fatal("did not see divide-by-sizer panic")
}
}
func TestCallersDeferNilFuncPanic(t *testing.T) {
// Make sure we don't have any extra frames on the stack. We cut off the check
// at runtime.sigpanic, because non-open-coded defers (which may be used in
// non-opt or race checker mode) include an extra 'deferreturn' frame (which is
// where the nil pointer deref happens).
state := 1
want := []string{"runtime.Callers", "runtime_test.TestCallersDeferNilFuncPanic.func1",
"runtime.gopanic", "runtime.panicmem", "runtime.sigpanic"}
defer func() {
if r := recover(); r == nil {
t.Fatal("did not panic")
}
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
if state == 1 {
t.Fatal("nil defer func panicked at defer time rather than function exit time")
}
}()
var f func()
defer f()
// Use the value of 'state' to make sure nil defer func f causes panic at
// function exit, rather than at the defer statement.
state = 2
}
// Same test, but forcing non-open-coded defer by putting the defer in a loop. See
// issue #36050
func TestCallersDeferNilFuncPanicWithLoop(t *testing.T) {
state := 1
want := []string{"runtime.Callers", "runtime_test.TestCallersDeferNilFuncPanicWithLoop.func1",
"runtime.gopanic", "runtime.panicmem", "runtime.sigpanic", "runtime.deferreturn", "runtime_test.TestCallersDeferNilFuncPanicWithLoop"}
defer func() {
if r := recover(); r == nil {
t.Fatal("did not panic")
}
pcs := make([]uintptr, 20)
pcs = pcs[:runtime.Callers(0, pcs)]
testCallersEqual(t, pcs, want)
if state == 1 {
t.Fatal("nil defer func panicked at defer time rather than function exit time")
}
}()
for i := 0; i < 1; i++ {
var f func()
defer f()
}
// Use the value of 'state' to make sure nil defer func f causes panic at
// function exit, rather than at the defer statement.
state = 2
}
// issue #51988
// Func.Endlineno was lost when instantiating generic functions, leading to incorrect
// stack trace positions.
func TestCallersEndlineno(t *testing.T) {
testNormalEndlineno(t)
testGenericEndlineno[int](t)
}
func testNormalEndlineno(t *testing.T) {
defer testCallerLine(t, callerLine(t, 0)+1)
}
func testGenericEndlineno[_ any](t *testing.T) {
defer testCallerLine(t, callerLine(t, 0)+1)
}
func testCallerLine(t *testing.T, want int) {
if have := callerLine(t, 1); have != want {
t.Errorf("callerLine(1) returned %d, but want %d\n", have, want)
}
}
func callerLine(t *testing.T, skip int) int {
_, _, line, ok := runtime.Caller(skip + 1)
if !ok {
t.Fatalf("runtime.Caller(%d) failed", skip+1)
}
return line
}
func BenchmarkCallers(b *testing.B) {
b.Run("cached", func(b *testing.B) {
// Very pcvalueCache-friendly, no inlining.
callersCached(b, 100)
})
b.Run("inlined", func(b *testing.B) {
// Some inlining, still pretty cache-friendly.
callersInlined(b, 100)
})
b.Run("no-cache", func(b *testing.B) {
// Cache-hostile
callersNoCache(b, 100)
})
}
func callersCached(b *testing.B, n int) int {
if n <= 0 {
pcs := make([]uintptr, 32)
b.ResetTimer()
for i := 0; i < b.N; i++ {
runtime.Callers(0, pcs)
}
b.StopTimer()
return 0
}
return 1 + callersCached(b, n-1)
}
func callersInlined(b *testing.B, n int) int {
if n <= 0 {
pcs := make([]uintptr, 32)
b.ResetTimer()
for i := 0; i < b.N; i++ {
runtime.Callers(0, pcs)
}
b.StopTimer()
return 0
}
return 1 + callersInlined1(b, n-1)
}
func callersInlined1(b *testing.B, n int) int { return callersInlined2(b, n) }
func callersInlined2(b *testing.B, n int) int { return callersInlined3(b, n) }
func callersInlined3(b *testing.B, n int) int { return callersInlined4(b, n) }
func callersInlined4(b *testing.B, n int) int { return callersInlined(b, n) }
func callersNoCache(b *testing.B, n int) int {
if n <= 0 {
pcs := make([]uintptr, 32)
b.ResetTimer()
for i := 0; i < b.N; i++ {
runtime.Callers(0, pcs)
}
b.StopTimer()
return 0
}
switch n % 16 {
case 0:
return 1 + callersNoCache(b, n-1)
case 1:
return 1 + callersNoCache(b, n-1)
case 2:
return 1 + callersNoCache(b, n-1)
case 3:
return 1 + callersNoCache(b, n-1)
case 4:
return 1 + callersNoCache(b, n-1)
case 5:
return 1 + callersNoCache(b, n-1)
case 6:
return 1 + callersNoCache(b, n-1)
case 7:
return 1 + callersNoCache(b, n-1)
case 8:
return 1 + callersNoCache(b, n-1)
case 9:
return 1 + callersNoCache(b, n-1)
case 10:
return 1 + callersNoCache(b, n-1)
case 11:
return 1 + callersNoCache(b, n-1)
case 12:
return 1 + callersNoCache(b, n-1)
case 13:
return 1 + callersNoCache(b, n-1)
case 14:
return 1 + callersNoCache(b, n-1)
default:
return 1 + callersNoCache(b, n-1)
}
}
func BenchmarkFPCallers(b *testing.B) {
b.Run("cached", func(b *testing.B) {
// Very pcvalueCache-friendly, no inlining.
fpCallersCached(b, 100)
})
}
func fpCallersCached(b *testing.B, n int) int {
if n <= 0 {
pcs := make([]uintptr, 32)
b.ResetTimer()
for i := 0; i < b.N; i++ {
runtime.FPCallers(pcs)
}
b.StopTimer()
return 0
}
return 1 + fpCallersCached(b, n-1)
}
func TestFPUnwindAfterRecovery(t *testing.T) {
if !runtime.FramePointerEnabled {
t.Skip("frame pointers not supported for this architecture")
}
func() {
// Make sure that frame pointer unwinding succeeds from a deferred
// function run after recovering from a panic. It can fail if the
// recovery does not properly restore the caller's frame pointer before
// running the remaining deferred functions.
//
// Wrap this all in an extra function since the unwinding is most likely
// to fail trying to unwind *after* the frame we're currently in (since
// *that* bp will fail to be restored). Below we'll try to induce a crash,
// but if for some reason we can't, let's make sure the stack trace looks
// right.
want := []string{
"runtime_test.TestFPUnwindAfterRecovery.func1.1",
"runtime_test.TestFPUnwindAfterRecovery.func1",
"runtime_test.TestFPUnwindAfterRecovery",
}
defer func() {
pcs := make([]uintptr, 32)
for i := range pcs {
// If runtime.recovery doesn't properly restore the
// frame pointer before returning control to this
// function, it will point somewhere lower in the stack
// from one of the frames of runtime.gopanic() or one of
// it's callees prior to recovery. So, we put some
// non-zero values on the stack to try and get frame
// pointer unwinding to crash if it sees the old,
// invalid frame pointer.
pcs[i] = 10
}
runtime.FPCallers(pcs)
// If it didn't crash, let's symbolize. Something is going
// to look wrong if the bp restoration just happened to
// reference a valid frame. Look for
var got []string
frames := runtime.CallersFrames(pcs)
for {
frame, more := frames.Next()
if !more {
break
}
got = append(got, frame.Function)
}
// Check that we see the frames in want and in that order.
// This is a bit roundabout because FPCallers doesn't do
// filtering of runtime internals like Callers.
i := 0
for _, f := range got {
if f != want[i] {
continue
}
i++
if i == len(want) {
break
}
}
if i != len(want) {
t.Fatalf("bad unwind: got %v, want %v in that order", got, want)
}
}()
defer func() {
if recover() == nil {
t.Fatal("did not recover from panic")
}
}()
panic(1)
}()
}