symtab_test.go

Documentation: runtime

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package runtime_test
     6  
     7  import (
     8  	"runtime"
     9  	"strings"
    10  	"testing"
    11  	"unsafe"
    12  )
    13  
    14  func TestCaller(t *testing.T) {
    15  	procs := runtime.GOMAXPROCS(-1)
    16  	c := make(chan bool, procs)
    17  	for p := 0; p < procs; p++ {
    18  		go func() {
    19  			for i := 0; i < 1000; i++ {
    20  				testCallerFoo(t)
    21  			}
    22  			c <- true
    23  		}()
    24  		defer func() {
    25  			<-c
    26  		}()
    27  	}
    28  }
    29  
    30  // These are marked noinline so that we can use FuncForPC
    31  // in testCallerBar.
    32  //go:noinline
    33  func testCallerFoo(t *testing.T) {
    34  	testCallerBar(t)
    35  }
    36  
    37  //go:noinline
    38  func testCallerBar(t *testing.T) {
    39  	for i := 0; i < 2; i++ {
    40  		pc, file, line, ok := runtime.Caller(i)
    41  		f := runtime.FuncForPC(pc)
    42  		if !ok ||
    43  			!strings.HasSuffix(file, "symtab_test.go") ||
    44  			(i == 0 && !strings.HasSuffix(f.Name(), "testCallerBar")) ||
    45  			(i == 1 && !strings.HasSuffix(f.Name(), "testCallerFoo")) ||
    46  			line < 5 || line > 1000 ||
    47  			f.Entry() >= pc {
    48  			t.Errorf("incorrect symbol info %d: %t %d %d %s %s %d",
    49  				i, ok, f.Entry(), pc, f.Name(), file, line)
    50  		}
    51  	}
    52  }
    53  
    54  func lineNumber() int {
    55  	_, _, line, _ := runtime.Caller(1)
    56  	return line // return 0 for error
    57  }
    58  
    59  // Do not add/remove lines in this block without updating the line numbers.
    60  var firstLine = lineNumber() // 0
    61  var (                        // 1
    62  	lineVar1             = lineNumber()               // 2
    63  	lineVar2a, lineVar2b = lineNumber(), lineNumber() // 3
    64  )                        // 4
    65  var compLit = []struct { // 5
    66  	lineA, lineB int // 6
    67  }{ // 7
    68  	{ // 8
    69  		lineNumber(), lineNumber(), // 9
    70  	}, // 10
    71  	{ // 11
    72  		lineNumber(), // 12
    73  		lineNumber(), // 13
    74  	}, // 14
    75  	{ // 15
    76  		lineB: lineNumber(), // 16
    77  		lineA: lineNumber(), // 17
    78  	}, // 18
    79  }                                     // 19
    80  var arrayLit = [...]int{lineNumber(), // 20
    81  	lineNumber(), lineNumber(), // 21
    82  	lineNumber(), // 22
    83  }                                  // 23
    84  var sliceLit = []int{lineNumber(), // 24
    85  	lineNumber(), lineNumber(), // 25
    86  	lineNumber(), // 26
    87  }                         // 27
    88  var mapLit = map[int]int{ // 28
    89  	29:           lineNumber(), // 29
    90  	30:           lineNumber(), // 30
    91  	lineNumber(): 31,           // 31
    92  	lineNumber(): 32,           // 32
    93  }                           // 33
    94  var intLit = lineNumber() + // 34
    95  	lineNumber() + // 35
    96  	lineNumber() // 36
    97  func trythis() { // 37
    98  	recordLines(lineNumber(), // 38
    99  		lineNumber(), // 39
   100  		lineNumber()) // 40
   101  }
   102  
   103  // Modifications below this line are okay.
   104  
   105  var l38, l39, l40 int
   106  
   107  func recordLines(a, b, c int) {
   108  	l38 = a
   109  	l39 = b
   110  	l40 = c
   111  }
   112  
   113  func TestLineNumber(t *testing.T) {
   114  	trythis()
   115  	for _, test := range []struct {
   116  		name string
   117  		val  int
   118  		want int
   119  	}{
   120  		{"firstLine", firstLine, 0},
   121  		{"lineVar1", lineVar1, 2},
   122  		{"lineVar2a", lineVar2a, 3},
   123  		{"lineVar2b", lineVar2b, 3},
   124  		{"compLit[0].lineA", compLit[0].lineA, 9},
   125  		{"compLit[0].lineB", compLit[0].lineB, 9},
   126  		{"compLit[1].lineA", compLit[1].lineA, 12},
   127  		{"compLit[1].lineB", compLit[1].lineB, 13},
   128  		{"compLit[2].lineA", compLit[2].lineA, 17},
   129  		{"compLit[2].lineB", compLit[2].lineB, 16},
   130  
   131  		{"arrayLit[0]", arrayLit[0], 20},
   132  		{"arrayLit[1]", arrayLit[1], 21},
   133  		{"arrayLit[2]", arrayLit[2], 21},
   134  		{"arrayLit[3]", arrayLit[3], 22},
   135  
   136  		{"sliceLit[0]", sliceLit[0], 24},
   137  		{"sliceLit[1]", sliceLit[1], 25},
   138  		{"sliceLit[2]", sliceLit[2], 25},
   139  		{"sliceLit[3]", sliceLit[3], 26},
   140  
   141  		{"mapLit[29]", mapLit[29], 29},
   142  		{"mapLit[30]", mapLit[30], 30},
   143  		{"mapLit[31]", mapLit[31+firstLine] + firstLine, 31}, // nb it's the key not the value
   144  		{"mapLit[32]", mapLit[32+firstLine] + firstLine, 32}, // nb it's the key not the value
   145  
   146  		{"intLit", intLit - 2*firstLine, 34 + 35 + 36},
   147  
   148  		{"l38", l38, 38},
   149  		{"l39", l39, 39},
   150  		{"l40", l40, 40},
   151  	} {
   152  		if got := test.val - firstLine; got != test.want {
   153  			t.Errorf("%s on firstLine+%d want firstLine+%d (firstLine=%d, val=%d)",
   154  				test.name, got, test.want, firstLine, test.val)
   155  		}
   156  	}
   157  }
   158  
   159  func TestNilName(t *testing.T) {
   160  	defer func() {
   161  		if ex := recover(); ex != nil {
   162  			t.Fatalf("expected no nil panic, got=%v", ex)
   163  		}
   164  	}()
   165  	if got := (*runtime.Func)(nil).Name(); got != "" {
   166  		t.Errorf("Name() = %q, want %q", got, "")
   167  	}
   168  }
   169  
   170  var dummy int
   171  
   172  func inlined() {
   173  	// Side effect to prevent elimination of this entire function.
   174  	dummy = 42
   175  }
   176  
   177  // A function with an InlTree. Returns a PC within the function body.
   178  //
   179  // No inline to ensure this complete function appears in output.
   180  //
   181  //go:noinline
   182  func tracebackFunc(t *testing.T) uintptr {
   183  	// This body must be more complex than a single call to inlined to get
   184  	// an inline tree.
   185  	inlined()
   186  	inlined()
   187  
   188  	// Acquire a PC in this function.
   189  	pc, _, _, ok := runtime.Caller(0)
   190  	if !ok {
   191  		t.Fatalf("Caller(0) got ok false, want true")
   192  	}
   193  
   194  	return pc
   195  }
   196  
   197  // Test that CallersFrames handles PCs in the alignment region between
   198  // functions (int 3 on amd64) without crashing.
   199  //
   200  // Go will never generate a stack trace containing such an address, as it is
   201  // not a valid call site. However, the cgo traceback function passed to
   202  // runtime.SetCgoTraceback may not be completely accurate and may incorrect
   203  // provide PCs in Go code or the alignement region between functions.
   204  //
   205  // Go obviously doesn't easily expose the problematic PCs to running programs,
   206  // so this test is a bit fragile. Some details:
   207  //
   208  // * tracebackFunc is our target function. We want to get a PC in the
   209  //   alignment region following this function. This function also has other
   210  //   functions inlined into it to ensure it has an InlTree (this was the source
   211  //   of the bug in issue 44971).
   212  //
   213  // * We acquire a PC in tracebackFunc, walking forwards until FuncForPC says
   214  //   we're in a new function. The last PC of the function according to FuncForPC
   215  //   should be in the alignment region (assuming the function isn't already
   216  //   perfectly aligned).
   217  //
   218  // This is a regression test for issue 44971.
   219  func TestFunctionAlignmentTraceback(t *testing.T) {
   220  	pc := tracebackFunc(t)
   221  
   222  	// Double-check we got the right PC.
   223  	f := runtime.FuncForPC(pc)
   224  	if !strings.HasSuffix(f.Name(), "tracebackFunc") {
   225  		t.Fatalf("Caller(0) = %+v, want tracebackFunc", f)
   226  	}
   227  
   228  	// Iterate forward until we find a different function. Back up one
   229  	// instruction is (hopefully) an alignment instruction.
   230  	for runtime.FuncForPC(pc) == f {
   231  		pc++
   232  	}
   233  	pc--
   234  
   235  	// Is this an alignment region filler instruction? We only check this
   236  	// on amd64 for simplicity. If this function has no filler, then we may
   237  	// get a false negative, but will never get a false positive.
   238  	if runtime.GOARCH == "amd64" {
   239  		code := *(*uint8)(unsafe.Pointer(pc))
   240  		if code != 0xcc { // INT $3
   241  			t.Errorf("PC %v code got %#x want 0xcc", pc, code)
   242  		}
   243  	}
   244  
   245  	// Finally ensure that Frames.Next doesn't crash when processing this
   246  	// PC.
   247  	frames := runtime.CallersFrames([]uintptr{pc})
   248  	frame, _ := frames.Next()
   249  	if frame.Func != f {
   250  		t.Errorf("frames.Next() got %+v want %+v", frame.Func, f)
   251  	}
   252  }
   253
View as plain text