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