link.go raw
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