259 lines
6.9 KiB
Go
259 lines
6.9 KiB
Go
// 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)
|
|
}
|
|
}
|