1 // Derived from Inferno utils/6l/l.h and related files. 2 // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h 3 // 4 // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. 5 // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) 6 // Portions Copyright © 1997-1999 Vita Nuova Limited 7 // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) 8 // Portions Copyright © 2004,2006 Bruce Ellis 9 // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) 10 // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others 11 // Portions Copyright © 2009 The Go Authors. All rights reserved. 12 // 13 // Permission is hereby granted, free of charge, to any person obtaining a copy 14 // of this software and associated documentation files (the "Software"), to deal 15 // in the Software without restriction, including without limitation the rights 16 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 17 // copies of the Software, and to permit persons to whom the Software is 18 // furnished to do so, subject to the following conditions: 19 // 20 // The above copyright notice and this permission notice shall be included in 21 // all copies or substantial portions of the Software. 22 // 23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 26 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 28 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 29 // THE SOFTWARE. 30 31 package obj 32 33 import ( 34 "bufio" 35 "github.com/twitchyliquid64/golang-asm/dwarf" 36 "github.com/twitchyliquid64/golang-asm/goobj" 37 "github.com/twitchyliquid64/golang-asm/objabi" 38 "github.com/twitchyliquid64/golang-asm/src" 39 "github.com/twitchyliquid64/golang-asm/sys" 40 "fmt" 41 "sync" 42 ) 43 44 // An Addr is an argument to an instruction. 45 // The general forms and their encodings are: 46 // 47 // sym±offset(symkind)(reg)(index*scale) 48 // Memory reference at address &sym(symkind) + offset + reg + index*scale. 49 // Any of sym(symkind), ±offset, (reg), (index*scale), and *scale can be omitted. 50 // If (reg) and *scale are both omitted, the resulting expression (index) is parsed as (reg). 51 // To force a parsing as index*scale, write (index*1). 52 // Encoding: 53 // type = TYPE_MEM 54 // name = symkind (NAME_AUTO, ...) or 0 (NAME_NONE) 55 // sym = sym 56 // offset = ±offset 57 // reg = reg (REG_*) 58 // index = index (REG_*) 59 // scale = scale (1, 2, 4, 8) 60 // 61 // $<mem> 62 // Effective address of memory reference <mem>, defined above. 63 // Encoding: same as memory reference, but type = TYPE_ADDR. 64 // 65 // $<±integer value> 66 // This is a special case of $<mem>, in which only ±offset is present. 67 // It has a separate type for easy recognition. 68 // Encoding: 69 // type = TYPE_CONST 70 // offset = ±integer value 71 // 72 // *<mem> 73 // Indirect reference through memory reference <mem>, defined above. 74 // Only used on x86 for CALL/JMP *sym(SB), which calls/jumps to a function 75 // pointer stored in the data word sym(SB), not a function named sym(SB). 76 // Encoding: same as above, but type = TYPE_INDIR. 77 // 78 // $*$<mem> 79 // No longer used. 80 // On machines with actual SB registers, $*$<mem> forced the 81 // instruction encoding to use a full 32-bit constant, never a 82 // reference relative to SB. 83 // 84 // $<floating point literal> 85 // Floating point constant value. 86 // Encoding: 87 // type = TYPE_FCONST 88 // val = floating point value 89 // 90 // $<string literal, up to 8 chars> 91 // String literal value (raw bytes used for DATA instruction). 92 // Encoding: 93 // type = TYPE_SCONST 94 // val = string 95 // 96 // <register name> 97 // Any register: integer, floating point, control, segment, and so on. 98 // If looking for specific register kind, must check type and reg value range. 99 // Encoding: 100 // type = TYPE_REG 101 // reg = reg (REG_*) 102 // 103 // x(PC) 104 // Encoding: 105 // type = TYPE_BRANCH 106 // val = Prog* reference OR ELSE offset = target pc (branch takes priority) 107 // 108 // $±x-±y 109 // Final argument to TEXT, specifying local frame size x and argument size y. 110 // In this form, x and y are integer literals only, not arbitrary expressions. 111 // This avoids parsing ambiguities due to the use of - as a separator. 112 // The ± are optional. 113 // If the final argument to TEXT omits the -±y, the encoding should still 114 // use TYPE_TEXTSIZE (not TYPE_CONST), with u.argsize = ArgsSizeUnknown. 115 // Encoding: 116 // type = TYPE_TEXTSIZE 117 // offset = x 118 // val = int32(y) 119 // 120 // reg<<shift, reg>>shift, reg->shift, reg@>shift 121 // Shifted register value, for ARM and ARM64. 122 // In this form, reg must be a register and shift can be a register or an integer constant. 123 // Encoding: 124 // type = TYPE_SHIFT 125 // On ARM: 126 // offset = (reg&15) | shifttype<<5 | count 127 // shifttype = 0, 1, 2, 3 for <<, >>, ->, @> 128 // count = (reg&15)<<8 | 1<<4 for a register shift count, (n&31)<<7 for an integer constant. 129 // On ARM64: 130 // offset = (reg&31)<<16 | shifttype<<22 | (count&63)<<10 131 // shifttype = 0, 1, 2 for <<, >>, -> 132 // 133 // (reg, reg) 134 // A destination register pair. When used as the last argument of an instruction, 135 // this form makes clear that both registers are destinations. 136 // Encoding: 137 // type = TYPE_REGREG 138 // reg = first register 139 // offset = second register 140 // 141 // [reg, reg, reg-reg] 142 // Register list for ARM, ARM64, 386/AMD64. 143 // Encoding: 144 // type = TYPE_REGLIST 145 // On ARM: 146 // offset = bit mask of registers in list; R0 is low bit. 147 // On ARM64: 148 // offset = register count (Q:size) | arrangement (opcode) | first register 149 // On 386/AMD64: 150 // reg = range low register 151 // offset = 2 packed registers + kind tag (see x86.EncodeRegisterRange) 152 // 153 // reg, reg 154 // Register pair for ARM. 155 // TYPE_REGREG2 156 // 157 // (reg+reg) 158 // Register pair for PPC64. 159 // Encoding: 160 // type = TYPE_MEM 161 // reg = first register 162 // index = second register 163 // scale = 1 164 // 165 // reg.[US]XT[BHWX] 166 // Register extension for ARM64 167 // Encoding: 168 // type = TYPE_REG 169 // reg = REG_[US]XT[BHWX] + register + shift amount 170 // offset = ((reg&31) << 16) | (exttype << 13) | (amount<<10) 171 // 172 // reg.<T> 173 // Register arrangement for ARM64 SIMD register 174 // e.g.: V1.S4, V2.S2, V7.D2, V2.H4, V6.B16 175 // Encoding: 176 // type = TYPE_REG 177 // reg = REG_ARNG + register + arrangement 178 // 179 // reg.<T>[index] 180 // Register element for ARM64 181 // Encoding: 182 // type = TYPE_REG 183 // reg = REG_ELEM + register + arrangement 184 // index = element index 185 186 type Addr struct { 187 Reg int16 188 Index int16 189 Scale int16 // Sometimes holds a register. 190 Type AddrType 191 Name AddrName 192 Class int8 193 Offset int64 194 Sym *LSym 195 196 // argument value: 197 // for TYPE_SCONST, a string 198 // for TYPE_FCONST, a float64 199 // for TYPE_BRANCH, a *Prog (optional) 200 // for TYPE_TEXTSIZE, an int32 (optional) 201 Val interface{} 202 } 203 204 type AddrName int8 205 206 const ( 207 NAME_NONE AddrName = iota 208 NAME_EXTERN 209 NAME_STATIC 210 NAME_AUTO 211 NAME_PARAM 212 // A reference to name@GOT(SB) is a reference to the entry in the global offset 213 // table for 'name'. 214 NAME_GOTREF 215 // Indicates that this is a reference to a TOC anchor. 216 NAME_TOCREF 217 ) 218 219 //go:generate stringer -type AddrType 220 221 type AddrType uint8 222 223 const ( 224 TYPE_NONE AddrType = iota 225 TYPE_BRANCH 226 TYPE_TEXTSIZE 227 TYPE_MEM 228 TYPE_CONST 229 TYPE_FCONST 230 TYPE_SCONST 231 TYPE_REG 232 TYPE_ADDR 233 TYPE_SHIFT 234 TYPE_REGREG 235 TYPE_REGREG2 236 TYPE_INDIR 237 TYPE_REGLIST 238 ) 239 240 func (a *Addr) Target() *Prog { 241 if a.Type == TYPE_BRANCH && a.Val != nil { 242 return a.Val.(*Prog) 243 } 244 return nil 245 } 246 func (a *Addr) SetTarget(t *Prog) { 247 if a.Type != TYPE_BRANCH { 248 panic("setting branch target when type is not TYPE_BRANCH") 249 } 250 a.Val = t 251 } 252 253 // Prog describes a single machine instruction. 254 // 255 // The general instruction form is: 256 // 257 // (1) As.Scond From [, ...RestArgs], To 258 // (2) As.Scond From, Reg [, ...RestArgs], To, RegTo2 259 // 260 // where As is an opcode and the others are arguments: 261 // From, Reg are sources, and To, RegTo2 are destinations. 262 // RestArgs can hold additional sources and destinations. 263 // Usually, not all arguments are present. 264 // For example, MOVL R1, R2 encodes using only As=MOVL, From=R1, To=R2. 265 // The Scond field holds additional condition bits for systems (like arm) 266 // that have generalized conditional execution. 267 // (2) form is present for compatibility with older code, 268 // to avoid too much changes in a single swing. 269 // (1) scheme is enough to express any kind of operand combination. 270 // 271 // Jump instructions use the To.Val field to point to the target *Prog, 272 // which must be in the same linked list as the jump instruction. 273 // 274 // The Progs for a given function are arranged in a list linked through the Link field. 275 // 276 // Each Prog is charged to a specific source line in the debug information, 277 // specified by Pos.Line(). 278 // Every Prog has a Ctxt field that defines its context. 279 // For performance reasons, Progs usually are usually bulk allocated, cached, and reused; 280 // those bulk allocators should always be used, rather than new(Prog). 281 // 282 // The other fields not yet mentioned are for use by the back ends and should 283 // be left zeroed by creators of Prog lists. 284 type Prog struct { 285 Ctxt *Link // linker context 286 Link *Prog // next Prog in linked list 287 From Addr // first source operand 288 RestArgs []Addr // can pack any operands that not fit into {Prog.From, Prog.To} 289 To Addr // destination operand (second is RegTo2 below) 290 Pool *Prog // constant pool entry, for arm,arm64 back ends 291 Forwd *Prog // for x86 back end 292 Rel *Prog // for x86, arm back ends 293 Pc int64 // for back ends or assembler: virtual or actual program counter, depending on phase 294 Pos src.XPos // source position of this instruction 295 Spadj int32 // effect of instruction on stack pointer (increment or decrement amount) 296 As As // assembler opcode 297 Reg int16 // 2nd source operand 298 RegTo2 int16 // 2nd destination operand 299 Mark uint16 // bitmask of arch-specific items 300 Optab uint16 // arch-specific opcode index 301 Scond uint8 // bits that describe instruction suffixes (e.g. ARM conditions) 302 Back uint8 // for x86 back end: backwards branch state 303 Ft uint8 // for x86 back end: type index of Prog.From 304 Tt uint8 // for x86 back end: type index of Prog.To 305 Isize uint8 // for x86 back end: size of the instruction in bytes 306 } 307 308 // From3Type returns p.GetFrom3().Type, or TYPE_NONE when 309 // p.GetFrom3() returns nil. 310 // 311 // Deprecated: for the same reasons as Prog.GetFrom3. 312 func (p *Prog) From3Type() AddrType { 313 if p.RestArgs == nil { 314 return TYPE_NONE 315 } 316 return p.RestArgs[0].Type 317 } 318 319 // GetFrom3 returns second source operand (the first is Prog.From). 320 // In combination with Prog.From and Prog.To it makes common 3 operand 321 // case easier to use. 322 // 323 // Should be used only when RestArgs is set with SetFrom3. 324 // 325 // Deprecated: better use RestArgs directly or define backend-specific getters. 326 // Introduced to simplify transition to []Addr. 327 // Usage of this is discouraged due to fragility and lack of guarantees. 328 func (p *Prog) GetFrom3() *Addr { 329 if p.RestArgs == nil { 330 return nil 331 } 332 return &p.RestArgs[0] 333 } 334 335 // SetFrom3 assigns []Addr{a} to p.RestArgs. 336 // In pair with Prog.GetFrom3 it can help in emulation of Prog.From3. 337 // 338 // Deprecated: for the same reasons as Prog.GetFrom3. 339 func (p *Prog) SetFrom3(a Addr) { 340 p.RestArgs = []Addr{a} 341 } 342 343 // An As denotes an assembler opcode. 344 // There are some portable opcodes, declared here in package obj, 345 // that are common to all architectures. 346 // However, the majority of opcodes are arch-specific 347 // and are declared in their respective architecture's subpackage. 348 type As int16 349 350 // These are the portable opcodes. 351 const ( 352 AXXX As = iota 353 ACALL 354 ADUFFCOPY 355 ADUFFZERO 356 AEND 357 AFUNCDATA 358 AJMP 359 ANOP 360 APCALIGN 361 APCDATA 362 ARET 363 AGETCALLERPC 364 ATEXT 365 AUNDEF 366 A_ARCHSPECIFIC 367 ) 368 369 // Each architecture is allotted a distinct subspace of opcode values 370 // for declaring its arch-specific opcodes. 371 // Within this subspace, the first arch-specific opcode should be 372 // at offset A_ARCHSPECIFIC. 373 // 374 // Subspaces are aligned to a power of two so opcodes can be masked 375 // with AMask and used as compact array indices. 376 const ( 377 ABase386 = (1 + iota) << 11 378 ABaseARM 379 ABaseAMD64 380 ABasePPC64 381 ABaseARM64 382 ABaseMIPS 383 ABaseRISCV 384 ABaseS390X 385 ABaseWasm 386 387 AllowedOpCodes = 1 << 11 // The number of opcodes available for any given architecture. 388 AMask = AllowedOpCodes - 1 // AND with this to use the opcode as an array index. 389 ) 390 391 // An LSym is the sort of symbol that is written to an object file. 392 // It represents Go symbols in a flat pkg+"."+name namespace. 393 type LSym struct { 394 Name string 395 Type objabi.SymKind 396 Attribute 397 398 RefIdx int // Index of this symbol in the symbol reference list. 399 Size int64 400 Gotype *LSym 401 P []byte 402 R []Reloc 403 404 Func *FuncInfo 405 406 Pkg string 407 PkgIdx int32 408 SymIdx int32 // TODO: replace RefIdx 409 } 410 411 // A FuncInfo contains extra fields for STEXT symbols. 412 type FuncInfo struct { 413 Args int32 414 Locals int32 415 Align int32 416 FuncID objabi.FuncID 417 Text *Prog 418 Autot map[*LSym]struct{} 419 Pcln Pcln 420 InlMarks []InlMark 421 422 dwarfInfoSym *LSym 423 dwarfLocSym *LSym 424 dwarfRangesSym *LSym 425 dwarfAbsFnSym *LSym 426 dwarfDebugLinesSym *LSym 427 428 GCArgs *LSym 429 GCLocals *LSym 430 GCRegs *LSym // Only if !go115ReduceLiveness 431 StackObjects *LSym 432 OpenCodedDeferInfo *LSym 433 434 FuncInfoSym *LSym 435 } 436 437 type InlMark struct { 438 // When unwinding from an instruction in an inlined body, mark 439 // where we should unwind to. 440 // id records the global inlining id of the inlined body. 441 // p records the location of an instruction in the parent (inliner) frame. 442 p *Prog 443 id int32 444 } 445 446 // Mark p as the instruction to set as the pc when 447 // "unwinding" the inlining global frame id. Usually it should be 448 // instruction with a file:line at the callsite, and occur 449 // just before the body of the inlined function. 450 func (fi *FuncInfo) AddInlMark(p *Prog, id int32) { 451 fi.InlMarks = append(fi.InlMarks, InlMark{p: p, id: id}) 452 } 453 454 // Record the type symbol for an auto variable so that the linker 455 // an emit DWARF type information for the type. 456 func (fi *FuncInfo) RecordAutoType(gotype *LSym) { 457 if fi.Autot == nil { 458 fi.Autot = make(map[*LSym]struct{}) 459 } 460 fi.Autot[gotype] = struct{}{} 461 } 462 463 //go:generate stringer -type ABI 464 465 // ABI is the calling convention of a text symbol. 466 type ABI uint8 467 468 const ( 469 // ABI0 is the stable stack-based ABI. It's important that the 470 // value of this is "0": we can't distinguish between 471 // references to data and ABI0 text symbols in assembly code, 472 // and hence this doesn't distinguish between symbols without 473 // an ABI and text symbols with ABI0. 474 ABI0 ABI = iota 475 476 // ABIInternal is the internal ABI that may change between Go 477 // versions. All Go functions use the internal ABI and the 478 // compiler generates wrappers for calls to and from other 479 // ABIs. 480 ABIInternal 481 482 ABICount 483 ) 484 485 // Attribute is a set of symbol attributes. 486 type Attribute uint32 487 488 const ( 489 AttrDuplicateOK Attribute = 1 << iota 490 AttrCFunc 491 AttrNoSplit 492 AttrLeaf 493 AttrWrapper 494 AttrNeedCtxt 495 AttrNoFrame 496 AttrOnList 497 AttrStatic 498 499 // MakeTypelink means that the type should have an entry in the typelink table. 500 AttrMakeTypelink 501 502 // ReflectMethod means the function may call reflect.Type.Method or 503 // reflect.Type.MethodByName. Matching is imprecise (as reflect.Type 504 // can be used through a custom interface), so ReflectMethod may be 505 // set in some cases when the reflect package is not called. 506 // 507 // Used by the linker to determine what methods can be pruned. 508 AttrReflectMethod 509 510 // Local means make the symbol local even when compiling Go code to reference Go 511 // symbols in other shared libraries, as in this mode symbols are global by 512 // default. "local" here means in the sense of the dynamic linker, i.e. not 513 // visible outside of the module (shared library or executable) that contains its 514 // definition. (When not compiling to support Go shared libraries, all symbols are 515 // local in this sense unless there is a cgo_export_* directive). 516 AttrLocal 517 518 // For function symbols; indicates that the specified function was the 519 // target of an inline during compilation 520 AttrWasInlined 521 522 // TopFrame means that this function is an entry point and unwinders should not 523 // keep unwinding beyond this frame. 524 AttrTopFrame 525 526 // Indexed indicates this symbol has been assigned with an index (when using the 527 // new object file format). 528 AttrIndexed 529 530 // Only applied on type descriptor symbols, UsedInIface indicates this type is 531 // converted to an interface. 532 // 533 // Used by the linker to determine what methods can be pruned. 534 AttrUsedInIface 535 536 // ContentAddressable indicates this is a content-addressable symbol. 537 AttrContentAddressable 538 539 // attrABIBase is the value at which the ABI is encoded in 540 // Attribute. This must be last; all bits after this are 541 // assumed to be an ABI value. 542 // 543 // MUST BE LAST since all bits above this comprise the ABI. 544 attrABIBase 545 ) 546 547 func (a Attribute) DuplicateOK() bool { return a&AttrDuplicateOK != 0 } 548 func (a Attribute) MakeTypelink() bool { return a&AttrMakeTypelink != 0 } 549 func (a Attribute) CFunc() bool { return a&AttrCFunc != 0 } 550 func (a Attribute) NoSplit() bool { return a&AttrNoSplit != 0 } 551 func (a Attribute) Leaf() bool { return a&AttrLeaf != 0 } 552 func (a Attribute) OnList() bool { return a&AttrOnList != 0 } 553 func (a Attribute) ReflectMethod() bool { return a&AttrReflectMethod != 0 } 554 func (a Attribute) Local() bool { return a&AttrLocal != 0 } 555 func (a Attribute) Wrapper() bool { return a&AttrWrapper != 0 } 556 func (a Attribute) NeedCtxt() bool { return a&AttrNeedCtxt != 0 } 557 func (a Attribute) NoFrame() bool { return a&AttrNoFrame != 0 } 558 func (a Attribute) Static() bool { return a&AttrStatic != 0 } 559 func (a Attribute) WasInlined() bool { return a&AttrWasInlined != 0 } 560 func (a Attribute) TopFrame() bool { return a&AttrTopFrame != 0 } 561 func (a Attribute) Indexed() bool { return a&AttrIndexed != 0 } 562 func (a Attribute) UsedInIface() bool { return a&AttrUsedInIface != 0 } 563 func (a Attribute) ContentAddressable() bool { return a&AttrContentAddressable != 0 } 564 565 func (a *Attribute) Set(flag Attribute, value bool) { 566 if value { 567 *a |= flag 568 } else { 569 *a &^= flag 570 } 571 } 572 573 func (a Attribute) ABI() ABI { return ABI(a / attrABIBase) } 574 func (a *Attribute) SetABI(abi ABI) { 575 const mask = 1 // Only one ABI bit for now. 576 *a = (*a &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase 577 } 578 579 var textAttrStrings = [...]struct { 580 bit Attribute 581 s string 582 }{ 583 {bit: AttrDuplicateOK, s: "DUPOK"}, 584 {bit: AttrMakeTypelink, s: ""}, 585 {bit: AttrCFunc, s: "CFUNC"}, 586 {bit: AttrNoSplit, s: "NOSPLIT"}, 587 {bit: AttrLeaf, s: "LEAF"}, 588 {bit: AttrOnList, s: ""}, 589 {bit: AttrReflectMethod, s: "REFLECTMETHOD"}, 590 {bit: AttrLocal, s: "LOCAL"}, 591 {bit: AttrWrapper, s: "WRAPPER"}, 592 {bit: AttrNeedCtxt, s: "NEEDCTXT"}, 593 {bit: AttrNoFrame, s: "NOFRAME"}, 594 {bit: AttrStatic, s: "STATIC"}, 595 {bit: AttrWasInlined, s: ""}, 596 {bit: AttrTopFrame, s: "TOPFRAME"}, 597 {bit: AttrIndexed, s: ""}, 598 {bit: AttrContentAddressable, s: ""}, 599 } 600 601 // TextAttrString formats a for printing in as part of a TEXT prog. 602 func (a Attribute) TextAttrString() string { 603 var s string 604 for _, x := range textAttrStrings { 605 if a&x.bit != 0 { 606 if x.s != "" { 607 s += x.s + "|" 608 } 609 a &^= x.bit 610 } 611 } 612 switch a.ABI() { 613 case ABI0: 614 case ABIInternal: 615 s += "ABIInternal|" 616 a.SetABI(0) // Clear ABI so we don't print below. 617 } 618 if a != 0 { 619 s += fmt.Sprintf("UnknownAttribute(%d)|", a) 620 } 621 // Chop off trailing |, if present. 622 if len(s) > 0 { 623 s = s[:len(s)-1] 624 } 625 return s 626 } 627 628 func (s *LSym) String() string { 629 return s.Name 630 } 631 632 // The compiler needs *LSym to be assignable to cmd/compile/internal/ssa.Sym. 633 func (s *LSym) CanBeAnSSASym() { 634 } 635 636 type Pcln struct { 637 Pcsp Pcdata 638 Pcfile Pcdata 639 Pcline Pcdata 640 Pcinline Pcdata 641 Pcdata []Pcdata 642 Funcdata []*LSym 643 Funcdataoff []int64 644 UsedFiles map[goobj.CUFileIndex]struct{} // file indices used while generating pcfile 645 InlTree InlTree // per-function inlining tree extracted from the global tree 646 } 647 648 type Reloc struct { 649 Off int32 650 Siz uint8 651 Type objabi.RelocType 652 Add int64 653 Sym *LSym 654 } 655 656 type Auto struct { 657 Asym *LSym 658 Aoffset int32 659 Name AddrName 660 Gotype *LSym 661 } 662 663 type Pcdata struct { 664 P []byte 665 } 666 667 // Link holds the context for writing object code from a compiler 668 // to be linker input or for reading that input into the linker. 669 type Link struct { 670 Headtype objabi.HeadType 671 Arch *LinkArch 672 Debugasm int 673 Debugvlog bool 674 Debugpcln string 675 Flag_shared bool 676 Flag_dynlink bool 677 Flag_linkshared bool 678 Flag_optimize bool 679 Flag_locationlists bool 680 Retpoline bool // emit use of retpoline stubs for indirect jmp/call 681 Bso *bufio.Writer 682 Pathname string 683 Pkgpath string // the current package's import path, "" if unknown 684 hashmu sync.Mutex // protects hash, funchash 685 hash map[string]*LSym // name -> sym mapping 686 funchash map[string]*LSym // name -> sym mapping for ABIInternal syms 687 statichash map[string]*LSym // name -> sym mapping for static syms 688 PosTable src.PosTable 689 InlTree InlTree // global inlining tree used by gc/inl.go 690 DwFixups *DwarfFixupTable 691 Imports []goobj.ImportedPkg 692 DiagFunc func(string, ...interface{}) 693 DiagFlush func() 694 DebugInfo func(fn *LSym, info *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node 695 GenAbstractFunc func(fn *LSym) 696 Errors int 697 698 InParallel bool // parallel backend phase in effect 699 UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges 700 IsAsm bool // is the source assembly language, which may contain surprising idioms (e.g., call tables) 701 702 // state for writing objects 703 Text []*LSym 704 Data []*LSym 705 706 // ABIAliases are text symbols that should be aliased to all 707 // ABIs. These symbols may only be referenced and not defined 708 // by this object, since the need for an alias may appear in a 709 // different object than the definition. Hence, this 710 // information can't be carried in the symbol definition. 711 // 712 // TODO(austin): Replace this with ABI wrappers once the ABIs 713 // actually diverge. 714 ABIAliases []*LSym 715 716 // Constant symbols (e.g. $i64.*) are data symbols created late 717 // in the concurrent phase. To ensure a deterministic order, we 718 // add them to a separate list, sort at the end, and append it 719 // to Data. 720 constSyms []*LSym 721 722 // pkgIdx maps package path to index. The index is used for 723 // symbol reference in the object file. 724 pkgIdx map[string]int32 725 726 defs []*LSym // list of defined symbols in the current package 727 hashed64defs []*LSym // list of defined short (64-bit or less) hashed (content-addressable) symbols 728 hasheddefs []*LSym // list of defined hashed (content-addressable) symbols 729 nonpkgdefs []*LSym // list of defined non-package symbols 730 nonpkgrefs []*LSym // list of referenced non-package symbols 731 732 Fingerprint goobj.FingerprintType // fingerprint of symbol indices, to catch index mismatch 733 } 734 735 func (ctxt *Link) Diag(format string, args ...interface{}) { 736 ctxt.Errors++ 737 ctxt.DiagFunc(format, args...) 738 } 739 740 func (ctxt *Link) Logf(format string, args ...interface{}) { 741 fmt.Fprintf(ctxt.Bso, format, args...) 742 ctxt.Bso.Flush() 743 } 744 745 // The smallest possible offset from the hardware stack pointer to a local 746 // variable on the stack. Architectures that use a link register save its value 747 // on the stack in the function prologue and so always have a pointer between 748 // the hardware stack pointer and the local variable area. 749 func (ctxt *Link) FixedFrameSize() int64 { 750 switch ctxt.Arch.Family { 751 case sys.AMD64, sys.I386, sys.Wasm: 752 return 0 753 case sys.PPC64: 754 // PIC code on ppc64le requires 32 bytes of stack, and it's easier to 755 // just use that much stack always on ppc64x. 756 return int64(4 * ctxt.Arch.PtrSize) 757 default: 758 return int64(ctxt.Arch.PtrSize) 759 } 760 } 761 762 // LinkArch is the definition of a single architecture. 763 type LinkArch struct { 764 *sys.Arch 765 Init func(*Link) 766 Preprocess func(*Link, *LSym, ProgAlloc) 767 Assemble func(*Link, *LSym, ProgAlloc) 768 Progedit func(*Link, *Prog, ProgAlloc) 769 UnaryDst map[As]bool // Instruction takes one operand, a destination. 770 DWARFRegisters map[int16]int16 771 } 772