symtab.go 25.6 KB
Newer Older
1 2 3 4 5 6
// 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

7
import (
8
	"runtime/internal/atomic"
9 10 11
	"runtime/internal/sys"
	"unsafe"
)
12

13 14 15
// Frames may be used to get function/file/line information for a
// slice of PC values returned by Callers.
type Frames struct {
16
	// callers is a slice of PCs that have not yet been expanded to frames.
17 18
	callers []uintptr

19 20 21
	// frames is a slice of Frames that have yet to be returned.
	frames     []Frame
	frameStore [2]Frame
22 23 24 25
}

// Frame is the information returned by Frames for each call frame.
type Frame struct {
26 27 28 29 30
	// 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.
31 32
	PC uintptr

33 34
	// Func is the Func value of this call frame. This may be nil
	// for non-Go code or fully inlined functions.
35 36
	Func *Func

37 38 39 40
	// 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.
41 42 43
	// If Func is not nil then Function == Func.Name().
	Function string

44 45 46 47 48 49 50 51 52 53
	// 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

	// Entry point program counter for the function; may be zero
	// if not known. If Func is not nil then Entry ==
	// Func.Entry().
54 55 56 57 58 59 60
	Entry uintptr
}

// 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 {
61 62 63
	f := &Frames{callers: callers}
	f.frames = f.frameStore[:0]
	return f
64 65 66 67 68
}

// Next returns frame information for the next caller.
// If more is false, there are no more callers (the Frame value is valid).
func (ci *Frames) Next() (frame Frame, more bool) {
69 70 71 72 73 74
	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
75
		}
76 77 78 79 80 81 82 83 84
		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)...)
85
			}
86
			continue
87
		}
88 89
		f := funcInfo._Func()
		entry := f.Entry()
90 91 92 93 94 95 96
		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--
		}
97 98 99 100 101 102 103 104 105 106 107 108
		name := funcname(funcInfo)
		file, line := funcline1(funcInfo, pc, false)
		if inldata := funcdata(funcInfo, _FUNCDATA_InlTree); inldata != nil {
			inltree := (*[1 << 20]inlinedCall)(inldata)
			ix := pcdatavalue(funcInfo, _PCDATA_InlTreeIndex, pc, nil)
			if ix >= 0 {
				// Note: entry is not modified. It always refers to a real frame, not an inlined one.
				f = nil
				name = funcnameFromNameoff(funcInfo, inltree[ix].func_)
				// File/line is already correct.
				// TODO: remove file/line from InlinedCall?
			}
109
		}
110 111 112 113 114 115 116 117
		ci.frames = append(ci.frames, Frame{
			PC:       pc,
			Func:     f,
			Function: name,
			File:     file,
			Line:     int(line),
			Entry:    entry,
		})
118 119
	}

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	// 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{}.
	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
	return
137 138
}

139 140
// expandCgoFrames expands frame information for pc, known to be
// a non-Go function, using the cgoSymbolizer hook. expandCgoFrames
141 142
// returns nil if pc could not be expanded.
func expandCgoFrames(pc uintptr) []Frame {
143 144 145 146 147
	arg := cgoSymbolizerArg{pc: pc}
	callCgoSymbolizer(&arg)

	if arg.file == nil && arg.funcName == nil {
		// No useful information from symbolizer.
148
		return nil
149 150
	}

151
	var frames []Frame
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	for {
		frames = append(frames, Frame{
			PC:       pc,
			Func:     nil,
			Function: gostring(arg.funcName),
			File:     gostring(arg.file),
			Line:     int(arg.lineno),
			Entry:    arg.entry,
		})
		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)

174
	return frames
175 176
}

177 178 179
// 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{}.
180 181
// All code operating on a *Func must call raw() to get the *_func
// or funcInfo() to get the funcInfo instead.
182

183 184 185 186 187 188 189 190 191
// 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))
}

192 193 194 195 196
func (f *Func) funcInfo() funcInfo {
	fn := f.raw()
	return funcInfo{fn, findmoduledatap(fn.entry)}
}

197 198
// PCDATA and FUNCDATA table indexes.
//
199
// See funcdata.h and ../cmd/internal/objabi/funcdata.go.
200
const (
201
	_PCDATA_StackMapIndex       = 0
202
	_PCDATA_InlTreeIndex        = 1
203
	_PCDATA_RegMapIndex         = 2
204 205
	_FUNCDATA_ArgsPointerMaps   = 0
	_FUNCDATA_LocalsPointerMaps = 1
206
	_FUNCDATA_InlTree           = 2
207
	_FUNCDATA_RegPointerMaps    = 3
208
	_FUNCDATA_StackObjects      = 4
209 210 211
	_ArgsSizeUnknown            = -0x80000000
)

212 213 214 215 216
// A FuncID identifies particular functions that need to be treated
// specially by the runtime.
// Note that in some situations involving plugins, there may be multiple
// copies of a particular special runtime function.
// Note: this list must match the list in cmd/internal/objabi/funcid.go.
217
type funcID uint8
218 219 220

const (
	funcID_normal funcID = iota // not a special function
221
	funcID_runtime_main
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
	funcID_goexit
	funcID_jmpdefer
	funcID_mcall
	funcID_morestack
	funcID_mstart
	funcID_rt0_go
	funcID_asmcgocall
	funcID_sigpanic
	funcID_runfinq
	funcID_gcBgMarkWorker
	funcID_systemstack_switch
	funcID_systemstack
	funcID_cgocallback_gofunc
	funcID_gogo
	funcID_externalthreadhandler
237
	funcID_debugCallV1
238 239 240
	funcID_gopanic
	funcID_panicwrap
	funcID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
241 242
)

243 244 245
// 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/internal/ld/symtab.go:symtab.
246 247
// moduledata is stored in statically allocated non-pointer memory;
// none of the pointers here are visible to the garbage collector.
248
type moduledata struct {
249 250 251 252 253
	pclntable    []byte
	ftab         []functab
	filetab      []uint32
	findfunctab  uintptr
	minpc, maxpc uintptr
254 255 256 257 258 259 260

	text, etext           uintptr
	noptrdata, enoptrdata uintptr
	data, edata           uintptr
	bss, ebss             uintptr
	noptrbss, enoptrbss   uintptr
	end, gcdata, gcbss    uintptr
261
	types, etypes         uintptr
262

263 264 265
	textsectmap []textsect
	typelinks   []int32 // offsets from types
	itablinks   []*itab
266

267 268
	ptab []ptabEntry

269 270 271
	pluginpath string
	pkghashes  []modulehash

272 273 274
	modulename   string
	modulehashes []modulehash

275 276
	hasmain uint8 // 1 if module contains the main function, 0 otherwise

277 278
	gcdatamask, gcbssmask bitvector

279 280
	typemap map[typeOff]*_type // offset to *_rtype in previous module

281 282
	bad bool // module failed to load and should be ignored

283
	next *moduledata
284
}
285

286 287 288
// A modulehash is used to compare the ABI of a new module or a
// package in a new module with the loaded program.
//
289 290 291 292
// 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.
293
//
294
// For each loaded plugin, the pkghashes slice has a modulehash of the
295 296 297
// 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.
298 299 300 301 302 303
type modulehash struct {
	modulename   string
	linktimehash string
	runtimehash  *string
}

304 305 306 307 308 309 310 311 312
// 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

313 314
var firstmoduledata moduledata  // linker symbol
var lastmoduledatap *moduledata // linker symbol
315
var modulesSlice *[]*moduledata // see activeModules
316 317 318 319 320

// 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.
321 322 323 324 325
//
// This is nosplit/nowritebarrier because it is called by the
// cgo pointer checking code.
//go:nosplit
//go:nowritebarrier
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
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 {
355 356 357
		if md.bad {
			continue
		}
358
		*modules = append(*modules, md)
359
		if md.gcdatamask == (bitvector{}) {
360 361 362 363
			md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), md.edata-md.data)
			md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), md.ebss-md.bss)
		}
	}
364 365 366 367 368 369 370 371 372 373 374

	// 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 {
375
		if md.hasmain != 0 {
376 377 378 379 380 381
			(*modules)[0] = md
			(*modules)[i] = &firstmoduledata
			break
		}
	}

382 383
	atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
}
384 385 386 387 388 389

type functab struct {
	entry   uintptr
	funcoff uintptr
}

390 391 392 393 394 395 396 397
// Mapping information for secondary text sections

type textsect struct {
	vaddr    uintptr // prelinked section vaddr
	length   uintptr // section length
	baseaddr uintptr // relocated section address
}

398 399
const minfunc = 16                 // minimum function size
const pcbucketsize = 256 * minfunc // size of bucket in the pc->func lookup table
400 401 402 403 404

// findfunctab 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
405 406
// that pc. Add together the idx and subbucket value to obtain a
// function index. Then scan the functab array starting at that
407 408 409
// index to find the target function.
// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
type findfuncbucket struct {
410
	idx        uint32
411 412 413
	subbuckets [16]byte
}

414 415 416 417 418 419
func moduledataverify() {
	for datap := &firstmoduledata; datap != nil; datap = datap.next {
		moduledataverify1(datap)
	}
}

420 421
const debugPcln = false

422
func moduledataverify1(datap *moduledata) {
423 424 425
	// See golang.org/s/go12symtab for header: 0xfffffffb,
	// two zero bytes, a byte giving the PC quantum,
	// and a byte giving the pointer width in bytes.
426 427
	pcln := *(**[8]byte)(unsafe.Pointer(&datap.pclntable))
	pcln32 := *(**[2]uint32)(unsafe.Pointer(&datap.pclntable))
428
	if pcln32[0] != 0xfffffffb || pcln[4] != 0 || pcln[5] != 0 || pcln[6] != sys.PCQuantum || pcln[7] != sys.PtrSize {
429
		println("runtime: function symbol table header:", hex(pcln32[0]), hex(pcln[4]), hex(pcln[5]), hex(pcln[6]), hex(pcln[7]))
430
		throw("invalid function symbol table\n")
431 432
	}

433
	// ftab is lookup table for function by program counter.
434
	nftab := len(datap.ftab) - 1
435 436
	for i := 0; i < nftab; i++ {
		// NOTE: ftab[nftab].entry is legal; it is the address beyond the final function.
437
		if datap.ftab[i].entry > datap.ftab[i+1].entry {
438 439
			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}
440 441
			f2name := "end"
			if i+1 < nftab {
442
				f2name = funcname(f2)
443
			}
444
			println("function symbol table not sorted by program counter:", hex(datap.ftab[i].entry), funcname(f1), ">", hex(datap.ftab[i+1].entry), f2name)
445
			for j := 0; j <= i; j++ {
446
				print("\t", hex(datap.ftab[j].entry), " ", funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}), "\n")
447
			}
448 449 450
			if GOOS == "aix" && isarchive {
				println("-Wl,-bnoobjreorder is mandatory on aix/ppc64 with c-archive")
			}
451
			throw("invalid runtime symbol table")
452 453 454
		}
	}

455 456
	if datap.minpc != datap.ftab[0].entry ||
		datap.maxpc != datap.ftab[nftab].entry {
457 458
		throw("minpc or maxpc invalid")
	}
459 460 461 462 463 464 465

	for _, modulehash := range datap.modulehashes {
		if modulehash.linktimehash != *modulehash.runtimehash {
			println("abi mismatch detected between", datap.modulename, "and", modulehash.modulename)
			throw("abi mismatch")
		}
	}
466 467 468 469
}

// FuncForPC returns a *Func describing the function that contains the
// given program counter address, or else nil.
470 471
//
// If pc represents multiple functions because of inlining, it returns
472 473
// the a *Func describing the innermost function, but with an entry
// of the outermost function.
474
func FuncForPC(pc uintptr) *Func {
475 476 477 478 479
	f := findfunc(pc)
	if !f.valid() {
		return nil
	}
	if inldata := funcdata(f, _FUNCDATA_InlTree); inldata != nil {
480
		// Note: strict=false so bad PCs (those between functions) don't crash the runtime.
481
		// We just report the preceding function in that situation. See issue 29735.
482 483 484
		// TODO: Perhaps we should report no function at all in that case.
		// The runtime currently doesn't have function end info, alas.
		if ix := pcdatavalue1(f, _PCDATA_InlTreeIndex, pc, nil, false); ix >= 0 {
485 486 487 488 489 490 491 492 493 494 495 496 497
			inltree := (*[1 << 20]inlinedCall)(inldata)
			name := funcnameFromNameoff(f, inltree[ix].func_)
			file, line := funcline(f, pc)
			fi := &funcinl{
				entry: f.entry, // entry of the real (the outermost) function.
				name:  name,
				file:  file,
				line:  int(line),
			}
			return (*Func)(unsafe.Pointer(fi))
		}
	}
	return f._Func()
498 499 500 501
}

// Name returns the name of the function.
func (f *Func) Name() string {
502 503 504
	if f == nil {
		return ""
	}
505 506 507 508 509
	fn := f.raw()
	if fn.entry == 0 { // inlined version
		fi := (*funcinl)(unsafe.Pointer(fn))
		return fi.name
	}
510
	return funcname(f.funcInfo())
511 512 513 514
}

// Entry returns the entry address of the function.
func (f *Func) Entry() uintptr {
515 516 517 518 519 520
	fn := f.raw()
	if fn.entry == 0 { // inlined version
		fi := (*funcinl)(unsafe.Pointer(fn))
		return fi.entry
	}
	return fn.entry
521 522 523 524 525 526 527
}

// 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) {
528 529 530 531 532
	fn := f.raw()
	if fn.entry == 0 { // inlined version
		fi := (*funcinl)(unsafe.Pointer(fn))
		return fi.file, fi.line
	}
533 534
	// Pass strict=false here, because anyone can call this function,
	// and they might just be wrong about targetpc belonging to f.
535
	file, line32 := funcline1(f.funcInfo(), pc, false)
536
	return file, int(line32)
537 538
}

539
func findmoduledatap(pc uintptr) *moduledata {
540
	for datap := &firstmoduledata; datap != nil; datap = datap.next {
541
		if datap.minpc <= pc && pc < datap.maxpc {
542 543 544 545 546 547
			return datap
		}
	}
	return nil
}

548 549 550 551 552 553 554 555 556
type funcInfo struct {
	*_func
	datap *moduledata
}

func (f funcInfo) valid() bool {
	return f._func != nil
}

557 558 559 560
func (f funcInfo) _Func() *Func {
	return (*Func)(unsafe.Pointer(f._func))
}

561
func findfunc(pc uintptr) funcInfo {
562 563
	datap := findmoduledatap(pc)
	if datap == nil {
564
		return funcInfo{}
565
	}
566
	const nsub = uintptr(len(findfuncbucket{}.subbuckets))
567

568
	x := pc - datap.minpc
569
	b := x / pcbucketsize
570
	i := x % pcbucketsize / (pcbucketsize / nsub)
571

572
	ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
573
	idx := ffb.idx + uint32(ffb.subbuckets[i])
574 575 576 577 578 579 580 581

	// If the idx is beyond the end of the ftab, set it to the end of the table and search backward.
	// This situation can occur if multiple text sections are generated to handle large text sections
	// and the linker has inserted jump tables between them.

	if idx >= uint32(len(datap.ftab)) {
		idx = uint32(len(datap.ftab) - 1)
	}
582
	if pc < datap.ftab[idx].entry {
583 584
		// With multiple text sections, the idx might reference a function address that
		// is higher than the pc being searched, so search backward until the matching address is found.
585 586 587 588 589 590 591 592 593 594 595 596

		for datap.ftab[idx].entry > pc && idx > 0 {
			idx--
		}
		if idx == 0 {
			throw("findfunc: bad findfunctab entry idx")
		}
	} else {
		// linear search to find func with pc >= entry.
		for datap.ftab[idx+1].entry <= pc {
			idx++
		}
597
	}
598
	return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[idx].funcoff])), datap}
599 600
}

601
type pcvalueCache struct {
602
	entries [2][8]pcvalueCacheEnt
603 604 605 606 607 608 609 610 611 612
}

type pcvalueCacheEnt struct {
	// targetpc and off together are the key of this cache entry.
	targetpc uintptr
	off      int32
	// val is the value of this cached pcvalue entry.
	val int32
}

613 614 615 616 617 618 619 620
// pcvalueCacheKey returns the outermost index in a pcvalueCache to use for targetpc.
// It must be very cheap to calculate.
// For now, align to sys.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 / sys.PtrSize) % uintptr(len(pcvalueCache{}.entries))
}

621
func pcvalue(f funcInfo, off int32, targetpc uintptr, cache *pcvalueCache, strict bool) int32 {
622 623 624
	if off == 0 {
		return -1
	}
625 626 627 628 629 630 631 632

	// Check the cache. This speeds up walks of deep stacks, which
	// tend to have the same recursive functions over and over.
	//
	// This cache is small enough that full associativity is
	// cheaper than doing the hashing for a less associative
	// cache.
	if cache != nil {
633 634
		x := pcvalueCacheKey(targetpc)
		for i := range cache.entries[x] {
635 636 637 638 639
			// 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.
640
			ent := &cache.entries[x][i]
641 642 643 644 645 646
			if ent.off == off && ent.targetpc == targetpc {
				return ent.val
			}
		}
	}

647
	if !f.valid() {
648 649 650 651 652 653
		if strict && panicking == 0 {
			print("runtime: no module data for ", hex(f.entry), "\n")
			throw("no module data")
		}
		return -1
	}
654
	datap := f.datap
655
	p := datap.pclntable[off:]
656 657
	pc := f.entry
	val := int32(-1)
658 659 660 661 662 663
	for {
		var ok bool
		p, ok = step(p, &pc, &val, pc == f.entry)
		if !ok {
			break
		}
664
		if targetpc < pc {
665 666 667 668
			// 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.
669 670
			// Put the new element at the beginning,
			// since it is the most likely to be newly used.
671
			if cache != nil {
672 673 674 675 676
				x := pcvalueCacheKey(targetpc)
				e := &cache.entries[x]
				ci := fastrand() % uint32(len(cache.entries[x]))
				e[ci] = e[0]
				e[0] = pcvalueCacheEnt{
677 678 679 680 681 682
					targetpc: targetpc,
					off:      off,
					val:      val,
				}
			}

683 684 685
			return val
		}
	}
686 687 688 689 690 691 692

	// If there was a table, it should have covered all program counters.
	// If not, something is wrong.
	if panicking != 0 || !strict {
		return -1
	}

693
	print("runtime: invalid pc-encoded table f=", funcname(f), " pc=", hex(pc), " targetpc=", hex(targetpc), " tab=", p, "\n")
694

695
	p = datap.pclntable[off:]
696 697 698 699 700 701 702 703 704 705 706
	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")
	}

707
	throw("invalid runtime symbol table")
708 709 710
	return -1
}

711 712
func cfuncname(f funcInfo) *byte {
	if !f.valid() || f.nameoff == 0 {
713 714
		return nil
	}
715
	return &f.datap.pclntable[f.nameoff]
716 717
}

718
func funcname(f funcInfo) string {
719
	return gostringnocopy(cfuncname(f))
720 721
}

722 723 724
func funcnameFromNameoff(f funcInfo, nameoff int32) string {
	datap := f.datap
	if !f.valid() {
725 726 727 728 729 730
		return ""
	}
	cstr := &datap.pclntable[nameoff]
	return gostringnocopy(cstr)
}

731 732 733
func funcfile(f funcInfo, fileno int32) string {
	datap := f.datap
	if !f.valid() {
734 735 736 737 738
		return "?"
	}
	return gostringnocopy(&datap.pclntable[datap.filetab[fileno]])
}

739 740 741
func funcline1(f funcInfo, targetpc uintptr, strict bool) (file string, line int32) {
	datap := f.datap
	if !f.valid() {
742 743
		return "?", 0
	}
744 745
	fileno := int(pcvalue(f, f.pcfile, targetpc, nil, strict))
	line = pcvalue(f, f.pcln, targetpc, nil, strict)
746
	if fileno == -1 || line == -1 || fileno >= len(datap.filetab) {
747
		// print("looking for ", hex(targetpc), " in ", funcname(f), " got file=", fileno, " line=", lineno, "\n")
748
		return "?", 0
749
	}
750
	file = gostringnocopy(&datap.pclntable[datap.filetab[fileno]])
751
	return
752 753
}

754
func funcline(f funcInfo, targetpc uintptr) (file string, line int32) {
755
	return funcline1(f, targetpc, true)
756 757
}

758
func funcspdelta(f funcInfo, targetpc uintptr, cache *pcvalueCache) int32 {
759
	x := pcvalue(f, f.pcsp, targetpc, cache, true)
760
	if x&(sys.PtrSize-1) != 0 {
761
		print("invalid spdelta ", funcname(f), " ", hex(f.entry), " ", hex(targetpc), " ", hex(f.pcsp), " ", x, "\n")
762 763 764 765
	}
	return x
}

766 767 768 769
func pcdatastart(f funcInfo, table int32) int32 {
	return *(*int32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
}

770
func pcdatavalue(f funcInfo, table int32, targetpc uintptr, cache *pcvalueCache) int32 {
771 772 773
	if table < 0 || table >= f.npcdata {
		return -1
	}
774 775 776 777 778 779 780 781
	return pcvalue(f, pcdatastart(f, table), targetpc, cache, true)
}

func pcdatavalue1(f funcInfo, table int32, targetpc uintptr, cache *pcvalueCache, strict bool) int32 {
	if table < 0 || table >= f.npcdata {
		return -1
	}
	return pcvalue(f, pcdatastart(f, table), targetpc, cache, strict)
782 783
}

784
func funcdata(f funcInfo, i uint8) unsafe.Pointer {
785 786 787 788
	if i < 0 || i >= f.nfuncdata {
		return nil
	}
	p := add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(f.npcdata)*4)
789
	if sys.PtrSize == 8 && uintptr(p)&4 != 0 {
790 791
		if uintptr(unsafe.Pointer(f._func))&4 != 0 {
			println("runtime: misaligned func", f._func)
792 793 794
		}
		p = add(p, 4)
	}
795
	return *(*unsafe.Pointer)(add(p, uintptr(i)*sys.PtrSize))
796 797
}

798
// step advances to the next pc, value pair in the encoded table.
799
func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) {
800 801 802
	// 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])
803
	if uvdelta == 0 && !first {
804
		return nil, false
805
	}
806 807 808 809
	n := uint32(1)
	if uvdelta&0x80 != 0 {
		n, uvdelta = readvarint(p)
	}
810
	*val += int32(-(uvdelta & 1) ^ (uvdelta >> 1))
811
	p = p[n:]
812

813 814 815 816 817 818
	pcdelta := uint32(p[0])
	n = 1
	if pcdelta&0x80 != 0 {
		n, pcdelta = readvarint(p)
	}
	p = p[n:]
819
	*pc += uintptr(pcdelta * sys.PCQuantum)
820
	return p, true
821 822
}

823
// readvarint reads a varint from p.
824 825
func readvarint(p []byte) (read uint32, val uint32) {
	var v, shift, n uint32
826
	for {
827 828 829
		b := p[n]
		n++
		v |= uint32(b&0x7F) << (shift & 31)
830 831 832 833 834
		if b&0x80 == 0 {
			break
		}
		shift += 7
	}
835
	return n, v
836
}
Russ Cox's avatar
Russ Cox committed
837 838 839 840

type stackmap struct {
	n        int32   // number of bitmaps
	nbit     int32   // number of bits in each bitmap
841
	bytedata [1]byte // bitmaps, each starting on a byte boundary
Russ Cox's avatar
Russ Cox committed
842 843 844 845
}

//go:nowritebarrier
func stackmapdata(stkmap *stackmap, n int32) bitvector {
846 847 848 849
	// 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) {
Russ Cox's avatar
Russ Cox committed
850 851
		throw("stackmapdata: index out of range")
	}
852
	return bitvector{stkmap.nbit, addb(&stkmap.bytedata[0], uintptr(n*((stkmap.nbit+7)>>3)))}
Russ Cox's avatar
Russ Cox committed
853
}
854 855 856

// inlinedCall is the encoding of entries in the FUNCDATA_InlTree table.
type inlinedCall struct {
857 858 859 860 861 862 863
	parent   int16  // index of parent in the inltree, or < 0
	funcID   funcID // type of the called function
	_        byte
	file     int32 // fileno index into filetab
	line     int32 // line number of the call site
	func_    int32 // offset into pclntab for name of called function
	parentPc int32 // position of an instruction whose source position is the call site (offset from entry)
864
}