From 7843ca83e7c8229f4fdca22949428a2418f45138 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 17 Apr 2023 16:50:00 -0400 Subject: [PATCH] internal/abi, runtime, cmd: merge PCDATA_* and FUNCDATA_* consts into internal/abi We also rename the constants related to unsafe-points: currently, they follow the same naming scheme as the PCDATA table indexes, but are not PCDATA table indexes. For #59670. Change-Id: I06529fecfae535be5fe7d9ac56c886b9106c74fd Reviewed-on: https://go-review.googlesource.com/c/go/+/485497 Run-TryBot: Austin Clements Reviewed-by: David Chase TryBot-Result: Gopher Robot Auto-Submit: Austin Clements Reviewed-by: Cherry Mui --- src/cmd/asm/internal/asm/asm.go | 4 +- src/cmd/compile/internal/liveness/arg.go | 4 +- src/cmd/compile/internal/liveness/plive.go | 9 ++-- src/cmd/compile/internal/objw/prog.go | 10 ++--- src/cmd/compile/internal/ssagen/ssa.go | 13 +++--- src/cmd/dist/buildtool.go | 2 +- src/cmd/internal/obj/plist.go | 34 +++++++-------- src/cmd/internal/obj/util.go | 4 +- src/cmd/internal/objabi/funcdata.go | 51 ---------------------- src/cmd/link/internal/ld/pcln.go | 16 +++---- src/internal/abi/symtab.go | 42 ++++++++++++++++++ src/runtime/debugcall.go | 9 ++-- src/runtime/funcdata.h | 2 +- src/runtime/heapdump.go | 7 +-- src/runtime/panic.go | 2 +- src/runtime/preempt.go | 10 ++--- src/runtime/stkframe.go | 12 ++--- src/runtime/symtab.go | 39 ----------------- src/runtime/symtabinl.go | 4 +- src/runtime/trace.go | 2 +- src/runtime/traceback.go | 6 +-- 21 files changed, 120 insertions(+), 162 deletions(-) delete mode 100644 src/cmd/internal/objabi/funcdata.go diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go index 4d0eeacc74..c04e25bb50 100644 --- a/src/cmd/asm/internal/asm/asm.go +++ b/src/cmd/asm/internal/asm/asm.go @@ -6,6 +6,7 @@ package asm import ( "fmt" + "internal/abi" "strconv" "strings" "text/scanner" @@ -16,7 +17,6 @@ import ( "cmd/internal/obj" "cmd/internal/obj/ppc64" "cmd/internal/obj/x86" - "cmd/internal/objabi" "cmd/internal/sys" ) @@ -169,7 +169,7 @@ func (p *Parser) asmText(operands [][]lex.Token) { frameSize = -frameSize } op = op[1:] - argSize := int64(objabi.ArgsSizeUnknown) + argSize := int64(abi.ArgsSizeUnknown) if len(op) > 0 { // There is an argument size. It must be a minus sign followed by a non-negative integer literal. if len(op) != 2 || op[0].ScanToken != '-' || op[1].ScanToken != scanner.Int { diff --git a/src/cmd/compile/internal/liveness/arg.go b/src/cmd/compile/internal/liveness/arg.go index abbc8c9771..6375e43ff3 100644 --- a/src/cmd/compile/internal/liveness/arg.go +++ b/src/cmd/compile/internal/liveness/arg.go @@ -6,6 +6,7 @@ package liveness import ( "fmt" + "internal/abi" "cmd/compile/internal/base" "cmd/compile/internal/bitvec" @@ -13,7 +14,6 @@ import ( "cmd/compile/internal/objw" "cmd/compile/internal/ssa" "cmd/internal/obj" - "cmd/internal/objabi" ) // Argument liveness tracking. @@ -221,7 +221,7 @@ func ArgLiveness(fn *ir.Func, f *ssa.Func, pp *objw.Progs) (blockIdx, valueIdx m //lv.print() p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_ArgLiveInfo) + p.From.SetConst(abi.FUNCDATA_ArgLiveInfo) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = lsym diff --git a/src/cmd/compile/internal/liveness/plive.go b/src/cmd/compile/internal/liveness/plive.go index 82f651a520..3314db458e 100644 --- a/src/cmd/compile/internal/liveness/plive.go +++ b/src/cmd/compile/internal/liveness/plive.go @@ -31,8 +31,9 @@ import ( "cmd/compile/internal/types" "cmd/internal/notsha256" "cmd/internal/obj" - "cmd/internal/objabi" "cmd/internal/src" + + rtabi "internal/abi" ) // OpVarDef is an annotation for the liveness analysis, marking a place @@ -1361,20 +1362,20 @@ func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs) (Map fninfo.GCArgs, fninfo.GCLocals = lv.emit() p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_ArgsPointerMaps) + p.From.SetConst(rtabi.FUNCDATA_ArgsPointerMaps) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = fninfo.GCArgs p = pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_LocalsPointerMaps) + p.From.SetConst(rtabi.FUNCDATA_LocalsPointerMaps) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = fninfo.GCLocals if x := lv.emitStackObjects(); x != nil { p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_StackObjects) + p.From.SetConst(rtabi.FUNCDATA_StackObjects) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = x diff --git a/src/cmd/compile/internal/objw/prog.go b/src/cmd/compile/internal/objw/prog.go index b5ac4dda1e..3175123e6e 100644 --- a/src/cmd/compile/internal/objw/prog.go +++ b/src/cmd/compile/internal/objw/prog.go @@ -34,8 +34,8 @@ import ( "cmd/compile/internal/base" "cmd/compile/internal/ir" "cmd/internal/obj" - "cmd/internal/objabi" "cmd/internal/src" + "internal/abi" ) var sharedProgArray = new([10000]obj.Prog) // *T instead of T to work around issue 19839 @@ -144,18 +144,18 @@ func (pp *Progs) Prog(as obj.As) *obj.Prog { idx := pp.NextLive.StackMapIndex pp.PrevLive.StackMapIndex = idx p := pp.Prog(obj.APCDATA) - p.From.SetConst(objabi.PCDATA_StackMapIndex) + p.From.SetConst(abi.PCDATA_StackMapIndex) p.To.SetConst(int64(idx)) } if pp.NextLive.IsUnsafePoint != pp.PrevLive.IsUnsafePoint { // Emit unsafe-point marker. pp.PrevLive.IsUnsafePoint = pp.NextLive.IsUnsafePoint p := pp.Prog(obj.APCDATA) - p.From.SetConst(objabi.PCDATA_UnsafePoint) + p.From.SetConst(abi.PCDATA_UnsafePoint) if pp.NextLive.IsUnsafePoint { - p.To.SetConst(objabi.PCDATA_UnsafePointUnsafe) + p.To.SetConst(abi.UnsafePointUnsafe) } else { - p.To.SetConst(objabi.PCDATA_UnsafePointSafe) + p.To.SetConst(abi.UnsafePointSafe) } } diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index d7b016f967..4907113b06 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -27,9 +27,10 @@ import ( "cmd/compile/internal/typecheck" "cmd/compile/internal/types" "cmd/internal/obj" - "cmd/internal/objabi" "cmd/internal/src" "cmd/internal/sys" + + rtabi "internal/abi" ) var ssaConfig *ssa.Config @@ -6726,7 +6727,7 @@ func emitArgInfo(e *ssafn, f *ssa.Func, pp *objw.Progs) { // Emit a funcdata pointing at the arg info data. p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_ArgInfo) + p.From.SetConst(rtabi.FUNCDATA_ArgInfo) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = x @@ -6893,7 +6894,7 @@ func emitWrappedFuncInfo(e *ssafn, pp *objw.Progs) { // Emit a funcdata pointing at the wrap info data. p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_WrapInfo) + p.From.SetConst(rtabi.FUNCDATA_WrapInfo) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = x @@ -6915,7 +6916,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) { // This function uses open-coded defers -- write out the funcdata // info that we computed at the end of genssa. p := pp.Prog(obj.AFUNCDATA) - p.From.SetConst(objabi.FUNCDATA_OpenCodedDeferInfo) + p.From.SetConst(rtabi.FUNCDATA_OpenCodedDeferInfo) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = openDeferInfo @@ -6987,7 +6988,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) { if idx, ok := argLiveBlockMap[b.ID]; ok && idx != argLiveIdx { argLiveIdx = idx p := s.pp.Prog(obj.APCDATA) - p.From.SetConst(objabi.PCDATA_ArgLiveIndex) + p.From.SetConst(rtabi.PCDATA_ArgLiveIndex) p.To.SetConst(int64(idx)) } @@ -7051,7 +7052,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) { if idx, ok := argLiveValueMap[v.ID]; ok && idx != argLiveIdx { argLiveIdx = idx p := s.pp.Prog(obj.APCDATA) - p.From.SetConst(objabi.PCDATA_ArgLiveIndex) + p.From.SetConst(rtabi.PCDATA_ArgLiveIndex) p.To.SetConst(int64(idx)) } diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index c88e01c3de..815f944fe2 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -307,7 +307,7 @@ func bootstrapFixImports(srcFile string) string { continue } if strings.HasPrefix(line, `import "`) || strings.HasPrefix(line, `import . "`) || - inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"") || strings.HasPrefix(line, "\texec \"")) { + inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"") || strings.HasPrefix(line, "\texec \"") || strings.HasPrefix(line, "\trtabi \"")) { line = strings.Replace(line, `"cmd/`, `"bootstrap/cmd/`, -1) for _, dir := range bootstrapDirs { if strings.HasPrefix(dir, "cmd/") { diff --git a/src/cmd/internal/obj/plist.go b/src/cmd/internal/obj/plist.go index 9ff8e425e8..921dfee2a3 100644 --- a/src/cmd/internal/obj/plist.go +++ b/src/cmd/internal/obj/plist.go @@ -58,12 +58,12 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string } switch p.To.Sym.Name { case "go_args_stackmap": - if p.From.Type != TYPE_CONST || p.From.Offset != objabi.FUNCDATA_ArgsPointerMaps { + if p.From.Type != TYPE_CONST || p.From.Offset != abi.FUNCDATA_ArgsPointerMaps { ctxt.Diag("%s: FUNCDATA use of go_args_stackmap(SB) without FUNCDATA_ArgsPointerMaps", p.Pos) } p.To.Sym = ctxt.LookupDerived(curtext, curtext.Name+".args_stackmap") case "no_pointers_stackmap": - if p.From.Type != TYPE_CONST || p.From.Offset != objabi.FUNCDATA_LocalsPointerMaps { + if p.From.Type != TYPE_CONST || p.From.Offset != abi.FUNCDATA_LocalsPointerMaps { ctxt.Diag("%s: FUNCDATA use of no_pointers_stackmap(SB) without FUNCDATA_LocalsPointerMaps", p.Pos) } // funcdata for functions with no local variables in frame. @@ -110,10 +110,10 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string foundArgMap, foundArgInfo := false, false for p := s.Func().Text; p != nil; p = p.Link { if p.As == AFUNCDATA && p.From.Type == TYPE_CONST { - if p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps { + if p.From.Offset == abi.FUNCDATA_ArgsPointerMaps { foundArgMap = true } - if p.From.Offset == objabi.FUNCDATA_ArgInfo { + if p.From.Offset == abi.FUNCDATA_ArgInfo { foundArgInfo = true } if foundArgMap && foundArgInfo { @@ -125,7 +125,7 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string p := Appendp(s.Func().Text, newprog) p.As = AFUNCDATA p.From.Type = TYPE_CONST - p.From.Offset = objabi.FUNCDATA_ArgsPointerMaps + p.From.Offset = abi.FUNCDATA_ArgsPointerMaps p.To.Type = TYPE_MEM p.To.Name = NAME_EXTERN p.To.Sym = ctxt.LookupDerived(s, s.Name+".args_stackmap") @@ -134,7 +134,7 @@ func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string p := Appendp(s.Func().Text, newprog) p.As = AFUNCDATA p.From.Type = TYPE_CONST - p.From.Offset = objabi.FUNCDATA_ArgInfo + p.From.Offset = abi.FUNCDATA_ArgInfo p.To.Type = TYPE_MEM p.To.Name = NAME_EXTERN p.To.Sym = ctxt.LookupDerived(s, fmt.Sprintf("%s.arginfo%d", s.Name, s.ABI())) @@ -261,7 +261,7 @@ func (ctxt *Link) EmitEntryStackMap(s *LSym, p *Prog, newprog ProgAlloc) *Prog { pcdata.Pos = s.Func().Text.Pos pcdata.As = APCDATA pcdata.From.Type = TYPE_CONST - pcdata.From.Offset = objabi.PCDATA_StackMapIndex + pcdata.From.Offset = abi.PCDATA_StackMapIndex pcdata.To.Type = TYPE_CONST pcdata.To.Offset = -1 // pcdata starts at -1 at function entry @@ -274,7 +274,7 @@ func (ctxt *Link) EmitEntryUnsafePoint(s *LSym, p *Prog, newprog ProgAlloc) *Pro pcdata.Pos = s.Func().Text.Pos pcdata.As = APCDATA pcdata.From.Type = TYPE_CONST - pcdata.From.Offset = objabi.PCDATA_UnsafePoint + pcdata.From.Offset = abi.PCDATA_UnsafePoint pcdata.To.Type = TYPE_CONST pcdata.To.Offset = -1 @@ -289,9 +289,9 @@ func (ctxt *Link) StartUnsafePoint(p *Prog, newprog ProgAlloc) *Prog { pcdata := Appendp(p, newprog) pcdata.As = APCDATA pcdata.From.Type = TYPE_CONST - pcdata.From.Offset = objabi.PCDATA_UnsafePoint + pcdata.From.Offset = abi.PCDATA_UnsafePoint pcdata.To.Type = TYPE_CONST - pcdata.To.Offset = objabi.PCDATA_UnsafePointUnsafe + pcdata.To.Offset = abi.UnsafePointUnsafe return pcdata } @@ -304,7 +304,7 @@ func (ctxt *Link) EndUnsafePoint(p *Prog, newprog ProgAlloc, oldval int64) *Prog pcdata := Appendp(p, newprog) pcdata.As = APCDATA pcdata.From.Type = TYPE_CONST - pcdata.From.Offset = objabi.PCDATA_UnsafePoint + pcdata.From.Offset = abi.PCDATA_UnsafePoint pcdata.To.Type = TYPE_CONST pcdata.To.Offset = oldval @@ -330,11 +330,11 @@ func MarkUnsafePoints(ctxt *Link, p0 *Prog, newprog ProgAlloc, isUnsafePoint, is prevPcdata := int64(-1) // entry PC data value prevRestart := int64(0) for p := prev.Link; p != nil; p, prev = p.Link, p { - if p.As == APCDATA && p.From.Offset == objabi.PCDATA_UnsafePoint { + if p.As == APCDATA && p.From.Offset == abi.PCDATA_UnsafePoint { prevPcdata = p.To.Offset continue } - if prevPcdata == objabi.PCDATA_UnsafePointUnsafe { + if prevPcdata == abi.UnsafePointUnsafe { continue // already unsafe } if isUnsafePoint(p) { @@ -353,15 +353,15 @@ func MarkUnsafePoints(ctxt *Link, p0 *Prog, newprog ProgAlloc, isUnsafePoint, is continue } if isRestartable(p) { - val := int64(objabi.PCDATA_Restart1) + val := int64(abi.UnsafePointRestart1) if val == prevRestart { - val = objabi.PCDATA_Restart2 + val = abi.UnsafePointRestart2 } prevRestart = val q := Appendp(prev, newprog) q.As = APCDATA q.From.Type = TYPE_CONST - q.From.Offset = objabi.PCDATA_UnsafePoint + q.From.Offset = abi.PCDATA_UnsafePoint q.To.Type = TYPE_CONST q.To.Offset = val q.Pc = p.Pc @@ -378,7 +378,7 @@ func MarkUnsafePoints(ctxt *Link, p0 *Prog, newprog ProgAlloc, isUnsafePoint, is p = Appendp(p, newprog) p.As = APCDATA p.From.Type = TYPE_CONST - p.From.Offset = objabi.PCDATA_UnsafePoint + p.From.Offset = abi.PCDATA_UnsafePoint p.To.Type = TYPE_CONST p.To.Offset = prevPcdata p.Pc = p.Link.Pc diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go index f0955039c0..14b09f43d4 100644 --- a/src/cmd/internal/obj/util.go +++ b/src/cmd/internal/obj/util.go @@ -6,9 +6,9 @@ package obj import ( "bytes" - "cmd/internal/objabi" "cmd/internal/src" "fmt" + "internal/abi" "internal/buildcfg" "io" "strings" @@ -313,7 +313,7 @@ func writeDconv(w io.Writer, p *Prog, a *Addr, abiDetail bool) { } case TYPE_TEXTSIZE: - if a.Val.(int32) == objabi.ArgsSizeUnknown { + if a.Val.(int32) == abi.ArgsSizeUnknown { fmt.Fprintf(w, "$%d", a.Offset) } else { fmt.Fprintf(w, "$%d-%d", a.Offset, a.Val.(int32)) diff --git a/src/cmd/internal/objabi/funcdata.go b/src/cmd/internal/objabi/funcdata.go deleted file mode 100644 index 05a1d49dec..0000000000 --- a/src/cmd/internal/objabi/funcdata.go +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright 2013 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 objabi - -// This file defines the IDs for PCDATA and FUNCDATA instructions -// in Go binaries. -// -// These must agree with ../../../runtime/funcdata.h and -// ../../../runtime/symtab.go. - -const ( - PCDATA_UnsafePoint = 0 - PCDATA_StackMapIndex = 1 - PCDATA_InlTreeIndex = 2 - PCDATA_ArgLiveIndex = 3 - - FUNCDATA_ArgsPointerMaps = 0 - FUNCDATA_LocalsPointerMaps = 1 - FUNCDATA_StackObjects = 2 - FUNCDATA_InlTree = 3 - FUNCDATA_OpenCodedDeferInfo = 4 - FUNCDATA_ArgInfo = 5 - FUNCDATA_ArgLiveInfo = 6 - FUNCDATA_WrapInfo = 7 - - // ArgsSizeUnknown is set in Func.argsize to mark all functions - // whose argument size is unknown (C vararg functions, and - // assembly code without an explicit specification). - // This value is generated by the compiler, assembler, or linker. - ArgsSizeUnknown = -0x80000000 -) - -// Special PCDATA values. -const ( - // PCDATA_UnsafePoint values. - PCDATA_UnsafePointSafe = -1 // Safe for async preemption - PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption - - // PCDATA_Restart1(2) apply on a sequence of instructions, within - // which if an async preemption happens, we should back off the PC - // to the start of the sequence when resuming. - // We need two so we can distinguish the start/end of the sequence - // in case that two sequences are next to each other. - PCDATA_Restart1 = -3 - PCDATA_Restart2 = -4 - - // Like PCDATA_Restart1, but back to function entry if async preempted. - PCDATA_RestartAtEntry = -5 -) diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go index 13e8cd33da..77806d824a 100644 --- a/src/cmd/link/internal/ld/pcln.go +++ b/src/cmd/link/internal/ld/pcln.go @@ -528,8 +528,8 @@ func numPCData(ldr *loader.Loader, s loader.Sym, fi loader.FuncInfo) uint32 { } numPCData := uint32(ldr.NumPcdata(s)) if fi.NumInlTree() > 0 { - if numPCData < objabi.PCDATA_InlTreeIndex+1 { - numPCData = objabi.PCDATA_InlTreeIndex + 1 + if numPCData < abi.PCDATA_InlTreeIndex+1 { + numPCData = abi.PCDATA_InlTreeIndex + 1 } } return numPCData @@ -566,10 +566,10 @@ func funcData(ldr *loader.Loader, s loader.Sym, fi loader.FuncInfo, inlSym loade if fi.Valid() { fdSyms = ldr.Funcdata(s, fdSyms) if fi.NumInlTree() > 0 { - if len(fdSyms) < objabi.FUNCDATA_InlTree+1 { - fdSyms = append(fdSyms, make([]loader.Sym, objabi.FUNCDATA_InlTree+1-len(fdSyms))...) + if len(fdSyms) < abi.FUNCDATA_InlTree+1 { + fdSyms = append(fdSyms, make([]loader.Sym, abi.FUNCDATA_InlTree+1-len(fdSyms))...) } - fdSyms[objabi.FUNCDATA_InlTree] = inlSym + fdSyms[abi.FUNCDATA_InlTree] = inlSym } } return fdSyms @@ -597,8 +597,8 @@ func (state pclntab) calculateFunctabSize(ctxt *Link, funcs []loader.Sym) (int64 fi.Preload() numFuncData := ldr.NumFuncdata(s) if fi.NumInlTree() > 0 { - if numFuncData < objabi.FUNCDATA_InlTree+1 { - numFuncData = objabi.FUNCDATA_InlTree + 1 + if numFuncData < abi.FUNCDATA_InlTree+1 { + numFuncData = abi.FUNCDATA_InlTree + 1 } } size += int64(numPCData(ldr, s, fi) * 4) @@ -724,7 +724,7 @@ func writeFuncs(ctxt *Link, sb *loader.SymbolBuilder, funcs []loader.Sym, inlSym sb.SetUint32(ctxt.Arch, off+int64(j*4), uint32(ldr.SymValue(pcSym))) } if fi.NumInlTree() > 0 { - sb.SetUint32(ctxt.Arch, off+objabi.PCDATA_InlTreeIndex*4, uint32(ldr.SymValue(pcinline))) + sb.SetUint32(ctxt.Arch, off+abi.PCDATA_InlTreeIndex*4, uint32(ldr.SymValue(pcinline))) } } diff --git a/src/internal/abi/symtab.go b/src/internal/abi/symtab.go index c6a9689c92..bf6ea82f1c 100644 --- a/src/internal/abi/symtab.go +++ b/src/internal/abi/symtab.go @@ -62,3 +62,45 @@ const ( FuncID_systemstack_switch FuncIDWrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.) ) + +// ArgsSizeUnknown is set in Func.argsize to mark all functions +// whose argument size is unknown (C vararg functions, and +// assembly code without an explicit specification). +// This value is generated by the compiler, assembler, or linker. +const ArgsSizeUnknown = -0x80000000 + +// IDs for PCDATA and FUNCDATA tables in Go binaries. +// +// These must agree with ../../../runtime/funcdata.h. +const ( + PCDATA_UnsafePoint = 0 + PCDATA_StackMapIndex = 1 + PCDATA_InlTreeIndex = 2 + PCDATA_ArgLiveIndex = 3 + + FUNCDATA_ArgsPointerMaps = 0 + FUNCDATA_LocalsPointerMaps = 1 + FUNCDATA_StackObjects = 2 + FUNCDATA_InlTree = 3 + FUNCDATA_OpenCodedDeferInfo = 4 + FUNCDATA_ArgInfo = 5 + FUNCDATA_ArgLiveInfo = 6 + FUNCDATA_WrapInfo = 7 +) + +// Special values for the PCDATA_UnsafePoint table. +const ( + UnsafePointSafe = -1 // Safe for async preemption + UnsafePointUnsafe = -2 // Unsafe for async preemption + + // UnsafePointRestart1(2) apply on a sequence of instructions, within + // which if an async preemption happens, we should back off the PC + // to the start of the sequence when resuming. + // We need two so we can distinguish the start/end of the sequence + // in case that two sequences are next to each other. + UnsafePointRestart1 = -3 + UnsafePointRestart2 = -4 + + // Like UnsafePointRestart1, but back to function entry if async preempted. + UnsafePointRestartAtEntry = -5 +) diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go index a4393b121a..fb96b41a3a 100644 --- a/src/runtime/debugcall.go +++ b/src/runtime/debugcall.go @@ -6,7 +6,10 @@ package runtime -import "unsafe" +import ( + "internal/abi" + "unsafe" +) const ( debugCallSystemStack = "executing on Go runtime stack" @@ -80,8 +83,8 @@ func debugCallCheck(pc uintptr) string { if pc != f.entry() { pc-- } - up := pcdatavalue(f, _PCDATA_UnsafePoint, pc, nil) - if up != _PCDATA_UnsafePointSafe { + up := pcdatavalue(f, abi.PCDATA_UnsafePoint, pc, nil) + if up != abi.UnsafePointSafe { // Not at a safe point. ret = debugCallUnsafePoint } diff --git a/src/runtime/funcdata.h b/src/runtime/funcdata.h index 2e2bb30446..edc0316fb0 100644 --- a/src/runtime/funcdata.h +++ b/src/runtime/funcdata.h @@ -6,7 +6,7 @@ // in Go binaries. It is included by assembly sources, so it must // be written using #defines. // -// These must agree with symtab.go and ../cmd/internal/objabi/funcdata.go. +// These must agree with internal/abi/symtab.go. #define PCDATA_UnsafePoint 0 #define PCDATA_StackMapIndex 1 diff --git a/src/runtime/heapdump.go b/src/runtime/heapdump.go index 59e28ae9aa..74107a2095 100644 --- a/src/runtime/heapdump.go +++ b/src/runtime/heapdump.go @@ -12,6 +12,7 @@ package runtime import ( + "internal/abi" "internal/goarch" "unsafe" ) @@ -257,7 +258,7 @@ func dumpframe(s *stkframe, child *childInfo) { pcdata := int32(-1) // Use the entry map at function entry if pc != f.entry() { pc-- - pcdata = pcdatavalue(f, _PCDATA_StackMapIndex, pc, nil) + pcdata = pcdatavalue(f, abi.PCDATA_StackMapIndex, pc, nil) } if pcdata == -1 { // We do not have a valid pcdata value but there might be a @@ -265,7 +266,7 @@ func dumpframe(s *stkframe, child *childInfo) { // at the function prologue, assume so and hope for the best. pcdata = 0 } - stkmap := (*stackmap)(funcdata(f, _FUNCDATA_LocalsPointerMaps)) + stkmap := (*stackmap)(funcdata(f, abi.FUNCDATA_LocalsPointerMaps)) var bv bitvector if stkmap != nil && stkmap.n > 0 { @@ -326,7 +327,7 @@ func dumpframe(s *stkframe, child *childInfo) { child.arglen = s.argBytes() child.sp = (*uint8)(unsafe.Pointer(s.sp)) child.depth++ - stkmap = (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps)) + stkmap = (*stackmap)(funcdata(f, abi.FUNCDATA_ArgsPointerMaps)) if stkmap != nil { child.args = stackmapdata(stkmap, pcdata) } else { diff --git a/src/runtime/panic.go b/src/runtime/panic.go index a68f34f767..cefab56902 100644 --- a/src/runtime/panic.go +++ b/src/runtime/panic.go @@ -654,7 +654,7 @@ func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) { continue } f := frame.fn - fd := funcdata(f, _FUNCDATA_OpenCodedDeferInfo) + fd := funcdata(f, abi.FUNCDATA_OpenCodedDeferInfo) if fd == nil { continue } diff --git a/src/runtime/preempt.go b/src/runtime/preempt.go index 751268ee8f..a575fbcf11 100644 --- a/src/runtime/preempt.go +++ b/src/runtime/preempt.go @@ -396,14 +396,14 @@ func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) { // use the LR for unwinding, which will be bad. return false, 0 } - up, startpc := pcdatavalue2(f, _PCDATA_UnsafePoint, pc) - if up == _PCDATA_UnsafePointUnsafe { + up, startpc := pcdatavalue2(f, abi.PCDATA_UnsafePoint, pc) + if up == abi.UnsafePointUnsafe { // Unsafe-point marked by compiler. This includes // atomic sequences (e.g., write barrier) and nosplit // functions (except at calls). return false, 0 } - if fd := funcdata(f, _FUNCDATA_LocalsPointerMaps); fd == nil || f.flag&abi.FuncFlagAsm != 0 { + if fd := funcdata(f, abi.FUNCDATA_LocalsPointerMaps); fd == nil || f.flag&abi.FuncFlagAsm != 0 { // This is assembly code. Don't assume it's well-formed. // TODO: Empirically we still need the fd == nil check. Why? // @@ -432,14 +432,14 @@ func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) { return false, 0 } switch up { - case _PCDATA_Restart1, _PCDATA_Restart2: + case abi.UnsafePointRestart1, abi.UnsafePointRestart2: // Restartable instruction sequence. Back off PC to // the start PC. if startpc == 0 || startpc > pc || pc-startpc > 20 { throw("bad restart PC") } return true, startpc - case _PCDATA_RestartAtEntry: + case abi.UnsafePointRestartAtEntry: // Restart from the function entry at resumption. return true, f.entry() } diff --git a/src/runtime/stkframe.go b/src/runtime/stkframe.go index 3ecf3a828c..9c8f4be453 100644 --- a/src/runtime/stkframe.go +++ b/src/runtime/stkframe.go @@ -70,7 +70,7 @@ type reflectMethodValue struct { // argBytes returns the argument frame size for a call to frame.fn. func (frame *stkframe) argBytes() uintptr { - if frame.fn.args != _ArgsSizeUnknown { + if frame.fn.args != abi.ArgsSizeUnknown { return uintptr(frame.fn.args) } // This is an uncommon and complicated case. Fall back to fully @@ -93,7 +93,7 @@ func (frame *stkframe) argBytes() uintptr { // function stack object, which the caller must synthesize. func (frame *stkframe) argMapInternal() (argMap bitvector, hasReflectStackObj bool) { f := frame.fn - if f.args != _ArgsSizeUnknown { + if f.args != abi.ArgsSizeUnknown { argMap.n = f.args / goarch.PtrSize return } @@ -169,7 +169,7 @@ func (frame *stkframe) getStackMap(cache *pcvalueCache, debug bool) (locals, arg // the first instruction of the function changes the // stack map. targetpc-- - pcdata = pcdatavalue(f, _PCDATA_StackMapIndex, targetpc, cache) + pcdata = pcdatavalue(f, abi.PCDATA_StackMapIndex, targetpc, cache) } if pcdata == -1 { // We do not have a valid pcdata value but there might be a @@ -189,7 +189,7 @@ func (frame *stkframe) getStackMap(cache *pcvalueCache, debug bool) (locals, arg } if size > minsize { stackid := pcdata - stkmap := (*stackmap)(funcdata(f, _FUNCDATA_LocalsPointerMaps)) + stkmap := (*stackmap)(funcdata(f, abi.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") @@ -216,7 +216,7 @@ func (frame *stkframe) getStackMap(cache *pcvalueCache, debug bool) (locals, arg 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)) + stackmap := (*stackmap)(funcdata(f, abi.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") @@ -242,7 +242,7 @@ func (frame *stkframe) getStackMap(cache *pcvalueCache, debug bool) (locals, arg // This offset matches the assembly code on amd64 and arm64. objs = methodValueCallFrameObjs[:] } else { - p := funcdata(f, _FUNCDATA_StackObjects) + p := funcdata(f, abi.FUNCDATA_StackObjects) if p != nil { n := *(*uintptr)(p) p = add(p, goarch.PtrSize) diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go index 82c6c9af54..b11854c943 100644 --- a/src/runtime/symtab.go +++ b/src/runtime/symtab.go @@ -296,45 +296,6 @@ func (f *_func) funcInfo() funcInfo { return funcInfo{f, mod} } -// PCDATA and FUNCDATA table indexes. -// -// See funcdata.h and ../cmd/internal/objabi/funcdata.go. -const ( - _PCDATA_UnsafePoint = 0 - _PCDATA_StackMapIndex = 1 - _PCDATA_InlTreeIndex = 2 - _PCDATA_ArgLiveIndex = 3 - - _FUNCDATA_ArgsPointerMaps = 0 - _FUNCDATA_LocalsPointerMaps = 1 - _FUNCDATA_StackObjects = 2 - _FUNCDATA_InlTree = 3 - _FUNCDATA_OpenCodedDeferInfo = 4 - _FUNCDATA_ArgInfo = 5 - _FUNCDATA_ArgLiveInfo = 6 - _FUNCDATA_WrapInfo = 7 - - _ArgsSizeUnknown = -0x80000000 -) - -const ( - // PCDATA_UnsafePoint values. - _PCDATA_UnsafePointSafe = -1 // Safe for async preemption - _PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption - - // _PCDATA_Restart1(2) apply on a sequence of instructions, within - // which if an async preemption happens, we should back off the PC - // to the start of the sequence when resume. - // We need two so we can distinguish the start/end of the sequence - // in case that two sequences are next to each other. - _PCDATA_Restart1 = -3 - _PCDATA_Restart2 = -4 - - // Like _PCDATA_RestartAtEntry, but back to function entry if async - // preempted. - _PCDATA_RestartAtEntry = -5 -) - // pcHeader holds data used by the pclntab lookups. type pcHeader struct { magic uint32 // 0xFFFFFFF1 diff --git a/src/runtime/symtabinl.go b/src/runtime/symtabinl.go index e9cd535a17..2bb1c4bc6a 100644 --- a/src/runtime/symtabinl.go +++ b/src/runtime/symtabinl.go @@ -53,7 +53,7 @@ type inlineFrame struct { // only ever used for symbolic debugging. If things go really wrong, it'll just // fall back to the outermost frame. func newInlineUnwinder(f funcInfo, pc uintptr, cache *pcvalueCache) (inlineUnwinder, inlineFrame) { - inldata := funcdata(f, _FUNCDATA_InlTree) + inldata := funcdata(f, abi.FUNCDATA_InlTree) if inldata == nil { return inlineUnwinder{f: f}, inlineFrame{pc: pc, index: -1} } @@ -67,7 +67,7 @@ func (u *inlineUnwinder) resolveInternal(pc uintptr) inlineFrame { pc: pc, // Conveniently, this returns -1 if there's an error, which is the same // value we use for the outermost frame. - index: pcdatavalue1(u.f, _PCDATA_InlTreeIndex, pc, u.cache, false), + index: pcdatavalue1(u.f, abi.PCDATA_InlTreeIndex, pc, u.cache, false), } } diff --git a/src/runtime/trace.go b/src/runtime/trace.go index 2528c18274..c382068e2f 100644 --- a/src/runtime/trace.go +++ b/src/runtime/trace.go @@ -1701,7 +1701,7 @@ func startPCforTrace(pc uintptr) uintptr { if !f.valid() { return pc // may happen for locked g in extra M since its pc is 0. } - w := funcdata(f, _FUNCDATA_WrapInfo) + w := funcdata(f, abi.FUNCDATA_WrapInfo) if w == nil { return pc // not a wrapper } diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go index aac19dc980..d55c6d7aa5 100644 --- a/src/runtime/traceback.go +++ b/src/runtime/traceback.go @@ -664,13 +664,13 @@ func printArgs(f funcInfo, argp unsafe.Pointer, pc uintptr) { maxLen = (maxDepth*3+2)*limit + 1 // max length of _FUNCDATA_ArgInfo (see the compiler side for reasoning) ) - p := (*[maxLen]uint8)(funcdata(f, _FUNCDATA_ArgInfo)) + p := (*[maxLen]uint8)(funcdata(f, abi.FUNCDATA_ArgInfo)) if p == nil { return } - liveInfo := funcdata(f, _FUNCDATA_ArgLiveInfo) - liveIdx := pcdatavalue(f, _PCDATA_ArgLiveIndex, pc, nil) + liveInfo := funcdata(f, abi.FUNCDATA_ArgLiveInfo) + liveIdx := pcdatavalue(f, abi.PCDATA_ArgLiveIndex, pc, nil) startOffset := uint8(0xff) // smallest offset that needs liveness info (slots with a lower offset is always live) if liveInfo != nil { startOffset = *(*uint8)(liveInfo) -- 2.48.1