Source file src/cmd/internal/obj/link.go
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 "bytes" 36 "cmd/internal/dwarf" 37 "cmd/internal/goobj" 38 "cmd/internal/objabi" 39 "cmd/internal/src" 40 "cmd/internal/sys" 41 "encoding/binary" 42 "fmt" 43 "internal/abi" 44 "sync" 45 "sync/atomic" 46 ) 47 48 // An Addr is an argument to an instruction. 49 // The general forms and their encodings are: 50 // 51 // sym±offset(symkind)(reg)(index*scale) 52 // Memory reference at address &sym(symkind) + offset + reg + index*scale. 53 // Any of sym(symkind), ±offset, (reg), (index*scale), and *scale can be omitted. 54 // If (reg) and *scale are both omitted, the resulting expression (index) is parsed as (reg). 55 // To force a parsing as index*scale, write (index*1). 56 // Encoding: 57 // type = TYPE_MEM 58 // name = symkind (NAME_AUTO, ...) or 0 (NAME_NONE) 59 // sym = sym 60 // offset = ±offset 61 // reg = reg (REG_*) 62 // index = index (REG_*) 63 // scale = scale (1, 2, 4, 8) 64 // 65 // $<mem> 66 // Effective address of memory reference <mem>, defined above. 67 // Encoding: same as memory reference, but type = TYPE_ADDR. 68 // 69 // $<±integer value> 70 // This is a special case of $<mem>, in which only ±offset is present. 71 // It has a separate type for easy recognition. 72 // Encoding: 73 // type = TYPE_CONST 74 // offset = ±integer value 75 // 76 // *<mem> 77 // Indirect reference through memory reference <mem>, defined above. 78 // Only used on x86 for CALL/JMP *sym(SB), which calls/jumps to a function 79 // pointer stored in the data word sym(SB), not a function named sym(SB). 80 // Encoding: same as above, but type = TYPE_INDIR. 81 // 82 // $*$<mem> 83 // No longer used. 84 // On machines with actual SB registers, $*$<mem> forced the 85 // instruction encoding to use a full 32-bit constant, never a 86 // reference relative to SB. 87 // 88 // $<floating point literal> 89 // Floating point constant value. 90 // Encoding: 91 // type = TYPE_FCONST 92 // val = floating point value 93 // 94 // $<string literal, up to 8 chars> 95 // String literal value (raw bytes used for DATA instruction). 96 // Encoding: 97 // type = TYPE_SCONST 98 // val = string 99 // 100 // <symbolic constant name> 101 // Special symbolic constants for ARM64 (such as conditional flags, tlbi_op and so on) 102 // and RISCV64 (such as names for vector configuration instruction arguments and CSRs). 103 // Encoding: 104 // type = TYPE_SPECIAL 105 // offset = The constant value corresponding to this symbol 106 // 107 // <register name> 108 // Any register: integer, floating point, control, segment, and so on. 109 // If looking for specific register kind, must check type and reg value range. 110 // Encoding: 111 // type = TYPE_REG 112 // reg = reg (REG_*) 113 // 114 // x(PC) 115 // Encoding: 116 // type = TYPE_BRANCH 117 // val = Prog* reference OR ELSE offset = target pc (branch takes priority) 118 // 119 // $±x-±y 120 // Final argument to TEXT, specifying local frame size x and argument size y. 121 // In this form, x and y are integer literals only, not arbitrary expressions. 122 // This avoids parsing ambiguities due to the use of - as a separator. 123 // The ± are optional. 124 // If the final argument to TEXT omits the -±y, the encoding should still 125 // use TYPE_TEXTSIZE (not TYPE_CONST), with u.argsize = ArgsSizeUnknown. 126 // Encoding: 127 // type = TYPE_TEXTSIZE 128 // offset = x 129 // val = int32(y) 130 // 131 // reg<<shift, reg>>shift, reg->shift, reg@>shift 132 // Shifted register value, for ARM and ARM64. 133 // In this form, reg must be a register and shift can be a register or an integer constant. 134 // Encoding: 135 // type = TYPE_SHIFT 136 // On ARM: 137 // offset = (reg&15) | shifttype<<5 | count 138 // shifttype = 0, 1, 2, 3 for <<, >>, ->, @> 139 // count = (reg&15)<<8 | 1<<4 for a register shift count, (n&31)<<7 for an integer constant. 140 // On ARM64: 141 // offset = (reg&31)<<16 | shifttype<<22 | (count&63)<<10 142 // shifttype = 0, 1, 2 for <<, >>, -> 143 // 144 // (reg, reg) 145 // A destination register pair. When used as the last argument of an instruction, 146 // this form makes clear that both registers are destinations. 147 // Encoding: 148 // type = TYPE_REGREG 149 // reg = first register 150 // offset = second register 151 // 152 // [reg, reg, reg-reg] 153 // Register list for ARM, ARM64, 386/AMD64. 154 // Encoding: 155 // type = TYPE_REGLIST 156 // On ARM: 157 // offset = bit mask of registers in list; R0 is low bit. 158 // On ARM64: 159 // offset = register count (Q:size) | arrangement (opcode) | first register 160 // On 386/AMD64: 161 // reg = range low register 162 // offset = 2 packed registers + kind tag (see x86.EncodeRegisterRange) 163 // 164 // reg, reg 165 // Register pair for ARM. 166 // TYPE_REGREG2 167 // 168 // (reg+reg) 169 // Register pair for PPC64. 170 // Encoding: 171 // type = TYPE_MEM 172 // reg = first register 173 // index = second register 174 // scale = 1 175 // 176 // reg.[US]XT[BHWX] 177 // Register extension for ARM64 178 // Encoding: 179 // type = TYPE_REG 180 // reg = REG_[US]XT[BHWX] + register + shift amount 181 // offset = ((reg&31) << 16) | (exttype << 13) | (amount<<10) 182 // 183 // reg.<T> 184 // Register arrangement for ARM64 and Loong64 SIMD register 185 // e.g.: 186 // On ARM64: V1.S4, V2.S2, V7.D2, V2.H4, V6.B16 187 // On Loong64: X1.B32, X1.H16, X1.W8, X2.V4, X1.Q1, V1.B16, V1.H8, V1.W4, V1.V2 188 // Encoding: 189 // type = TYPE_REG 190 // reg = REG_ARNG + register + arrangement 191 // 192 // reg.<T>[index] 193 // Register element for ARM64 and Loong64 194 // Encoding: 195 // type = TYPE_REG 196 // reg = REG_ELEM + register + arrangement 197 // index = element index 198 199 type Addr struct { 200 Reg int16 201 Index int16 202 Scale int16 // Sometimes holds a register. 203 Type AddrType 204 Name AddrName 205 Class int8 206 Offset int64 207 Sym *LSym 208 209 // argument value: 210 // for TYPE_SCONST, a string 211 // for TYPE_FCONST, a float64 212 // for TYPE_BRANCH, a *Prog (optional) 213 // for TYPE_TEXTSIZE, an int32 (optional) 214 Val any 215 } 216 217 type AddrName int8 218 219 const ( 220 NAME_NONE AddrName = iota 221 NAME_EXTERN 222 NAME_STATIC 223 NAME_AUTO 224 NAME_PARAM 225 // A reference to name@GOT(SB) is a reference to the entry in the global offset 226 // table for 'name'. 227 NAME_GOTREF 228 // Indicates that this is a reference to a TOC anchor. 229 NAME_TOCREF 230 ) 231 232 //go:generate stringer -type AddrType 233 234 type AddrType uint8 235 236 const ( 237 TYPE_NONE AddrType = iota 238 TYPE_BRANCH 239 TYPE_TEXTSIZE 240 TYPE_MEM 241 TYPE_CONST 242 TYPE_FCONST 243 TYPE_SCONST 244 TYPE_REG 245 TYPE_ADDR 246 TYPE_SHIFT 247 TYPE_REGREG 248 TYPE_REGREG2 249 TYPE_INDIR 250 TYPE_REGLIST 251 TYPE_SPECIAL 252 ) 253 254 func (a *Addr) Target() *Prog { 255 if a.Type == TYPE_BRANCH && a.Val != nil { 256 return a.Val.(*Prog) 257 } 258 return nil 259 } 260 func (a *Addr) SetTarget(t *Prog) { 261 if a.Type != TYPE_BRANCH { 262 panic("setting branch target when type is not TYPE_BRANCH") 263 } 264 a.Val = t 265 } 266 267 func (a *Addr) SetConst(v int64) { 268 a.Sym = nil 269 a.Type = TYPE_CONST 270 a.Offset = v 271 } 272 273 // Prog describes a single machine instruction. 274 // 275 // The general instruction form is: 276 // 277 // (1) As.Scond From [, ...RestArgs], To 278 // (2) As.Scond From, Reg [, ...RestArgs], To, RegTo2 279 // 280 // where As is an opcode and the others are arguments: 281 // From, Reg are sources, and To, RegTo2 are destinations. 282 // RestArgs can hold additional sources and destinations. 283 // Usually, not all arguments are present. 284 // For example, MOVL R1, R2 encodes using only As=MOVL, From=R1, To=R2. 285 // The Scond field holds additional condition bits for systems (like arm) 286 // that have generalized conditional execution. 287 // (2) form is present for compatibility with older code, 288 // to avoid too much changes in a single swing. 289 // (1) scheme is enough to express any kind of operand combination. 290 // 291 // Jump instructions use the To.Val field to point to the target *Prog, 292 // which must be in the same linked list as the jump instruction. 293 // 294 // The Progs for a given function are arranged in a list linked through the Link field. 295 // 296 // Each Prog is charged to a specific source line in the debug information, 297 // specified by Pos.Line(). 298 // Every Prog has a Ctxt field that defines its context. 299 // For performance reasons, Progs are usually bulk allocated, cached, and reused; 300 // those bulk allocators should always be used, rather than new(Prog). 301 // 302 // The other fields not yet mentioned are for use by the back ends and should 303 // be left zeroed by creators of Prog lists. 304 type Prog struct { 305 Ctxt *Link // linker context 306 Link *Prog // next Prog in linked list 307 From Addr // first source operand 308 RestArgs []AddrPos // can pack any operands that not fit into {Prog.From, Prog.To}, same kinds of operands are saved in order 309 To Addr // destination operand (second is RegTo2 below) 310 Pool *Prog // constant pool entry, for arm,arm64 back ends 311 Forwd *Prog // for x86 back end 312 Rel *Prog // for x86, arm back ends 313 Pc int64 // for back ends or assembler: virtual or actual program counter, depending on phase 314 Pos src.XPos // source position of this instruction 315 Spadj int32 // effect of instruction on stack pointer (increment or decrement amount) 316 As As // assembler opcode 317 Reg int16 // 2nd source operand 318 RegTo2 int16 // 2nd destination operand 319 Mark uint16 // bitmask of arch-specific items 320 Optab uint16 // arch-specific opcode index 321 Scond uint8 // bits that describe instruction suffixes (e.g. ARM conditions, RISCV Rounding Mode) 322 Back uint8 // for x86 back end: backwards branch state 323 Ft uint8 // for x86 back end: type index of Prog.From 324 Tt uint8 // for x86 back end: type index of Prog.To 325 Isize uint8 // for x86 back end: size of the instruction in bytes 326 } 327 328 // AddrPos indicates whether the operand is the source or the destination. 329 type AddrPos struct { 330 Addr 331 Pos OperandPos 332 } 333 334 type OperandPos int8 335 336 const ( 337 Source OperandPos = iota 338 Destination 339 ) 340 341 // From3Type returns p.GetFrom3().Type, or TYPE_NONE when 342 // p.GetFrom3() returns nil. 343 func (p *Prog) From3Type() AddrType { 344 from3 := p.GetFrom3() 345 if from3 == nil { 346 return TYPE_NONE 347 } 348 return from3.Type 349 } 350 351 // GetFrom3 returns second source operand (the first is Prog.From). 352 // The same kinds of operands are saved in order so GetFrom3 actually 353 // return the first source operand in p.RestArgs. 354 // In combination with Prog.From and Prog.To it makes common 3 operand 355 // case easier to use. 356 func (p *Prog) GetFrom3() *Addr { 357 for i := range p.RestArgs { 358 if p.RestArgs[i].Pos == Source { 359 return &p.RestArgs[i].Addr 360 } 361 } 362 return nil 363 } 364 365 // AddRestSource assigns []Args{{a, Source}} to p.RestArgs. 366 func (p *Prog) AddRestSource(a Addr) { 367 p.RestArgs = append(p.RestArgs, AddrPos{a, Source}) 368 } 369 370 // AddRestSourceReg calls p.AddRestSource with a register Addr containing reg. 371 func (p *Prog) AddRestSourceReg(reg int16) { 372 p.AddRestSource(Addr{Type: TYPE_REG, Reg: reg}) 373 } 374 375 // AddRestSourceConst calls p.AddRestSource with a const Addr containing off. 376 func (p *Prog) AddRestSourceConst(off int64) { 377 p.AddRestSource(Addr{Type: TYPE_CONST, Offset: off}) 378 } 379 380 // AddRestDest assigns []Args{{a, Destination}} to p.RestArgs when the second destination 381 // operand does not fit into prog.RegTo2. 382 func (p *Prog) AddRestDest(a Addr) { 383 p.RestArgs = append(p.RestArgs, AddrPos{a, Destination}) 384 } 385 386 // GetTo2 returns the second destination operand. 387 // The same kinds of operands are saved in order so GetTo2 actually 388 // return the first destination operand in Prog.RestArgs[] 389 func (p *Prog) GetTo2() *Addr { 390 for i := range p.RestArgs { 391 if p.RestArgs[i].Pos == Destination { 392 return &p.RestArgs[i].Addr 393 } 394 } 395 return nil 396 } 397 398 // AddRestSourceArgs assigns more than one source operands to p.RestArgs. 399 func (p *Prog) AddRestSourceArgs(args []Addr) { 400 for i := range args { 401 p.RestArgs = append(p.RestArgs, AddrPos{args[i], Source}) 402 } 403 } 404 405 // An As denotes an assembler opcode. 406 // There are some portable opcodes, declared here in package obj, 407 // that are common to all architectures. 408 // However, the majority of opcodes are arch-specific 409 // and are declared in their respective architecture's subpackage. 410 type As int16 411 412 // These are the portable opcodes. 413 const ( 414 AXXX As = iota 415 ACALL 416 ADUFFCOPY 417 ADUFFZERO 418 AEND 419 AFUNCDATA 420 AJMP 421 ANOP 422 APCALIGN 423 APCALIGNMAX // currently x86, amd64 and arm64 424 APCDATA 425 ARET 426 AGETCALLERPC 427 ATEXT 428 AUNDEF 429 A_ARCHSPECIFIC 430 ) 431 432 // Each architecture is allotted a distinct subspace of opcode values 433 // for declaring its arch-specific opcodes. 434 // Within this subspace, the first arch-specific opcode should be 435 // at offset A_ARCHSPECIFIC. 436 // 437 // Subspaces are aligned to a power of two so opcodes can be masked 438 // with AMask and used as compact array indices. 439 const ( 440 ABase386 = (1 + iota) << 11 441 ABaseARM 442 ABaseAMD64 443 ABasePPC64 444 ABaseARM64 445 ABaseMIPS 446 ABaseLoong64 447 ABaseRISCV 448 ABaseS390X 449 ABaseWasm 450 451 AllowedOpCodes = 1 << 11 // The number of opcodes available for any given architecture. 452 AMask = AllowedOpCodes - 1 // AND with this to use the opcode as an array index. 453 ) 454 455 // An LSym is the sort of symbol that is written to an object file. 456 // It represents Go symbols in a flat pkg+"."+name namespace. 457 type LSym struct { 458 Name string 459 Attribute 460 Type objabi.SymKind 461 462 Align int16 463 Size int64 464 Gotype *LSym 465 P []byte 466 R []Reloc 467 468 Extra *any // *FuncInfo, *VarInfo, *FileInfo, *TypeInfo, or *ItabInfo, if present 469 470 Pkg string 471 PkgIdx int32 472 SymIdx int32 473 } 474 475 // A FuncInfo contains extra fields for STEXT symbols. 476 type FuncInfo struct { 477 Args int32 478 Locals int32 479 FuncID abi.FuncID 480 FuncFlag abi.FuncFlag 481 StartLine int32 482 Text *Prog 483 Autot map[*LSym]struct{} 484 Pcln Pcln 485 InlMarks []InlMark 486 spills []RegSpill 487 488 dwarfInfoSym *LSym 489 dwarfLocSym *LSym 490 dwarfRangesSym *LSym 491 dwarfAbsFnSym *LSym 492 dwarfDebugLinesSym *LSym 493 494 GCArgs *LSym 495 GCLocals *LSym 496 StackObjects *LSym 497 OpenCodedDeferInfo *LSym 498 ArgInfo *LSym // argument info for traceback 499 ArgLiveInfo *LSym // argument liveness info for traceback 500 WrapInfo *LSym // for wrapper, info of wrapped function 501 JumpTables []JumpTable 502 503 FuncInfoSym *LSym 504 505 WasmImport *WasmImport 506 WasmExport *WasmExport 507 508 sehUnwindInfoSym *LSym 509 } 510 511 // JumpTable represents a table used for implementing multi-way 512 // computed branching, used typically for implementing switches. 513 // Sym is the table itself, and Targets is a list of target 514 // instructions to go to for the computed branch index. 515 type JumpTable struct { 516 Sym *LSym 517 Targets []*Prog 518 } 519 520 // NewFuncInfo allocates and returns a FuncInfo for LSym. 521 func (s *LSym) NewFuncInfo() *FuncInfo { 522 if s.Extra != nil { 523 panic(fmt.Sprintf("invalid use of LSym - NewFuncInfo with Extra of type %T", *s.Extra)) 524 } 525 f := new(FuncInfo) 526 s.Extra = new(any) 527 *s.Extra = f 528 return f 529 } 530 531 // Func returns the *FuncInfo associated with s, or else nil. 532 func (s *LSym) Func() *FuncInfo { 533 if s.Extra == nil { 534 return nil 535 } 536 f, _ := (*s.Extra).(*FuncInfo) 537 return f 538 } 539 540 type VarInfo struct { 541 dwarfInfoSym *LSym 542 } 543 544 // NewVarInfo allocates and returns a VarInfo for LSym. 545 func (s *LSym) NewVarInfo() *VarInfo { 546 if s.Extra != nil { 547 panic(fmt.Sprintf("invalid use of LSym - NewVarInfo with Extra of type %T", *s.Extra)) 548 } 549 f := new(VarInfo) 550 s.Extra = new(any) 551 *s.Extra = f 552 return f 553 } 554 555 // VarInfo returns the *VarInfo associated with s, or else nil. 556 func (s *LSym) VarInfo() *VarInfo { 557 if s.Extra == nil { 558 return nil 559 } 560 f, _ := (*s.Extra).(*VarInfo) 561 return f 562 } 563 564 // A FileInfo contains extra fields for SDATA symbols backed by files. 565 // (If LSym.Extra is a *FileInfo, LSym.P == nil.) 566 type FileInfo struct { 567 Name string // name of file to read into object file 568 Size int64 // length of file 569 } 570 571 // NewFileInfo allocates and returns a FileInfo for LSym. 572 func (s *LSym) NewFileInfo() *FileInfo { 573 if s.Extra != nil { 574 panic(fmt.Sprintf("invalid use of LSym - NewFileInfo with Extra of type %T", *s.Extra)) 575 } 576 f := new(FileInfo) 577 s.Extra = new(any) 578 *s.Extra = f 579 return f 580 } 581 582 // File returns the *FileInfo associated with s, or else nil. 583 func (s *LSym) File() *FileInfo { 584 if s.Extra == nil { 585 return nil 586 } 587 f, _ := (*s.Extra).(*FileInfo) 588 return f 589 } 590 591 // A TypeInfo contains information for a symbol 592 // that contains a runtime._type. 593 type TypeInfo struct { 594 Type any // a *cmd/compile/internal/types.Type 595 } 596 597 func (s *LSym) NewTypeInfo() *TypeInfo { 598 if s.Extra != nil { 599 panic(fmt.Sprintf("invalid use of LSym - NewTypeInfo with Extra of type %T", *s.Extra)) 600 } 601 t := new(TypeInfo) 602 s.Extra = new(any) 603 *s.Extra = t 604 return t 605 } 606 607 // TypeInfo returns the *TypeInfo associated with s, or else nil. 608 func (s *LSym) TypeInfo() *TypeInfo { 609 if s.Extra == nil { 610 return nil 611 } 612 t, _ := (*s.Extra).(*TypeInfo) 613 return t 614 } 615 616 // An ItabInfo contains information for a symbol 617 // that contains a runtime.itab. 618 type ItabInfo struct { 619 Type any // a *cmd/compile/internal/types.Type 620 } 621 622 func (s *LSym) NewItabInfo() *ItabInfo { 623 if s.Extra != nil { 624 panic(fmt.Sprintf("invalid use of LSym - NewItabInfo with Extra of type %T", *s.Extra)) 625 } 626 t := new(ItabInfo) 627 s.Extra = new(any) 628 *s.Extra = t 629 return t 630 } 631 632 // ItabInfo returns the *ItabInfo associated with s, or else nil. 633 func (s *LSym) ItabInfo() *ItabInfo { 634 if s.Extra == nil { 635 return nil 636 } 637 i, _ := (*s.Extra).(*ItabInfo) 638 return i 639 } 640 641 // WasmImport represents a WebAssembly (WASM) imported function with 642 // parameters and results translated into WASM types based on the Go function 643 // declaration. 644 type WasmImport struct { 645 // Module holds the WASM module name specified by the //go:wasmimport 646 // directive. 647 Module string 648 // Name holds the WASM imported function name specified by the 649 // //go:wasmimport directive. 650 Name string 651 652 WasmFuncType // type of the imported function 653 654 // aux symbol to pass metadata to the linker, serialization of 655 // the fields above. 656 AuxSym *LSym 657 } 658 659 func (wi *WasmImport) CreateAuxSym() { 660 var b bytes.Buffer 661 wi.Write(&b) 662 p := b.Bytes() 663 wi.AuxSym = &LSym{ 664 Type: objabi.SDATA, // doesn't really matter 665 P: append([]byte(nil), p...), 666 Size: int64(len(p)), 667 } 668 } 669 670 func (wi *WasmImport) Write(w *bytes.Buffer) { 671 var b [8]byte 672 writeUint32 := func(x uint32) { 673 binary.LittleEndian.PutUint32(b[:], x) 674 w.Write(b[:4]) 675 } 676 writeString := func(s string) { 677 writeUint32(uint32(len(s))) 678 w.WriteString(s) 679 } 680 writeString(wi.Module) 681 writeString(wi.Name) 682 wi.WasmFuncType.Write(w) 683 } 684 685 func (wi *WasmImport) Read(b []byte) { 686 readUint32 := func() uint32 { 687 x := binary.LittleEndian.Uint32(b) 688 b = b[4:] 689 return x 690 } 691 readString := func() string { 692 n := readUint32() 693 s := string(b[:n]) 694 b = b[n:] 695 return s 696 } 697 wi.Module = readString() 698 wi.Name = readString() 699 wi.WasmFuncType.Read(b) 700 } 701 702 // WasmFuncType represents a WebAssembly (WASM) function type with 703 // parameters and results translated into WASM types based on the Go function 704 // declaration. 705 type WasmFuncType struct { 706 // Params holds the function parameter fields. 707 Params []WasmField 708 // Results holds the function result fields. 709 Results []WasmField 710 } 711 712 func (ft *WasmFuncType) Write(w *bytes.Buffer) { 713 var b [8]byte 714 writeByte := func(x byte) { 715 w.WriteByte(x) 716 } 717 writeUint32 := func(x uint32) { 718 binary.LittleEndian.PutUint32(b[:], x) 719 w.Write(b[:4]) 720 } 721 writeInt64 := func(x int64) { 722 binary.LittleEndian.PutUint64(b[:], uint64(x)) 723 w.Write(b[:]) 724 } 725 writeUint32(uint32(len(ft.Params))) 726 for _, f := range ft.Params { 727 writeByte(byte(f.Type)) 728 writeInt64(f.Offset) 729 } 730 writeUint32(uint32(len(ft.Results))) 731 for _, f := range ft.Results { 732 writeByte(byte(f.Type)) 733 writeInt64(f.Offset) 734 } 735 } 736 737 func (ft *WasmFuncType) Read(b []byte) { 738 readByte := func() byte { 739 x := b[0] 740 b = b[1:] 741 return x 742 } 743 readUint32 := func() uint32 { 744 x := binary.LittleEndian.Uint32(b) 745 b = b[4:] 746 return x 747 } 748 readInt64 := func() int64 { 749 x := binary.LittleEndian.Uint64(b) 750 b = b[8:] 751 return int64(x) 752 } 753 ft.Params = make([]WasmField, readUint32()) 754 for i := range ft.Params { 755 ft.Params[i].Type = WasmFieldType(readByte()) 756 ft.Params[i].Offset = readInt64() 757 } 758 ft.Results = make([]WasmField, readUint32()) 759 for i := range ft.Results { 760 ft.Results[i].Type = WasmFieldType(readByte()) 761 ft.Results[i].Offset = readInt64() 762 } 763 } 764 765 // WasmExport represents a WebAssembly (WASM) exported function with 766 // parameters and results translated into WASM types based on the Go function 767 // declaration. 768 type WasmExport struct { 769 WasmFuncType 770 771 WrappedSym *LSym // the wrapped Go function 772 AuxSym *LSym // aux symbol to pass metadata to the linker 773 } 774 775 func (we *WasmExport) CreateAuxSym() { 776 var b bytes.Buffer 777 we.WasmFuncType.Write(&b) 778 p := b.Bytes() 779 we.AuxSym = &LSym{ 780 Type: objabi.SDATA, // doesn't really matter 781 P: append([]byte(nil), p...), 782 Size: int64(len(p)), 783 } 784 } 785 786 type WasmField struct { 787 Type WasmFieldType 788 // Offset holds the frame-pointer-relative locations for Go's stack-based 789 // ABI. This is used by the src/cmd/internal/wasm package to map WASM 790 // import parameters to the Go stack in a wrapper function. 791 Offset int64 792 } 793 794 type WasmFieldType byte 795 796 const ( 797 WasmI32 WasmFieldType = iota 798 WasmI64 799 WasmF32 800 WasmF64 801 WasmPtr 802 WasmV128 803 804 // bool is not really a wasm type, but we allow it on wasmimport/wasmexport 805 // function parameters/results. 32-bit on Wasm side, 8-bit on Go side. 806 WasmBool 807 ) 808 809 type InlMark struct { 810 // When unwinding from an instruction in an inlined body, mark 811 // where we should unwind to. 812 // id records the global inlining id of the inlined body. 813 // p records the location of an instruction in the parent (inliner) frame. 814 p *Prog 815 id int32 816 } 817 818 // Mark p as the instruction to set as the pc when 819 // "unwinding" the inlining global frame id. Usually it should be 820 // instruction with a file:line at the callsite, and occur 821 // just before the body of the inlined function. 822 func (fi *FuncInfo) AddInlMark(p *Prog, id int32) { 823 fi.InlMarks = append(fi.InlMarks, InlMark{p: p, id: id}) 824 } 825 826 // AddSpill appends a spill record to the list for FuncInfo fi 827 func (fi *FuncInfo) AddSpill(s RegSpill) { 828 fi.spills = append(fi.spills, s) 829 } 830 831 // Record the type symbol for an auto variable so that the linker 832 // an emit DWARF type information for the type. 833 func (fi *FuncInfo) RecordAutoType(gotype *LSym) { 834 if fi.Autot == nil { 835 fi.Autot = make(map[*LSym]struct{}) 836 } 837 fi.Autot[gotype] = struct{}{} 838 } 839 840 //go:generate stringer -type ABI 841 842 // ABI is the calling convention of a text symbol. 843 type ABI uint8 844 845 const ( 846 // ABI0 is the stable stack-based ABI. It's important that the 847 // value of this is "0": we can't distinguish between 848 // references to data and ABI0 text symbols in assembly code, 849 // and hence this doesn't distinguish between symbols without 850 // an ABI and text symbols with ABI0. 851 ABI0 ABI = iota 852 853 // ABIInternal is the internal ABI that may change between Go 854 // versions. All Go functions use the internal ABI and the 855 // compiler generates wrappers for calls to and from other 856 // ABIs. 857 ABIInternal 858 859 ABICount 860 ) 861 862 // ParseABI converts from a string representation in 'abistr' to the 863 // corresponding ABI value. Second return value is TRUE if the 864 // abi string is recognized, FALSE otherwise. 865 func ParseABI(abistr string) (ABI, bool) { 866 switch abistr { 867 default: 868 return ABI0, false 869 case "ABI0": 870 return ABI0, true 871 case "ABIInternal": 872 return ABIInternal, true 873 } 874 } 875 876 // ABISet is a bit set of ABI values. 877 type ABISet uint8 878 879 const ( 880 // ABISetCallable is the set of all ABIs any function could 881 // potentially be called using. 882 ABISetCallable ABISet = (1 << ABI0) | (1 << ABIInternal) 883 ) 884 885 // Ensure ABISet is big enough to hold all ABIs. 886 var _ ABISet = 1 << (ABICount - 1) 887 888 func ABISetOf(abi ABI) ABISet { 889 return 1 << abi 890 } 891 892 func (a *ABISet) Set(abi ABI, value bool) { 893 if value { 894 *a |= 1 << abi 895 } else { 896 *a &^= 1 << abi 897 } 898 } 899 900 func (a *ABISet) Get(abi ABI) bool { 901 return (*a>>abi)&1 != 0 902 } 903 904 func (a ABISet) String() string { 905 s := "{" 906 for i := ABI(0); a != 0; i++ { 907 if a&(1<<i) != 0 { 908 if s != "{" { 909 s += "," 910 } 911 s += i.String() 912 a &^= 1 << i 913 } 914 } 915 return s + "}" 916 } 917 918 // Attribute is a set of symbol attributes. 919 type Attribute uint32 920 921 const ( 922 AttrDuplicateOK Attribute = 1 << iota 923 AttrCFunc 924 AttrNoSplit 925 AttrLeaf 926 AttrWrapper 927 AttrNeedCtxt 928 AttrNoFrame 929 AttrOnList 930 AttrStatic 931 932 // MakeTypelink means that the type should have an entry in the typelink table. 933 AttrMakeTypelink 934 935 // ReflectMethod means the function may call reflect.Type.Method or 936 // reflect.Type.MethodByName. Matching is imprecise (as reflect.Type 937 // can be used through a custom interface), so ReflectMethod may be 938 // set in some cases when the reflect package is not called. 939 // 940 // Used by the linker to determine what methods can be pruned. 941 AttrReflectMethod 942 943 // Local means make the symbol local even when compiling Go code to reference Go 944 // symbols in other shared libraries, as in this mode symbols are global by 945 // default. "local" here means in the sense of the dynamic linker, i.e. not 946 // visible outside of the module (shared library or executable) that contains its 947 // definition. (When not compiling to support Go shared libraries, all symbols are 948 // local in this sense unless there is a cgo_export_* directive). 949 AttrLocal 950 951 // For function symbols; indicates that the specified function was the 952 // target of an inline during compilation 953 AttrWasInlined 954 955 // Indexed indicates this symbol has been assigned with an index (when using the 956 // new object file format). 957 AttrIndexed 958 959 // Only applied on type descriptor symbols, UsedInIface indicates this type is 960 // converted to an interface. 961 // 962 // Used by the linker to determine what methods can be pruned. 963 AttrUsedInIface 964 965 // ContentAddressable indicates this is a content-addressable symbol. 966 AttrContentAddressable 967 968 // ABI wrapper is set for compiler-generated text symbols that 969 // convert between ABI0 and ABIInternal calling conventions. 970 AttrABIWrapper 971 972 // IsPcdata indicates this is a pcdata symbol. 973 AttrPcdata 974 975 // PkgInit indicates this is a compiler-generated package init func. 976 AttrPkgInit 977 978 // Linkname indicates this is a go:linkname'd symbol. 979 AttrLinkname 980 981 // LinknameStd indicates this is a go:linknamestd'd symbol. 982 AttrLinknameStd 983 984 // attrABIBase is the value at which the ABI is encoded in 985 // Attribute. This must be last; all bits after this are 986 // assumed to be an ABI value. 987 // 988 // MUST BE LAST since all bits above this comprise the ABI. 989 attrABIBase 990 ) 991 992 func (a *Attribute) load() Attribute { return Attribute(atomic.LoadUint32((*uint32)(a))) } 993 994 func (a *Attribute) DuplicateOK() bool { return a.load()&AttrDuplicateOK != 0 } 995 func (a *Attribute) MakeTypelink() bool { return a.load()&AttrMakeTypelink != 0 } 996 func (a *Attribute) CFunc() bool { return a.load()&AttrCFunc != 0 } 997 func (a *Attribute) NoSplit() bool { return a.load()&AttrNoSplit != 0 } 998 func (a *Attribute) Leaf() bool { return a.load()&AttrLeaf != 0 } 999 func (a *Attribute) OnList() bool { return a.load()&AttrOnList != 0 } 1000 func (a *Attribute) ReflectMethod() bool { return a.load()&AttrReflectMethod != 0 } 1001 func (a *Attribute) Local() bool { return a.load()&AttrLocal != 0 } 1002 func (a *Attribute) Wrapper() bool { return a.load()&AttrWrapper != 0 } 1003 func (a *Attribute) NeedCtxt() bool { return a.load()&AttrNeedCtxt != 0 } 1004 func (a *Attribute) NoFrame() bool { return a.load()&AttrNoFrame != 0 } 1005 func (a *Attribute) Static() bool { return a.load()&AttrStatic != 0 } 1006 func (a *Attribute) WasInlined() bool { return a.load()&AttrWasInlined != 0 } 1007 func (a *Attribute) Indexed() bool { return a.load()&AttrIndexed != 0 } 1008 func (a *Attribute) UsedInIface() bool { return a.load()&AttrUsedInIface != 0 } 1009 func (a *Attribute) ContentAddressable() bool { return a.load()&AttrContentAddressable != 0 } 1010 func (a *Attribute) ABIWrapper() bool { return a.load()&AttrABIWrapper != 0 } 1011 func (a *Attribute) IsPcdata() bool { return a.load()&AttrPcdata != 0 } 1012 func (a *Attribute) IsPkgInit() bool { return a.load()&AttrPkgInit != 0 } 1013 func (a *Attribute) IsLinkname() bool { return a.load()&AttrLinkname != 0 } 1014 func (a *Attribute) IsLinknameStd() bool { return a.load()&AttrLinknameStd != 0 } 1015 1016 func (a *Attribute) Set(flag Attribute, value bool) { 1017 for { 1018 v0 := a.load() 1019 v := v0 1020 if value { 1021 v |= flag 1022 } else { 1023 v &^= flag 1024 } 1025 if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) { 1026 break 1027 } 1028 } 1029 } 1030 1031 func (a *Attribute) ABI() ABI { return ABI(a.load() / attrABIBase) } 1032 func (a *Attribute) SetABI(abi ABI) { 1033 const mask = 1 // Only one ABI bit for now. 1034 for { 1035 v0 := a.load() 1036 v := (v0 &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase 1037 if atomic.CompareAndSwapUint32((*uint32)(a), uint32(v0), uint32(v)) { 1038 break 1039 } 1040 } 1041 } 1042 1043 var textAttrStrings = [...]struct { 1044 bit Attribute 1045 s string 1046 }{ 1047 {bit: AttrDuplicateOK, s: "DUPOK"}, 1048 {bit: AttrMakeTypelink, s: ""}, 1049 {bit: AttrCFunc, s: "CFUNC"}, 1050 {bit: AttrNoSplit, s: "NOSPLIT"}, 1051 {bit: AttrLeaf, s: "LEAF"}, 1052 {bit: AttrOnList, s: ""}, 1053 {bit: AttrReflectMethod, s: "REFLECTMETHOD"}, 1054 {bit: AttrLocal, s: "LOCAL"}, 1055 {bit: AttrWrapper, s: "WRAPPER"}, 1056 {bit: AttrNeedCtxt, s: "NEEDCTXT"}, 1057 {bit: AttrNoFrame, s: "NOFRAME"}, 1058 {bit: AttrStatic, s: "STATIC"}, 1059 {bit: AttrWasInlined, s: ""}, 1060 {bit: AttrIndexed, s: ""}, 1061 {bit: AttrContentAddressable, s: ""}, 1062 {bit: AttrABIWrapper, s: "ABIWRAPPER"}, 1063 {bit: AttrPkgInit, s: "PKGINIT"}, 1064 {bit: AttrLinkname, s: "LINKNAME"}, 1065 {bit: AttrLinknameStd, s: "LINKNAMESTD"}, 1066 } 1067 1068 // String formats a for printing in as part of a TEXT prog. 1069 func (a Attribute) String() string { 1070 var s string 1071 for _, x := range textAttrStrings { 1072 if a&x.bit != 0 { 1073 if x.s != "" { 1074 s += x.s + "|" 1075 } 1076 a &^= x.bit 1077 } 1078 } 1079 switch a.ABI() { 1080 case ABI0: 1081 case ABIInternal: 1082 s += "ABIInternal|" 1083 a.SetABI(0) // Clear ABI so we don't print below. 1084 } 1085 if a != 0 { 1086 s += fmt.Sprintf("UnknownAttribute(%d)|", a) 1087 } 1088 // Chop off trailing |, if present. 1089 if len(s) > 0 { 1090 s = s[:len(s)-1] 1091 } 1092 return s 1093 } 1094 1095 // TextAttrString formats the symbol attributes for printing in as part of a TEXT prog. 1096 func (s *LSym) TextAttrString() string { 1097 attr := s.Attribute.String() 1098 if s.Func().FuncFlag&abi.FuncFlagTopFrame != 0 { 1099 if attr != "" { 1100 attr += "|" 1101 } 1102 attr += "TOPFRAME" 1103 } 1104 return attr 1105 } 1106 1107 func (s *LSym) String() string { 1108 return s.Name 1109 } 1110 1111 // The compiler needs *LSym to be assignable to cmd/compile/internal/ssa.Sym. 1112 func (*LSym) CanBeAnSSASym() {} 1113 func (*LSym) CanBeAnSSAAux() {} 1114 1115 type Pcln struct { 1116 // Aux symbols for pcln 1117 Pcsp *LSym 1118 Pcfile *LSym 1119 Pcline *LSym 1120 Pcinline *LSym 1121 Pcdata []*LSym 1122 Funcdata []*LSym 1123 UsedFiles map[goobj.CUFileIndex]struct{} // file indices used while generating pcfile 1124 InlTree InlTree // per-function inlining tree extracted from the global tree 1125 } 1126 1127 type Reloc struct { 1128 Off int32 1129 Siz uint8 1130 Type objabi.RelocType 1131 Add int64 1132 Sym *LSym 1133 } 1134 1135 type Auto struct { 1136 Asym *LSym 1137 Aoffset int32 1138 Name AddrName 1139 Gotype *LSym 1140 } 1141 1142 // RegSpill provides spill/fill information for a register-resident argument 1143 // to a function. These need spilling/filling in the safepoint/stackgrowth case. 1144 // At the time of fill/spill, the offset must be adjusted by the architecture-dependent 1145 // adjustment to hardware SP that occurs in a call instruction. E.g., for AMD64, 1146 // at Offset+8 because the return address was pushed. 1147 type RegSpill struct { 1148 Addr Addr 1149 Reg int16 1150 Reg2 int16 // If not 0, a second register to spill at Addr+regSize. Only for some archs. 1151 Spill, Unspill As 1152 } 1153 1154 // A Func represents a Go function. If non-nil, it must be a *ir.Func. 1155 type Func interface { 1156 Pos() src.XPos 1157 } 1158 1159 // Link holds the context for writing object code from a compiler 1160 // to be linker input or for reading that input into the linker. 1161 type Link struct { 1162 Headtype objabi.HeadType 1163 Arch *LinkArch 1164 CompressInstructions bool // use compressed instructions where possible (if supported by architecture) 1165 Debugasm int 1166 Debugvlog bool 1167 Debugpcln string 1168 Flag_shared bool 1169 Flag_dynlink bool 1170 Flag_linkshared bool 1171 Flag_optimize bool 1172 Flag_locationlists bool 1173 Flag_noRefName bool // do not include referenced symbol names in object file 1174 Retpoline bool // emit use of retpoline stubs for indirect jmp/call 1175 Flag_maymorestack string // If not "", call this function before stack checks 1176 Bso *bufio.Writer 1177 Pathname string 1178 Pkgpath string // the current package's import path 1179 1180 hashmu sync.Mutex // protects hash, funchash 1181 hash sync.Map // name(string) -> sym(*syncOnce) mapping 1182 funchash sync.Map // name(string) -> sym(*syncOnce) mapping for ABIInternal syms 1183 statichash map[string]*LSym // name -> sym mapping for static syms 1184 PosTable src.PosTable 1185 InlTree InlTree // global inlining tree used by gc/inl.go 1186 DwFixups *DwarfFixupTable 1187 DwTextCount int 1188 Imports []goobj.ImportedPkg 1189 DiagFunc func(string, ...any) 1190 DiagFlush func() 1191 DebugInfo func(ctxt *Link, fn *LSym, info *LSym, curfn Func) ([]dwarf.Scope, dwarf.InlCalls) 1192 GenAbstractFunc func(fn *LSym) 1193 Errors int 1194 1195 InParallel bool // parallel backend phase in effect 1196 UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges 1197 IsAsm bool // is the source assembly language, which may contain surprising idioms (e.g., call tables) 1198 Std bool // is standard library package 1199 1200 // state for writing objects 1201 Text []*LSym 1202 Data []*LSym 1203 1204 // Constant symbols (e.g. $i64.*) are data symbols created late 1205 // in the concurrent phase. To ensure a deterministic order, we 1206 // add them to a separate list, sort at the end, and append it 1207 // to Data. 1208 constSyms []*LSym 1209 1210 // Windows SEH symbols are also data symbols that can be created 1211 // concurrently. 1212 SEHSyms []*LSym 1213 1214 // pkgIdx maps package path to index. The index is used for 1215 // symbol reference in the object file. 1216 pkgIdx map[string]int32 1217 1218 defs []*LSym // list of defined symbols in the current package 1219 hashed64defs []*LSym // list of defined short (64-bit or less) hashed (content-addressable) symbols 1220 hasheddefs []*LSym // list of defined hashed (content-addressable) symbols 1221 nonpkgdefs []*LSym // list of defined non-package symbols 1222 nonpkgrefs []*LSym // list of referenced non-package symbols 1223 1224 Fingerprint goobj.FingerprintType // fingerprint of symbol indices, to catch index mismatch 1225 } 1226 1227 // symOnce is a "marker" value for our sync.Maps. We insert it on lookup and 1228 // use the atomic value to check whether initialization has been completed. 1229 type symOnce struct { 1230 sym LSym 1231 inited atomic.Bool 1232 } 1233 1234 // Assert to vet's printf checker that Link.DiagFunc is a printf-like. 1235 func _(ctxt *Link) { 1236 ctxt.DiagFunc = func(format string, args ...any) { 1237 _ = fmt.Sprintf(format, args...) 1238 } 1239 } 1240 1241 func (ctxt *Link) Diag(format string, args ...any) { 1242 ctxt.Errors++ 1243 ctxt.DiagFunc(format, args...) 1244 } 1245 1246 func (ctxt *Link) Logf(format string, args ...any) { 1247 fmt.Fprintf(ctxt.Bso, format, args...) 1248 ctxt.Bso.Flush() 1249 } 1250 1251 // SpillRegisterArgs emits the code to spill register args into whatever 1252 // locations the spill records specify. 1253 func (fi *FuncInfo) SpillRegisterArgs(last *Prog, pa ProgAlloc) *Prog { 1254 // Spill register args. 1255 for _, ra := range fi.spills { 1256 spill := Appendp(last, pa) 1257 spill.As = ra.Spill 1258 spill.From.Type = TYPE_REG 1259 spill.From.Reg = ra.Reg 1260 if ra.Reg2 != 0 { 1261 spill.From.Type = TYPE_REGREG 1262 spill.From.Offset = int64(ra.Reg2) 1263 } 1264 spill.To = ra.Addr 1265 last = spill 1266 } 1267 return last 1268 } 1269 1270 // UnspillRegisterArgs emits the code to restore register args from whatever 1271 // locations the spill records specify. 1272 func (fi *FuncInfo) UnspillRegisterArgs(last *Prog, pa ProgAlloc) *Prog { 1273 // Unspill any spilled register args 1274 for _, ra := range fi.spills { 1275 unspill := Appendp(last, pa) 1276 unspill.As = ra.Unspill 1277 unspill.From = ra.Addr 1278 unspill.To.Type = TYPE_REG 1279 unspill.To.Reg = ra.Reg 1280 if ra.Reg2 != 0 { 1281 unspill.To.Type = TYPE_REGREG 1282 unspill.To.Offset = int64(ra.Reg2) 1283 } 1284 last = unspill 1285 } 1286 return last 1287 } 1288 1289 // LinkArch is the definition of a single architecture. 1290 type LinkArch struct { 1291 *sys.Arch 1292 Init func(*Link) 1293 ErrorCheck func(*Link, *LSym) 1294 Preprocess func(*Link, *LSym, ProgAlloc) 1295 Assemble func(*Link, *LSym, ProgAlloc) 1296 Progedit func(*Link, *Prog, ProgAlloc) 1297 SEH func(*Link, *LSym) *LSym 1298 UnaryDst map[As]bool // Instruction takes one operand, a destination. 1299 DWARFRegisters map[int16]int16 1300 } 1301