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