Documentation ¶
Index ¶
- Constants
- Variables
- func Bool2int(b bool) int
- func CConv(s uint8) string
- func Dconv(p *Prog, a *Addr) string
- func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string)
- func Mconv(a *Addr) string
- func Nopout(p *Prog)
- func RLconv(list int64) string
- func Rconv(reg int) string
- func RegisterOpcode(lo As, Anames []string)
- func RegisterRegister(lo, hi int, Rconv func(int) string)
- func RegisterRegisterList(lo, hi int64, rlconv func(int64) string)
- func SortSlice(slice interface{}, less func(i, j int) bool)
- func WriteObjFile(ctxt *Link, b *bufio.Writer)
- type Addr
- type AddrName
- type AddrType
- type As
- type Attribute
- func (a Attribute) CFunc() bool
- func (a Attribute) DuplicateOK() bool
- func (a Attribute) Leaf() bool
- func (a Attribute) Local() bool
- func (a Attribute) MakeTypelink() bool
- func (a Attribute) NeedCtxt() bool
- func (a Attribute) NoFrame() bool
- func (a Attribute) NoSplit() bool
- func (a Attribute) OnList() bool
- func (a Attribute) ReflectMethod() bool
- func (a Attribute) SeenGlobl() bool
- func (a *Attribute) Set(flag Attribute, value bool)
- func (a Attribute) Static() bool
- func (a Attribute) TextAttrString() string
- func (a Attribute) WasInlined() bool
- func (a Attribute) Wrapper() bool
- type Auto
- type DwarfFixupTable
- func (ft *DwarfFixupTable) AbsFuncDwarfSym(fnsym *LSym) *LSym
- func (ft *DwarfFixupTable) Finalize(myimportpath string, trace bool)
- func (ft *DwarfFixupTable) GetPrecursorFunc(s *LSym) interface{}
- func (ft *DwarfFixupTable) ReferenceChildDIE(s *LSym, ridx int, tgt *LSym, dclidx int, inlIndex int)
- func (ft *DwarfFixupTable) RegisterChildDIEOffsets(s *LSym, vars []*dwarf.Var, coffsets []int32)
- func (ft *DwarfFixupTable) SetPrecursorFunc(s *LSym, fn interface{})
- type FuncInfo
- type InlTree
- type InlinedCall
- type LSym
- func (s *LSym) Grow(lsiz int64)
- func (s *LSym) GrowCap(c int64)
- func (s *LSym) Len() int64
- func (s *LSym) String() string
- func (s *LSym) WriteAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64)
- func (s *LSym) WriteBytes(ctxt *Link, off int64, b []byte) int64
- func (s *LSym) WriteFloat32(ctxt *Link, off int64, f float32)
- func (s *LSym) WriteFloat64(ctxt *Link, off int64, f float64)
- func (s *LSym) WriteInt(ctxt *Link, off int64, siz int, i int64)
- func (s *LSym) WriteOff(ctxt *Link, off int64, rsym *LSym, roff int64)
- func (s *LSym) WriteString(ctxt *Link, off int64, siz int, str string)
- func (s *LSym) WriteWeakOff(ctxt *Link, off int64, rsym *LSym, roff int64)
- type Link
- func (ctxt *Link) AddImport(pkg string)
- func (ctxt *Link) CanReuseProgs() bool
- func (ctxt *Link) Diag(format string, args ...interface{})
- func (ctxt *Link) DwarfAbstractFunc(curfn interface{}, s *LSym, myimportpath string)
- func (ctxt *Link) DwarfIntConst(myimportpath, name, typename string, val int64)
- func (ctxt *Link) FixedFrameSize() int64
- func (ctxt *Link) Float32Sym(f float32) *LSym
- func (ctxt *Link) Float64Sym(f float64) *LSym
- func (ctxt *Link) Globl(s *LSym, size int64, flag int)
- func (ctxt *Link) InitTextSym(s *LSym, flag int)
- func (ctxt *Link) InnermostPos(xpos src.XPos) src.Pos
- func (ctxt *Link) Int64Sym(i int64) *LSym
- func (ctxt *Link) Logf(format string, args ...interface{})
- func (ctxt *Link) Lookup(name string) *LSym
- func (ctxt *Link) LookupDerived(s *LSym, name string) *LSym
- func (ctxt *Link) LookupInit(name string, init func(s *LSym)) *LSym
- func (ctxt *Link) LookupStatic(name string) *LSym
- func (ctxt *Link) NewProg() *Prog
- func (ctxt *Link) OutermostPos(xpos src.XPos) src.Pos
- type LinkArch
- type Pcdata
- type Pcln
- type Plist
- type Prog
- func (p *Prog) From3Type() AddrTypedeprecated
- func (p *Prog) GetFrom3() *Addrdeprecated
- func (p *Prog) InnermostFilename() string
- func (p *Prog) InnermostLineNumber() string
- func (p *Prog) InnermostLineNumberHTML() string
- func (p *Prog) InstructionString() string
- func (p *Prog) Line() string
- func (p *Prog) SetFrom3(a Addr)deprecated
- func (p *Prog) String() string
- type ProgAlloc
- type Reloc
Constants ¶
const ( ABase386 = (1 + iota) << 11 ABaseARM ABaseAMD64 ABasePPC64 ABaseARM64 ABaseMIPS ABaseS390X AllowedOpCodes = 1 << 11 // The number of opcodes available for any given architecture. AMask = AllowedOpCodes - 1 // AND with this to use the opcode as an array index. )
Each architecture is allotted a distinct subspace of opcode values for declaring its arch-specific opcodes. Within this subspace, the first arch-specific opcode should be at offset A_ARCHSPECIFIC.
Subspaces are aligned to a power of two so opcodes can be masked with AMask and used as compact array indices.
const ( // Don't profile the marked routine. // // Deprecated: Not implemented, do not use. NOPROF = 1 // It is ok for the linker to get multiple of these symbols. It will // pick one of the duplicates to use. DUPOK = 2 // Don't insert stack check preamble. NOSPLIT = 4 // Put this data in a read-only section. RODATA = 8 // This data contains no pointers. NOPTR = 16 // This is a wrapper function and should not count as disabling 'recover'. WRAPPER = 32 // This function uses its incoming context register. NEEDCTXT = 64 // When passed to ggloblsym, causes Local to be set to true on the LSym it creates. LOCAL = 128 // Allocate a word of thread local storage and store the offset from the // thread local base to the thread local storage in this variable. TLSBSS = 256 // Do not insert instructions to allocate a stack frame for this function. // Only valid on functions that declare a frame size of 0. // TODO(mwhudson): only implemented for ppc64x at present. NOFRAME = 512 // Function can call reflect.Type.Method or reflect.Type.MethodByName. REFLECTMETHOD = 1024 )
const ( C_SCOND = (1 << 4) - 1 C_SBIT = 1 << 4 C_PBIT = 1 << 5 C_WBIT = 1 << 6 C_FBIT = 1 << 7 C_UBIT = 1 << 7 C_SCOND_XOR = 14 )
ARM scond byte
const ( // Because of masking operations in the encodings, each register // space should start at 0 modulo some power of 2. RBase386 = 1 * 1024 RBaseAMD64 = 2 * 1024 RBaseARM = 3 * 1024 RBasePPC64 = 4 * 1024 // range [4k, 8k) RBaseARM64 = 8 * 1024 // range [8k, 13k) RBaseMIPS = 13 * 1024 // range [13k, 14k) RBaseS390X = 14 * 1024 // range [14k, 15k) )
const ( RegListARMLo = 0 RegListARMHi = 1 << 16 // arm64 uses the 60th bit to differentiate from other archs RegListARM64Lo = 1 << 60 RegListARM64Hi = 1<<61 - 1 )
Each architecture is allotted a distinct subspace: [Lo, Hi) for declaring its arch-specific register list numbers.
const (
LOG = 5
)
const REG_NONE = 0
Variables ¶
var Anames = []string{
"XXX",
"CALL",
"DUFFCOPY",
"DUFFZERO",
"END",
"FUNCDATA",
"JMP",
"NOP",
"PCDATA",
"RET",
"TEXT",
"UNDEF",
}
Functions ¶
func RegisterOpcode ¶
RegisterOpcode binds a list of instruction names to a given instruction number range.
func RegisterRegister ¶
RegisterRegister binds a pretty-printer (Rconv) for register numbers to a given register number range. Lo is inclusive, hi exclusive (valid registers are lo through hi-1).
func RegisterRegisterList ¶
RegisterRegisterList binds a pretty-printer (RLconv) for register list numbers to a given register list number range. Lo is inclusive, hi exclusive (valid register list are lo through hi-1).
func WriteObjFile ¶
Types ¶
type Addr ¶
type Addr struct { Reg int16 Index int16 Scale int16 // Sometimes holds a register. Type AddrType Name AddrName Class int8 Offset int64 Sym *LSym // argument value: // for TYPE_SCONST, a string // for TYPE_FCONST, a float64 // for TYPE_BRANCH, a *Prog (optional) // for TYPE_TEXTSIZE, an int32 (optional) Val interface{} }
type AddrName ¶
type AddrName int8
const ( NAME_NONE AddrName = iota NAME_EXTERN NAME_STATIC NAME_AUTO NAME_PARAM // A reference to name@GOT(SB) is a reference to the entry in the global offset // table for 'name'. NAME_GOTREF // Indicates auto that was optimized away, but whose type // we want to preserve in the DWARF debug info. NAME_DELETED_AUTO )
type As ¶
type As int16
An As denotes an assembler opcode. There are some portable opcodes, declared here in package obj, that are common to all architectures. However, the majority of opcodes are arch-specific and are declared in their respective architecture's subpackage.
type Attribute ¶
type Attribute int16
Attribute is a set of symbol attributes.
const ( AttrDuplicateOK Attribute = 1 << iota AttrCFunc AttrNoSplit AttrLeaf AttrWrapper AttrNeedCtxt AttrNoFrame AttrSeenGlobl AttrOnList AttrStatic // MakeTypelink means that the type should have an entry in the typelink table. AttrMakeTypelink // ReflectMethod means the function may call reflect.Type.Method or // reflect.Type.MethodByName. Matching is imprecise (as reflect.Type // can be used through a custom interface), so ReflectMethod may be // set in some cases when the reflect package is not called. // // Used by the linker to determine what methods can be pruned. AttrReflectMethod // Local means make the symbol local even when compiling Go code to reference Go // symbols in other shared libraries, as in this mode symbols are global by // default. "local" here means in the sense of the dynamic linker, i.e. not // visible outside of the module (shared library or executable) that contains its // definition. (When not compiling to support Go shared libraries, all symbols are // local in this sense unless there is a cgo_export_* directive). AttrLocal // For function symbols; indicates that the specified function was the // target of an inline during compilation AttrWasInlined )
func (Attribute) DuplicateOK ¶
func (Attribute) MakeTypelink ¶
func (Attribute) ReflectMethod ¶
func (Attribute) TextAttrString ¶
TextAttrString formats a for printing in as part of a TEXT prog.
func (Attribute) WasInlined ¶
type DwarfFixupTable ¶
type DwarfFixupTable struct {
// contains filtered or unexported fields
}
This table is designed to aid in the creation of references betweeen DWARF subprogram DIEs.
In most cases when one DWARF DIE has to refer to another DWARF DIE, the target of the reference has an LSym, which makes it easy to use the existing relocation mechanism. For DWARF inlined routine DIEs, however, the subprogram DIE has to refer to a child parameter/variable DIE of the abstract subprogram. This child DIE doesn't have an LSym, and also of interest is the fact that when DWARF generation is happening for inlined function F within caller G, it's possible that DWARF generation hasn't happened yet for F, so there is no way to know the offset of a child DIE within F's abstract function. Making matters more complex, each inlined instance of F may refer to a subset of the original F's variables (depending on what happens with optimization, some vars may be eliminated).
The fixup table below helps overcome this hurdle. At the point where a parameter/variable reference is made (via a call to "ReferenceChildDIE"), a fixup record is generate that records the relocation that is targeting that child variable. At a later point when the abstract function DIE is emitted, there will be a call to "RegisterChildDIEOffsets", at which point the offsets needed to apply fixups are captured. Finally, once the parallel portion of the compilation is done, fixups can actually be applied during the "Finalize" method (this can't be done during the parallel portion of the compile due to the possibility of data races).
This table is also used to record the "precursor" function node for each function that is the target of an inline -- child DIE references have to be made with respect to the original pre-optimization version of the function (to allow for the fact that each inlined body may be optimized differently).
func NewDwarfFixupTable ¶
func NewDwarfFixupTable(ctxt *Link) *DwarfFixupTable
func (*DwarfFixupTable) AbsFuncDwarfSym ¶
func (ft *DwarfFixupTable) AbsFuncDwarfSym(fnsym *LSym) *LSym
return the LSym corresponding to the 'abstract subprogram' DWARF info entry for a function.
func (*DwarfFixupTable) Finalize ¶
func (ft *DwarfFixupTable) Finalize(myimportpath string, trace bool)
Called after all functions have been compiled; the main job of this function is to identify cases where there are outstanding fixups. This scenario crops up when we have references to variables of an inlined routine, but that routine is defined in some other package. This helper walks through and locate these fixups, then invokes a helper to create an abstract subprogram DIE for each one.
func (*DwarfFixupTable) GetPrecursorFunc ¶
func (ft *DwarfFixupTable) GetPrecursorFunc(s *LSym) interface{}
func (*DwarfFixupTable) ReferenceChildDIE ¶
func (ft *DwarfFixupTable) ReferenceChildDIE(s *LSym, ridx int, tgt *LSym, dclidx int, inlIndex int)
Make a note of a child DIE reference: relocation 'ridx' within symbol 's' is targeting child 'c' of DIE with symbol 'tgt'.
func (*DwarfFixupTable) RegisterChildDIEOffsets ¶
func (ft *DwarfFixupTable) RegisterChildDIEOffsets(s *LSym, vars []*dwarf.Var, coffsets []int32)
Called once DWARF generation is complete for a given abstract function, whose children might have been referenced via a call above. Stores the offsets for any child DIEs (vars, params) so that they can be consumed later in on DwarfFixupTable.Finalize, which applies any outstanding fixups.
func (*DwarfFixupTable) SetPrecursorFunc ¶
func (ft *DwarfFixupTable) SetPrecursorFunc(s *LSym, fn interface{})
type FuncInfo ¶
type FuncInfo struct { Args int32 Locals int32 Text *Prog Autom []*Auto Pcln Pcln GCArgs LSym GCLocals LSym // contains filtered or unexported fields }
A FuncInfo contains extra fields for STEXT symbols.
type InlTree ¶
type InlTree struct {
// contains filtered or unexported fields
}
InlTree is a collection of inlined calls. The Parent field of an InlinedCall is the index of another InlinedCall in InlTree.
The compiler maintains a global inlining tree and adds a node to it every time a function is inlined. For example, suppose f() calls g() and g has two calls to h(), and that f, g, and h are inlineable:
1 func main() { 2 f() 3 } 4 func f() { 5 g() 6 } 7 func g() { 8 h() 9 h()
10 } 11 func h() { 12 println("H") 13 }
Assuming the global tree starts empty, inlining will produce the following tree:
[]InlinedCall{ {Parent: -1, Func: "f", Pos: <line 2>}, {Parent: 0, Func: "g", Pos: <line 5>}, {Parent: 1, Func: "h", Pos: <line 8>}, {Parent: 1, Func: "h", Pos: <line 9>}, }
The nodes of h inlined into main will have inlining indexes 2 and 3.
Eventually, the compiler extracts a per-function inlining tree from the global inlining tree (see pcln.go).
func (*InlTree) InlinedFunction ¶
type InlinedCall ¶
type InlinedCall struct { Parent int // index of the parent in the InlTree or < 0 if outermost call Pos src.XPos // position of the inlined call Func *LSym // function that was inlined }
InlinedCall is a node in an InlTree.
type LSym ¶
type LSym struct { Name string Type objabi.SymKind Attribute RefIdx int // Index of this symbol in the symbol reference list. Size int64 Gotype *LSym P []byte R []Reloc Func *FuncInfo }
An LSym is the sort of symbol that is written to an object file.
func (*LSym) String ¶
The compiler needs LSym to satisfy fmt.Stringer, because it stores an LSym in ssa.ExternSymbol.
func (*LSym) WriteAddr ¶
WriteAddr writes an address of size siz into s at offset off. rsym and roff specify the relocation for the address.
func (*LSym) WriteBytes ¶
WriteBytes writes a slice of bytes into s at offset off.
func (*LSym) WriteFloat32 ¶
WriteFloat32 writes f into s at offset off.
func (*LSym) WriteFloat64 ¶
WriteFloat64 writes f into s at offset off.
func (*LSym) WriteOff ¶
WriteOff writes a 4 byte offset to rsym+roff into s at offset off. After linking the 4 bytes stored at s+off will be rsym+roff-(start of section that s is in).
func (*LSym) WriteString ¶
WriteString writes a string of size siz into s at offset off.
type Link ¶
type Link struct { Headtype objabi.HeadType Arch *LinkArch Debugasm bool Debugvlog bool Debugpcln string Flag_dynlink bool Flag_optimize bool Flag_locationlists bool Bso *bufio.Writer Pathname string PosTable src.PosTable InlTree InlTree // global inlining tree used by gc/inl.go DwFixups *DwarfFixupTable Imports []string DiagFunc func(string, ...interface{}) DiagFlush func() DebugInfo func(fn *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node GenAbstractFunc func(fn *LSym) Errors int InParallel bool // parallel backend phase in effect Framepointer_enabled bool // state for writing objects Text []*LSym Data []*LSym // contains filtered or unexported fields }
Link holds the context for writing object code from a compiler to be linker input or for reading that input into the linker.
func (*Link) CanReuseProgs ¶
func (*Link) DwarfAbstractFunc ¶
func (*Link) DwarfIntConst ¶
DwarfIntConst creates a link symbol for an integer constant with the given name, type and value.
func (*Link) FixedFrameSize ¶
The smallest possible offset from the hardware stack pointer to a local variable on the stack. Architectures that use a link register save its value on the stack in the function prologue and so always have a pointer between the hardware stack pointer and the local variable area.
func (*Link) Float32Sym ¶
func (*Link) Float64Sym ¶
func (*Link) InitTextSym ¶
func (*Link) InnermostPos ¶
InnermostPos returns the innermost position corresponding to xpos, that is, the code that is inlined and that inlines nothing else. In the example for InlTree above, the code for println within h would have an innermost position with line number 12, whether h was not inlined, inlined into g, g-then-f, or g-then-f-then-main. This corresponds to what someone debugging main, f, g, or h might expect to see while single-stepping.
func (*Link) Lookup ¶
Lookup looks up the symbol with name name. If it does not exist, it creates it.
func (*Link) LookupDerived ¶
LookupDerived looks up or creates the symbol with name name derived from symbol s. The resulting symbol will be static iff s is.
func (*Link) LookupInit ¶
LookupInit looks up the symbol with name name. If it does not exist, it creates it and passes it to init for one-time initialization.
func (*Link) LookupStatic ¶
LookupStatic looks up the static symbol with name name. If it does not exist, it creates it.
func (*Link) OutermostPos ¶
OutermostPos returns the outermost position corresponding to xpos, which is where xpos was ultimately inlined to. In the example for InlTree, main() contains inlined AST nodes from h(), but the outermost position for those nodes is line 2.
type LinkArch ¶
type LinkArch struct { *sys.Arch Init func(*Link) Preprocess func(*Link, *LSym, ProgAlloc) Assemble func(*Link, *LSym, ProgAlloc) Progedit func(*Link, *Prog, ProgAlloc) UnaryDst map[As]bool // Instruction takes one operand, a destination. DWARFRegisters map[int16]int16 }
LinkArch is the definition of a single architecture.
type Prog ¶
type Prog struct { Ctxt *Link // linker context Link *Prog // next Prog in linked list From Addr // first source operand RestArgs []Addr // can pack any operands that not fit into {Prog.From, Prog.To} To Addr // destination operand (second is RegTo2 below) Pcond *Prog // target of conditional jump Forwd *Prog // for x86 back end Rel *Prog // for x86, arm back ends Pc int64 // for back ends or assembler: virtual or actual program counter, depending on phase Pos src.XPos // source position of this instruction Spadj int32 // effect of instruction on stack pointer (increment or decrement amount) As As // assembler opcode Reg int16 // 2nd source operand RegTo2 int16 // 2nd destination operand Mark uint16 // bitmask of arch-specific items Optab uint16 // arch-specific opcode index Scond uint8 // condition bits for conditional instruction (e.g., on ARM) Back uint8 // for x86 back end: backwards branch state Ft uint8 // for x86 back end: type index of Prog.From Tt uint8 // for x86 back end: type index of Prog.To Isize uint8 // for x86 back end: size of the instruction in bytes }
Prog describes a single machine instruction.
The general instruction form is:
(1) As.Scond From [, ...RestArgs], To (2) As.Scond From, Reg [, ...RestArgs], To, RegTo2
where As is an opcode and the others are arguments: From, Reg are sources, and To, RegTo2 are destinations. RestArgs can hold additional sources and destinations. Usually, not all arguments are present. For example, MOVL R1, R2 encodes using only As=MOVL, From=R1, To=R2. The Scond field holds additional condition bits for systems (like arm) that have generalized conditional execution. (2) form is present for compatibility with older code, to avoid too much changes in a single swing. (1) scheme is enough to express any kind of operand combination.
Jump instructions use the Pcond field to point to the target instruction, which must be in the same linked list as the jump instruction.
The Progs for a given function are arranged in a list linked through the Link field.
Each Prog is charged to a specific source line in the debug information, specified by Pos.Line(). Every Prog has a Ctxt field that defines its context. For performance reasons, Progs usually are usually bulk allocated, cached, and reused; those bulk allocators should always be used, rather than new(Prog).
The other fields not yet mentioned are for use by the back ends and should be left zeroed by creators of Prog lists.
func (*Prog) GetFrom3
deprecated
GetFrom3 returns second source operand (the first is Prog.From). In combination with Prog.From and Prog.To it makes common 3 operand case easier to use.
Should be used only when RestArgs is set with SetFrom3.
Deprecated: better use RestArgs directly or define backend-specific getters. Introduced to simplify transition to []Addr. Usage of this is discouraged due to fragility and lack of guarantees.
func (*Prog) InnermostFilename ¶
InnermostFilename returns a string containing the innermost (in inlining) filename at p's position
func (*Prog) InnermostLineNumber ¶
InnermostLineNumber returns a string containing the line number for the innermost inlined function (if any inlining) at p's position
func (*Prog) InnermostLineNumberHTML ¶
InnermostLineNumberHTML returns a string containing the line number for the innermost inlined function (if any inlining) at p's position
func (*Prog) InstructionString ¶
InstructionString returns a string representation of the instruction without preceding program counter or file and line number.