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