runtime: consolidate stkframe and its methods into stkframe.go

The stkframe struct and its methods are strewn across different source
files. Since they actually have a pretty coherent theme at this point,
migrate it all into a new file, stkframe.go. There are no code changes
in this CL.

For #54466, albeit rather indirectly.

Change-Id: Ibe53fc4b1106d131005e1c9d491be838a8f14211
Reviewed-on: https://go-review.googlesource.com/c/go/+/424516
Reviewed-by: Michael Pratt <[email protected]>
Reviewed-by: Cherry Mui <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Austin Clements <[email protected]>
Auto-Submit: Austin Clements <[email protected]>

Author: aclements

src/runtime/runtime2.go

@@ -985,55 +985,6 @@ type _panic struct {
 	goexit    bool
 }
 
-// A stkframe holds information about a single physical stack frame.
-type stkframe struct {
-	// fn is the function being run in this frame. If there is
-	// inlining, this is the outermost function.
-	fn funcInfo
-
-	// pc is the program counter within fn.
-	//
-	// The meaning of this is subtle:
-	//
-	// - Typically, this frame performed a regular function call
-	//   and this is the return PC (just after the CALL
-	//   instruction). In this case, pc-1 reflects the CALL
-	//   instruction itself and is the correct source of symbolic
-	//   information.
-	//
-	// - If this frame "called" sigpanic, then pc is the
-	//   instruction that panicked, and pc is the correct address
-	//   to use for symbolic information.
-	//
-	// - If this is the innermost frame, then PC is where
-	//   execution will continue, but it may not be the
-	//   instruction following a CALL. This may be from
-	//   cooperative preemption, in which case this is the
-	//   instruction after the call to morestack. Or this may be
-	//   from a signal or an un-started goroutine, in which case
-	//   PC could be any instruction, including the first
-	//   instruction in a function. Conventionally, we use pc-1
-	//   for symbolic information, unless pc == fn.entry(), in
-	//   which case we use pc.
-	pc uintptr
-
-	// continpc is the PC where execution will continue in fn, or
-	// 0 if execution will not continue in this frame.
-	//
-	// This is usually the same as pc, unless this frame "called"
-	// sigpanic, in which case it's either the address of
-	// deferreturn or 0 if this frame will never execute again.
-	//
-	// This is the PC to use to look up GC liveness for this frame.
-	continpc uintptr
-
-	lr   uintptr // program counter at caller aka link register
-	sp   uintptr // stack pointer at pc
-	fp   uintptr // stack pointer at caller aka frame pointer
-	varp uintptr // top of local variables
-	argp uintptr // pointer to function arguments
-}
-
 // ancestorInfo records details of where a goroutine was started.
 type ancestorInfo struct {
 	pcs  []uintptr // pcs from the stack of this goroutine

src/runtime/stack.go

@@ -1247,142 +1247,6 @@ func freeStackSpans() {
 	unlock(&stackLarge.lock)
 }
 
-// getStackMap returns the locals and arguments live pointer maps, and
-// stack object list for frame.
-func (frame *stkframe) getStackMap(cache *pcvalueCache, debug bool) (locals, args bitvector, objs []stackObjectRecord) {
-	targetpc := frame.continpc
-	if targetpc == 0 {
-		// Frame is dead. Return empty bitvectors.
-		return
-	}
-
-	f := frame.fn
-	pcdata := int32(-1)
-	if targetpc != f.entry() {
-		// Back up to the CALL. If we're at the function entry
-		// point, we want to use the entry map (-1), even if
-		// the first instruction of the function changes the
-		// stack map.
-		targetpc--
-		pcdata = pcdatavalue(f, _PCDATA_StackMapIndex, targetpc, cache)
-	}
-	if pcdata == -1 {
-		// We do not have a valid pcdata value but there might be a
-		// stackmap for this function. It is likely that we are looking
-		// at the function prologue, assume so and hope for the best.
-		pcdata = 0
-	}
-
-	// Local variables.
-	size := frame.varp - frame.sp
-	var minsize uintptr
-	switch goarch.ArchFamily {
-	case goarch.ARM64:
-		minsize = sys.StackAlign
-	default:
-		minsize = sys.MinFrameSize
-	}
-	if size > minsize {
-		stackid := pcdata
-		stkmap := (*stackmap)(funcdata(f, _FUNCDATA_LocalsPointerMaps))
-		if stkmap == nil || stkmap.n <= 0 {
-			print("runtime: frame ", funcname(f), " untyped locals ", hex(frame.varp-size), "+", hex(size), "\n")
-			throw("missing stackmap")
-		}
-		// If nbit == 0, there's no work to do.
-		if stkmap.nbit > 0 {
-			if stackid < 0 || stackid >= stkmap.n {
-				// don't know where we are
-				print("runtime: pcdata is ", stackid, " and ", stkmap.n, " locals stack map entries for ", funcname(f), " (targetpc=", hex(targetpc), ")\n")
-				throw("bad symbol table")
-			}
-			locals = stackmapdata(stkmap, stackid)
-			if stackDebug >= 3 && debug {
-				print("      locals ", stackid, "/", stkmap.n, " ", locals.n, " words ", locals.bytedata, "\n")
-			}
-		} else if stackDebug >= 3 && debug {
-			print("      no locals to adjust\n")
-		}
-	}
-
-	// Arguments. First fetch frame size and special-case argument maps.
-	var isReflect bool
-	args, isReflect = frame.argMapInternal()
-	if args.n > 0 && args.bytedata == nil {
-		// Non-empty argument frame, but not a special map.
-		// Fetch the argument map at pcdata.
-		stackmap := (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))
-		if stackmap == nil || stackmap.n <= 0 {
-			print("runtime: frame ", funcname(f), " untyped args ", hex(frame.argp), "+", hex(args.n*goarch.PtrSize), "\n")
-			throw("missing stackmap")
-		}
-		if pcdata < 0 || pcdata >= stackmap.n {
-			// don't know where we are
-			print("runtime: pcdata is ", pcdata, " and ", stackmap.n, " args stack map entries for ", funcname(f), " (targetpc=", hex(targetpc), ")\n")
-			throw("bad symbol table")
-		}
-		if stackmap.nbit == 0 {
-			args.n = 0
-		} else {
-			args = stackmapdata(stackmap, pcdata)
-		}
-	}
-
-	// stack objects.
-	if (GOARCH == "amd64" || GOARCH == "arm64" || GOARCH == "ppc64" || GOARCH == "ppc64le" || GOARCH == "riscv64") &&
-		unsafe.Sizeof(abi.RegArgs{}) > 0 && isReflect {
-		// For reflect.makeFuncStub and reflect.methodValueCall,
-		// we need to fake the stack object record.
-		// These frames contain an internal/abi.RegArgs at a hard-coded offset.
-		// This offset matches the assembly code on amd64 and arm64.
-		objs = methodValueCallFrameObjs[:]
-	} else {
-		p := funcdata(f, _FUNCDATA_StackObjects)
-		if p != nil {
-			n := *(*uintptr)(p)
-			p = add(p, goarch.PtrSize)
-			r0 := (*stackObjectRecord)(noescape(p))
-			objs = unsafe.Slice(r0, int(n))
-			// Note: the noescape above is needed to keep
-			// getStackMap from "leaking param content:
-			// frame".  That leak propagates up to getgcmask, then
-			// GCMask, then verifyGCInfo, which converts the stack
-			// gcinfo tests into heap gcinfo tests :(
-		}
-	}
-
-	return
-}
-
-var methodValueCallFrameObjs [1]stackObjectRecord // initialized in stackobjectinit
-
-func stkobjinit() {
-	var abiRegArgsEface any = abi.RegArgs{}
-	abiRegArgsType := efaceOf(&abiRegArgsEface)._type
-	if abiRegArgsType.kind&kindGCProg != 0 {
-		throw("abiRegArgsType needs GC Prog, update methodValueCallFrameObjs")
-	}
-	// Set methodValueCallFrameObjs[0].gcdataoff so that
-	// stackObjectRecord.gcdata() will work correctly with it.
-	ptr := uintptr(unsafe.Pointer(&methodValueCallFrameObjs[0]))
-	var mod *moduledata
-	for datap := &firstmoduledata; datap != nil; datap = datap.next {
-		if datap.gofunc <= ptr && ptr < datap.end {
-			mod = datap
-			break
-		}
-	}
-	if mod == nil {
-		throw("methodValueCallFrameObjs is not in a module")
-	}
-	methodValueCallFrameObjs[0] = stackObjectRecord{
-		off:       -int32(alignUp(abiRegArgsType.size, 8)), // It's always the highest address local.
-		size:      int32(abiRegArgsType.size),
-		_ptrdata:  int32(abiRegArgsType.ptrdata),
-		gcdataoff: uint32(uintptr(unsafe.Pointer(abiRegArgsType.gcdata)) - mod.rodata),
-	}
-}
-
 // A stackObjectRecord is generated by the compiler for each stack object in a stack frame.
 // This record must match the generator code in cmd/compile/internal/liveness/plive.go:emitStackObjects.
 type stackObjectRecord struct {