// 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 ( "internal/abi" "internal/goarch" "runtime/internal/atomic" "runtime/internal/sys" "unsafe" ) // 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 // 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 CallersFrames(callers []uintptr) *Frames { f := &Frames{callers: callers} f.frames = f.frameStore[:0] return f } // 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 (ci *Frames) Next() (frame Frame, more bool) { for len(ci.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(ci.callers) == 0 { break } pc := ci.callers[0] ci.callers = ci.callers[1:] funcInfo := findfunc(pc) if !funcInfo.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. ci.frames = append(ci.frames, expandCgoFrames(pc)...) } continue } f := funcInfo._Func() entry := f.Entry() if pc > entry { // 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. pc-- } // It's important that interpret pc non-strictly as cgoTraceback may // have added bogus PCs with a valid funcInfo but invalid PCDATA. u, uf := newInlineUnwinder(funcInfo, pc) sf := u.srcFunc(uf) if u.isInlined(uf) { // Note: entry is not modified. It always refers to a real frame, not an inlined one. // File/line from funcline1 below are already correct. f = nil } ci.frames = append(ci.frames, Frame{ PC: pc, Func: f, Function: funcNameForPrint(sf.name()), Entry: entry, startLine: int(sf.startLine), funcInfo: 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(ci.frames) { case 0: // In the rare case when there are no frames at all, we return Frame{}. return case 1: frame = ci.frames[0] ci.frames = ci.frameStore[:0] case 2: frame = ci.frames[0] ci.frameStore[0] = ci.frames[1] ci.frames = ci.frameStore[:1] default: frame = ci.frames[0] ci.frames = ci.frames[1:] } more = len(ci.frames) > 0 if frame.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. file, line := funcline1(frame.funcInfo, frame.PC, false) frame.File, frame.Line = file, int(line) } return } // runtime_FrameStartLine returns the start line of the function in a Frame. // //go:linkname runtime_FrameStartLine runtime/pprof.runtime_FrameStartLine func runtime_FrameStartLine(f *Frame) int { return f.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 "...". // //go:linkname runtime_FrameSymbolName runtime/pprof.runtime_FrameSymbolName func runtime_FrameSymbolName(f *Frame) string { if !f.funcInfo.valid() { return f.Function } u, uf := newInlineUnwinder(f.funcInfo, f.PC) sf := u.srcFunc(uf) return sf.name() } // runtime_expandFinalInlineFrame expands the final pc in stk to include all // "callers" if pc is inline. // //go:linkname runtime_expandFinalInlineFrame runtime/pprof.runtime_expandFinalInlineFrame func runtime_expandFinalInlineFrame(stk []uintptr) []uintptr { // TODO: It would be more efficient to report only physical PCs to pprof and // just expand the whole stack. if len(stk) == 0 { return stk } pc := stk[len(stk)-1] tracepc := pc - 1 f := findfunc(tracepc) if !f.valid() { // Not a Go function. return stk } u, uf := newInlineUnwinder(f, tracepc) if !u.isInlined(uf) { // Nothing inline at tracepc. return stk } // 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. calleeID := abi.FuncIDNormal // Remove pc from stk; we'll re-add it below. stk = stk[:len(stk)-1] for ; uf.valid(); uf = u.next(uf) { funcID := u.srcFunc(uf).funcID if funcID == abi.FuncIDWrapper && elideWrapperCalling(calleeID) { // ignore wrappers } else { stk = append(stk, uf.pc+1) } calleeID = funcID } return stk } // 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(pc uintptr) []Frame { arg := cgoSymbolizerArg{pc: pc} callCgoSymbolizer(&arg) if arg.file == nil && arg.funcName == nil { // No useful information from symbolizer. return nil } var frames []Frame for { frames = append(frames, Frame{ PC: pc, Func: nil, Function: gostring(arg.funcName), File: gostring(arg.file), Line: int(arg.lineno), Entry: arg.entry, // funcInfo is zero, which implies !funcInfo.valid(). // That ensures that we use the File/Line info given here. }) if arg.more == 0 { break } callCgoSymbolizer(&arg) } // 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. arg.pc = 0 callCgoSymbolizer(&arg) return frames } // 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 (f *Func) raw() *_func { return (*_func)(unsafe.Pointer(f)) } func (f *Func) funcInfo() funcInfo { return f.raw().funcInfo() } func (f *_func) funcInfo() 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. ptr := uintptr(unsafe.Pointer(f)) var mod *moduledata for datap := &firstmoduledata; datap != nil; datap = datap.next { if len(datap.pclntable) == 0 { continue } base := uintptr(unsafe.Pointer(&datap.pclntable[0])) if base <= ptr && ptr < base+uintptr(len(datap.pclntable)) { mod = datap break } } return funcInfo{f, mod} } // 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 gcdatamask, gcbssmask bitvector typemap map[typeOff]*_type // offset to *_rtype in previous module bad bool // module failed to load and should be ignored 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 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 { p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice))) if p == nil { return nil } return *p } // 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() { modules := new([]*moduledata) for md := &firstmoduledata; md != nil; md = md.next { if md.bad { continue } *modules = append(*modules, md) if md.gcdatamask == (bitvector{}) { scanDataSize := md.edata - md.data md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), scanDataSize) scanBSSSize := md.ebss - md.bss md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), scanBSSSize) gcController.addGlobals(int64(scanDataSize + scanBSSSize)) } } // 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 i, md := range *modules { if md.hasmain != 0 { (*modules)[0] = md (*modules)[i] = &firstmoduledata break } } atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules)) } 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 } const minfunc = 16 // minimum function size const pcbucketsize = 256 * minfunc // size of bucket in the pc->func lookup table // 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 datap := &firstmoduledata; datap != nil; datap = datap.next { moduledataverify1(datap) } } const debugPcln = false func moduledataverify1(datap *moduledata) { // Check that the pclntab's format is valid. hdr := datap.pcHeader if hdr.magic != 0xfffffff1 || hdr.pad1 != 0 || hdr.pad2 != 0 || hdr.minLC != sys.PCQuantum || hdr.ptrSize != goarch.PtrSize || hdr.textStart != datap.text { println("runtime: pcHeader: magic=", hex(hdr.magic), "pad1=", hdr.pad1, "pad2=", hdr.pad2, "minLC=", hdr.minLC, "ptrSize=", hdr.ptrSize, "pcHeader.textStart=", hex(hdr.textStart), "text=", hex(datap.text), "pluginpath=", datap.pluginpath) throw("invalid function symbol table") } // ftab is lookup table for function by program counter. nftab := len(datap.ftab) - 1 for i := 0; i < nftab; i++ { // NOTE: ftab[nftab].entry is legal; it is the address beyond the final function. if datap.ftab[i].entryoff > datap.ftab[i+1].entryoff { f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap} f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap} f2name := "end" if i+1 < nftab { f2name = funcname(f2) } println("function symbol table not sorted by PC offset:", hex(datap.ftab[i].entryoff), funcname(f1), ">", hex(datap.ftab[i+1].entryoff), f2name, ", plugin:", datap.pluginpath) for j := 0; j <= i; j++ { println("\t", hex(datap.ftab[j].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap})) } if GOOS == "aix" && isarchive { println("-Wl,-bnoobjreorder is mandatory on aix/ppc64 with c-archive") } throw("invalid runtime symbol table") } } min := datap.textAddr(datap.ftab[0].entryoff) max := datap.textAddr(datap.ftab[nftab].entryoff) if datap.minpc != min || datap.maxpc != max { println("minpc=", hex(datap.minpc), "min=", hex(min), "maxpc=", hex(datap.maxpc), "max=", hex(max)) throw("minpc or maxpc invalid") } for _, modulehash := range datap.modulehashes { if modulehash.linktimehash != *modulehash.runtimehash { println("abi mismatch detected between", datap.modulename, "and", modulehash.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 (md *moduledata) textAddr(off32 uint32) uintptr { off := uintptr(off32) res := md.text + off if len(md.textsectmap) > 1 { for i, sect := range md.textsectmap { // For the last section, include the end address (etext), as it is included in the functab. if off >= sect.vaddr && off < sect.end || (i == len(md.textsectmap)-1 && off == sect.end) { res = sect.baseaddr + off - sect.vaddr break } } if res > md.etext && GOARCH != "wasm" { // on wasm, functions do not live in the same address space as the linear memory println("runtime: textAddr", hex(res), "out of range", hex(md.text), "-", hex(md.etext)) throw("runtime: text offset out of range") } } return res } // 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 (md *moduledata) textOff(pc uintptr) (uint32, bool) { res := uint32(pc - md.text) if len(md.textsectmap) > 1 { for i, sect := range md.textsectmap { if sect.baseaddr > pc { // pc is not in any section. return 0, false } end := sect.baseaddr + (sect.end - sect.vaddr) // For the last section, include the end address (etext), as it is included in the functab. if i == len(md.textsectmap)-1 { end++ } if pc < end { res = uint32(pc - sect.baseaddr + sect.vaddr) break } } } return res, true } // funcName returns the string at nameOff in the function name table. func (md *moduledata) funcName(nameOff int32) string { if nameOff == 0 { return "" } return gostringnocopy(&md.funcnametab[nameOff]) } // 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. func FuncForPC(pc uintptr) *Func { f := findfunc(pc) if !f.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. u, uf := newInlineUnwinder(f, pc) if !u.isInlined(uf) { return f._Func() } sf := u.srcFunc(uf) file, line := u.fileLine(uf) fi := &funcinl{ ones: ^uint32(0), entry: f.entry(), // entry of the real (the outermost) function. name: sf.name(), file: file, line: int32(line), startLine: sf.startLine, } return (*Func)(unsafe.Pointer(fi)) } // Name returns the name of the function. func (f *Func) Name() string { if f == nil { return "" } fn := f.raw() if fn.isInlined() { // inlined version fi := (*funcinl)(unsafe.Pointer(fn)) return funcNameForPrint(fi.name) } return funcNameForPrint(funcname(f.funcInfo())) } // Entry returns the entry address of the function. func (f *Func) Entry() uintptr { fn := f.raw() if fn.isInlined() { // inlined version fi := (*funcinl)(unsafe.Pointer(fn)) return fi.entry } return fn.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 (f *Func) FileLine(pc uintptr) (file string, line int) { fn := f.raw() if fn.isInlined() { // inlined version fi := (*funcinl)(unsafe.Pointer(fn)) return fi.file, int(fi.line) } // Pass strict=false here, because anyone can call this function, // and they might just be wrong about targetpc belonging to f. file, line32 := funcline1(f.funcInfo(), pc, false) return file, int(line32) } // startLine returns the starting line number of the function. i.e., the line // number of the func keyword. func (f *Func) startLine() int32 { fn := f.raw() if fn.isInlined() { // inlined version fi := (*funcinl)(unsafe.Pointer(fn)) return fi.startLine } return fn.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(pc uintptr) *moduledata { for datap := &firstmoduledata; datap != nil; datap = datap.next { if datap.minpc <= pc && pc < datap.maxpc { return datap } } return nil } type funcInfo struct { *_func datap *moduledata } func (f funcInfo) valid() bool { return f._func != nil } func (f funcInfo) _Func() *Func { return (*Func)(unsafe.Pointer(f._func)) } // isInlined reports whether f should be re-interpreted as a *funcinl. func (f *_func) isInlined() bool { return f.entryOff == ^uint32(0) // see comment for funcinl.ones } // entry returns the entry PC for f. func (f funcInfo) entry() uintptr { return f.datap.textAddr(f.entryOff) } // findfunc looks up function metadata for a PC. // // It is nosplit because it's part of the isgoexception // implementation. // //go:nosplit func findfunc(pc uintptr) funcInfo { datap := findmoduledatap(pc) if datap == nil { return funcInfo{} } const nsub = uintptr(len(findfuncbucket{}.subbuckets)) pcOff, ok := datap.textOff(pc) if !ok { return funcInfo{} } x := uintptr(pcOff) + datap.text - datap.minpc // TODO: are datap.text and datap.minpc always equal? b := x / pcbucketsize i := x % pcbucketsize / (pcbucketsize / nsub) ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{}))) idx := ffb.idx + uint32(ffb.subbuckets[i]) // Find the ftab entry. for datap.ftab[idx+1].entryoff <= pcOff { idx++ } funcoff := datap.ftab[idx].funcoff return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap} } // 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 (f funcInfo) srcFunc() srcFunc { if !f.valid() { return srcFunc{} } return srcFunc{f.datap, f.nameOff, f.startLine, f.funcID} } func (s srcFunc) name() string { if s.datap == nil { return "" } return s.datap.funcName(s.nameOff) } 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(targetpc uintptr) uintptr { return (targetpc / goarch.PtrSize) % uintptr(len(pcvalueCache{}.entries)) } // Returns the PCData value, and the PC where this value starts. func pcvalue(f funcInfo, off uint32, targetpc uintptr, strict 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 debugCheckCache = false if off == 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 checkVal int32 var checkPC uintptr ck := pcvalueCacheKey(targetpc) { mp := acquirem() cache := &mp.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. cache.inUse++ if cache.inUse == 1 { for i := range cache.entries[ck] { // 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. ent := &cache.entries[ck][i] if ent.off == off && ent.targetpc == targetpc { val, pc := ent.val, ent.valPC if debugCheckCache { checkVal, checkPC = ent.val, ent.valPC break } else { cache.inUse-- releasem(mp) return val, pc } } } } else if debugCheckCache && (cache.inUse < 1 || cache.inUse > 2) { // Catch accounting errors or deeply reentrant use. In principle // "inUse" should never exceed 2. throw("cache.inUse out of range") } cache.inUse-- releasem(mp) } if !f.valid() { if strict && panicking.Load() == 0 { println("runtime: no module data for", hex(f.entry())) throw("no module data") } return -1, 0 } datap := f.datap p := datap.pctab[off:] pc := f.entry() prevpc := pc val := int32(-1) for { var ok bool p, ok = step(p, &pc, &val, pc == f.entry()) if !ok { break } if targetpc < pc { // 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 debugCheckCache && checkPC != 0 { if checkVal != val || checkPC != prevpc { print("runtime: table value ", val, "@", prevpc, " != cache value ", checkVal, "@", checkPC, " at PC ", targetpc, " off ", off, "\n") throw("bad pcvalue cache") } } else { mp := acquirem() cache := &mp.pcvalueCache cache.inUse++ if cache.inUse == 1 { e := &cache.entries[ck] ci := cheaprandn(uint32(len(cache.entries[ck]))) e[ci] = e[0] e[0] = pcvalueCacheEnt{ targetpc: targetpc, off: off, val: val, valPC: prevpc, } } cache.inUse-- releasem(mp) } return val, prevpc } prevpc = pc } // If there was a table, it should have covered all program counters. // If not, something is wrong. if panicking.Load() != 0 || !strict { return -1, 0 } print("runtime: invalid pc-encoded table f=", funcname(f), " pc=", hex(pc), " targetpc=", hex(targetpc), " tab=", p, "\n") p = datap.pctab[off:] pc = f.entry() val = -1 for { var ok bool p, ok = step(p, &pc, &val, pc == f.entry()) if !ok { break } print("\tvalue=", val, " until pc=", hex(pc), "\n") } throw("invalid runtime symbol table") return -1, 0 } func funcname(f funcInfo) string { if !f.valid() { return "" } return f.datap.funcName(f.nameOff) } func funcpkgpath(f funcInfo) string { name := funcNameForPrint(funcname(f)) i := len(name) - 1 for ; i > 0; i-- { if name[i] == '/' { break } } for ; i < len(name); i++ { if name[i] == '.' { break } } return name[:i] } func funcfile(f funcInfo, fileno int32) string { datap := f.datap if !f.valid() { return "?" } // Make sure the cu index and file offset are valid if fileoff := datap.cutab[f.cuOffset+uint32(fileno)]; fileoff != ^uint32(0) { return gostringnocopy(&datap.filetab[fileoff]) } // pcln section is corrupt. return "?" } func funcline1(f funcInfo, targetpc uintptr, strict bool) (file string, line int32) { datap := f.datap if !f.valid() { return "?", 0 } fileno, _ := pcvalue(f, f.pcfile, targetpc, strict) line, _ = pcvalue(f, f.pcln, targetpc, strict) if fileno == -1 || line == -1 || int(fileno) >= len(datap.filetab) { // print("looking for ", hex(targetpc), " in ", funcname(f), " got file=", fileno, " line=", lineno, "\n") return "?", 0 } file = funcfile(f, fileno) return } func funcline(f funcInfo, targetpc uintptr) (file string, line int32) { return funcline1(f, targetpc, true) } func funcspdelta(f funcInfo, targetpc uintptr) int32 { x, _ := pcvalue(f, f.pcsp, targetpc, true) if debugPcln && x&(goarch.PtrSize-1) != 0 { print("invalid spdelta ", funcname(f), " ", hex(f.entry()), " ", hex(targetpc), " ", hex(f.pcsp), " ", x, "\n") throw("bad spdelta") } return x } // funcMaxSPDelta returns the maximum spdelta at any point in f. func funcMaxSPDelta(f funcInfo) int32 { datap := f.datap p := datap.pctab[f.pcsp:] pc := f.entry() val := int32(-1) most := int32(0) for { var ok bool p, ok = step(p, &pc, &val, pc == f.entry()) if !ok { return most } most = max(most, val) } } func pcdatastart(f funcInfo, table uint32) uint32 { return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4)) } func pcdatavalue(f funcInfo, table uint32, targetpc uintptr) int32 { if table >= f.npcdata { return -1 } r, _ := pcvalue(f, pcdatastart(f, table), targetpc, true) return r } func pcdatavalue1(f funcInfo, table uint32, targetpc uintptr, strict bool) int32 { if table >= f.npcdata { return -1 } r, _ := pcvalue(f, pcdatastart(f, table), targetpc, strict) return r } // Like pcdatavalue, but also return the start PC of this PCData value. func pcdatavalue2(f funcInfo, table uint32, targetpc uintptr) (int32, uintptr) { if table >= f.npcdata { return -1, 0 } return pcvalue(f, pcdatastart(f, table), targetpc, true) } // funcdata returns a pointer to the ith funcdata for f. // funcdata should be kept in sync with cmd/link:writeFuncs. func funcdata(f funcInfo, i uint8) unsafe.Pointer { if i < 0 || i >= f.nfuncdata { return nil } base := f.datap.gofunc // load gofunc address early so that we calculate during cache misses p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4 off := *(*uint32)(unsafe.Pointer(p)) // Return off == ^uint32(0) ? 0 : f.datap.gofunc + uintptr(off), but without branches. // The compiler calculates mask on most architectures using conditional assignment. var mask uintptr if off == ^uint32(0) { mask = 1 } mask-- raw := base + uintptr(off) return unsafe.Pointer(raw & mask) } // step advances to the next pc, value pair in the encoded table. func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) { // For both uvdelta and pcdelta, the common case (~70%) // is that they are a single byte. If so, avoid calling readvarint. uvdelta := uint32(p[0]) if uvdelta == 0 && !first { return nil, false } n := uint32(1) if uvdelta&0x80 != 0 { n, uvdelta = readvarint(p) } *val += int32(-(uvdelta & 1) ^ (uvdelta >> 1)) p = p[n:] pcdelta := uint32(p[0]) n = 1 if pcdelta&0x80 != 0 { n, pcdelta = readvarint(p) } p = p[n:] *pc += uintptr(pcdelta * sys.PCQuantum) return p, true } // readvarint reads a varint from p. func readvarint(p []byte) (read uint32, val uint32) { var v, shift, n uint32 for { b := p[n] n++ v |= uint32(b&0x7F) << (shift & 31) if b&0x80 == 0 { break } shift += 7 } return n, v } 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 } //go:nowritebarrier func stackmapdata(stkmap *stackmap, n 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 && (n < 0 || n >= stkmap.n) { throw("stackmapdata: index out of range") } return bitvector{stkmap.nbit, addb(&stkmap.bytedata[0], uintptr(n*((stkmap.nbit+7)>>3)))} }