LLVM 24.0.0git
X86InstComments.cpp
Go to the documentation of this file.
1//===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This defines functionality used to emit comments about X86 instructions to
10// an output stream for -fverbose-asm.
11//
12//===----------------------------------------------------------------------===//
13
14#include "X86InstComments.h"
15#include "X86ATTInstPrinter.h"
16#include "X86BaseInfo.h"
17#include "X86MCTargetDesc.h"
18#include "X86ShuffleDecode.h"
19#include "llvm/ADT/Enum.h"
20#include "llvm/MC/MCInst.h"
21#include "llvm/MC/MCInstrInfo.h"
22#include "llvm/Support/raw_ostream.h"
23#include <string_view>
24
25using namespace llvm;
26
27#define CASE_SSE_INS_COMMON(Inst, src) \
28 case X86::Inst##src:
29
30#define CASE_AVX_INS_COMMON(Inst, Suffix, src) \
31 case X86::V##Inst##Suffix##src:
32
33#define CASE_MASK_INS_COMMON(Inst, Suffix, src) \
34 case X86::V##Inst##Suffix##src##k:
35
36#define CASE_MASKZ_INS_COMMON(Inst, Suffix, src) \
37 case X86::V##Inst##Suffix##src##kz:
38
39#define CASE_AVX512_INS_COMMON(Inst, Suffix, src) \
40 CASE_AVX_INS_COMMON(Inst, Suffix, src) \
41 CASE_MASK_INS_COMMON(Inst, Suffix, src) \
42 CASE_MASKZ_INS_COMMON(Inst, Suffix, src)
43
44#define CASE_MASK_INS_COMMON_INT(Inst, Suffix, src) \
45 case X86::V##Inst##Suffix##src##k_Int:
46
47#define CASE_MASKZ_INS_COMMON_INT(Inst, Suffix, src) \
48 case X86::V##Inst##Suffix##src##kz_Int:
49
50#define CASE_AVX512_INS_COMMON_INT(Inst, Suffix, src) \
51 CASE_AVX_INS_COMMON(Inst, Suffix, src##_Int) \
52 CASE_MASK_INS_COMMON_INT(Inst, Suffix, src) \
53 CASE_MASKZ_INS_COMMON_INT(Inst, Suffix, src)
54
55#define CASE_FPCLASS_PACKED(Inst, src) \
56 CASE_AVX_INS_COMMON(Inst, Z, src##i) \
57 CASE_AVX_INS_COMMON(Inst, Z256, src##i) \
58 CASE_AVX_INS_COMMON(Inst, Z128, src##i) \
59 CASE_MASK_INS_COMMON(Inst, Z, src##i)
60
61#define CASE_FPCLASS_PACKED_MEM(Inst) \
62 CASE_FPCLASS_PACKED(Inst, m) \
63 CASE_FPCLASS_PACKED(Inst, mb)
64
65#define CASE_FPCLASS_SCALAR(Inst, src) \
66 CASE_AVX_INS_COMMON(Inst, Z, src##i) \
67 CASE_MASK_INS_COMMON(Inst, Z, src##i)
68
69#define CASE_PTERNLOG(Inst, src) \
70 CASE_AVX512_INS_COMMON(Inst, Z, r##src##i) \
71 CASE_AVX512_INS_COMMON(Inst, Z256, r##src##i) \
72 CASE_AVX512_INS_COMMON(Inst, Z128, r##src##i)
73
74#define CASE_MOVDUP(Inst, src) \
75 CASE_AVX512_INS_COMMON(Inst, Z, r##src) \
76 CASE_AVX512_INS_COMMON(Inst, Z256, r##src) \
77 CASE_AVX512_INS_COMMON(Inst, Z128, r##src) \
78 CASE_AVX_INS_COMMON(Inst, , r##src) \
79 CASE_AVX_INS_COMMON(Inst, Y, r##src) \
80 CASE_SSE_INS_COMMON(Inst, r##src)
81
82#define CASE_MASK_MOVDUP(Inst, src) \
83 CASE_MASK_INS_COMMON(Inst, Z, r##src) \
84 CASE_MASK_INS_COMMON(Inst, Z256, r##src) \
85 CASE_MASK_INS_COMMON(Inst, Z128, r##src)
86
87#define CASE_MASKZ_MOVDUP(Inst, src) \
88 CASE_MASKZ_INS_COMMON(Inst, Z, r##src) \
89 CASE_MASKZ_INS_COMMON(Inst, Z256, r##src) \
90 CASE_MASKZ_INS_COMMON(Inst, Z128, r##src)
91
92#define CASE_PMOVZX(Inst, src) \
93 CASE_AVX512_INS_COMMON(Inst, Z, r##src) \
94 CASE_AVX512_INS_COMMON(Inst, Z256, r##src) \
95 CASE_AVX512_INS_COMMON(Inst, Z128, r##src) \
96 CASE_AVX_INS_COMMON(Inst, , r##src) \
97 CASE_AVX_INS_COMMON(Inst, Y, r##src) \
98 CASE_SSE_INS_COMMON(Inst, r##src)
99
100#define CASE_UNPCK(Inst, src) \
101 CASE_AVX512_INS_COMMON(Inst, Z, r##src) \
102 CASE_AVX512_INS_COMMON(Inst, Z256, r##src) \
103 CASE_AVX512_INS_COMMON(Inst, Z128, r##src) \
104 CASE_AVX_INS_COMMON(Inst, , r##src) \
105 CASE_AVX_INS_COMMON(Inst, Y, r##src) \
106 CASE_SSE_INS_COMMON(Inst, r##src)
107
108#define CASE_MASK_UNPCK(Inst, src) \
109 CASE_MASK_INS_COMMON(Inst, Z, r##src) \
110 CASE_MASK_INS_COMMON(Inst, Z256, r##src) \
111 CASE_MASK_INS_COMMON(Inst, Z128, r##src)
112
113#define CASE_MASKZ_UNPCK(Inst, src) \
114 CASE_MASKZ_INS_COMMON(Inst, Z, r##src) \
115 CASE_MASKZ_INS_COMMON(Inst, Z256, r##src) \
116 CASE_MASKZ_INS_COMMON(Inst, Z128, r##src)
117
118#define CASE_SHUF(Inst, suf) \
119 CASE_AVX512_INS_COMMON(Inst, Z, suf) \
120 CASE_AVX512_INS_COMMON(Inst, Z256, suf) \
121 CASE_AVX512_INS_COMMON(Inst, Z128, suf) \
122 CASE_AVX_INS_COMMON(Inst, , suf) \
123 CASE_AVX_INS_COMMON(Inst, Y, suf) \
124 CASE_SSE_INS_COMMON(Inst, suf)
125
126#define CASE_MASK_SHUF(Inst, src) \
127 CASE_MASK_INS_COMMON(Inst, Z, r##src##i) \
128 CASE_MASK_INS_COMMON(Inst, Z256, r##src##i) \
129 CASE_MASK_INS_COMMON(Inst, Z128, r##src##i)
130
131#define CASE_MASKZ_SHUF(Inst, src) \
132 CASE_MASKZ_INS_COMMON(Inst, Z, r##src##i) \
133 CASE_MASKZ_INS_COMMON(Inst, Z256, r##src##i) \
134 CASE_MASKZ_INS_COMMON(Inst, Z128, r##src##i)
135
136#define CASE_VPERMILPI(Inst, src) \
137 CASE_AVX512_INS_COMMON(Inst, Z, src##i) \
138 CASE_AVX512_INS_COMMON(Inst, Z256, src##i) \
139 CASE_AVX512_INS_COMMON(Inst, Z128, src##i) \
140 CASE_AVX_INS_COMMON(Inst, , src##i) \
141 CASE_AVX_INS_COMMON(Inst, Y, src##i)
142
143#define CASE_MASK_VPERMILPI(Inst, src) \
144 CASE_MASK_INS_COMMON(Inst, Z, src##i) \
145 CASE_MASK_INS_COMMON(Inst, Z256, src##i) \
146 CASE_MASK_INS_COMMON(Inst, Z128, src##i)
147
148#define CASE_MASKZ_VPERMILPI(Inst, src) \
149 CASE_MASKZ_INS_COMMON(Inst, Z, src##i) \
150 CASE_MASKZ_INS_COMMON(Inst, Z256, src##i) \
151 CASE_MASKZ_INS_COMMON(Inst, Z128, src##i)
152
153#define CASE_VPERM(Inst, src) \
154 CASE_AVX512_INS_COMMON(Inst, Z, src##i) \
155 CASE_AVX512_INS_COMMON(Inst, Z256, src##i) \
156 CASE_AVX_INS_COMMON(Inst, Y, src##i)
157
158#define CASE_MASK_VPERM(Inst, src) \
159 CASE_MASK_INS_COMMON(Inst, Z, src##i) \
160 CASE_MASK_INS_COMMON(Inst, Z256, src##i)
161
162#define CASE_MASKZ_VPERM(Inst, src) \
163 CASE_MASKZ_INS_COMMON(Inst, Z, src##i) \
164 CASE_MASKZ_INS_COMMON(Inst, Z256, src##i)
165
166#define CASE_VSHUF(Inst, src) \
167 CASE_AVX512_INS_COMMON(SHUFF##Inst, Z, r##src##i) \
168 CASE_AVX512_INS_COMMON(SHUFI##Inst, Z, r##src##i) \
169 CASE_AVX512_INS_COMMON(SHUFF##Inst, Z256, r##src##i) \
170 CASE_AVX512_INS_COMMON(SHUFI##Inst, Z256, r##src##i)
171
172#define CASE_MASK_VSHUF(Inst, src) \
173 CASE_MASK_INS_COMMON(SHUFF##Inst, Z, r##src##i) \
174 CASE_MASK_INS_COMMON(SHUFI##Inst, Z, r##src##i) \
175 CASE_MASK_INS_COMMON(SHUFF##Inst, Z256, r##src##i) \
176 CASE_MASK_INS_COMMON(SHUFI##Inst, Z256, r##src##i)
177
178#define CASE_MASKZ_VSHUF(Inst, src) \
179 CASE_MASKZ_INS_COMMON(SHUFF##Inst, Z, r##src##i) \
180 CASE_MASKZ_INS_COMMON(SHUFI##Inst, Z, r##src##i) \
181 CASE_MASKZ_INS_COMMON(SHUFF##Inst, Z256, r##src##i) \
182 CASE_MASKZ_INS_COMMON(SHUFI##Inst, Z256, r##src##i)
183
184#define CASE_AVX512_FMA(Inst, suf) \
185 CASE_AVX512_INS_COMMON(Inst, Z, suf) \
186 CASE_AVX512_INS_COMMON(Inst, Z256, suf) \
187 CASE_AVX512_INS_COMMON(Inst, Z128, suf)
188
189#define CASE_FMA(Inst, suf) \
190 CASE_AVX512_FMA(Inst, suf) \
191 CASE_AVX_INS_COMMON(Inst, , suf) \
192 CASE_AVX_INS_COMMON(Inst, Y, suf)
193
194#define CASE_FMA_PACKED_REG(Inst) \
195 CASE_FMA(Inst##PD, r) \
196 CASE_FMA(Inst##PS, r)
197
198#define CASE_FMA_PACKED_MEM(Inst) \
199 CASE_FMA(Inst##PD, m) \
200 CASE_FMA(Inst##PS, m) \
201 CASE_AVX512_FMA(Inst##PD, mb) \
202 CASE_AVX512_FMA(Inst##PS, mb)
203
204#define CASE_FMA_SCALAR_REG(Inst) \
205 CASE_AVX_INS_COMMON(Inst##SD, , r) \
206 CASE_AVX_INS_COMMON(Inst##SS, , r) \
207 CASE_AVX_INS_COMMON(Inst##SD, , r_Int) \
208 CASE_AVX_INS_COMMON(Inst##SS, , r_Int) \
209 CASE_AVX_INS_COMMON(Inst##SD, Z, r) \
210 CASE_AVX_INS_COMMON(Inst##SS, Z, r) \
211 CASE_AVX512_INS_COMMON_INT(Inst##SD, Z, r) \
212 CASE_AVX512_INS_COMMON_INT(Inst##SS, Z, r)
213
214#define CASE_FMA_SCALAR_MEM(Inst) \
215 CASE_AVX_INS_COMMON(Inst##SD, , m) \
216 CASE_AVX_INS_COMMON(Inst##SS, , m) \
217 CASE_AVX_INS_COMMON(Inst##SD, , m_Int) \
218 CASE_AVX_INS_COMMON(Inst##SS, , m_Int) \
219 CASE_AVX_INS_COMMON(Inst##SD, Z, m) \
220 CASE_AVX_INS_COMMON(Inst##SS, Z, m) \
221 CASE_AVX512_INS_COMMON_INT(Inst##SD, Z, m) \
222 CASE_AVX512_INS_COMMON_INT(Inst##SS, Z, m)
223
224#define CASE_FMA4(Inst, suf) \
225 CASE_AVX_INS_COMMON(Inst, 4, suf) \
226 CASE_AVX_INS_COMMON(Inst, 4Y, suf)
227
228#define CASE_FMA4_PACKED_RR(Inst) \
229 CASE_FMA4(Inst##PD, rr) \
230 CASE_FMA4(Inst##PS, rr)
231
232#define CASE_FMA4_PACKED_RM(Inst) \
233 CASE_FMA4(Inst##PD, rm) \
234 CASE_FMA4(Inst##PS, rm)
235
236#define CASE_FMA4_PACKED_MR(Inst) \
237 CASE_FMA4(Inst##PD, mr) \
238 CASE_FMA4(Inst##PS, mr)
239
240#define CASE_FMA4_SCALAR_RR(Inst) \
241 CASE_AVX_INS_COMMON(Inst##SD4, , rr) \
242 CASE_AVX_INS_COMMON(Inst##SS4, , rr) \
243 CASE_AVX_INS_COMMON(Inst##SD4, , rr_Int) \
244 CASE_AVX_INS_COMMON(Inst##SS4, , rr_Int)
245
246#define CASE_FMA4_SCALAR_RM(Inst) \
247 CASE_AVX_INS_COMMON(Inst##SD4, , rm) \
248 CASE_AVX_INS_COMMON(Inst##SS4, , rm) \
249 CASE_AVX_INS_COMMON(Inst##SD4, , rm_Int) \
250 CASE_AVX_INS_COMMON(Inst##SS4, , rm_Int)
251
252#define CASE_FMA4_SCALAR_MR(Inst) \
253 CASE_AVX_INS_COMMON(Inst##SD4, , mr) \
254 CASE_AVX_INS_COMMON(Inst##SS4, , mr) \
255 CASE_AVX_INS_COMMON(Inst##SD4, , mr_Int) \
256 CASE_AVX_INS_COMMON(Inst##SS4, , mr_Int)
257
258static unsigned getVectorRegSize(MCRegister Reg) {
259 if (X86II::isZMMReg(Reg))
260 return 512;
261 if (X86II::isYMMReg(Reg))
262 return 256;
263 if (X86II::isXMMReg(Reg))
264 return 128;
265 if (Reg >= X86::MM0 && Reg <= X86::MM7)
266 return 64;
267
268 llvm_unreachable("Unknown vector reg!");
269}
270
271static unsigned getRegOperandNumElts(const MCInst *MI, unsigned ScalarSize,
272 unsigned OperandIndex) {
273 MCRegister OpReg = MI->getOperand(OperandIndex).getReg();
274 return getVectorRegSize(OpReg) / ScalarSize;
275}
276
277static const char *getRegName(MCRegister Reg) {
278 return X86ATTInstPrinter::getRegisterName(Reg);
279}
280
281/// Wraps the destination register name with AVX512 mask/maskz filtering.
282static void printMasking(raw_ostream &OS, const MCInst *MI,
283 const MCInstrInfo &MCII) {
284 const MCInstrDesc &Desc = MCII.get(MI->getOpcode());
285 uint64_t TSFlags = Desc.TSFlags;
286
287 if (!(TSFlags & X86II::EVEX_K))
288 return;
289
290 bool MaskWithZero = (TSFlags & X86II::EVEX_Z);
291 unsigned MaskOp = Desc.getNumDefs();
292
293 if (Desc.getOperandConstraint(MaskOp, MCOI::TIED_TO) != -1)
294 ++MaskOp;
295
296 const char *MaskRegName = getRegName(MI->getOperand(MaskOp).getReg());
297
298 // MASK: zmmX {%kY}
299 OS << " {%" << MaskRegName << "}";
300
301 // MASKZ: zmmX {%kY} {z}
302 if (MaskWithZero)
303 OS << " {z}";
304}
305
306static bool printFMAComments(const MCInst *MI, raw_ostream &OS,
307 const MCInstrInfo &MCII) {
308 const char *Mul1Name = nullptr, *Mul2Name = nullptr, *AccName = nullptr;
309 unsigned NumOperands = MI->getNumOperands();
310 bool RegForm = false;
311 bool Negate = false;
312 StringRef AccStr = "+";
313
314 // The operands for FMA3 instructions without rounding fall into two forms:
315 // dest, src1, src2, src3
316 // dest, src1, mask, src2, src3
317 // Where src3 is either a register or 5 memory address operands. So to find
318 // dest and src1 we can index from the front. To find src2 and src3 we can
319 // index from the end by taking into account memory vs register form when
320 // finding src2.
321
322 // The operands for FMA4 instructions:
323 // dest, src1, src2, src3
324 // Where src2 OR src3 are either a register or 5 memory address operands. So
325 // to find dest and src1 we can index from the front, src2 (reg/mem) follows
326 // and then src3 (reg) will be at the end.
327
328 switch (MI->getOpcode()) {
329 default:
330 return false;
331
332 CASE_FMA4_PACKED_RR(FMADD)
333 CASE_FMA4_SCALAR_RR(FMADD)
334 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
335 [[fallthrough]];
336 CASE_FMA4_PACKED_RM(FMADD)
337 CASE_FMA4_SCALAR_RM(FMADD)
338 Mul2Name = getRegName(MI->getOperand(2).getReg());
339 Mul1Name = getRegName(MI->getOperand(1).getReg());
340 break;
341 CASE_FMA4_PACKED_MR(FMADD)
342 CASE_FMA4_SCALAR_MR(FMADD)
343 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
344 Mul1Name = getRegName(MI->getOperand(1).getReg());
345 break;
346
347 CASE_FMA4_PACKED_RR(FMSUB)
348 CASE_FMA4_SCALAR_RR(FMSUB)
349 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
350 [[fallthrough]];
351 CASE_FMA4_PACKED_RM(FMSUB)
352 CASE_FMA4_SCALAR_RM(FMSUB)
353 Mul2Name = getRegName(MI->getOperand(2).getReg());
354 Mul1Name = getRegName(MI->getOperand(1).getReg());
355 AccStr = "-";
356 break;
357 CASE_FMA4_PACKED_MR(FMSUB)
358 CASE_FMA4_SCALAR_MR(FMSUB)
359 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
360 Mul1Name = getRegName(MI->getOperand(1).getReg());
361 AccStr = "-";
362 break;
363
364 CASE_FMA4_PACKED_RR(FNMADD)
365 CASE_FMA4_SCALAR_RR(FNMADD)
366 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
367 [[fallthrough]];
368 CASE_FMA4_PACKED_RM(FNMADD)
369 CASE_FMA4_SCALAR_RM(FNMADD)
370 Mul2Name = getRegName(MI->getOperand(2).getReg());
371 Mul1Name = getRegName(MI->getOperand(1).getReg());
372 Negate = true;
373 break;
374 CASE_FMA4_PACKED_MR(FNMADD)
375 CASE_FMA4_SCALAR_MR(FNMADD)
376 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
377 Mul1Name = getRegName(MI->getOperand(1).getReg());
378 Negate = true;
379 break;
380
381 CASE_FMA4_PACKED_RR(FNMSUB)
382 CASE_FMA4_SCALAR_RR(FNMSUB)
383 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
384 [[fallthrough]];
385 CASE_FMA4_PACKED_RM(FNMSUB)
386 CASE_FMA4_SCALAR_RM(FNMSUB)
387 Mul2Name = getRegName(MI->getOperand(2).getReg());
388 Mul1Name = getRegName(MI->getOperand(1).getReg());
389 AccStr = "-";
390 Negate = true;
391 break;
392 CASE_FMA4_PACKED_MR(FNMSUB)
393 CASE_FMA4_SCALAR_MR(FNMSUB)
394 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
395 Mul1Name = getRegName(MI->getOperand(1).getReg());
396 AccStr = "-";
397 Negate = true;
398 break;
399
400 CASE_FMA4_PACKED_RR(FMADDSUB)
401 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
402 [[fallthrough]];
403 CASE_FMA4_PACKED_RM(FMADDSUB)
404 Mul2Name = getRegName(MI->getOperand(2).getReg());
405 Mul1Name = getRegName(MI->getOperand(1).getReg());
406 AccStr = "+/-";
407 break;
408 CASE_FMA4_PACKED_MR(FMADDSUB)
409 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
410 Mul1Name = getRegName(MI->getOperand(1).getReg());
411 AccStr = "+/-";
412 break;
413
414 CASE_FMA4_PACKED_RR(FMSUBADD)
415 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
416 [[fallthrough]];
417 CASE_FMA4_PACKED_RM(FMSUBADD)
418 Mul2Name = getRegName(MI->getOperand(2).getReg());
419 Mul1Name = getRegName(MI->getOperand(1).getReg());
420 AccStr = "-/+";
421 break;
422 CASE_FMA4_PACKED_MR(FMSUBADD)
423 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
424 Mul1Name = getRegName(MI->getOperand(1).getReg());
425 AccStr = "-/+";
426 break;
427
428 CASE_FMA_PACKED_REG(FMADD132)
429 CASE_FMA_SCALAR_REG(FMADD132)
430 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
431 RegForm = true;
432 [[fallthrough]];
433 CASE_FMA_PACKED_MEM(FMADD132)
434 CASE_FMA_SCALAR_MEM(FMADD132)
435 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
436 Mul1Name = getRegName(MI->getOperand(1).getReg());
437 break;
438
439 CASE_FMA_PACKED_REG(FMADD213)
440 CASE_FMA_SCALAR_REG(FMADD213)
441 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
442 RegForm = true;
443 [[fallthrough]];
444 CASE_FMA_PACKED_MEM(FMADD213)
445 CASE_FMA_SCALAR_MEM(FMADD213)
446 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
447 Mul2Name = getRegName(MI->getOperand(1).getReg());
448 break;
449
450 CASE_FMA_PACKED_REG(FMADD231)
451 CASE_FMA_SCALAR_REG(FMADD231)
452 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
453 RegForm = true;
454 [[fallthrough]];
455 CASE_FMA_PACKED_MEM(FMADD231)
456 CASE_FMA_SCALAR_MEM(FMADD231)
457 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
458 AccName = getRegName(MI->getOperand(1).getReg());
459 break;
460
461 CASE_FMA_PACKED_REG(FMSUB132)
462 CASE_FMA_SCALAR_REG(FMSUB132)
463 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
464 RegForm = true;
465 [[fallthrough]];
466 CASE_FMA_PACKED_MEM(FMSUB132)
467 CASE_FMA_SCALAR_MEM(FMSUB132)
468 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
469 Mul1Name = getRegName(MI->getOperand(1).getReg());
470 AccStr = "-";
471 break;
472
473 CASE_FMA_PACKED_REG(FMSUB213)
474 CASE_FMA_SCALAR_REG(FMSUB213)
475 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
476 RegForm = true;
477 [[fallthrough]];
478 CASE_FMA_PACKED_MEM(FMSUB213)
479 CASE_FMA_SCALAR_MEM(FMSUB213)
480 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
481 Mul2Name = getRegName(MI->getOperand(1).getReg());
482 AccStr = "-";
483 break;
484
485 CASE_FMA_PACKED_REG(FMSUB231)
486 CASE_FMA_SCALAR_REG(FMSUB231)
487 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
488 RegForm = true;
489 [[fallthrough]];
490 CASE_FMA_PACKED_MEM(FMSUB231)
491 CASE_FMA_SCALAR_MEM(FMSUB231)
492 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
493 AccName = getRegName(MI->getOperand(1).getReg());
494 AccStr = "-";
495 break;
496
497 CASE_FMA_PACKED_REG(FNMADD132)
498 CASE_FMA_SCALAR_REG(FNMADD132)
499 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
500 RegForm = true;
501 [[fallthrough]];
502 CASE_FMA_PACKED_MEM(FNMADD132)
503 CASE_FMA_SCALAR_MEM(FNMADD132)
504 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
505 Mul1Name = getRegName(MI->getOperand(1).getReg());
506 Negate = true;
507 break;
508
509 CASE_FMA_PACKED_REG(FNMADD213)
510 CASE_FMA_SCALAR_REG(FNMADD213)
511 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
512 RegForm = true;
513 [[fallthrough]];
514 CASE_FMA_PACKED_MEM(FNMADD213)
515 CASE_FMA_SCALAR_MEM(FNMADD213)
516 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
517 Mul2Name = getRegName(MI->getOperand(1).getReg());
518 Negate = true;
519 break;
520
521 CASE_FMA_PACKED_REG(FNMADD231)
522 CASE_FMA_SCALAR_REG(FNMADD231)
523 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
524 RegForm = true;
525 [[fallthrough]];
526 CASE_FMA_PACKED_MEM(FNMADD231)
527 CASE_FMA_SCALAR_MEM(FNMADD231)
528 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
529 AccName = getRegName(MI->getOperand(1).getReg());
530 Negate = true;
531 break;
532
533 CASE_FMA_PACKED_REG(FNMSUB132)
534 CASE_FMA_SCALAR_REG(FNMSUB132)
535 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
536 RegForm = true;
537 [[fallthrough]];
538 CASE_FMA_PACKED_MEM(FNMSUB132)
539 CASE_FMA_SCALAR_MEM(FNMSUB132)
540 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
541 Mul1Name = getRegName(MI->getOperand(1).getReg());
542 AccStr = "-";
543 Negate = true;
544 break;
545
546 CASE_FMA_PACKED_REG(FNMSUB213)
547 CASE_FMA_SCALAR_REG(FNMSUB213)
548 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
549 RegForm = true;
550 [[fallthrough]];
551 CASE_FMA_PACKED_MEM(FNMSUB213)
552 CASE_FMA_SCALAR_MEM(FNMSUB213)
553 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
554 Mul2Name = getRegName(MI->getOperand(1).getReg());
555 AccStr = "-";
556 Negate = true;
557 break;
558
559 CASE_FMA_PACKED_REG(FNMSUB231)
560 CASE_FMA_SCALAR_REG(FNMSUB231)
561 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
562 RegForm = true;
563 [[fallthrough]];
564 CASE_FMA_PACKED_MEM(FNMSUB231)
565 CASE_FMA_SCALAR_MEM(FNMSUB231)
566 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
567 AccName = getRegName(MI->getOperand(1).getReg());
568 AccStr = "-";
569 Negate = true;
570 break;
571
572 CASE_FMA_PACKED_REG(FMADDSUB132)
573 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
574 RegForm = true;
575 [[fallthrough]];
576 CASE_FMA_PACKED_MEM(FMADDSUB132)
577 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
578 Mul1Name = getRegName(MI->getOperand(1).getReg());
579 AccStr = "+/-";
580 break;
581
582 CASE_FMA_PACKED_REG(FMADDSUB213)
583 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
584 RegForm = true;
585 [[fallthrough]];
586 CASE_FMA_PACKED_MEM(FMADDSUB213)
587 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
588 Mul2Name = getRegName(MI->getOperand(1).getReg());
589 AccStr = "+/-";
590 break;
591
592 CASE_FMA_PACKED_REG(FMADDSUB231)
593 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
594 RegForm = true;
595 [[fallthrough]];
596 CASE_FMA_PACKED_MEM(FMADDSUB231)
597 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
598 AccName = getRegName(MI->getOperand(1).getReg());
599 AccStr = "+/-";
600 break;
601
602 CASE_FMA_PACKED_REG(FMSUBADD132)
603 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
604 RegForm = true;
605 [[fallthrough]];
606 CASE_FMA_PACKED_MEM(FMSUBADD132)
607 AccName = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
608 Mul1Name = getRegName(MI->getOperand(1).getReg());
609 AccStr = "-/+";
610 break;
611
612 CASE_FMA_PACKED_REG(FMSUBADD213)
613 AccName = getRegName(MI->getOperand(NumOperands - 1).getReg());
614 RegForm = true;
615 [[fallthrough]];
616 CASE_FMA_PACKED_MEM(FMSUBADD213)
617 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
618 Mul2Name = getRegName(MI->getOperand(1).getReg());
619 AccStr = "-/+";
620 break;
621
622 CASE_FMA_PACKED_REG(FMSUBADD231)
623 Mul2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
624 RegForm = true;
625 [[fallthrough]];
626 CASE_FMA_PACKED_MEM(FMSUBADD231)
627 Mul1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
628 AccName = getRegName(MI->getOperand(1).getReg());
629 AccStr = "-/+";
630 break;
631 }
632
633 const char *DestName = getRegName(MI->getOperand(0).getReg());
634
635 if (!Mul1Name) Mul1Name = "mem";
636 if (!Mul2Name) Mul2Name = "mem";
637 if (!AccName) AccName = "mem";
638
639 OS << DestName;
640 printMasking(OS, MI, MCII);
641 OS << " = ";
642
643 if (Negate)
644 OS << '-';
645
646 OS << '(' << Mul1Name << " * " << Mul2Name << ") " << AccStr << ' '
647 << AccName << '\n';
648
649 return true;
650}
651
652// This table is indexed by the imm8 binary function specified in a
653// vpternlog{d,q} instruction. The symbols {a,b,c} correspond to the three
654// inputs to the binary function. This table was taken from
655// https://gist.github.com/dougallj/81a80cd381988466c4e1c4889ecac95b#file-2-x86-base-txt
656// with slight massaging.
657constexpr EnumStringDef<uint8_t> TernlogFunctionDefs[] = {
658 {{"0"}, 0},
659 {{"~(a | b | c)"}, 1},
660 {{"c & ~(a | b)"}, 2},
661 {{"~(a | b)"}, 3},
662 {{"b & ~(a | c)"}, 4},
663 {{"~(a | c)"}, 5},
664 {{"~a & (b ^ c)"}, 6},
665 {{"~(a | (b & c))"}, 7},
666 {{"b & c & ~a"}, 8},
667 {{"~(a | (b ^ c))"}, 9},
668 {{"c & ~a"}, 10},
669 {{"~a & (c | ~b)"}, 11},
670 {{"b & ~a"}, 12},
671 {{"~a & (b | ~c)"}, 13},
672 {{"~a & (b | c)"}, 14},
673 {{"~a"}, 15},
674 {{"a & ~(b | c)"}, 16},
675 {{"~(b | c)"}, 17},
676 {{"~b & (a ^ c)"}, 18},
677 {{"~((a & c) | b)"}, 19},
678 {{"~c & (a ^ b)"}, 20},
679 {{"~((a & b) | c)"}, 21},
680 {{"a ^ ((a & b) | (b ^ c))"}, 22},
681 {{"(a & (b ^ c)) ^ ~(b & c)"}, 23},
682 {{"(a ^ b) & (a ^ c)"}, 24},
683 {{"~((a & b) | (b ^ c))"}, 25},
684 {{"a ^ ((a & b) | c)"}, 26},
685 {{"(a & c) ^ (c | ~b)"}, 27},
686 {{"a ^ ((a & c) | b)"}, 28},
687 {{"(a & b) ^ (b | ~c)"}, 29},
688 {{"a ^ (b | c)"}, 30},
689 {{"~(a & (b | c))"}, 31},
690 {{"a & c & ~b"}, 32},
691 {{"~(b | (a ^ c))"}, 33},
692 {{"c & ~b"}, 34},
693 {{"~b & (c | ~a)"}, 35},
694 {{"(a ^ b) & (b ^ c)"}, 36},
695 {{"~((a & b) | (a ^ c))"}, 37},
696 {{"b ^ ((a & b) | c)"}, 38},
697 {{"(b & c) ^ (c | ~a)"}, 39},
698 {{"c & (a ^ b)"}, 40},
699 {{"(a | b) ^ ((a & b) | ~c)"}, 41},
700 {{"c & ~(a & b)"}, 42},
701 {{"(c & (a ^ b)) | ~(a | b)"}, 43},
702 {{"(b | c) & (a ^ b)"}, 44},
703 {{"a ^ (b | ~c)"}, 45},
704 {{"(a & b) ^ (b | c)"}, 46},
705 {{"(c & ~b) | ~a"}, 47},
706 {{"a & ~b"}, 48},
707 {{"~b & (a | ~c)"}, 49},
708 {{"~b & (a | c)"}, 50},
709 {{"~b"}, 51},
710 {{"b ^ (a | (b & c))"}, 52},
711 {{"(a & b) ^ (a | ~c)"}, 53},
712 {{"b ^ (a | c)"}, 54},
713 {{"~(b & (a | c))"}, 55},
714 {{"(a | c) & (a ^ b)"}, 56},
715 {{"b ^ (a | ~c)"}, 57},
716 {{"(a & b) ^ (a | c)"}, 58},
717 {{"(c & ~a) | ~b"}, 59},
718 {{"a ^ b"}, 60},
719 {{"~(a | c) | (a ^ b)"}, 61},
720 {{"(c & ~a) | (a ^ b)"}, 62},
721 {{"~(a & b)"}, 63},
722 {{"a & b & ~c"}, 64},
723 {{"~(c | (a ^ b))"}, 65},
724 {{"(a ^ c) & (b ^ c)"}, 66},
725 {{"~((a & c) | (a ^ b))"}, 67},
726 {{"b & ~c"}, 68},
727 {{"~c & (b | ~a)"}, 69},
728 {{"c ^ ((a & c) | b)"}, 70},
729 {{"(b & c) ^ (b | ~a)"}, 71},
730 {{"b & (a ^ c)"}, 72},
731 {{"(a | c) ^ ((a & c) | ~b)"}, 73},
732 {{"(b | c) & (a ^ c)"}, 74},
733 {{"a ^ (c | ~b)"}, 75},
734 {{"b & ~(a & c)"}, 76},
735 {{"(b & (a ^ c)) | ~(a | c)"}, 77},
736 {{"(a & c) ^ (b | c)"}, 78},
737 {{"(b & ~c) | ~a"}, 79},
738 {{"a & ~c"}, 80},
739 {{"~c & (a | ~b)"}, 81},
740 {{"c ^ (a | (b & c))"}, 82},
741 {{"(a & c) ^ (a | ~b)"}, 83},
742 {{"~c & (a | b)"}, 84},
743 {{"~c"}, 85},
744 {{"c ^ (a | b)"}, 86},
745 {{"~(c & (a | b))"}, 87},
746 {{"(a | b) & (a ^ c)"}, 88},
747 {{"c ^ (a | ~b)"}, 89},
748 {{"a ^ c"}, 90},
749 {{"~(a | b) | (a ^ c)"}, 91},
750 {{"(a & c) ^ (a | b)"}, 92},
751 {{"(b & ~a) | ~c"}, 93},
752 {{"(b & ~a) | (a ^ c)"}, 94},
753 {{"~(a & c)"}, 95},
754 {{"a & (b ^ c)"}, 96},
755 {{"~(b ^ c) ^ (a | (b & c))"}, 97},
756 {{"(a | c) & (b ^ c)"}, 98},
757 {{"b ^ (c | ~a)"}, 99},
758 {{"(a | b) & (b ^ c)"}, 100},
759 {{"c ^ (b | ~a)"}, 101},
760 {{"b ^ c"}, 102},
761 {{"~(a | b) | (b ^ c)"}, 103},
762 {{"(a | b) & (c ^ (a & b))"}, 104},
763 {{"b ^ c ^ ~a"}, 105},
764 {{"c ^ (a & b)"}, 106},
765 {{"~(a | b) | (c ^ (a & b))"}, 107},
766 {{"b ^ (a & c)"}, 108},
767 {{"~(a | c) | (b ^ (a & c))"}, 109},
768 {{"(b & ~a) | (b ^ c)"}, 110},
769 {{"~a | (b ^ c)"}, 111},
770 {{"a & ~(b & c)"}, 112},
771 {{"(a & (b ^ c)) | ~(b | c)"}, 113},
772 {{"(b & c) ^ (a | c)"}, 114},
773 {{"(a & ~c) | ~b"}, 115},
774 {{"(b & c) ^ (a | b)"}, 116},
775 {{"(a & ~b) | ~c"}, 117},
776 {{"(a & ~b) | (b ^ c)"}, 118},
777 {{"~(b & c)"}, 119},
778 {{"a ^ (b & c)"}, 120},
779 {{"~(b | c) | (a ^ (b & c))"}, 121},
780 {{"(a & ~b) | (a ^ c)"}, 122},
781 {{"~b | (a ^ c)"}, 123},
782 {{"(a & ~c) | (a ^ b)"}, 124},
783 {{"~c | (a ^ b)"}, 125},
784 {{"(a ^ b) | (a ^ c)"}, 126},
785 {{"~(a & b & c)"}, 127},
786 {{"a & b & c"}, 128},
787 {{"~((a ^ b) | (a ^ c))"}, 129},
788 {{"c & ~(a ^ b)"}, 130},
789 {{"~(a ^ b) & (c | ~a)"}, 131},
790 {{"b & ~(a ^ c)"}, 132},
791 {{"~(a ^ c) & (b | ~a)"}, 133},
792 {{"(b | c) & (a ^ b ^ c)"}, 134},
793 {{"(b & c) ^ ~a"}, 135},
794 {{"b & c"}, 136},
795 {{"~(b ^ c) & (b | ~a)"}, 137},
796 {{"c & (b | ~a)"}, 138},
797 {{"~((b & c) ^ (a | b))"}, 139},
798 {{"b & (c | ~a)"}, 140},
799 {{"~((b & c) ^ (a | c))"}, 141},
800 {{"a ^ ((a ^ b) | (a ^ c))"}, 142},
801 {{"(b & c) | ~a"}, 143},
802 {{"a & ~(b ^ c)"}, 144},
803 {{"~(b ^ c) & (a | ~b)"}, 145},
804 {{"(a | c) & (a ^ b ^ c)"}, 146},
805 {{"(a & c) ^ ~b"}, 147},
806 {{"(a | b) & (a ^ b ^ c)"}, 148},
807 {{"(a & b) ^ ~c"}, 149},
808 {{"a ^ b ^ c"}, 150},
809 {{"~(a | b) | (a ^ b ^ c)"}, 151},
810 {{"~(b ^ c) & (a | b)"}, 152},
811 {{"~(b ^ c)"}, 153},
812 {{"c ^ (a & ~b)"}, 154},
813 {{"~((a | b) & (b ^ c))"}, 155},
814 {{"b ^ (a & ~c)"}, 156},
815 {{"~((a | c) & (b ^ c))"}, 157},
816 {{"(b & c) | (a ^ (b | c))"}, 158},
817 {{"~(a & (b ^ c))"}, 159},
818 {{"a & c"}, 160},
819 {{"~(a ^ c) & (a | ~b)"}, 161},
820 {{"c & (a | ~b)"}, 162},
821 {{"~((a & c) ^ (a | b))"}, 163},
822 {{"~(a ^ c) & (a | b)"}, 164},
823 {{"~(a ^ c)"}, 165},
824 {{"c ^ (b & ~a)"}, 166},
825 {{"~((a | b) & (a ^ c))"}, 167},
826 {{"c & (a | b)"}, 168},
827 {{"~c ^ (a | b)"}, 169},
828 {{"c"}, 170},
829 {{"c | ~(a | b)"}, 171},
830 {{"b ^ (a & (b ^ c))"}, 172},
831 {{"(b & c) | ~(a ^ c)"}, 173},
832 {{"(b & ~a) | c"}, 174},
833 {{"c | ~a"}, 175},
834 {{"a & (c | ~b)"}, 176},
835 {{"~((a & c) ^ (b | c))"}, 177},
836 {{"a ^ ((a ^ c) & (b ^ c))"}, 178},
837 {{"(a & c) | ~b"}, 179},
838 {{"a ^ (b & ~c)"}, 180},
839 {{"~((b | c) & (a ^ c))"}, 181},
840 {{"(a & c) | (a ^ b ^ c)"}, 182},
841 {{"~(b & (a ^ c))"}, 183},
842 {{"a ^ (b & (a ^ c))"}, 184},
843 {{"(a & c) | ~(b ^ c)"}, 185},
844 {{"(a & ~b) | c"}, 186},
845 {{"c | ~b"}, 187},
846 {{"(a & c) | (a ^ b)"}, 188},
847 {{"~((a ^ c) & (b ^ c))"}, 189},
848 {{"c | (a ^ b)"}, 190},
849 {{"c | ~(a & b)"}, 191},
850 {{"a & b"}, 192},
851 {{"~(a ^ b) & (a | ~c)"}, 193},
852 {{"~(a ^ b) & (a | c)"}, 194},
853 {{"~(a ^ b)"}, 195},
854 {{"b & (a | ~c)"}, 196},
855 {{"~((a & b) ^ (a | c))"}, 197},
856 {{"b ^ (c & ~a)"}, 198},
857 {{"~((a | c) & (a ^ b))"}, 199},
858 {{"b & (a | c)"}, 200},
859 {{"~b ^ (a | c)"}, 201},
860 {{"c ^ (a & (b ^ c))"}, 202},
861 {{"(b & c) | ~(a ^ b)"}, 203},
862 {{"b"}, 204},
863 {{"b | ~(a | c)"}, 205},
864 {{"(c & ~a) | b"}, 206},
865 {{"b | ~a"}, 207},
866 {{"a & (b | ~c)"}, 208},
867 {{"~((a & b) ^ (b | c))"}, 209},
868 {{"a ^ (c & ~b)"}, 210},
869 {{"~((b | c) & (a ^ b))"}, 211},
870 {{"a ^ ((a ^ b) & (b ^ c))"}, 212},
871 {{"(a & b) | ~c"}, 213},
872 {{"(a & b) | (a ^ b ^ c)"}, 214},
873 {{"~(c & (a ^ b))"}, 215},
874 {{"a ^ (c & (a ^ b))"}, 216},
875 {{"(a & b) | ~(b ^ c)"}, 217},
876 {{"(a & b) | (a ^ c)"}, 218},
877 {{"~((a ^ b) & (b ^ c))"}, 219},
878 {{"(a & ~c) | b"}, 220},
879 {{"b | ~c"}, 221},
880 {{"b | (a ^ c)"}, 222},
881 {{"b | ~(a & c)"}, 223},
882 {{"a & (b | c)"}, 224},
883 {{"~a ^ (b | c)"}, 225},
884 {{"c ^ (b & (a ^ c))"}, 226},
885 {{"(a & c) | ~(a ^ b)"}, 227},
886 {{"b ^ (c & (a ^ b))"}, 228},
887 {{"(a & b) | ~(a ^ c)"}, 229},
888 {{"(a & b) | (b ^ c)"}, 230},
889 {{"~((a ^ b) & (a ^ c))"}, 231},
890 {{"(a | b) & ((a & b) | c)"}, 232},
891 {{"(a & b) | (b ^ c ^ ~a)"}, 233},
892 {{"(a & b) | c"}, 234},
893 {{"c | ~(a ^ b)"}, 235},
894 {{"(a & c) | b"}, 236},
895 {{"b | ~(a ^ c)"}, 237},
896 {{"b | c"}, 238},
897 {{"~a | b | c"}, 239},
898 {{"a"}, 240},
899 {{"a | ~(b | c)"}, 241},
900 {{"a | (c & ~b)"}, 242},
901 {{"a | ~b"}, 243},
902 {{"a | (b & ~c)"}, 244},
903 {{"a | ~c"}, 245},
904 {{"a | (b ^ c)"}, 246},
905 {{"a | ~(b & c)"}, 247},
906 {{"a | (b & c)"}, 248},
907 {{"a | ~(b ^ c)"}, 249},
908 {{"a | c"}, 250},
909 {{"~b | a | c"}, 251},
910 {{"a | b"}, 252},
911 {{"~c | a | b"}, 253},
912 {{"a | b | c"}, 254},
913 {{"-1"}, 255},
914};
915constexpr auto TernlogFunctions = BUILD_ENUM_STRINGS(TernlogFunctionDefs);
916
917static bool printPTERNLOGComments(const MCInst *MI, raw_ostream &OS,
918 const MCInstrInfo &MCII) {
919 unsigned NumOperands = MI->getNumOperands();
920
921 int Src2Idx;
922 int Src3Idx;
923 switch (MI->getOpcode()) {
924 // dest, src1, src2, src3, tbl
925 // dest, src1, mask, src2, src3, tbl
926 CASE_PTERNLOG(PTERNLOGD, r)
927 CASE_PTERNLOG(PTERNLOGQ, r)
928 Src2Idx = NumOperands - 3;
929 Src3Idx = NumOperands - 2;
930 break;
931
932 // dest, src1, src2, memory, tbl
933 // dest, src1, mask, src2, memory, tbl
934 CASE_PTERNLOG(PTERNLOGD, m)
935 CASE_PTERNLOG(PTERNLOGQ, m)
936 Src2Idx = NumOperands - 7;
937 Src3Idx = -1;
938 break;
939
940 CASE_PTERNLOG(PTERNLOGD, mb)
941 Src2Idx = NumOperands - 7;
942 Src3Idx = -2;
943 break;
944
945 CASE_PTERNLOG(PTERNLOGQ, mb)
946 Src2Idx = NumOperands - 7;
947 Src3Idx = -3;
948 break;
949
950 default:
951 return false;
952 }
953 StringRef DestName = getRegName(MI->getOperand(0).getReg());
954 StringRef Src1Name = getRegName(MI->getOperand(1).getReg());
955 StringRef Src2Name = getRegName(MI->getOperand(Src2Idx).getReg());
956 StringRef Src3Name;
957 switch (Src3Idx) {
958 case -1:
959 Src3Name = "mem";
960 break;
961 case -2:
962 Src3Name = "m32bcst";
963 break;
964 case -3:
965 Src3Name = "m64bcst";
966 break;
967 default:
968 Src3Name = getRegName(MI->getOperand(Src3Idx).getReg());
969 break;
970 }
971 uint8_t TruthTable = MI->getOperand(NumOperands - 1).getImm();
972
973 StringRef SrcNames[] = {Src1Name, Src2Name, Src3Name};
974
975 OS << DestName;
976 printMasking(OS, MI, MCII);
977 OS << " = ";
978
979 static_assert(std::size(TernlogFunctions) == 256);
980 std::string_view BooleanFunction = TernlogFunctions[TruthTable].name();
981
982 while (!BooleanFunction.empty()) {
983 // Print the expression up to the next symbol.
984 size_t SymbolOffset = BooleanFunction.find_first_of("abc");
985 OS << BooleanFunction.substr(0, SymbolOffset);
986 if (SymbolOffset == std::string_view::npos) {
987 // No more symbols, that means we just printed everything.
988 break;
989 }
990 // Let's replace {a,b,c} with Src{1,2,3}Name.
991 char Symbol = BooleanFunction[SymbolOffset];
992 OS << SrcNames[Symbol - 'a'];
993 // Consume the part of the expression we handled.
994 BooleanFunction.remove_prefix(SymbolOffset + 1);
995 }
996 OS << '\n';
997 return true;
998}
999
1000static bool printFPCLASSComments(const MCInst *MI, raw_ostream &OS,
1001 const MCInstrInfo &MCII) {
1002 unsigned NumOperands = MI->getNumOperands();
1003 int SrcIdx;
1004 switch (MI->getOpcode()) {
1005 CASE_FPCLASS_PACKED(FPCLASSBF16, r)
1006 CASE_FPCLASS_PACKED(FPCLASSPH, r)
1007 CASE_FPCLASS_PACKED(FPCLASSPS, r)
1008 CASE_FPCLASS_PACKED(FPCLASSPD, r)
1009 CASE_FPCLASS_SCALAR(FPCLASSSH, r)
1010 CASE_FPCLASS_SCALAR(FPCLASSSS, r)
1011 CASE_FPCLASS_SCALAR(FPCLASSSD, r) {
1012 SrcIdx = NumOperands - 2;
1013 break;
1014 }
1015 CASE_FPCLASS_PACKED_MEM(FPCLASSBF16)
1016 CASE_FPCLASS_PACKED_MEM(FPCLASSPH)
1017 CASE_FPCLASS_PACKED_MEM(FPCLASSPS)
1018 CASE_FPCLASS_PACKED_MEM(FPCLASSPD)
1019 CASE_FPCLASS_SCALAR(FPCLASSSH, m)
1020 CASE_FPCLASS_SCALAR(FPCLASSSS, m)
1021 CASE_FPCLASS_SCALAR(FPCLASSSD, m) {
1022 SrcIdx = -1;
1023 break;
1024 }
1025 default:
1026 return false;
1027 }
1028 // The category mask can be a symbol rather than a literal, in which case its
1029 // value is only known at link time and there is no category to describe.
1030 if (!MI->getOperand(NumOperands - 1).isImm())
1031 return false;
1032
1033 StringRef DestName = getRegName(MI->getOperand(0).getReg());
1034 StringRef SrcName =
1035 SrcIdx != -1 ? getRegName(MI->getOperand(SrcIdx).getReg()) : "mem";
1036
1037 OS << DestName;
1038 printMasking(OS, MI, MCII);
1039 OS << " = ";
1040
1041 uint8_t Categories = MI->getOperand(NumOperands - 1).getImm();
1042 if (Categories == 0) {
1043 OS << "false";
1044 } else {
1045 static constexpr StringLiteral CategoryNames[] = {
1046 "QuietNaN",
1047 "PositiveZero",
1048 "NegativeZero",
1049 "PositiveInfinity",
1050 "NegativeInfinity",
1051 "Subnormal",
1052 "Negative",
1053 "SignalingNaN",
1054 };
1055 bool Conjoin = false;
1056 for (size_t I = 0, E = std::size(CategoryNames); I != E; ++I) {
1057 if (Categories & (1 << I)) {
1058 if (Conjoin)
1059 OS << " | ";
1060 Conjoin = true;
1061 OS << "is" << CategoryNames[I] << '(' << SrcName << ')';
1062 }
1063 }
1064 }
1065 OS << '\n';
1066 return true;
1067}
1068
1069//===----------------------------------------------------------------------===//
1070// Top Level Entrypoint
1071//===----------------------------------------------------------------------===//
1072
1073/// EmitAnyX86InstComments - This function decodes x86 instructions and prints
1074/// newline terminated strings to the specified string if desired. This
1075/// information is shown in disassembly dumps when verbose assembly is enabled.
1076bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
1077 const MCInstrInfo &MCII) {
1078 // If this is a shuffle operation, the switch should fill in this state.
1079 SmallVector<int, 8> ShuffleMask;
1080 const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
1081 unsigned NumOperands = MI->getNumOperands();
1082 bool RegForm = false;
1083
1084 if (printFMAComments(MI, OS, MCII))
1085 return true;
1086
1087 if (printPTERNLOGComments(MI, OS, MCII))
1088 return true;
1089
1090 if (printFPCLASSComments(MI, OS, MCII))
1091 return true;
1092
1093 switch (MI->getOpcode()) {
1094 default:
1095 // Not an instruction for which we can decode comments.
1096 return false;
1097
1098 case X86::BLENDPDrri:
1099 case X86::VBLENDPDrri:
1100 case X86::VBLENDPDYrri:
1101 Src2Name = getRegName(MI->getOperand(2).getReg());
1102 [[fallthrough]];
1103 case X86::BLENDPDrmi:
1104 case X86::VBLENDPDrmi:
1105 case X86::VBLENDPDYrmi:
1106 if (MI->getOperand(NumOperands - 1).isImm())
1107 DecodeBLENDMask(getRegOperandNumElts(MI, 64, 0),
1108 MI->getOperand(NumOperands - 1).getImm(),
1109 ShuffleMask);
1110 Src1Name = getRegName(MI->getOperand(1).getReg());
1111 DestName = getRegName(MI->getOperand(0).getReg());
1112 break;
1113
1114 case X86::BLENDPSrri:
1115 case X86::VBLENDPSrri:
1116 case X86::VBLENDPSYrri:
1117 Src2Name = getRegName(MI->getOperand(2).getReg());
1118 [[fallthrough]];
1119 case X86::BLENDPSrmi:
1120 case X86::VBLENDPSrmi:
1121 case X86::VBLENDPSYrmi:
1122 if (MI->getOperand(NumOperands - 1).isImm())
1123 DecodeBLENDMask(getRegOperandNumElts(MI, 32, 0),
1124 MI->getOperand(NumOperands - 1).getImm(),
1125 ShuffleMask);
1126 Src1Name = getRegName(MI->getOperand(1).getReg());
1127 DestName = getRegName(MI->getOperand(0).getReg());
1128 break;
1129
1130 case X86::PBLENDWrri:
1131 case X86::VPBLENDWrri:
1132 case X86::VPBLENDWYrri:
1133 Src2Name = getRegName(MI->getOperand(2).getReg());
1134 [[fallthrough]];
1135 case X86::PBLENDWrmi:
1136 case X86::VPBLENDWrmi:
1137 case X86::VPBLENDWYrmi:
1138 if (MI->getOperand(NumOperands - 1).isImm())
1139 DecodeBLENDMask(getRegOperandNumElts(MI, 16, 0),
1140 MI->getOperand(NumOperands - 1).getImm(),
1141 ShuffleMask);
1142 Src1Name = getRegName(MI->getOperand(1).getReg());
1143 DestName = getRegName(MI->getOperand(0).getReg());
1144 break;
1145
1146 case X86::VPBLENDDrri:
1147 case X86::VPBLENDDYrri:
1148 Src2Name = getRegName(MI->getOperand(2).getReg());
1149 [[fallthrough]];
1150 case X86::VPBLENDDrmi:
1151 case X86::VPBLENDDYrmi:
1152 if (MI->getOperand(NumOperands - 1).isImm())
1153 DecodeBLENDMask(getRegOperandNumElts(MI, 32, 0),
1154 MI->getOperand(NumOperands - 1).getImm(),
1155 ShuffleMask);
1156 Src1Name = getRegName(MI->getOperand(1).getReg());
1157 DestName = getRegName(MI->getOperand(0).getReg());
1158 break;
1159
1160 case X86::INSERTPSrri:
1161 case X86::VINSERTPSrri:
1162 case X86::VINSERTPSZrri:
1163 Src2Name = getRegName(MI->getOperand(2).getReg());
1164 DestName = getRegName(MI->getOperand(0).getReg());
1165 Src1Name = getRegName(MI->getOperand(1).getReg());
1166 if (MI->getOperand(NumOperands - 1).isImm())
1167 DecodeINSERTPSMask(MI->getOperand(NumOperands - 1).getImm(), ShuffleMask,
1168 /*SrcIsMem=*/false);
1169 break;
1170
1171 case X86::INSERTPSrmi:
1172 case X86::VINSERTPSrmi:
1173 case X86::VINSERTPSZrmi:
1174 DestName = getRegName(MI->getOperand(0).getReg());
1175 Src1Name = getRegName(MI->getOperand(1).getReg());
1176 if (MI->getOperand(NumOperands - 1).isImm())
1177 DecodeINSERTPSMask(MI->getOperand(NumOperands - 1).getImm(), ShuffleMask,
1178 /*SrcIsMem=*/true);
1179 break;
1180
1181 case X86::MOVLHPSrr:
1182 case X86::VMOVLHPSrr:
1183 case X86::VMOVLHPSZrr:
1184 Src2Name = getRegName(MI->getOperand(2).getReg());
1185 Src1Name = getRegName(MI->getOperand(1).getReg());
1186 DestName = getRegName(MI->getOperand(0).getReg());
1187 DecodeMOVLHPSMask(2, ShuffleMask);
1188 break;
1189
1190 case X86::MOVHLPSrr:
1191 case X86::VMOVHLPSrr:
1192 case X86::VMOVHLPSZrr:
1193 Src2Name = getRegName(MI->getOperand(2).getReg());
1194 Src1Name = getRegName(MI->getOperand(1).getReg());
1195 DestName = getRegName(MI->getOperand(0).getReg());
1196 DecodeMOVHLPSMask(2, ShuffleMask);
1197 break;
1198
1199 case X86::MOVHPDrm:
1200 case X86::VMOVHPDrm:
1201 case X86::VMOVHPDZ128rm:
1202 Src1Name = getRegName(MI->getOperand(1).getReg());
1203 DestName = getRegName(MI->getOperand(0).getReg());
1204 DecodeInsertElementMask(2, 1, 1, ShuffleMask);
1205 break;
1206
1207 case X86::MOVHPSrm:
1208 case X86::VMOVHPSrm:
1209 case X86::VMOVHPSZ128rm:
1210 Src1Name = getRegName(MI->getOperand(1).getReg());
1211 DestName = getRegName(MI->getOperand(0).getReg());
1212 DecodeInsertElementMask(4, 2, 2, ShuffleMask);
1213 break;
1214
1215 case X86::MOVLPDrm:
1216 case X86::VMOVLPDrm:
1217 case X86::VMOVLPDZ128rm:
1218 Src1Name = getRegName(MI->getOperand(1).getReg());
1219 DestName = getRegName(MI->getOperand(0).getReg());
1220 DecodeInsertElementMask(2, 0, 1, ShuffleMask);
1221 break;
1222
1223 case X86::MOVLPSrm:
1224 case X86::VMOVLPSrm:
1225 case X86::VMOVLPSZ128rm:
1226 Src1Name = getRegName(MI->getOperand(1).getReg());
1227 DestName = getRegName(MI->getOperand(0).getReg());
1228 DecodeInsertElementMask(4, 0, 2, ShuffleMask);
1229 break;
1230
1231 CASE_MOVDUP(MOVSLDUP, r)
1232 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1233 [[fallthrough]];
1234
1235 CASE_MOVDUP(MOVSLDUP, m)
1236 DestName = getRegName(MI->getOperand(0).getReg());
1237 DecodeMOVSLDUPMask(getRegOperandNumElts(MI, 32, 0), ShuffleMask);
1238 break;
1239
1240 CASE_MOVDUP(MOVSHDUP, r)
1241 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1242 [[fallthrough]];
1243
1244 CASE_MOVDUP(MOVSHDUP, m)
1245 DestName = getRegName(MI->getOperand(0).getReg());
1246 DecodeMOVSHDUPMask(getRegOperandNumElts(MI, 32, 0), ShuffleMask);
1247 break;
1248
1249 CASE_MOVDUP(MOVDDUP, r)
1250 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1251 [[fallthrough]];
1252
1253 CASE_MOVDUP(MOVDDUP, m)
1254 DestName = getRegName(MI->getOperand(0).getReg());
1255 DecodeMOVDDUPMask(getRegOperandNumElts(MI, 64, 0), ShuffleMask);
1256 break;
1257
1258 case X86::PSLLDQri:
1259 case X86::VPSLLDQri:
1260 case X86::VPSLLDQYri:
1261 case X86::VPSLLDQZ128ri:
1262 case X86::VPSLLDQZ256ri:
1263 case X86::VPSLLDQZri:
1264 Src1Name = getRegName(MI->getOperand(1).getReg());
1265 [[fallthrough]];
1266 case X86::VPSLLDQZ128mi:
1267 case X86::VPSLLDQZ256mi:
1268 case X86::VPSLLDQZmi:
1269 DestName = getRegName(MI->getOperand(0).getReg());
1270 if (MI->getOperand(NumOperands - 1).isImm())
1271 DecodePSLLDQMask(getRegOperandNumElts(MI, 8, 0),
1272 MI->getOperand(NumOperands - 1).getImm(),
1273 ShuffleMask);
1274 break;
1275
1276 case X86::PSRLDQri:
1277 case X86::VPSRLDQri:
1278 case X86::VPSRLDQYri:
1279 case X86::VPSRLDQZ128ri:
1280 case X86::VPSRLDQZ256ri:
1281 case X86::VPSRLDQZri:
1282 Src1Name = getRegName(MI->getOperand(1).getReg());
1283 [[fallthrough]];
1284 case X86::VPSRLDQZ128mi:
1285 case X86::VPSRLDQZ256mi:
1286 case X86::VPSRLDQZmi:
1287 DestName = getRegName(MI->getOperand(0).getReg());
1288 if (MI->getOperand(NumOperands - 1).isImm())
1289 DecodePSRLDQMask(getRegOperandNumElts(MI, 8, 0),
1290 MI->getOperand(NumOperands - 1).getImm(),
1291 ShuffleMask);
1292 break;
1293
1294 CASE_SHUF(PALIGNR, rri)
1295 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1296 RegForm = true;
1297 [[fallthrough]];
1298
1299 CASE_SHUF(PALIGNR, rmi)
1300 Src2Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1301 DestName = getRegName(MI->getOperand(0).getReg());
1302 if (MI->getOperand(NumOperands - 1).isImm())
1303 DecodePALIGNRMask(getRegOperandNumElts(MI, 8, 0),
1304 MI->getOperand(NumOperands - 1).getImm(),
1305 ShuffleMask);
1306 break;
1307
1308 CASE_AVX512_INS_COMMON(ALIGNQ, Z, rri)
1309 CASE_AVX512_INS_COMMON(ALIGNQ, Z256, rri)
1310 CASE_AVX512_INS_COMMON(ALIGNQ, Z128, rri)
1311 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1312 RegForm = true;
1313 [[fallthrough]];
1314
1315 CASE_AVX512_INS_COMMON(ALIGNQ, Z, rmi)
1316 CASE_AVX512_INS_COMMON(ALIGNQ, Z256, rmi)
1317 CASE_AVX512_INS_COMMON(ALIGNQ, Z128, rmi)
1318 Src2Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1319 DestName = getRegName(MI->getOperand(0).getReg());
1320 if (MI->getOperand(NumOperands - 1).isImm())
1321 DecodeVALIGNMask(getRegOperandNumElts(MI, 64, 0),
1322 MI->getOperand(NumOperands - 1).getImm(),
1323 ShuffleMask);
1324 break;
1325
1326 CASE_AVX512_INS_COMMON(ALIGND, Z, rri)
1327 CASE_AVX512_INS_COMMON(ALIGND, Z256, rri)
1328 CASE_AVX512_INS_COMMON(ALIGND, Z128, rri)
1329 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1330 RegForm = true;
1331 [[fallthrough]];
1332
1333 CASE_AVX512_INS_COMMON(ALIGND, Z, rmi)
1334 CASE_AVX512_INS_COMMON(ALIGND, Z256, rmi)
1335 CASE_AVX512_INS_COMMON(ALIGND, Z128, rmi)
1336 Src2Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1337 DestName = getRegName(MI->getOperand(0).getReg());
1338 if (MI->getOperand(NumOperands - 1).isImm())
1339 DecodeVALIGNMask(getRegOperandNumElts(MI, 32, 0),
1340 MI->getOperand(NumOperands - 1).getImm(),
1341 ShuffleMask);
1342 break;
1343
1344 CASE_SHUF(PSHUFD, ri)
1345 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1346 [[fallthrough]];
1347
1348 CASE_SHUF(PSHUFD, mi)
1349 DestName = getRegName(MI->getOperand(0).getReg());
1350 if (MI->getOperand(NumOperands - 1).isImm())
1351 DecodePSHUFMask(getRegOperandNumElts(MI, 32, 0), 32,
1352 MI->getOperand(NumOperands - 1).getImm(),
1353 ShuffleMask);
1354 break;
1355
1356 CASE_SHUF(PSHUFHW, ri)
1357 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1358 [[fallthrough]];
1359
1360 CASE_SHUF(PSHUFHW, mi)
1361 DestName = getRegName(MI->getOperand(0).getReg());
1362 if (MI->getOperand(NumOperands - 1).isImm())
1363 DecodePSHUFHWMask(getRegOperandNumElts(MI, 16, 0),
1364 MI->getOperand(NumOperands - 1).getImm(),
1365 ShuffleMask);
1366 break;
1367
1368 CASE_SHUF(PSHUFLW, ri)
1369 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1370 [[fallthrough]];
1371
1372 CASE_SHUF(PSHUFLW, mi)
1373 DestName = getRegName(MI->getOperand(0).getReg());
1374 if (MI->getOperand(NumOperands - 1).isImm())
1375 DecodePSHUFLWMask(getRegOperandNumElts(MI, 16, 0),
1376 MI->getOperand(NumOperands - 1).getImm(),
1377 ShuffleMask);
1378 break;
1379
1380 case X86::MMX_PSHUFWri:
1381 Src1Name = getRegName(MI->getOperand(1).getReg());
1382 [[fallthrough]];
1383
1384 case X86::MMX_PSHUFWmi:
1385 DestName = getRegName(MI->getOperand(0).getReg());
1386 if (MI->getOperand(NumOperands - 1).isImm())
1387 DecodePSHUFMask(4, 16, MI->getOperand(NumOperands - 1).getImm(),
1388 ShuffleMask);
1389 break;
1390
1391 case X86::PSWAPDrr:
1392 Src1Name = getRegName(MI->getOperand(1).getReg());
1393 [[fallthrough]];
1394
1395 case X86::PSWAPDrm:
1396 DestName = getRegName(MI->getOperand(0).getReg());
1397 DecodePSWAPMask(2, ShuffleMask);
1398 break;
1399
1400 CASE_UNPCK(PUNPCKHBW, r)
1401 case X86::MMX_PUNPCKHBWrr:
1402 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1403 RegForm = true;
1404 [[fallthrough]];
1405
1406 CASE_UNPCK(PUNPCKHBW, m)
1407 case X86::MMX_PUNPCKHBWrm:
1408 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1409 DestName = getRegName(MI->getOperand(0).getReg());
1410 DecodeUNPCKHMask(getRegOperandNumElts(MI, 8, 0), 8, ShuffleMask);
1411 break;
1412
1413 CASE_UNPCK(PUNPCKHWD, r)
1414 case X86::MMX_PUNPCKHWDrr:
1415 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1416 RegForm = true;
1417 [[fallthrough]];
1418
1419 CASE_UNPCK(PUNPCKHWD, m)
1420 case X86::MMX_PUNPCKHWDrm:
1421 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1422 DestName = getRegName(MI->getOperand(0).getReg());
1423 DecodeUNPCKHMask(getRegOperandNumElts(MI, 16, 0), 16, ShuffleMask);
1424 break;
1425
1426 CASE_UNPCK(PUNPCKHDQ, r)
1427 case X86::MMX_PUNPCKHDQrr:
1428 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1429 RegForm = true;
1430 [[fallthrough]];
1431
1432 CASE_UNPCK(PUNPCKHDQ, m)
1433 case X86::MMX_PUNPCKHDQrm:
1434 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1435 DestName = getRegName(MI->getOperand(0).getReg());
1436 DecodeUNPCKHMask(getRegOperandNumElts(MI, 32, 0), 32, ShuffleMask);
1437 break;
1438
1439 CASE_UNPCK(PUNPCKHQDQ, r)
1440 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1441 RegForm = true;
1442 [[fallthrough]];
1443
1444 CASE_UNPCK(PUNPCKHQDQ, m)
1445 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1446 DestName = getRegName(MI->getOperand(0).getReg());
1447 DecodeUNPCKHMask(getRegOperandNumElts(MI, 64, 0), 64, ShuffleMask);
1448 break;
1449
1450 CASE_UNPCK(PUNPCKLBW, r)
1451 case X86::MMX_PUNPCKLBWrr:
1452 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1453 RegForm = true;
1454 [[fallthrough]];
1455
1456 CASE_UNPCK(PUNPCKLBW, m)
1457 case X86::MMX_PUNPCKLBWrm:
1458 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1459 DestName = getRegName(MI->getOperand(0).getReg());
1460 DecodeUNPCKLMask(getRegOperandNumElts(MI, 8, 0), 8, ShuffleMask);
1461 break;
1462
1463 CASE_UNPCK(PUNPCKLWD, r)
1464 case X86::MMX_PUNPCKLWDrr:
1465 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1466 RegForm = true;
1467 [[fallthrough]];
1468
1469 CASE_UNPCK(PUNPCKLWD, m)
1470 case X86::MMX_PUNPCKLWDrm:
1471 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1472 DestName = getRegName(MI->getOperand(0).getReg());
1473 DecodeUNPCKLMask(getRegOperandNumElts(MI, 16, 0), 16, ShuffleMask);
1474 break;
1475
1476 CASE_UNPCK(PUNPCKLDQ, r)
1477 case X86::MMX_PUNPCKLDQrr:
1478 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1479 RegForm = true;
1480 [[fallthrough]];
1481
1482 CASE_UNPCK(PUNPCKLDQ, m)
1483 case X86::MMX_PUNPCKLDQrm:
1484 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1485 DestName = getRegName(MI->getOperand(0).getReg());
1486 DecodeUNPCKLMask(getRegOperandNumElts(MI, 32, 0), 32, ShuffleMask);
1487 break;
1488
1489 CASE_UNPCK(PUNPCKLQDQ, r)
1490 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1491 RegForm = true;
1492 [[fallthrough]];
1493
1494 CASE_UNPCK(PUNPCKLQDQ, m)
1495 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1496 DestName = getRegName(MI->getOperand(0).getReg());
1497 DecodeUNPCKLMask(getRegOperandNumElts(MI, 64, 0), 64, ShuffleMask);
1498 break;
1499
1500 CASE_SHUF(SHUFPD, rri)
1501 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1502 RegForm = true;
1503 [[fallthrough]];
1504
1505 CASE_SHUF(SHUFPD, rmi)
1506 if (MI->getOperand(NumOperands - 1).isImm())
1507 DecodeSHUFPMask(getRegOperandNumElts(MI, 64, 0), 64,
1508 MI->getOperand(NumOperands - 1).getImm(), ShuffleMask);
1509 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1510 DestName = getRegName(MI->getOperand(0).getReg());
1511 break;
1512
1513 CASE_SHUF(SHUFPS, rri)
1514 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1515 RegForm = true;
1516 [[fallthrough]];
1517
1518 CASE_SHUF(SHUFPS, rmi)
1519 if (MI->getOperand(NumOperands - 1).isImm())
1520 DecodeSHUFPMask(getRegOperandNumElts(MI, 32, 0), 32,
1521 MI->getOperand(NumOperands - 1).getImm(),
1522 ShuffleMask);
1523 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1524 DestName = getRegName(MI->getOperand(0).getReg());
1525 break;
1526
1527 CASE_VSHUF(64X2, r)
1528 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1529 RegForm = true;
1530 [[fallthrough]];
1531
1532 CASE_VSHUF(64X2, m)
1533 decodeVSHUF64x2FamilyMask(getRegOperandNumElts(MI, 64, 0), 64,
1534 MI->getOperand(NumOperands - 1).getImm(),
1535 ShuffleMask);
1536 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1537 DestName = getRegName(MI->getOperand(0).getReg());
1538 break;
1539
1540 CASE_VSHUF(32X4, r)
1541 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1542 RegForm = true;
1543 [[fallthrough]];
1544
1545 CASE_VSHUF(32X4, m)
1546 decodeVSHUF64x2FamilyMask(getRegOperandNumElts(MI, 32, 0), 32,
1547 MI->getOperand(NumOperands - 1).getImm(),
1548 ShuffleMask);
1549 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
1550 DestName = getRegName(MI->getOperand(0).getReg());
1551 break;
1552
1553 CASE_UNPCK(UNPCKLPD, r)
1554 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1555 RegForm = true;
1556 [[fallthrough]];
1557
1558 CASE_UNPCK(UNPCKLPD, m)
1559 DecodeUNPCKLMask(getRegOperandNumElts(MI, 64, 0), 64, ShuffleMask);
1560 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1561 DestName = getRegName(MI->getOperand(0).getReg());
1562 break;
1563
1564 CASE_UNPCK(UNPCKLPS, r)
1565 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1566 RegForm = true;
1567 [[fallthrough]];
1568
1569 CASE_UNPCK(UNPCKLPS, m)
1570 DecodeUNPCKLMask(getRegOperandNumElts(MI, 32, 0), 32, ShuffleMask);
1571 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1572 DestName = getRegName(MI->getOperand(0).getReg());
1573 break;
1574
1575 CASE_UNPCK(UNPCKHPD, r)
1576 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1577 RegForm = true;
1578 [[fallthrough]];
1579
1580 CASE_UNPCK(UNPCKHPD, m)
1581 DecodeUNPCKHMask(getRegOperandNumElts(MI, 64, 0), 64, ShuffleMask);
1582 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1583 DestName = getRegName(MI->getOperand(0).getReg());
1584 break;
1585
1586 CASE_UNPCK(UNPCKHPS, r)
1587 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1588 RegForm = true;
1589 [[fallthrough]];
1590
1591 CASE_UNPCK(UNPCKHPS, m)
1592 DecodeUNPCKHMask(getRegOperandNumElts(MI, 32, 0), 32, ShuffleMask);
1593 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
1594 DestName = getRegName(MI->getOperand(0).getReg());
1595 break;
1596
1597 CASE_VPERMILPI(PERMILPS, r)
1598 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1599 [[fallthrough]];
1600
1601 CASE_VPERMILPI(PERMILPS, m)
1602 if (MI->getOperand(NumOperands - 1).isImm())
1603 DecodePSHUFMask(getRegOperandNumElts(MI, 32, 0), 32,
1604 MI->getOperand(NumOperands - 1).getImm(),
1605 ShuffleMask);
1606 DestName = getRegName(MI->getOperand(0).getReg());
1607 break;
1608
1609 CASE_VPERMILPI(PERMILPD, r)
1610 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1611 [[fallthrough]];
1612
1613 CASE_VPERMILPI(PERMILPD, m)
1614 if (MI->getOperand(NumOperands - 1).isImm())
1615 DecodePSHUFMask(getRegOperandNumElts(MI, 64, 0), 64,
1616 MI->getOperand(NumOperands - 1).getImm(),
1617 ShuffleMask);
1618 DestName = getRegName(MI->getOperand(0).getReg());
1619 break;
1620
1621 case X86::VPERM2F128rri:
1622 case X86::VPERM2I128rri:
1623 Src2Name = getRegName(MI->getOperand(2).getReg());
1624 [[fallthrough]];
1625
1626 case X86::VPERM2F128rmi:
1627 case X86::VPERM2I128rmi:
1628 // For instruction comments purpose, assume the 256-bit vector is v4i64.
1629 if (MI->getOperand(NumOperands - 1).isImm())
1630 DecodeVPERM2X128Mask(4, MI->getOperand(NumOperands - 1).getImm(),
1631 ShuffleMask);
1632 Src1Name = getRegName(MI->getOperand(1).getReg());
1633 DestName = getRegName(MI->getOperand(0).getReg());
1634 break;
1635
1636 CASE_VPERM(PERMPD, r)
1637 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1638 [[fallthrough]];
1639
1640 CASE_VPERM(PERMPD, m)
1641 if (MI->getOperand(NumOperands - 1).isImm())
1642 DecodeVPERMMask(getRegOperandNumElts(MI, 64, 0),
1643 MI->getOperand(NumOperands - 1).getImm(),
1644 ShuffleMask);
1645 DestName = getRegName(MI->getOperand(0).getReg());
1646 break;
1647
1648 CASE_VPERM(PERMQ, r)
1649 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
1650 [[fallthrough]];
1651
1652 CASE_VPERM(PERMQ, m)
1653 if (MI->getOperand(NumOperands - 1).isImm())
1654 DecodeVPERMMask(getRegOperandNumElts(MI, 64, 0),
1655 MI->getOperand(NumOperands - 1).getImm(),
1656 ShuffleMask);
1657 DestName = getRegName(MI->getOperand(0).getReg());
1658 break;
1659
1660 case X86::MOVSDrr:
1661 case X86::VMOVSDrr:
1662 case X86::VMOVSDZrr:
1663 Src2Name = getRegName(MI->getOperand(2).getReg());
1664 Src1Name = getRegName(MI->getOperand(1).getReg());
1665 DecodeScalarMoveMask(2, false, ShuffleMask);
1666 DestName = getRegName(MI->getOperand(0).getReg());
1667 break;
1668
1669 case X86::MOVSSrr:
1670 case X86::VMOVSSrr:
1671 case X86::VMOVSSZrr:
1672 Src2Name = getRegName(MI->getOperand(2).getReg());
1673 Src1Name = getRegName(MI->getOperand(1).getReg());
1674 DecodeScalarMoveMask(4, false, ShuffleMask);
1675 DestName = getRegName(MI->getOperand(0).getReg());
1676 break;
1677
1678 case X86::VMOVSHZrr:
1679 Src2Name = getRegName(MI->getOperand(2).getReg());
1680 Src1Name = getRegName(MI->getOperand(1).getReg());
1681 DecodeScalarMoveMask(8, false, ShuffleMask);
1682 DestName = getRegName(MI->getOperand(0).getReg());
1683 break;
1684
1685 case X86::MOVPQI2QIrr:
1686 case X86::MOVZPQILo2PQIrr:
1687 case X86::VMOVPQI2QIrr:
1688 case X86::VMOVPQI2QIZrr:
1689 case X86::VMOVZPQILo2PQIrr:
1690 case X86::VMOVZPQILo2PQIZrr:
1691 Src1Name = getRegName(MI->getOperand(1).getReg());
1692 DecodeZeroMoveLowMask(2, ShuffleMask);
1693 DestName = getRegName(MI->getOperand(0).getReg());
1694 break;
1695
1696 case X86::EXTRQI:
1697 if (MI->getOperand(2).isImm() &&
1698 MI->getOperand(3).isImm())
1699 DecodeEXTRQIMask(16, 8, MI->getOperand(2).getImm(),
1700 MI->getOperand(3).getImm(), ShuffleMask);
1701
1702 DestName = getRegName(MI->getOperand(0).getReg());
1703 Src1Name = getRegName(MI->getOperand(1).getReg());
1704 break;
1705
1706 case X86::INSERTQI:
1707 if (MI->getOperand(3).isImm() &&
1708 MI->getOperand(4).isImm())
1709 DecodeINSERTQIMask(16, 8, MI->getOperand(3).getImm(),
1710 MI->getOperand(4).getImm(), ShuffleMask);
1711
1712 DestName = getRegName(MI->getOperand(0).getReg());
1713 Src1Name = getRegName(MI->getOperand(1).getReg());
1714 Src2Name = getRegName(MI->getOperand(2).getReg());
1715 break;
1716
1717 case X86::VBROADCASTF128rm:
1718 case X86::VBROADCASTI128rm:
1719 CASE_AVX512_INS_COMMON(BROADCASTF64X2, Z256, rm)
1720 CASE_AVX512_INS_COMMON(BROADCASTI64X2, Z256, rm)
1721 DecodeSubVectorBroadcast(4, 2, ShuffleMask);
1722 DestName = getRegName(MI->getOperand(0).getReg());
1723 break;
1724 CASE_AVX512_INS_COMMON(BROADCASTF64X2, Z, rm)
1725 CASE_AVX512_INS_COMMON(BROADCASTI64X2, Z, rm)
1726 DecodeSubVectorBroadcast(8, 2, ShuffleMask);
1727 DestName = getRegName(MI->getOperand(0).getReg());
1728 break;
1729 CASE_AVX512_INS_COMMON(BROADCASTF64X4, Z, rm)
1730 CASE_AVX512_INS_COMMON(BROADCASTI64X4, Z, rm)
1731 DecodeSubVectorBroadcast(8, 4, ShuffleMask);
1732 DestName = getRegName(MI->getOperand(0).getReg());
1733 break;
1734 CASE_AVX512_INS_COMMON(BROADCASTF32X4, Z256, rm)
1735 CASE_AVX512_INS_COMMON(BROADCASTI32X4, Z256, rm)
1736 DecodeSubVectorBroadcast(8, 4, ShuffleMask);
1737 DestName = getRegName(MI->getOperand(0).getReg());
1738 break;
1739 CASE_AVX512_INS_COMMON(BROADCASTF32X4, Z, rm)
1740 CASE_AVX512_INS_COMMON(BROADCASTI32X4, Z, rm)
1741 DecodeSubVectorBroadcast(16, 4, ShuffleMask);
1742 DestName = getRegName(MI->getOperand(0).getReg());
1743 break;
1744 CASE_AVX512_INS_COMMON(BROADCASTF32X8, Z, rm)
1745 CASE_AVX512_INS_COMMON(BROADCASTI32X8, Z, rm)
1746 DecodeSubVectorBroadcast(16, 8, ShuffleMask);
1747 DestName = getRegName(MI->getOperand(0).getReg());
1748 break;
1749 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z128, rr)
1750 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1751 [[fallthrough]];
1752 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z128, rm)
1753 DecodeSubVectorBroadcast(4, 2, ShuffleMask);
1754 DestName = getRegName(MI->getOperand(0).getReg());
1755 break;
1756 CASE_AVX512_INS_COMMON(BROADCASTF32X2, Z256, rr)
1757 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z256, rr)
1758 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1759 [[fallthrough]];
1760 CASE_AVX512_INS_COMMON(BROADCASTF32X2, Z256, rm)
1761 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z256, rm)
1762 DecodeSubVectorBroadcast(8, 2, ShuffleMask);
1763 DestName = getRegName(MI->getOperand(0).getReg());
1764 break;
1765 CASE_AVX512_INS_COMMON(BROADCASTF32X2, Z, rr)
1766 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z, rr)
1767 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1768 [[fallthrough]];
1769 CASE_AVX512_INS_COMMON(BROADCASTF32X2, Z, rm)
1770 CASE_AVX512_INS_COMMON(BROADCASTI32X2, Z, rm)
1771 DecodeSubVectorBroadcast(16, 2, ShuffleMask);
1772 DestName = getRegName(MI->getOperand(0).getReg());
1773 break;
1774
1775 CASE_PMOVZX(PMOVZXBW, r)
1776 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1777 DecodeZeroExtendMask(8, 16, getRegOperandNumElts(MI, 16, 0), false,
1778 ShuffleMask);
1779 DestName = getRegName(MI->getOperand(0).getReg());
1780 break;
1781
1782 CASE_PMOVZX(PMOVZXBD, r)
1783 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1784 DecodeZeroExtendMask(8, 32, getRegOperandNumElts(MI, 32, 0), false,
1785 ShuffleMask);
1786 DestName = getRegName(MI->getOperand(0).getReg());
1787 break;
1788
1789 CASE_PMOVZX(PMOVZXBQ, r)
1790 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1791 DecodeZeroExtendMask(8, 64, getRegOperandNumElts(MI, 64, 0), false,
1792 ShuffleMask);
1793 DestName = getRegName(MI->getOperand(0).getReg());
1794 break;
1795
1796 CASE_PMOVZX(PMOVZXWD, r)
1797 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1798 DecodeZeroExtendMask(16, 32, getRegOperandNumElts(MI, 32, 0), false,
1799 ShuffleMask);
1800 DestName = getRegName(MI->getOperand(0).getReg());
1801 break;
1802
1803 CASE_PMOVZX(PMOVZXWQ, r)
1804 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1805 DecodeZeroExtendMask(16, 64, getRegOperandNumElts(MI, 64, 0), false,
1806 ShuffleMask);
1807 DestName = getRegName(MI->getOperand(0).getReg());
1808 break;
1809
1810 CASE_PMOVZX(PMOVZXDQ, r)
1811 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
1812 DecodeZeroExtendMask(32, 64, getRegOperandNumElts(MI, 64, 0), false,
1813 ShuffleMask);
1814 DestName = getRegName(MI->getOperand(0).getReg());
1815 break;
1816 }
1817
1818 // The only comments we decode are shuffles, so give up if we were unable to
1819 // decode a shuffle mask.
1820 if (ShuffleMask.empty())
1821 return false;
1822
1823 if (!DestName) DestName = Src1Name;
1824 if (DestName) {
1825 OS << DestName;
1826 printMasking(OS, MI, MCII);
1827 } else
1828 OS << "mem";
1829
1830 OS << " = ";
1831
1832 // If the two sources are the same, canonicalize the input elements to be
1833 // from the first src so that we get larger element spans.
1834 if (Src1Name == Src2Name) {
1835 for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
1836 if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
1837 ShuffleMask[i] >= (int)e) // From second mask.
1838 ShuffleMask[i] -= e;
1839 }
1840 }
1841
1842 // The shuffle mask specifies which elements of the src1/src2 fill in the
1843 // destination, with a few sentinel values. Loop through and print them
1844 // out.
1845 for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
1846 if (i != 0)
1847 OS << ',';
1848 if (ShuffleMask[i] == SM_SentinelZero) {
1849 OS << "zero";
1850 continue;
1851 }
1852
1853 // Otherwise, it must come from src1 or src2. Print the span of elements
1854 // that comes from this src.
1855 bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
1856 const char *SrcName = isSrc1 ? Src1Name : Src2Name;
1857 OS << (SrcName ? SrcName : "mem") << '[';
1858 bool IsFirst = true;
1859 while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
1860 (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
1861 if (!IsFirst)
1862 OS << ',';
1863 else
1864 IsFirst = false;
1865 if (ShuffleMask[i] == SM_SentinelUndef)
1866 OS << "u";
1867 else
1868 OS << ShuffleMask[i] % ShuffleMask.size();
1869 ++i;
1870 }
1871 OS << ']';
1872 --i; // For loop increments element #.
1873 }
1874 OS << '\n';
1875
1876 // We successfully added a comment to this instruction.
1877 return true;
1878}
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
BUILD_ENUM_STRINGS
#define BUILD_ENUM_STRINGS(Tab)
Definition Enum.h:120
MI
IRTranslator LLVM IR MI
Definition IRTranslator.cpp:110
I
#define I(x, y, z)
Definition MD5.cpp:57
Reg
Register Reg
Definition MachineSink.cpp:2131
CASE_VPERM
#define CASE_VPERM(Inst, src)
Definition X86InstComments.cpp:153
CASE_FPCLASS_PACKED_MEM
#define CASE_FPCLASS_PACKED_MEM(Inst)
Definition X86InstComments.cpp:61
CASE_FMA_SCALAR_REG
#define CASE_FMA_SCALAR_REG(Inst)
Definition X86InstComments.cpp:204
printPTERNLOGComments
static bool printPTERNLOGComments(const MCInst *MI, raw_ostream &OS, const MCInstrInfo &MCII)
Definition X86InstComments.cpp:917
CASE_FPCLASS_PACKED
#define CASE_FPCLASS_PACKED(Inst, src)
Definition X86InstComments.cpp:55
getVectorRegSize
static unsigned getVectorRegSize(MCRegister Reg)
Definition X86InstComments.cpp:258
CASE_VPERMILPI
#define CASE_VPERMILPI(Inst, src)
Definition X86InstComments.cpp:136
CASE_FMA4_SCALAR_MR
#define CASE_FMA4_SCALAR_MR(Inst)
Definition X86InstComments.cpp:252
printFMAComments
static bool printFMAComments(const MCInst *MI, raw_ostream &OS, const MCInstrInfo &MCII)
Definition X86InstComments.cpp:306
CASE_SHUF
#define CASE_SHUF(Inst, suf)
Definition X86InstComments.cpp:118
CASE_FMA4_PACKED_RM
#define CASE_FMA4_PACKED_RM(Inst)
Definition X86InstComments.cpp:232
CASE_MOVDUP
#define CASE_MOVDUP(Inst, src)
Definition X86InstComments.cpp:74
CASE_FMA_SCALAR_MEM
#define CASE_FMA_SCALAR_MEM(Inst)
Definition X86InstComments.cpp:214
CASE_FMA4_SCALAR_RR
#define CASE_FMA4_SCALAR_RR(Inst)
Definition X86InstComments.cpp:240
getRegOperandNumElts
static unsigned getRegOperandNumElts(const MCInst *MI, unsigned ScalarSize, unsigned OperandIndex)
Definition X86InstComments.cpp:271
CASE_FMA4_PACKED_MR
#define CASE_FMA4_PACKED_MR(Inst)
Definition X86InstComments.cpp:236
CASE_AVX512_INS_COMMON
#define CASE_AVX512_INS_COMMON(Inst, Suffix, src)
Definition X86InstComments.cpp:39
TernlogFunctionDefs
constexpr EnumStringDef< uint8_t > TernlogFunctionDefs[]
Definition X86InstComments.cpp:657
printFPCLASSComments
static bool printFPCLASSComments(const MCInst *MI, raw_ostream &OS, const MCInstrInfo &MCII)
Definition X86InstComments.cpp:1000
getRegName
static const char * getRegName(MCRegister Reg)
Definition X86InstComments.cpp:277
CASE_PMOVZX
#define CASE_PMOVZX(Inst, src)
Definition X86InstComments.cpp:92
CASE_VSHUF
#define CASE_VSHUF(Inst, src)
Definition X86InstComments.cpp:166
CASE_FMA_PACKED_MEM
#define CASE_FMA_PACKED_MEM(Inst)
Definition X86InstComments.cpp:198
printMasking
static void printMasking(raw_ostream &OS, const MCInst *MI, const MCInstrInfo &MCII)
Wraps the destination register name with AVX512 mask/maskz filtering.
Definition X86InstComments.cpp:282
CASE_FPCLASS_SCALAR
#define CASE_FPCLASS_SCALAR(Inst, src)
Definition X86InstComments.cpp:65
CASE_FMA4_SCALAR_RM
#define CASE_FMA4_SCALAR_RM(Inst)
Definition X86InstComments.cpp:246
TernlogFunctions
constexpr auto TernlogFunctions
Definition X86InstComments.cpp:915
CASE_FMA4_PACKED_RR
#define CASE_FMA4_PACKED_RR(Inst)
Definition X86InstComments.cpp:228
CASE_FMA_PACKED_REG
#define CASE_FMA_PACKED_REG(Inst)
Definition X86InstComments.cpp:194
CASE_PTERNLOG
#define CASE_PTERNLOG(Inst, src)
Definition X86InstComments.cpp:69
CASE_UNPCK
#define CASE_UNPCK(Inst, src)
Definition X86InstComments.cpp:100
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition MCInst.h:188
llvm::MCInstrDesc
Describe properties that are true of each instruction in the target description file.
Definition MCInstrDesc.h:199
llvm::MCInstrInfo
Interface to description of machine instruction set.
Definition MCInstrInfo.h:27
llvm::MCInstrInfo::get
const MCInstrDesc & get(unsigned Opcode) const
Return the machine instruction descriptor that corresponds to the specified instruction opcode.
Definition MCInstrInfo.h:89
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition MCRegister.h:41
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1236
llvm::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition StringRef.h:888
llvm::StringRef
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
llvm::X86ATTInstPrinter::getRegisterName
static const char * getRegisterName(MCRegister Reg)
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
uint64_t
uint8_t
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition ErrorHandling.h:164
llvm::X86II::isZMMReg
bool isZMMReg(MCRegister Reg)
Definition X86BaseInfo.h:1189
llvm::X86II::isXMMReg
bool isXMMReg(MCRegister Reg)
Definition X86BaseInfo.h:1169
llvm::X86II::isYMMReg
bool isYMMReg(MCRegister Reg)
Definition X86BaseInfo.h:1179
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition FunctionInfo.h:25
llvm::DecodeZeroExtendMask
void DecodeZeroExtendMask(unsigned SrcScalarBits, unsigned DstScalarBits, unsigned NumDstElts, bool IsAnyExtend, SmallVectorImpl< int > &ShuffleMask)
Decode a zero extension instruction as a shuffle mask.
Definition X86ShuffleDecode.cpp:371
llvm::EmitAnyX86InstComments
bool EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS, const MCInstrInfo &MCII)
EmitAnyX86InstComments - This function decodes x86 instructions and prints newline terminated strings...
Definition X86InstComments.cpp:1076
llvm::DecodeMOVHLPSMask
void DecodeMOVHLPSMask(unsigned NElts, SmallVectorImpl< int > &ShuffleMask)
Decode a MOVHLPS instruction as a v2f64/v4f32 shuffle mask.
Definition X86ShuffleDecode.cpp:61
llvm::DecodeZeroMoveLowMask
void DecodeZeroMoveLowMask(unsigned NumElts, SmallVectorImpl< int > &ShuffleMask)
Decode a move lower and zero upper instruction as a shuffle mask.
Definition X86ShuffleDecode.cpp:385
llvm::DecodeInsertElementMask
void DecodeInsertElementMask(unsigned NumElts, unsigned Idx, unsigned Len, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:50
llvm::DecodePSHUFLWMask
void DecodePSHUFLWMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for pshuflw.
Definition X86ShuffleDecode.cpp:178
llvm::DecodeBLENDMask
void DecodeBLENDMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decode a BLEND immediate mask into a shuffle mask.
Definition X86ShuffleDecode.cpp:315
llvm::decodeVSHUF64x2FamilyMask
void decodeVSHUF64x2FamilyMask(unsigned NumElts, unsigned ScalarSize, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decode a shuffle packed values at 128-bit granularity (SHUFF32x4/SHUFF64x2/SHUFI32x4/SHUFI64x2) immed...
Definition X86ShuffleDecode.cpp:264
llvm::DecodeVPERMMask
void DecodeVPERMMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for VPERMQ/VPERMPD.
Definition X86ShuffleDecode.cpp:364
llvm::DecodeEXTRQIMask
void DecodeEXTRQIMask(unsigned NumElts, unsigned EltSize, int Len, int Idx, SmallVectorImpl< int > &ShuffleMask)
Decode a SSE4A EXTRQ instruction as a shuffle mask.
Definition X86ShuffleDecode.cpp:400
llvm::DecodePSRLDQMask
void DecodePSRLDQMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:112
llvm::Desc
Op::Description Desc
Definition DWARFExpressionPrinter.cpp:26
llvm::DecodeINSERTPSMask
void DecodeINSERTPSMask(unsigned Imm, SmallVectorImpl< int > &ShuffleMask, bool SrcIsMem)
Decode a 128-bit INSERTPS instruction as a v4f32 shuffle mask.
Definition X86ShuffleDecode.cpp:26
llvm::DecodeVPERM2X128Mask
void DecodeVPERM2X128Mask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:281
llvm::DecodeMOVLHPSMask
void DecodeMOVLHPSMask(unsigned NElts, SmallVectorImpl< int > &ShuffleMask)
Decode a MOVLHPS instruction as a v2f64/v4f32 shuffle mask.
Definition X86ShuffleDecode.cpp:70
llvm::DecodePSWAPMask
void DecodePSWAPMask(unsigned NumElts, SmallVectorImpl< int > &ShuffleMask)
Decodes a PSWAPD 3DNow! instruction.
Definition X86ShuffleDecode.cpp:192
llvm::DecodeINSERTQIMask
void DecodeINSERTQIMask(unsigned NumElts, unsigned EltSize, int Len, int Idx, SmallVectorImpl< int > &ShuffleMask)
Decode a SSE4A INSERTQ instruction as a shuffle mask.
Definition X86ShuffleDecode.cpp:437
llvm::DecodeVALIGNMask
void DecodeVALIGNMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:139
llvm::DecodeScalarMoveMask
void DecodeScalarMoveMask(unsigned NumElts, bool IsLoad, SmallVectorImpl< int > &ShuffleMask)
Decode a scalar float move instruction as a shuffle mask.
Definition X86ShuffleDecode.cpp:391
llvm::DecodePALIGNRMask
void DecodePALIGNRMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:125
llvm::DecodeMOVSLDUPMask
void DecodeMOVSLDUPMask(unsigned NumElts, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:78
llvm::DecodeSubVectorBroadcast
void DecodeSubVectorBroadcast(unsigned DstNumElts, unsigned SrcNumElts, SmallVectorImpl< int > &ShuffleMask)
Decodes a broadcast of a subvector to a larger vector type.
Definition X86ShuffleDecode.cpp:255
llvm::DecodeUNPCKLMask
void DecodeUNPCKLMask(unsigned NumElts, unsigned ScalarBits, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for unpcklps/unpcklpd and punpckl*.
Definition X86ShuffleDecode.cpp:234
llvm::DecodePSLLDQMask
void DecodePSLLDQMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:100
llvm::DecodeUNPCKHMask
void DecodeUNPCKHMask(unsigned NumElts, unsigned ScalarBits, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for unpckhps/unpckhpd and punpckh*.
Definition X86ShuffleDecode.cpp:218
llvm::DecodePSHUFMask
void DecodePSHUFMask(unsigned NumElts, unsigned ScalarBits, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for pshufd/pshufw/vpermilpd/vpermilps.
Definition X86ShuffleDecode.cpp:148
llvm::DecodeMOVDDUPMask
void DecodeMOVDDUPMask(unsigned NumElts, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:92
llvm::DecodeSHUFPMask
void DecodeSHUFPMask(unsigned NumElts, unsigned ScalarBits, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for shufp*.
Definition X86ShuffleDecode.cpp:201
llvm::DecodePSHUFHWMask
void DecodePSHUFHWMask(unsigned NumElts, unsigned Imm, SmallVectorImpl< int > &ShuffleMask)
Decodes the shuffle masks for pshufhw.
Definition X86ShuffleDecode.cpp:164
llvm::DecodeMOVSHDUPMask
void DecodeMOVSHDUPMask(unsigned NumElts, SmallVectorImpl< int > &ShuffleMask)
Definition X86ShuffleDecode.cpp:85
llvm::SM_SentinelUndef
@ SM_SentinelUndef
Definition X86ShuffleDecode.h:28
llvm::SM_SentinelZero
@ SM_SentinelZero
Definition X86ShuffleDecode.h:28
raw_ostream.h
llvm::EnumStringDef
Compile-time data representation of enum entries.
Definition Enum.h:47
Generated on for LLVM by doxygen 1.14.0