podman

1
// Copyright 2018 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 x86
6

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

14
// evexBits stores EVEX prefix info that is used during instruction encoding.
15
type evexBits struct {
16
	b1 byte // [W1mmLLpp]
17
	b2 byte // [NNNbbZRS]
18

19
	// Associated instruction opcode.
20
	opcode byte
21
}
22

23
// newEVEXBits creates evexBits object from enc bytes at z position.
24
func newEVEXBits(z int, enc *opBytes) evexBits {
25
	return evexBits{
26
		b1:     enc[z+0],
27
		b2:     enc[z+1],
28
		opcode: enc[z+2],
29
	}
30
}
31

32
// P returns EVEX.pp value.
33
func (evex evexBits) P() byte { return (evex.b1 & evexP) >> 0 }
34

35
// L returns EVEX.L'L value.
36
func (evex evexBits) L() byte { return (evex.b1 & evexL) >> 2 }
37

38
// M returns EVEX.mm value.
39
func (evex evexBits) M() byte { return (evex.b1 & evexM) >> 4 }
40

41
// W returns EVEX.W value.
42
func (evex evexBits) W() byte { return (evex.b1 & evexW) >> 7 }
43

44
// BroadcastEnabled reports whether BCST suffix is permitted.
45
func (evex evexBits) BroadcastEnabled() bool {
46
	return evex.b2&evexBcst != 0
47
}
48

49
// ZeroingEnabled reports whether Z suffix is permitted.
50
func (evex evexBits) ZeroingEnabled() bool {
51
	return (evex.b2&evexZeroing)>>2 != 0
52
}
53

54
// RoundingEnabled reports whether RN_SAE, RZ_SAE, RD_SAE and RU_SAE suffixes
55
// are permitted.
56
func (evex evexBits) RoundingEnabled() bool {
57
	return (evex.b2&evexRounding)>>1 != 0
58
}
59

60
// SaeEnabled reports whether SAE suffix is permitted.
61
func (evex evexBits) SaeEnabled() bool {
62
	return (evex.b2&evexSae)>>0 != 0
63
}
64

65
// DispMultiplier returns displacement multiplier that is calculated
66
// based on tuple type, EVEX.W and input size.
67
// If embedded broadcast is used, bcst should be true.
68
func (evex evexBits) DispMultiplier(bcst bool) int32 {
69
	if bcst {
70
		switch evex.b2 & evexBcst {
71
		case evexBcstN4:
72
			return 4
73
		case evexBcstN8:
74
			return 8
75
		}
76
		return 1
77
	}
78

79
	switch evex.b2 & evexN {
80
	case evexN1:
81
		return 1
82
	case evexN2:
83
		return 2
84
	case evexN4:
85
		return 4
86
	case evexN8:
87
		return 8
88
	case evexN16:
89
		return 16
90
	case evexN32:
91
		return 32
92
	case evexN64:
93
		return 64
94
	case evexN128:
95
		return 128
96
	}
97
	return 1
98
}
99

100
// EVEX is described by using 2-byte sequence.
101
// See evexBits for more details.
102
const (
103
	evexW   = 0x80 // b1[W... ....]
104
	evexWIG = 0 << 7
105
	evexW0  = 0 << 7
106
	evexW1  = 1 << 7
107

108
	evexM    = 0x30 // b2[..mm ...]
109
	evex0F   = 1 << 4
110
	evex0F38 = 2 << 4
111
	evex0F3A = 3 << 4
112

113
	evexL   = 0x0C // b1[.... LL..]
114
	evexLIG = 0 << 2
115
	evex128 = 0 << 2
116
	evex256 = 1 << 2
117
	evex512 = 2 << 2
118

119
	evexP  = 0x03 // b1[.... ..pp]
120
	evex66 = 1 << 0
121
	evexF3 = 2 << 0
122
	evexF2 = 3 << 0
123

124
	// Precalculated Disp8 N value.
125
	// N acts like a multiplier for 8bit displacement.
126
	// Note that some N are not used, but their bits are reserved.
127
	evexN    = 0xE0 // b2[NNN. ....]
128
	evexN1   = 0 << 5
129
	evexN2   = 1 << 5
130
	evexN4   = 2 << 5
131
	evexN8   = 3 << 5
132
	evexN16  = 4 << 5
133
	evexN32  = 5 << 5
134
	evexN64  = 6 << 5
135
	evexN128 = 7 << 5
136

137
	// Disp8 for broadcasts.
138
	evexBcst   = 0x18 // b2[...b b...]
139
	evexBcstN4 = 1 << 3
140
	evexBcstN8 = 2 << 3
141

142
	// Flags that permit certain AVX512 features.
143
	// It's semantically illegal to combine evexZeroing and evexSae.
144
	evexZeroing         = 0x4 // b2[.... .Z..]
145
	evexZeroingEnabled  = 1 << 2
146
	evexRounding        = 0x2 // b2[.... ..R.]
147
	evexRoundingEnabled = 1 << 1
148
	evexSae             = 0x1 // b2[.... ...S]
149
	evexSaeEnabled      = 1 << 0
150
)
151

152
// compressedDisp8 calculates EVEX compressed displacement, if applicable.
153
func compressedDisp8(disp, elemSize int32) (disp8 byte, ok bool) {
154
	if disp%elemSize == 0 {
155
		v := disp / elemSize
156
		if v >= -128 && v <= 127 {
157
			return byte(v), true
158
		}
159
	}
160
	return 0, false
161
}
162

163
// evexZcase reports whether given Z-case belongs to EVEX group.
164
func evexZcase(zcase uint8) bool {
165
	return zcase > Zevex_first && zcase < Zevex_last
166
}
167

168
// evexSuffixBits carries instruction EVEX suffix set flags.
169
//
170
// Examples:
171
//	"RU_SAE.Z" => {rounding: 3, zeroing: true}
172
//	"Z" => {zeroing: true}
173
//	"BCST" => {broadcast: true}
174
//	"SAE.Z" => {sae: true, zeroing: true}
175
type evexSuffix struct {
176
	rounding  byte
177
	sae       bool
178
	zeroing   bool
179
	broadcast bool
180
}
181

182
// Rounding control values.
183
// Match exact value for EVEX.L'L field (with exception of rcUnset).
184
const (
185
	rcRNSAE = 0 // Round towards nearest
186
	rcRDSAE = 1 // Round towards -Inf
187
	rcRUSAE = 2 // Round towards +Inf
188
	rcRZSAE = 3 // Round towards zero
189
	rcUnset = 4
190
)
191

192
// newEVEXSuffix returns proper zero value for evexSuffix.
193
func newEVEXSuffix() evexSuffix {
194
	return evexSuffix{rounding: rcUnset}
195
}
196

197
// evexSuffixMap maps obj.X86suffix to its decoded version.
198
// Filled during init().
199
var evexSuffixMap [255]evexSuffix
200

201
func init() {
202
	// Decode all valid suffixes for later use.
203
	for i := range opSuffixTable {
204
		suffix := newEVEXSuffix()
205
		parts := strings.Split(opSuffixTable[i], ".")
206
		for j := range parts {
207
			switch parts[j] {
208
			case "Z":
209
				suffix.zeroing = true
210
			case "BCST":
211
				suffix.broadcast = true
212
			case "SAE":
213
				suffix.sae = true
214

215
			case "RN_SAE":
216
				suffix.rounding = rcRNSAE
217
			case "RD_SAE":
218
				suffix.rounding = rcRDSAE
219
			case "RU_SAE":
220
				suffix.rounding = rcRUSAE
221
			case "RZ_SAE":
222
				suffix.rounding = rcRZSAE
223
			}
224
		}
225
		evexSuffixMap[i] = suffix
226
	}
227
}
228

229
// toDisp8 tries to convert disp to proper 8-bit displacement value.
230
func toDisp8(disp int32, p *obj.Prog, asmbuf *AsmBuf) (disp8 byte, ok bool) {
231
	if asmbuf.evexflag {
232
		bcst := evexSuffixMap[p.Scond].broadcast
233
		elemSize := asmbuf.evex.DispMultiplier(bcst)
234
		return compressedDisp8(disp, elemSize)
235
	}
236
	return byte(disp), disp >= -128 && disp < 128
237
}
238

239
// EncodeRegisterRange packs [reg0-reg1] list into 64-bit value that
240
// is intended to be stored inside obj.Addr.Offset with TYPE_REGLIST.
241
func EncodeRegisterRange(reg0, reg1 int16) int64 {
242
	return (int64(reg0) << 0) |
243
		(int64(reg1) << 16) |
244
		obj.RegListX86Lo
245
}
246

247
// decodeRegisterRange unpacks [reg0-reg1] list from 64-bit value created by EncodeRegisterRange.
248
func decodeRegisterRange(list int64) (reg0, reg1 int) {
249
	return int((list >> 0) & 0xFFFF),
250
		int((list >> 16) & 0xFFFF)
251
}
252

253
// ParseSuffix handles the special suffix for the 386/AMD64.
254
// Suffix bits are stored into p.Scond.
255
//
256
// Leading "." in cond is ignored.
257
func ParseSuffix(p *obj.Prog, cond string) error {
258
	cond = strings.TrimPrefix(cond, ".")
259

260
	suffix := newOpSuffix(cond)
261
	if !suffix.IsValid() {
262
		return inferSuffixError(cond)
263
	}
264

265
	p.Scond = uint8(suffix)
266
	return nil
267
}
268

269
// inferSuffixError returns non-nil error that describes what could be
270
// the cause of suffix parse failure.
271
//
272
// At the point this function is executed there is already assembly error,
273
// so we can burn some clocks to construct good error message.
274
//
275
// Reported issues:
276
//	- duplicated suffixes
277
//	- illegal rounding/SAE+broadcast combinations
278
//	- unknown suffixes
279
//	- misplaced suffix (e.g. wrong Z suffix position)
280
func inferSuffixError(cond string) error {
281
	suffixSet := make(map[string]bool)  // Set for duplicates detection.
282
	unknownSet := make(map[string]bool) // Set of unknown suffixes.
283
	hasBcst := false
284
	hasRoundSae := false
285
	var msg []string // Error message parts
286

287
	suffixes := strings.Split(cond, ".")
288
	for i, suffix := range suffixes {
289
		switch suffix {
290
		case "Z":
291
			if i != len(suffixes)-1 {
292
				msg = append(msg, "Z suffix should be the last")
293
			}
294
		case "BCST":
295
			hasBcst = true
296
		case "SAE", "RN_SAE", "RZ_SAE", "RD_SAE", "RU_SAE":
297
			hasRoundSae = true
298
		default:
299
			if !unknownSet[suffix] {
300
				msg = append(msg, fmt.Sprintf("unknown suffix %q", suffix))
301
			}
302
			unknownSet[suffix] = true
303
		}
304

305
		if suffixSet[suffix] {
306
			msg = append(msg, fmt.Sprintf("duplicate suffix %q", suffix))
307
		}
308
		suffixSet[suffix] = true
309
	}
310

311
	if hasBcst && hasRoundSae {
312
		msg = append(msg, "can't combine rounding/SAE and broadcast")
313
	}
314

315
	if len(msg) == 0 {
316
		return errors.New("bad suffix combination")
317
	}
318
	return errors.New(strings.Join(msg, "; "))
319
}
320

321
// opSuffixTable is a complete list of possible opcode suffix combinations.
322
// It "maps" uint8 suffix bits to their string representation.
323
// With the exception of first and last elements, order is not important.
324
var opSuffixTable = [...]string{
325
	"", // Map empty suffix to empty string.
326

327
	"Z",
328

329
	"SAE",
330
	"SAE.Z",
331

332
	"RN_SAE",
333
	"RZ_SAE",
334
	"RD_SAE",
335
	"RU_SAE",
336
	"RN_SAE.Z",
337
	"RZ_SAE.Z",
338
	"RD_SAE.Z",
339
	"RU_SAE.Z",
340

341
	"BCST",
342
	"BCST.Z",
343

344
	"<bad suffix>",
345
}
346

347
// opSuffix represents instruction opcode suffix.
348
// Compound (multi-part) suffixes expressed with single opSuffix value.
349
//
350
// uint8 type is used to fit obj.Prog.Scond.
351
type opSuffix uint8
352

353
// badOpSuffix is used to represent all invalid suffix combinations.
354
const badOpSuffix = opSuffix(len(opSuffixTable) - 1)
355

356
// newOpSuffix returns opSuffix object that matches suffixes string.
357
//
358
// If no matching suffix is found, special "invalid" suffix is returned.
359
// Use IsValid method to check against this case.
360
func newOpSuffix(suffixes string) opSuffix {
361
	for i := range opSuffixTable {
362
		if opSuffixTable[i] == suffixes {
363
			return opSuffix(i)
364
		}
365
	}
366
	return badOpSuffix
367
}
368

369
// IsValid reports whether suffix is valid.
370
// Empty suffixes are valid.
371
func (suffix opSuffix) IsValid() bool {
372
	return suffix != badOpSuffix
373
}
374

375
// String returns suffix printed representation.
376
//
377
// It matches the string that was used to create suffix with NewX86Suffix()
378
// for valid suffixes.
379
// For all invalid suffixes, special marker is returned.
380
func (suffix opSuffix) String() string {
381
	return opSuffixTable[suffix]
382
}
383