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 
22 using 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.
getZeroExtensionTypes(const MCInst * MI,MVT & SrcVT,MVT & DstVT)28 static 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.
EmitAnyX86InstComments(const MCInst * MI,raw_ostream & OS,const char * (* getRegName)(unsigned))117 bool 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