Source file src/runtime/symtab.go

     1  // Copyright 2014 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
     6  
     7  import (
     8  	"internal/abi"
     9  	"internal/goarch"
    10  	"internal/runtime/atomic"
    11  	"internal/runtime/sys"
    12  	"unsafe"
    13  )
    14  
    15  // Frames may be used to get function/file/line information for a
    16  // slice of PC values returned by [Callers].
    17  type Frames struct {
    18  	// callers is a slice of PCs that have not yet been expanded to frames.
    19  	callers []uintptr
    20  
    21  	// nextPC is a next PC to expand ahead of processing callers.
    22  	nextPC uintptr
    23  
    24  	// frames is a slice of Frames that have yet to be returned.
    25  	frames     []Frame
    26  	frameStore [2]Frame
    27  }
    28  
    29  // Frame is the information returned by [Frames] for each call frame.
    30  type Frame struct {
    31  	// PC is the program counter for the location in this frame.
    32  	// For a frame that calls another frame, this will be the
    33  	// program counter of a call instruction. Because of inlining,
    34  	// multiple frames may have the same PC value, but different
    35  	// symbolic information.
    36  	PC uintptr
    37  
    38  	// Func is the Func value of this call frame. This may be nil
    39  	// for non-Go code or fully inlined functions.
    40  	Func *Func
    41  
    42  	// Function is the package path-qualified function name of
    43  	// this call frame. If non-empty, this string uniquely
    44  	// identifies a single function in the program.
    45  	// This may be the empty string if not known.
    46  	// If Func is not nil then Function == Func.Name().
    47  	Function string
    48  
    49  	// File and Line are the file name and line number of the
    50  	// location in this frame. For non-leaf frames, this will be
    51  	// the location of a call. These may be the empty string and
    52  	// zero, respectively, if not known. The file name uses
    53  	// forward slashes, even on Windows.
    54  	File string
    55  	Line int
    56  
    57  	// startLine is the line number of the beginning of the function in
    58  	// this frame. Specifically, it is the line number of the func keyword
    59  	// for Go functions. Note that //line directives can change the
    60  	// filename and/or line number arbitrarily within a function, meaning
    61  	// that the Line - startLine offset is not always meaningful.
    62  	//
    63  	// This may be zero if not known.
    64  	startLine int
    65  
    66  	// Entry point program counter for the function; may be zero
    67  	// if not known. If Func is not nil then Entry ==
    68  	// Func.Entry().
    69  	Entry uintptr
    70  
    71  	// The runtime's internal view of the function. This field
    72  	// is set (funcInfo.valid() returns true) only for Go functions,
    73  	// not for C functions.
    74  	funcInfo funcInfo
    75  }
    76  
    77  // CallersFrames takes a slice of PC values returned by [Callers] and
    78  // prepares to return function/file/line information.
    79  // Do not change the slice until you are done with the [Frames].
    80  func CallersFrames(callers []uintptr) *Frames {
    81  	f := &Frames{callers: callers}
    82  	f.frames = f.frameStore[:0]
    83  	return f
    84  }
    85  
    86  // Next returns a [Frame] representing the next call frame in the slice
    87  // of PC values. If it has already returned all call frames, Next
    88  // returns a zero [Frame].
    89  //
    90  // The more result indicates whether the next call to Next will return
    91  // a valid [Frame]. It does not necessarily indicate whether this call
    92  // returned one.
    93  //
    94  // See the [Frames] example for idiomatic usage.
    95  func (ci *Frames) Next() (frame Frame, more bool) {
    96  	for len(ci.frames) < 2 {
    97  		// Find the next frame.
    98  		// We need to look for 2 frames so we know what
    99  		// to return for the "more" result.
   100  		if len(ci.callers) == 0 {
   101  			break
   102  		}
   103  		var pc uintptr
   104  		if ci.nextPC != 0 {
   105  			pc, ci.nextPC = ci.nextPC, 0
   106  		} else {
   107  			pc, ci.callers = ci.callers[0], ci.callers[1:]
   108  		}
   109  		funcInfo := findfunc(pc)
   110  		if !funcInfo.valid() {
   111  			if cgoSymbolizer != nil {
   112  				// Pre-expand cgo frames. We could do this
   113  				// incrementally, too, but there's no way to
   114  				// avoid allocation in this case anyway.
   115  				ci.frames = append(ci.frames, expandCgoFrames(pc)...)
   116  			}
   117  			continue
   118  		}
   119  		f := funcInfo._Func()
   120  		entry := f.Entry()
   121  		// We store the pc of the start of the instruction following
   122  		// the instruction in question (the call or the inline mark).
   123  		// This is done for historical reasons, and to make FuncForPC
   124  		// work correctly for entries in the result of runtime.Callers.
   125  		// Decrement to get back to the instruction we care about.
   126  		//
   127  		// It is not possible to get pc == entry from runtime.Callers,
   128  		// but if the caller does provide one, provide best-effort
   129  		// results by avoiding backing out of the function entirely.
   130  		if pc > entry {
   131  			pc--
   132  		}
   133  		// It's important that interpret pc non-strictly as cgoTraceback may
   134  		// have added bogus PCs with a valid funcInfo but invalid PCDATA.
   135  		u, uf := newInlineUnwinder(funcInfo, pc)
   136  		sf := u.srcFunc(uf)
   137  		if u.isInlined(uf) {
   138  			// Note: entry is not modified. It always refers to a real frame, not an inlined one.
   139  			// File/line from funcline1 below are already correct.
   140  			f = nil
   141  
   142  			// When CallersFrame is invoked using the PC list returned by Callers,
   143  			// the PC list includes virtual PCs corresponding to each outer frame
   144  			// around an innermost real inlined PC.
   145  			// We also want to support code passing in a PC list extracted from a
   146  			// stack trace, and there only the real PCs are printed, not the virtual ones.
   147  			// So check to see if the implied virtual PC for this PC (obtained from the
   148  			// unwinder itself) is the next PC in ci.callers. If not, insert it.
   149  			// The +1 here correspond to the pc-- above: the output of Callers
   150  			// and therefore the input to CallersFrames is return PCs from the stack;
   151  			// The pc-- backs up into the CALL instruction (not the first byte of the CALL
   152  			// instruction, but good enough to find it nonetheless).
   153  			// There are no cycles in implied virtual PCs (some number of frames were
   154  			// inlined, but that number is finite), so this unpacking cannot cause an infinite loop.
   155  			for unext := u.next(uf); unext.valid() && len(ci.callers) > 0 && ci.callers[0] != unext.pc+1; unext = u.next(unext) {
   156  				snext := u.srcFunc(unext)
   157  				if snext.funcID == abi.FuncIDWrapper && elideWrapperCalling(sf.funcID) {
   158  					// Skip, because tracebackPCs (inside runtime.Callers) would too.
   159  					continue
   160  				}
   161  				ci.nextPC = unext.pc + 1
   162  				break
   163  			}
   164  		}
   165  		ci.frames = append(ci.frames, Frame{
   166  			PC:        pc,
   167  			Func:      f,
   168  			Function:  funcNameForPrint(sf.name()),
   169  			Entry:     entry,
   170  			startLine: int(sf.startLine),
   171  			funcInfo:  funcInfo,
   172  			// Note: File,Line set below
   173  		})
   174  	}
   175  
   176  	// Pop one frame from the frame list. Keep the rest.
   177  	// Avoid allocation in the common case, which is 1 or 2 frames.
   178  	switch len(ci.frames) {
   179  	case 0: // In the rare case when there are no frames at all, we return Frame{}.
   180  		return
   181  	case 1:
   182  		frame = ci.frames[0]
   183  		ci.frames = ci.frameStore[:0]
   184  	case 2:
   185  		frame = ci.frames[0]
   186  		ci.frameStore[0] = ci.frames[1]
   187  		ci.frames = ci.frameStore[:1]
   188  	default:
   189  		frame = ci.frames[0]
   190  		ci.frames = ci.frames[1:]
   191  	}
   192  	more = len(ci.frames) > 0
   193  	if frame.funcInfo.valid() {
   194  		// Compute file/line just before we need to return it,
   195  		// as it can be expensive. This avoids computing file/line
   196  		// for the Frame we find but don't return. See issue 32093.
   197  		file, line := funcline1(frame.funcInfo, frame.PC, false)
   198  		frame.File, frame.Line = file, int(line)
   199  	}
   200  	return
   201  }
   202  
   203  // runtime_FrameStartLine returns the start line of the function in a Frame.
   204  //
   205  // runtime_FrameStartLine should be an internal detail,
   206  // but widely used packages access it using linkname.
   207  // Notable members of the hall of shame include:
   208  //   - github.com/grafana/pyroscope-go/godeltaprof
   209  //
   210  // Do not remove or change the type signature.
   211  // See go.dev/issue/67401.
   212  //
   213  //go:linkname runtime_FrameStartLine runtime/pprof.runtime_FrameStartLine
   214  func runtime_FrameStartLine(f *Frame) int {
   215  	return f.startLine
   216  }
   217  
   218  // runtime_FrameSymbolName returns the full symbol name of the function in a Frame.
   219  // For generic functions this differs from f.Function in that this doesn't replace
   220  // the shape name to "...".
   221  //
   222  // runtime_FrameSymbolName should be an internal detail,
   223  // but widely used packages access it using linkname.
   224  // Notable members of the hall of shame include:
   225  //   - github.com/grafana/pyroscope-go/godeltaprof
   226  //
   227  // Do not remove or change the type signature.
   228  // See go.dev/issue/67401.
   229  //
   230  //go:linkname runtime_FrameSymbolName runtime/pprof.runtime_FrameSymbolName
   231  func runtime_FrameSymbolName(f *Frame) string {
   232  	if !f.funcInfo.valid() {
   233  		return f.Function
   234  	}
   235  	u, uf := newInlineUnwinder(f.funcInfo, f.PC)
   236  	sf := u.srcFunc(uf)
   237  	return sf.name()
   238  }
   239  
   240  // runtime_expandFinalInlineFrame expands the final pc in stk to include all
   241  // "callers" if pc is inline.
   242  //
   243  // runtime_expandFinalInlineFrame should be an internal detail,
   244  // but widely used packages access it using linkname.
   245  // Notable members of the hall of shame include:
   246  //   - github.com/grafana/pyroscope-go/godeltaprof
   247  //   - github.com/pyroscope-io/godeltaprof
   248  //
   249  // Do not remove or change the type signature.
   250  // See go.dev/issue/67401.
   251  //
   252  //go:linkname runtime_expandFinalInlineFrame runtime/pprof.runtime_expandFinalInlineFrame
   253  func runtime_expandFinalInlineFrame(stk []uintptr) []uintptr {
   254  	// TODO: It would be more efficient to report only physical PCs to pprof and
   255  	// just expand the whole stack.
   256  	if len(stk) == 0 {
   257  		return stk
   258  	}
   259  	pc := stk[len(stk)-1]
   260  	tracepc := pc - 1
   261  
   262  	f := findfunc(tracepc)
   263  	if !f.valid() {
   264  		// Not a Go function.
   265  		return stk
   266  	}
   267  
   268  	u, uf := newInlineUnwinder(f, tracepc)
   269  	if !u.isInlined(uf) {
   270  		// Nothing inline at tracepc.
   271  		return stk
   272  	}
   273  
   274  	// Treat the previous func as normal. We haven't actually checked, but
   275  	// since this pc was included in the stack, we know it shouldn't be
   276  	// elided.
   277  	calleeID := abi.FuncIDNormal
   278  
   279  	// Remove pc from stk; we'll re-add it below.
   280  	stk = stk[:len(stk)-1]
   281  
   282  	for ; uf.valid(); uf = u.next(uf) {
   283  		funcID := u.srcFunc(uf).funcID
   284  		if funcID == abi.FuncIDWrapper && elideWrapperCalling(calleeID) {
   285  			// ignore wrappers
   286  		} else {
   287  			stk = append(stk, uf.pc+1)
   288  		}
   289  		calleeID = funcID
   290  	}
   291  
   292  	return stk
   293  }
   294  
   295  // expandCgoFrames expands frame information for pc, known to be
   296  // a non-Go function, using the cgoSymbolizer hook. expandCgoFrames
   297  // returns nil if pc could not be expanded.
   298  func expandCgoFrames(pc uintptr) []Frame {
   299  	arg := cgoSymbolizerArg{pc: pc}
   300  	callCgoSymbolizer(&arg)
   301  
   302  	if arg.file == nil && arg.funcName == nil {
   303  		// No useful information from symbolizer.
   304  		return nil
   305  	}
   306  
   307  	var frames []Frame
   308  	for {
   309  		frames = append(frames, Frame{
   310  			PC:       pc,
   311  			Func:     nil,
   312  			Function: gostring(arg.funcName),
   313  			File:     gostring(arg.file),
   314  			Line:     int(arg.lineno),
   315  			Entry:    arg.entry,
   316  			// funcInfo is zero, which implies !funcInfo.valid().
   317  			// That ensures that we use the File/Line info given here.
   318  		})
   319  		if arg.more == 0 {
   320  			break
   321  		}
   322  		callCgoSymbolizer(&arg)
   323  	}
   324  
   325  	// No more frames for this PC. Tell the symbolizer we are done.
   326  	// We don't try to maintain a single cgoSymbolizerArg for the
   327  	// whole use of Frames, because there would be no good way to tell
   328  	// the symbolizer when we are done.
   329  	arg.pc = 0
   330  	callCgoSymbolizer(&arg)
   331  
   332  	return frames
   333  }
   334  
   335  // NOTE: Func does not expose the actual unexported fields, because we return *Func
   336  // values to users, and we want to keep them from being able to overwrite the data
   337  // with (say) *f = Func{}.
   338  // All code operating on a *Func must call raw() to get the *_func
   339  // or funcInfo() to get the funcInfo instead.
   340  
   341  // A Func represents a Go function in the running binary.
   342  type Func struct {
   343  	opaque struct{} // unexported field to disallow conversions
   344  }
   345  
   346  func (f *Func) raw() *_func {
   347  	return (*_func)(unsafe.Pointer(f))
   348  }
   349  
   350  func (f *Func) funcInfo() funcInfo {
   351  	return f.raw().funcInfo()
   352  }
   353  
   354  func (f *_func) funcInfo() funcInfo {
   355  	// Find the module containing fn. fn is located in the pclntable.
   356  	// The unsafe.Pointer to uintptr conversions and arithmetic
   357  	// are safe because we are working with module addresses.
   358  	ptr := uintptr(unsafe.Pointer(f))
   359  	var mod *moduledata
   360  	for datap := &firstmoduledata; datap != nil; datap = datap.next {
   361  		if len(datap.pclntable) == 0 {
   362  			continue
   363  		}
   364  		base := uintptr(unsafe.Pointer(&datap.pclntable[0]))
   365  		if base <= ptr && ptr < base+uintptr(len(datap.pclntable)) {
   366  			mod = datap
   367  			break
   368  		}
   369  	}
   370  	return funcInfo{f, mod}
   371  }
   372  
   373  // pcHeader holds data used by the pclntab lookups.
   374  type pcHeader struct {
   375  	magic          uint32  // 0xFFFFFFF1
   376  	pad1, pad2     uint8   // 0,0
   377  	minLC          uint8   // min instruction size
   378  	ptrSize        uint8   // size of a ptr in bytes
   379  	nfunc          int     // number of functions in the module
   380  	nfiles         uint    // number of entries in the file tab
   381  	textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
   382  	funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
   383  	cuOffset       uintptr // offset to the cutab variable from pcHeader
   384  	filetabOffset  uintptr // offset to the filetab variable from pcHeader
   385  	pctabOffset    uintptr // offset to the pctab variable from pcHeader
   386  	pclnOffset     uintptr // offset to the pclntab variable from pcHeader
   387  }
   388  
   389  // moduledata records information about the layout of the executable
   390  // image. It is written by the linker. Any changes here must be
   391  // matched changes to the code in cmd/link/internal/ld/symtab.go:symtab.
   392  // moduledata is stored in statically allocated non-pointer memory;
   393  // none of the pointers here are visible to the garbage collector.
   394  type moduledata struct {
   395  	sys.NotInHeap // Only in static data
   396  
   397  	pcHeader     *pcHeader
   398  	funcnametab  []byte
   399  	cutab        []uint32
   400  	filetab      []byte
   401  	pctab        []byte
   402  	pclntable    []byte
   403  	ftab         []functab
   404  	findfunctab  uintptr
   405  	minpc, maxpc uintptr
   406  
   407  	text, etext           uintptr
   408  	noptrdata, enoptrdata uintptr
   409  	data, edata           uintptr
   410  	bss, ebss             uintptr
   411  	noptrbss, enoptrbss   uintptr
   412  	covctrs, ecovctrs     uintptr
   413  	end, gcdata, gcbss    uintptr
   414  	types, etypes         uintptr
   415  	rodata                uintptr
   416  	gofunc                uintptr // go.func.*
   417  
   418  	textsectmap []textsect
   419  	typelinks   []int32 // offsets from types
   420  	itablinks   []*itab
   421  
   422  	ptab []ptabEntry
   423  
   424  	pluginpath string
   425  	pkghashes  []modulehash
   426  
   427  	// This slice records the initializing tasks that need to be
   428  	// done to start up the program. It is built by the linker.
   429  	inittasks []*initTask
   430  
   431  	modulename   string
   432  	modulehashes []modulehash
   433  
   434  	hasmain uint8 // 1 if module contains the main function, 0 otherwise
   435  	bad     bool  // module failed to load and should be ignored
   436  
   437  	gcdatamask, gcbssmask bitvector
   438  
   439  	typemap map[typeOff]*_type // offset to *_rtype in previous module
   440  
   441  	next *moduledata
   442  }
   443  
   444  // A modulehash is used to compare the ABI of a new module or a
   445  // package in a new module with the loaded program.
   446  //
   447  // For each shared library a module links against, the linker creates an entry in the
   448  // moduledata.modulehashes slice containing the name of the module, the abi hash seen
   449  // at link time and a pointer to the runtime abi hash. These are checked in
   450  // moduledataverify1 below.
   451  //
   452  // For each loaded plugin, the pkghashes slice has a modulehash of the
   453  // newly loaded package that can be used to check the plugin's version of
   454  // a package against any previously loaded version of the package.
   455  // This is done in plugin.lastmoduleinit.
   456  type modulehash struct {
   457  	modulename   string
   458  	linktimehash string
   459  	runtimehash  *string
   460  }
   461  
   462  // pinnedTypemaps are the map[typeOff]*_type from the moduledata objects.
   463  //
   464  // These typemap objects are allocated at run time on the heap, but the
   465  // only direct reference to them is in the moduledata, created by the
   466  // linker and marked SNOPTRDATA so it is ignored by the GC.
   467  //
   468  // To make sure the map isn't collected, we keep a second reference here.
   469  var pinnedTypemaps []map[typeOff]*_type
   470  
   471  // aixStaticDataBase (used only on AIX) holds the unrelocated address
   472  // of the data section, set by the linker.
   473  //
   474  // On AIX, an R_ADDR relocation from an RODATA symbol to a DATA symbol
   475  // does not work, as the dynamic loader can change the address of the
   476  // data section, and it is not possible to apply a dynamic relocation
   477  // to RODATA. In order to get the correct address, we need to apply
   478  // the delta between unrelocated and relocated data section addresses.
   479  // aixStaticDataBase is the unrelocated address, and moduledata.data is
   480  // the relocated one.
   481  var aixStaticDataBase uintptr // linker symbol
   482  
   483  var firstmoduledata moduledata // linker symbol
   484  
   485  // lastmoduledatap should be an internal detail,
   486  // but widely used packages access it using linkname.
   487  // Notable members of the hall of shame include:
   488  //   - github.com/bytedance/sonic
   489  //
   490  // Do not remove or change the type signature.
   491  // See go.dev/issues/67401.
   492  // See go.dev/issues/71672.
   493  //
   494  //go:linkname lastmoduledatap
   495  var lastmoduledatap *moduledata // linker symbol
   496  
   497  var modulesSlice *[]*moduledata // see activeModules
   498  
   499  // activeModules returns a slice of active modules.
   500  //
   501  // A module is active once its gcdatamask and gcbssmask have been
   502  // assembled and it is usable by the GC.
   503  //
   504  // This is nosplit/nowritebarrier because it is called by the
   505  // cgo pointer checking code.
   506  //
   507  //go:nosplit
   508  //go:nowritebarrier
   509  func activeModules() []*moduledata {
   510  	p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
   511  	if p == nil {
   512  		return nil
   513  	}
   514  	return *p
   515  }
   516  
   517  // modulesinit creates the active modules slice out of all loaded modules.
   518  //
   519  // When a module is first loaded by the dynamic linker, an .init_array
   520  // function (written by cmd/link) is invoked to call addmoduledata,
   521  // appending to the module to the linked list that starts with
   522  // firstmoduledata.
   523  //
   524  // There are two times this can happen in the lifecycle of a Go
   525  // program. First, if compiled with -linkshared, a number of modules
   526  // built with -buildmode=shared can be loaded at program initialization.
   527  // Second, a Go program can load a module while running that was built
   528  // with -buildmode=plugin.
   529  //
   530  // After loading, this function is called which initializes the
   531  // moduledata so it is usable by the GC and creates a new activeModules
   532  // list.
   533  //
   534  // Only one goroutine may call modulesinit at a time.
   535  func modulesinit() {
   536  	modules := new([]*moduledata)
   537  	for md := &firstmoduledata; md != nil; md = md.next {
   538  		if md.bad {
   539  			continue
   540  		}
   541  		*modules = append(*modules, md)
   542  		if md.gcdatamask == (bitvector{}) {
   543  			scanDataSize := md.edata - md.data
   544  			md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), scanDataSize)
   545  			scanBSSSize := md.ebss - md.bss
   546  			md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), scanBSSSize)
   547  			gcController.addGlobals(int64(scanDataSize + scanBSSSize))
   548  		}
   549  	}
   550  
   551  	// Modules appear in the moduledata linked list in the order they are
   552  	// loaded by the dynamic loader, with one exception: the
   553  	// firstmoduledata itself the module that contains the runtime. This
   554  	// is not always the first module (when using -buildmode=shared, it
   555  	// is typically libstd.so, the second module). The order matters for
   556  	// typelinksinit, so we swap the first module with whatever module
   557  	// contains the main function.
   558  	//
   559  	// See Issue #18729.
   560  	for i, md := range *modules {
   561  		if md.hasmain != 0 {
   562  			(*modules)[0] = md
   563  			(*modules)[i] = &firstmoduledata
   564  			break
   565  		}
   566  	}
   567  
   568  	atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
   569  }
   570  
   571  type functab struct {
   572  	entryoff uint32 // relative to runtime.text
   573  	funcoff  uint32
   574  }
   575  
   576  // Mapping information for secondary text sections
   577  
   578  type textsect struct {
   579  	vaddr    uintptr // prelinked section vaddr
   580  	end      uintptr // vaddr + section length
   581  	baseaddr uintptr // relocated section address
   582  }
   583  
   584  // findfuncbucket is an array of these structures.
   585  // Each bucket represents 4096 bytes of the text segment.
   586  // Each subbucket represents 256 bytes of the text segment.
   587  // To find a function given a pc, locate the bucket and subbucket for
   588  // that pc. Add together the idx and subbucket value to obtain a
   589  // function index. Then scan the functab array starting at that
   590  // index to find the target function.
   591  // This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
   592  type findfuncbucket struct {
   593  	idx        uint32
   594  	subbuckets [16]byte
   595  }
   596  
   597  func moduledataverify() {
   598  	for datap := &firstmoduledata; datap != nil; datap = datap.next {
   599  		moduledataverify1(datap)
   600  	}
   601  }
   602  
   603  const debugPcln = false
   604  
   605  // moduledataverify1 should be an internal detail,
   606  // but widely used packages access it using linkname.
   607  // Notable members of the hall of shame include:
   608  //   - github.com/bytedance/sonic
   609  //
   610  // Do not remove or change the type signature.
   611  // See go.dev/issues/67401.
   612  // See go.dev/issues/71672.
   613  //
   614  //go:linkname moduledataverify1
   615  func moduledataverify1(datap *moduledata) {
   616  	// Check that the pclntab's format is valid.
   617  	hdr := datap.pcHeader
   618  	if hdr.magic != 0xfffffff1 || hdr.pad1 != 0 || hdr.pad2 != 0 ||
   619  		hdr.minLC != sys.PCQuantum || hdr.ptrSize != goarch.PtrSize || hdr.textStart != datap.text {
   620  		println("runtime: pcHeader: magic=", hex(hdr.magic), "pad1=", hdr.pad1, "pad2=", hdr.pad2,
   621  			"minLC=", hdr.minLC, "ptrSize=", hdr.ptrSize, "pcHeader.textStart=", hex(hdr.textStart),
   622  			"text=", hex(datap.text), "pluginpath=", datap.pluginpath)
   623  		throw("invalid function symbol table")
   624  	}
   625  
   626  	// ftab is lookup table for function by program counter.
   627  	nftab := len(datap.ftab) - 1
   628  	for i := 0; i < nftab; i++ {
   629  		// NOTE: ftab[nftab].entry is legal; it is the address beyond the final function.
   630  		if datap.ftab[i].entryoff > datap.ftab[i+1].entryoff {
   631  			f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap}
   632  			f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap}
   633  			f2name := "end"
   634  			if i+1 < nftab {
   635  				f2name = funcname(f2)
   636  			}
   637  			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)
   638  			for j := 0; j <= i; j++ {
   639  				println("\t", hex(datap.ftab[j].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}))
   640  			}
   641  			if GOOS == "aix" && isarchive {
   642  				println("-Wl,-bnoobjreorder is mandatory on aix/ppc64 with c-archive")
   643  			}
   644  			throw("invalid runtime symbol table")
   645  		}
   646  	}
   647  
   648  	min := datap.textAddr(datap.ftab[0].entryoff)
   649  	max := datap.textAddr(datap.ftab[nftab].entryoff)
   650  	minpc := datap.minpc
   651  	maxpc := datap.maxpc
   652  	if GOARCH == "wasm" {
   653  		// On Wasm, the func table contains the function index, whereas
   654  		// the "PC" is function index << 16 + block index.
   655  		maxpc = alignUp(maxpc, 1<<16) // round up for end PC
   656  	}
   657  	if minpc != min || maxpc != max {
   658  		println("minpc=", hex(minpc), "min=", hex(min), "maxpc=", hex(maxpc), "max=", hex(max))
   659  		throw("minpc or maxpc invalid")
   660  	}
   661  
   662  	for _, modulehash := range datap.modulehashes {
   663  		if modulehash.linktimehash != *modulehash.runtimehash {
   664  			println("abi mismatch detected between", datap.modulename, "and", modulehash.modulename)
   665  			throw("abi mismatch")
   666  		}
   667  	}
   668  }
   669  
   670  // textAddr returns md.text + off, with special handling for multiple text sections.
   671  // off is a (virtual) offset computed at internal linking time,
   672  // before the external linker adjusts the sections' base addresses.
   673  //
   674  // The text, or instruction stream is generated as one large buffer.
   675  // The off (offset) for a function is its offset within this buffer.
   676  // If the total text size gets too large, there can be issues on platforms like ppc64
   677  // if the target of calls are too far for the call instruction.
   678  // To resolve the large text issue, the text is split into multiple text sections
   679  // to allow the linker to generate long calls when necessary.
   680  // When this happens, the vaddr for each text section is set to its offset within the text.
   681  // Each function's offset is compared against the section vaddrs and ends to determine the containing section.
   682  // Then the section relative offset is added to the section's
   683  // relocated baseaddr to compute the function address.
   684  //
   685  // It is nosplit because it is part of the findfunc implementation.
   686  //
   687  //go:nosplit
   688  func (md *moduledata) textAddr(off32 uint32) uintptr {
   689  	off := uintptr(off32)
   690  	res := md.text + off
   691  	if len(md.textsectmap) > 1 {
   692  		for i, sect := range md.textsectmap {
   693  			// For the last section, include the end address (etext), as it is included in the functab.
   694  			if off >= sect.vaddr && off < sect.end || (i == len(md.textsectmap)-1 && off == sect.end) {
   695  				res = sect.baseaddr + off - sect.vaddr
   696  				break
   697  			}
   698  		}
   699  		if res > md.etext && GOARCH != "wasm" { // on wasm, functions do not live in the same address space as the linear memory
   700  			println("runtime: textAddr", hex(res), "out of range", hex(md.text), "-", hex(md.etext))
   701  			throw("runtime: text offset out of range")
   702  		}
   703  	}
   704  	if GOARCH == "wasm" {
   705  		// On Wasm, a text offset (e.g. in the method table) is function index, whereas
   706  		// the "PC" is function index << 16 + block index.
   707  		res <<= 16
   708  	}
   709  	return res
   710  }
   711  
   712  // textOff is the opposite of textAddr. It converts a PC to a (virtual) offset
   713  // to md.text, and returns if the PC is in any Go text section.
   714  //
   715  // It is nosplit because it is part of the findfunc implementation.
   716  //
   717  //go:nosplit
   718  func (md *moduledata) textOff(pc uintptr) (uint32, bool) {
   719  	off := pc - md.text
   720  	if GOARCH == "wasm" {
   721  		// On Wasm, the func table contains the function index, whereas
   722  		// the "PC" is function index << 16 + block index.
   723  		off >>= 16
   724  	}
   725  	res := uint32(off)
   726  	if len(md.textsectmap) > 1 {
   727  		if GOARCH == "wasm" {
   728  			fatal("unexpected multiple text sections on Wasm")
   729  		}
   730  		for i, sect := range md.textsectmap {
   731  			if sect.baseaddr > pc {
   732  				// pc is not in any section.
   733  				return 0, false
   734  			}
   735  			end := sect.baseaddr + (sect.end - sect.vaddr)
   736  			// For the last section, include the end address (etext), as it is included in the functab.
   737  			if i == len(md.textsectmap)-1 {
   738  				end++
   739  			}
   740  			if pc < end {
   741  				res = uint32(pc - sect.baseaddr + sect.vaddr)
   742  				break
   743  			}
   744  		}
   745  	}
   746  	return res, true
   747  }
   748  
   749  // funcName returns the string at nameOff in the function name table.
   750  func (md *moduledata) funcName(nameOff int32) string {
   751  	if nameOff == 0 {
   752  		return ""
   753  	}
   754  	return gostringnocopy(&md.funcnametab[nameOff])
   755  }
   756  
   757  // Despite being an exported symbol,
   758  // FuncForPC is linknamed by widely used packages.
   759  // Notable members of the hall of shame include:
   760  //   - gitee.com/quant1x/gox
   761  //
   762  // Do not remove or change the type signature.
   763  // See go.dev/issue/67401.
   764  //
   765  // Note that this comment is not part of the doc comment.
   766  //
   767  //go:linkname FuncForPC
   768  
   769  // FuncForPC returns a *[Func] describing the function that contains the
   770  // given program counter address, or else nil.
   771  //
   772  // If pc represents multiple functions because of inlining, it returns
   773  // the *Func describing the innermost function, but with an entry of
   774  // the outermost function.
   775  func FuncForPC(pc uintptr) *Func {
   776  	f := findfunc(pc)
   777  	if !f.valid() {
   778  		return nil
   779  	}
   780  	// This must interpret PC non-strictly so bad PCs (those between functions) don't crash the runtime.
   781  	// We just report the preceding function in that situation. See issue 29735.
   782  	// TODO: Perhaps we should report no function at all in that case.
   783  	// The runtime currently doesn't have function end info, alas.
   784  	u, uf := newInlineUnwinder(f, pc)
   785  	if !u.isInlined(uf) {
   786  		return f._Func()
   787  	}
   788  	sf := u.srcFunc(uf)
   789  	file, line := u.fileLine(uf)
   790  	fi := &funcinl{
   791  		ones:      ^uint32(0),
   792  		entry:     f.entry(), // entry of the real (the outermost) function.
   793  		name:      sf.name(),
   794  		file:      file,
   795  		line:      int32(line),
   796  		startLine: sf.startLine,
   797  	}
   798  	return (*Func)(unsafe.Pointer(fi))
   799  }
   800  
   801  // Name returns the name of the function.
   802  func (f *Func) Name() string {
   803  	if f == nil {
   804  		return ""
   805  	}
   806  	fn := f.raw()
   807  	if fn.isInlined() { // inlined version
   808  		fi := (*funcinl)(unsafe.Pointer(fn))
   809  		return funcNameForPrint(fi.name)
   810  	}
   811  	return funcNameForPrint(funcname(f.funcInfo()))
   812  }
   813  
   814  // Entry returns the entry address of the function.
   815  func (f *Func) Entry() uintptr {
   816  	fn := f.raw()
   817  	if fn.isInlined() { // inlined version
   818  		fi := (*funcinl)(unsafe.Pointer(fn))
   819  		return fi.entry
   820  	}
   821  	return fn.funcInfo().entry()
   822  }
   823  
   824  // FileLine returns the file name and line number of the
   825  // source code corresponding to the program counter pc.
   826  // The result will not be accurate if pc is not a program
   827  // counter within f.
   828  func (f *Func) FileLine(pc uintptr) (file string, line int) {
   829  	fn := f.raw()
   830  	if fn.isInlined() { // inlined version
   831  		fi := (*funcinl)(unsafe.Pointer(fn))
   832  		return fi.file, int(fi.line)
   833  	}
   834  	// Pass strict=false here, because anyone can call this function,
   835  	// and they might just be wrong about targetpc belonging to f.
   836  	file, line32 := funcline1(f.funcInfo(), pc, false)
   837  	return file, int(line32)
   838  }
   839  
   840  // startLine returns the starting line number of the function. i.e., the line
   841  // number of the func keyword.
   842  func (f *Func) startLine() int32 {
   843  	fn := f.raw()
   844  	if fn.isInlined() { // inlined version
   845  		fi := (*funcinl)(unsafe.Pointer(fn))
   846  		return fi.startLine
   847  	}
   848  	return fn.funcInfo().startLine
   849  }
   850  
   851  // findmoduledatap looks up the moduledata for a PC.
   852  //
   853  // It is nosplit because it's part of the isgoexception
   854  // implementation.
   855  //
   856  //go:nosplit
   857  func findmoduledatap(pc uintptr) *moduledata {
   858  	for datap := &firstmoduledata; datap != nil; datap = datap.next {
   859  		if datap.minpc <= pc && pc < datap.maxpc {
   860  			return datap
   861  		}
   862  	}
   863  	return nil
   864  }
   865  
   866  type funcInfo struct {
   867  	*_func
   868  	datap *moduledata
   869  }
   870  
   871  func (f funcInfo) valid() bool {
   872  	return f._func != nil
   873  }
   874  
   875  func (f funcInfo) _Func() *Func {
   876  	return (*Func)(unsafe.Pointer(f._func))
   877  }
   878  
   879  // isInlined reports whether f should be re-interpreted as a *funcinl.
   880  func (f *_func) isInlined() bool {
   881  	return f.entryOff == ^uint32(0) // see comment for funcinl.ones
   882  }
   883  
   884  // entry returns the entry PC for f.
   885  //
   886  // entry should be an internal detail,
   887  // but widely used packages access it using linkname.
   888  // Notable members of the hall of shame include:
   889  //   - github.com/phuslu/log
   890  //
   891  // Do not remove or change the type signature.
   892  // See go.dev/issue/67401.
   893  func (f funcInfo) entry() uintptr {
   894  	return f.datap.textAddr(f.entryOff)
   895  }
   896  
   897  //go:linkname badFuncInfoEntry runtime.funcInfo.entry
   898  func badFuncInfoEntry(funcInfo) uintptr
   899  
   900  // findfunc looks up function metadata for a PC.
   901  //
   902  // It is nosplit because it's part of the isgoexception
   903  // implementation.
   904  //
   905  // findfunc should be an internal detail,
   906  // but widely used packages access it using linkname.
   907  // Notable members of the hall of shame include:
   908  //   - github.com/phuslu/log
   909  //
   910  // Do not remove or change the type signature.
   911  // See go.dev/issue/67401.
   912  //
   913  //go:nosplit
   914  //go:linkname findfunc
   915  func findfunc(pc uintptr) funcInfo {
   916  	datap := findmoduledatap(pc)
   917  	if datap == nil {
   918  		return funcInfo{}
   919  	}
   920  	const nsub = uintptr(len(findfuncbucket{}.subbuckets))
   921  
   922  	pcOff, ok := datap.textOff(pc)
   923  	if !ok {
   924  		return funcInfo{}
   925  	}
   926  
   927  	x := uintptr(pcOff) + datap.text - datap.minpc // TODO: are datap.text and datap.minpc always equal?
   928  	if GOARCH == "wasm" {
   929  		// On Wasm, pcOff is the function index, whereas
   930  		// the "PC" is function index << 16 + block index.
   931  		x = uintptr(pcOff)<<16 + datap.text - datap.minpc
   932  	}
   933  	b := x / abi.FuncTabBucketSize
   934  	i := x % abi.FuncTabBucketSize / (abi.FuncTabBucketSize / nsub)
   935  
   936  	ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
   937  	idx := ffb.idx + uint32(ffb.subbuckets[i])
   938  
   939  	// Find the ftab entry.
   940  	for datap.ftab[idx+1].entryoff <= pcOff {
   941  		idx++
   942  	}
   943  
   944  	funcoff := datap.ftab[idx].funcoff
   945  	return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap}
   946  }
   947  
   948  // A srcFunc represents a logical function in the source code. This may
   949  // correspond to an actual symbol in the binary text, or it may correspond to a
   950  // source function that has been inlined.
   951  type srcFunc struct {
   952  	datap     *moduledata
   953  	nameOff   int32
   954  	startLine int32
   955  	funcID    abi.FuncID
   956  }
   957  
   958  func (f funcInfo) srcFunc() srcFunc {
   959  	if !f.valid() {
   960  		return srcFunc{}
   961  	}
   962  	return srcFunc{f.datap, f.nameOff, f.startLine, f.funcID}
   963  }
   964  
   965  // name should be an internal detail,
   966  // but widely used packages access it using linkname.
   967  // Notable members of the hall of shame include:
   968  //   - github.com/phuslu/log
   969  //
   970  // Do not remove or change the type signature.
   971  // See go.dev/issue/67401.
   972  func (s srcFunc) name() string {
   973  	if s.datap == nil {
   974  		return ""
   975  	}
   976  	return s.datap.funcName(s.nameOff)
   977  }
   978  
   979  //go:linkname badSrcFuncName runtime.srcFunc.name
   980  func badSrcFuncName(srcFunc) string
   981  
   982  type pcvalueCache struct {
   983  	entries [2][8]pcvalueCacheEnt
   984  	inUse   int
   985  }
   986  
   987  type pcvalueCacheEnt struct {
   988  	// targetpc and off together are the key of this cache entry.
   989  	targetpc uintptr
   990  	off      uint32
   991  
   992  	val   int32   // The value of this entry.
   993  	valPC uintptr // The PC at which val starts
   994  }
   995  
   996  // pcvalueCacheKey returns the outermost index in a pcvalueCache to use for targetpc.
   997  // It must be very cheap to calculate.
   998  // For now, align to goarch.PtrSize and reduce mod the number of entries.
   999  // In practice, this appears to be fairly randomly and evenly distributed.
  1000  func pcvalueCacheKey(targetpc uintptr) uintptr {
  1001  	return (targetpc / goarch.PtrSize) % uintptr(len(pcvalueCache{}.entries))
  1002  }
  1003  
  1004  // Returns the PCData value, and the PC where this value starts.
  1005  func pcvalue(f funcInfo, off uint32, targetpc uintptr, strict bool) (int32, uintptr) {
  1006  	// If true, when we get a cache hit, still look up the data and make sure it
  1007  	// matches the cached contents.
  1008  	const debugCheckCache = false
  1009  
  1010  	// If true, skip checking the cache entirely.
  1011  	const skipCache = false
  1012  
  1013  	if off == 0 {
  1014  		return -1, 0
  1015  	}
  1016  
  1017  	// Check the cache. This speeds up walks of deep stacks, which
  1018  	// tend to have the same recursive functions over and over,
  1019  	// or repetitive stacks between goroutines.
  1020  	var checkVal int32
  1021  	var checkPC uintptr
  1022  	ck := pcvalueCacheKey(targetpc)
  1023  	if !skipCache {
  1024  		mp := acquirem()
  1025  		cache := &mp.pcvalueCache
  1026  		// The cache can be used by the signal handler on this M. Avoid
  1027  		// re-entrant use of the cache. The signal handler can also write inUse,
  1028  		// but will always restore its value, so we can use a regular increment
  1029  		// even if we get signaled in the middle of it.
  1030  		cache.inUse++
  1031  		if cache.inUse == 1 {
  1032  			for i := range cache.entries[ck] {
  1033  				// We check off first because we're more
  1034  				// likely to have multiple entries with
  1035  				// different offsets for the same targetpc
  1036  				// than the other way around, so we'll usually
  1037  				// fail in the first clause.
  1038  				ent := &cache.entries[ck][i]
  1039  				if ent.off == off && ent.targetpc == targetpc {
  1040  					val, pc := ent.val, ent.valPC
  1041  					if debugCheckCache {
  1042  						checkVal, checkPC = ent.val, ent.valPC
  1043  						break
  1044  					} else {
  1045  						cache.inUse--
  1046  						releasem(mp)
  1047  						return val, pc
  1048  					}
  1049  				}
  1050  			}
  1051  		} else if debugCheckCache && (cache.inUse < 1 || cache.inUse > 2) {
  1052  			// Catch accounting errors or deeply reentrant use. In principle
  1053  			// "inUse" should never exceed 2.
  1054  			throw("cache.inUse out of range")
  1055  		}
  1056  		cache.inUse--
  1057  		releasem(mp)
  1058  	}
  1059  
  1060  	if !f.valid() {
  1061  		if strict && panicking.Load() == 0 {
  1062  			println("runtime: no module data for", hex(f.entry()))
  1063  			throw("no module data")
  1064  		}
  1065  		return -1, 0
  1066  	}
  1067  	datap := f.datap
  1068  	p := datap.pctab[off:]
  1069  	pc := f.entry()
  1070  	prevpc := pc
  1071  	val := int32(-1)
  1072  	for {
  1073  		var ok bool
  1074  		p, ok = step(p, &pc, &val, pc == f.entry())
  1075  		if !ok {
  1076  			break
  1077  		}
  1078  		if targetpc < pc {
  1079  			// Replace a random entry in the cache. Random
  1080  			// replacement prevents a performance cliff if
  1081  			// a recursive stack's cycle is slightly
  1082  			// larger than the cache.
  1083  			// Put the new element at the beginning,
  1084  			// since it is the most likely to be newly used.
  1085  			if debugCheckCache && checkPC != 0 {
  1086  				if checkVal != val || checkPC != prevpc {
  1087  					print("runtime: table value ", val, "@", prevpc, " != cache value ", checkVal, "@", checkPC, " at PC ", targetpc, " off ", off, "\n")
  1088  					throw("bad pcvalue cache")
  1089  				}
  1090  			} else {
  1091  				mp := acquirem()
  1092  				cache := &mp.pcvalueCache
  1093  				cache.inUse++
  1094  				if cache.inUse == 1 {
  1095  					e := &cache.entries[ck]
  1096  					ci := cheaprandn(uint32(len(cache.entries[ck])))
  1097  					e[ci] = e[0]
  1098  					e[0] = pcvalueCacheEnt{
  1099  						targetpc: targetpc,
  1100  						off:      off,
  1101  						val:      val,
  1102  						valPC:    prevpc,
  1103  					}
  1104  				}
  1105  				cache.inUse--
  1106  				releasem(mp)
  1107  			}
  1108  
  1109  			return val, prevpc
  1110  		}
  1111  		prevpc = pc
  1112  	}
  1113  
  1114  	// If there was a table, it should have covered all program counters.
  1115  	// If not, something is wrong.
  1116  	if panicking.Load() != 0 || !strict {
  1117  		return -1, 0
  1118  	}
  1119  
  1120  	print("runtime: invalid pc-encoded table f=", funcname(f), " pc=", hex(pc), " targetpc=", hex(targetpc), " tab=", p, "\n")
  1121  
  1122  	p = datap.pctab[off:]
  1123  	pc = f.entry()
  1124  	val = -1
  1125  	for {
  1126  		var ok bool
  1127  		p, ok = step(p, &pc, &val, pc == f.entry())
  1128  		if !ok {
  1129  			break
  1130  		}
  1131  		print("\tvalue=", val, " until pc=", hex(pc), "\n")
  1132  	}
  1133  
  1134  	throw("invalid runtime symbol table")
  1135  	return -1, 0
  1136  }
  1137  
  1138  func funcname(f funcInfo) string {
  1139  	if !f.valid() {
  1140  		return ""
  1141  	}
  1142  	return f.datap.funcName(f.nameOff)
  1143  }
  1144  
  1145  func funcpkgpath(f funcInfo) string {
  1146  	name := funcNameForPrint(funcname(f))
  1147  	i := len(name) - 1
  1148  	for ; i > 0; i-- {
  1149  		if name[i] == '/' {
  1150  			break
  1151  		}
  1152  	}
  1153  	for ; i < len(name); i++ {
  1154  		if name[i] == '.' {
  1155  			break
  1156  		}
  1157  	}
  1158  	return name[:i]
  1159  }
  1160  
  1161  func funcfile(f funcInfo, fileno int32) string {
  1162  	datap := f.datap
  1163  	if !f.valid() {
  1164  		return "?"
  1165  	}
  1166  	// Make sure the cu index and file offset are valid
  1167  	if fileoff := datap.cutab[f.cuOffset+uint32(fileno)]; fileoff != ^uint32(0) {
  1168  		return gostringnocopy(&datap.filetab[fileoff])
  1169  	}
  1170  	// pcln section is corrupt.
  1171  	return "?"
  1172  }
  1173  
  1174  // funcline1 should be an internal detail,
  1175  // but widely used packages access it using linkname.
  1176  // Notable members of the hall of shame include:
  1177  //   - github.com/phuslu/log
  1178  //
  1179  // Do not remove or change the type signature.
  1180  // See go.dev/issue/67401.
  1181  //
  1182  //go:linkname funcline1
  1183  func funcline1(f funcInfo, targetpc uintptr, strict bool) (file string, line int32) {
  1184  	datap := f.datap
  1185  	if !f.valid() {
  1186  		return "?", 0
  1187  	}
  1188  	fileno, _ := pcvalue(f, f.pcfile, targetpc, strict)
  1189  	line, _ = pcvalue(f, f.pcln, targetpc, strict)
  1190  	if fileno == -1 || line == -1 || int(fileno) >= len(datap.filetab) {
  1191  		// print("looking for ", hex(targetpc), " in ", funcname(f), " got file=", fileno, " line=", lineno, "\n")
  1192  		return "?", 0
  1193  	}
  1194  	file = funcfile(f, fileno)
  1195  	return
  1196  }
  1197  
  1198  func funcline(f funcInfo, targetpc uintptr) (file string, line int32) {
  1199  	return funcline1(f, targetpc, true)
  1200  }
  1201  
  1202  func funcspdelta(f funcInfo, targetpc uintptr) int32 {
  1203  	x, _ := pcvalue(f, f.pcsp, targetpc, true)
  1204  	if debugPcln && x&(goarch.PtrSize-1) != 0 {
  1205  		print("invalid spdelta ", funcname(f), " ", hex(f.entry()), " ", hex(targetpc), " ", hex(f.pcsp), " ", x, "\n")
  1206  		throw("bad spdelta")
  1207  	}
  1208  	return x
  1209  }
  1210  
  1211  // funcMaxSPDelta returns the maximum spdelta at any point in f.
  1212  func funcMaxSPDelta(f funcInfo) int32 {
  1213  	datap := f.datap
  1214  	p := datap.pctab[f.pcsp:]
  1215  	pc := f.entry()
  1216  	val := int32(-1)
  1217  	most := int32(0)
  1218  	for {
  1219  		var ok bool
  1220  		p, ok = step(p, &pc, &val, pc == f.entry())
  1221  		if !ok {
  1222  			return most
  1223  		}
  1224  		most = max(most, val)
  1225  	}
  1226  }
  1227  
  1228  func pcdatastart(f funcInfo, table uint32) uint32 {
  1229  	return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
  1230  }
  1231  
  1232  func pcdatavalue(f funcInfo, table uint32, targetpc uintptr) int32 {
  1233  	if table >= f.npcdata {
  1234  		return -1
  1235  	}
  1236  	r, _ := pcvalue(f, pcdatastart(f, table), targetpc, true)
  1237  	return r
  1238  }
  1239  
  1240  func pcdatavalue1(f funcInfo, table uint32, targetpc uintptr, strict bool) int32 {
  1241  	if table >= f.npcdata {
  1242  		return -1
  1243  	}
  1244  	r, _ := pcvalue(f, pcdatastart(f, table), targetpc, strict)
  1245  	return r
  1246  }
  1247  
  1248  // Like pcdatavalue, but also return the start PC of this PCData value.
  1249  func pcdatavalue2(f funcInfo, table uint32, targetpc uintptr) (int32, uintptr) {
  1250  	if table >= f.npcdata {
  1251  		return -1, 0
  1252  	}
  1253  	return pcvalue(f, pcdatastart(f, table), targetpc, true)
  1254  }
  1255  
  1256  // funcdata returns a pointer to the ith funcdata for f.
  1257  // funcdata should be kept in sync with cmd/link:writeFuncs.
  1258  func funcdata(f funcInfo, i uint8) unsafe.Pointer {
  1259  	if i < 0 || i >= f.nfuncdata {
  1260  		return nil
  1261  	}
  1262  	base := f.datap.gofunc // load gofunc address early so that we calculate during cache misses
  1263  	p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4
  1264  	off := *(*uint32)(unsafe.Pointer(p))
  1265  	// Return off == ^uint32(0) ? 0 : f.datap.gofunc + uintptr(off), but without branches.
  1266  	// The compiler calculates mask on most architectures using conditional assignment.
  1267  	var mask uintptr
  1268  	if off == ^uint32(0) {
  1269  		mask = 1
  1270  	}
  1271  	mask--
  1272  	raw := base + uintptr(off)
  1273  	return unsafe.Pointer(raw & mask)
  1274  }
  1275  
  1276  // step advances to the next pc, value pair in the encoded table.
  1277  func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) {
  1278  	// For both uvdelta and pcdelta, the common case (~70%)
  1279  	// is that they are a single byte. If so, avoid calling readvarint.
  1280  	uvdelta := uint32(p[0])
  1281  	if uvdelta == 0 && !first {
  1282  		return nil, false
  1283  	}
  1284  	n := uint32(1)
  1285  	if uvdelta&0x80 != 0 {
  1286  		n, uvdelta = readvarint(p)
  1287  	}
  1288  	*val += int32(-(uvdelta & 1) ^ (uvdelta >> 1))
  1289  	p = p[n:]
  1290  
  1291  	pcdelta := uint32(p[0])
  1292  	n = 1
  1293  	if pcdelta&0x80 != 0 {
  1294  		n, pcdelta = readvarint(p)
  1295  	}
  1296  	p = p[n:]
  1297  	*pc += uintptr(pcdelta * sys.PCQuantum)
  1298  	return p, true
  1299  }
  1300  
  1301  // readvarint reads a varint from p.
  1302  func readvarint(p []byte) (read uint32, val uint32) {
  1303  	var v, shift, n uint32
  1304  	for {
  1305  		b := p[n]
  1306  		n++
  1307  		v |= uint32(b&0x7F) << (shift & 31)
  1308  		if b&0x80 == 0 {
  1309  			break
  1310  		}
  1311  		shift += 7
  1312  	}
  1313  	return n, v
  1314  }
  1315  
  1316  type stackmap struct {
  1317  	n        int32   // number of bitmaps
  1318  	nbit     int32   // number of bits in each bitmap
  1319  	bytedata [1]byte // bitmaps, each starting on a byte boundary
  1320  }
  1321  
  1322  //go:nowritebarrier
  1323  func stackmapdata(stkmap *stackmap, n int32) bitvector {
  1324  	// Check this invariant only when stackDebug is on at all.
  1325  	// The invariant is already checked by many of stackmapdata's callers,
  1326  	// and disabling it by default allows stackmapdata to be inlined.
  1327  	if stackDebug > 0 && (n < 0 || n >= stkmap.n) {
  1328  		throw("stackmapdata: index out of range")
  1329  	}
  1330  	return bitvector{stkmap.nbit, addb(&stkmap.bytedata[0], uintptr(n*((stkmap.nbit+7)>>3)))}
  1331  }
  1332  

View as plain text