podman

1
// Copyright 2013 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
// Writing Go object files.
6

7
package obj
8

9
import (
10
	"bytes"
11
	"github.com/twitchyliquid64/golang-asm/bio"
12
	"github.com/twitchyliquid64/golang-asm/goobj"
13
	"github.com/twitchyliquid64/golang-asm/objabi"
14
	"github.com/twitchyliquid64/golang-asm/sys"
15
	"crypto/sha1"
16
	"encoding/binary"
17
	"fmt"
18
	"io"
19
	"path/filepath"
20
	"sort"
21
	"strings"
22
)
23

24
// Entry point of writing new object file.
25
func WriteObjFile(ctxt *Link, b *bio.Writer) {
26

27
	debugAsmEmit(ctxt)
28

29
	genFuncInfoSyms(ctxt)
30

31
	w := writer{
32
		Writer:  goobj.NewWriter(b),
33
		ctxt:    ctxt,
34
		pkgpath: objabi.PathToPrefix(ctxt.Pkgpath),
35
	}
36

37
	start := b.Offset()
38
	w.init()
39

40
	// Header
41
	// We just reserve the space. We'll fill in the offsets later.
42
	flags := uint32(0)
43
	if ctxt.Flag_shared {
44
		flags |= goobj.ObjFlagShared
45
	}
46
	if w.pkgpath == "" {
47
		flags |= goobj.ObjFlagNeedNameExpansion
48
	}
49
	if ctxt.IsAsm {
50
		flags |= goobj.ObjFlagFromAssembly
51
	}
52
	h := goobj.Header{
53
		Magic:       goobj.Magic,
54
		Fingerprint: ctxt.Fingerprint,
55
		Flags:       flags,
56
	}
57
	h.Write(w.Writer)
58

59
	// String table
60
	w.StringTable()
61

62
	// Autolib
63
	h.Offsets[goobj.BlkAutolib] = w.Offset()
64
	for i := range ctxt.Imports {
65
		ctxt.Imports[i].Write(w.Writer)
66
	}
67

68
	// Package references
69
	h.Offsets[goobj.BlkPkgIdx] = w.Offset()
70
	for _, pkg := range w.pkglist {
71
		w.StringRef(pkg)
72
	}
73

74
	// File table (for DWARF and pcln generation).
75
	h.Offsets[goobj.BlkFile] = w.Offset()
76
	for _, f := range ctxt.PosTable.FileTable() {
77
		w.StringRef(filepath.ToSlash(f))
78
	}
79

80
	// Symbol definitions
81
	h.Offsets[goobj.BlkSymdef] = w.Offset()
82
	for _, s := range ctxt.defs {
83
		w.Sym(s)
84
	}
85

86
	// Short hashed symbol definitions
87
	h.Offsets[goobj.BlkHashed64def] = w.Offset()
88
	for _, s := range ctxt.hashed64defs {
89
		w.Sym(s)
90
	}
91

92
	// Hashed symbol definitions
93
	h.Offsets[goobj.BlkHasheddef] = w.Offset()
94
	for _, s := range ctxt.hasheddefs {
95
		w.Sym(s)
96
	}
97

98
	// Non-pkg symbol definitions
99
	h.Offsets[goobj.BlkNonpkgdef] = w.Offset()
100
	for _, s := range ctxt.nonpkgdefs {
101
		w.Sym(s)
102
	}
103

104
	// Non-pkg symbol references
105
	h.Offsets[goobj.BlkNonpkgref] = w.Offset()
106
	for _, s := range ctxt.nonpkgrefs {
107
		w.Sym(s)
108
	}
109

110
	// Referenced package symbol flags
111
	h.Offsets[goobj.BlkRefFlags] = w.Offset()
112
	w.refFlags()
113

114
	// Hashes
115
	h.Offsets[goobj.BlkHash64] = w.Offset()
116
	for _, s := range ctxt.hashed64defs {
117
		w.Hash64(s)
118
	}
119
	h.Offsets[goobj.BlkHash] = w.Offset()
120
	for _, s := range ctxt.hasheddefs {
121
		w.Hash(s)
122
	}
123
	// TODO: hashedrefs unused/unsupported for now
124

125
	// Reloc indexes
126
	h.Offsets[goobj.BlkRelocIdx] = w.Offset()
127
	nreloc := uint32(0)
128
	lists := [][]*LSym{ctxt.defs, ctxt.hashed64defs, ctxt.hasheddefs, ctxt.nonpkgdefs}
129
	for _, list := range lists {
130
		for _, s := range list {
131
			w.Uint32(nreloc)
132
			nreloc += uint32(len(s.R))
133
		}
134
	}
135
	w.Uint32(nreloc)
136

137
	// Symbol Info indexes
138
	h.Offsets[goobj.BlkAuxIdx] = w.Offset()
139
	naux := uint32(0)
140
	for _, list := range lists {
141
		for _, s := range list {
142
			w.Uint32(naux)
143
			naux += uint32(nAuxSym(s))
144
		}
145
	}
146
	w.Uint32(naux)
147

148
	// Data indexes
149
	h.Offsets[goobj.BlkDataIdx] = w.Offset()
150
	dataOff := uint32(0)
151
	for _, list := range lists {
152
		for _, s := range list {
153
			w.Uint32(dataOff)
154
			dataOff += uint32(len(s.P))
155
		}
156
	}
157
	w.Uint32(dataOff)
158

159
	// Relocs
160
	h.Offsets[goobj.BlkReloc] = w.Offset()
161
	for _, list := range lists {
162
		for _, s := range list {
163
			for i := range s.R {
164
				w.Reloc(&s.R[i])
165
			}
166
		}
167
	}
168

169
	// Aux symbol info
170
	h.Offsets[goobj.BlkAux] = w.Offset()
171
	for _, list := range lists {
172
		for _, s := range list {
173
			w.Aux(s)
174
		}
175
	}
176

177
	// Data
178
	h.Offsets[goobj.BlkData] = w.Offset()
179
	for _, list := range lists {
180
		for _, s := range list {
181
			w.Bytes(s.P)
182
		}
183
	}
184

185
	// Pcdata
186
	h.Offsets[goobj.BlkPcdata] = w.Offset()
187
	for _, s := range ctxt.Text { // iteration order must match genFuncInfoSyms
188
		if s.Func != nil {
189
			pc := &s.Func.Pcln
190
			w.Bytes(pc.Pcsp.P)
191
			w.Bytes(pc.Pcfile.P)
192
			w.Bytes(pc.Pcline.P)
193
			w.Bytes(pc.Pcinline.P)
194
			for i := range pc.Pcdata {
195
				w.Bytes(pc.Pcdata[i].P)
196
			}
197
		}
198
	}
199

200
	// Blocks used only by tools (objdump, nm).
201

202
	// Referenced symbol names from other packages
203
	h.Offsets[goobj.BlkRefName] = w.Offset()
204
	w.refNames()
205

206
	h.Offsets[goobj.BlkEnd] = w.Offset()
207

208
	// Fix up block offsets in the header
209
	end := start + int64(w.Offset())
210
	b.MustSeek(start, 0)
211
	h.Write(w.Writer)
212
	b.MustSeek(end, 0)
213
}
214

215
type writer struct {
216
	*goobj.Writer
217
	ctxt    *Link
218
	pkgpath string   // the package import path (escaped), "" if unknown
219
	pkglist []string // list of packages referenced, indexed by ctxt.pkgIdx
220
}
221

222
// prepare package index list
223
func (w *writer) init() {
224
	w.pkglist = make([]string, len(w.ctxt.pkgIdx)+1)
225
	w.pkglist[0] = "" // dummy invalid package for index 0
226
	for pkg, i := range w.ctxt.pkgIdx {
227
		w.pkglist[i] = pkg
228
	}
229
}
230

231
func (w *writer) StringTable() {
232
	w.AddString("")
233
	for _, p := range w.ctxt.Imports {
234
		w.AddString(p.Pkg)
235
	}
236
	for _, pkg := range w.pkglist {
237
		w.AddString(pkg)
238
	}
239
	w.ctxt.traverseSyms(traverseAll, func(s *LSym) {
240
		// TODO: this includes references of indexed symbols from other packages,
241
		// for which the linker doesn't need the name. Consider moving them to
242
		// a separate block (for tools only).
243
		if w.pkgpath != "" {
244
			s.Name = strings.Replace(s.Name, "\"\".", w.pkgpath+".", -1)
245
		}
246
		// Don't put names of builtins into the string table (to save
247
		// space).
248
		if s.PkgIdx == goobj.PkgIdxBuiltin {
249
			return
250
		}
251
		w.AddString(s.Name)
252
	})
253

254
	// All filenames are in the postable.
255
	for _, f := range w.ctxt.PosTable.FileTable() {
256
		w.AddString(filepath.ToSlash(f))
257
	}
258
}
259

260
func (w *writer) Sym(s *LSym) {
261
	abi := uint16(s.ABI())
262
	if s.Static() {
263
		abi = goobj.SymABIstatic
264
	}
265
	flag := uint8(0)
266
	if s.DuplicateOK() {
267
		flag |= goobj.SymFlagDupok
268
	}
269
	if s.Local() {
270
		flag |= goobj.SymFlagLocal
271
	}
272
	if s.MakeTypelink() {
273
		flag |= goobj.SymFlagTypelink
274
	}
275
	if s.Leaf() {
276
		flag |= goobj.SymFlagLeaf
277
	}
278
	if s.NoSplit() {
279
		flag |= goobj.SymFlagNoSplit
280
	}
281
	if s.ReflectMethod() {
282
		flag |= goobj.SymFlagReflectMethod
283
	}
284
	if s.TopFrame() {
285
		flag |= goobj.SymFlagTopFrame
286
	}
287
	if strings.HasPrefix(s.Name, "type.") && s.Name[5] != '.' && s.Type == objabi.SRODATA {
288
		flag |= goobj.SymFlagGoType
289
	}
290
	flag2 := uint8(0)
291
	if s.UsedInIface() {
292
		flag2 |= goobj.SymFlagUsedInIface
293
	}
294
	if strings.HasPrefix(s.Name, "go.itab.") && s.Type == objabi.SRODATA {
295
		flag2 |= goobj.SymFlagItab
296
	}
297
	name := s.Name
298
	if strings.HasPrefix(name, "gofile..") {
299
		name = filepath.ToSlash(name)
300
	}
301
	var align uint32
302
	if s.Func != nil {
303
		align = uint32(s.Func.Align)
304
	}
305
	if s.ContentAddressable() {
306
		// We generally assume data symbols are natually aligned,
307
		// except for strings. If we dedup a string symbol and a
308
		// non-string symbol with the same content, we should keep
309
		// the largest alignment.
310
		// TODO: maybe the compiler could set the alignment for all
311
		// data symbols more carefully.
312
		if s.Size != 0 && !strings.HasPrefix(s.Name, "go.string.") {
313
			switch {
314
			case w.ctxt.Arch.PtrSize == 8 && s.Size%8 == 0:
315
				align = 8
316
			case s.Size%4 == 0:
317
				align = 4
318
			case s.Size%2 == 0:
319
				align = 2
320
			}
321
			// don't bother setting align to 1.
322
		}
323
	}
324
	var o goobj.Sym
325
	o.SetName(name, w.Writer)
326
	o.SetABI(abi)
327
	o.SetType(uint8(s.Type))
328
	o.SetFlag(flag)
329
	o.SetFlag2(flag2)
330
	o.SetSiz(uint32(s.Size))
331
	o.SetAlign(align)
332
	o.Write(w.Writer)
333
}
334

335
func (w *writer) Hash64(s *LSym) {
336
	if !s.ContentAddressable() || len(s.R) != 0 {
337
		panic("Hash of non-content-addresable symbol")
338
	}
339
	b := contentHash64(s)
340
	w.Bytes(b[:])
341
}
342

343
func (w *writer) Hash(s *LSym) {
344
	if !s.ContentAddressable() {
345
		panic("Hash of non-content-addresable symbol")
346
	}
347
	b := w.contentHash(s)
348
	w.Bytes(b[:])
349
}
350

351
func contentHash64(s *LSym) goobj.Hash64Type {
352
	var b goobj.Hash64Type
353
	copy(b[:], s.P)
354
	return b
355
}
356

357
// Compute the content hash for a content-addressable symbol.
358
// We build a content hash based on its content and relocations.
359
// Depending on the category of the referenced symbol, we choose
360
// different hash algorithms such that the hash is globally
361
// consistent.
362
// - For referenced content-addressable symbol, its content hash
363
//   is globally consistent.
364
// - For package symbol and builtin symbol, its local index is
365
//   globally consistent.
366
// - For non-package symbol, its fully-expanded name is globally
367
//   consistent. For now, we require we know the current package
368
//   path so we can always expand symbol names. (Otherwise,
369
//   symbols with relocations are not considered hashable.)
370
//
371
// For now, we assume there is no circular dependencies among
372
// hashed symbols.
373
func (w *writer) contentHash(s *LSym) goobj.HashType {
374
	h := sha1.New()
375
	// The compiler trims trailing zeros _sometimes_. We just do
376
	// it always.
377
	h.Write(bytes.TrimRight(s.P, "\x00"))
378
	var tmp [14]byte
379
	for i := range s.R {
380
		r := &s.R[i]
381
		binary.LittleEndian.PutUint32(tmp[:4], uint32(r.Off))
382
		tmp[4] = r.Siz
383
		tmp[5] = uint8(r.Type)
384
		binary.LittleEndian.PutUint64(tmp[6:14], uint64(r.Add))
385
		h.Write(tmp[:])
386
		rs := r.Sym
387
		switch rs.PkgIdx {
388
		case goobj.PkgIdxHashed64:
389
			h.Write([]byte{0})
390
			t := contentHash64(rs)
391
			h.Write(t[:])
392
		case goobj.PkgIdxHashed:
393
			h.Write([]byte{1})
394
			t := w.contentHash(rs)
395
			h.Write(t[:])
396
		case goobj.PkgIdxNone:
397
			h.Write([]byte{2})
398
			io.WriteString(h, rs.Name) // name is already expanded at this point
399
		case goobj.PkgIdxBuiltin:
400
			h.Write([]byte{3})
401
			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
402
			h.Write(tmp[:4])
403
		case goobj.PkgIdxSelf:
404
			io.WriteString(h, w.pkgpath)
405
			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
406
			h.Write(tmp[:4])
407
		default:
408
			io.WriteString(h, rs.Pkg)
409
			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
410
			h.Write(tmp[:4])
411
		}
412
	}
413
	var b goobj.HashType
414
	copy(b[:], h.Sum(nil))
415
	return b
416
}
417

418
func makeSymRef(s *LSym) goobj.SymRef {
419
	if s == nil {
420
		return goobj.SymRef{}
421
	}
422
	if s.PkgIdx == 0 || !s.Indexed() {
423
		fmt.Printf("unindexed symbol reference: %v\n", s)
424
		panic("unindexed symbol reference")
425
	}
426
	return goobj.SymRef{PkgIdx: uint32(s.PkgIdx), SymIdx: uint32(s.SymIdx)}
427
}
428

429
func (w *writer) Reloc(r *Reloc) {
430
	var o goobj.Reloc
431
	o.SetOff(r.Off)
432
	o.SetSiz(r.Siz)
433
	o.SetType(uint8(r.Type))
434
	o.SetAdd(r.Add)
435
	o.SetSym(makeSymRef(r.Sym))
436
	o.Write(w.Writer)
437
}
438

439
func (w *writer) aux1(typ uint8, rs *LSym) {
440
	var o goobj.Aux
441
	o.SetType(typ)
442
	o.SetSym(makeSymRef(rs))
443
	o.Write(w.Writer)
444
}
445

446
func (w *writer) Aux(s *LSym) {
447
	if s.Gotype != nil {
448
		w.aux1(goobj.AuxGotype, s.Gotype)
449
	}
450
	if s.Func != nil {
451
		w.aux1(goobj.AuxFuncInfo, s.Func.FuncInfoSym)
452

453
		for _, d := range s.Func.Pcln.Funcdata {
454
			w.aux1(goobj.AuxFuncdata, d)
455
		}
456

457
		if s.Func.dwarfInfoSym != nil && s.Func.dwarfInfoSym.Size != 0 {
458
			w.aux1(goobj.AuxDwarfInfo, s.Func.dwarfInfoSym)
459
		}
460
		if s.Func.dwarfLocSym != nil && s.Func.dwarfLocSym.Size != 0 {
461
			w.aux1(goobj.AuxDwarfLoc, s.Func.dwarfLocSym)
462
		}
463
		if s.Func.dwarfRangesSym != nil && s.Func.dwarfRangesSym.Size != 0 {
464
			w.aux1(goobj.AuxDwarfRanges, s.Func.dwarfRangesSym)
465
		}
466
		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
467
			w.aux1(goobj.AuxDwarfLines, s.Func.dwarfDebugLinesSym)
468
		}
469
	}
470
}
471

472
// Emits flags of referenced indexed symbols.
473
func (w *writer) refFlags() {
474
	seen := make(map[*LSym]bool)
475
	w.ctxt.traverseSyms(traverseRefs, func(rs *LSym) { // only traverse refs, not auxs, as tools don't need auxs
476
		switch rs.PkgIdx {
477
		case goobj.PkgIdxNone, goobj.PkgIdxHashed64, goobj.PkgIdxHashed, goobj.PkgIdxBuiltin, goobj.PkgIdxSelf: // not an external indexed reference
478
			return
479
		case goobj.PkgIdxInvalid:
480
			panic("unindexed symbol reference")
481
		}
482
		if seen[rs] {
483
			return
484
		}
485
		seen[rs] = true
486
		symref := makeSymRef(rs)
487
		flag2 := uint8(0)
488
		if rs.UsedInIface() {
489
			flag2 |= goobj.SymFlagUsedInIface
490
		}
491
		if flag2 == 0 {
492
			return // no need to write zero flags
493
		}
494
		var o goobj.RefFlags
495
		o.SetSym(symref)
496
		o.SetFlag2(flag2)
497
		o.Write(w.Writer)
498
	})
499
}
500

501
// Emits names of referenced indexed symbols, used by tools (objdump, nm)
502
// only.
503
func (w *writer) refNames() {
504
	seen := make(map[*LSym]bool)
505
	w.ctxt.traverseSyms(traverseRefs, func(rs *LSym) { // only traverse refs, not auxs, as tools don't need auxs
506
		switch rs.PkgIdx {
507
		case goobj.PkgIdxNone, goobj.PkgIdxHashed64, goobj.PkgIdxHashed, goobj.PkgIdxBuiltin, goobj.PkgIdxSelf: // not an external indexed reference
508
			return
509
		case goobj.PkgIdxInvalid:
510
			panic("unindexed symbol reference")
511
		}
512
		if seen[rs] {
513
			return
514
		}
515
		seen[rs] = true
516
		symref := makeSymRef(rs)
517
		var o goobj.RefName
518
		o.SetSym(symref)
519
		o.SetName(rs.Name, w.Writer)
520
		o.Write(w.Writer)
521
	})
522
	// TODO: output in sorted order?
523
	// Currently tools (cmd/internal/goobj package) doesn't use mmap,
524
	// and it just read it into a map in memory upfront. If it uses
525
	// mmap, if the output is sorted, it probably could avoid reading
526
	// into memory and just do lookups in the mmap'd object file.
527
}
528

529
// return the number of aux symbols s have.
530
func nAuxSym(s *LSym) int {
531
	n := 0
532
	if s.Gotype != nil {
533
		n++
534
	}
535
	if s.Func != nil {
536
		// FuncInfo is an aux symbol, each Funcdata is an aux symbol
537
		n += 1 + len(s.Func.Pcln.Funcdata)
538
		if s.Func.dwarfInfoSym != nil && s.Func.dwarfInfoSym.Size != 0 {
539
			n++
540
		}
541
		if s.Func.dwarfLocSym != nil && s.Func.dwarfLocSym.Size != 0 {
542
			n++
543
		}
544
		if s.Func.dwarfRangesSym != nil && s.Func.dwarfRangesSym.Size != 0 {
545
			n++
546
		}
547
		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
548
			n++
549
		}
550
	}
551
	return n
552
}
553

554
// generate symbols for FuncInfo.
555
func genFuncInfoSyms(ctxt *Link) {
556
	infosyms := make([]*LSym, 0, len(ctxt.Text))
557
	var pcdataoff uint32
558
	var b bytes.Buffer
559
	symidx := int32(len(ctxt.defs))
560
	for _, s := range ctxt.Text {
561
		if s.Func == nil {
562
			continue
563
		}
564
		o := goobj.FuncInfo{
565
			Args:   uint32(s.Func.Args),
566
			Locals: uint32(s.Func.Locals),
567
			FuncID: objabi.FuncID(s.Func.FuncID),
568
		}
569
		pc := &s.Func.Pcln
570
		o.Pcsp = pcdataoff
571
		pcdataoff += uint32(len(pc.Pcsp.P))
572
		o.Pcfile = pcdataoff
573
		pcdataoff += uint32(len(pc.Pcfile.P))
574
		o.Pcline = pcdataoff
575
		pcdataoff += uint32(len(pc.Pcline.P))
576
		o.Pcinline = pcdataoff
577
		pcdataoff += uint32(len(pc.Pcinline.P))
578
		o.Pcdata = make([]uint32, len(pc.Pcdata))
579
		for i, pcd := range pc.Pcdata {
580
			o.Pcdata[i] = pcdataoff
581
			pcdataoff += uint32(len(pcd.P))
582
		}
583
		o.PcdataEnd = pcdataoff
584
		o.Funcdataoff = make([]uint32, len(pc.Funcdataoff))
585
		for i, x := range pc.Funcdataoff {
586
			o.Funcdataoff[i] = uint32(x)
587
		}
588
		i := 0
589
		o.File = make([]goobj.CUFileIndex, len(pc.UsedFiles))
590
		for f := range pc.UsedFiles {
591
			o.File[i] = f
592
			i++
593
		}
594
		sort.Slice(o.File, func(i, j int) bool { return o.File[i] < o.File[j] })
595
		o.InlTree = make([]goobj.InlTreeNode, len(pc.InlTree.nodes))
596
		for i, inl := range pc.InlTree.nodes {
597
			f, l := getFileIndexAndLine(ctxt, inl.Pos)
598
			o.InlTree[i] = goobj.InlTreeNode{
599
				Parent:   int32(inl.Parent),
600
				File:     goobj.CUFileIndex(f),
601
				Line:     l,
602
				Func:     makeSymRef(inl.Func),
603
				ParentPC: inl.ParentPC,
604
			}
605
		}
606

607
		o.Write(&b)
608
		isym := &LSym{
609
			Type:   objabi.SDATA, // for now, I don't think it matters
610
			PkgIdx: goobj.PkgIdxSelf,
611
			SymIdx: symidx,
612
			P:      append([]byte(nil), b.Bytes()...),
613
		}
614
		isym.Set(AttrIndexed, true)
615
		symidx++
616
		infosyms = append(infosyms, isym)
617
		s.Func.FuncInfoSym = isym
618
		b.Reset()
619

620
		dwsyms := []*LSym{s.Func.dwarfRangesSym, s.Func.dwarfLocSym, s.Func.dwarfDebugLinesSym, s.Func.dwarfInfoSym}
621
		for _, s := range dwsyms {
622
			if s == nil || s.Size == 0 {
623
				continue
624
			}
625
			s.PkgIdx = goobj.PkgIdxSelf
626
			s.SymIdx = symidx
627
			s.Set(AttrIndexed, true)
628
			symidx++
629
			infosyms = append(infosyms, s)
630
		}
631
	}
632
	ctxt.defs = append(ctxt.defs, infosyms...)
633
}
634

635
// debugDumpAux is a dumper for selected aux symbols.
636
func writeAuxSymDebug(ctxt *Link, par *LSym, aux *LSym) {
637
	// Most aux symbols (ex: funcdata) are not interesting--
638
	// pick out just the DWARF ones for now.
639
	if aux.Type != objabi.SDWARFLOC &&
640
		aux.Type != objabi.SDWARFFCN &&
641
		aux.Type != objabi.SDWARFABSFCN &&
642
		aux.Type != objabi.SDWARFLINES &&
643
		aux.Type != objabi.SDWARFRANGE {
644
		return
645
	}
646
	ctxt.writeSymDebugNamed(aux, "aux for "+par.Name)
647
}
648

649
func debugAsmEmit(ctxt *Link) {
650
	if ctxt.Debugasm > 0 {
651
		ctxt.traverseSyms(traverseDefs, ctxt.writeSymDebug)
652
		if ctxt.Debugasm > 1 {
653
			fn := func(par *LSym, aux *LSym) {
654
				writeAuxSymDebug(ctxt, par, aux)
655
			}
656
			ctxt.traverseAuxSyms(traverseAux, fn)
657
		}
658
	}
659
}
660

661
func (ctxt *Link) writeSymDebug(s *LSym) {
662
	ctxt.writeSymDebugNamed(s, s.Name)
663
}
664

665
func (ctxt *Link) writeSymDebugNamed(s *LSym, name string) {
666
	ver := ""
667
	if ctxt.Debugasm > 1 {
668
		ver = fmt.Sprintf("<%d>", s.ABI())
669
	}
670
	fmt.Fprintf(ctxt.Bso, "%s%s ", name, ver)
671
	if s.Type != 0 {
672
		fmt.Fprintf(ctxt.Bso, "%v ", s.Type)
673
	}
674
	if s.Static() {
675
		fmt.Fprint(ctxt.Bso, "static ")
676
	}
677
	if s.DuplicateOK() {
678
		fmt.Fprintf(ctxt.Bso, "dupok ")
679
	}
680
	if s.CFunc() {
681
		fmt.Fprintf(ctxt.Bso, "cfunc ")
682
	}
683
	if s.NoSplit() {
684
		fmt.Fprintf(ctxt.Bso, "nosplit ")
685
	}
686
	if s.TopFrame() {
687
		fmt.Fprintf(ctxt.Bso, "topframe ")
688
	}
689
	fmt.Fprintf(ctxt.Bso, "size=%d", s.Size)
690
	if s.Type == objabi.STEXT {
691
		fmt.Fprintf(ctxt.Bso, " args=%#x locals=%#x funcid=%#x", uint64(s.Func.Args), uint64(s.Func.Locals), uint64(s.Func.FuncID))
692
		if s.Leaf() {
693
			fmt.Fprintf(ctxt.Bso, " leaf")
694
		}
695
	}
696
	fmt.Fprintf(ctxt.Bso, "\n")
697
	if s.Type == objabi.STEXT {
698
		for p := s.Func.Text; p != nil; p = p.Link {
699
			fmt.Fprintf(ctxt.Bso, "\t%#04x ", uint(int(p.Pc)))
700
			if ctxt.Debugasm > 1 {
701
				io.WriteString(ctxt.Bso, p.String())
702
			} else {
703
				p.InnermostString(ctxt.Bso)
704
			}
705
			fmt.Fprintln(ctxt.Bso)
706
		}
707
	}
708
	for i := 0; i < len(s.P); i += 16 {
709
		fmt.Fprintf(ctxt.Bso, "\t%#04x", uint(i))
710
		j := i
711
		for ; j < i+16 && j < len(s.P); j++ {
712
			fmt.Fprintf(ctxt.Bso, " %02x", s.P[j])
713
		}
714
		for ; j < i+16; j++ {
715
			fmt.Fprintf(ctxt.Bso, "   ")
716
		}
717
		fmt.Fprintf(ctxt.Bso, "  ")
718
		for j = i; j < i+16 && j < len(s.P); j++ {
719
			c := int(s.P[j])
720
			b := byte('.')
721
			if ' ' <= c && c <= 0x7e {
722
				b = byte(c)
723
			}
724
			ctxt.Bso.WriteByte(b)
725
		}
726

727
		fmt.Fprintf(ctxt.Bso, "\n")
728
	}
729

730
	sort.Sort(relocByOff(s.R)) // generate stable output
731
	for _, r := range s.R {
732
		name := ""
733
		ver := ""
734
		if r.Sym != nil {
735
			name = r.Sym.Name
736
			if ctxt.Debugasm > 1 {
737
				ver = fmt.Sprintf("<%d>", s.ABI())
738
			}
739
		} else if r.Type == objabi.R_TLS_LE {
740
			name = "TLS"
741
		}
742
		if ctxt.Arch.InFamily(sys.ARM, sys.PPC64) {
743
			fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s%s+%x\n", int(r.Off), r.Siz, r.Type, name, ver, uint64(r.Add))
744
		} else {
745
			fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s%s+%d\n", int(r.Off), r.Siz, r.Type, name, ver, r.Add)
746
		}
747
	}
748
}
749

750
// relocByOff sorts relocations by their offsets.
751
type relocByOff []Reloc
752

753
func (x relocByOff) Len() int           { return len(x) }
754
func (x relocByOff) Less(i, j int) bool { return x[i].Off < x[j].Off }
755
func (x relocByOff) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
756