[X86] Remove the _alt forms of XOP VPCOM and AVX512 VPCMP instructions. Use a combination of custom printing and custom parsing to achieve the same result and more

[craig.topper]

Summary

Previously we had a regular form of the instruction used when the immediate was 0-7. And _alt form that allowed the full 8 bit immediate. Codegen would always use the 0-7 form since the immediate was always checked to be in range. Assembly parsing would use the 0-7 form when a mnemonic like vpcomtrueb was used. If the immediate was specified directly the _alt form was used. The disassembler would prefer to use the 0-7 form instruction when the immediate was in range and the _alt form otherwise. This way disassembly would print the most readable form when possible.

The assembly parsing for things like vpcomtrueb relied on splitting the mnemonic into 3 pieces. A "vpcom" prefix, an immediate representing the "true", and a suffix of "b". The tablegenerated printing code would similarly print a "vpcom" prefix, decode the immediate into a string, and then print "b".

The _alt form on the other hand parsed and printed like any other instruction with no specialness.

With this patch we drop to one form and solve the disassembly printing issue by doing custom printing when the immediate is 0-7. The parsing code has been tweaked to turn "vpcomtrueb" into "vpcomb" and then the immediate for the "true" is inserted either before or after the other operands depending on at&t or intel syntax.

I'd rather not do the custom printing, but I tried using an InstAlias for each possible mnemonic for all 8 immediates for all 16 combinations of element size, signedness, and memory/register. The code emitted into printAliasInstr ended up checking the number of operands, the register class of each operand, and the immediate for all 256 aliases. This was repeated for both the at&t and intel printer. Despite a lot of common checks between all of the aliases, when compiled with clang at least this commonality was not well optimized. Nor do all the checks seem necessary. Since I want to do a similar thing for vcmpps/pd/ss/sd which have 32 immediate values and 3 encoding flavors, 3 register sizes, etc. This didn't seem to scale well for clang binary size. So custom printing seemed a better trade off.

I also considered just using the InstAlias for the matching and not the printing. But that seemed like it would add a lot of extra rows to the matcher table. Especially given that the 32 immediates for vpcmpps have 46 strings associated with them.

[RKSimon]

lib/Target/X86/AsmParser/X86AsmParser.cpp

2517 ↗

(On Diff #190752)

Is the plan to reuse this for the upcoming vcmpps/pd/ss/sd support?

[lebedev.ri]

test/tools/llvm-mca/X86/BdVer2/resources-xop.s

242 ↗

(On Diff #190752)

So now that the immediate matters, should i add back these tests for the rest of immediates?

[RKSimon]

test/tools/llvm-mca/X86/BdVer2/resources-xop.s

242 ↗

(On Diff #190752)

You can if you want, although IIRC the only thing that could show different behaviour is true/false - and we don't emit those.

[lebedev.ri]

test/tools/llvm-mca/X86/BdVer2/resources-xop.s

242 ↗

(On Diff #190752)

What i mean is, there does not seem to be other test changes other than these,
so is there test coverage for printing the VPCOM with imm != 0?
I'm guessing no, and that is why i think the tests should be added.

[craig.topper]

lib/Target/X86/AsmParser/X86AsmParser.cpp

2517 ↗

(On Diff #190752)

Yes.

test/tools/llvm-mca/X86/BdVer2/resources-xop.s

242 ↗

(On Diff #190752)

There are MC tests for immediates other than 0, but they all used a special mnemonic and we verify the special mnemonic gets printed back out.

The only observable change in this patch is that if you use an explicit immediate of 0-7, that will now be printed with the special mnemonic.

[craig.topper]

Extend to cover VPCMP as well. Use TSFlags to make some of the printing decisions rather than switching on the enum. I think this should be better than the jump tables that switching on the enum would require.

[RKSimon]

LGTM - if possible I'd probably prefer to have the XOP + AVX512 cases committed separately (not its not that vital).

llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp

if (ComparisonCode != ~0U && (ComparisonCode != 0 || CCIdx == 2)) {
       const MCExpr *ImmOp = MCConstantExpr::create(ComparisonCode,
                                                    getParser().getContext());
       Operands.push_back(X86Operand::CreateImm(ImmOp, NameLoc, NameLoc));
 
       PatchedName = PatchedName.substr(PatchedName.size() - CCIdx);
     }
   }
 
+  unsigned ComparisonCode = ~0U;
+
   // FIXME: Hack to recognize vpcom<comparison code>{ub,uw,ud,uq,b,w,d,q}.
   if (PatchedName.startswith("vpcom") &&
-      (PatchedName.endswith("b") || PatchedName.endswith("w") ||
-       PatchedName.endswith("d") || PatchedName.endswith("q"))) {
-    unsigned CCIdx = PatchedName.drop_back().back() == 'u' ? 2 : 1;
-    unsigned ComparisonCode = StringSwitch<unsigned>(
-      PatchedName.slice(5, PatchedName.size() - CCIdx))
+      (PatchedName.back() == 'b' || PatchedName.back() == 'w' ||
+       PatchedName.back() == 'd' || PatchedName.back() == 'q')) {
+    unsigned SuffixSize = PatchedName.drop_back().back() == 'u' ? 2 : 1;
+    unsigned CC = StringSwitch<unsigned>(
+      PatchedName.slice(5, PatchedName.size() - SuffixSize))
       .Case("lt",    0x0)
       .Case("le",    0x1)
       .Case("gt",    0x2)
       .Case("ge",    0x3)
       .Case("eq",    0x4)
       .Case("neq",   0x5)
       .Case("false", 0x6)
       .Case("true",  0x7)
       .Default(~0U);
-    if (ComparisonCode != ~0U) {
-      Operands.push_back(X86Operand::CreateToken("vpcom", NameLoc));
-
-      const MCExpr *ImmOp = MCConstantExpr::create(ComparisonCode,
-                                                   getParser().getContext());
-      Operands.push_back(X86Operand::CreateImm(ImmOp, NameLoc, NameLoc));
-
-      PatchedName = PatchedName.substr(PatchedName.size() - CCIdx);
+    if (CC != ~0U) {
+      switch (PatchedName.back()) {
+      default: llvm_unreachable("Unexpected character!");
+      case 'b': PatchedName = SuffixSize == 2 ? "vpcomub" : "vpcomb"; break;
+      case 'w': PatchedName = SuffixSize == 2 ? "vpcomuw" : "vpcomw"; break;
+      case 'd': PatchedName = SuffixSize == 2 ? "vpcomud" : "vpcomd"; break;
+      case 'q': PatchedName = SuffixSize == 2 ? "vpcomuq" : "vpcomq"; break;
+      }
+      // Set up the immediate to push into the operands later.
+      ComparisonCode = CC;
     }
   }
 
 
   // Determine whether this is an instruction prefix.
   // FIXME:
   // Enhance prefixes integrity robustness. for example, following forms
   // are currently tolerated:
if (PatchedName == "data32") {
     if (is64BitMode())
       return Error(NameLoc, "'data32' is not supported in 64-bit mode");
     // Hack to 'data16' for the table lookup.
     PatchedName = "data16";
   }
 
   Operands.push_back(X86Operand::CreateToken(PatchedName, NameLoc));
 
+  // Push the immediate if we extracted one from the mnemonic.
+  if (ComparisonCode != ~0U && !isParsingIntelSyntax()) {
+    const MCExpr *ImmOp = MCConstantExpr::create(ComparisonCode,
+                                                 getParser().getContext());
+    Operands.push_back(X86Operand::CreateImm(ImmOp, NameLoc, NameLoc));
+  }
+
   // This does the actual operand parsing.  Don't parse any more if we have a
   // prefix juxtaposed with an operation like "lock incl 4(%rax)", because we
   // just want to parse the "lock" as the first instruction and the "incl" as
   // the next one.
   if (getLexer().isNot(AsmToken::EndOfStatement) && !isPrefix) {
     // Parse '*' modifier.
     if (getLexer().is(AsmToken::Star))
       Operands.push_back(X86Operand::CreateToken("*", consumeToken()));
if (getLexer().isNot(AsmToken::EndOfStatement) && !isPrefix) {
     // therefore they should be interepreted as end of statement
     CurlyAsEndOfStatement =
         isParsingIntelSyntax() && isParsingInlineAsm() &&
         (getLexer().is(AsmToken::LCurly) || getLexer().is(AsmToken::RCurly));
     if (getLexer().isNot(AsmToken::EndOfStatement) && !CurlyAsEndOfStatement)
       return TokError("unexpected token in argument list");
   }
 
+  // Push the immediate if we extracted one from the mnemonic.
+  if (ComparisonCode != ~0U && isParsingIntelSyntax()) {
+    const MCExpr *ImmOp = MCConstantExpr::create(ComparisonCode,
+                                                 getParser().getContext());
+    Operands.push_back(X86Operand::CreateImm(ImmOp, NameLoc, NameLoc));
+  }
+
   // Consume the EndOfStatement or the prefix separator Slash
   if (getLexer().is(AsmToken::EndOfStatement) ||
       (isPrefix && getLexer().is(AsmToken::Slash)))
     Parser.Lex();
   else if (CurlyAsEndOfStatement)
     // Add an actual EndOfStatement before the curly brace
     Info.AsmRewrites->emplace_back(AOK_EndOfStatement,
                                    getLexer().getTok().getLoc(), 0);

llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp

if (immediate >= 8) {
       case X86::CMPPDrmi:  NewOpc = X86::CMPPDrmi_alt;  break;
       case X86::CMPPDrri:  NewOpc = X86::CMPPDrri_alt;  break;
       case X86::CMPPSrmi:  NewOpc = X86::CMPPSrmi_alt;  break;
       case X86::CMPPSrri:  NewOpc = X86::CMPPSrri_alt;  break;
       case X86::CMPSDrm:   NewOpc = X86::CMPSDrm_alt;   break;
       case X86::CMPSDrr:   NewOpc = X86::CMPSDrr_alt;   break;
       case X86::CMPSSrm:   NewOpc = X86::CMPSSrm_alt;   break;
       case X86::CMPSSrr:   NewOpc = X86::CMPSSrr_alt;   break;
-      case X86::VPCOMBri:  NewOpc = X86::VPCOMBri_alt;  break;
-      case X86::VPCOMBmi:  NewOpc = X86::VPCOMBmi_alt;  break;
-      case X86::VPCOMWri:  NewOpc = X86::VPCOMWri_alt;  break;
-      case X86::VPCOMWmi:  NewOpc = X86::VPCOMWmi_alt;  break;
-      case X86::VPCOMDri:  NewOpc = X86::VPCOMDri_alt;  break;
-      case X86::VPCOMDmi:  NewOpc = X86::VPCOMDmi_alt;  break;
-      case X86::VPCOMQri:  NewOpc = X86::VPCOMQri_alt;  break;
-      case X86::VPCOMQmi:  NewOpc = X86::VPCOMQmi_alt;  break;
-      case X86::VPCOMUBri: NewOpc = X86::VPCOMUBri_alt; break;
-      case X86::VPCOMUBmi: NewOpc = X86::VPCOMUBmi_alt; break;
-      case X86::VPCOMUWri: NewOpc = X86::VPCOMUWri_alt; break;
-      case X86::VPCOMUWmi: NewOpc = X86::VPCOMUWmi_alt; break;
-      case X86::VPCOMUDri: NewOpc = X86::VPCOMUDri_alt; break;
-      case X86::VPCOMUDmi: NewOpc = X86::VPCOMUDmi_alt; break;
-      case X86::VPCOMUQri: NewOpc = X86::VPCOMUQri_alt; break;
-      case X86::VPCOMUQmi: NewOpc = X86::VPCOMUQmi_alt; break;
       }
       // Switch opcode to the one that doesn't get special printing.
       mcInst.setOpcode(NewOpc);
     }
   } else if (type == TYPE_IMM5) {
     // Check for immediates that printAVXCC can't handle.
     if (immediate >= 32) {
       unsigned NewOpc;

llvm/trunk/lib/Target/X86/InstPrinter/X86ATTInstPrinter.h

 public:
   X86ATTInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                     const MCRegisterInfo &MRI)
       : X86InstPrinterCommon(MAI, MII, MRI) {}
 
   void printRegName(raw_ostream &OS, unsigned RegNo) const override;
   void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot,
                  const MCSubtargetInfo &STI) override;
+  bool printVecCompareInstr(const MCInst *MI, raw_ostream &OS);
 
   // Autogenerated by tblgen, returns true if we successfully printed an
   // alias.
   bool printAliasInstr(const MCInst *MI, raw_ostream &OS);
   void printCustomAliasOperand(const MCInst *MI, unsigned OpIdx,
                                unsigned PrintMethodIdx, raw_ostream &O);
 
   // Autogenerated by tblgen.

llvm/trunk/lib/Target/X86/InstPrinter/X86ATTInstPrinter.cpp

void X86ATTInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
   // There seems to be some lack of support of the Requires clause that causes
   // 0x66 to be interpreted as "data16" by the asm printer.
   // Thus we add an adjustment here in order to print the "right" instruction.
   else if (MI->getOpcode() == X86::DATA16_PREFIX &&
            STI.getFeatureBits()[X86::Mode16Bit]) {
    OS << "\tdata32";
   }
   // Try to print any aliases first.
-  else if (!printAliasInstr(MI, OS))
+  else if (!printAliasInstr(MI, OS) &&
+           !printVecCompareInstr(MI, OS))
     printInstruction(MI, OS);
 
   // Next always print the annotation.
   printAnnotation(OS, Annot);
 }
 
+bool X86ATTInstPrinter::printVecCompareInstr(const MCInst *MI,
+                                             raw_ostream &OS) {
+  if (MI->getNumOperands() == 0 ||
+      !MI->getOperand(MI->getNumOperands() - 1).isImm())
+    return false;
+
+  unsigned Imm = MI->getOperand(MI->getNumOperands() - 1).getImm();
+
+  const MCInstrDesc &Desc = MII.get(MI->getOpcode());
+
+  // Custom print the vector compare instructions to get the immediate
+  // translated into the mnemonic.
+  switch (MI->getOpcode()) {
+  case X86::VPCOMBmi:  case X86::VPCOMBri:
+  case X86::VPCOMDmi:  case X86::VPCOMDri:
+  case X86::VPCOMQmi:  case X86::VPCOMQri:
+  case X86::VPCOMUBmi: case X86::VPCOMUBri:
+  case X86::VPCOMUDmi: case X86::VPCOMUDri:
+  case X86::VPCOMUQmi: case X86::VPCOMUQri:
+  case X86::VPCOMUWmi: case X86::VPCOMUWri:
+  case X86::VPCOMWmi:  case X86::VPCOMWri:
+    if (Imm >= 0 && Imm <= 7) {
+      printVPCOMMnemonic(MI, OS);
+
+      if ((Desc.TSFlags & X86II::FormMask) == X86II::MRMSrcMem)
+        printi128mem(MI, 2, OS);
+      else
+        printOperand(MI, 2, OS);
+
+      OS << ", ";
+      printOperand(MI, 1, OS);
+      OS << ", ";
+      printOperand(MI, 0, OS);
+      return true;
+    }
+    break;
+  }
+
+  return false;
+}
+
 void X86ATTInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
                                      raw_ostream &O) {
   const MCOperand &Op = MI->getOperand(OpNo);
   if (Op.isReg()) {
     printRegName(O, Op.getReg());
   } else if (Op.isImm()) {
     // Print immediates as signed values.
     int64_t Imm = Op.getImm();

llvm/trunk/lib/Target/X86/InstPrinter/X86InstPrinterCommon.h

 namespace llvm {
 
 class X86InstPrinterCommon : public MCInstPrinter {
 public:
   using MCInstPrinter::MCInstPrinter;
 
   virtual void printOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O) = 0;
   void printSSEAVXCC(const MCInst *MI, unsigned Op, raw_ostream &OS);
-  void printXOPCC(const MCInst *MI, unsigned Op, raw_ostream &OS);
+  void printVPCOMMnemonic(const MCInst *MI, raw_ostream &OS);
   void printRoundingControl(const MCInst *MI, unsigned Op, raw_ostream &O);
   void printPCRelImm(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 protected:
   void printInstFlags(const MCInst *MI, raw_ostream &O);
   void printOptionalSegReg(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_X86_INSTPRINTER_X86ATTINSTPRINTER_H

llvm/trunk/lib/Target/X86/InstPrinter/X86InstPrinterCommon.cpp

void X86InstPrinterCommon::printSSEAVXCC(const MCInst *MI, unsigned Op,
   case 0x1b: O << "false_os"; break;
   case 0x1c: O << "neq_os"; break;
   case 0x1d: O << "ge_oq"; break;
   case 0x1e: O << "gt_oq"; break;
   case 0x1f: O << "true_us"; break;
   }
 }
 
-void X86InstPrinterCommon::printXOPCC(const MCInst *MI, unsigned Op,
-                                      raw_ostream &O) {
-  int64_t Imm = MI->getOperand(Op).getImm();
+void X86InstPrinterCommon::printVPCOMMnemonic(const MCInst *MI,
+                                              raw_ostream &OS) {
+  OS << "vpcom";
+
+  int64_t Imm = MI->getOperand(MI->getNumOperands() - 1).getImm();
   switch (Imm) {
-  default: llvm_unreachable("Invalid xopcc argument!");
-  case 0: O << "lt"; break;
-  case 1: O << "le"; break;
-  case 2: O << "gt"; break;
-  case 3: O << "ge"; break;
-  case 4: O << "eq"; break;
-  case 5: O << "neq"; break;
-  case 6: O << "false"; break;
-  case 7: O << "true"; break;
+  default: llvm_unreachable("Invalid vpcom argument!");
+  case 0: OS << "lt"; break;
+  case 1: OS << "le"; break;
+  case 2: OS << "gt"; break;
+  case 3: OS << "ge"; break;
+  case 4: OS << "eq"; break;
+  case 5: OS << "neq"; break;
+  case 6: OS << "false"; break;
+  case 7: OS << "true"; break;
+  }
+
+  switch (MI->getOpcode()) {
+  default: llvm_unreachable("Unexpected opcode!");
+  case X86::VPCOMBmi:  case X86::VPCOMBri:  OS << "b\t";  break;
+  case X86::VPCOMDmi:  case X86::VPCOMDri:  OS << "d\t";  break;
+  case X86::VPCOMQmi:  case X86::VPCOMQri:  OS << "q\t";  break;
+  case X86::VPCOMUBmi: case X86::VPCOMUBri: OS << "ub\t"; break;
+  case X86::VPCOMUDmi: case X86::VPCOMUDri: OS << "ud\t"; break;
+  case X86::VPCOMUQmi: case X86::VPCOMUQri: OS << "uq\t"; break;
+  case X86::VPCOMUWmi: case X86::VPCOMUWri: OS << "uw\t"; break;
+  case X86::VPCOMWmi:  case X86::VPCOMWri:  OS << "w\t";  break;
   }
 }
 
 void X86InstPrinterCommon::printRoundingControl(const MCInst *MI, unsigned Op,
                                                 raw_ostream &O) {
   int64_t Imm = MI->getOperand(Op).getImm();
   switch (Imm) {
   default:

llvm/trunk/lib/Target/X86/InstPrinter/X86IntelInstPrinter.h

 public:
   X86IntelInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                       const MCRegisterInfo &MRI)
     : X86InstPrinterCommon(MAI, MII, MRI) {}
 
   void printRegName(raw_ostream &OS, unsigned RegNo) const override;
   void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot,
                  const MCSubtargetInfo &STI) override;
+  bool printVecCompareInstr(const MCInst *MI, raw_ostream &OS);
 
   // Autogenerated by tblgen, returns true if we successfully printed an
   // alias.
   bool printAliasInstr(const MCInst *MI, raw_ostream &OS);
   void printCustomAliasOperand(const MCInst *MI, unsigned OpIdx,
                                unsigned PrintMethodIdx, raw_ostream &O);
 
   // Autogenerated by tblgen.

llvm/trunk/lib/Target/X86/InstPrinter/X86IntelInstPrinter.cpp

void X86IntelInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
                                     StringRef Annot,
                                     const MCSubtargetInfo &STI) {
   printInstFlags(MI, OS);
 
   // In 16-bit mode, print data16 as data32.
   if (MI->getOpcode() == X86::DATA16_PREFIX &&
       STI.getFeatureBits()[X86::Mode16Bit]) {
     OS << "\tdata32";
-  } else if (!printAliasInstr(MI, OS))
+  } else if (!printAliasInstr(MI, OS) &&
+             !printVecCompareInstr(MI, OS))
     printInstruction(MI, OS);
 
   // Next always print the annotation.
   printAnnotation(OS, Annot);
 
   // If verbose assembly is enabled, we can print some informative comments.
   if (CommentStream)
     EmitAnyX86InstComments(MI, *CommentStream, MII);
 }
 
+bool X86IntelInstPrinter::printVecCompareInstr(const MCInst *MI, raw_ostream &OS) {
+  if (MI->getNumOperands() == 0 ||
+      !MI->getOperand(MI->getNumOperands() - 1).isImm())
+    return false;
+
+  unsigned Imm = MI->getOperand(MI->getNumOperands() - 1).getImm();
+
+  const MCInstrDesc &Desc = MII.get(MI->getOpcode());
+
+  // Custom print the vector compare instructions to get the immediate
+  // translated into the mnemonic.
+  switch (MI->getOpcode()) {
+  case X86::VPCOMBmi:  case X86::VPCOMBri:
+  case X86::VPCOMDmi:  case X86::VPCOMDri:
+  case X86::VPCOMQmi:  case X86::VPCOMQri:
+  case X86::VPCOMUBmi: case X86::VPCOMUBri:
+  case X86::VPCOMUDmi: case X86::VPCOMUDri:
+  case X86::VPCOMUQmi: case X86::VPCOMUQri:
+  case X86::VPCOMUWmi: case X86::VPCOMUWri:
+  case X86::VPCOMWmi:  case X86::VPCOMWri:
+    if (Imm >= 0 && Imm <= 7) {
+      printVPCOMMnemonic(MI, OS);
+      printOperand(MI, 0, OS);
+      OS << ", ";
+      printOperand(MI, 1, OS);
+      OS << ", ";
+      if ((Desc.TSFlags & X86II::FormMask) == X86II::MRMSrcMem)
+        printi128mem(MI, 2, OS);
+      else
+        printOperand(MI, 2, OS);
+      return true;
+    }
+    break;
+  }
+
+  return false;
+}
+
 void X86IntelInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
                                        raw_ostream &O) {
   const MCOperand &Op = MI->getOperand(OpNo);
   if (Op.isReg()) {
     printRegName(O, Op.getReg());
   } else if (Op.isImm()) {
     O << formatImm((int64_t)Op.getImm());
   } else {

llvm/trunk/lib/Target/X86/X86InstrInfo.td

def AVXCC : Operand<i8> {
   let OperandType = "OPERAND_IMMEDIATE";
 }
 
 def AVX512ICC : Operand<i8> {
   let PrintMethod = "printSSEAVXCC";
   let OperandType = "OPERAND_IMMEDIATE";
 }
 
-def XOPCC : Operand<i8> {
-  let PrintMethod = "printXOPCC";
-  let OperandType = "OPERAND_IMMEDIATE";
-}
-
 class ImmSExtAsmOperandClass : AsmOperandClass {
   let SuperClasses = [ImmAsmOperand];
   let RenderMethod = "addImmOperands";
 }
 
 def X86GR32orGR64AsmOperand : AsmOperandClass {
   let Name = "GR32orGR64";
 }

llvm/trunk/lib/Target/X86/X86InstrXOP.td

 }]>;
 
 // Instruction where second source can be memory, third must be imm8
 multiclass xopvpcom<bits<8> opc, string Suffix, SDNode OpNode, ValueType vt128,
                     X86FoldableSchedWrite sched> {
   let ExeDomain = SSEPackedInt in { // SSE integer instructions
     let isCommutable = 1 in
     def ri : IXOPi8<opc, MRMSrcReg, (outs VR128:$dst),
-             (ins VR128:$src1, VR128:$src2, XOPCC:$cc),
-             !strconcat("vpcom${cc}", Suffix,
-             "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
+             (ins VR128:$src1, VR128:$src2, u8imm:$cc),
+             !strconcat("vpcom", Suffix,
+             "\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}"),
              [(set VR128:$dst,
                 (vt128 (OpNode (vt128 VR128:$src1), (vt128 VR128:$src2),
                                imm:$cc)))]>,
              XOP_4V, Sched<[sched]>;
     def mi : IXOPi8<opc, MRMSrcMem, (outs VR128:$dst),
-             (ins VR128:$src1, i128mem:$src2, XOPCC:$cc),
-             !strconcat("vpcom${cc}", Suffix,
-             "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
+             (ins VR128:$src1, i128mem:$src2, u8imm:$cc),
+             !strconcat("vpcom", Suffix,
+             "\t{$cc, $src2, $src1, $dst|$dst, $src1, $src2, $cc}"),
              [(set VR128:$dst,
                 (vt128 (OpNode (vt128 VR128:$src1),
                                (vt128 (load addr:$src2)),
                                 imm:$cc)))]>,
              XOP_4V, Sched<[sched.Folded, sched.ReadAfterFold]>;
-    let isAsmParserOnly = 1, hasSideEffects = 0 in {
-      def ri_alt : IXOPi8<opc, MRMSrcReg, (outs VR128:$dst),
-                   (ins VR128:$src1, VR128:$src2, u8imm:$src3),
-                   !strconcat("vpcom", Suffix,
-                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
-                   []>, XOP_4V, Sched<[sched]>, NotMemoryFoldable;
-      let mayLoad = 1 in
-      def mi_alt : IXOPi8<opc, MRMSrcMem, (outs VR128:$dst),
-                   (ins VR128:$src1, i128mem:$src2, u8imm:$src3),
-                   !strconcat("vpcom", Suffix,
-                   "\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}"),
-                   []>, XOP_4V, Sched<[sched.Folded, sched.ReadAfterFold]>,
-                   NotMemoryFoldable;
-    }
   }
 
   def : Pat<(OpNode (load addr:$src2),
                     (vt128 VR128:$src1), imm:$cc),
             (!cast<Instruction>(NAME#"mi") VR128:$src1, addr:$src2,
                                            (CommuteVPCOMCC imm:$cc))>;
 }
 

llvm/trunk/test/tools/llvm-mca/X86/BdVer2/resources-xop.s

 # CHECK-NEXT:  2      10    1.00                        vfrczss %xmm0, %xmm3
 # CHECK-NEXT:  2      15    1.00    *                   vfrczss (%rax), %xmm3
 # CHECK-NEXT:  1      2     0.50                        vpcmov  %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  1      7     0.50    *                   vpcmov  (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  1      7     0.50    *                   vpcmov  %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  2      2     0.50                        vpcmov  %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  2      7     1.00    *                   vpcmov  (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  2      7     1.00    *                   vpcmov  %ymm0, (%rax), %ymm1, %ymm3
-# CHECK-NEXT:  1      2     0.50                        vpcomb  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomb  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomd  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomd  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomq  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomq  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomub $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomub $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomud $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomud $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomuq $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomuq $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomuw $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomuw $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      2     0.50                        vpcomw  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  1      7     0.50    *                   vpcomw  $0, (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltb  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltb  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltd  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltd  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltq  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltq  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltub %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltub (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltud %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltud (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltuq %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltuq (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltuw %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltuw (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      2     0.50                        vpcomltw  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  1      7     0.50    *                   vpcomltw  (%rax), %xmm0, %xmm3
 # CHECK-NEXT:  1      3     2.00                        vpermil2pd  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  1      8     2.00    *                   vpermil2pd  $0, (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  1      8     2.00    *                   vpermil2pd  $0, %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  2      3     3.00                        vpermil2pd  $0, %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  2      8     3.00    *                   vpermil2pd  $0, (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  2      8     3.00    *                   vpermil2pd  $0, %ymm0, (%rax), %ymm1, %ymm3
 # CHECK-NEXT:  1      3     2.00                        vpermil2ps  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  1      8     2.00    *                   vpermil2ps  $0, (%rax), %xmm0, %xmm1, %xmm3

 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     vfrczss  %xmm0, %xmm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     vfrczss  (%rax), %xmm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcmov %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcmov (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcmov %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcmov %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT: 1.00   1.00    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     1.00   1.00    -      -     vpcmov (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT: 1.00   1.00    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     1.00   1.00    -      -     vpcmov %ymm0, (%rax), %ymm1, %ymm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomb  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomb  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomd  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomd  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomq  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomq  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomub  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomub  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomud  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomud  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomuq  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomuq  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomuw  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomuw  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomw  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomw  $0, (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltb %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltb  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltd %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltd  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltq %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltq  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltub  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltub  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltud  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltud  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltuq  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltuq  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltuw  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltuw  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -      -      -      -      -     vpcomltw %xmm0, %xmm1, %xmm3
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     0.50   0.50    -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpcomltw  (%rax), %xmm0, %xmm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     2.00   2.00    -      -      -      -     0.50   0.50    -      -      -      -      -      -      -     vpermil2pd $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     2.00   2.00    -      -      -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpermil2pd $0, (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     2.00   2.00    -      -      -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpermil2pd $0, %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     3.00   3.00    -      -      -      -     1.00   1.00    -      -      -      -      -      -      -     vpermil2pd $0, %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT: 1.00   1.00    -      -      -      -      -      -     3.00   3.00    -      -      -      -     1.00   1.00    -      -      -     1.00   1.00    -      -     vpermil2pd $0, (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT: 1.00   1.00    -      -      -      -      -      -     3.00   3.00    -      -      -      -     1.00   1.00    -      -      -     1.00   1.00    -      -     vpermil2pd $0, %ymm0, (%rax), %ymm1, %ymm3
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     2.00   2.00    -      -      -      -     0.50   0.50    -      -      -      -      -      -      -     vpermil2ps $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     2.00   2.00    -      -      -      -     0.50   0.50    -      -      -     0.50   0.50    -      -     vpermil2ps $0, (%rax), %xmm0, %xmm1, %xmm3

llvm/trunk/test/tools/llvm-mca/X86/Generic/resources-xop.s

 # CHECK-NEXT:  1      3     1.00                        vfrczss %xmm0, %xmm3
 # CHECK-NEXT:  2      9     1.00    *                   vfrczss (%rax), %xmm3
 # CHECK-NEXT:  1      1     0.50                        vpcmov  %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  2      7     0.50    *                   vpcmov  (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  2      7     0.50    *                   vpcmov  %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  1      1     1.00                        vpcmov  %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  2      8     1.00    *                   vpcmov  (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  2      8     1.00    *                   vpcmov  %ymm0, (%rax), %ymm1, %ymm3
-# CHECK-NEXT:  1      1     0.50                        vpcomb  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomb  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomd  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomd  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomq  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomq  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomub $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomub $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomud $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomud $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomuq $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomuq $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomuw $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomuw $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  1      1     0.50                        vpcomw  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  2      7     0.50    *                   vpcomw  $0, (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltb  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltb  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltd  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltd  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltq  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltq  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltub %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltub (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltud %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltud (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltuq %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltuq (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltuw %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltuw (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  1      1     0.50                        vpcomltw  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  2      7     0.50    *                   vpcomltw  (%rax), %xmm0, %xmm3
 # CHECK-NEXT:  1      1     1.00                        vpermil2pd  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  2      7     1.00    *                   vpermil2pd  $0, (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  2      7     1.00    *                   vpermil2pd  $0, %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  1      1     1.00                        vpermil2pd  $0, %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  2      8     1.00    *                   vpermil2pd  $0, (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  2      8     1.00    *                   vpermil2pd  $0, %ymm0, (%rax), %ymm1, %ymm3
 # CHECK-NEXT:  1      1     1.00                        vpermil2ps  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  2      7     1.00    *                   vpermil2ps  $0, (%rax), %xmm0, %xmm1, %xmm3

 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     vfrczss %xmm0, %xmm3
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   vfrczss (%rax), %xmm3
 # CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcmov  %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcmov  (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcmov  %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     vpcmov  %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpcmov  (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpcmov  %ymm0, (%rax), %ymm1, %ymm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomb  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomb  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomd  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomd  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomq  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomq  $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomub $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomub $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomud $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomud $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomuq $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomuq $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomuw $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomuw $0, (%rax), %xmm0, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomw  $0, %xmm0, %xmm1, %xmm3
-# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomw  $0, (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltb  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltb  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltd  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltd  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltq  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltq  (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltub %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltub (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltud %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltud (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltuq %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltuq (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltuw %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltuw (%rax), %xmm0, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50    -      -     vpcomltw  %xmm0, %xmm1, %xmm3
+# CHECK-NEXT:  -      -      -     0.50    -     0.50   0.50   0.50   vpcomltw  (%rax), %xmm0, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     vpermil2pd  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpermil2pd  $0, (%rax), %xmm0, %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpermil2pd  $0, %xmm0, (%rax), %xmm1, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     vpermil2pd  $0, %ymm0, %ymm1, %ymm2, %ymm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpermil2pd  $0, (%rax), %ymm0, %ymm1, %ymm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpermil2pd  $0, %ymm0, (%rax), %ymm1, %ymm3
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     vpermil2ps  $0, %xmm0, %xmm1, %xmm2, %xmm3
 # CHECK-NEXT:  -      -      -      -      -     1.00   0.50   0.50   vpermil2ps  $0, (%rax), %xmm0, %xmm1, %xmm3

llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp

OperandType RecognizableInstr::typeFromString(const std::string &s,
   TYPE("RSTi",                TYPE_ST)
   TYPE("i128mem",             TYPE_M)
   TYPE("i256mem",             TYPE_M)
   TYPE("i512mem",             TYPE_M)
   TYPE("i64i32imm_pcrel",     TYPE_REL)
   TYPE("i16imm_pcrel",        TYPE_REL)
   TYPE("i32imm_pcrel",        TYPE_REL)
   TYPE("SSECC",               TYPE_IMM3)
-  TYPE("XOPCC",               TYPE_IMM3)
   TYPE("AVXCC",               TYPE_IMM5)
   TYPE("AVX512ICC",           TYPE_AVX512ICC)
   TYPE("AVX512RC",            TYPE_IMM)
   TYPE("brtarget32",          TYPE_REL)
   TYPE("brtarget16",          TYPE_REL)
   TYPE("brtarget8",           TYPE_REL)
   TYPE("f80mem",              TYPE_M)
   TYPE("lea64_32mem",         TYPE_M)
RecognizableInstr::immediateEncodingFromString(const std::string &s,
                                                uint8_t OpSize) {
   if(OpSize != X86Local::OpSize16) {
     // For instructions without an OpSize prefix, a declared 16-bit register or
     // immediate encoding is special.
     ENCODING("i16imm",        ENCODING_IW)
   }
   ENCODING("i32i8imm",        ENCODING_IB)
   ENCODING("SSECC",           ENCODING_IB)
-  ENCODING("XOPCC",           ENCODING_IB)
   ENCODING("AVXCC",           ENCODING_IB)
   ENCODING("AVX512ICC",       ENCODING_IB)
   ENCODING("AVX512RC",        ENCODING_IRC)
   ENCODING("i16imm",          ENCODING_Iv)
   ENCODING("i16i8imm",        ENCODING_IB)
   ENCODING("i32imm",          ENCODING_Iv)
   ENCODING("i64i32imm",       ENCODING_ID)
   ENCODING("i64i8imm",        ENCODING_IB)