lib/Target/X86/InstPrinter/X86InstComments.cpp

   1 //===-- X86InstComments.cpp - Generate verbose-asm comments for instrs ----===//\r
   2 //\r
   3 //                     The LLVM Compiler Infrastructure\r
   4 //\r
   5 // This file is distributed under the University of Illinois Open Source\r
   6 // License. See LICENSE.TXT for details.\r
   7 //\r
   8 //===----------------------------------------------------------------------===//\r
   9 //\r
  10 // This defines functionality used to emit comments about X86 instructions to\r
  11 // an output stream for -fverbose-asm.\r
  12 //\r
  13 //===----------------------------------------------------------------------===//\r
  14 \r
  15 #include "X86InstComments.h"\r
  16 #include "MCTargetDesc/X86MCTargetDesc.h"\r
  17 #include "Utils/X86ShuffleDecode.h"\r
  18 #include "llvm/MC/MCInst.h"\r
  19 #include "llvm/CodeGen/MachineValueType.h"\r
  20 #include "llvm/Support/raw_ostream.h"\r
  21 \r
  22 using namespace llvm;\r
  23 \r
  24 /// \brief Extracts the src/dst types for a given zero extension instruction.\r
  25 /// \note While the number of elements in DstVT type correct, the\r
  26 /// number in the SrcVT type is expanded to fill the src xmm register and the\r
  27 /// upper elements may not be included in the dst xmm/ymm register.\r
  28 static void getZeroExtensionTypes(const MCInst *MI, MVT &SrcVT, MVT &DstVT) {\r
  29   switch (MI->getOpcode()) {\r
  30   default:\r
  31     llvm_unreachable("Unknown zero extension instruction");\r
  32   // i8 zero extension\r
  33   case X86::PMOVZXBWrm:\r
  34   case X86::PMOVZXBWrr:\r
  35   case X86::VPMOVZXBWrm:\r
  36   case X86::VPMOVZXBWrr:\r
  37     SrcVT = MVT::v16i8;\r
  38     DstVT = MVT::v8i16;\r
  39     break;\r
  40   case X86::VPMOVZXBWYrm:\r
  41   case X86::VPMOVZXBWYrr:\r
  42     SrcVT = MVT::v16i8;\r
  43     DstVT = MVT::v16i16;\r
  44     break;\r
  45   case X86::PMOVZXBDrm:\r
  46   case X86::PMOVZXBDrr:\r
  47   case X86::VPMOVZXBDrm:\r
  48   case X86::VPMOVZXBDrr:\r
  49     SrcVT = MVT::v16i8;\r
  50     DstVT = MVT::v4i32;\r
  51     break;\r
  52   case X86::VPMOVZXBDYrm:\r
  53   case X86::VPMOVZXBDYrr:\r
  54     SrcVT = MVT::v16i8;\r
  55     DstVT = MVT::v8i32;\r
  56     break;\r
  57   case X86::PMOVZXBQrm:\r
  58   case X86::PMOVZXBQrr:\r
  59   case X86::VPMOVZXBQrm:\r
  60   case X86::VPMOVZXBQrr:\r
  61     SrcVT = MVT::v16i8;\r
  62     DstVT = MVT::v2i64;\r
  63     break;\r
  64   case X86::VPMOVZXBQYrm:\r
  65   case X86::VPMOVZXBQYrr:\r
  66     SrcVT = MVT::v16i8;\r
  67     DstVT = MVT::v4i64;\r
  68     break;\r
  69   // i16 zero extension\r
  70   case X86::PMOVZXWDrm:\r
  71   case X86::PMOVZXWDrr:\r
  72   case X86::VPMOVZXWDrm:\r
  73   case X86::VPMOVZXWDrr:\r
  74     SrcVT = MVT::v8i16;\r
  75     DstVT = MVT::v4i32;\r
  76     break;\r
  77   case X86::VPMOVZXWDYrm:\r
  78   case X86::VPMOVZXWDYrr:\r
  79     SrcVT = MVT::v8i16;\r
  80     DstVT = MVT::v8i32;\r
  81     break;\r
  82   case X86::PMOVZXWQrm:\r
  83   case X86::PMOVZXWQrr:\r
  84   case X86::VPMOVZXWQrm:\r
  85   case X86::VPMOVZXWQrr:\r
  86     SrcVT = MVT::v8i16;\r
  87     DstVT = MVT::v2i64;\r
  88     break;\r
  89   case X86::VPMOVZXWQYrm:\r
  90   case X86::VPMOVZXWQYrr:\r
  91     SrcVT = MVT::v8i16;\r
  92     DstVT = MVT::v4i64;\r
  93     break;\r
  94   // i32 zero extension\r
  95   case X86::PMOVZXDQrm:\r
  96   case X86::PMOVZXDQrr:\r
  97   case X86::VPMOVZXDQrm:\r
  98   case X86::VPMOVZXDQrr:\r
  99     SrcVT = MVT::v4i32;\r
 100     DstVT = MVT::v2i64;\r
 101     break;\r
 102   case X86::VPMOVZXDQYrm:\r
 103   case X86::VPMOVZXDQYrr:\r
 104     SrcVT = MVT::v4i32;\r
 105     DstVT = MVT::v4i64;\r
 106     break;\r
 107   }\r
 108 }\r
 109 \r
 110 //===----------------------------------------------------------------------===//\r
 111 // Top Level Entrypoint\r
 112 //===----------------------------------------------------------------------===//\r
 113 \r
 114 /// EmitAnyX86InstComments - This function decodes x86 instructions and prints\r
 115 /// newline terminated strings to the specified string if desired.  This\r
 116 /// information is shown in disassembly dumps when verbose assembly is enabled.\r
 117 bool llvm::EmitAnyX86InstComments(const MCInst *MI, raw_ostream &OS,\r
 118                                   const char *(*getRegName)(unsigned)) {\r
 119   // If this is a shuffle operation, the switch should fill in this state.\r
 120   SmallVector<int, 8> ShuffleMask;\r
 121   const char *DestName = nullptr, *Src1Name = nullptr, *Src2Name = nullptr;\r
 122 \r
 123   switch (MI->getOpcode()) {\r
 124   default:\r
 125     // Not an instruction for which we can decode comments.\r
 126     return false;\r
 127 \r
 128   case X86::BLENDPDrri:\r
 129   case X86::VBLENDPDrri:\r
 130     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 131     // FALL THROUGH.\r
 132   case X86::BLENDPDrmi:\r
 133   case X86::VBLENDPDrmi:\r
 134     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 135       DecodeBLENDMask(MVT::v2f64,\r
 136                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 137                       ShuffleMask);\r
 138     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 139     DestName = getRegName(MI->getOperand(0).getReg());\r
 140     break;\r
 141   case X86::VBLENDPDYrri:\r
 142     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 143     // FALL THROUGH.\r
 144   case X86::VBLENDPDYrmi:\r
 145     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 146       DecodeBLENDMask(MVT::v4f64,\r
 147                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 148                       ShuffleMask);\r
 149     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 150     DestName = getRegName(MI->getOperand(0).getReg());\r
 151     break;\r
 152 \r
 153   case X86::BLENDPSrri:\r
 154   case X86::VBLENDPSrri:\r
 155     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 156     // FALL THROUGH.\r
 157   case X86::BLENDPSrmi:\r
 158   case X86::VBLENDPSrmi:\r
 159     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 160       DecodeBLENDMask(MVT::v4f32,\r
 161                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 162                       ShuffleMask);\r
 163     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 164     DestName = getRegName(MI->getOperand(0).getReg());\r
 165     break;\r
 166   case X86::VBLENDPSYrri:\r
 167     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 168     // FALL THROUGH.\r
 169   case X86::VBLENDPSYrmi:\r
 170     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 171       DecodeBLENDMask(MVT::v8f32,\r
 172                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 173                       ShuffleMask);\r
 174     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 175     DestName = getRegName(MI->getOperand(0).getReg());\r
 176     break;\r
 177 \r
 178   case X86::PBLENDWrri:\r
 179   case X86::VPBLENDWrri:\r
 180     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 181     // FALL THROUGH.\r
 182   case X86::PBLENDWrmi:\r
 183   case X86::VPBLENDWrmi:\r
 184     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 185       DecodeBLENDMask(MVT::v8i16,\r
 186                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 187                       ShuffleMask);\r
 188     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 189     DestName = getRegName(MI->getOperand(0).getReg());\r
 190     break;\r
 191   case X86::VPBLENDWYrri:\r
 192     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 193     // FALL THROUGH.\r
 194   case X86::VPBLENDWYrmi:\r
 195     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 196       DecodeBLENDMask(MVT::v16i16,\r
 197                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 198                       ShuffleMask);\r
 199     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 200     DestName = getRegName(MI->getOperand(0).getReg());\r
 201     break;\r
 202 \r
 203   case X86::VPBLENDDrri:\r
 204     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 205     // FALL THROUGH.\r
 206   case X86::VPBLENDDrmi:\r
 207     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 208       DecodeBLENDMask(MVT::v4i32,\r
 209                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 210                       ShuffleMask);\r
 211     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 212     DestName = getRegName(MI->getOperand(0).getReg());\r
 213     break;\r
 214 \r
 215   case X86::VPBLENDDYrri:\r
 216     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 217     // FALL THROUGH.\r
 218   case X86::VPBLENDDYrmi:\r
 219     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 220       DecodeBLENDMask(MVT::v8i32,\r
 221                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 222                       ShuffleMask);\r
 223     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 224     DestName = getRegName(MI->getOperand(0).getReg());\r
 225     break;\r
 226 \r
 227   case X86::INSERTPSrr:\r
 228   case X86::VINSERTPSrr:\r
 229     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 230     // FALL THROUGH.\r
 231   case X86::INSERTPSrm:\r
 232   case X86::VINSERTPSrm:\r
 233     DestName = getRegName(MI->getOperand(0).getReg());\r
 234     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 235     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 236       DecodeINSERTPSMask(MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 237                          ShuffleMask);\r
 238     break;\r
 239 \r
 240   case X86::MOVLHPSrr:\r
 241   case X86::VMOVLHPSrr:\r
 242     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 243     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 244     DestName = getRegName(MI->getOperand(0).getReg());\r
 245     DecodeMOVLHPSMask(2, ShuffleMask);\r
 246     break;\r
 247 \r
 248   case X86::MOVHLPSrr:\r
 249   case X86::VMOVHLPSrr:\r
 250     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 251     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 252     DestName = getRegName(MI->getOperand(0).getReg());\r
 253     DecodeMOVHLPSMask(2, ShuffleMask);\r
 254     break;\r
 255 \r
 256   case X86::MOVSLDUPrr:\r
 257   case X86::VMOVSLDUPrr:\r
 258     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 259     // FALL THROUGH.\r
 260   case X86::MOVSLDUPrm:\r
 261   case X86::VMOVSLDUPrm:\r
 262     DestName = getRegName(MI->getOperand(0).getReg());\r
 263     DecodeMOVSLDUPMask(MVT::v4f32, ShuffleMask);\r
 264     break;\r
 265 \r
 266   case X86::VMOVSHDUPYrr:\r
 267     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 268     // FALL THROUGH.\r
 269   case X86::VMOVSHDUPYrm:\r
 270     DestName = getRegName(MI->getOperand(0).getReg());\r
 271     DecodeMOVSHDUPMask(MVT::v8f32, ShuffleMask);\r
 272     break;\r
 273 \r
 274   case X86::VMOVSLDUPYrr:\r
 275     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 276     // FALL THROUGH.\r
 277   case X86::VMOVSLDUPYrm:\r
 278     DestName = getRegName(MI->getOperand(0).getReg());\r
 279     DecodeMOVSLDUPMask(MVT::v8f32, ShuffleMask);\r
 280     break;\r
 281 \r
 282   case X86::MOVSHDUPrr:\r
 283   case X86::VMOVSHDUPrr:\r
 284     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 285     // FALL THROUGH.\r
 286   case X86::MOVSHDUPrm:\r
 287   case X86::VMOVSHDUPrm:\r
 288     DestName = getRegName(MI->getOperand(0).getReg());\r
 289     DecodeMOVSHDUPMask(MVT::v4f32, ShuffleMask);\r
 290     break;\r
 291 \r
 292   case X86::VMOVDDUPYrr:\r
 293     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 294     // FALL THROUGH.\r
 295   case X86::VMOVDDUPYrm:\r
 296     DestName = getRegName(MI->getOperand(0).getReg());\r
 297     DecodeMOVDDUPMask(MVT::v4f64, ShuffleMask);\r
 298     break;\r
 299 \r
 300   case X86::MOVDDUPrr:\r
 301   case X86::VMOVDDUPrr:\r
 302     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 303     // FALL THROUGH.\r
 304   case X86::MOVDDUPrm:\r
 305   case X86::VMOVDDUPrm:\r
 306     DestName = getRegName(MI->getOperand(0).getReg());\r
 307     DecodeMOVDDUPMask(MVT::v2f64, ShuffleMask);\r
 308     break;\r
 309 \r
 310   case X86::PSLLDQri:\r
 311   case X86::VPSLLDQri:\r
 312     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 313     DestName = getRegName(MI->getOperand(0).getReg());\r
 314     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 315       DecodePSLLDQMask(MVT::v16i8,\r
 316                        MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 317                        ShuffleMask);\r
 318     break;\r
 319 \r
 320   case X86::VPSLLDQYri:\r
 321     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 322     DestName = getRegName(MI->getOperand(0).getReg());\r
 323     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 324       DecodePSLLDQMask(MVT::v32i8,\r
 325                        MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 326                        ShuffleMask);\r
 327     break;\r
 328 \r
 329   case X86::PSRLDQri:\r
 330   case X86::VPSRLDQri:\r
 331     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 332     DestName = getRegName(MI->getOperand(0).getReg());\r
 333     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 334       DecodePSRLDQMask(MVT::v16i8,\r
 335                        MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 336                        ShuffleMask);\r
 337     break;\r
 338 \r
 339   case X86::VPSRLDQYri:\r
 340     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 341     DestName = getRegName(MI->getOperand(0).getReg());\r
 342     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 343       DecodePSRLDQMask(MVT::v32i8,\r
 344                        MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 345                        ShuffleMask);\r
 346     break;\r
 347 \r
 348   case X86::PALIGNR128rr:\r
 349   case X86::VPALIGNR128rr:\r
 350     Src1Name = getRegName(MI->getOperand(2).getReg());\r
 351     // FALL THROUGH.\r
 352   case X86::PALIGNR128rm:\r
 353   case X86::VPALIGNR128rm:\r
 354     Src2Name = getRegName(MI->getOperand(1).getReg());\r
 355     DestName = getRegName(MI->getOperand(0).getReg());\r
 356     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 357       DecodePALIGNRMask(MVT::v16i8,\r
 358                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 359                         ShuffleMask);\r
 360     break;\r
 361   case X86::VPALIGNR256rr:\r
 362     Src1Name = getRegName(MI->getOperand(2).getReg());\r
 363     // FALL THROUGH.\r
 364   case X86::VPALIGNR256rm:\r
 365     Src2Name = getRegName(MI->getOperand(1).getReg());\r
 366     DestName = getRegName(MI->getOperand(0).getReg());\r
 367     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 368       DecodePALIGNRMask(MVT::v32i8,\r
 369                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 370                         ShuffleMask);\r
 371     break;\r
 372 \r
 373   case X86::PSHUFDri:\r
 374   case X86::VPSHUFDri:\r
 375     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 376     // FALL THROUGH.\r
 377   case X86::PSHUFDmi:\r
 378   case X86::VPSHUFDmi:\r
 379     DestName = getRegName(MI->getOperand(0).getReg());\r
 380     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 381       DecodePSHUFMask(MVT::v4i32,\r
 382                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 383                       ShuffleMask);\r
 384     break;\r
 385   case X86::VPSHUFDYri:\r
 386     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 387     // FALL THROUGH.\r
 388   case X86::VPSHUFDYmi:\r
 389     DestName = getRegName(MI->getOperand(0).getReg());\r
 390     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 391       DecodePSHUFMask(MVT::v8i32,\r
 392                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 393                       ShuffleMask);\r
 394     break;\r
 395 \r
 396 \r
 397   case X86::PSHUFHWri:\r
 398   case X86::VPSHUFHWri:\r
 399     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 400     // FALL THROUGH.\r
 401   case X86::PSHUFHWmi:\r
 402   case X86::VPSHUFHWmi:\r
 403     DestName = getRegName(MI->getOperand(0).getReg());\r
 404     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 405       DecodePSHUFHWMask(MVT::v8i16,\r
 406                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 407                         ShuffleMask);\r
 408     break;\r
 409   case X86::VPSHUFHWYri:\r
 410     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 411     // FALL THROUGH.\r
 412   case X86::VPSHUFHWYmi:\r
 413     DestName = getRegName(MI->getOperand(0).getReg());\r
 414     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 415       DecodePSHUFHWMask(MVT::v16i16,\r
 416                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 417                         ShuffleMask);\r
 418     break;\r
 419   case X86::PSHUFLWri:\r
 420   case X86::VPSHUFLWri:\r
 421     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 422     // FALL THROUGH.\r
 423   case X86::PSHUFLWmi:\r
 424   case X86::VPSHUFLWmi:\r
 425     DestName = getRegName(MI->getOperand(0).getReg());\r
 426     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 427       DecodePSHUFLWMask(MVT::v8i16,\r
 428                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 429                         ShuffleMask);\r
 430     break;\r
 431   case X86::VPSHUFLWYri:\r
 432     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 433     // FALL THROUGH.\r
 434   case X86::VPSHUFLWYmi:\r
 435     DestName = getRegName(MI->getOperand(0).getReg());\r
 436     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 437       DecodePSHUFLWMask(MVT::v16i16,\r
 438                         MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 439                         ShuffleMask);\r
 440     break;\r
 441 \r
 442   case X86::PUNPCKHBWrr:\r
 443   case X86::VPUNPCKHBWrr:\r
 444     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 445     // FALL THROUGH.\r
 446   case X86::PUNPCKHBWrm:\r
 447   case X86::VPUNPCKHBWrm:\r
 448     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 449     DestName = getRegName(MI->getOperand(0).getReg());\r
 450     DecodeUNPCKHMask(MVT::v16i8, ShuffleMask);\r
 451     break;\r
 452   case X86::VPUNPCKHBWYrr:\r
 453     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 454     // FALL THROUGH.\r
 455   case X86::VPUNPCKHBWYrm:\r
 456     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 457     DestName = getRegName(MI->getOperand(0).getReg());\r
 458     DecodeUNPCKHMask(MVT::v32i8, ShuffleMask);\r
 459     break;\r
 460   case X86::PUNPCKHWDrr:\r
 461   case X86::VPUNPCKHWDrr:\r
 462     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 463     // FALL THROUGH.\r
 464   case X86::PUNPCKHWDrm:\r
 465   case X86::VPUNPCKHWDrm:\r
 466     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 467     DestName = getRegName(MI->getOperand(0).getReg());\r
 468     DecodeUNPCKHMask(MVT::v8i16, ShuffleMask);\r
 469     break;\r
 470   case X86::VPUNPCKHWDYrr:\r
 471     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 472     // FALL THROUGH.\r
 473   case X86::VPUNPCKHWDYrm:\r
 474     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 475     DestName = getRegName(MI->getOperand(0).getReg());\r
 476     DecodeUNPCKHMask(MVT::v16i16, ShuffleMask);\r
 477     break;\r
 478   case X86::PUNPCKHDQrr:\r
 479   case X86::VPUNPCKHDQrr:\r
 480     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 481     // FALL THROUGH.\r
 482   case X86::PUNPCKHDQrm:\r
 483   case X86::VPUNPCKHDQrm:\r
 484     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 485     DestName = getRegName(MI->getOperand(0).getReg());\r
 486     DecodeUNPCKHMask(MVT::v4i32, ShuffleMask);\r
 487     break;\r
 488   case X86::VPUNPCKHDQYrr:\r
 489     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 490     // FALL THROUGH.\r
 491   case X86::VPUNPCKHDQYrm:\r
 492     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 493     DestName = getRegName(MI->getOperand(0).getReg());\r
 494     DecodeUNPCKHMask(MVT::v8i32, ShuffleMask);\r
 495     break;\r
 496   case X86::VPUNPCKHDQZrr:\r
 497     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 498     // FALL THROUGH.\r
 499   case X86::VPUNPCKHDQZrm:\r
 500     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 501     DestName = getRegName(MI->getOperand(0).getReg());\r
 502     DecodeUNPCKHMask(MVT::v16i32, ShuffleMask);\r
 503     break;\r
 504   case X86::PUNPCKHQDQrr:\r
 505   case X86::VPUNPCKHQDQrr:\r
 506     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 507     // FALL THROUGH.\r
 508   case X86::PUNPCKHQDQrm:\r
 509   case X86::VPUNPCKHQDQrm:\r
 510     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 511     DestName = getRegName(MI->getOperand(0).getReg());\r
 512     DecodeUNPCKHMask(MVT::v2i64, ShuffleMask);\r
 513     break;\r
 514   case X86::VPUNPCKHQDQYrr:\r
 515     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 516     // FALL THROUGH.\r
 517   case X86::VPUNPCKHQDQYrm:\r
 518     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 519     DestName = getRegName(MI->getOperand(0).getReg());\r
 520     DecodeUNPCKHMask(MVT::v4i64, ShuffleMask);\r
 521     break;\r
 522   case X86::VPUNPCKHQDQZrr:\r
 523     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 524     // FALL THROUGH.\r
 525   case X86::VPUNPCKHQDQZrm:\r
 526     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 527     DestName = getRegName(MI->getOperand(0).getReg());\r
 528     DecodeUNPCKHMask(MVT::v8i64, ShuffleMask);\r
 529     break;\r
 530 \r
 531   case X86::PUNPCKLBWrr:\r
 532   case X86::VPUNPCKLBWrr:\r
 533     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 534     // FALL THROUGH.\r
 535   case X86::PUNPCKLBWrm:\r
 536   case X86::VPUNPCKLBWrm:\r
 537     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 538     DestName = getRegName(MI->getOperand(0).getReg());\r
 539     DecodeUNPCKLMask(MVT::v16i8, ShuffleMask);\r
 540     break;\r
 541   case X86::VPUNPCKLBWYrr:\r
 542     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 543     // FALL THROUGH.\r
 544   case X86::VPUNPCKLBWYrm:\r
 545     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 546     DestName = getRegName(MI->getOperand(0).getReg());\r
 547     DecodeUNPCKLMask(MVT::v32i8, ShuffleMask);\r
 548     break;\r
 549   case X86::PUNPCKLWDrr:\r
 550   case X86::VPUNPCKLWDrr:\r
 551     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 552     // FALL THROUGH.\r
 553   case X86::PUNPCKLWDrm:\r
 554   case X86::VPUNPCKLWDrm:\r
 555     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 556     DestName = getRegName(MI->getOperand(0).getReg());\r
 557     DecodeUNPCKLMask(MVT::v8i16, ShuffleMask);\r
 558     break;\r
 559   case X86::VPUNPCKLWDYrr:\r
 560     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 561     // FALL THROUGH.\r
 562   case X86::VPUNPCKLWDYrm:\r
 563     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 564     DestName = getRegName(MI->getOperand(0).getReg());\r
 565     DecodeUNPCKLMask(MVT::v16i16, ShuffleMask);\r
 566     break;\r
 567   case X86::PUNPCKLDQrr:\r
 568   case X86::VPUNPCKLDQrr:\r
 569     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 570     // FALL THROUGH.\r
 571   case X86::PUNPCKLDQrm:\r
 572   case X86::VPUNPCKLDQrm:\r
 573     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 574     DestName = getRegName(MI->getOperand(0).getReg());\r
 575     DecodeUNPCKLMask(MVT::v4i32, ShuffleMask);\r
 576     break;\r
 577   case X86::VPUNPCKLDQYrr:\r
 578     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 579     // FALL THROUGH.\r
 580   case X86::VPUNPCKLDQYrm:\r
 581     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 582     DestName = getRegName(MI->getOperand(0).getReg());\r
 583     DecodeUNPCKLMask(MVT::v8i32, ShuffleMask);\r
 584     break;\r
 585   case X86::VPUNPCKLDQZrr:\r
 586     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 587     // FALL THROUGH.\r
 588   case X86::VPUNPCKLDQZrm:\r
 589     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 590     DestName = getRegName(MI->getOperand(0).getReg());\r
 591     DecodeUNPCKLMask(MVT::v16i32, ShuffleMask);\r
 592     break;\r
 593   case X86::PUNPCKLQDQrr:\r
 594   case X86::VPUNPCKLQDQrr:\r
 595     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 596     // FALL THROUGH.\r
 597   case X86::PUNPCKLQDQrm:\r
 598   case X86::VPUNPCKLQDQrm:\r
 599     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 600     DestName = getRegName(MI->getOperand(0).getReg());\r
 601     DecodeUNPCKLMask(MVT::v2i64, ShuffleMask);\r
 602     break;\r
 603   case X86::VPUNPCKLQDQYrr:\r
 604     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 605     // FALL THROUGH.\r
 606   case X86::VPUNPCKLQDQYrm:\r
 607     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 608     DestName = getRegName(MI->getOperand(0).getReg());\r
 609     DecodeUNPCKLMask(MVT::v4i64, ShuffleMask);\r
 610     break;\r
 611   case X86::VPUNPCKLQDQZrr:\r
 612     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 613     // FALL THROUGH.\r
 614   case X86::VPUNPCKLQDQZrm:\r
 615     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 616     DestName = getRegName(MI->getOperand(0).getReg());\r
 617     DecodeUNPCKLMask(MVT::v8i64, ShuffleMask);\r
 618     break;\r
 619 \r
 620   case X86::SHUFPDrri:\r
 621   case X86::VSHUFPDrri:\r
 622     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 623     // FALL THROUGH.\r
 624   case X86::SHUFPDrmi:\r
 625   case X86::VSHUFPDrmi:\r
 626     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 627       DecodeSHUFPMask(MVT::v2f64,\r
 628                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 629                       ShuffleMask);\r
 630     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 631     DestName = getRegName(MI->getOperand(0).getReg());\r
 632     break;\r
 633   case X86::VSHUFPDYrri:\r
 634     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 635     // FALL THROUGH.\r
 636   case X86::VSHUFPDYrmi:\r
 637     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 638       DecodeSHUFPMask(MVT::v4f64,\r
 639                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 640                       ShuffleMask);\r
 641     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 642     DestName = getRegName(MI->getOperand(0).getReg());\r
 643     break;\r
 644 \r
 645   case X86::SHUFPSrri:\r
 646   case X86::VSHUFPSrri:\r
 647     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 648     // FALL THROUGH.\r
 649   case X86::SHUFPSrmi:\r
 650   case X86::VSHUFPSrmi:\r
 651     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 652       DecodeSHUFPMask(MVT::v4f32,\r
 653                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 654                       ShuffleMask);\r
 655     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 656     DestName = getRegName(MI->getOperand(0).getReg());\r
 657     break;\r
 658   case X86::VSHUFPSYrri:\r
 659     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 660     // FALL THROUGH.\r
 661   case X86::VSHUFPSYrmi:\r
 662     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 663       DecodeSHUFPMask(MVT::v8f32,\r
 664                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 665                       ShuffleMask);\r
 666     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 667     DestName = getRegName(MI->getOperand(0).getReg());\r
 668     break;\r
 669 \r
 670   case X86::UNPCKLPDrr:\r
 671   case X86::VUNPCKLPDrr:\r
 672     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 673     // FALL THROUGH.\r
 674   case X86::UNPCKLPDrm:\r
 675   case X86::VUNPCKLPDrm:\r
 676     DecodeUNPCKLMask(MVT::v2f64, ShuffleMask);\r
 677     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 678     DestName = getRegName(MI->getOperand(0).getReg());\r
 679     break;\r
 680   case X86::VUNPCKLPDYrr:\r
 681     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 682     // FALL THROUGH.\r
 683   case X86::VUNPCKLPDYrm:\r
 684     DecodeUNPCKLMask(MVT::v4f64, ShuffleMask);\r
 685     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 686     DestName = getRegName(MI->getOperand(0).getReg());\r
 687     break;\r
 688   case X86::VUNPCKLPDZrr:\r
 689     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 690     // FALL THROUGH.\r
 691   case X86::VUNPCKLPDZrm:\r
 692     DecodeUNPCKLMask(MVT::v8f64, ShuffleMask);\r
 693     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 694     DestName = getRegName(MI->getOperand(0).getReg());\r
 695     break;\r
 696   case X86::UNPCKLPSrr:\r
 697   case X86::VUNPCKLPSrr:\r
 698     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 699     // FALL THROUGH.\r
 700   case X86::UNPCKLPSrm:\r
 701   case X86::VUNPCKLPSrm:\r
 702     DecodeUNPCKLMask(MVT::v4f32, ShuffleMask);\r
 703     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 704     DestName = getRegName(MI->getOperand(0).getReg());\r
 705     break;\r
 706   case X86::VUNPCKLPSYrr:\r
 707     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 708     // FALL THROUGH.\r
 709   case X86::VUNPCKLPSYrm:\r
 710     DecodeUNPCKLMask(MVT::v8f32, ShuffleMask);\r
 711     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 712     DestName = getRegName(MI->getOperand(0).getReg());\r
 713     break;\r
 714   case X86::VUNPCKLPSZrr:\r
 715     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 716     // FALL THROUGH.\r
 717   case X86::VUNPCKLPSZrm:\r
 718     DecodeUNPCKLMask(MVT::v16f32, ShuffleMask);\r
 719     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 720     DestName = getRegName(MI->getOperand(0).getReg());\r
 721     break;\r
 722   case X86::UNPCKHPDrr:\r
 723   case X86::VUNPCKHPDrr:\r
 724     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 725     // FALL THROUGH.\r
 726   case X86::UNPCKHPDrm:\r
 727   case X86::VUNPCKHPDrm:\r
 728     DecodeUNPCKHMask(MVT::v2f64, ShuffleMask);\r
 729     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 730     DestName = getRegName(MI->getOperand(0).getReg());\r
 731     break;\r
 732   case X86::VUNPCKHPDYrr:\r
 733     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 734     // FALL THROUGH.\r
 735   case X86::VUNPCKHPDYrm:\r
 736     DecodeUNPCKHMask(MVT::v4f64, ShuffleMask);\r
 737     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 738     DestName = getRegName(MI->getOperand(0).getReg());\r
 739     break;\r
 740   case X86::VUNPCKHPDZrr:\r
 741     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 742     // FALL THROUGH.\r
 743   case X86::VUNPCKHPDZrm:\r
 744     DecodeUNPCKHMask(MVT::v8f64, ShuffleMask);\r
 745     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 746     DestName = getRegName(MI->getOperand(0).getReg());\r
 747     break;\r
 748   case X86::UNPCKHPSrr:\r
 749   case X86::VUNPCKHPSrr:\r
 750     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 751     // FALL THROUGH.\r
 752   case X86::UNPCKHPSrm:\r
 753   case X86::VUNPCKHPSrm:\r
 754     DecodeUNPCKHMask(MVT::v4f32, ShuffleMask);\r
 755     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 756     DestName = getRegName(MI->getOperand(0).getReg());\r
 757     break;\r
 758   case X86::VUNPCKHPSYrr:\r
 759     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 760     // FALL THROUGH.\r
 761   case X86::VUNPCKHPSYrm:\r
 762     DecodeUNPCKHMask(MVT::v8f32, ShuffleMask);\r
 763     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 764     DestName = getRegName(MI->getOperand(0).getReg());\r
 765     break;\r
 766   case X86::VUNPCKHPSZrr:\r
 767     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 768     // FALL THROUGH.\r
 769   case X86::VUNPCKHPSZrm:\r
 770     DecodeUNPCKHMask(MVT::v16f32, ShuffleMask);\r
 771     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 772     DestName = getRegName(MI->getOperand(0).getReg());\r
 773     break;\r
 774   case X86::VPERMILPSri:\r
 775     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 776     // FALL THROUGH.\r
 777   case X86::VPERMILPSmi:\r
 778     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 779       DecodePSHUFMask(MVT::v4f32,\r
 780                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 781                       ShuffleMask);\r
 782     DestName = getRegName(MI->getOperand(0).getReg());\r
 783     break;\r
 784   case X86::VPERMILPSYri:\r
 785     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 786     // FALL THROUGH.\r
 787   case X86::VPERMILPSYmi:\r
 788     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 789       DecodePSHUFMask(MVT::v8f32,\r
 790                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 791                       ShuffleMask);\r
 792     DestName = getRegName(MI->getOperand(0).getReg());\r
 793     break;\r
 794   case X86::VPERMILPDri:\r
 795     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 796     // FALL THROUGH.\r
 797   case X86::VPERMILPDmi:\r
 798     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 799       DecodePSHUFMask(MVT::v2f64,\r
 800                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 801                       ShuffleMask);\r
 802     DestName = getRegName(MI->getOperand(0).getReg());\r
 803     break;\r
 804   case X86::VPERMILPDYri:\r
 805     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 806     // FALL THROUGH.\r
 807   case X86::VPERMILPDYmi:\r
 808     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 809       DecodePSHUFMask(MVT::v4f64,\r
 810                       MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 811                       ShuffleMask);\r
 812     DestName = getRegName(MI->getOperand(0).getReg());\r
 813     break;\r
 814   case X86::VPERM2F128rr:\r
 815   case X86::VPERM2I128rr:\r
 816     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 817     // FALL THROUGH.\r
 818   case X86::VPERM2F128rm:\r
 819   case X86::VPERM2I128rm:\r
 820     // For instruction comments purpose, assume the 256-bit vector is v4i64.\r
 821     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 822       DecodeVPERM2X128Mask(MVT::v4i64,\r
 823                            MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 824                            ShuffleMask);\r
 825     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 826     DestName = getRegName(MI->getOperand(0).getReg());\r
 827     break;\r
 828   case X86::VPERMQYri:\r
 829   case X86::VPERMPDYri:\r
 830     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 831     // FALL THROUGH.\r
 832   case X86::VPERMQYmi:\r
 833   case X86::VPERMPDYmi:\r
 834     if(MI->getOperand(MI->getNumOperands()-1).isImm())\r
 835       DecodeVPERMMask(MI->getOperand(MI->getNumOperands()-1).getImm(),\r
 836                       ShuffleMask);\r
 837     DestName = getRegName(MI->getOperand(0).getReg());\r
 838     break;\r
 839 \r
 840   case X86::MOVSDrr:\r
 841   case X86::VMOVSDrr:\r
 842     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 843     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 844     // FALL THROUGH.\r
 845   case X86::MOVSDrm:\r
 846   case X86::VMOVSDrm:\r
 847     DecodeScalarMoveMask(MVT::v2f64, nullptr == Src2Name, ShuffleMask);\r
 848     DestName = getRegName(MI->getOperand(0).getReg());\r
 849     break;\r
 850   case X86::MOVSSrr:\r
 851   case X86::VMOVSSrr:\r
 852     Src2Name = getRegName(MI->getOperand(2).getReg());\r
 853     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 854     // FALL THROUGH.\r
 855   case X86::MOVSSrm:\r
 856   case X86::VMOVSSrm:\r
 857     DecodeScalarMoveMask(MVT::v4f32, nullptr == Src2Name, ShuffleMask);\r
 858     DestName = getRegName(MI->getOperand(0).getReg());\r
 859     break;\r
 860 \r
 861   case X86::MOVPQI2QIrr:\r
 862   case X86::MOVZPQILo2PQIrr:\r
 863   case X86::VMOVPQI2QIrr:\r
 864   case X86::VMOVZPQILo2PQIrr:\r
 865     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 866   // FALL THROUGH.\r
 867   case X86::MOVQI2PQIrm:\r
 868   case X86::MOVZQI2PQIrm:\r
 869   case X86::MOVZPQILo2PQIrm:\r
 870   case X86::VMOVQI2PQIrm:\r
 871   case X86::VMOVZQI2PQIrm:\r
 872   case X86::VMOVZPQILo2PQIrm:\r
 873     DecodeZeroMoveLowMask(MVT::v2i64, ShuffleMask);\r
 874     DestName = getRegName(MI->getOperand(0).getReg());\r
 875     break;\r
 876   case X86::MOVDI2PDIrm:\r
 877   case X86::VMOVDI2PDIrm:\r
 878     DecodeZeroMoveLowMask(MVT::v4i32, ShuffleMask);\r
 879     DestName = getRegName(MI->getOperand(0).getReg());\r
 880     break;\r
 881 \r
 882   case X86::PMOVZXBWrr:\r
 883   case X86::PMOVZXBDrr:\r
 884   case X86::PMOVZXBQrr:\r
 885   case X86::PMOVZXWDrr:\r
 886   case X86::PMOVZXWQrr:\r
 887   case X86::PMOVZXDQrr:\r
 888   case X86::VPMOVZXBWrr:\r
 889   case X86::VPMOVZXBDrr:\r
 890   case X86::VPMOVZXBQrr:\r
 891   case X86::VPMOVZXWDrr:\r
 892   case X86::VPMOVZXWQrr:\r
 893   case X86::VPMOVZXDQrr:\r
 894   case X86::VPMOVZXBWYrr:\r
 895   case X86::VPMOVZXBDYrr:\r
 896   case X86::VPMOVZXBQYrr:\r
 897   case X86::VPMOVZXWDYrr:\r
 898   case X86::VPMOVZXWQYrr:\r
 899   case X86::VPMOVZXDQYrr:\r
 900     Src1Name = getRegName(MI->getOperand(1).getReg());\r
 901   // FALL THROUGH.\r
 902   case X86::PMOVZXBWrm:\r
 903   case X86::PMOVZXBDrm:\r
 904   case X86::PMOVZXBQrm:\r
 905   case X86::PMOVZXWDrm:\r
 906   case X86::PMOVZXWQrm:\r
 907   case X86::PMOVZXDQrm:\r
 908   case X86::VPMOVZXBWrm:\r
 909   case X86::VPMOVZXBDrm:\r
 910   case X86::VPMOVZXBQrm:\r
 911   case X86::VPMOVZXWDrm:\r
 912   case X86::VPMOVZXWQrm:\r
 913   case X86::VPMOVZXDQrm:\r
 914   case X86::VPMOVZXBWYrm:\r
 915   case X86::VPMOVZXBDYrm:\r
 916   case X86::VPMOVZXBQYrm:\r
 917   case X86::VPMOVZXWDYrm:\r
 918   case X86::VPMOVZXWQYrm:\r
 919   case X86::VPMOVZXDQYrm: {\r
 920     MVT SrcVT, DstVT;\r
 921     getZeroExtensionTypes(MI, SrcVT, DstVT);\r
 922     DecodeZeroExtendMask(SrcVT, DstVT, ShuffleMask);\r
 923     DestName = getRegName(MI->getOperand(0).getReg());\r
 924   } break;\r
 925   }\r
 926 \r
 927   // The only comments we decode are shuffles, so give up if we were unable to\r
 928   // decode a shuffle mask.\r
 929   if (ShuffleMask.empty())\r
 930     return false;\r
 931 \r
 932   if (!DestName) DestName = Src1Name;\r
 933   OS << (DestName ? DestName : "mem") << " = ";\r
 934 \r
 935   // If the two sources are the same, canonicalize the input elements to be\r
 936   // from the first src so that we get larger element spans.\r
 937   if (Src1Name == Src2Name) {\r
 938     for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {\r
 939       if ((int)ShuffleMask[i] >= 0 && // Not sentinel.\r
 940           ShuffleMask[i] >= (int)e)        // From second mask.\r
 941         ShuffleMask[i] -= e;\r
 942     }\r
 943   }\r
 944 \r
 945   // The shuffle mask specifies which elements of the src1/src2 fill in the\r
 946   // destination, with a few sentinel values.  Loop through and print them\r
 947   // out.\r
 948   for (unsigned i = 0, e = ShuffleMask.size(); i != e; ++i) {\r
 949     if (i != 0)\r
 950       OS << ',';\r
 951     if (ShuffleMask[i] == SM_SentinelZero) {\r
 952       OS << "zero";\r
 953       continue;\r
 954     }\r
 955 \r
 956     // Otherwise, it must come from src1 or src2.  Print the span of elements\r
 957     // that comes from this src.\r
 958     bool isSrc1 = ShuffleMask[i] < (int)ShuffleMask.size();\r
 959     const char *SrcName = isSrc1 ? Src1Name : Src2Name;\r
 960     OS << (SrcName ? SrcName : "mem") << '[';\r
 961     bool IsFirst = true;\r
 962     while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&\r
 963            (ShuffleMask[i] < (int)ShuffleMask.size()) == isSrc1) {\r
 964       if (!IsFirst)\r
 965         OS << ',';\r
 966       else\r
 967         IsFirst = false;\r
 968       if (ShuffleMask[i] == SM_SentinelUndef)\r
 969         OS << "u";\r
 970       else\r
 971         OS << ShuffleMask[i] % ShuffleMask.size();\r
 972       ++i;\r
 973     }\r
 974     OS << ']';\r
 975     --i;  // For loop increments element #.\r
 976   }\r
 977   //MI->print(OS, 0);\r
 978   OS << "\n";\r
 979 \r
 980   // We successfully added a comment to this instruction.\r
 981   return true;\r
 982 }\r