[X86] Support avx512fp16 compare instructions in the IntelInstPrinter.

[pengfei]

Summary

This enables printing of the mnemonics that contain the predicate
in the Intel printer. This requires accounting for the memory size
that is explicitly printed in Intel syntax. Those changes have been
synced to the ATT printer as well.

[pengfei]

LGTM. Thanks Craig for fixing it.

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

Why don't use assert like above?

[craig.topper]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

TA can also have PS and/or PD which need to got to EVEX_L2/VEX_L. So I didn't see a clean way to do it. Feel free to make a concrete suggestion.

[pengfei]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

How about:

if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XS) {
  if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA)
    printwordmem(MI, CurOp--, OS);
  else
    printdwordmem(MI, CurOp--, OS);
} else if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XD) {
  assert((Desc.TSFlags & X86II::OpMapMask) != X86II::TA) &&
         "Unexpected op map!");
  printqwordmem(MI, CurOp--, OS);
} ...

[pengfei]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

Sorry for the noise, I missed the EVEX_L2/VEX_L.

[pengfei]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

Emm, seems correct :)

[craig.topper]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

That should work. Do you mind taking over this patch?

[pengfei]

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

203–207

Sure.

[pengfei]

Refine the assertions and Intel syntax tests.

[craig.topper]

LGTM

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

if (Imm >= 0 && Imm <= 31) {
       OS << '\t';
       printCMPMnemonic(MI, /*IsVCMP*/true, OS);
 
       unsigned CurOp = (Desc.TSFlags & X86II::EVEX_K) ? 3 : 2;
 
       if ((Desc.TSFlags & X86II::FormMask) == X86II::MRMSrcMem) {
         if (Desc.TSFlags & X86II::EVEX_B) {
           // Broadcast form.
-          // Load size is based on W-bit.
-          if (Desc.TSFlags & X86II::VEX_W)
+          // Load size is word for TA map. Otherwise it is based on W-bit.
+          if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA) {
+            assert(!(Desc.TSFlags & X86II::VEX_W) && "Unknown W-bit value!");
+            printwordmem(MI, CurOp--, OS);
+          } else if (Desc.TSFlags & X86II::VEX_W) {
             printqwordmem(MI, CurOp--, OS);
-          else
+          } else {
             printdwordmem(MI, CurOp--, OS);
+          }
 
           // Print the number of elements broadcasted.
           unsigned NumElts;
           if (Desc.TSFlags & X86II::EVEX_L2)
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 8 : 16;
           else if (Desc.TSFlags & X86II::VEX_L)
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 4 : 8;
           else
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 2 : 4;
-          if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA)
+          if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA) {
+            assert(!(Desc.TSFlags & X86II::VEX_W) && "Unknown W-bit value!");
             NumElts *= 2;
+          }
           OS << "{1to" << NumElts << "}";
         } else {
-          if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XS)
+          if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XS) {
+            if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA)
+              printwordmem(MI, CurOp--, OS);
+            else
               printdwordmem(MI, CurOp--, OS);
-          else if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XD)
+          } else if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XD) {
+            assert((Desc.TSFlags & X86II::OpMapMask) != X86II::TA &&
+                   "Unexpected op map!");
             printqwordmem(MI, CurOp--, OS);
-          else if (Desc.TSFlags & X86II::EVEX_L2)
+          } else if (Desc.TSFlags & X86II::EVEX_L2) {
             printzmmwordmem(MI, CurOp--, OS);
-          else if (Desc.TSFlags & X86II::VEX_L)
+          } else if (Desc.TSFlags & X86II::VEX_L) {
             printymmwordmem(MI, CurOp--, OS);
-          else
+          } else {
             printxmmwordmem(MI, CurOp--, OS);
           }
+        }
       } else {
         if (Desc.TSFlags & X86II::EVEX_B)
           OS << "{sae}, ";
         printOperand(MI, CurOp--, OS);
       }
 
       OS << ", ";
       printOperand(MI, CurOp--, OS);

llvm/lib/Target/X86/MCTargetDesc/X86IntelInstPrinter.cpp

bool X86IntelInstPrinter::printVecCompareInstr(const MCInst *MI, raw_ostream &OS) {
   case X86::VCMPPDZrmbi:    case X86::VCMPPDZrmbik:
   case X86::VCMPPSZ128rmbi: case X86::VCMPPSZ128rmbik:
   case X86::VCMPPSZ256rmbi: case X86::VCMPPSZ256rmbik:
   case X86::VCMPPSZrmbi:    case X86::VCMPPSZrmbik:
   case X86::VCMPPDZrrib:    case X86::VCMPPDZrribk:
   case X86::VCMPPSZrrib:    case X86::VCMPPSZrribk:
   case X86::VCMPSDZrrb_Int: case X86::VCMPSDZrrb_Intk:
   case X86::VCMPSSZrrb_Int: case X86::VCMPSSZrrb_Intk:
+  case X86::VCMPPHZ128rmi:  case X86::VCMPPHZ128rri:
+  case X86::VCMPPHZ256rmi:  case X86::VCMPPHZ256rri:
+  case X86::VCMPPHZrmi:     case X86::VCMPPHZrri:
+  case X86::VCMPSHZrm:      case X86::VCMPSHZrr:
+  case X86::VCMPSHZrm_Int:  case X86::VCMPSHZrr_Int:
+  case X86::VCMPPHZ128rmik: case X86::VCMPPHZ128rrik:
+  case X86::VCMPPHZ256rmik: case X86::VCMPPHZ256rrik:
+  case X86::VCMPPHZrmik:    case X86::VCMPPHZrrik:
+  case X86::VCMPSHZrm_Intk: case X86::VCMPSHZrr_Intk:
+  case X86::VCMPPHZ128rmbi: case X86::VCMPPHZ128rmbik:
+  case X86::VCMPPHZ256rmbi: case X86::VCMPPHZ256rmbik:
+  case X86::VCMPPHZrmbi:    case X86::VCMPPHZrmbik:
+  case X86::VCMPPHZrrib:    case X86::VCMPPHZrribk:
+  case X86::VCMPSHZrrb_Int: case X86::VCMPSHZrrb_Intk:
     if (Imm >= 0 && Imm <= 31) {
       OS << '\t';
       printCMPMnemonic(MI, /*IsVCMP*/true, OS);
 
       unsigned CurOp = 0;
       printOperand(MI, CurOp++, OS);
 
       if (Desc.TSFlags & X86II::EVEX_K) {
         // Print mask operand.
         OS << " {";
         printOperand(MI, CurOp++, OS);
         OS << "}";
       }
       OS << ", ";
       printOperand(MI, CurOp++, OS);
       OS << ", ";
 
       if ((Desc.TSFlags & X86II::FormMask) == X86II::MRMSrcMem) {
         if (Desc.TSFlags & X86II::EVEX_B) {
           // Broadcast form.
-          // Load size is based on W-bit.
-          if (Desc.TSFlags & X86II::VEX_W)
+          // Load size is word for TA map. Otherwise it is based on W-bit.
+          if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA) {
+            assert(!(Desc.TSFlags & X86II::VEX_W) && "Unknown W-bit value!");
+            printwordmem(MI, CurOp++, OS);
+          } else if (Desc.TSFlags & X86II::VEX_W) {
             printqwordmem(MI, CurOp++, OS);
-          else
+          } else {
             printdwordmem(MI, CurOp++, OS);
+          }
 
           // Print the number of elements broadcasted.
           unsigned NumElts;
           if (Desc.TSFlags & X86II::EVEX_L2)
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 8 : 16;
           else if (Desc.TSFlags & X86II::VEX_L)
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 4 : 8;
           else
             NumElts = (Desc.TSFlags & X86II::VEX_W) ? 2 : 4;
+          if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA) {
+            assert(!(Desc.TSFlags & X86II::VEX_W) && "Unknown W-bit value!");
+            NumElts *= 2;
+          }
           OS << "{1to" << NumElts << "}";
         } else {
-          if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XS)
+          if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XS) {
+            if ((Desc.TSFlags & X86II::OpMapMask) == X86II::TA)
+              printwordmem(MI, CurOp++, OS);
+            else
               printdwordmem(MI, CurOp++, OS);
-          else if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XD)
+          } else if ((Desc.TSFlags & X86II::OpPrefixMask) == X86II::XD) {
+            assert((Desc.TSFlags & X86II::OpMapMask) != X86II::TA &&
+                   "Unexpected op map!");
             printqwordmem(MI, CurOp++, OS);
-          else if (Desc.TSFlags & X86II::EVEX_L2)
+          } else if (Desc.TSFlags & X86II::EVEX_L2) {
             printzmmwordmem(MI, CurOp++, OS);
-          else if (Desc.TSFlags & X86II::VEX_L)
+          } else if (Desc.TSFlags & X86II::VEX_L) {
             printymmwordmem(MI, CurOp++, OS);
-          else
+          } else {
             printxmmwordmem(MI, CurOp++, OS);
           }
+        }
       } else {
         printOperand(MI, CurOp++, OS);
         if (Desc.TSFlags & X86II::EVEX_B)
           OS << ", {sae}";
       }
 
       return true;
     }

llvm/test/MC/Disassembler/X86/avx512fp16.txt

 # INTEL: vaddsh xmm30, xmm29, word ptr [rcx + 254]
 0x62,0x65,0x16,0x00,0x58,0x71,0x7f
 
 # ATT:   vaddsh  -256(%rdx), %xmm29, %xmm30 {%k7} {z}
 # INTEL: vaddsh xmm30 {k7} {z}, xmm29, word ptr [rdx - 256]
 0x62,0x65,0x16,0x87,0x58,0x72,0x80
 
 # ATT:   vcmpeqph %zmm28, %zmm29, %k5
-# INTEL: vcmpph k5, zmm29, zmm28, 0
+# INTEL: vcmpeqph k5, zmm29, zmm28
 0x62,0x93,0x14,0x40,0xc2,0xec,0x00
 
 # ATT:   vcmpleph {sae}, %zmm28, %zmm29, %k5
-# INTEL: vcmpph k5, zmm29, zmm28, {sae}, 2
+# INTEL: vcmpleph k5, zmm29, zmm28, {sae}
 0x62,0x93,0x14,0x10,0xc2,0xec,0x02
 
 # ATT:   vcmpneqph 268435456(%rbp,%r14,8), %zmm29, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, zmm29, zmmword ptr [rbp + 8*r14 + 268435456], 4
+# INTEL: vcmpneqph k5 {k7}, zmm29, zmmword ptr [rbp + 8*r14 + 268435456]
 0x62,0xb3,0x14,0x47,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x04
 
 # ATT:   vcmpnleph (%r9){1to32}, %zmm29, %k5
-# INTEL: vcmpph k5, zmm29, word ptr [r9]{1to32}, 6
+# INTEL: vcmpnleph k5, zmm29, word ptr [r9]{1to32}
 0x62,0xd3,0x14,0x50,0xc2,0x29,0x06
 
 # ATT:   vcmpeq_uqph 8128(%rcx), %zmm29, %k5
-# INTEL: vcmpph k5, zmm29, zmmword ptr [rcx + 8128], 8
+# INTEL: vcmpeq_uqph k5, zmm29, zmmword ptr [rcx + 8128]
 0x62,0xf3,0x14,0x40,0xc2,0x69,0x7f,0x08
 
 # ATT:   vcmpngtph -256(%rdx){1to32}, %zmm29, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, zmm29, word ptr [rdx - 256]{1to32}, 10
+# INTEL: vcmpngtph k5 {k7}, zmm29, word ptr [rdx - 256]{1to32}
 0x62,0xf3,0x14,0x57,0xc2,0x6a,0x80,0x0a
 
 # ATT:   vcmpneq_oqsh %xmm28, %xmm29, %k5
-# INTEL: vcmpsh k5, xmm29, xmm28, 12
+# INTEL: vcmpneq_oqsh k5, xmm29, xmm28
 0x62,0x93,0x16,0x00,0xc2,0xec,0x0c
 
 # ATT:   vcmpgtsh {sae}, %xmm28, %xmm29, %k5
-# INTEL: vcmpsh k5, xmm29, xmm28, {sae}, 14
+# INTEL: vcmpgtsh k5, xmm29, xmm28, {sae}
 0x62,0x93,0x16,0x10,0xc2,0xec,0x0e
 
 # ATT:   vcmpeq_ossh 268435456(%rbp,%r14,8), %xmm29, %k5 {%k7}
-# INTEL: vcmpsh k5 {k7}, xmm29, word ptr [rbp + 8*r14 + 268435456], 16
+# INTEL: vcmpeq_ossh k5 {k7}, xmm29, word ptr [rbp + 8*r14 + 268435456]
 0x62,0xb3,0x16,0x07,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x10
 
 # ATT:   vcmple_oqsh (%r9), %xmm29, %k5
-# INTEL: vcmpsh k5, xmm29, word ptr [r9], 18
+# INTEL: vcmple_oqsh k5, xmm29, word ptr [r9]
 0x62,0xd3,0x16,0x00,0xc2,0x29,0x12
 
 # ATT:   vcmpneq_ussh 254(%rcx), %xmm29, %k5
-# INTEL: vcmpsh k5, xmm29, word ptr [rcx + 254], 20
+# INTEL: vcmpneq_ussh k5, xmm29, word ptr [rcx + 254]
 0x62,0xf3,0x16,0x00,0xc2,0x69,0x7f,0x14
 
 # ATT:   vcmpnle_uqsh -256(%rdx), %xmm29, %k5 {%k7}
-# INTEL: vcmpsh k5 {k7}, xmm29, word ptr [rdx - 256], 22
+# INTEL: vcmpnle_uqsh k5 {k7}, xmm29, word ptr [rdx - 256]
 0x62,0xf3,0x16,0x07,0xc2,0x6a,0x80,0x16
 
 # ATT:   vcomish %xmm29, %xmm30
 # INTEL: vcomish xmm30, xmm29
 0x62,0x05,0x7c,0x08,0x2f,0xf5
 
 # ATT:   vcomish {sae}, %xmm29, %xmm30
 # INTEL: vcomish xmm30, xmm29, {sae}

llvm/test/MC/Disassembler/X86/avx512fp16vl.txt

 # INTEL: vaddph xmm6, xmm5, xmmword ptr [ecx + 2032]
 0x62,0xf5,0x54,0x08,0x58,0x71,0x7f
 
 # ATT:   vaddph  -256(%edx){1to8}, %xmm5, %xmm6 {%k7} {z}
 # INTEL: vaddph xmm6 {k7} {z}, xmm5, word ptr [edx - 256]{1to8}
 0x62,0xf5,0x54,0x9f,0x58,0x72,0x80
 
 # ATT:   vcmpltph %ymm4, %ymm5, %k5
-# INTEL: vcmpph k5, ymm5, ymm4, 1
+# INTEL: vcmpltph k5, ymm5, ymm4
 0x62,0xf3,0x54,0x28,0xc2,0xec,0x01
 
 # ATT:   vcmpunordph %xmm4, %xmm5, %k5
-# INTEL: vcmpph k5, xmm5, xmm4, 3
+# INTEL: vcmpunordph k5, xmm5, xmm4
 0x62,0xf3,0x54,0x08,0xc2,0xec,0x03
 
 # ATT:   vcmpnltph 268435456(%esp,%esi,8), %xmm5, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, xmm5, xmmword ptr [esp + 8*esi + 268435456], 5
+# INTEL: vcmpnltph k5 {k7}, xmm5, xmmword ptr [esp + 8*esi + 268435456]
 0x62,0xf3,0x54,0x0f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x05
 
 # ATT:   vcmpordph (%ecx){1to8}, %xmm5, %k5
-# INTEL: vcmpph k5, xmm5, word ptr [ecx]{1to8}, 7
+# INTEL: vcmpordph k5, xmm5, word ptr [ecx]{1to8}
 0x62,0xf3,0x54,0x18,0xc2,0x29,0x07
 
 # ATT:   vcmpngeph 2032(%ecx), %xmm5, %k5
-# INTEL: vcmpph k5, xmm5, xmmword ptr [ecx + 2032], 9
+# INTEL: vcmpngeph k5, xmm5, xmmword ptr [ecx + 2032]
 0x62,0xf3,0x54,0x08,0xc2,0x69,0x7f,0x09
 
 # ATT:   vcmpfalseph -256(%edx){1to8}, %xmm5, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, xmm5, word ptr [edx - 256]{1to8}, 11
+# INTEL: vcmpfalseph k5 {k7}, xmm5, word ptr [edx - 256]{1to8}
 0x62,0xf3,0x54,0x1f,0xc2,0x6a,0x80,0x0b
 
 # ATT:   vcmpgeph 268435456(%esp,%esi,8), %ymm5, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, ymm5, ymmword ptr [esp + 8*esi + 268435456], 13
+# INTEL: vcmpgeph k5 {k7}, ymm5, ymmword ptr [esp + 8*esi + 268435456]
 0x62,0xf3,0x54,0x2f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x0d
 
 # ATT:   vcmptrueph (%ecx){1to16}, %ymm5, %k5
-# INTEL: vcmpph k5, ymm5, word ptr [ecx]{1to16}, 15
+# INTEL: vcmptrueph k5, ymm5, word ptr [ecx]{1to16}
 0x62,0xf3,0x54,0x38,0xc2,0x29,0x0f
 
 # ATT:   vcmplt_oqph 4064(%ecx), %ymm5, %k5
-# INTEL: vcmpph k5, ymm5, ymmword ptr [ecx + 4064], 17
+# INTEL: vcmplt_oqph k5, ymm5, ymmword ptr [ecx + 4064]
 0x62,0xf3,0x54,0x28,0xc2,0x69,0x7f,0x11
 
 # ATT:   vcmpunord_sph -256(%edx){1to16}, %ymm5, %k5 {%k7}
-# INTEL: vcmpph k5 {k7}, ymm5, word ptr [edx - 256]{1to16}, 19
+# INTEL: vcmpunord_sph k5 {k7}, ymm5, word ptr [edx - 256]{1to16}
 0x62,0xf3,0x54,0x3f,0xc2,0x6a,0x80,0x13
 
 # ATT:   vdivph %ymm4, %ymm5, %ymm6
 # INTEL: vdivph ymm6, ymm5, ymm4
 0x62,0xf5,0x54,0x28,0x5e,0xf4
 
 # ATT:   vdivph %xmm4, %xmm5, %xmm6
 # INTEL: vdivph xmm6, xmm5, xmm4

llvm/test/MC/X86/intel-syntax-avx512fp16.s

 // CHECK: vaddsh xmm6, xmm5, word ptr [ecx + 254]
 // CHECK: encoding: [0x62,0xf5,0x56,0x08,0x58,0x71,0x7f]
           vaddsh xmm6, xmm5, word ptr [ecx + 254]
 
 // CHECK: vaddsh xmm6 {k7} {z}, xmm5, word ptr [edx - 256]
 // CHECK: encoding: [0x62,0xf5,0x56,0x8f,0x58,0x72,0x80]
           vaddsh xmm6 {k7} {z}, xmm5, word ptr [edx - 256]
 
-// CHECK: vcmpph k5, zmm5, zmm4, 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x48,0xc2,0xec,0x7b]
-          vcmpph k5, zmm5, zmm4, 123
-
-// CHECK: vcmpph k5, zmm5, zmm4, {sae}, 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x18,0xc2,0xec,0x7b]
-          vcmpph k5, zmm5, zmm4, {sae}, 123
-
-// CHECK: vcmpph k5 {k7}, zmm5, zmmword ptr [esp + 8*esi + 268435456], 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x4f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x7b]
-          vcmpph k5 {k7}, zmm5, zmmword ptr [esp + 8*esi + 268435456], 123
-
-// CHECK: vcmpph k5, zmm5, word ptr [ecx]{1to32}, 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x58,0xc2,0x29,0x7b]
-          vcmpph k5, zmm5, word ptr [ecx]{1to32}, 123
-
-// CHECK: vcmpph k5, zmm5, zmmword ptr [ecx + 8128], 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x48,0xc2,0x69,0x7f,0x7b]
-          vcmpph k5, zmm5, zmmword ptr [ecx + 8128], 123
-
-// CHECK: vcmpph k5 {k7}, zmm5, word ptr [edx - 256]{1to32}, 123
-// CHECK: encoding: [0x62,0xf3,0x54,0x5f,0xc2,0x6a,0x80,0x7b]
-          vcmpph k5 {k7}, zmm5, word ptr [edx - 256]{1to32}, 123
-
-// CHECK: vcmpsh k5, xmm5, xmm4, 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0xec,0x7b]
-          vcmpsh k5, xmm5, xmm4, 123
-
-// CHECK: vcmpsh k5, xmm5, xmm4, {sae}, 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x18,0xc2,0xec,0x7b]
-          vcmpsh k5, xmm5, xmm4, {sae}, 123
-
-// CHECK: vcmpsh k5 {k7}, xmm5, word ptr [esp + 8*esi + 268435456], 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x0f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x7b]
-          vcmpsh k5 {k7}, xmm5, word ptr [esp + 8*esi + 268435456], 123
-
-// CHECK: vcmpsh k5, xmm5, word ptr [ecx], 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0x29,0x7b]
-          vcmpsh k5, xmm5, word ptr [ecx], 123
-
-// CHECK: vcmpsh k5, xmm5, word ptr [ecx + 254], 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0x69,0x7f,0x7b]
-          vcmpsh k5, xmm5, word ptr [ecx + 254], 123
-
-// CHECK: vcmpsh k5 {k7}, xmm5, word ptr [edx - 256], 123
-// CHECK: encoding: [0x62,0xf3,0x56,0x0f,0xc2,0x6a,0x80,0x7b]
-          vcmpsh k5 {k7}, xmm5, word ptr [edx - 256], 123
+// CHECK: vcmpneq_usph k5, zmm5, zmm4
+// CHECK: encoding: [0x62,0xf3,0x54,0x48,0xc2,0xec,0x14]
+          vcmpneq_usph k5, zmm5, zmm4
+
+// CHECK: vcmpnlt_uqph k5, zmm5, zmm4, {sae}
+// CHECK: encoding: [0x62,0xf3,0x54,0x18,0xc2,0xec,0x15]
+          vcmpnlt_uqph k5, zmm5, zmm4, {sae}
+
+// CHECK: vcmpnle_uqph k5 {k7}, zmm5, zmmword ptr [esp + 8*esi + 268435456]
+// CHECK: encoding: [0x62,0xf3,0x54,0x4f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x16]
+          vcmpnle_uqph k5 {k7}, zmm5, zmmword ptr [esp + 8*esi + 268435456]
+
+// CHECK: vcmpord_sph k5, zmm5, word ptr [ecx]{1to32}
+// CHECK: encoding: [0x62,0xf3,0x54,0x58,0xc2,0x29,0x17]
+          vcmpord_sph k5, zmm5, word ptr [ecx]{1to32}
+
+// CHECK: vcmpeq_usph k5, zmm5, zmmword ptr [ecx + 8128]
+// CHECK: encoding: [0x62,0xf3,0x54,0x48,0xc2,0x69,0x7f,0x18]
+          vcmpeq_usph k5, zmm5, zmmword ptr [ecx + 8128]
+
+// CHECK: vcmpnge_uqph k5 {k7}, zmm5, word ptr [edx - 256]{1to32}
+// CHECK: encoding: [0x62,0xf3,0x54,0x5f,0xc2,0x6a,0x80,0x19]
+          vcmpnge_uqph k5 {k7}, zmm5, word ptr [edx - 256]{1to32}
+
+// CHECK: vcmpngt_uqsh k5, xmm5, xmm4
+// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0xec,0x1a]
+          vcmpngt_uqsh k5, xmm5, xmm4
+
+// CHECK: vcmpfalse_ossh k5, xmm5, xmm4, {sae}
+// CHECK: encoding: [0x62,0xf3,0x56,0x18,0xc2,0xec,0x1b]
+          vcmpfalse_ossh k5, xmm5, xmm4, {sae}
+
+// CHECK: vcmpneq_ossh k5 {k7}, xmm5, word ptr [esp + 8*esi + 268435456]
+// CHECK: encoding: [0x62,0xf3,0x56,0x0f,0xc2,0xac,0xf4,0x00,0x00,0x00,0x10,0x1c]
+          vcmpneq_ossh k5 {k7}, xmm5, word ptr [esp + 8*esi + 268435456]
+
+// CHECK: vcmpge_oqsh k5, xmm5, word ptr [ecx]
+// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0x29,0x1d]
+          vcmpge_oqsh k5, xmm5, word ptr [ecx]
+
+// CHECK: vcmpgt_oqsh k5, xmm5, word ptr [ecx + 254]
+// CHECK: encoding: [0x62,0xf3,0x56,0x08,0xc2,0x69,0x7f,0x1e]
+          vcmpgt_oqsh k5, xmm5, word ptr [ecx + 254]
+
+// CHECK: vcmptrue_ussh k5 {k7}, xmm5, word ptr [edx - 256]
+// CHECK: encoding: [0x62,0xf3,0x56,0x0f,0xc2,0x6a,0x80,0x1f]
+          vcmptrue_ussh k5 {k7}, xmm5, word ptr [edx - 256]
 
 // CHECK: vcomish xmm6, xmm5
 // CHECK: encoding: [0x62,0xf5,0x7c,0x08,0x2f,0xf5]
           vcomish xmm6, xmm5
 
 // CHECK: vcomish xmm6, xmm5, {sae}
 // CHECK: encoding: [0x62,0xf5,0x7c,0x18,0x2f,0xf5]
           vcomish xmm6, xmm5, {sae}

llvm/test/MC/X86/intel-syntax-avx512fp16vl.s

 // CHECK: vaddph xmm30, xmm29, xmmword ptr [rcx + 2032]
 // CHECK: encoding: [0x62,0x65,0x14,0x00,0x58,0x71,0x7f]
           vaddph xmm30, xmm29, xmmword ptr [rcx + 2032]
 
 // CHECK: vaddph xmm30 {k7} {z}, xmm29, word ptr [rdx - 256]{1to8}
 // CHECK: encoding: [0x62,0x65,0x14,0x97,0x58,0x72,0x80]
           vaddph xmm30 {k7} {z}, xmm29, word ptr [rdx - 256]{1to8}
 
-// CHECK: vcmpph k5, ymm29, ymm28, 123
-// CHECK: encoding: [0x62,0x93,0x14,0x20,0xc2,0xec,0x7b]
-          vcmpph k5, ymm29, ymm28, 123
-
-// CHECK: vcmpph k5, xmm29, xmm28, 123
-// CHECK: encoding: [0x62,0x93,0x14,0x00,0xc2,0xec,0x7b]
-          vcmpph k5, xmm29, xmm28, 123
-
-// CHECK: vcmpph k5 {k7}, xmm29, xmmword ptr [rbp + 8*r14 + 268435456], 123
-// CHECK: encoding: [0x62,0xb3,0x14,0x07,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x7b]
-          vcmpph k5 {k7}, xmm29, xmmword ptr [rbp + 8*r14 + 268435456], 123
-
-// CHECK: vcmpph k5, xmm29, word ptr [r9]{1to8}, 123
-// CHECK: encoding: [0x62,0xd3,0x14,0x10,0xc2,0x29,0x7b]
-          vcmpph k5, xmm29, word ptr [r9]{1to8}, 123
-
-// CHECK: vcmpph k5, xmm29, xmmword ptr [rcx + 2032], 123
-// CHECK: encoding: [0x62,0xf3,0x14,0x00,0xc2,0x69,0x7f,0x7b]
-          vcmpph k5, xmm29, xmmword ptr [rcx + 2032], 123
-
-// CHECK: vcmpph k5 {k7}, xmm29, word ptr [rdx - 256]{1to8}, 123
-// CHECK: encoding: [0x62,0xf3,0x14,0x17,0xc2,0x6a,0x80,0x7b]
-          vcmpph k5 {k7}, xmm29, word ptr [rdx - 256]{1to8}, 123
-
-// CHECK: vcmpph k5 {k7}, ymm29, ymmword ptr [rbp + 8*r14 + 268435456], 123
-// CHECK: encoding: [0x62,0xb3,0x14,0x27,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x7b]
-          vcmpph k5 {k7}, ymm29, ymmword ptr [rbp + 8*r14 + 268435456], 123
-
-// CHECK: vcmpph k5, ymm29, word ptr [r9]{1to16}, 123
-// CHECK: encoding: [0x62,0xd3,0x14,0x30,0xc2,0x29,0x7b]
-          vcmpph k5, ymm29, word ptr [r9]{1to16}, 123
-
-// CHECK: vcmpph k5, ymm29, ymmword ptr [rcx + 4064], 123
-// CHECK: encoding: [0x62,0xf3,0x14,0x20,0xc2,0x69,0x7f,0x7b]
-          vcmpph k5, ymm29, ymmword ptr [rcx + 4064], 123
-
-// CHECK: vcmpph k5 {k7}, ymm29, word ptr [rdx - 256]{1to16}, 123
-// CHECK: encoding: [0x62,0xf3,0x14,0x37,0xc2,0x6a,0x80,0x7b]
-          vcmpph k5 {k7}, ymm29, word ptr [rdx - 256]{1to16}, 123
+// CHECK: vcmpeqph k5, ymm29, ymm28
+// CHECK: encoding: [0x62,0x93,0x14,0x20,0xc2,0xec,0x00]
+          vcmpph k5, ymm29, ymm28, 0
+
+// CHECK: vcmpltph k5, xmm29, xmm28
+// CHECK: encoding: [0x62,0x93,0x14,0x00,0xc2,0xec,0x01]
+          vcmpph k5, xmm29, xmm28, 1
+
+// CHECK: vcmpleph k5 {k7}, xmm29, xmmword ptr [rbp + 8*r14 + 268435456]
+// CHECK: encoding: [0x62,0xb3,0x14,0x07,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x02]
+          vcmpph k5 {k7}, xmm29, xmmword ptr [rbp + 8*r14 + 268435456], 2
+
+// CHECK: vcmpunordph k5, xmm29, word ptr [r9]{1to8}
+// CHECK: encoding: [0x62,0xd3,0x14,0x10,0xc2,0x29,0x03]
+          vcmpph k5, xmm29, word ptr [r9]{1to8}, 3
+
+// CHECK: vcmpneqph k5, xmm29, xmmword ptr [rcx + 2032]
+// CHECK: encoding: [0x62,0xf3,0x14,0x00,0xc2,0x69,0x7f,0x04]
+          vcmpph k5, xmm29, xmmword ptr [rcx + 2032], 4
+
+// CHECK: vcmpnltph k5 {k7}, xmm29, word ptr [rdx - 256]{1to8}
+// CHECK: encoding: [0x62,0xf3,0x14,0x17,0xc2,0x6a,0x80,0x05]
+          vcmpph k5 {k7}, xmm29, word ptr [rdx - 256]{1to8}, 5
+
+// CHECK: vcmpnleph k5 {k7}, ymm29, ymmword ptr [rbp + 8*r14 + 268435456]
+// CHECK: encoding: [0x62,0xb3,0x14,0x27,0xc2,0xac,0xf5,0x00,0x00,0x00,0x10,0x06]
+          vcmpph k5 {k7}, ymm29, ymmword ptr [rbp + 8*r14 + 268435456], 6
+
+// CHECK: vcmpordph k5, ymm29, word ptr [r9]{1to16}
+// CHECK: encoding: [0x62,0xd3,0x14,0x30,0xc2,0x29,0x07]
+          vcmpph k5, ymm29, word ptr [r9]{1to16}, 7
+
+// CHECK: vcmpeq_uqph k5, ymm29, ymmword ptr [rcx + 4064]
+// CHECK: encoding: [0x62,0xf3,0x14,0x20,0xc2,0x69,0x7f,0x08]
+          vcmpph k5, ymm29, ymmword ptr [rcx + 4064], 8
+
+// CHECK: vcmpngeph k5 {k7}, ymm29, word ptr [rdx - 256]{1to16}
+// CHECK: encoding: [0x62,0xf3,0x14,0x37,0xc2,0x6a,0x80,0x09]
+          vcmpph k5 {k7}, ymm29, word ptr [rdx - 256]{1to16}, 9
 
 // CHECK: vdivph ymm30, ymm29, ymm28
 // CHECK: encoding: [0x62,0x05,0x14,0x20,0x5e,0xf4]
           vdivph ymm30, ymm29, ymm28
 
 // CHECK: vdivph xmm30, xmm29, xmm28
 // CHECK: encoding: [0x62,0x05,0x14,0x00,0x5e,0xf4]
           vdivph xmm30, xmm29, xmm28