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
package obj
6

7
import (
8
	"github.com/twitchyliquid64/golang-asm/objabi"
9
	"fmt"
10
	"strings"
11
)
12

13
type Plist struct {
14
	Firstpc *Prog
15
	Curfn   interface{} // holds a *gc.Node, if non-nil
16
}
17

18
// ProgAlloc is a function that allocates Progs.
19
// It is used to provide access to cached/bulk-allocated Progs to the assemblers.
20
type ProgAlloc func() *Prog
21

22
func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string) {
23
	// Build list of symbols, and assign instructions to lists.
24
	var curtext *LSym
25
	var etext *Prog
26
	var text []*LSym
27

28
	var plink *Prog
29
	for p := plist.Firstpc; p != nil; p = plink {
30
		if ctxt.Debugasm > 0 && ctxt.Debugvlog {
31
			fmt.Printf("obj: %v\n", p)
32
		}
33
		plink = p.Link
34
		p.Link = nil
35

36
		switch p.As {
37
		case AEND:
38
			continue
39

40
		case ATEXT:
41
			s := p.From.Sym
42
			if s == nil {
43
				// func _() { }
44
				curtext = nil
45
				continue
46
			}
47
			text = append(text, s)
48
			etext = p
49
			curtext = s
50
			continue
51

52
		case AFUNCDATA:
53
			// Rewrite reference to go_args_stackmap(SB) to the Go-provided declaration information.
54
			if curtext == nil { // func _() {}
55
				continue
56
			}
57
			if p.To.Sym.Name == "go_args_stackmap" {
58
				if p.From.Type != TYPE_CONST || p.From.Offset != objabi.FUNCDATA_ArgsPointerMaps {
59
					ctxt.Diag("FUNCDATA use of go_args_stackmap(SB) without FUNCDATA_ArgsPointerMaps")
60
				}
61
				p.To.Sym = ctxt.LookupDerived(curtext, curtext.Name+".args_stackmap")
62
			}
63

64
		}
65

66
		if curtext == nil {
67
			etext = nil
68
			continue
69
		}
70
		etext.Link = p
71
		etext = p
72
	}
73

74
	if newprog == nil {
75
		newprog = ctxt.NewProg
76
	}
77

78
	// Add reference to Go arguments for C or assembly functions without them.
79
	for _, s := range text {
80
		if !strings.HasPrefix(s.Name, "\"\".") {
81
			continue
82
		}
83
		found := false
84
		for p := s.Func.Text; p != nil; p = p.Link {
85
			if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
86
				found = true
87
				break
88
			}
89
		}
90

91
		if !found {
92
			p := Appendp(s.Func.Text, newprog)
93
			p.As = AFUNCDATA
94
			p.From.Type = TYPE_CONST
95
			p.From.Offset = objabi.FUNCDATA_ArgsPointerMaps
96
			p.To.Type = TYPE_MEM
97
			p.To.Name = NAME_EXTERN
98
			p.To.Sym = ctxt.LookupDerived(s, s.Name+".args_stackmap")
99
		}
100
	}
101

102
	// Turn functions into machine code images.
103
	for _, s := range text {
104
		mkfwd(s)
105
		linkpatch(ctxt, s, newprog)
106
		ctxt.Arch.Preprocess(ctxt, s, newprog)
107
		ctxt.Arch.Assemble(ctxt, s, newprog)
108
		if ctxt.Errors > 0 {
109
			continue
110
		}
111
		linkpcln(ctxt, s)
112
		if myimportpath != "" {
113
			ctxt.populateDWARF(plist.Curfn, s, myimportpath)
114
		}
115
	}
116
}
117

118
func (ctxt *Link) InitTextSym(s *LSym, flag int) {
119
	if s == nil {
120
		// func _() { }
121
		return
122
	}
123
	if s.Func != nil {
124
		ctxt.Diag("InitTextSym double init for %s", s.Name)
125
	}
126
	s.Func = new(FuncInfo)
127
	if s.OnList() {
128
		ctxt.Diag("symbol %s listed multiple times", s.Name)
129
	}
130
	name := strings.Replace(s.Name, "\"\"", ctxt.Pkgpath, -1)
131
	s.Func.FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0)
132
	s.Set(AttrOnList, true)
133
	s.Set(AttrDuplicateOK, flag&DUPOK != 0)
134
	s.Set(AttrNoSplit, flag&NOSPLIT != 0)
135
	s.Set(AttrReflectMethod, flag&REFLECTMETHOD != 0)
136
	s.Set(AttrWrapper, flag&WRAPPER != 0)
137
	s.Set(AttrNeedCtxt, flag&NEEDCTXT != 0)
138
	s.Set(AttrNoFrame, flag&NOFRAME != 0)
139
	s.Set(AttrTopFrame, flag&TOPFRAME != 0)
140
	s.Type = objabi.STEXT
141
	ctxt.Text = append(ctxt.Text, s)
142

143
	// Set up DWARF entries for s
144
	ctxt.dwarfSym(s)
145
}
146

147
func (ctxt *Link) Globl(s *LSym, size int64, flag int) {
148
	if s.OnList() {
149
		ctxt.Diag("symbol %s listed multiple times", s.Name)
150
	}
151
	s.Set(AttrOnList, true)
152
	ctxt.Data = append(ctxt.Data, s)
153
	s.Size = size
154
	if s.Type == 0 {
155
		s.Type = objabi.SBSS
156
	}
157
	if flag&DUPOK != 0 {
158
		s.Set(AttrDuplicateOK, true)
159
	}
160
	if flag&RODATA != 0 {
161
		s.Type = objabi.SRODATA
162
	} else if flag&NOPTR != 0 {
163
		if s.Type == objabi.SDATA {
164
			s.Type = objabi.SNOPTRDATA
165
		} else {
166
			s.Type = objabi.SNOPTRBSS
167
		}
168
	} else if flag&TLSBSS != 0 {
169
		s.Type = objabi.STLSBSS
170
	}
171
	if strings.HasPrefix(s.Name, "\"\"."+StaticNamePref) {
172
		s.Set(AttrStatic, true)
173
	}
174
}
175

176
// EmitEntryLiveness generates PCDATA Progs after p to switch to the
177
// liveness map active at the entry of function s. It returns the last
178
// Prog generated.
179
func (ctxt *Link) EmitEntryLiveness(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
180
	pcdata := ctxt.EmitEntryStackMap(s, p, newprog)
181
	pcdata = ctxt.EmitEntryRegMap(s, pcdata, newprog)
182
	return pcdata
183
}
184

185
// Similar to EmitEntryLiveness, but just emit stack map.
186
func (ctxt *Link) EmitEntryStackMap(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
187
	pcdata := Appendp(p, newprog)
188
	pcdata.Pos = s.Func.Text.Pos
189
	pcdata.As = APCDATA
190
	pcdata.From.Type = TYPE_CONST
191
	pcdata.From.Offset = objabi.PCDATA_StackMapIndex
192
	pcdata.To.Type = TYPE_CONST
193
	pcdata.To.Offset = -1 // pcdata starts at -1 at function entry
194

195
	return pcdata
196
}
197

198
// Similar to EmitEntryLiveness, but just emit register map.
199
func (ctxt *Link) EmitEntryRegMap(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
200
	pcdata := Appendp(p, newprog)
201
	pcdata.Pos = s.Func.Text.Pos
202
	pcdata.As = APCDATA
203
	pcdata.From.Type = TYPE_CONST
204
	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
205
	pcdata.To.Type = TYPE_CONST
206
	pcdata.To.Offset = -1
207

208
	return pcdata
209
}
210

211
// StartUnsafePoint generates PCDATA Progs after p to mark the
212
// beginning of an unsafe point. The unsafe point starts immediately
213
// after p.
214
// It returns the last Prog generated.
215
func (ctxt *Link) StartUnsafePoint(p *Prog, newprog ProgAlloc) *Prog {
216
	pcdata := Appendp(p, newprog)
217
	pcdata.As = APCDATA
218
	pcdata.From.Type = TYPE_CONST
219
	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
220
	pcdata.To.Type = TYPE_CONST
221
	pcdata.To.Offset = objabi.PCDATA_RegMapUnsafe
222

223
	return pcdata
224
}
225

226
// EndUnsafePoint generates PCDATA Progs after p to mark the end of an
227
// unsafe point, restoring the register map index to oldval.
228
// The unsafe point ends right after p.
229
// It returns the last Prog generated.
230
func (ctxt *Link) EndUnsafePoint(p *Prog, newprog ProgAlloc, oldval int64) *Prog {
231
	pcdata := Appendp(p, newprog)
232
	pcdata.As = APCDATA
233
	pcdata.From.Type = TYPE_CONST
234
	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
235
	pcdata.To.Type = TYPE_CONST
236
	pcdata.To.Offset = oldval
237

238
	return pcdata
239
}
240

241
// MarkUnsafePoints inserts PCDATAs to mark nonpreemptible and restartable
242
// instruction sequences, based on isUnsafePoint and isRestartable predicate.
243
// p0 is the start of the instruction stream.
244
// isUnsafePoint(p) returns true if p is not safe for async preemption.
245
// isRestartable(p) returns true if we can restart at the start of p (this Prog)
246
// upon async preemption. (Currently multi-Prog restartable sequence is not
247
// supported.)
248
// isRestartable can be nil. In this case it is treated as always returning false.
249
// If isUnsafePoint(p) and isRestartable(p) are both true, it is treated as
250
// an unsafe point.
251
func MarkUnsafePoints(ctxt *Link, p0 *Prog, newprog ProgAlloc, isUnsafePoint, isRestartable func(*Prog) bool) {
252
	if isRestartable == nil {
253
		// Default implementation: nothing is restartable.
254
		isRestartable = func(*Prog) bool { return false }
255
	}
256
	prev := p0
257
	prevPcdata := int64(-1) // entry PC data value
258
	prevRestart := int64(0)
259
	for p := prev.Link; p != nil; p, prev = p.Link, p {
260
		if p.As == APCDATA && p.From.Offset == objabi.PCDATA_RegMapIndex {
261
			prevPcdata = p.To.Offset
262
			continue
263
		}
264
		if prevPcdata == objabi.PCDATA_RegMapUnsafe {
265
			continue // already unsafe
266
		}
267
		if isUnsafePoint(p) {
268
			q := ctxt.StartUnsafePoint(prev, newprog)
269
			q.Pc = p.Pc
270
			q.Link = p
271
			// Advance to the end of unsafe point.
272
			for p.Link != nil && isUnsafePoint(p.Link) {
273
				p = p.Link
274
			}
275
			if p.Link == nil {
276
				break // Reached the end, don't bother marking the end
277
			}
278
			p = ctxt.EndUnsafePoint(p, newprog, prevPcdata)
279
			p.Pc = p.Link.Pc
280
			continue
281
		}
282
		if isRestartable(p) {
283
			val := int64(objabi.PCDATA_Restart1)
284
			if val == prevRestart {
285
				val = objabi.PCDATA_Restart2
286
			}
287
			prevRestart = val
288
			q := Appendp(prev, newprog)
289
			q.As = APCDATA
290
			q.From.Type = TYPE_CONST
291
			q.From.Offset = objabi.PCDATA_RegMapIndex
292
			q.To.Type = TYPE_CONST
293
			q.To.Offset = val
294
			q.Pc = p.Pc
295
			q.Link = p
296

297
			if p.Link == nil {
298
				break // Reached the end, don't bother marking the end
299
			}
300
			if isRestartable(p.Link) {
301
				// Next Prog is also restartable. No need to mark the end
302
				// of this sequence. We'll just go ahead mark the next one.
303
				continue
304
			}
305
			p = Appendp(p, newprog)
306
			p.As = APCDATA
307
			p.From.Type = TYPE_CONST
308
			p.From.Offset = objabi.PCDATA_RegMapIndex
309
			p.To.Type = TYPE_CONST
310
			p.To.Offset = prevPcdata
311
			p.Pc = p.Link.Pc
312
		}
313
	}
314
}
315