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/Support/raw_ostream.h"
20using namespace llvm;
21
22//===----------------------------------------------------------------------===//
23// Top Level Entrypoint
24//===----------------------------------------------------------------------===//
25
26/// EmitAnyX86InstComments - This function decodes x86 instructions and prints
27/// newline terminated strings to the specified string if desired.  This
28/// information is shown in disassembly dumps when verbose assembly is enabled.
29void llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,
30                                  const char *(*getRegName)(unsigned)) {
31  // If this is a shuffle operation, the switch should fill in this state.
32  SmallVector<int, 8> ShuffleMask;
33  const char *DestName = 0, *Src1Name = 0, *Src2Name = 0;
34
35  switch (MI->getOpcode()) {
36  case X86::INSERTPSrr:
37    Src1Name = getRegName(MI->getOperand(0).getReg());
38    Src2Name = getRegName(MI->getOperand(2).getReg());
39    DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
40    break;
41  case X86::VINSERTPSrr:
42    DestName = getRegName(MI->getOperand(0).getReg());
43    Src1Name = getRegName(MI->getOperand(1).getReg());
44    Src2Name = getRegName(MI->getOperand(2).getReg());
45    DecodeINSERTPSMask(MI->getOperand(3).getImm(), ShuffleMask);
46    break;
47
48  case X86::MOVLHPSrr:
49    Src2Name = getRegName(MI->getOperand(2).getReg());
50    Src1Name = getRegName(MI->getOperand(0).getReg());
51    DecodeMOVLHPSMask(2, ShuffleMask);
52    break;
53  case X86::VMOVLHPSrr:
54    Src2Name = getRegName(MI->getOperand(2).getReg());
55    Src1Name = getRegName(MI->getOperand(1).getReg());
56    DestName = getRegName(MI->getOperand(0).getReg());
57    DecodeMOVLHPSMask(2, ShuffleMask);
58    break;
59
60  case X86::MOVHLPSrr:
61    Src2Name = getRegName(MI->getOperand(2).getReg());
62    Src1Name = getRegName(MI->getOperand(0).getReg());
63    DecodeMOVHLPSMask(2, ShuffleMask);
64    break;
65  case X86::VMOVHLPSrr:
66    Src2Name = getRegName(MI->getOperand(2).getReg());
67    Src1Name = getRegName(MI->getOperand(1).getReg());
68    DestName = getRegName(MI->getOperand(0).getReg());
69    DecodeMOVHLPSMask(2, ShuffleMask);
70    break;
71
72  case X86::PSHUFDri:
73  case X86::VPSHUFDri:
74    Src1Name = getRegName(MI->getOperand(1).getReg());
75    // FALL THROUGH.
76  case X86::PSHUFDmi:
77  case X86::VPSHUFDmi:
78    DestName = getRegName(MI->getOperand(0).getReg());
79    DecodePSHUFMask(MVT::v4i32, MI->getOperand(MI->getNumOperands()-1).getImm(),
80                     ShuffleMask);
81    break;
82  case X86::VPSHUFDYri:
83    Src1Name = getRegName(MI->getOperand(1).getReg());
84    // FALL THROUGH.
85  case X86::VPSHUFDYmi:
86    DestName = getRegName(MI->getOperand(0).getReg());
87    DecodePSHUFMask(MVT::v8i32, MI->getOperand(MI->getNumOperands()-1).getImm(),
88                    ShuffleMask);
89    break;
90
91
92  case X86::PSHUFHWri:
93  case X86::VPSHUFHWri:
94    Src1Name = getRegName(MI->getOperand(1).getReg());
95    // FALL THROUGH.
96  case X86::PSHUFHWmi:
97  case X86::VPSHUFHWmi:
98    DestName = getRegName(MI->getOperand(0).getReg());
99    DecodePSHUFHWMask(MVT::v8i16,
100                      MI->getOperand(MI->getNumOperands()-1).getImm(),
101                      ShuffleMask);
102    break;
103  case X86::VPSHUFHWYri:
104    Src1Name = getRegName(MI->getOperand(1).getReg());
105    // FALL THROUGH.
106  case X86::VPSHUFHWYmi:
107    DestName = getRegName(MI->getOperand(0).getReg());
108    DecodePSHUFHWMask(MVT::v16i16,
109                      MI->getOperand(MI->getNumOperands()-1).getImm(),
110                      ShuffleMask);
111    break;
112  case X86::PSHUFLWri:
113  case X86::VPSHUFLWri:
114    Src1Name = getRegName(MI->getOperand(1).getReg());
115    // FALL THROUGH.
116  case X86::PSHUFLWmi:
117  case X86::VPSHUFLWmi:
118    DestName = getRegName(MI->getOperand(0).getReg());
119    DecodePSHUFLWMask(MVT::v8i16,
120                      MI->getOperand(MI->getNumOperands()-1).getImm(),
121                      ShuffleMask);
122    break;
123  case X86::VPSHUFLWYri:
124    Src1Name = getRegName(MI->getOperand(1).getReg());
125    // FALL THROUGH.
126  case X86::VPSHUFLWYmi:
127    DestName = getRegName(MI->getOperand(0).getReg());
128    DecodePSHUFLWMask(MVT::v16i16,
129                      MI->getOperand(MI->getNumOperands()-1).getImm(),
130                      ShuffleMask);
131    break;
132
133  case X86::PUNPCKHBWrr:
134    Src2Name = getRegName(MI->getOperand(2).getReg());
135    // FALL THROUGH.
136  case X86::PUNPCKHBWrm:
137    Src1Name = getRegName(MI->getOperand(0).getReg());
138    DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
139    break;
140  case X86::VPUNPCKHBWrr:
141    Src2Name = getRegName(MI->getOperand(2).getReg());
142    // FALL THROUGH.
143  case X86::VPUNPCKHBWrm:
144    Src1Name = getRegName(MI->getOperand(1).getReg());
145    DestName = getRegName(MI->getOperand(0).getReg());
146    DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);
147    break;
148  case X86::VPUNPCKHBWYrr:
149    Src2Name = getRegName(MI->getOperand(2).getReg());
150    // FALL THROUGH.
151  case X86::VPUNPCKHBWYrm:
152    Src1Name = getRegName(MI->getOperand(1).getReg());
153    DestName = getRegName(MI->getOperand(0).getReg());
154    DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);
155    break;
156  case X86::PUNPCKHWDrr:
157    Src2Name = getRegName(MI->getOperand(2).getReg());
158    // FALL THROUGH.
159  case X86::PUNPCKHWDrm:
160    Src1Name = getRegName(MI->getOperand(0).getReg());
161    DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
162    break;
163  case X86::VPUNPCKHWDrr:
164    Src2Name = getRegName(MI->getOperand(2).getReg());
165    // FALL THROUGH.
166  case X86::VPUNPCKHWDrm:
167    Src1Name = getRegName(MI->getOperand(1).getReg());
168    DestName = getRegName(MI->getOperand(0).getReg());
169    DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);
170    break;
171  case X86::VPUNPCKHWDYrr:
172    Src2Name = getRegName(MI->getOperand(2).getReg());
173    // FALL THROUGH.
174  case X86::VPUNPCKHWDYrm:
175    Src1Name = getRegName(MI->getOperand(1).getReg());
176    DestName = getRegName(MI->getOperand(0).getReg());
177    DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);
178    break;
179  case X86::PUNPCKHDQrr:
180    Src2Name = getRegName(MI->getOperand(2).getReg());
181    // FALL THROUGH.
182  case X86::PUNPCKHDQrm:
183    Src1Name = getRegName(MI->getOperand(0).getReg());
184    DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
185    break;
186  case X86::VPUNPCKHDQrr:
187    Src2Name = getRegName(MI->getOperand(2).getReg());
188    // FALL THROUGH.
189  case X86::VPUNPCKHDQrm:
190    Src1Name = getRegName(MI->getOperand(1).getReg());
191    DestName = getRegName(MI->getOperand(0).getReg());
192    DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);
193    break;
194  case X86::VPUNPCKHDQYrr:
195    Src2Name = getRegName(MI->getOperand(2).getReg());
196    // FALL THROUGH.
197  case X86::VPUNPCKHDQYrm:
198    Src1Name = getRegName(MI->getOperand(1).getReg());
199    DestName = getRegName(MI->getOperand(0).getReg());
200    DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);
201    break;
202  case X86::PUNPCKHQDQrr:
203    Src2Name = getRegName(MI->getOperand(2).getReg());
204    // FALL THROUGH.
205  case X86::PUNPCKHQDQrm:
206    Src1Name = getRegName(MI->getOperand(0).getReg());
207    DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
208    break;
209  case X86::VPUNPCKHQDQrr:
210    Src2Name = getRegName(MI->getOperand(2).getReg());
211    // FALL THROUGH.
212  case X86::VPUNPCKHQDQrm:
213    Src1Name = getRegName(MI->getOperand(1).getReg());
214    DestName = getRegName(MI->getOperand(0).getReg());
215    DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);
216    break;
217  case X86::VPUNPCKHQDQYrr:
218    Src2Name = getRegName(MI->getOperand(2).getReg());
219    // FALL THROUGH.
220  case X86::VPUNPCKHQDQYrm:
221    Src1Name = getRegName(MI->getOperand(1).getReg());
222    DestName = getRegName(MI->getOperand(0).getReg());
223    DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);
224    break;
225
226  case X86::PUNPCKLBWrr:
227    Src2Name = getRegName(MI->getOperand(2).getReg());
228    // FALL THROUGH.
229  case X86::PUNPCKLBWrm:
230    Src1Name = getRegName(MI->getOperand(0).getReg());
231    DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
232    break;
233  case X86::VPUNPCKLBWrr:
234    Src2Name = getRegName(MI->getOperand(2).getReg());
235    // FALL THROUGH.
236  case X86::VPUNPCKLBWrm:
237    Src1Name = getRegName(MI->getOperand(1).getReg());
238    DestName = getRegName(MI->getOperand(0).getReg());
239    DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);
240    break;
241  case X86::VPUNPCKLBWYrr:
242    Src2Name = getRegName(MI->getOperand(2).getReg());
243    // FALL THROUGH.
244  case X86::VPUNPCKLBWYrm:
245    Src1Name = getRegName(MI->getOperand(1).getReg());
246    DestName = getRegName(MI->getOperand(0).getReg());
247    DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);
248    break;
249  case X86::PUNPCKLWDrr:
250    Src2Name = getRegName(MI->getOperand(2).getReg());
251    // FALL THROUGH.
252  case X86::PUNPCKLWDrm:
253    Src1Name = getRegName(MI->getOperand(0).getReg());
254    DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
255    break;
256  case X86::VPUNPCKLWDrr:
257    Src2Name = getRegName(MI->getOperand(2).getReg());
258    // FALL THROUGH.
259  case X86::VPUNPCKLWDrm:
260    Src1Name = getRegName(MI->getOperand(1).getReg());
261    DestName = getRegName(MI->getOperand(0).getReg());
262    DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);
263    break;
264  case X86::VPUNPCKLWDYrr:
265    Src2Name = getRegName(MI->getOperand(2).getReg());
266    // FALL THROUGH.
267  case X86::VPUNPCKLWDYrm:
268    Src1Name = getRegName(MI->getOperand(1).getReg());
269    DestName = getRegName(MI->getOperand(0).getReg());
270    DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);
271    break;
272  case X86::PUNPCKLDQrr:
273    Src2Name = getRegName(MI->getOperand(2).getReg());
274    // FALL THROUGH.
275  case X86::PUNPCKLDQrm:
276    Src1Name = getRegName(MI->getOperand(0).getReg());
277    DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
278    break;
279  case X86::VPUNPCKLDQrr:
280    Src2Name = getRegName(MI->getOperand(2).getReg());
281    // FALL THROUGH.
282  case X86::VPUNPCKLDQrm:
283    Src1Name = getRegName(MI->getOperand(1).getReg());
284    DestName = getRegName(MI->getOperand(0).getReg());
285    DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);
286    break;
287  case X86::VPUNPCKLDQYrr:
288    Src2Name = getRegName(MI->getOperand(2).getReg());
289    // FALL THROUGH.
290  case X86::VPUNPCKLDQYrm:
291    Src1Name = getRegName(MI->getOperand(1).getReg());
292    DestName = getRegName(MI->getOperand(0).getReg());
293    DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);
294    break;
295  case X86::PUNPCKLQDQrr:
296    Src2Name = getRegName(MI->getOperand(2).getReg());
297    // FALL THROUGH.
298  case X86::PUNPCKLQDQrm:
299    Src1Name = getRegName(MI->getOperand(0).getReg());
300    DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
301    break;
302  case X86::VPUNPCKLQDQrr:
303    Src2Name = getRegName(MI->getOperand(2).getReg());
304    // FALL THROUGH.
305  case X86::VPUNPCKLQDQrm:
306    Src1Name = getRegName(MI->getOperand(1).getReg());
307    DestName = getRegName(MI->getOperand(0).getReg());
308    DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);
309    break;
310  case X86::VPUNPCKLQDQYrr:
311    Src2Name = getRegName(MI->getOperand(2).getReg());
312    // FALL THROUGH.
313  case X86::VPUNPCKLQDQYrm:
314    Src1Name = getRegName(MI->getOperand(1).getReg());
315    DestName = getRegName(MI->getOperand(0).getReg());
316    DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);
317    break;
318
319  case X86::SHUFPDrri:
320    Src2Name = getRegName(MI->getOperand(2).getReg());
321    // FALL THROUGH.
322  case X86::SHUFPDrmi:
323    DecodeSHUFPMask(MVT::v2f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
324                    ShuffleMask);
325    Src1Name = getRegName(MI->getOperand(0).getReg());
326    break;
327  case X86::VSHUFPDrri:
328    Src2Name = getRegName(MI->getOperand(2).getReg());
329    // FALL THROUGH.
330  case X86::VSHUFPDrmi:
331    DecodeSHUFPMask(MVT::v2f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
332                    ShuffleMask);
333    Src1Name = getRegName(MI->getOperand(1).getReg());
334    DestName = getRegName(MI->getOperand(0).getReg());
335    break;
336  case X86::VSHUFPDYrri:
337    Src2Name = getRegName(MI->getOperand(2).getReg());
338    // FALL THROUGH.
339  case X86::VSHUFPDYrmi:
340    DecodeSHUFPMask(MVT::v4f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
341                    ShuffleMask);
342    Src1Name = getRegName(MI->getOperand(1).getReg());
343    DestName = getRegName(MI->getOperand(0).getReg());
344    break;
345
346  case X86::SHUFPSrri:
347    Src2Name = getRegName(MI->getOperand(2).getReg());
348    // FALL THROUGH.
349  case X86::SHUFPSrmi:
350    DecodeSHUFPMask(MVT::v4f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
351                    ShuffleMask);
352    Src1Name = getRegName(MI->getOperand(0).getReg());
353    break;
354  case X86::VSHUFPSrri:
355    Src2Name = getRegName(MI->getOperand(2).getReg());
356    // FALL THROUGH.
357  case X86::VSHUFPSrmi:
358    DecodeSHUFPMask(MVT::v4f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
359                    ShuffleMask);
360    Src1Name = getRegName(MI->getOperand(1).getReg());
361    DestName = getRegName(MI->getOperand(0).getReg());
362    break;
363  case X86::VSHUFPSYrri:
364    Src2Name = getRegName(MI->getOperand(2).getReg());
365    // FALL THROUGH.
366  case X86::VSHUFPSYrmi:
367    DecodeSHUFPMask(MVT::v8f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
368                    ShuffleMask);
369    Src1Name = getRegName(MI->getOperand(1).getReg());
370    DestName = getRegName(MI->getOperand(0).getReg());
371    break;
372
373  case X86::UNPCKLPDrr:
374    Src2Name = getRegName(MI->getOperand(2).getReg());
375    // FALL THROUGH.
376  case X86::UNPCKLPDrm:
377    DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
378    Src1Name = getRegName(MI->getOperand(0).getReg());
379    break;
380  case X86::VUNPCKLPDrr:
381    Src2Name = getRegName(MI->getOperand(2).getReg());
382    // FALL THROUGH.
383  case X86::VUNPCKLPDrm:
384    DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);
385    Src1Name = getRegName(MI->getOperand(1).getReg());
386    DestName = getRegName(MI->getOperand(0).getReg());
387    break;
388  case X86::VUNPCKLPDYrr:
389    Src2Name = getRegName(MI->getOperand(2).getReg());
390    // FALL THROUGH.
391  case X86::VUNPCKLPDYrm:
392    DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);
393    Src1Name = getRegName(MI->getOperand(1).getReg());
394    DestName = getRegName(MI->getOperand(0).getReg());
395    break;
396  case X86::UNPCKLPSrr:
397    Src2Name = getRegName(MI->getOperand(2).getReg());
398    // FALL THROUGH.
399  case X86::UNPCKLPSrm:
400    DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
401    Src1Name = getRegName(MI->getOperand(0).getReg());
402    break;
403  case X86::VUNPCKLPSrr:
404    Src2Name = getRegName(MI->getOperand(2).getReg());
405    // FALL THROUGH.
406  case X86::VUNPCKLPSrm:
407    DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);
408    Src1Name = getRegName(MI->getOperand(1).getReg());
409    DestName = getRegName(MI->getOperand(0).getReg());
410    break;
411  case X86::VUNPCKLPSYrr:
412    Src2Name = getRegName(MI->getOperand(2).getReg());
413    // FALL THROUGH.
414  case X86::VUNPCKLPSYrm:
415    DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);
416    Src1Name = getRegName(MI->getOperand(1).getReg());
417    DestName = getRegName(MI->getOperand(0).getReg());
418    break;
419  case X86::UNPCKHPDrr:
420    Src2Name = getRegName(MI->getOperand(2).getReg());
421    // FALL THROUGH.
422  case X86::UNPCKHPDrm:
423    DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
424    Src1Name = getRegName(MI->getOperand(0).getReg());
425    break;
426  case X86::VUNPCKHPDrr:
427    Src2Name = getRegName(MI->getOperand(2).getReg());
428    // FALL THROUGH.
429  case X86::VUNPCKHPDrm:
430    DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);
431    Src1Name = getRegName(MI->getOperand(1).getReg());
432    DestName = getRegName(MI->getOperand(0).getReg());
433    break;
434  case X86::VUNPCKHPDYrr:
435    Src2Name = getRegName(MI->getOperand(2).getReg());
436    // FALL THROUGH.
437  case X86::VUNPCKHPDYrm:
438    DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);
439    Src1Name = getRegName(MI->getOperand(1).getReg());
440    DestName = getRegName(MI->getOperand(0).getReg());
441    break;
442  case X86::UNPCKHPSrr:
443    Src2Name = getRegName(MI->getOperand(2).getReg());
444    // FALL THROUGH.
445  case X86::UNPCKHPSrm:
446    DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
447    Src1Name = getRegName(MI->getOperand(0).getReg());
448    break;
449  case X86::VUNPCKHPSrr:
450    Src2Name = getRegName(MI->getOperand(2).getReg());
451    // FALL THROUGH.
452  case X86::VUNPCKHPSrm:
453    DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);
454    Src1Name = getRegName(MI->getOperand(1).getReg());
455    DestName = getRegName(MI->getOperand(0).getReg());
456    break;
457  case X86::VUNPCKHPSYrr:
458    Src2Name = getRegName(MI->getOperand(2).getReg());
459    // FALL THROUGH.
460  case X86::VUNPCKHPSYrm:
461    DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);
462    Src1Name = getRegName(MI->getOperand(1).getReg());
463    DestName = getRegName(MI->getOperand(0).getReg());
464    break;
465  case X86::VPERMILPSri:
466    Src1Name = getRegName(MI->getOperand(1).getReg());
467    // FALL THROUGH.
468  case X86::VPERMILPSmi:
469    DecodePSHUFMask(MVT::v4f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
470                    ShuffleMask);
471    DestName = getRegName(MI->getOperand(0).getReg());
472    break;
473  case X86::VPERMILPSYri:
474    Src1Name = getRegName(MI->getOperand(1).getReg());
475    // FALL THROUGH.
476  case X86::VPERMILPSYmi:
477    DecodePSHUFMask(MVT::v8f32, MI->getOperand(MI->getNumOperands()-1).getImm(),
478                    ShuffleMask);
479    DestName = getRegName(MI->getOperand(0).getReg());
480    break;
481  case X86::VPERMILPDri:
482    Src1Name = getRegName(MI->getOperand(1).getReg());
483    // FALL THROUGH.
484  case X86::VPERMILPDmi:
485    DecodePSHUFMask(MVT::v2f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
486                    ShuffleMask);
487    DestName = getRegName(MI->getOperand(0).getReg());
488    break;
489  case X86::VPERMILPDYri:
490    Src1Name = getRegName(MI->getOperand(1).getReg());
491    // FALL THROUGH.
492  case X86::VPERMILPDYmi:
493    DecodePSHUFMask(MVT::v4f64, MI->getOperand(MI->getNumOperands()-1).getImm(),
494                       ShuffleMask);
495    DestName = getRegName(MI->getOperand(0).getReg());
496    break;
497  case X86::VPERM2F128rr:
498  case X86::VPERM2I128rr:
499    Src2Name = getRegName(MI->getOperand(2).getReg());
500    // FALL THROUGH.
501  case X86::VPERM2F128rm:
502  case X86::VPERM2I128rm:
503    // For instruction comments purpose, assume the 256-bit vector is v4i64.
504    DecodeVPERM2X128Mask(MVT::v4i64,
505                         MI->getOperand(MI->getNumOperands()-1).getImm(),
506                         ShuffleMask);
507    Src1Name = getRegName(MI->getOperand(1).getReg());
508    DestName = getRegName(MI->getOperand(0).getReg());
509    break;
510  case X86::VPERMQYri:
511  case X86::VPERMPDYri:
512    Src1Name = getRegName(MI->getOperand(1).getReg());
513    // FALL THROUGH.
514  case X86::VPERMQYmi:
515  case X86::VPERMPDYmi:
516    DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),
517                    ShuffleMask);
518    DestName = getRegName(MI->getOperand(0).getReg());
519    break;
520  }
521
522
523  // If this was a shuffle operation, print the shuffle mask.
524  if (!ShuffleMask.empty()) {
525    if (DestName == 0) DestName = Src1Name;
526    OS << (DestName ? DestName : "mem") << " = ";
527
528    // If the two sources are the same, canonicalize the input elements to be
529    // from the first src so that we get larger element spans.
530    if (Src1Name == Src2Name) {
531      for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
532        if ((int)ShuffleMask[i] >= 0 && // Not sentinel.
533            ShuffleMask[i] >= (int)e)        // From second mask.
534          ShuffleMask[i] -= e;
535      }
536    }
537
538    // The shuffle mask specifies which elements of the src1/src2 fill in the
539    // destination, with a few sentinel values.  Loop through and print them
540    // out.
541    for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {
542      if (i != 0)
543        OS << ',';
544      if (ShuffleMask[i] == SM_SentinelZero) {
545        OS << "zero";
546        continue;
547      }
548
549      // Otherwise, it must come from src1 or src2.  Print the span of elements
550      // that comes from this src.
551      bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();
552      const char *SrcName = isSrc1 ? Src1Name : Src2Name;
553      OS << (SrcName ? SrcName : "mem") << '[';
554      bool IsFirst = true;
555      while (i != e &&
556             (int)ShuffleMask[i] >= 0 &&
557             (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {
558        if (!IsFirst)
559          OS << ',';
560        else
561          IsFirst = false;
562        OS << ShuffleMask[i] % ShuffleMask.size();
563        ++i;
564      }
565      OS << ']';
566      --i;  // For loop increments element #.
567    }
568    //MI->print(OS, 0);
569    OS << "\n";
570  }
571
572}
573