blob: ddf64f6854aeda4816555f451f4aba9f58d07084 [file] [log] [blame]
// Copyright 2009 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 (
"runtime"
"strings"
"testing"
"unsafe"
)
var _ = runtime.Caller
var _ = strings.HasSuffix
type _ testing.T
func TestCaller(t *testing.T) {
procs := runtime.GOMAXPROCS(-1)
c := make(chan bool, procs)
for p := 0; p < procs; p++ {
go func() {
for i := 0; i < 1000; i++ {
testCallerFoo(t)
}
c <- true
}()
defer func() {
<-c
}()
}
}
// These are marked noinline so that we can use FuncForPC
// in testCallerBar.
//go:noinline
func testCallerFoo(t *testing.T) {
testCallerBar(t)
}
//go:noinline
func testCallerBar(t *testing.T) {
for i := 0; i < 2; i++ {
pc, file, line, ok := runtime.Caller(i)
f := runtime.FuncForPC(pc)
if !ok ||
!strings.HasSuffix(file, "symtab_test.go") ||
// FuncForPC doesn't work gccgo, because of inlining.
// (i == 0 && !strings.HasSuffix(f.Name(), "testCallerBar")) ||
// (i == 1 && !strings.HasSuffix(f.Name(), "testCallerFoo")) ||
line < 5 || line > 1000 ||
f.Entry() >= pc {
t.Errorf("incorrect symbol info %d: %t %d %d %s %s %d",
i, ok, f.Entry(), pc, f.Name(), file, line)
}
}
}
func lineNumber() int {
_, _, line, _ := runtime.Caller(1)
return line // return 0 for error
}
// Do not add/remove lines in this block without updating the line numbers.
var firstLine = lineNumber() // 0
var ( // 1
lineVar1 = lineNumber() // 2
lineVar2a, lineVar2b = lineNumber(), lineNumber() // 3
) // 4
var compLit = []struct { // 5
lineA, lineB int // 6
}{ // 7
{ // 8
lineNumber(), lineNumber(), // 9
}, // 10
{ // 11
lineNumber(), // 12
lineNumber(), // 13
}, // 14
{ // 15
lineB: lineNumber(), // 16
lineA: lineNumber(), // 17
}, // 18
} // 19
var arrayLit = [...]int{lineNumber(), // 20
lineNumber(), lineNumber(), // 21
lineNumber(), // 22
} // 23
var sliceLit = []int{lineNumber(), // 24
lineNumber(), lineNumber(), // 25
lineNumber(), // 26
} // 27
var mapLit = map[int]int{ // 28
29: lineNumber(), // 29
30: lineNumber(), // 30
lineNumber(): 31, // 31
lineNumber(): 32, // 32
} // 33
var intLit = lineNumber() + // 34
lineNumber() + // 35
lineNumber() // 36
func trythis() { // 37
recordLines(lineNumber(), // 38
lineNumber(), // 39
lineNumber()) // 40
}
// Modifications below this line are okay.
var l38, l39, l40 int
func recordLines(a, b, c int) {
l38 = a
l39 = b
l40 = c
}
func TestLineNumber(t *testing.T) {
trythis()
for _, test := range []struct {
name string
val int
want int
}{
{"firstLine", firstLine, 0},
{"lineVar1", lineVar1, 2},
{"lineVar2a", lineVar2a, 3},
{"lineVar2b", lineVar2b, 3},
{"compLit[0].lineA", compLit[0].lineA, 9},
{"compLit[0].lineB", compLit[0].lineB, 9},
{"compLit[1].lineA", compLit[1].lineA, 12},
{"compLit[1].lineB", compLit[1].lineB, 13},
{"compLit[2].lineA", compLit[2].lineA, 17},
{"compLit[2].lineB", compLit[2].lineB, 16},
{"arrayLit[0]", arrayLit[0], 20},
{"arrayLit[1]", arrayLit[1], 21},
{"arrayLit[2]", arrayLit[2], 21},
{"arrayLit[3]", arrayLit[3], 22},
{"sliceLit[0]", sliceLit[0], 24},
{"sliceLit[1]", sliceLit[1], 25},
{"sliceLit[2]", sliceLit[2], 25},
{"sliceLit[3]", sliceLit[3], 26},
{"mapLit[29]", mapLit[29], 29},
{"mapLit[30]", mapLit[30], 30},
{"mapLit[31]", mapLit[31+firstLine] + firstLine, 31}, // nb it's the key not the value
{"mapLit[32]", mapLit[32+firstLine] + firstLine, 32}, // nb it's the key not the value
{"intLit", intLit - 2*firstLine, 34 + 35 + 36},
{"l38", l38, 38},
{"l39", l39, 39},
{"l40", l40, 40},
} {
if got := test.val - firstLine; got != test.want {
t.Errorf("%s on firstLine+%d want firstLine+%d (firstLine=%d, val=%d)",
test.name, got, test.want, firstLine, test.val)
}
}
}
func TestNilName(t *testing.T) {
defer func() {
if ex := recover(); ex != nil {
t.Fatalf("expected no nil panic, got=%v", ex)
}
}()
if got := (*runtime.Func)(nil).Name(); got != "" {
t.Errorf("Name() = %q, want %q", got, "")
}
}
var dummy int
func inlined() {
// Side effect to prevent elimination of this entire function.
dummy = 42
}
// A function with an InlTree. Returns a PC within the function body.
//
// No inline to ensure this complete function appears in output.
//
//go:noinline
func tracebackFunc(t *testing.T) uintptr {
// This body must be more complex than a single call to inlined to get
// an inline tree.
inlined()
inlined()
// Acquire a PC in this function.
pc, _, _, ok := runtime.Caller(0)
if !ok {
t.Fatalf("Caller(0) got ok false, want true")
}
return pc
}
// Test that CallersFrames handles PCs in the alignment region between
// functions (int 3 on amd64) without crashing.
//
// Go will never generate a stack trace containing such an address, as it is
// not a valid call site. However, the cgo traceback function passed to
// runtime.SetCgoTraceback may not be completely accurate and may incorrect
// provide PCs in Go code or the alignement region between functions.
//
// Go obviously doesn't easily expose the problematic PCs to running programs,
// so this test is a bit fragile. Some details:
//
// * tracebackFunc is our target function. We want to get a PC in the
// alignment region following this function. This function also has other
// functions inlined into it to ensure it has an InlTree (this was the source
// of the bug in issue 44971).
//
// * We acquire a PC in tracebackFunc, walking forwards until FuncForPC says
// we're in a new function. The last PC of the function according to FuncForPC
// should be in the alignment region (assuming the function isn't already
// perfectly aligned).
//
// This is a regression test for issue 44971.
func TestFunctionAlignmentTraceback(t *testing.T) {
pc := tracebackFunc(t)
// Double-check we got the right PC.
f := runtime.FuncForPC(pc)
if !strings.HasSuffix(f.Name(), "tracebackFunc") {
t.Fatalf("Caller(0) = %+v, want tracebackFunc", f)
}
// Iterate forward until we find a different function. Back up one
// instruction is (hopefully) an alignment instruction.
for runtime.FuncForPC(pc) == f {
pc++
}
pc--
// Is this an alignment region filler instruction? We only check this
// on amd64 for simplicity. If this function has no filler, then we may
// get a false negative, but will never get a false positive.
if runtime.GOARCH == "amd64" && runtime.Compiler == "gc" {
code := *(*uint8)(unsafe.Pointer(pc))
if code != 0xcc { // INT $3
t.Errorf("PC %v code got %#x want 0xcc", pc, code)
}
}
// Finally ensure that Frames.Next doesn't crash when processing this
// PC.
frames := runtime.CallersFrames([]uintptr{pc})
frame, _ := frames.Next()
if *frame.Func != *f {
t.Errorf("frames.Next() got %+v want %+v", frame.Func, f)
}
}