Source File
symtab.go
Belonging Package
runtime
// Copyright 2014 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
import (
)
// Frames may be used to get function/file/line information for a
// slice of PC values returned by [Callers].
type Frames struct {
// callers is a slice of PCs that have not yet been expanded to frames.
callers []uintptr
// nextPC is a next PC to expand ahead of processing callers.
nextPC uintptr
// frames is a slice of Frames that have yet to be returned.
frames []Frame
frameStore [2]Frame
}
// Frame is the information returned by [Frames] for each call frame.
type Frame struct {
// PC is the program counter for the location in this frame.
// For a frame that calls another frame, this will be the
// program counter of a call instruction. Because of inlining,
// multiple frames may have the same PC value, but different
// symbolic information.
PC uintptr
// Func is the Func value of this call frame. This may be nil
// for non-Go code or fully inlined functions.
Func *Func
// Function is the package path-qualified function name of
// this call frame. If non-empty, this string uniquely
// identifies a single function in the program.
// This may be the empty string if not known.
// If Func is not nil then Function == Func.Name().
Function string
// File and Line are the file name and line number of the
// location in this frame. For non-leaf frames, this will be
// the location of a call. These may be the empty string and
// zero, respectively, if not known.
File string
Line int
// startLine is the line number of the beginning of the function in
// this frame. Specifically, it is the line number of the func keyword
// for Go functions. Note that //line directives can change the
// filename and/or line number arbitrarily within a function, meaning
// that the Line - startLine offset is not always meaningful.
//
// This may be zero if not known.
startLine int
// Entry point program counter for the function; may be zero
// if not known. If Func is not nil then Entry ==
// Func.Entry().
Entry uintptr
// The runtime's internal view of the function. This field
// is set (funcInfo.valid() returns true) only for Go functions,
// not for C functions.
funcInfo funcInfo
}
// CallersFrames takes a slice of PC values returned by [Callers] and
// prepares to return function/file/line information.
// Do not change the slice until you are done with the [Frames].
func ( []uintptr) *Frames {
:= &Frames{callers: }
.frames = .frameStore[:0]
return
}
// Next returns a [Frame] representing the next call frame in the slice
// of PC values. If it has already returned all call frames, Next
// returns a zero [Frame].
//
// The more result indicates whether the next call to Next will return
// a valid [Frame]. It does not necessarily indicate whether this call
// returned one.
//
// See the [Frames] example for idiomatic usage.
func ( *Frames) () ( Frame, bool) {
for len(.frames) < 2 {
// Find the next frame.
// We need to look for 2 frames so we know what
// to return for the "more" result.
if len(.callers) == 0 {
break
}
var uintptr
if .nextPC != 0 {
, .nextPC = .nextPC, 0
} else {
, .callers = .callers[0], .callers[1:]
}
:= findfunc()
if !.valid() {
if cgoSymbolizer != nil {
// Pre-expand cgo frames. We could do this
// incrementally, too, but there's no way to
// avoid allocation in this case anyway.
.frames = append(.frames, expandCgoFrames()...)
}
continue
}
:= ._Func()
:= .Entry()
if > {
// We store the pc of the start of the instruction following
// the instruction in question (the call or the inline mark).
// This is done for historical reasons, and to make FuncForPC
// work correctly for entries in the result of runtime.Callers.
--
}
// It's important that interpret pc non-strictly as cgoTraceback may
// have added bogus PCs with a valid funcInfo but invalid PCDATA.
, := newInlineUnwinder(, )
:= .srcFunc()
if .isInlined() {
// Note: entry is not modified. It always refers to a real frame, not an inlined one.
// File/line from funcline1 below are already correct.
= nil
// When CallersFrame is invoked using the PC list returned by Callers,
// the PC list includes virtual PCs corresponding to each outer frame
// around an innermost real inlined PC.
// We also want to support code passing in a PC list extracted from a
// stack trace, and there only the real PCs are printed, not the virtual ones.
// So check to see if the implied virtual PC for this PC (obtained from the
// unwinder itself) is the next PC in ci.callers. If not, insert it.
// The +1 here correspond to the pc-- above: the output of Callers
// and therefore the input to CallersFrames is return PCs from the stack;
// The pc-- backs up into the CALL instruction (not the first byte of the CALL
// instruction, but good enough to find it nonetheless).
// There are no cycles in implied virtual PCs (some number of frames were
// inlined, but that number is finite), so this unpacking cannot cause an infinite loop.
for := .next(); .valid() && len(.callers) > 0 && .callers[0] != .pc+1; = .next() {
:= .srcFunc()
if .funcID == abi.FuncIDWrapper && elideWrapperCalling(.funcID) {
// Skip, because tracebackPCs (inside runtime.Callers) would too.
continue
}
.nextPC = .pc + 1
break
}
}
.frames = append(.frames, Frame{
PC: ,
Func: ,
Function: funcNameForPrint(.name()),
Entry: ,
startLine: int(.startLine),
funcInfo: ,
// Note: File,Line set below
})
}
// Pop one frame from the frame list. Keep the rest.
// Avoid allocation in the common case, which is 1 or 2 frames.
switch len(.frames) {
case 0: // In the rare case when there are no frames at all, we return Frame{}.
return
case 1:
= .frames[0]
.frames = .frameStore[:0]
case 2:
= .frames[0]
.frameStore[0] = .frames[1]
.frames = .frameStore[:1]
default:
= .frames[0]
.frames = .frames[1:]
}
= len(.frames) > 0
if .funcInfo.valid() {
// Compute file/line just before we need to return it,
// as it can be expensive. This avoids computing file/line
// for the Frame we find but don't return. See issue 32093.
, := funcline1(.funcInfo, .PC, false)
.File, .Line = , int()
}
return
}
// runtime_FrameStartLine returns the start line of the function in a Frame.
//
// runtime_FrameStartLine should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/grafana/pyroscope-go/godeltaprof
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname runtime_FrameStartLine runtime/pprof.runtime_FrameStartLine
func runtime_FrameStartLine( *Frame) int {
return .startLine
}
// runtime_FrameSymbolName returns the full symbol name of the function in a Frame.
// For generic functions this differs from f.Function in that this doesn't replace
// the shape name to "...".
//
// runtime_FrameSymbolName should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/grafana/pyroscope-go/godeltaprof
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname runtime_FrameSymbolName runtime/pprof.runtime_FrameSymbolName
func runtime_FrameSymbolName( *Frame) string {
if !.funcInfo.valid() {
return .Function
}
, := newInlineUnwinder(.funcInfo, .PC)
:= .srcFunc()
return .name()
}
// runtime_expandFinalInlineFrame expands the final pc in stk to include all
// "callers" if pc is inline.
//
// runtime_expandFinalInlineFrame should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/grafana/pyroscope-go/godeltaprof
// - github.com/pyroscope-io/godeltaprof
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname runtime_expandFinalInlineFrame runtime/pprof.runtime_expandFinalInlineFrame
func runtime_expandFinalInlineFrame( []uintptr) []uintptr {
// TODO: It would be more efficient to report only physical PCs to pprof and
// just expand the whole stack.
if len() == 0 {
return
}
:= [len()-1]
:= - 1
:= findfunc()
if !.valid() {
// Not a Go function.
return
}
, := newInlineUnwinder(, )
if !.isInlined() {
// Nothing inline at tracepc.
return
}
// Treat the previous func as normal. We haven't actually checked, but
// since this pc was included in the stack, we know it shouldn't be
// elided.
:= abi.FuncIDNormal
// Remove pc from stk; we'll re-add it below.
= [:len()-1]
for ; .valid(); = .next() {
:= .srcFunc().funcID
if == abi.FuncIDWrapper && elideWrapperCalling() {
// ignore wrappers
} else {
= append(, .pc+1)
}
=
}
return
}
// expandCgoFrames expands frame information for pc, known to be
// a non-Go function, using the cgoSymbolizer hook. expandCgoFrames
// returns nil if pc could not be expanded.
func expandCgoFrames( uintptr) []Frame {
:= cgoSymbolizerArg{pc: }
callCgoSymbolizer(&)
if .file == nil && .funcName == nil {
// No useful information from symbolizer.
return nil
}
var []Frame
for {
= append(, Frame{
PC: ,
Func: nil,
Function: gostring(.funcName),
File: gostring(.file),
Line: int(.lineno),
Entry: .entry,
// funcInfo is zero, which implies !funcInfo.valid().
// That ensures that we use the File/Line info given here.
})
if .more == 0 {
break
}
callCgoSymbolizer(&)
}
// No more frames for this PC. Tell the symbolizer we are done.
// We don't try to maintain a single cgoSymbolizerArg for the
// whole use of Frames, because there would be no good way to tell
// the symbolizer when we are done.
.pc = 0
callCgoSymbolizer(&)
return
}
// NOTE: Func does not expose the actual unexported fields, because we return *Func
// values to users, and we want to keep them from being able to overwrite the data
// with (say) *f = Func{}.
// All code operating on a *Func must call raw() to get the *_func
// or funcInfo() to get the funcInfo instead.
// A Func represents a Go function in the running binary.
type Func struct {
opaque struct{} // unexported field to disallow conversions
}
func ( *Func) () *_func {
return (*_func)(unsafe.Pointer())
}
func ( *Func) () funcInfo {
return .raw().funcInfo()
}
func ( *_func) () funcInfo {
// Find the module containing fn. fn is located in the pclntable.
// The unsafe.Pointer to uintptr conversions and arithmetic
// are safe because we are working with module addresses.
:= uintptr(unsafe.Pointer())
var *moduledata
for := &firstmoduledata; != nil; = .next {
if len(.pclntable) == 0 {
continue
}
:= uintptr(unsafe.Pointer(&.pclntable[0]))
if <= && < +uintptr(len(.pclntable)) {
=
break
}
}
return funcInfo{, }
}
// pcHeader holds data used by the pclntab lookups.
type pcHeader struct {
magic uint32 // 0xFFFFFFF1
pad1, pad2 uint8 // 0,0
minLC uint8 // min instruction size
ptrSize uint8 // size of a ptr in bytes
nfunc int // number of functions in the module
nfiles uint // number of entries in the file tab
textStart uintptr // base for function entry PC offsets in this module, equal to moduledata.text
funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
cuOffset uintptr // offset to the cutab variable from pcHeader
filetabOffset uintptr // offset to the filetab variable from pcHeader
pctabOffset uintptr // offset to the pctab variable from pcHeader
pclnOffset uintptr // offset to the pclntab variable from pcHeader
}
// moduledata records information about the layout of the executable
// image. It is written by the linker. Any changes here must be
// matched changes to the code in cmd/link/internal/ld/symtab.go:symtab.
// moduledata is stored in statically allocated non-pointer memory;
// none of the pointers here are visible to the garbage collector.
type moduledata struct {
sys.NotInHeap // Only in static data
pcHeader *pcHeader
funcnametab []byte
cutab []uint32
filetab []byte
pctab []byte
pclntable []byte
ftab []functab
findfunctab uintptr
minpc, maxpc uintptr
text, etext uintptr
noptrdata, enoptrdata uintptr
data, edata uintptr
bss, ebss uintptr
noptrbss, enoptrbss uintptr
covctrs, ecovctrs uintptr
end, gcdata, gcbss uintptr
types, etypes uintptr
rodata uintptr
gofunc uintptr // go.func.*
textsectmap []textsect
typelinks []int32 // offsets from types
itablinks []*itab
ptab []ptabEntry
pluginpath string
pkghashes []modulehash
// This slice records the initializing tasks that need to be
// done to start up the program. It is built by the linker.
inittasks []*initTask
modulename string
modulehashes []modulehash
hasmain uint8 // 1 if module contains the main function, 0 otherwise
bad bool // module failed to load and should be ignored
gcdatamask, gcbssmask bitvector
typemap map[typeOff]*_type // offset to *_rtype in previous module
next *moduledata
}
// A modulehash is used to compare the ABI of a new module or a
// package in a new module with the loaded program.
//
// For each shared library a module links against, the linker creates an entry in the
// moduledata.modulehashes slice containing the name of the module, the abi hash seen
// at link time and a pointer to the runtime abi hash. These are checked in
// moduledataverify1 below.
//
// For each loaded plugin, the pkghashes slice has a modulehash of the
// newly loaded package that can be used to check the plugin's version of
// a package against any previously loaded version of the package.
// This is done in plugin.lastmoduleinit.
type modulehash struct {
modulename string
linktimehash string
runtimehash *string
}
// pinnedTypemaps are the map[typeOff]*_type from the moduledata objects.
//
// These typemap objects are allocated at run time on the heap, but the
// only direct reference to them is in the moduledata, created by the
// linker and marked SNOPTRDATA so it is ignored by the GC.
//
// To make sure the map isn't collected, we keep a second reference here.
var pinnedTypemaps []map[typeOff]*_type
var firstmoduledata moduledata // linker symbol
// lastmoduledatap should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname lastmoduledatap
var lastmoduledatap *moduledata // linker symbol
var modulesSlice *[]*moduledata // see activeModules
// activeModules returns a slice of active modules.
//
// A module is active once its gcdatamask and gcbssmask have been
// assembled and it is usable by the GC.
//
// This is nosplit/nowritebarrier because it is called by the
// cgo pointer checking code.
//
//go:nosplit
//go:nowritebarrier
func activeModules() []*moduledata {
:= (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
if == nil {
return nil
}
return *
}
// modulesinit creates the active modules slice out of all loaded modules.
//
// When a module is first loaded by the dynamic linker, an .init_array
// function (written by cmd/link) is invoked to call addmoduledata,
// appending to the module to the linked list that starts with
// firstmoduledata.
//
// There are two times this can happen in the lifecycle of a Go
// program. First, if compiled with -linkshared, a number of modules
// built with -buildmode=shared can be loaded at program initialization.
// Second, a Go program can load a module while running that was built
// with -buildmode=plugin.
//
// After loading, this function is called which initializes the
// moduledata so it is usable by the GC and creates a new activeModules
// list.
//
// Only one goroutine may call modulesinit at a time.
func modulesinit() {
:= new([]*moduledata)
for := &firstmoduledata; != nil; = .next {
if .bad {
continue
}
* = append(*, )
if .gcdatamask == (bitvector{}) {
:= .edata - .data
.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(.gcdata)), )
:= .ebss - .bss
.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(.gcbss)), )
gcController.addGlobals(int64( + ))
}
}
// Modules appear in the moduledata linked list in the order they are
// loaded by the dynamic loader, with one exception: the
// firstmoduledata itself the module that contains the runtime. This
// is not always the first module (when using -buildmode=shared, it
// is typically libstd.so, the second module). The order matters for
// typelinksinit, so we swap the first module with whatever module
// contains the main function.
//
// See Issue #18729.
for , := range * {
if .hasmain != 0 {
(*)[0] =
(*)[] = &firstmoduledata
break
}
}
atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer())
}
type functab struct {
entryoff uint32 // relative to runtime.text
funcoff uint32
}
// Mapping information for secondary text sections
type textsect struct {
vaddr uintptr // prelinked section vaddr
end uintptr // vaddr + section length
baseaddr uintptr // relocated section address
}
// findfuncbucket is an array of these structures.
// Each bucket represents 4096 bytes of the text segment.
// Each subbucket represents 256 bytes of the text segment.
// To find a function given a pc, locate the bucket and subbucket for
// that pc. Add together the idx and subbucket value to obtain a
// function index. Then scan the functab array starting at that
// index to find the target function.
// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
type findfuncbucket struct {
idx uint32
subbuckets [16]byte
}
func moduledataverify() {
for := &firstmoduledata; != nil; = .next {
moduledataverify1()
}
}
const debugPcln = false
// moduledataverify1 should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname moduledataverify1
func moduledataverify1( *moduledata) {
// Check that the pclntab's format is valid.
:= .pcHeader
if .magic != 0xfffffff1 || .pad1 != 0 || .pad2 != 0 ||
.minLC != sys.PCQuantum || .ptrSize != goarch.PtrSize || .textStart != .text {
println("runtime: pcHeader: magic=", hex(.magic), "pad1=", .pad1, "pad2=", .pad2,
"minLC=", .minLC, "ptrSize=", .ptrSize, "pcHeader.textStart=", hex(.textStart),
"text=", hex(.text), "pluginpath=", .pluginpath)
throw("invalid function symbol table")
}
// ftab is lookup table for function by program counter.
:= len(.ftab) - 1
for := 0; < ; ++ {
// NOTE: ftab[nftab].entry is legal; it is the address beyond the final function.
if .ftab[].entryoff > .ftab[+1].entryoff {
:= funcInfo{(*_func)(unsafe.Pointer(&.pclntable[.ftab[].funcoff])), }
:= funcInfo{(*_func)(unsafe.Pointer(&.pclntable[.ftab[+1].funcoff])), }
:= "end"
if +1 < {
= funcname()
}
println("function symbol table not sorted by PC offset:", hex(.ftab[].entryoff), funcname(), ">", hex(.ftab[+1].entryoff), , ", plugin:", .pluginpath)
for := 0; <= ; ++ {
println("\t", hex(.ftab[].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&.pclntable[.ftab[].funcoff])), }))
}
if GOOS == "aix" && isarchive {
println("-Wl,-bnoobjreorder is mandatory on aix/ppc64 with c-archive")
}
throw("invalid runtime symbol table")
}
}
:= .textAddr(.ftab[0].entryoff)
:= .textAddr(.ftab[].entryoff)
if .minpc != || .maxpc != {
println("minpc=", hex(.minpc), "min=", hex(), "maxpc=", hex(.maxpc), "max=", hex())
throw("minpc or maxpc invalid")
}
for , := range .modulehashes {
if .linktimehash != *.runtimehash {
println("abi mismatch detected between", .modulename, "and", .modulename)
throw("abi mismatch")
}
}
}
// textAddr returns md.text + off, with special handling for multiple text sections.
// off is a (virtual) offset computed at internal linking time,
// before the external linker adjusts the sections' base addresses.
//
// The text, or instruction stream is generated as one large buffer.
// The off (offset) for a function is its offset within this buffer.
// If the total text size gets too large, there can be issues on platforms like ppc64
// if the target of calls are too far for the call instruction.
// To resolve the large text issue, the text is split into multiple text sections
// to allow the linker to generate long calls when necessary.
// When this happens, the vaddr for each text section is set to its offset within the text.
// Each function's offset is compared against the section vaddrs and ends to determine the containing section.
// Then the section relative offset is added to the section's
// relocated baseaddr to compute the function address.
//
// It is nosplit because it is part of the findfunc implementation.
//
//go:nosplit
func ( *moduledata) ( uint32) uintptr {
:= uintptr()
:= .text +
if len(.textsectmap) > 1 {
for , := range .textsectmap {
// For the last section, include the end address (etext), as it is included in the functab.
if >= .vaddr && < .end || ( == len(.textsectmap)-1 && == .end) {
= .baseaddr + - .vaddr
break
}
}
if > .etext && GOARCH != "wasm" { // on wasm, functions do not live in the same address space as the linear memory
println("runtime: textAddr", hex(), "out of range", hex(.text), "-", hex(.etext))
throw("runtime: text offset out of range")
}
}
return
}
// textOff is the opposite of textAddr. It converts a PC to a (virtual) offset
// to md.text, and returns if the PC is in any Go text section.
//
// It is nosplit because it is part of the findfunc implementation.
//
//go:nosplit
func ( *moduledata) ( uintptr) (uint32, bool) {
:= uint32( - .text)
if len(.textsectmap) > 1 {
for , := range .textsectmap {
if .baseaddr > {
// pc is not in any section.
return 0, false
}
:= .baseaddr + (.end - .vaddr)
// For the last section, include the end address (etext), as it is included in the functab.
if == len(.textsectmap)-1 {
++
}
if < {
= uint32( - .baseaddr + .vaddr)
break
}
}
}
return , true
}
// funcName returns the string at nameOff in the function name table.
func ( *moduledata) ( int32) string {
if == 0 {
return ""
}
return gostringnocopy(&.funcnametab[])
}
// FuncForPC returns a *[Func] describing the function that contains the
// given program counter address, or else nil.
//
// If pc represents multiple functions because of inlining, it returns
// the *Func describing the innermost function, but with an entry of
// the outermost function.
//
// For completely unclear reasons, even though they can import runtime,
// some widely used packages access this using linkname.
// Notable members of the hall of shame include:
// - gitee.com/quant1x/gox
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname FuncForPC
func ( uintptr) *Func {
:= findfunc()
if !.valid() {
return nil
}
// This must interpret PC non-strictly so bad PCs (those between functions) don't crash the runtime.
// We just report the preceding function in that situation. See issue 29735.
// TODO: Perhaps we should report no function at all in that case.
// The runtime currently doesn't have function end info, alas.
, := newInlineUnwinder(, )
if !.isInlined() {
return ._Func()
}
:= .srcFunc()
, := .fileLine()
:= &funcinl{
ones: ^uint32(0),
entry: .entry(), // entry of the real (the outermost) function.
name: .name(),
file: ,
line: int32(),
startLine: .startLine,
}
return (*Func)(unsafe.Pointer())
}
// Name returns the name of the function.
func ( *Func) () string {
if == nil {
return ""
}
:= .raw()
if .isInlined() { // inlined version
:= (*funcinl)(unsafe.Pointer())
return funcNameForPrint(.name)
}
return funcNameForPrint(funcname(.funcInfo()))
}
// Entry returns the entry address of the function.
func ( *Func) () uintptr {
:= .raw()
if .isInlined() { // inlined version
:= (*funcinl)(unsafe.Pointer())
return .entry
}
return .funcInfo().entry()
}
// FileLine returns the file name and line number of the
// source code corresponding to the program counter pc.
// The result will not be accurate if pc is not a program
// counter within f.
func ( *Func) ( uintptr) ( string, int) {
:= .raw()
if .isInlined() { // inlined version
:= (*funcinl)(unsafe.Pointer())
return .file, int(.line)
}
// Pass strict=false here, because anyone can call this function,
// and they might just be wrong about targetpc belonging to f.
, := funcline1(.funcInfo(), , false)
return , int()
}
// startLine returns the starting line number of the function. i.e., the line
// number of the func keyword.
func ( *Func) () int32 {
:= .raw()
if .isInlined() { // inlined version
:= (*funcinl)(unsafe.Pointer())
return .startLine
}
return .funcInfo().startLine
}
// findmoduledatap looks up the moduledata for a PC.
//
// It is nosplit because it's part of the isgoexception
// implementation.
//
//go:nosplit
func findmoduledatap( uintptr) *moduledata {
for := &firstmoduledata; != nil; = .next {
if .minpc <= && < .maxpc {
return
}
}
return nil
}
type funcInfo struct {
*_func
datap *moduledata
}
func ( funcInfo) () bool {
return ._func != nil
}
func ( funcInfo) () *Func {
return (*Func)(unsafe.Pointer(._func))
}
// isInlined reports whether f should be re-interpreted as a *funcinl.
func ( *_func) () bool {
return .entryOff == ^uint32(0) // see comment for funcinl.ones
}
// entry returns the entry PC for f.
//
// entry should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/phuslu/log
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
func ( funcInfo) () uintptr {
return .datap.textAddr(.entryOff)
}
//go:linkname badFuncInfoEntry runtime.funcInfo.entry
func badFuncInfoEntry(funcInfo) uintptr
// findfunc looks up function metadata for a PC.
//
// It is nosplit because it's part of the isgoexception
// implementation.
//
// findfunc should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
// - github.com/phuslu/log
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:nosplit
//go:linkname findfunc
func findfunc( uintptr) funcInfo {
:= findmoduledatap()
if == nil {
return funcInfo{}
}
const = uintptr(len(findfuncbucket{}.subbuckets))
, := .textOff()
if ! {
return funcInfo{}
}
:= uintptr() + .text - .minpc // TODO: are datap.text and datap.minpc always equal?
:= / abi.FuncTabBucketSize
:= % abi.FuncTabBucketSize / (abi.FuncTabBucketSize / )
:= (*findfuncbucket)(add(unsafe.Pointer(.findfunctab), *unsafe.Sizeof(findfuncbucket{})))
:= .idx + uint32(.subbuckets[])
// Find the ftab entry.
for .ftab[+1].entryoff <= {
++
}
:= .ftab[].funcoff
return funcInfo{(*_func)(unsafe.Pointer(&.pclntable[])), }
}
// A srcFunc represents a logical function in the source code. This may
// correspond to an actual symbol in the binary text, or it may correspond to a
// source function that has been inlined.
type srcFunc struct {
datap *moduledata
nameOff int32
startLine int32
funcID abi.FuncID
}
func ( funcInfo) () srcFunc {
if !.valid() {
return srcFunc{}
}
return srcFunc{.datap, .nameOff, .startLine, .funcID}
}
// name should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/phuslu/log
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
func ( srcFunc) () string {
if .datap == nil {
return ""
}
return .datap.funcName(.nameOff)
}
//go:linkname badSrcFuncName runtime.srcFunc.name
func badSrcFuncName(srcFunc) string
type pcvalueCache struct {
entries [2][8]pcvalueCacheEnt
inUse int
}
type pcvalueCacheEnt struct {
// targetpc and off together are the key of this cache entry.
targetpc uintptr
off uint32
val int32 // The value of this entry.
valPC uintptr // The PC at which val starts
}
// pcvalueCacheKey returns the outermost index in a pcvalueCache to use for targetpc.
// It must be very cheap to calculate.
// For now, align to goarch.PtrSize and reduce mod the number of entries.
// In practice, this appears to be fairly randomly and evenly distributed.
func pcvalueCacheKey( uintptr) uintptr {
return ( / goarch.PtrSize) % uintptr(len(pcvalueCache{}.entries))
}
// Returns the PCData value, and the PC where this value starts.
func pcvalue( funcInfo, uint32, uintptr, bool) (int32, uintptr) {
// If true, when we get a cache hit, still look up the data and make sure it
// matches the cached contents.
const = false
if == 0 {
return -1, 0
}
// Check the cache. This speeds up walks of deep stacks, which
// tend to have the same recursive functions over and over,
// or repetitive stacks between goroutines.
var int32
var uintptr
:= pcvalueCacheKey()
{
:= acquirem()
:= &.pcvalueCache
// The cache can be used by the signal handler on this M. Avoid
// re-entrant use of the cache. The signal handler can also write inUse,
// but will always restore its value, so we can use a regular increment
// even if we get signaled in the middle of it.
.inUse++
if .inUse == 1 {
for := range .entries[] {
// We check off first because we're more
// likely to have multiple entries with
// different offsets for the same targetpc
// than the other way around, so we'll usually
// fail in the first clause.
:= &.entries[][]
if .off == && .targetpc == {
, := .val, .valPC
if {
, = .val, .valPC
break
} else {
.inUse--
releasem()
return ,
}
}
}
} else if && (.inUse < 1 || .inUse > 2) {
// Catch accounting errors or deeply reentrant use. In principle
// "inUse" should never exceed 2.
throw("cache.inUse out of range")
}
.inUse--
releasem()
}
if !.valid() {
if && panicking.Load() == 0 {
println("runtime: no module data for", hex(.entry()))
throw("no module data")
}
return -1, 0
}
:= .datap
:= .pctab[:]
:= .entry()
:=
:= int32(-1)
for {
var bool
, = step(, &, &, == .entry())
if ! {
break
}
if < {
// Replace a random entry in the cache. Random
// replacement prevents a performance cliff if
// a recursive stack's cycle is slightly
// larger than the cache.
// Put the new element at the beginning,
// since it is the most likely to be newly used.
if && != 0 {
if != || != {
print("runtime: table value ", , "@", , " != cache value ", , "@", , " at PC ", , " off ", , "\n")
throw("bad pcvalue cache")
}
} else {
:= acquirem()
:= &.pcvalueCache
.inUse++
if .inUse == 1 {
:= &.entries[]
:= cheaprandn(uint32(len(.entries[])))
[] = [0]
[0] = pcvalueCacheEnt{
targetpc: ,
off: ,
val: ,
valPC: ,
}
}
.inUse--
releasem()
}
return ,
}
=
}
// If there was a table, it should have covered all program counters.
// If not, something is wrong.
if panicking.Load() != 0 || ! {
return -1, 0
}
print("runtime: invalid pc-encoded table f=", funcname(), " pc=", hex(), " targetpc=", hex(), " tab=", , "\n")
= .pctab[:]
= .entry()
= -1
for {
var bool
, = step(, &, &, == .entry())
if ! {
break
}
print("\tvalue=", , " until pc=", hex(), "\n")
}
throw("invalid runtime symbol table")
return -1, 0
}
func funcname( funcInfo) string {
if !.valid() {
return ""
}
return .datap.funcName(.nameOff)
}
func funcpkgpath( funcInfo) string {
:= funcNameForPrint(funcname())
:= len() - 1
for ; > 0; -- {
if [] == '/' {
break
}
}
for ; < len(); ++ {
if [] == '.' {
break
}
}
return [:]
}
func funcfile( funcInfo, int32) string {
:= .datap
if !.valid() {
return "?"
}
// Make sure the cu index and file offset are valid
if := .cutab[.cuOffset+uint32()]; != ^uint32(0) {
return gostringnocopy(&.filetab[])
}
// pcln section is corrupt.
return "?"
}
// funcline1 should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/phuslu/log
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname funcline1
func funcline1( funcInfo, uintptr, bool) ( string, int32) {
:= .datap
if !.valid() {
return "?", 0
}
, := pcvalue(, .pcfile, , )
, _ = pcvalue(, .pcln, , )
if == -1 || == -1 || int() >= len(.filetab) {
// print("looking for ", hex(targetpc), " in ", funcname(f), " got file=", fileno, " line=", lineno, "\n")
return "?", 0
}
= funcfile(, )
return
}
func funcline( funcInfo, uintptr) ( string, int32) {
return funcline1(, , true)
}
func funcspdelta( funcInfo, uintptr) int32 {
, := pcvalue(, .pcsp, , true)
if debugPcln && &(goarch.PtrSize-1) != 0 {
print("invalid spdelta ", funcname(), " ", hex(.entry()), " ", hex(), " ", hex(.pcsp), " ", , "\n")
throw("bad spdelta")
}
return
}
// funcMaxSPDelta returns the maximum spdelta at any point in f.
func funcMaxSPDelta( funcInfo) int32 {
:= .datap
:= .pctab[.pcsp:]
:= .entry()
:= int32(-1)
:= int32(0)
for {
var bool
, = step(, &, &, == .entry())
if ! {
return
}
= max(, )
}
}
func pcdatastart( funcInfo, uint32) uint32 {
return *(*uint32)(add(unsafe.Pointer(&.nfuncdata), unsafe.Sizeof(.nfuncdata)+uintptr()*4))
}
func pcdatavalue( funcInfo, uint32, uintptr) int32 {
if >= .npcdata {
return -1
}
, := pcvalue(, pcdatastart(, ), , true)
return
}
func pcdatavalue1( funcInfo, uint32, uintptr, bool) int32 {
if >= .npcdata {
return -1
}
, := pcvalue(, pcdatastart(, ), , )
return
}
// Like pcdatavalue, but also return the start PC of this PCData value.
//
// pcdatavalue2 should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname pcdatavalue2
func pcdatavalue2( funcInfo, uint32, uintptr) (int32, uintptr) {
if >= .npcdata {
return -1, 0
}
return pcvalue(, pcdatastart(, ), , true)
}
// funcdata returns a pointer to the ith funcdata for f.
// funcdata should be kept in sync with cmd/link:writeFuncs.
func funcdata( funcInfo, uint8) unsafe.Pointer {
if < 0 || >= .nfuncdata {
return nil
}
:= .datap.gofunc // load gofunc address early so that we calculate during cache misses
:= uintptr(unsafe.Pointer(&.nfuncdata)) + unsafe.Sizeof(.nfuncdata) + uintptr(.npcdata)*4 + uintptr()*4
:= *(*uint32)(unsafe.Pointer())
// Return off == ^uint32(0) ? 0 : f.datap.gofunc + uintptr(off), but without branches.
// The compiler calculates mask on most architectures using conditional assignment.
var uintptr
if == ^uint32(0) {
= 1
}
--
:= + uintptr()
return unsafe.Pointer( & )
}
// step advances to the next pc, value pair in the encoded table.
//
// step should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname step
func step( []byte, *uintptr, *int32, bool) ( []byte, bool) {
// For both uvdelta and pcdelta, the common case (~70%)
// is that they are a single byte. If so, avoid calling readvarint.
:= uint32([0])
if == 0 && ! {
return nil, false
}
:= uint32(1)
if &0x80 != 0 {
, = readvarint()
}
* += int32(-( & 1) ^ ( >> 1))
= [:]
:= uint32([0])
= 1
if &0x80 != 0 {
, = readvarint()
}
= [:]
* += uintptr( * sys.PCQuantum)
return , true
}
// readvarint reads a varint from p.
func readvarint( []byte) ( uint32, uint32) {
var , , uint32
for {
:= []
++
|= uint32(&0x7F) << ( & 31)
if &0x80 == 0 {
break
}
+= 7
}
return ,
}
type stackmap struct {
n int32 // number of bitmaps
nbit int32 // number of bits in each bitmap
bytedata [1]byte // bitmaps, each starting on a byte boundary
}
// stackmapdata should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
// - github.com/cloudwego/frugal
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname stackmapdata
//go:nowritebarrier
func stackmapdata( *stackmap, int32) bitvector {
// Check this invariant only when stackDebug is on at all.
// The invariant is already checked by many of stackmapdata's callers,
// and disabling it by default allows stackmapdata to be inlined.
if stackDebug > 0 && ( < 0 || >= .n) {
throw("stackmapdata: index out of range")
}
return bitvector{.nbit, addb(&.bytedata[0], uintptr(*((.nbit+7)>>3)))}
}
The pages are generated with Golds v0.6.9-preview. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |