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 //===----------------------------------------------------------------------===//
25 // Top Level Entrypoint
26 //===----------------------------------------------------------------------===//
27 
28 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints
29 /// newline terminated strings to the specified string if desired.  This
30 /// information is shown in disassembly dumps when verbose assembly is enabled.
31 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
32                                   const char *(*getRegName)(unsigned)) {
33   // If this is a shuffle operation, the switch should fill in this state.
34   SmallVector<int, 8> ShuffleMask;
35   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;
36 
37   switch (MI->getOpcode()) {
38   default:
39     // Not an instruction for which we can decode comments.
40     return false;
41 
42   case X86::BLENDPDrri:
43   case X86::VBLENDPDrri:
44     Src2Name = getRegName(MI->getOperand(2).getReg());
45     // FALL THROUGH.
46   case X86::BLENDPDrmi:
47   case X86::VBLENDPDrmi:
48     if(MI->getOperand(MI->getNumOperands()-1).isImm())
49       DecodeBLENDMask(MVT::v2f64,
50                       MI->getOperand(MI->getNumOperands()-1).getImm(),
51                       ShuffleMask);
52     Src1Name = getRegName(MI->getOperand(1).getReg());
53     DestName = getRegName(MI->getOperand(0).getReg());
54     break;
55   case X86::VBLENDPDYrri:
56     Src2Name = getRegName(MI->getOperand(2).getReg());
57     // FALL THROUGH.
58   case X86::VBLENDPDYrmi:
59     if(MI->getOperand(MI->getNumOperands()-1).isImm())
60       DecodeBLENDMask(MVT::v4f64,
61                       MI->getOperand(MI->getNumOperands()-1).getImm(),
62                       ShuffleMask);
63     Src1Name = getRegName(MI->getOperand(1).getReg());
64     DestName = getRegName(MI->getOperand(0).getReg());
65     break;
66 
67   case X86::BLENDPSrri:
68   case X86::VBLENDPSrri:
69     Src2Name = getRegName(MI->getOperand(2).getReg());
70     // FALL THROUGH.
71   case X86::BLENDPSrmi:
72   case X86::VBLENDPSrmi:
73     if(MI->getOperand(MI->getNumOperands()-1).isImm())
74       DecodeBLENDMask(MVT::v4f32,
75                       MI->getOperand(MI->getNumOperands()-1).getImm(),
76                       ShuffleMask);
77     Src1Name = getRegName(MI->getOperand(1).getReg());
78     DestName = getRegName(MI->getOperand(0).getReg());
79     break;
80   case X86::VBLENDPSYrri:
81     Src2Name = getRegName(MI->getOperand(2).getReg());
82     // FALL THROUGH.
83   case X86::VBLENDPSYrmi:
84     if(MI->getOperand(MI->getNumOperands()-1).isImm())
85       DecodeBLENDMask(MVT::v8f32,
86                       MI->getOperand(MI->getNumOperands()-1).getImm(),
87                       ShuffleMask);
88     Src1Name = getRegName(MI->getOperand(1).getReg());
89     DestName = getRegName(MI->getOperand(0).getReg());
90     break;
91 
92   case X86::PBLENDWrri:
93   case X86::VPBLENDWrri:
94     Src2Name = getRegName(MI->getOperand(2).getReg());
95     // FALL THROUGH.
96   case X86::PBLENDWrmi:
97   case X86::VPBLENDWrmi:
98     if(MI->getOperand(MI->getNumOperands()-1).isImm())
99       DecodeBLENDMask(MVT::v8i16,
100                       MI->getOperand(MI->getNumOperands()-1).getImm(),
101                       ShuffleMask);
102     Src1Name = getRegName(MI->getOperand(1).getReg());
103     DestName = getRegName(MI->getOperand(0).getReg());
104     break;
105   case X86::VPBLENDWYrri:
106     Src2Name = getRegName(MI->getOperand(2).getReg());
107     // FALL THROUGH.
108   case X86::VPBLENDWYrmi:
109     if(MI->getOperand(MI->getNumOperands()-1).isImm())
110       DecodeBLENDMask(MVT::v16i16,
111                       MI->getOperand(MI->getNumOperands()-1).getImm(),
112                       ShuffleMask);
113     Src1Name = getRegName(MI->getOperand(1).getReg());
114     DestName = getRegName(MI->getOperand(0).getReg());
115     break;
116 
117   case X86::VPBLENDDrri:
118     Src2Name = getRegName(MI->getOperand(2).getReg());
119     // FALL THROUGH.
120   case X86::VPBLENDDrmi:
121     if(MI->getOperand(MI->getNumOperands()-1).isImm())
122       DecodeBLENDMask(MVT::v4i32,
123                       MI->getOperand(MI->getNumOperands()-1).getImm(),
124                       ShuffleMask);
125     Src1Name = getRegName(MI->getOperand(1).getReg());
126     DestName = getRegName(MI->getOperand(0).getReg());
127     break;
128 
129   case X86::VPBLENDDYrri:
130     Src2Name = getRegName(MI->getOperand(2).getReg());
131     // FALL THROUGH.
132   case X86::VPBLENDDYrmi:
133     if(MI->getOperand(MI->getNumOperands()-1).isImm())
134       DecodeBLENDMask(MVT::v8i32,
135                       MI->getOperand(MI->getNumOperands()-1).getImm(),
136                       ShuffleMask);
137     Src1Name = getRegName(MI->getOperand(1).getReg());
138     DestName = getRegName(MI->getOperand(0).getReg());
139     break;
140 
141   case X86::INSERTPSrr:
142   case X86::VINSERTPSrr:
143     Src2Name = getRegName(MI->getOperand(2).getReg());
144     // FALL THROUGH.
145   case X86::INSERTPSrm:
146   case X86::VINSERTPSrm:
147     DestName = getRegName(MI->getOperand(0).getReg());
148     Src1Name = getRegName(MI->getOperand(1).getReg());
149     if(MI->getOperand(MI->getNumOperands()-1).isImm())
150       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
151                          ShuffleMask);
152     break;
153 
154   case X86::MOVLHPSrr:
155   case X86::VMOVLHPSrr:
156     Src2Name = getRegName(MI->getOperand(2).getReg());
157     Src1Name = getRegName(MI->getOperand(1).getReg());
158     DestName = getRegName(MI->getOperand(0).getReg());
159     DecodeMOVLHPSMask(2, ShuffleMask);
160     break;
161 
162   case X86::MOVHLPSrr:
163   case X86::VMOVHLPSrr:
164     Src2Name = getRegName(MI->getOperand(2).getReg());
165     Src1Name = getRegName(MI->getOperand(1).getReg());
166     DestName = getRegName(MI->getOperand(0).getReg());
167     DecodeMOVHLPSMask(2, ShuffleMask);
168     break;
169 
170   case X86::MOVSLDUPrr:
171   case X86::VMOVSLDUPrr:
172     Src1Name = getRegName(MI->getOperand(1).getReg());
173     // FALL THROUGH.
174   case X86::MOVSLDUPrm:
175   case X86::VMOVSLDUPrm:
176     DestName = getRegName(MI->getOperand(0).getReg());
177     DecodeMOVSLDUPMask(MVT::v4f32, ShuffleMask);
178     break;
179 
180   case X86::VMOVSHDUPYrr:
181     Src1Name = getRegName(MI->getOperand(1).getReg());
182     // FALL THROUGH.
183   case X86::VMOVSHDUPYrm:
184     DestName = getRegName(MI->getOperand(0).getReg());
185     DecodeMOVSHDUPMask(MVT::v8f32, ShuffleMask);
186     break;
187 
188   case X86::VMOVSLDUPYrr:
189     Src1Name = getRegName(MI->getOperand(1).getReg());
190     // FALL THROUGH.
191   case X86::VMOVSLDUPYrm:
192     DestName = getRegName(MI->getOperand(0).getReg());
193     DecodeMOVSLDUPMask(MVT::v8f32, ShuffleMask);
194     break;
195 
196   case X86::MOVSHDUPrr:
197   case X86::VMOVSHDUPrr:
198     Src1Name = getRegName(MI->getOperand(1).getReg());
199     // FALL THROUGH.
200   case X86::MOVSHDUPrm:
201   case X86::VMOVSHDUPrm:
202     DestName = getRegName(MI->getOperand(0).getReg());
203     DecodeMOVSHDUPMask(MVT::v4f32, ShuffleMask);
204     break;
205 
206   case X86::PSLLDQri:
207   case X86::VPSLLDQri:
208     Src1Name = getRegName(MI->getOperand(1).getReg());
209     DestName = getRegName(MI->getOperand(0).getReg());
210     if(MI->getOperand(MI->getNumOperands()-1).isImm())
211       DecodePSLLDQMask(MVT::v16i8,
212                        MI->getOperand(MI->getNumOperands()-1).getImm(),
213                        ShuffleMask);
214     break;
215 
216   case X86::VPSLLDQYri:
217     Src1Name = getRegName(MI->getOperand(1).getReg());
218     DestName = getRegName(MI->getOperand(0).getReg());
219     if(MI->getOperand(MI->getNumOperands()-1).isImm())
220       DecodePSLLDQMask(MVT::v32i8,
221                        MI->getOperand(MI->getNumOperands()-1).getImm(),
222                        ShuffleMask);
223     break;
224 
225   case X86::PSRLDQri:
226   case X86::VPSRLDQri:
227     Src1Name = getRegName(MI->getOperand(1).getReg());
228     DestName = getRegName(MI->getOperand(0).getReg());
229     if(MI->getOperand(MI->getNumOperands()-1).isImm())
230       DecodePSRLDQMask(MVT::v16i8,
231                        MI->getOperand(MI->getNumOperands()-1).getImm(),
232                        ShuffleMask);
233     break;
234 
235   case X86::VPSRLDQYri:
236     Src1Name = getRegName(MI->getOperand(1).getReg());
237     DestName = getRegName(MI->getOperand(0).getReg());
238     if(MI->getOperand(MI->getNumOperands()-1).isImm())
239       DecodePSRLDQMask(MVT::v32i8,
240                        MI->getOperand(MI->getNumOperands()-1).getImm(),
241                        ShuffleMask);
242     break;
243 
244   case X86::PALIGNR128rr:
245   case X86::VPALIGNR128rr:
246     Src1Name = getRegName(MI->getOperand(2).getReg());
247     // FALL THROUGH.
248   case X86::PALIGNR128rm:
249   case X86::VPALIGNR128rm:
250     Src2Name = getRegName(MI->getOperand(1).getReg());
251     DestName = getRegName(MI->getOperand(0).getReg());
252     if(MI->getOperand(MI->getNumOperands()-1).isImm())
253       DecodePALIGNRMask(MVT::v16i8,
254                         MI->getOperand(MI->getNumOperands()-1).getImm(),
255                         ShuffleMask);
256     break;
257   case X86::VPALIGNR256rr:
258     Src1Name = getRegName(MI->getOperand(2).getReg());
259     // FALL THROUGH.
260   case X86::VPALIGNR256rm:
261     Src2Name = getRegName(MI->getOperand(1).getReg());
262     DestName = getRegName(MI->getOperand(0).getReg());
263     if(MI->getOperand(MI->getNumOperands()-1).isImm())
264       DecodePALIGNRMask(MVT::v32i8,
265                         MI->getOperand(MI->getNumOperands()-1).getImm(),
266                         ShuffleMask);
267     break;
268 
269   case X86::PSHUFDri:
270   case X86::VPSHUFDri:
271     Src1Name = getRegName(MI->getOperand(1).getReg());
272     // FALL THROUGH.
273   case X86::PSHUFDmi:
274   case X86::VPSHUFDmi:
275     DestName = getRegName(MI->getOperand(0).getReg());
276     if(MI->getOperand(MI->getNumOperands()-1).isImm())
277       DecodePSHUFMask(MVT::v4i32,
278                       MI->getOperand(MI->getNumOperands()-1).getImm(),
279                       ShuffleMask);
280     break;
281   case X86::VPSHUFDYri:
282     Src1Name = getRegName(MI->getOperand(1).getReg());
283     // FALL THROUGH.
284   case X86::VPSHUFDYmi:
285     DestName = getRegName(MI->getOperand(0).getReg());
286     if(MI->getOperand(MI->getNumOperands()-1).isImm())
287       DecodePSHUFMask(MVT::v8i32,
288                       MI->getOperand(MI->getNumOperands()-1).getImm(),
289                       ShuffleMask);
290     break;
291 
292 
293   case X86::PSHUFHWri:
294   case X86::VPSHUFHWri:
295     Src1Name = getRegName(MI->getOperand(1).getReg());
296     // FALL THROUGH.
297   case X86::PSHUFHWmi:
298   case X86::VPSHUFHWmi:
299     DestName = getRegName(MI->getOperand(0).getReg());
300     if(MI->getOperand(MI->getNumOperands()-1).isImm())
301       DecodePSHUFHWMask(MVT::v8i16,
302                         MI->getOperand(MI->getNumOperands()-1).getImm(),
303                         ShuffleMask);
304     break;
305   case X86::VPSHUFHWYri:
306     Src1Name = getRegName(MI->getOperand(1).getReg());
307     // FALL THROUGH.
308   case X86::VPSHUFHWYmi:
309     DestName = getRegName(MI->getOperand(0).getReg());
310     if(MI->getOperand(MI->getNumOperands()-1).isImm())
311       DecodePSHUFHWMask(MVT::v16i16,
312                         MI->getOperand(MI->getNumOperands()-1).getImm(),
313                         ShuffleMask);
314     break;
315   case X86::PSHUFLWri:
316   case X86::VPSHUFLWri:
317     Src1Name = getRegName(MI->getOperand(1).getReg());
318     // FALL THROUGH.
319   case X86::PSHUFLWmi:
320   case X86::VPSHUFLWmi:
321     DestName = getRegName(MI->getOperand(0).getReg());
322     if(MI->getOperand(MI->getNumOperands()-1).isImm())
323       DecodePSHUFLWMask(MVT::v8i16,
324                         MI->getOperand(MI->getNumOperands()-1).getImm(),
325                         ShuffleMask);
326     break;
327   case X86::VPSHUFLWYri:
328     Src1Name = getRegName(MI->getOperand(1).getReg());
329     // FALL THROUGH.
330   case X86::VPSHUFLWYmi:
331     DestName = getRegName(MI->getOperand(0).getReg());
332     if(MI->getOperand(MI->getNumOperands()-1).isImm())
333       DecodePSHUFLWMask(MVT::v16i16,
334                         MI->getOperand(MI->getNumOperands()-1).getImm(),
335                         ShuffleMask);
336     break;
337 
338   case X86::PUNPCKHBWrr:
339   case X86::VPUNPCKHBWrr:
340     Src2Name = getRegName(MI->getOperand(2).getReg());
341     // FALL THROUGH.
342   case X86::PUNPCKHBWrm:
343   case X86::VPUNPCKHBWrm:
344     Src1Name = getRegName(MI->getOperand(1).getReg());
345     DestName = getRegName(MI->getOperand(0).getReg());
346     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
347     break;
348   case X86::VPUNPCKHBWYrr:
349     Src2Name = getRegName(MI->getOperand(2).getReg());
350     // FALL THROUGH.
351   case X86::VPUNPCKHBWYrm:
352     Src1Name = getRegName(MI->getOperand(1).getReg());
353     DestName = getRegName(MI->getOperand(0).getReg());
354     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
355     break;
356   case X86::PUNPCKHWDrr:
357   case X86::VPUNPCKHWDrr:
358     Src2Name = getRegName(MI->getOperand(2).getReg());
359     // FALL THROUGH.
360   case X86::PUNPCKHWDrm:
361   case X86::VPUNPCKHWDrm:
362     Src1Name = getRegName(MI->getOperand(1).getReg());
363     DestName = getRegName(MI->getOperand(0).getReg());
364     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
365     break;
366   case X86::VPUNPCKHWDYrr:
367     Src2Name = getRegName(MI->getOperand(2).getReg());
368     // FALL THROUGH.
369   case X86::VPUNPCKHWDYrm:
370     Src1Name = getRegName(MI->getOperand(1).getReg());
371     DestName = getRegName(MI->getOperand(0).getReg());
372     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
373     break;
374   case X86::PUNPCKHDQrr:
375   case X86::VPUNPCKHDQrr:
376     Src2Name = getRegName(MI->getOperand(2).getReg());
377     // FALL THROUGH.
378   case X86::PUNPCKHDQrm:
379   case X86::VPUNPCKHDQrm:
380     Src1Name = getRegName(MI->getOperand(1).getReg());
381     DestName = getRegName(MI->getOperand(0).getReg());
382     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
383     break;
384   case X86::VPUNPCKHDQYrr:
385     Src2Name = getRegName(MI->getOperand(2).getReg());
386     // FALL THROUGH.
387   case X86::VPUNPCKHDQYrm:
388     Src1Name = getRegName(MI->getOperand(1).getReg());
389     DestName = getRegName(MI->getOperand(0).getReg());
390     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
391     break;
392   case X86::VPUNPCKHDQZrr:
393     Src2Name = getRegName(MI->getOperand(2).getReg());
394     // FALL THROUGH.
395   case X86::VPUNPCKHDQZrm:
396     Src1Name = getRegName(MI->getOperand(1).getReg());
397     DestName = getRegName(MI->getOperand(0).getReg());
398     DecodeUNPCKHMask(MVT::v16i32, ShuffleMask);
399     break;
400   case X86::PUNPCKHQDQrr:
401   case X86::VPUNPCKHQDQrr:
402     Src2Name = getRegName(MI->getOperand(2).getReg());
403     // FALL THROUGH.
404   case X86::PUNPCKHQDQrm:
405   case X86::VPUNPCKHQDQrm:
406     Src1Name = getRegName(MI->getOperand(1).getReg());
407     DestName = getRegName(MI->getOperand(0).getReg());
408     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
409     break;
410   case X86::VPUNPCKHQDQYrr:
411     Src2Name = getRegName(MI->getOperand(2).getReg());
412     // FALL THROUGH.
413   case X86::VPUNPCKHQDQYrm:
414     Src1Name = getRegName(MI->getOperand(1).getReg());
415     DestName = getRegName(MI->getOperand(0).getReg());
416     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
417     break;
418   case X86::VPUNPCKHQDQZrr:
419     Src2Name = getRegName(MI->getOperand(2).getReg());
420     // FALL THROUGH.
421   case X86::VPUNPCKHQDQZrm:
422     Src1Name = getRegName(MI->getOperand(1).getReg());
423     DestName = getRegName(MI->getOperand(0).getReg());
424     DecodeUNPCKHMask(MVT::v8i64, ShuffleMask);
425     break;
426 
427   case X86::PUNPCKLBWrr:
428   case X86::VPUNPCKLBWrr:
429     Src2Name = getRegName(MI->getOperand(2).getReg());
430     // FALL THROUGH.
431   case X86::PUNPCKLBWrm:
432   case X86::VPUNPCKLBWrm:
433     Src1Name = getRegName(MI->getOperand(1).getReg());
434     DestName = getRegName(MI->getOperand(0).getReg());
435     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
436     break;
437   case X86::VPUNPCKLBWYrr:
438     Src2Name = getRegName(MI->getOperand(2).getReg());
439     // FALL THROUGH.
440   case X86::VPUNPCKLBWYrm:
441     Src1Name = getRegName(MI->getOperand(1).getReg());
442     DestName = getRegName(MI->getOperand(0).getReg());
443     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
444     break;
445   case X86::PUNPCKLWDrr:
446   case X86::VPUNPCKLWDrr:
447     Src2Name = getRegName(MI->getOperand(2).getReg());
448     // FALL THROUGH.
449   case X86::PUNPCKLWDrm:
450   case X86::VPUNPCKLWDrm:
451     Src1Name = getRegName(MI->getOperand(1).getReg());
452     DestName = getRegName(MI->getOperand(0).getReg());
453     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
454     break;
455   case X86::VPUNPCKLWDYrr:
456     Src2Name = getRegName(MI->getOperand(2).getReg());
457     // FALL THROUGH.
458   case X86::VPUNPCKLWDYrm:
459     Src1Name = getRegName(MI->getOperand(1).getReg());
460     DestName = getRegName(MI->getOperand(0).getReg());
461     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
462     break;
463   case X86::PUNPCKLDQrr:
464   case X86::VPUNPCKLDQrr:
465     Src2Name = getRegName(MI->getOperand(2).getReg());
466     // FALL THROUGH.
467   case X86::PUNPCKLDQrm:
468   case X86::VPUNPCKLDQrm:
469     Src1Name = getRegName(MI->getOperand(1).getReg());
470     DestName = getRegName(MI->getOperand(0).getReg());
471     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
472     break;
473   case X86::VPUNPCKLDQYrr:
474     Src2Name = getRegName(MI->getOperand(2).getReg());
475     // FALL THROUGH.
476   case X86::VPUNPCKLDQYrm:
477     Src1Name = getRegName(MI->getOperand(1).getReg());
478     DestName = getRegName(MI->getOperand(0).getReg());
479     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
480     break;
481   case X86::VPUNPCKLDQZrr:
482     Src2Name = getRegName(MI->getOperand(2).getReg());
483     // FALL THROUGH.
484   case X86::VPUNPCKLDQZrm:
485     Src1Name = getRegName(MI->getOperand(1).getReg());
486     DestName = getRegName(MI->getOperand(0).getReg());
487     DecodeUNPCKLMask(MVT::v16i32, ShuffleMask);
488     break;
489   case X86::PUNPCKLQDQrr:
490   case X86::VPUNPCKLQDQrr:
491     Src2Name = getRegName(MI->getOperand(2).getReg());
492     // FALL THROUGH.
493   case X86::PUNPCKLQDQrm:
494   case X86::VPUNPCKLQDQrm:
495     Src1Name = getRegName(MI->getOperand(1).getReg());
496     DestName = getRegName(MI->getOperand(0).getReg());
497     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
498     break;
499   case X86::VPUNPCKLQDQYrr:
500     Src2Name = getRegName(MI->getOperand(2).getReg());
501     // FALL THROUGH.
502   case X86::VPUNPCKLQDQYrm:
503     Src1Name = getRegName(MI->getOperand(1).getReg());
504     DestName = getRegName(MI->getOperand(0).getReg());
505     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
506     break;
507   case X86::VPUNPCKLQDQZrr:
508     Src2Name = getRegName(MI->getOperand(2).getReg());
509     // FALL THROUGH.
510   case X86::VPUNPCKLQDQZrm:
511     Src1Name = getRegName(MI->getOperand(1).getReg());
512     DestName = getRegName(MI->getOperand(0).getReg());
513     DecodeUNPCKLMask(MVT::v8i64, ShuffleMask);
514     break;
515 
516   case X86::SHUFPDrri:
517   case X86::VSHUFPDrri:
518     Src2Name = getRegName(MI->getOperand(2).getReg());
519     // FALL THROUGH.
520   case X86::SHUFPDrmi:
521   case X86::VSHUFPDrmi:
522     if(MI->getOperand(MI->getNumOperands()-1).isImm())
523       DecodeSHUFPMask(MVT::v2f64,
524                       MI->getOperand(MI->getNumOperands()-1).getImm(),
525                       ShuffleMask);
526     Src1Name = getRegName(MI->getOperand(1).getReg());
527     DestName = getRegName(MI->getOperand(0).getReg());
528     break;
529   case X86::VSHUFPDYrri:
530     Src2Name = getRegName(MI->getOperand(2).getReg());
531     // FALL THROUGH.
532   case X86::VSHUFPDYrmi:
533     if(MI->getOperand(MI->getNumOperands()-1).isImm())
534       DecodeSHUFPMask(MVT::v4f64,
535                       MI->getOperand(MI->getNumOperands()-1).getImm(),
536                       ShuffleMask);
537     Src1Name = getRegName(MI->getOperand(1).getReg());
538     DestName = getRegName(MI->getOperand(0).getReg());
539     break;
540 
541   case X86::SHUFPSrri:
542   case X86::VSHUFPSrri:
543     Src2Name = getRegName(MI->getOperand(2).getReg());
544     // FALL THROUGH.
545   case X86::SHUFPSrmi:
546   case X86::VSHUFPSrmi:
547     if(MI->getOperand(MI->getNumOperands()-1).isImm())
548       DecodeSHUFPMask(MVT::v4f32,
549                       MI->getOperand(MI->getNumOperands()-1).getImm(),
550                       ShuffleMask);
551     Src1Name = getRegName(MI->getOperand(1).getReg());
552     DestName = getRegName(MI->getOperand(0).getReg());
553     break;
554   case X86::VSHUFPSYrri:
555     Src2Name = getRegName(MI->getOperand(2).getReg());
556     // FALL THROUGH.
557   case X86::VSHUFPSYrmi:
558     if(MI->getOperand(MI->getNumOperands()-1).isImm())
559       DecodeSHUFPMask(MVT::v8f32,
560                       MI->getOperand(MI->getNumOperands()-1).getImm(),
561                       ShuffleMask);
562     Src1Name = getRegName(MI->getOperand(1).getReg());
563     DestName = getRegName(MI->getOperand(0).getReg());
564     break;
565 
566   case X86::UNPCKLPDrr:
567   case X86::VUNPCKLPDrr:
568     Src2Name = getRegName(MI->getOperand(2).getReg());
569     // FALL THROUGH.
570   case X86::UNPCKLPDrm:
571   case X86::VUNPCKLPDrm:
572     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
573     Src1Name = getRegName(MI->getOperand(1).getReg());
574     DestName = getRegName(MI->getOperand(0).getReg());
575     break;
576   case X86::VUNPCKLPDYrr:
577     Src2Name = getRegName(MI->getOperand(2).getReg());
578     // FALL THROUGH.
579   case X86::VUNPCKLPDYrm:
580     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
581     Src1Name = getRegName(MI->getOperand(1).getReg());
582     DestName = getRegName(MI->getOperand(0).getReg());
583     break;
584   case X86::VUNPCKLPDZrr:
585     Src2Name = getRegName(MI->getOperand(2).getReg());
586     // FALL THROUGH.
587   case X86::VUNPCKLPDZrm:
588     DecodeUNPCKLMask(MVT::v8f64, ShuffleMask);
589     Src1Name = getRegName(MI->getOperand(1).getReg());
590     DestName = getRegName(MI->getOperand(0).getReg());
591     break;
592   case X86::UNPCKLPSrr:
593   case X86::VUNPCKLPSrr:
594     Src2Name = getRegName(MI->getOperand(2).getReg());
595     // FALL THROUGH.
596   case X86::UNPCKLPSrm:
597   case X86::VUNPCKLPSrm:
598     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
599     Src1Name = getRegName(MI->getOperand(1).getReg());
600     DestName = getRegName(MI->getOperand(0).getReg());
601     break;
602   case X86::VUNPCKLPSYrr:
603     Src2Name = getRegName(MI->getOperand(2).getReg());
604     // FALL THROUGH.
605   case X86::VUNPCKLPSYrm:
606     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
607     Src1Name = getRegName(MI->getOperand(1).getReg());
608     DestName = getRegName(MI->getOperand(0).getReg());
609     break;
610   case X86::VUNPCKLPSZrr:
611     Src2Name = getRegName(MI->getOperand(2).getReg());
612     // FALL THROUGH.
613   case X86::VUNPCKLPSZrm:
614     DecodeUNPCKLMask(MVT::v16f32, ShuffleMask);
615     Src1Name = getRegName(MI->getOperand(1).getReg());
616     DestName = getRegName(MI->getOperand(0).getReg());
617     break;
618   case X86::UNPCKHPDrr:
619   case X86::VUNPCKHPDrr:
620     Src2Name = getRegName(MI->getOperand(2).getReg());
621     // FALL THROUGH.
622   case X86::UNPCKHPDrm:
623   case X86::VUNPCKHPDrm:
624     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
625     Src1Name = getRegName(MI->getOperand(1).getReg());
626     DestName = getRegName(MI->getOperand(0).getReg());
627     break;
628   case X86::VUNPCKHPDYrr:
629     Src2Name = getRegName(MI->getOperand(2).getReg());
630     // FALL THROUGH.
631   case X86::VUNPCKHPDYrm:
632     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
633     Src1Name = getRegName(MI->getOperand(1).getReg());
634     DestName = getRegName(MI->getOperand(0).getReg());
635     break;
636   case X86::VUNPCKHPDZrr:
637     Src2Name = getRegName(MI->getOperand(2).getReg());
638     // FALL THROUGH.
639   case X86::VUNPCKHPDZrm:
640     DecodeUNPCKHMask(MVT::v8f64, ShuffleMask);
641     Src1Name = getRegName(MI->getOperand(1).getReg());
642     DestName = getRegName(MI->getOperand(0).getReg());
643     break;
644   case X86::UNPCKHPSrr:
645   case X86::VUNPCKHPSrr:
646     Src2Name = getRegName(MI->getOperand(2).getReg());
647     // FALL THROUGH.
648   case X86::UNPCKHPSrm:
649   case X86::VUNPCKHPSrm:
650     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
651     Src1Name = getRegName(MI->getOperand(1).getReg());
652     DestName = getRegName(MI->getOperand(0).getReg());
653     break;
654   case X86::VUNPCKHPSYrr:
655     Src2Name = getRegName(MI->getOperand(2).getReg());
656     // FALL THROUGH.
657   case X86::VUNPCKHPSYrm:
658     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
659     Src1Name = getRegName(MI->getOperand(1).getReg());
660     DestName = getRegName(MI->getOperand(0).getReg());
661     break;
662   case X86::VUNPCKHPSZrr:
663     Src2Name = getRegName(MI->getOperand(2).getReg());
664     // FALL THROUGH.
665   case X86::VUNPCKHPSZrm:
666     DecodeUNPCKHMask(MVT::v16f32, ShuffleMask);
667     Src1Name = getRegName(MI->getOperand(1).getReg());
668     DestName = getRegName(MI->getOperand(0).getReg());
669     break;
670   case X86::VPERMILPSri:
671     Src1Name = getRegName(MI->getOperand(1).getReg());
672     // FALL THROUGH.
673   case X86::VPERMILPSmi:
674     if(MI->getOperand(MI->getNumOperands()-1).isImm())
675       DecodePSHUFMask(MVT::v4f32,
676                       MI->getOperand(MI->getNumOperands()-1).getImm(),
677                       ShuffleMask);
678     DestName = getRegName(MI->getOperand(0).getReg());
679     break;
680   case X86::VPERMILPSYri:
681     Src1Name = getRegName(MI->getOperand(1).getReg());
682     // FALL THROUGH.
683   case X86::VPERMILPSYmi:
684     if(MI->getOperand(MI->getNumOperands()-1).isImm())
685       DecodePSHUFMask(MVT::v8f32,
686                       MI->getOperand(MI->getNumOperands()-1).getImm(),
687                       ShuffleMask);
688     DestName = getRegName(MI->getOperand(0).getReg());
689     break;
690   case X86::VPERMILPDri:
691     Src1Name = getRegName(MI->getOperand(1).getReg());
692     // FALL THROUGH.
693   case X86::VPERMILPDmi:
694     if(MI->getOperand(MI->getNumOperands()-1).isImm())
695       DecodePSHUFMask(MVT::v2f64,
696                       MI->getOperand(MI->getNumOperands()-1).getImm(),
697                       ShuffleMask);
698     DestName = getRegName(MI->getOperand(0).getReg());
699     break;
700   case X86::VPERMILPDYri:
701     Src1Name = getRegName(MI->getOperand(1).getReg());
702     // FALL THROUGH.
703   case X86::VPERMILPDYmi:
704     if(MI->getOperand(MI->getNumOperands()-1).isImm())
705       DecodePSHUFMask(MVT::v4f64,
706                       MI->getOperand(MI->getNumOperands()-1).getImm(),
707                       ShuffleMask);
708     DestName = getRegName(MI->getOperand(0).getReg());
709     break;
710   case X86::VPERM2F128rr:
711   case X86::VPERM2I128rr:
712     Src2Name = getRegName(MI->getOperand(2).getReg());
713     // FALL THROUGH.
714   case X86::VPERM2F128rm:
715   case X86::VPERM2I128rm:
716     // For instruction comments purpose, assume the 256-bit vector is v4i64.
717     if(MI->getOperand(MI->getNumOperands()-1).isImm())
718       DecodeVPERM2X128Mask(MVT::v4i64,
719                            MI->getOperand(MI->getNumOperands()-1).getImm(),
720                            ShuffleMask);
721     Src1Name = getRegName(MI->getOperand(1).getReg());
722     DestName = getRegName(MI->getOperand(0).getReg());
723     break;
724   case X86::VPERMQYri:
725   case X86::VPERMPDYri:
726     Src1Name = getRegName(MI->getOperand(1).getReg());
727     // FALL THROUGH.
728   case X86::VPERMQYmi:
729   case X86::VPERMPDYmi:
730     if(MI->getOperand(MI->getNumOperands()-1).isImm())
731       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
732                       ShuffleMask);
733     DestName = getRegName(MI->getOperand(0).getReg());
734     break;
735   }
736 
737   // The only comments we decode are shuffles, so give up if we were unable to
738   // decode a shuffle mask.
739   if (ShuffleMask.empty())
740     return false;
741 
742   if (!DestName) DestName = Src1Name;
743   OS << (DestName ? DestName : "mem") << " = ";
744 
745   // If the two sources are the same, canonicalize the input elements to be
746   // from the first src so that we get larger element spans.
747   if (Src1Name == Src2Name) {
748     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
749       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
750           ShuffleMask[i] >= (int)e)        // From second mask.
751         ShuffleMask[i] -= e;
752     }
753   }
754 
755   // The shuffle mask specifies which elements of the src1/src2 fill in the
756   // destination, with a few sentinel values.  Loop through and print them
757   // out.
758   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
759     if (i != 0)
760       OS << ',';
761     if (ShuffleMask[i] == SM_SentinelZero) {
762       OS << "zero";
763       continue;
764     }
765 
766     // Otherwise, it must come from src1 or src2.  Print the span of elements
767     // that comes from this src.
768     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
769     const char *SrcName = isSrc1 ? Src1Name : Src2Name;
770     OS << (SrcName ? SrcName : "mem") << '[';
771     bool IsFirst = true;
772     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
773            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
774       if (!IsFirst)
775         OS << ',';
776       else
777         IsFirst = false;
778       if (ShuffleMask[i] == SM_SentinelUndef)
779         OS << "u";
780       else
781         OS << ShuffleMask[i] % ShuffleMask.size();
782       ++i;
783     }
784     OS << ']';
785     --i;  // For loop increments element #.
786   }
787   //MI->print(OS, 0);
788   OS << "\n";
789 
790   // We successfully added a comment to this instruction.
791   return true;
792 }
793