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.
EmitAnyX86InstComments(const MCInst * MI,raw_ostream & OS,const char * (* getRegName)(unsigned))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