1//===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This defines functionality used to emit comments about X86 instructions to
11// an output stream for -fverbose-asm.
12//
13//===----------------------------------------------------------------------===//
14
15#include "X86InstComments.h"
16#include "MCTargetDesc/X86MCTargetDesc.h"
17#include "Utils/X86ShuffleDecode.h"
18#include "llvm/MC/MCInst.h"
19#include "llvm/CodeGen/MachineValueType.h"
20#include "llvm/Support/raw_ostream.h"
21
22using namespace llvm;
23
24/// \brief Extracts the src/dst types for a given zero extension instruction.
25/// \note While the number of elements in DstVT type correct, the
26/// number in the SrcVT type is expanded to fill the src xmm register and the
27/// upper elements may not be included in the dst xmm/ymm register.
28static void getZeroExtensionTypes(const MCInst *MI, MVT &SrcVT, MVT &DstVT) {
29  switch (MI->getOpcode()) {
30  default:
31    llvm_unreachable("Unknown zero extension instruction");
32  // i8 zero extension
33  case X86::PMOVZXBWrm:
34  case X86::PMOVZXBWrr:
35  case X86::VPMOVZXBWrm:
36  case X86::VPMOVZXBWrr:
37    SrcVT = MVT::v16i8;
38    DstVT = MVT::v8i16;
39    break;
40  case X86::VPMOVZXBWYrm:
41  case X86::VPMOVZXBWYrr:
42    SrcVT = MVT::v16i8;
43    DstVT = MVT::v16i16;
44    break;
45  case X86::PMOVZXBDrm:
46  case X86::PMOVZXBDrr:
47  case X86::VPMOVZXBDrm:
48  case X86::VPMOVZXBDrr:
49    SrcVT = MVT::v16i8;
50    DstVT = MVT::v4i32;
51    break;
52  case X86::VPMOVZXBDYrm:
53  case X86::VPMOVZXBDYrr:
54    SrcVT = MVT::v16i8;
55    DstVT = MVT::v8i32;
56    break;
57  case X86::PMOVZXBQrm:
58  case X86::PMOVZXBQrr:
59  case X86::VPMOVZXBQrm:
60  case X86::VPMOVZXBQrr:
61    SrcVT = MVT::v16i8;
62    DstVT = MVT::v2i64;
63    break;
64  case X86::VPMOVZXBQYrm:
65  case X86::VPMOVZXBQYrr:
66    SrcVT = MVT::v16i8;
67    DstVT = MVT::v4i64;
68    break;
69  // i16 zero extension
70  case X86::PMOVZXWDrm:
71  case X86::PMOVZXWDrr:
72  case X86::VPMOVZXWDrm:
73  case X86::VPMOVZXWDrr:
74    SrcVT = MVT::v8i16;
75    DstVT = MVT::v4i32;
76    break;
77  case X86::VPMOVZXWDYrm:
78  case X86::VPMOVZXWDYrr:
79    SrcVT = MVT::v8i16;
80    DstVT = MVT::v8i32;
81    break;
82  case X86::PMOVZXWQrm:
83  case X86::PMOVZXWQrr:
84  case X86::VPMOVZXWQrm:
85  case X86::VPMOVZXWQrr:
86    SrcVT = MVT::v8i16;
87    DstVT = MVT::v2i64;
88    break;
89  case X86::VPMOVZXWQYrm:
90  case X86::VPMOVZXWQYrr:
91    SrcVT = MVT::v8i16;
92    DstVT = MVT::v4i64;
93    break;
94  // i32 zero extension
95  case X86::PMOVZXDQrm:
96  case X86::PMOVZXDQrr:
97  case X86::VPMOVZXDQrm:
98  case X86::VPMOVZXDQrr:
99    SrcVT = MVT::v4i32;
100    DstVT = MVT::v2i64;
101    break;
102  case X86::VPMOVZXDQYrm:
103  case X86::VPMOVZXDQYrr:
104    SrcVT = MVT::v4i32;
105    DstVT = MVT::v4i64;
106    break;
107  }
108}
109
110//===----------------------------------------------------------------------===//
111// Top Level Entrypoint
112//===----------------------------------------------------------------------===//
113
114/// EmitAnyX86InstComments - This function decodes x86 instructions and prints
115/// newline terminated strings to the specified string if desired.  This
116/// information is shown in disassembly dumps when verbose assembly is enabled.
117bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
118                                  const char *(*getRegName)(unsigned)) {
119  // If this is a shuffle operation, the switch should fill in this state.
120  SmallVector<int, 8> ShuffleMask;
121  const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
122
123  switch (MI->getOpcode()) {
124  default:
125    // Not an instruction for which we can decode comments.
126    return false;
127
128  case X86::BLENDPDrri:
129  case X86::VBLENDPDrri:
130    Src2Name = getRegName(MI->getOperand(2).getReg());
131    // FALL THROUGH.
132  case X86::BLENDPDrmi:
133  case X86::VBLENDPDrmi:
134    if(MI->getOperand(MI->getNumOperands()-1).isImm())
135      DecodeBLENDMask(MVT::v2f64,
136                      MI->getOperand(MI->getNumOperands()-1).getImm(),
137                      ShuffleMask);
138    Src1Name = getRegName(MI->getOperand(1).getReg());
139    DestName = getRegName(MI->getOperand(0).getReg());
140    break;
141  case X86::VBLENDPDYrri:
142    Src2Name = getRegName(MI->getOperand(2).getReg());
143    // FALL THROUGH.
144  case X86::VBLENDPDYrmi:
145    if(MI->getOperand(MI->getNumOperands()-1).isImm())
146      DecodeBLENDMask(MVT::v4f64,
147                      MI->getOperand(MI->getNumOperands()-1).getImm(),
148                      ShuffleMask);
149    Src1Name = getRegName(MI->getOperand(1).getReg());
150    DestName = getRegName(MI->getOperand(0).getReg());
151    break;
152
153  case X86::BLENDPSrri:
154  case X86::VBLENDPSrri:
155    Src2Name = getRegName(MI->getOperand(2).getReg());
156    // FALL THROUGH.
157  case X86::BLENDPSrmi:
158  case X86::VBLENDPSrmi:
159    if(MI->getOperand(MI->getNumOperands()-1).isImm())
160      DecodeBLENDMask(MVT::v4f32,
161                      MI->getOperand(MI->getNumOperands()-1).getImm(),
162                      ShuffleMask);
163    Src1Name = getRegName(MI->getOperand(1).getReg());
164    DestName = getRegName(MI->getOperand(0).getReg());
165    break;
166  case X86::VBLENDPSYrri:
167    Src2Name = getRegName(MI->getOperand(2).getReg());
168    // FALL THROUGH.
169  case X86::VBLENDPSYrmi:
170    if(MI->getOperand(MI->getNumOperands()-1).isImm())
171      DecodeBLENDMask(MVT::v8f32,
172                      MI->getOperand(MI->getNumOperands()-1).getImm(),
173                      ShuffleMask);
174    Src1Name = getRegName(MI->getOperand(1).getReg());
175    DestName = getRegName(MI->getOperand(0).getReg());
176    break;
177
178  case X86::PBLENDWrri:
179  case X86::VPBLENDWrri:
180    Src2Name = getRegName(MI->getOperand(2).getReg());
181    // FALL THROUGH.
182  case X86::PBLENDWrmi:
183  case X86::VPBLENDWrmi:
184    if(MI->getOperand(MI->getNumOperands()-1).isImm())
185      DecodeBLENDMask(MVT::v8i16,
186                      MI->getOperand(MI->getNumOperands()-1).getImm(),
187                      ShuffleMask);
188    Src1Name = getRegName(MI->getOperand(1).getReg());
189    DestName = getRegName(MI->getOperand(0).getReg());
190    break;
191  case X86::VPBLENDWYrri:
192    Src2Name = getRegName(MI->getOperand(2).getReg());
193    // FALL THROUGH.
194  case X86::VPBLENDWYrmi:
195    if(MI->getOperand(MI->getNumOperands()-1).isImm())
196      DecodeBLENDMask(MVT::v16i16,
197                      MI->getOperand(MI->getNumOperands()-1).getImm(),
198                      ShuffleMask);
199    Src1Name = getRegName(MI->getOperand(1).getReg());
200    DestName = getRegName(MI->getOperand(0).getReg());
201    break;
202
203  case X86::VPBLENDDrri:
204    Src2Name = getRegName(MI->getOperand(2).getReg());
205    // FALL THROUGH.
206  case X86::VPBLENDDrmi:
207    if(MI->getOperand(MI->getNumOperands()-1).isImm())
208      DecodeBLENDMask(MVT::v4i32,
209                      MI->getOperand(MI->getNumOperands()-1).getImm(),
210                      ShuffleMask);
211    Src1Name = getRegName(MI->getOperand(1).getReg());
212    DestName = getRegName(MI->getOperand(0).getReg());
213    break;
214
215  case X86::VPBLENDDYrri:
216    Src2Name = getRegName(MI->getOperand(2).getReg());
217    // FALL THROUGH.
218  case X86::VPBLENDDYrmi:
219    if(MI->getOperand(MI->getNumOperands()-1).isImm())
220      DecodeBLENDMask(MVT::v8i32,
221                      MI->getOperand(MI->getNumOperands()-1).getImm(),
222                      ShuffleMask);
223    Src1Name = getRegName(MI->getOperand(1).getReg());
224    DestName = getRegName(MI->getOperand(0).getReg());
225    break;
226
227  case X86::INSERTPSrr:
228  case X86::VINSERTPSrr:
229    Src2Name = getRegName(MI->getOperand(2).getReg());
230    // FALL THROUGH.
231  case X86::INSERTPSrm:
232  case X86::VINSERTPSrm:
233    DestName = getRegName(MI->getOperand(0).getReg());
234    Src1Name = getRegName(MI->getOperand(1).getReg());
235    if(MI->getOperand(MI->getNumOperands()-1).isImm())
236      DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
237                         ShuffleMask);
238    break;
239
240  case X86::MOVLHPSrr:
241  case X86::VMOVLHPSrr:
242    Src2Name = getRegName(MI->getOperand(2).getReg());
243    Src1Name = getRegName(MI->getOperand(1).getReg());
244    DestName = getRegName(MI->getOperand(0).getReg());
245    DecodeMOVLHPSMask(2, ShuffleMask);
246    break;
247
248  case X86::MOVHLPSrr:
249  case X86::VMOVHLPSrr:
250    Src2Name = getRegName(MI->getOperand(2).getReg());
251    Src1Name = getRegName(MI->getOperand(1).getReg());
252    DestName = getRegName(MI->getOperand(0).getReg());
253    DecodeMOVHLPSMask(2, ShuffleMask);
254    break;
255
256  case X86::MOVSLDUPrr:
257  case X86::VMOVSLDUPrr:
258    Src1Name = getRegName(MI->getOperand(1).getReg());
259    // FALL THROUGH.
260  case X86::MOVSLDUPrm:
261  case X86::VMOVSLDUPrm:
262    DestName = getRegName(MI->getOperand(0).getReg());
263    DecodeMOVSLDUPMask(MVT::v4f32, ShuffleMask);
264    break;
265
266  case X86::VMOVSHDUPYrr:
267    Src1Name = getRegName(MI->getOperand(1).getReg());
268    // FALL THROUGH.
269  case X86::VMOVSHDUPYrm:
270    DestName = getRegName(MI->getOperand(0).getReg());
271    DecodeMOVSHDUPMask(MVT::v8f32, ShuffleMask);
272    break;
273
274  case X86::VMOVSLDUPYrr:
275    Src1Name = getRegName(MI->getOperand(1).getReg());
276    // FALL THROUGH.
277  case X86::VMOVSLDUPYrm:
278    DestName = getRegName(MI->getOperand(0).getReg());
279    DecodeMOVSLDUPMask(MVT::v8f32, ShuffleMask);
280    break;
281
282  case X86::MOVSHDUPrr:
283  case X86::VMOVSHDUPrr:
284    Src1Name = getRegName(MI->getOperand(1).getReg());
285    // FALL THROUGH.
286  case X86::MOVSHDUPrm:
287  case X86::VMOVSHDUPrm:
288    DestName = getRegName(MI->getOperand(0).getReg());
289    DecodeMOVSHDUPMask(MVT::v4f32, ShuffleMask);
290    break;
291
292  case X86::VMOVDDUPYrr:
293    Src1Name = getRegName(MI->getOperand(1).getReg());
294    // FALL THROUGH.
295  case X86::VMOVDDUPYrm:
296    DestName = getRegName(MI->getOperand(0).getReg());
297    DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);
298    break;
299
300  case X86::MOVDDUPrr:
301  case X86::VMOVDDUPrr:
302    Src1Name = getRegName(MI->getOperand(1).getReg());
303    // FALL THROUGH.
304  case X86::MOVDDUPrm:
305  case X86::VMOVDDUPrm:
306    DestName = getRegName(MI->getOperand(0).getReg());
307    DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);
308    break;
309
310  case X86::PSLLDQri:
311  case X86::VPSLLDQri:
312    Src1Name = getRegName(MI->getOperand(1).getReg());
313    DestName = getRegName(MI->getOperand(0).getReg());
314    if(MI->getOperand(MI->getNumOperands()-1).isImm())
315      DecodePSLLDQMask(MVT::v16i8,
316                       MI->getOperand(MI->getNumOperands()-1).getImm(),
317                       ShuffleMask);
318    break;
319
320  case X86::VPSLLDQYri:
321    Src1Name = getRegName(MI->getOperand(1).getReg());
322    DestName = getRegName(MI->getOperand(0).getReg());
323    if(MI->getOperand(MI->getNumOperands()-1).isImm())
324      DecodePSLLDQMask(MVT::v32i8,
325                       MI->getOperand(MI->getNumOperands()-1).getImm(),
326                       ShuffleMask);
327    break;
328
329  case X86::PSRLDQri:
330  case X86::VPSRLDQri:
331    Src1Name = getRegName(MI->getOperand(1).getReg());
332    DestName = getRegName(MI->getOperand(0).getReg());
333    if(MI->getOperand(MI->getNumOperands()-1).isImm())
334      DecodePSRLDQMask(MVT::v16i8,
335                       MI->getOperand(MI->getNumOperands()-1).getImm(),
336                       ShuffleMask);
337    break;
338
339  case X86::VPSRLDQYri:
340    Src1Name = getRegName(MI->getOperand(1).getReg());
341    DestName = getRegName(MI->getOperand(0).getReg());
342    if(MI->getOperand(MI->getNumOperands()-1).isImm())
343      DecodePSRLDQMask(MVT::v32i8,
344                       MI->getOperand(MI->getNumOperands()-1).getImm(),
345                       ShuffleMask);
346    break;
347
348  case X86::PALIGNR128rr:
349  case X86::VPALIGNR128rr:
350    Src1Name = getRegName(MI->getOperand(2).getReg());
351    // FALL THROUGH.
352  case X86::PALIGNR128rm:
353  case X86::VPALIGNR128rm:
354    Src2Name = getRegName(MI->getOperand(1).getReg());
355    DestName = getRegName(MI->getOperand(0).getReg());
356    if(MI->getOperand(MI->getNumOperands()-1).isImm())
357      DecodePALIGNRMask(MVT::v16i8,
358                        MI->getOperand(MI->getNumOperands()-1).getImm(),
359                        ShuffleMask);
360    break;
361  case X86::VPALIGNR256rr:
362    Src1Name = getRegName(MI->getOperand(2).getReg());
363    // FALL THROUGH.
364  case X86::VPALIGNR256rm:
365    Src2Name = getRegName(MI->getOperand(1).getReg());
366    DestName = getRegName(MI->getOperand(0).getReg());
367    if(MI->getOperand(MI->getNumOperands()-1).isImm())
368      DecodePALIGNRMask(MVT::v32i8,
369                        MI->getOperand(MI->getNumOperands()-1).getImm(),
370                        ShuffleMask);
371    break;
372
373  case X86::PSHUFDri:
374  case X86::VPSHUFDri:
375    Src1Name = getRegName(MI->getOperand(1).getReg());
376    // FALL THROUGH.
377  case X86::PSHUFDmi:
378  case X86::VPSHUFDmi:
379    DestName = getRegName(MI->getOperand(0).getReg());
380    if(MI->getOperand(MI->getNumOperands()-1).isImm())
381      DecodePSHUFMask(MVT::v4i32,
382                      MI->getOperand(MI->getNumOperands()-1).getImm(),
383                      ShuffleMask);
384    break;
385  case X86::VPSHUFDYri:
386    Src1Name = getRegName(MI->getOperand(1).getReg());
387    // FALL THROUGH.
388  case X86::VPSHUFDYmi:
389    DestName = getRegName(MI->getOperand(0).getReg());
390    if(MI->getOperand(MI->getNumOperands()-1).isImm())
391      DecodePSHUFMask(MVT::v8i32,
392                      MI->getOperand(MI->getNumOperands()-1).getImm(),
393                      ShuffleMask);
394    break;
395
396
397  case X86::PSHUFHWri:
398  case X86::VPSHUFHWri:
399    Src1Name = getRegName(MI->getOperand(1).getReg());
400    // FALL THROUGH.
401  case X86::PSHUFHWmi:
402  case X86::VPSHUFHWmi:
403    DestName = getRegName(MI->getOperand(0).getReg());
404    if(MI->getOperand(MI->getNumOperands()-1).isImm())
405      DecodePSHUFHWMask(MVT::v8i16,
406                        MI->getOperand(MI->getNumOperands()-1).getImm(),
407                        ShuffleMask);
408    break;
409  case X86::VPSHUFHWYri:
410    Src1Name = getRegName(MI->getOperand(1).getReg());
411    // FALL THROUGH.
412  case X86::VPSHUFHWYmi:
413    DestName = getRegName(MI->getOperand(0).getReg());
414    if(MI->getOperand(MI->getNumOperands()-1).isImm())
415      DecodePSHUFHWMask(MVT::v16i16,
416                        MI->getOperand(MI->getNumOperands()-1).getImm(),
417                        ShuffleMask);
418    break;
419  case X86::PSHUFLWri:
420  case X86::VPSHUFLWri:
421    Src1Name = getRegName(MI->getOperand(1).getReg());
422    // FALL THROUGH.
423  case X86::PSHUFLWmi:
424  case X86::VPSHUFLWmi:
425    DestName = getRegName(MI->getOperand(0).getReg());
426    if(MI->getOperand(MI->getNumOperands()-1).isImm())
427      DecodePSHUFLWMask(MVT::v8i16,
428                        MI->getOperand(MI->getNumOperands()-1).getImm(),
429                        ShuffleMask);
430    break;
431  case X86::VPSHUFLWYri:
432    Src1Name = getRegName(MI->getOperand(1).getReg());
433    // FALL THROUGH.
434  case X86::VPSHUFLWYmi:
435    DestName = getRegName(MI->getOperand(0).getReg());
436    if(MI->getOperand(MI->getNumOperands()-1).isImm())
437      DecodePSHUFLWMask(MVT::v16i16,
438                        MI->getOperand(MI->getNumOperands()-1).getImm(),
439                        ShuffleMask);
440    break;
441
442  case X86::PUNPCKHBWrr:
443  case X86::VPUNPCKHBWrr:
444    Src2Name = getRegName(MI->getOperand(2).getReg());
445    // FALL THROUGH.
446  case X86::PUNPCKHBWrm:
447  case X86::VPUNPCKHBWrm:
448    Src1Name = getRegName(MI->getOperand(1).getReg());
449    DestName = getRegName(MI->getOperand(0).getReg());
450    DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
451    break;
452  case X86::VPUNPCKHBWYrr:
453    Src2Name = getRegName(MI->getOperand(2).getReg());
454    // FALL THROUGH.
455  case X86::VPUNPCKHBWYrm:
456    Src1Name = getRegName(MI->getOperand(1).getReg());
457    DestName = getRegName(MI->getOperand(0).getReg());
458    DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
459    break;
460  case X86::PUNPCKHWDrr:
461  case X86::VPUNPCKHWDrr:
462    Src2Name = getRegName(MI->getOperand(2).getReg());
463    // FALL THROUGH.
464  case X86::PUNPCKHWDrm:
465  case X86::VPUNPCKHWDrm:
466    Src1Name = getRegName(MI->getOperand(1).getReg());
467    DestName = getRegName(MI->getOperand(0).getReg());
468    DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
469    break;
470  case X86::VPUNPCKHWDYrr:
471    Src2Name = getRegName(MI->getOperand(2).getReg());
472    // FALL THROUGH.
473  case X86::VPUNPCKHWDYrm:
474    Src1Name = getRegName(MI->getOperand(1).getReg());
475    DestName = getRegName(MI->getOperand(0).getReg());
476    DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
477    break;
478  case X86::PUNPCKHDQrr:
479  case X86::VPUNPCKHDQrr:
480    Src2Name = getRegName(MI->getOperand(2).getReg());
481    // FALL THROUGH.
482  case X86::PUNPCKHDQrm:
483  case X86::VPUNPCKHDQrm:
484    Src1Name = getRegName(MI->getOperand(1).getReg());
485    DestName = getRegName(MI->getOperand(0).getReg());
486    DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
487    break;
488  case X86::VPUNPCKHDQYrr:
489    Src2Name = getRegName(MI->getOperand(2).getReg());
490    // FALL THROUGH.
491  case X86::VPUNPCKHDQYrm:
492    Src1Name = getRegName(MI->getOperand(1).getReg());
493    DestName = getRegName(MI->getOperand(0).getReg());
494    DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
495    break;
496  case X86::VPUNPCKHDQZrr:
497    Src2Name = getRegName(MI->getOperand(2).getReg());
498    // FALL THROUGH.
499  case X86::VPUNPCKHDQZrm:
500    Src1Name = getRegName(MI->getOperand(1).getReg());
501    DestName = getRegName(MI->getOperand(0).getReg());
502    DecodeUNPCKHMask(MVT::v16i32, ShuffleMask);
503    break;
504  case X86::PUNPCKHQDQrr:
505  case X86::VPUNPCKHQDQrr:
506    Src2Name = getRegName(MI->getOperand(2).getReg());
507    // FALL THROUGH.
508  case X86::PUNPCKHQDQrm:
509  case X86::VPUNPCKHQDQrm:
510    Src1Name = getRegName(MI->getOperand(1).getReg());
511    DestName = getRegName(MI->getOperand(0).getReg());
512    DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
513    break;
514  case X86::VPUNPCKHQDQYrr:
515    Src2Name = getRegName(MI->getOperand(2).getReg());
516    // FALL THROUGH.
517  case X86::VPUNPCKHQDQYrm:
518    Src1Name = getRegName(MI->getOperand(1).getReg());
519    DestName = getRegName(MI->getOperand(0).getReg());
520    DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
521    break;
522  case X86::VPUNPCKHQDQZrr:
523    Src2Name = getRegName(MI->getOperand(2).getReg());
524    // FALL THROUGH.
525  case X86::VPUNPCKHQDQZrm:
526    Src1Name = getRegName(MI->getOperand(1).getReg());
527    DestName = getRegName(MI->getOperand(0).getReg());
528    DecodeUNPCKHMask(MVT::v8i64, ShuffleMask);
529    break;
530
531  case X86::PUNPCKLBWrr:
532  case X86::VPUNPCKLBWrr:
533    Src2Name = getRegName(MI->getOperand(2).getReg());
534    // FALL THROUGH.
535  case X86::PUNPCKLBWrm:
536  case X86::VPUNPCKLBWrm:
537    Src1Name = getRegName(MI->getOperand(1).getReg());
538    DestName = getRegName(MI->getOperand(0).getReg());
539    DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
540    break;
541  case X86::VPUNPCKLBWYrr:
542    Src2Name = getRegName(MI->getOperand(2).getReg());
543    // FALL THROUGH.
544  case X86::VPUNPCKLBWYrm:
545    Src1Name = getRegName(MI->getOperand(1).getReg());
546    DestName = getRegName(MI->getOperand(0).getReg());
547    DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
548    break;
549  case X86::PUNPCKLWDrr:
550  case X86::VPUNPCKLWDrr:
551    Src2Name = getRegName(MI->getOperand(2).getReg());
552    // FALL THROUGH.
553  case X86::PUNPCKLWDrm:
554  case X86::VPUNPCKLWDrm:
555    Src1Name = getRegName(MI->getOperand(1).getReg());
556    DestName = getRegName(MI->getOperand(0).getReg());
557    DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
558    break;
559  case X86::VPUNPCKLWDYrr:
560    Src2Name = getRegName(MI->getOperand(2).getReg());
561    // FALL THROUGH.
562  case X86::VPUNPCKLWDYrm:
563    Src1Name = getRegName(MI->getOperand(1).getReg());
564    DestName = getRegName(MI->getOperand(0).getReg());
565    DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
566    break;
567  case X86::PUNPCKLDQrr:
568  case X86::VPUNPCKLDQrr:
569    Src2Name = getRegName(MI->getOperand(2).getReg());
570    // FALL THROUGH.
571  case X86::PUNPCKLDQrm:
572  case X86::VPUNPCKLDQrm:
573    Src1Name = getRegName(MI->getOperand(1).getReg());
574    DestName = getRegName(MI->getOperand(0).getReg());
575    DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
576    break;
577  case X86::VPUNPCKLDQYrr:
578    Src2Name = getRegName(MI->getOperand(2).getReg());
579    // FALL THROUGH.
580  case X86::VPUNPCKLDQYrm:
581    Src1Name = getRegName(MI->getOperand(1).getReg());
582    DestName = getRegName(MI->getOperand(0).getReg());
583    DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
584    break;
585  case X86::VPUNPCKLDQZrr:
586    Src2Name = getRegName(MI->getOperand(2).getReg());
587    // FALL THROUGH.
588  case X86::VPUNPCKLDQZrm:
589    Src1Name = getRegName(MI->getOperand(1).getReg());
590    DestName = getRegName(MI->getOperand(0).getReg());
591    DecodeUNPCKLMask(MVT::v16i32, ShuffleMask);
592    break;
593  case X86::PUNPCKLQDQrr:
594  case X86::VPUNPCKLQDQrr:
595    Src2Name = getRegName(MI->getOperand(2).getReg());
596    // FALL THROUGH.
597  case X86::PUNPCKLQDQrm:
598  case X86::VPUNPCKLQDQrm:
599    Src1Name = getRegName(MI->getOperand(1).getReg());
600    DestName = getRegName(MI->getOperand(0).getReg());
601    DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
602    break;
603  case X86::VPUNPCKLQDQYrr:
604    Src2Name = getRegName(MI->getOperand(2).getReg());
605    // FALL THROUGH.
606  case X86::VPUNPCKLQDQYrm:
607    Src1Name = getRegName(MI->getOperand(1).getReg());
608    DestName = getRegName(MI->getOperand(0).getReg());
609    DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
610    break;
611  case X86::VPUNPCKLQDQZrr:
612    Src2Name = getRegName(MI->getOperand(2).getReg());
613    // FALL THROUGH.
614  case X86::VPUNPCKLQDQZrm:
615    Src1Name = getRegName(MI->getOperand(1).getReg());
616    DestName = getRegName(MI->getOperand(0).getReg());
617    DecodeUNPCKLMask(MVT::v8i64, ShuffleMask);
618    break;
619
620  case X86::SHUFPDrri:
621  case X86::VSHUFPDrri:
622    Src2Name = getRegName(MI->getOperand(2).getReg());
623    // FALL THROUGH.
624  case X86::SHUFPDrmi:
625  case X86::VSHUFPDrmi:
626    if(MI->getOperand(MI->getNumOperands()-1).isImm())
627      DecodeSHUFPMask(MVT::v2f64,
628                      MI->getOperand(MI->getNumOperands()-1).getImm(),
629                      ShuffleMask);
630    Src1Name = getRegName(MI->getOperand(1).getReg());
631    DestName = getRegName(MI->getOperand(0).getReg());
632    break;
633  case X86::VSHUFPDYrri:
634    Src2Name = getRegName(MI->getOperand(2).getReg());
635    // FALL THROUGH.
636  case X86::VSHUFPDYrmi:
637    if(MI->getOperand(MI->getNumOperands()-1).isImm())
638      DecodeSHUFPMask(MVT::v4f64,
639                      MI->getOperand(MI->getNumOperands()-1).getImm(),
640                      ShuffleMask);
641    Src1Name = getRegName(MI->getOperand(1).getReg());
642    DestName = getRegName(MI->getOperand(0).getReg());
643    break;
644
645  case X86::SHUFPSrri:
646  case X86::VSHUFPSrri:
647    Src2Name = getRegName(MI->getOperand(2).getReg());
648    // FALL THROUGH.
649  case X86::SHUFPSrmi:
650  case X86::VSHUFPSrmi:
651    if(MI->getOperand(MI->getNumOperands()-1).isImm())
652      DecodeSHUFPMask(MVT::v4f32,
653                      MI->getOperand(MI->getNumOperands()-1).getImm(),
654                      ShuffleMask);
655    Src1Name = getRegName(MI->getOperand(1).getReg());
656    DestName = getRegName(MI->getOperand(0).getReg());
657    break;
658  case X86::VSHUFPSYrri:
659    Src2Name = getRegName(MI->getOperand(2).getReg());
660    // FALL THROUGH.
661  case X86::VSHUFPSYrmi:
662    if(MI->getOperand(MI->getNumOperands()-1).isImm())
663      DecodeSHUFPMask(MVT::v8f32,
664                      MI->getOperand(MI->getNumOperands()-1).getImm(),
665                      ShuffleMask);
666    Src1Name = getRegName(MI->getOperand(1).getReg());
667    DestName = getRegName(MI->getOperand(0).getReg());
668    break;
669
670  case X86::UNPCKLPDrr:
671  case X86::VUNPCKLPDrr:
672    Src2Name = getRegName(MI->getOperand(2).getReg());
673    // FALL THROUGH.
674  case X86::UNPCKLPDrm:
675  case X86::VUNPCKLPDrm:
676    DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
677    Src1Name = getRegName(MI->getOperand(1).getReg());
678    DestName = getRegName(MI->getOperand(0).getReg());
679    break;
680  case X86::VUNPCKLPDYrr:
681    Src2Name = getRegName(MI->getOperand(2).getReg());
682    // FALL THROUGH.
683  case X86::VUNPCKLPDYrm:
684    DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
685    Src1Name = getRegName(MI->getOperand(1).getReg());
686    DestName = getRegName(MI->getOperand(0).getReg());
687    break;
688  case X86::VUNPCKLPDZrr:
689    Src2Name = getRegName(MI->getOperand(2).getReg());
690    // FALL THROUGH.
691  case X86::VUNPCKLPDZrm:
692    DecodeUNPCKLMask(MVT::v8f64, ShuffleMask);
693    Src1Name = getRegName(MI->getOperand(1).getReg());
694    DestName = getRegName(MI->getOperand(0).getReg());
695    break;
696  case X86::UNPCKLPSrr:
697  case X86::VUNPCKLPSrr:
698    Src2Name = getRegName(MI->getOperand(2).getReg());
699    // FALL THROUGH.
700  case X86::UNPCKLPSrm:
701  case X86::VUNPCKLPSrm:
702    DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
703    Src1Name = getRegName(MI->getOperand(1).getReg());
704    DestName = getRegName(MI->getOperand(0).getReg());
705    break;
706  case X86::VUNPCKLPSYrr:
707    Src2Name = getRegName(MI->getOperand(2).getReg());
708    // FALL THROUGH.
709  case X86::VUNPCKLPSYrm:
710    DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
711    Src1Name = getRegName(MI->getOperand(1).getReg());
712    DestName = getRegName(MI->getOperand(0).getReg());
713    break;
714  case X86::VUNPCKLPSZrr:
715    Src2Name = getRegName(MI->getOperand(2).getReg());
716    // FALL THROUGH.
717  case X86::VUNPCKLPSZrm:
718    DecodeUNPCKLMask(MVT::v16f32, ShuffleMask);
719    Src1Name = getRegName(MI->getOperand(1).getReg());
720    DestName = getRegName(MI->getOperand(0).getReg());
721    break;
722  case X86::UNPCKHPDrr:
723  case X86::VUNPCKHPDrr:
724    Src2Name = getRegName(MI->getOperand(2).getReg());
725    // FALL THROUGH.
726  case X86::UNPCKHPDrm:
727  case X86::VUNPCKHPDrm:
728    DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
729    Src1Name = getRegName(MI->getOperand(1).getReg());
730    DestName = getRegName(MI->getOperand(0).getReg());
731    break;
732  case X86::VUNPCKHPDYrr:
733    Src2Name = getRegName(MI->getOperand(2).getReg());
734    // FALL THROUGH.
735  case X86::VUNPCKHPDYrm:
736    DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
737    Src1Name = getRegName(MI->getOperand(1).getReg());
738    DestName = getRegName(MI->getOperand(0).getReg());
739    break;
740  case X86::VUNPCKHPDZrr:
741    Src2Name = getRegName(MI->getOperand(2).getReg());
742    // FALL THROUGH.
743  case X86::VUNPCKHPDZrm:
744    DecodeUNPCKHMask(MVT::v8f64, ShuffleMask);
745    Src1Name = getRegName(MI->getOperand(1).getReg());
746    DestName = getRegName(MI->getOperand(0).getReg());
747    break;
748  case X86::UNPCKHPSrr:
749  case X86::VUNPCKHPSrr:
750    Src2Name = getRegName(MI->getOperand(2).getReg());
751    // FALL THROUGH.
752  case X86::UNPCKHPSrm:
753  case X86::VUNPCKHPSrm:
754    DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
755    Src1Name = getRegName(MI->getOperand(1).getReg());
756    DestName = getRegName(MI->getOperand(0).getReg());
757    break;
758  case X86::VUNPCKHPSYrr:
759    Src2Name = getRegName(MI->getOperand(2).getReg());
760    // FALL THROUGH.
761  case X86::VUNPCKHPSYrm:
762    DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
763    Src1Name = getRegName(MI->getOperand(1).getReg());
764    DestName = getRegName(MI->getOperand(0).getReg());
765    break;
766  case X86::VUNPCKHPSZrr:
767    Src2Name = getRegName(MI->getOperand(2).getReg());
768    // FALL THROUGH.
769  case X86::VUNPCKHPSZrm:
770    DecodeUNPCKHMask(MVT::v16f32, ShuffleMask);
771    Src1Name = getRegName(MI->getOperand(1).getReg());
772    DestName = getRegName(MI->getOperand(0).getReg());
773    break;
774  case X86::VPERMILPSri:
775    Src1Name = getRegName(MI->getOperand(1).getReg());
776    // FALL THROUGH.
777  case X86::VPERMILPSmi:
778    if(MI->getOperand(MI->getNumOperands()-1).isImm())
779      DecodePSHUFMask(MVT::v4f32,
780                      MI->getOperand(MI->getNumOperands()-1).getImm(),
781                      ShuffleMask);
782    DestName = getRegName(MI->getOperand(0).getReg());
783    break;
784  case X86::VPERMILPSYri:
785    Src1Name = getRegName(MI->getOperand(1).getReg());
786    // FALL THROUGH.
787  case X86::VPERMILPSYmi:
788    if(MI->getOperand(MI->getNumOperands()-1).isImm())
789      DecodePSHUFMask(MVT::v8f32,
790                      MI->getOperand(MI->getNumOperands()-1).getImm(),
791                      ShuffleMask);
792    DestName = getRegName(MI->getOperand(0).getReg());
793    break;
794  case X86::VPERMILPDri:
795    Src1Name = getRegName(MI->getOperand(1).getReg());
796    // FALL THROUGH.
797  case X86::VPERMILPDmi:
798    if(MI->getOperand(MI->getNumOperands()-1).isImm())
799      DecodePSHUFMask(MVT::v2f64,
800                      MI->getOperand(MI->getNumOperands()-1).getImm(),
801                      ShuffleMask);
802    DestName = getRegName(MI->getOperand(0).getReg());
803    break;
804  case X86::VPERMILPDYri:
805    Src1Name = getRegName(MI->getOperand(1).getReg());
806    // FALL THROUGH.
807  case X86::VPERMILPDYmi:
808    if(MI->getOperand(MI->getNumOperands()-1).isImm())
809      DecodePSHUFMask(MVT::v4f64,
810                      MI->getOperand(MI->getNumOperands()-1).getImm(),
811                      ShuffleMask);
812    DestName = getRegName(MI->getOperand(0).getReg());
813    break;
814  case X86::VPERM2F128rr:
815  case X86::VPERM2I128rr:
816    Src2Name = getRegName(MI->getOperand(2).getReg());
817    // FALL THROUGH.
818  case X86::VPERM2F128rm:
819  case X86::VPERM2I128rm:
820    // For instruction comments purpose, assume the 256-bit vector is v4i64.
821    if(MI->getOperand(MI->getNumOperands()-1).isImm())
822      DecodeVPERM2X128Mask(MVT::v4i64,
823                           MI->getOperand(MI->getNumOperands()-1).getImm(),
824                           ShuffleMask);
825    Src1Name = getRegName(MI->getOperand(1).getReg());
826    DestName = getRegName(MI->getOperand(0).getReg());
827    break;
828  case X86::VPERMQYri:
829  case X86::VPERMPDYri:
830    Src1Name = getRegName(MI->getOperand(1).getReg());
831    // FALL THROUGH.
832  case X86::VPERMQYmi:
833  case X86::VPERMPDYmi:
834    if(MI->getOperand(MI->getNumOperands()-1).isImm())
835      DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
836                      ShuffleMask);
837    DestName = getRegName(MI->getOperand(0).getReg());
838    break;
839
840  case X86::MOVSDrr:
841  case X86::VMOVSDrr:
842    Src2Name = getRegName(MI->getOperand(2).getReg());
843    Src1Name = getRegName(MI->getOperand(1).getReg());
844    // FALL THROUGH.
845  case X86::MOVSDrm:
846  case X86::VMOVSDrm:
847    DecodeScalarMoveMask(MVT::v2f64, nullptr == Src2Name, ShuffleMask);
848    DestName = getRegName(MI->getOperand(0).getReg());
849    break;
850  case X86::MOVSSrr:
851  case X86::VMOVSSrr:
852    Src2Name = getRegName(MI->getOperand(2).getReg());
853    Src1Name = getRegName(MI->getOperand(1).getReg());
854    // FALL THROUGH.
855  case X86::MOVSSrm:
856  case X86::VMOVSSrm:
857    DecodeScalarMoveMask(MVT::v4f32, nullptr == Src2Name, ShuffleMask);
858    DestName = getRegName(MI->getOperand(0).getReg());
859    break;
860
861  case X86::MOVPQI2QIrr:
862  case X86::MOVZPQILo2PQIrr:
863  case X86::VMOVPQI2QIrr:
864  case X86::VMOVZPQILo2PQIrr:
865    Src1Name = getRegName(MI->getOperand(1).getReg());
866  // FALL THROUGH.
867  case X86::MOVQI2PQIrm:
868  case X86::MOVZQI2PQIrm:
869  case X86::MOVZPQILo2PQIrm:
870  case X86::VMOVQI2PQIrm:
871  case X86::VMOVZQI2PQIrm:
872  case X86::VMOVZPQILo2PQIrm:
873    DecodeZeroMoveLowMask(MVT::v2i64, ShuffleMask);
874    DestName = getRegName(MI->getOperand(0).getReg());
875    break;
876  case X86::MOVDI2PDIrm:
877  case X86::VMOVDI2PDIrm:
878    DecodeZeroMoveLowMask(MVT::v4i32, ShuffleMask);
879    DestName = getRegName(MI->getOperand(0).getReg());
880    break;
881
882  case X86::PMOVZXBWrr:
883  case X86::PMOVZXBDrr:
884  case X86::PMOVZXBQrr:
885  case X86::PMOVZXWDrr:
886  case X86::PMOVZXWQrr:
887  case X86::PMOVZXDQrr:
888  case X86::VPMOVZXBWrr:
889  case X86::VPMOVZXBDrr:
890  case X86::VPMOVZXBQrr:
891  case X86::VPMOVZXWDrr:
892  case X86::VPMOVZXWQrr:
893  case X86::VPMOVZXDQrr:
894  case X86::VPMOVZXBWYrr:
895  case X86::VPMOVZXBDYrr:
896  case X86::VPMOVZXBQYrr:
897  case X86::VPMOVZXWDYrr:
898  case X86::VPMOVZXWQYrr:
899  case X86::VPMOVZXDQYrr:
900    Src1Name = getRegName(MI->getOperand(1).getReg());
901  // FALL THROUGH.
902  case X86::PMOVZXBWrm:
903  case X86::PMOVZXBDrm:
904  case X86::PMOVZXBQrm:
905  case X86::PMOVZXWDrm:
906  case X86::PMOVZXWQrm:
907  case X86::PMOVZXDQrm:
908  case X86::VPMOVZXBWrm:
909  case X86::VPMOVZXBDrm:
910  case X86::VPMOVZXBQrm:
911  case X86::VPMOVZXWDrm:
912  case X86::VPMOVZXWQrm:
913  case X86::VPMOVZXDQrm:
914  case X86::VPMOVZXBWYrm:
915  case X86::VPMOVZXBDYrm:
916  case X86::VPMOVZXBQYrm:
917  case X86::VPMOVZXWDYrm:
918  case X86::VPMOVZXWQYrm:
919  case X86::VPMOVZXDQYrm: {
920    MVT SrcVT, DstVT;
921    getZeroExtensionTypes(MI, SrcVT, DstVT);
922    DecodeZeroExtendMask(SrcVT, DstVT, ShuffleMask);
923    DestName = getRegName(MI->getOperand(0).getReg());
924  } break;
925  }
926
927  // The only comments we decode are shuffles, so give up if we were unable to
928  // decode a shuffle mask.
929  if (ShuffleMask.empty())
930    return false;
931
932  if (!DestName) DestName = Src1Name;
933  OS << (DestName ? DestName : "mem") << " = ";
934
935  // If the two sources are the same, canonicalize the input elements to be
936  // from the first src so that we get larger element spans.
937  if (Src1Name == Src2Name) {
938    for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
939      if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
940          ShuffleMask[i] >= (int)e)        // From second mask.
941        ShuffleMask[i] -= e;
942    }
943  }
944
945  // The shuffle mask specifies which elements of the src1/src2 fill in the
946  // destination, with a few sentinel values.  Loop through and print them
947  // out.
948  for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
949    if (i != 0)
950      OS << ',';
951    if (ShuffleMask[i] == SM_SentinelZero) {
952      OS << "zero";
953      continue;
954    }
955
956    // Otherwise, it must come from src1 or src2.  Print the span of elements
957    // that comes from this src.
958    bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
959    const char *SrcName = isSrc1 ? Src1Name : Src2Name;
960    OS << (SrcName ? SrcName : "mem") << '[';
961    bool IsFirst = true;
962    while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
963           (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
964      if (!IsFirst)
965        OS << ',';
966      else
967        IsFirst = false;
968      if (ShuffleMask[i] == SM_SentinelUndef)
969        OS << "u";
970      else
971        OS << ShuffleMask[i] % ShuffleMask.size();
972      ++i;
973    }
974    OS << ']';
975    --i;  // For loop increments element #.
976  }
977  //MI->print(OS, 0);
978  OS << "\n";
979
980  // We successfully added a comment to this instruction.
981  return true;
982}
983