From 28d7eefe8c50d38a03cf545421625ad5ea1be680 Mon Sep 17 00:00:00 2001
From: Iain Sandoe <iain@sandoe.co.uk>
Date: Tue, 20 Aug 2019 11:29:37 +0100
Subject: [PATCH] Backports for AVX512 from LLVM9

Allow assembly parser to accept x/y/z suffixes on  non-memory vfpclassps/pd and on memory forms in intel syntax

The x/y/z suffix is needed to disambiguate the memory form in at&t syntax since no xmm/ymm/zmm register is mentioned.

But we should also allow it for the register and broadcast forms where its not needed for consistency. This matches gas.

The printing code will still only use the suffix for the memory form where it is needed.

llvm-svn: 359903

Remove the redundant suffix in vfpclassp[d,s]'s broadcasting variant

The broadcasting variant for instruction vfpclassp[d,s] shouldn't use suffix q/l. So remove them from the template.

Patch by Pengfei Wang

Differential Revision: https://reviews.llvm.org/D61295

llvm-svn: 359753

backport r359418 to fix AVX512 ATT insn parsing.

Remove some intel syntax aliases on (v)cvtpd2(u)dq,
 (v)cvtpd2ps, (v)cvt(u)qq2ps. Add 'x' and'y' suffix aliases to masked version
 of the same in att syntax.

The 128/256 bit version of these instructions require an 'x' or 'y' suffix to
disambiguate the memory form in att syntax.

We were allowing the same suffix in intel syntax, but it appears gas does not
do that.

gas does allow the 'x' and 'y' suffix on register and broadcast forms even
though its not needed. We were allowing it on unmasked register form, but not on
masked versions or on masked or unmasked broadcast form.

While there fix some test coverage holes so they can be extended with the 'x'
and 'y' suffix tests.
---
 llvm/lib/Target/X86/X86InstrAVX512.td         |  247 ++-
 llvm/lib/Target/X86/X86InstrSSE.td            |   45 +-
 llvm/test/MC/X86/intel-syntax-x86-64-avx.s    |   48 -
 .../MC/X86/intel-syntax-x86-64-avx512f_vl.s   |  112 --
 .../MC/X86/intel-syntax-x86-avx512dq_vl.s     |   96 +
 llvm/test/MC/X86/x86-64-avx512dq.s            |  203 +-
 llvm/test/MC/X86/x86-64-avx512dq_vl.s         | 1694 ++++++++++++++++-
 llvm/test/MC/X86/x86-64-avx512f_vl.s          | 1657 ++++++++++++++++
 8 files changed, 3743 insertions(+), 359 deletions(-)

diff --git a/llvm/lib/Target/X86/X86InstrAVX512.td b/llvm/lib/Target/X86/X86InstrAVX512.td
index 2d95061a821..67b354e56b3 100644
--- a/llvm/lib/Target/X86/X86InstrAVX512.td
+++ b/llvm/lib/Target/X86/X86InstrAVX512.td
@@ -2711,7 +2711,7 @@ multiclass avx512_scalar_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
 //                                  fpclass(reg_vec, broadcast(eltVt), imm)
 multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                                  X86FoldableSchedWrite sched, X86VectorVTInfo _,
-                                 string mem, string broadcast>{
+                                 string mem>{
   let ExeDomain = _.ExeDomain in {
   def rr : AVX512<opc, MRMSrcReg, (outs _.KRC:$dst),
                       (ins _.RC:$src1, i32u8imm:$src2),
@@ -2729,7 +2729,7 @@ multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                       EVEX_K, Sched<[sched]>;
   def rm : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
                     (ins _.MemOp:$src1, i32u8imm:$src2),
-                    OpcodeStr##_.Suffix##mem#
+                    OpcodeStr##_.Suffix#"{"#mem#"}"#
                     "\t{$src2, $src1, $dst|$dst, $src1, $src2}",
                     [(set _.KRC:$dst,(OpNode
                                      (_.VT (bitconvert (_.LdFrag addr:$src1))),
@@ -2737,7 +2737,7 @@ multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                     Sched<[sched.Folded, ReadAfterLd]>;
   def rmk : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
                     (ins _.KRCWM:$mask, _.MemOp:$src1, i32u8imm:$src2),
-                    OpcodeStr##_.Suffix##mem#
+                    OpcodeStr##_.Suffix#"{"#mem#"}"#
                     "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
                     [(set _.KRC:$dst, (and _.KRCWM:$mask, (OpNode
                                   (_.VT (bitconvert (_.LdFrag addr:$src1))),
@@ -2745,7 +2745,7 @@ multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                     EVEX_K, Sched<[sched.Folded, ReadAfterLd]>;
   def rmb : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
                     (ins _.ScalarMemOp:$src1, i32u8imm:$src2),
-                    OpcodeStr##_.Suffix##broadcast##"\t{$src2, ${src1}"##
+                    OpcodeStr##_.Suffix##"\t{$src2, ${src1}"##
                                       _.BroadcastStr##", $dst|$dst, ${src1}"
                                                   ##_.BroadcastStr##", $src2}",
                     [(set _.KRC:$dst,(OpNode
@@ -2755,7 +2755,7 @@ multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                     EVEX_B, Sched<[sched.Folded, ReadAfterLd]>;
   def rmbk : AVX512<opc, MRMSrcMem, (outs _.KRC:$dst),
                     (ins _.KRCWM:$mask, _.ScalarMemOp:$src1, i32u8imm:$src2),
-                    OpcodeStr##_.Suffix##broadcast##"\t{$src2, ${src1}"##
+                    OpcodeStr##_.Suffix##"\t{$src2, ${src1}"##
                           _.BroadcastStr##", $dst {${mask}}|$dst {${mask}}, ${src1}"##
                                                    _.BroadcastStr##", $src2}",
                     [(set _.KRC:$dst,(and _.KRCWM:$mask, (OpNode
@@ -2764,21 +2764,42 @@ multiclass avx512_vector_fpclass<bits<8> opc, string OpcodeStr, SDNode OpNode,
                                      (i32 imm:$src2))))]>,
                     EVEX_B, EVEX_K,  Sched<[sched.Folded, ReadAfterLd]>;
   }
+
+  // Allow registers or broadcast with the x, y, z suffix we use to disambiguate
+  // the memory form.
+  def : InstAlias<OpcodeStr#_.Suffix#mem#
+                  "\t{$src2, $src1, $dst|$dst, $src1, $src2}",
+                  (!cast<Instruction>(NAME#"rr")
+                   _.KRC:$dst, _.RC:$src1, i32u8imm:$src2), 0, "att">;
+  def : InstAlias<OpcodeStr#_.Suffix#mem#
+                  "\t{$src2, $src1, $dst {${mask}}|$dst {${mask}}, $src1, $src2}",
+                  (!cast<Instruction>(NAME#"rrk")
+                   _.KRC:$dst, _.KRCWM:$mask, _.RC:$src1, i32u8imm:$src2), 0, "att">;
+  def : InstAlias<OpcodeStr#_.Suffix#mem#
+                  "\t{$src2, ${src1}"#_.BroadcastStr#", $dst|$dst, ${src1}"#
+                  _.BroadcastStr#", $src2}",
+                  (!cast<Instruction>(NAME#"rmb")
+                   _.KRC:$dst, _.ScalarMemOp:$src1, i32u8imm:$src2), 0, "att">;
+  def : InstAlias<OpcodeStr#_.Suffix#mem#
+                  "\t{$src2, ${src1}"#_.BroadcastStr#", $dst {${mask}}|"
+                  "$dst {${mask}}, ${src1}"#_.BroadcastStr#", $src2}",
+                  (!cast<Instruction>(NAME#"rmbk")
+                   _.KRC:$dst, _.KRCWM:$mask, _.ScalarMemOp:$src1, i32u8imm:$src2), 0, "att">;
 }
 
 multiclass avx512_vector_fpclass_all<string OpcodeStr, AVX512VLVectorVTInfo _,
                                      bits<8> opc, SDNode OpNode,
-                                     X86SchedWriteWidths sched, Predicate prd,
-                                     string broadcast>{
+                                     X86SchedWriteWidths sched,
+                                     Predicate prd>{
   let Predicates = [prd] in {
     defm Z    : avx512_vector_fpclass<opc, OpcodeStr, OpNode, sched.ZMM,
-                                      _.info512, "{z}", broadcast>, EVEX_V512;
+                                      _.info512, "z">, EVEX_V512;
   }
   let Predicates = [prd, HasVLX] in {
     defm Z128 : avx512_vector_fpclass<opc, OpcodeStr, OpNode, sched.XMM,
-                                      _.info128, "{x}", broadcast>, EVEX_V128;
+                                      _.info128, "x">, EVEX_V128;
     defm Z256 : avx512_vector_fpclass<opc, OpcodeStr, OpNode, sched.YMM,
-                                      _.info256, "{y}", broadcast>, EVEX_V256;
+                                      _.info256, "y">, EVEX_V256;
   }
 }
 
@@ -2787,10 +2808,10 @@ multiclass avx512_fp_fpclass_all<string OpcodeStr, bits<8> opcVec,
                                  SDNode ScalarOpNode, X86SchedWriteWidths sched,
                                  Predicate prd> {
   defm PS : avx512_vector_fpclass_all<OpcodeStr,  avx512vl_f32_info, opcVec,
-                                      VecOpNode, sched, prd, "{l}">,
+                                      VecOpNode, sched, prd>,
                                       EVEX_CD8<32, CD8VF>;
   defm PD : avx512_vector_fpclass_all<OpcodeStr,  avx512vl_f64_info, opcVec,
-                                      VecOpNode, sched, prd, "{q}">,
+                                      VecOpNode, sched, prd>,
                                       EVEX_CD8<64, CD8VF> , VEX_W;
   defm SSZ : avx512_scalar_fpclass<opcScalar, OpcodeStr, ScalarOpNode,
                                    sched.Scl, f32x_info, prd>,
@@ -7721,16 +7742,47 @@ multiclass avx512_cvtpd2ps<bits<8> opc, string OpcodeStr, X86SchedWriteWidths sc
                                X86vfpround, sched.XMM, "{1to2}", "{x}">, EVEX_V128;
     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v4f64x_info, fpround,
                                sched.YMM, "{1to4}", "{y}">, EVEX_V256;
-
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, f128mem:$src), 0, "intel">;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, f256mem:$src), 0, "intel">;
   }
+
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrk") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrkz") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst|$dst, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmb") VR128X:$dst, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbk") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbkz") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrk") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrkz") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst|$dst, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmb") VR128X:$dst, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbk") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbkz") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
 }
 
 defm VCVTPD2PS : avx512_cvtpd2ps<0x5A, "vcvtpd2ps", SchedWriteCvtPD2PS>,
@@ -7839,16 +7891,49 @@ multiclass avx512_cvttpd2dq<bits<8> opc, string OpcodeStr, SDNode OpNode,
                                OpNode, sched.XMM, "{1to2}", "{x}">, EVEX_V128;
     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f64x_info, OpNode,
                                sched.YMM, "{1to4}", "{y}">, EVEX_V256;
-
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, i128mem:$src), 0, "intel">;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, i256mem:$src), 0, "intel">;
   }
+
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst,
+                  VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrk") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}} {z}|$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrkz") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst|$dst, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmb") VR128X:$dst,
+                  f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbk") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbkz") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst,
+                  VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrk") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}} {z}|$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrkz") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst|$dst, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmb") VR128X:$dst,
+                  f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbk") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbkz") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
 }
 
 // Convert Double to Signed/Unsigned Doubleword
@@ -7869,16 +7954,47 @@ multiclass avx512_cvtpd2dq<bits<8> opc, string OpcodeStr, SDNode OpNode,
                                sched.XMM, "{1to2}", "{x}">, EVEX_V128;
     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4i32x_info, v4f64x_info, OpNode,
                                sched.YMM, "{1to4}", "{y}">, EVEX_V256;
-
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, f128mem:$src), 0, "intel">;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, f256mem:$src), 0, "intel">;
   }
+
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrk") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}} {z}|$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrkz") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst|$dst, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmb") VR128X:$dst,
+                  f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbk") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbkz") VR128X:$dst,
+                  VK2WM:$mask, f64mem:$src), 0, "att">;
+
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrk") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}} {z}|$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrkz") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst|$dst, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmb") VR128X:$dst,
+                  f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbk") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbkz") VR128X:$dst,
+                  VK4WM:$mask, f64mem:$src), 0, "att">;
 }
 
 // Convert Double to Signed/Unsigned Quardword
@@ -7990,16 +8106,51 @@ multiclass avx512_cvtqq2ps<bits<8> opc, string OpcodeStr, SDNode OpNode,
     defm Z256 : avx512_vcvt_fp<opc, OpcodeStr, v4f32x_info, v4i64x_info, OpNode,
                                sched.YMM, "{1to4}", "{y}">, EVEX_V256,
                                NotEVEX2VEXConvertible;
-
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst, VR128X:$src), 0>;
-    def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z128rm") VR128X:$dst, i128mem:$src), 0, "intel">;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst, VR256X:$src), 0>;
-    def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
-                    (!cast<Instruction>(NAME # "Z256rm") VR128X:$dst, i256mem:$src), 0, "intel">;
   }
+
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z128rr") VR128X:$dst,
+                  VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}}|$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrk") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{$src, $dst {${mask}} {z}|$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z128rrkz") VR128X:$dst,
+                  VK2WM:$mask, VR128X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst|$dst, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmb") VR128X:$dst,
+                  i64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbk") VR128X:$dst,
+                  VK2WM:$mask, i64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"x\t{${src}{1to2}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to2}}",
+                  (!cast<Instruction>(NAME # "Z128rmbkz") VR128X:$dst,
+                  VK2WM:$mask, i64mem:$src), 0, "att">;
+
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst|$dst, $src}",
+                  (!cast<Instruction>(NAME # "Z256rr") VR128X:$dst,
+                  VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}}|"
+                  "$dst {${mask}}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrk") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{$src, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, $src}",
+                  (!cast<Instruction>(NAME # "Z256rrkz") VR128X:$dst,
+                  VK4WM:$mask, VR256X:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst|$dst, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmb") VR128X:$dst,
+                  i64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}}|"
+                  "$dst {${mask}}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbk") VR128X:$dst,
+                  VK4WM:$mask, i64mem:$src), 0, "att">;
+  def : InstAlias<OpcodeStr##"y\t{${src}{1to4}, $dst {${mask}} {z}|"
+                  "$dst {${mask}} {z}, ${src}{1to4}}",
+                  (!cast<Instruction>(NAME # "Z256rmbkz") VR128X:$dst,
+                  VK4WM:$mask, i64mem:$src), 0, "att">;
 }
 
 defm VCVTDQ2PD : avx512_cvtdq2pd<0xE6, "vcvtdq2pd", sint_to_fp, X86VSintToFP,
diff --git a/llvm/lib/Target/X86/X86InstrSSE.td b/llvm/lib/Target/X86/X86InstrSSE.td
index 6a9b2099821..690e6866b5a 100644
--- a/llvm/lib/Target/X86/X86InstrSSE.td
+++ b/llvm/lib/Target/X86/X86InstrSSE.td
@@ -1469,15 +1469,11 @@ def VCVTPD2DQrr  : SDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
                        VEX, Sched<[WriteCvtPD2I]>, VEX_WIG;
 
 // XMM only
-def : InstAlias<"vcvtpd2dqx\t{$src, $dst|$dst, $src}",
-                (VCVTPD2DQrr VR128:$dst, VR128:$src), 0>;
 def VCVTPD2DQrm : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
                       "vcvtpd2dq{x}\t{$src, $dst|$dst, $src}",
                       [(set VR128:$dst,
                         (v4i32 (X86cvtp2Int (loadv2f64 addr:$src))))]>, VEX,
                       Sched<[WriteCvtPD2ILd]>, VEX_WIG;
-def : InstAlias<"vcvtpd2dqx\t{$src, $dst|$dst, $src}",
-                (VCVTPD2DQrm VR128:$dst, f128mem:$src), 0, "intel">;
 
 // YMM only
 def VCVTPD2DQYrr : SDI<0xE6, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
@@ -1490,12 +1486,13 @@ def VCVTPD2DQYrm : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
                        [(set VR128:$dst,
                          (v4i32 (X86cvtp2Int (loadv4f64 addr:$src))))]>,
                        VEX, VEX_L, Sched<[WriteCvtPD2IYLd]>, VEX_WIG;
-def : InstAlias<"vcvtpd2dqy\t{$src, $dst|$dst, $src}",
-                (VCVTPD2DQYrr VR128:$dst, VR256:$src), 0>;
-def : InstAlias<"vcvtpd2dqy\t{$src, $dst|$dst, $src}",
-                (VCVTPD2DQYrm VR128:$dst, f256mem:$src), 0, "intel">;
 }
 
+def : InstAlias<"vcvtpd2dqx\t{$src, $dst|$dst, $src}",
+                (VCVTPD2DQrr VR128:$dst, VR128:$src), 0, "att">;
+def : InstAlias<"vcvtpd2dqy\t{$src, $dst|$dst, $src}",
+                (VCVTPD2DQYrr VR128:$dst, VR256:$src), 0, "att">;
+
 def CVTPD2DQrm  : SDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
                       "cvtpd2dq\t{$src, $dst|$dst, $src}",
                       [(set VR128:$dst,
@@ -1583,8 +1580,6 @@ def VCVTTPD2DQrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
                         [(set VR128:$dst,
                           (v4i32 (X86cvttp2si (loadv2f64 addr:$src))))]>,
                         VEX, Sched<[WriteCvtPD2ILd]>, VEX_WIG;
-def : InstAlias<"vcvttpd2dqx\t{$src, $dst|$dst, $src}",
-                (VCVTTPD2DQrm VR128:$dst, f128mem:$src), 0, "intel">;
 
 // YMM only
 let Predicates = [HasAVX, NoVLX] in {
@@ -1598,11 +1593,12 @@ def VCVTTPD2DQYrm : VPDI<0xE6, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
                          [(set VR128:$dst,
                            (v4i32 (X86cvttp2si (loadv4f64 addr:$src))))]>,
                          VEX, VEX_L, Sched<[WriteCvtPD2IYLd]>, VEX_WIG;
-}
-def : InstAlias<"vcvttpd2dqy\t{$src, $dst|$dst, $src}",
-                (VCVTTPD2DQYrr VR128:$dst, VR256:$src), 0>;
+} // Predicates = [HasAVX, NoVLX]
+
+def : InstAlias<"vcvttpd2dqx\t{$src, $dst|$dst, $src}",
+                (VCVTTPD2DQrr VR128:$dst, VR128:$src), 0, "att">;
 def : InstAlias<"vcvttpd2dqy\t{$src, $dst|$dst, $src}",
-                (VCVTTPD2DQYrm VR128:$dst, f256mem:$src), 0, "intel">;
+                (VCVTTPD2DQYrr VR128:$dst, VR256:$src), 0, "att">;
 
 let Predicates = [HasAVX, NoVLX] in {
   def : Pat<(v4i32 (fp_to_sint (v4f64 VR256:$src))),
@@ -1742,25 +1738,17 @@ let Predicates = [UseSSE2] in {
 // The assembler can recognize rr 256-bit instructions by seeing a ymm
 // register, but the same isn't true when using memory operands instead.
 // Provide other assembly rr and rm forms to address this explicitly.
-let Predicates = [HasAVX, NoVLX] in
+let Predicates = [HasAVX, NoVLX] in {
+// XMM only
 def VCVTPD2PSrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
                        "cvtpd2ps\t{$src, $dst|$dst, $src}",
                        [(set VR128:$dst, (X86vfpround (v2f64 VR128:$src)))]>,
                        VEX, Sched<[WriteCvtPD2PS]>, VEX_WIG;
-
-// XMM only
-def : InstAlias<"vcvtpd2psx\t{$src, $dst|$dst, $src}",
-                (VCVTPD2PSrr VR128:$dst, VR128:$src), 0>;
-let Predicates = [HasAVX, NoVLX] in
 def VCVTPD2PSrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f128mem:$src),
                        "cvtpd2ps{x}\t{$src, $dst|$dst, $src}",
                        [(set VR128:$dst, (X86vfpround (loadv2f64 addr:$src)))]>,
                        VEX, Sched<[WriteCvtPD2PS.Folded]>, VEX_WIG;
-def : InstAlias<"vcvtpd2psx\t{$src, $dst|$dst, $src}",
-                (VCVTPD2PSrm VR128:$dst, f128mem:$src), 0, "intel">;
 
-// YMM only
-let Predicates = [HasAVX, NoVLX] in {
 def VCVTPD2PSYrr : VPDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR256:$src),
                         "cvtpd2ps\t{$src, $dst|$dst, $src}",
                         [(set VR128:$dst, (fpround VR256:$src))]>,
@@ -1769,11 +1757,12 @@ def VCVTPD2PSYrm : VPDI<0x5A, MRMSrcMem, (outs VR128:$dst), (ins f256mem:$src),
                         "cvtpd2ps{y}\t{$src, $dst|$dst, $src}",
                         [(set VR128:$dst, (fpround (loadv4f64 addr:$src)))]>,
                         VEX, VEX_L, Sched<[WriteCvtPD2PSY.Folded]>, VEX_WIG;
-}
-def : InstAlias<"vcvtpd2psy\t{$src, $dst|$dst, $src}",
-                (VCVTPD2PSYrr VR128:$dst, VR256:$src), 0>;
+} // Predicates = [HasAVX, NoVLX]
+
+def : InstAlias<"vcvtpd2psx\t{$src, $dst|$dst, $src}",
+                (VCVTPD2PSrr VR128:$dst, VR128:$src), 0, "att">;
 def : InstAlias<"vcvtpd2psy\t{$src, $dst|$dst, $src}",
-                (VCVTPD2PSYrm VR128:$dst, f256mem:$src), 0, "intel">;
+                (VCVTPD2PSYrr VR128:$dst, VR256:$src), 0, "att">;
 
 def CVTPD2PSrr : PDI<0x5A, MRMSrcReg, (outs VR128:$dst), (ins VR128:$src),
                      "cvtpd2ps\t{$src, $dst|$dst, $src}",
diff --git a/llvm/test/MC/X86/intel-syntax-x86-64-avx.s b/llvm/test/MC/X86/intel-syntax-x86-64-avx.s
index 3fdb758b0a0..bb57cb287f3 100644
--- a/llvm/test/MC/X86/intel-syntax-x86-64-avx.s
+++ b/llvm/test/MC/X86/intel-syntax-x86-64-avx.s
@@ -68,98 +68,50 @@
 // CHECK: encoding: [0xc4,0xc1,0x79,0x5a,0xc7]
           vcvtpd2ps xmm0, xmm15
 
-// CHECK: vcvtpd2ps xmm0, xmm15 
-// CHECK: encoding: [0xc4,0xc1,0x79,0x5a,0xc7]
-          vcvtpd2psx xmm0, xmm15
-
 // CHECK: vcvtpd2ps xmm0, xmmword ptr [rax]
 // CHECK: encoding: [0xc5,0xf9,0x5a,0x00]
           vcvtpd2ps xmm0, xmmword ptr [rax]
 
-// CHECK: vcvtpd2ps xmm0, xmmword ptr [rax]
-// CHECK: encoding: [0xc5,0xf9,0x5a,0x00]
-          vcvtpd2psx xmm0, xmmword ptr [rax]
-
 // CHECK: vcvtpd2ps xmm0, ymm15 
 // CHECK: encoding: [0xc4,0xc1,0x7d,0x5a,0xc7]
           vcvtpd2ps xmm0, ymm15
 
-// CHECK: vcvtpd2ps xmm0, ymm15 
-// CHECK: encoding: [0xc4,0xc1,0x7d,0x5a,0xc7]
-          vcvtpd2psy xmm0, ymm15
-
 // CHECK: vcvtpd2ps xmm0, ymmword ptr [rax]
 // CHECK: encoding: [0xc5,0xfd,0x5a,0x00]
           vcvtpd2ps xmm0, ymmword ptr [rax]
 
-// CHECK: vcvtpd2ps xmm0, ymmword ptr [rax]
-// CHECK: encoding: [0xc5,0xfd,0x5a,0x00]
-          vcvtpd2psy xmm0, ymmword ptr [rax]
-
 // CHECK: vcvtpd2dq xmm0, xmm15 
 // CHECK: encoding: [0xc4,0xc1,0x7b,0xe6,0xc7]
           vcvtpd2dq xmm0, xmm15
 
-// CHECK: vcvtpd2dq xmm0, xmm15 
-// CHECK: encoding: [0xc4,0xc1,0x7b,0xe6,0xc7]
-          vcvtpd2dqx xmm0, xmm15
-
 // CHECK: vcvtpd2dq xmm0, xmmword ptr [rax]
 // CHECK: encoding: [0xc5,0xfb,0xe6,0x00]
           vcvtpd2dq xmm0, xmmword ptr [rax]
 
-// CHECK: vcvtpd2dq xmm0, xmmword ptr [rax]
-// CHECK: encoding: [0xc5,0xfb,0xe6,0x00]
-          vcvtpd2dqx xmm0, xmmword ptr [rax]
-
 // CHECK: vcvtpd2dq xmm0, ymm15 
 // CHECK: encoding: [0xc4,0xc1,0x7f,0xe6,0xc7]
           vcvtpd2dq xmm0, ymm15
 
-// CHECK: vcvtpd2dq xmm0, ymm15 
-// CHECK: encoding: [0xc4,0xc1,0x7f,0xe6,0xc7]
-          vcvtpd2dqy xmm0, ymm15
-
 // CHECK: vcvtpd2dq xmm0, ymmword ptr [rax]
 // CHECK: encoding: [0xc5,0xff,0xe6,0x00]
           vcvtpd2dq xmm0, ymmword ptr [rax]
 
-// CHECK: vcvtpd2dq xmm0, ymmword ptr [rax]
-// CHECK: encoding: [0xc5,0xff,0xe6,0x00]
-          vcvtpd2dqy xmm0, ymmword ptr [rax]
-
 // CHECK: vcvttpd2dq xmm0, xmm15 
 // CHECK: encoding: [0xc4,0xc1,0x79,0xe6,0xc7]
           vcvttpd2dq xmm0, xmm15
 
-// CHECK: vcvttpd2dq xmm0, xmm15 
-// CHECK: encoding: [0xc4,0xc1,0x79,0xe6,0xc7]
-          vcvttpd2dqx xmm0, xmm15
-
 // CHECK: vcvttpd2dq xmm0, xmmword ptr [rax]
 // CHECK: encoding: [0xc5,0xf9,0xe6,0x00]
           vcvttpd2dq xmm0, xmmword ptr [rax]
 
-// CHECK: vcvttpd2dq xmm0, xmmword ptr [rax]
-// CHECK: encoding: [0xc5,0xf9,0xe6,0x00]
-          vcvttpd2dqx xmm0, xmmword ptr [rax]
-
 // CHECK: vcvttpd2dq xmm0, ymm15 
 // CHECK: encoding: [0xc4,0xc1,0x7d,0xe6,0xc7]
           vcvttpd2dq xmm0, ymm15
 
-// CHECK: vcvttpd2dq xmm0, ymm15 
-// CHECK: encoding: [0xc4,0xc1,0x7d,0xe6,0xc7]
-          vcvttpd2dqy xmm0, ymm15
-
 // CHECK: vcvttpd2dq xmm0, ymmword ptr [rax]
 // CHECK: encoding: [0xc5,0xfd,0xe6,0x00]
           vcvttpd2dq xmm0, ymmword ptr [rax]
 
-// CHECK: vcvttpd2dq xmm0, ymmword ptr [rax]
-// CHECK: encoding: [0xc5,0xfd,0xe6,0x00]
-          vcvttpd2dqy xmm0, ymmword ptr [rax]
-
 // CHECK: vpmaddwd xmm1, xmm2, xmm3
 // CHECK: encoding: [0xc5,0xe9,0xf5,0xcb]
           vpmaddwd xmm1, xmm2, xmm3
diff --git a/llvm/test/MC/X86/intel-syntax-x86-64-avx512f_vl.s b/llvm/test/MC/X86/intel-syntax-x86-64-avx512f_vl.s
index b98d230fad2..29bde03c586 100644
--- a/llvm/test/MC/X86/intel-syntax-x86-64-avx512f_vl.s
+++ b/llvm/test/MC/X86/intel-syntax-x86-64-avx512f_vl.s
@@ -1124,226 +1124,114 @@
 // CHECK: encoding: [0x62,0xb1,0xfd,0x08,0x5a,0xc7]
           vcvtpd2ps xmm0, xmm23
 
-// CHECK: vcvtpd2ps xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xfd,0x08,0x5a,0xc7]
-          vcvtpd2psx xmm0, xmm23
-
 // CHECK: vcvtpd2ps xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfd,0x08,0x5a,0x00]
           vcvtpd2ps xmm16, xmmword ptr [rax]
 
-// CHECK: vcvtpd2ps xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfd,0x08,0x5a,0x00]
-          vcvtpd2psx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvtpd2ps xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xfd,0x28,0x5a,0xc7]
           vcvtpd2ps xmm0, ymm23
 
-// CHECK: vcvtpd2ps xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xfd,0x28,0x5a,0xc7]
-          vcvtpd2psy xmm0, ymm23
-
 // CHECK: vcvtpd2ps xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfd,0x28,0x5a,0x00]
           vcvtpd2ps xmm16, ymmword ptr [rax]
 
-// CHECK: vcvtpd2ps xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfd,0x28,0x5a,0x00]
-          vcvtpd2psy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvtpd2dq xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xff,0x08,0xe6,0xc7]
           vcvtpd2dq xmm0, xmm23
 
-// CHECK: vcvtpd2dq xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xff,0x08,0xe6,0xc7]
-          vcvtpd2dqx xmm0, xmm23
-
 // CHECK: vcvtpd2dq xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xff,0x08,0xe6,0x00]
           vcvtpd2dq xmm16, xmmword ptr [rax]
 
-// CHECK: vcvtpd2dq xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xff,0x08,0xe6,0x00]
-          vcvtpd2dqx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvtpd2dq xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xff,0x28,0xe6,0xc7]
           vcvtpd2dq xmm0, ymm23
 
-// CHECK: vcvtpd2dq xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xff,0x28,0xe6,0xc7]
-          vcvtpd2dqy xmm0, ymm23
-
 // CHECK: vcvtpd2dq xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xff,0x28,0xe6,0x00]
           vcvtpd2dq xmm16, ymmword ptr [rax]
 
-// CHECK: vcvtpd2dq xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xff,0x28,0xe6,0x00]
-          vcvtpd2dqy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvtpd2udq xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x79,0xc7]
           vcvtpd2udq xmm0, xmm23
 
-// CHECK: vcvtpd2udq xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x79,0xc7]
-          vcvtpd2udqx xmm0, xmm23
-
 // CHECK: vcvtpd2udq xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x79,0x00]
           vcvtpd2udq xmm16, xmmword ptr [rax]
 
-// CHECK: vcvtpd2udq xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x79,0x00]
-          vcvtpd2udqx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvtpd2udq xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x79,0xc7]
           vcvtpd2udq xmm0, ymm23
 
-// CHECK: vcvtpd2udq xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x79,0xc7]
-          vcvtpd2udqy xmm0, ymm23
-
 // CHECK: vcvtpd2udq xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x79,0x00]
           vcvtpd2udq xmm16, ymmword ptr [rax]
 
-// CHECK: vcvtpd2udq xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x79,0x00]
-          vcvtpd2udqy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvttpd2dq xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xfd,0x08,0xe6,0xc7]
           vcvttpd2dq xmm0, xmm23
 
-// CHECK: vcvttpd2dq xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xfd,0x08,0xe6,0xc7]
-          vcvttpd2dqx xmm0, xmm23
-
 // CHECK: vcvttpd2dq xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfd,0x08,0xe6,0x00]
           vcvttpd2dq xmm16, xmmword ptr [rax]
 
-// CHECK: vcvttpd2dq xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfd,0x08,0xe6,0x00]
-          vcvttpd2dqx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvttpd2dq xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xfd,0x28,0xe6,0xc7]
           vcvttpd2dq xmm0, ymm23
 
-// CHECK: vcvttpd2dq xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xfd,0x28,0xe6,0xc7]
-          vcvttpd2dqy xmm0, ymm23
-
 // CHECK: vcvttpd2dq xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfd,0x28,0xe6,0x00]
           vcvttpd2dq xmm16, ymmword ptr [rax]
 
-// CHECK: vcvttpd2dq xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfd,0x28,0xe6,0x00]
-          vcvttpd2dqy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvttpd2udq xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x78,0xc7]
           vcvttpd2udq xmm0, xmm23
 
-// CHECK: vcvttpd2udq xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x78,0xc7]
-          vcvttpd2udqx xmm0, xmm23
-
 // CHECK: vcvttpd2udq xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x78,0x00]
           vcvttpd2udq xmm16, xmmword ptr [rax]
 
-// CHECK: vcvttpd2udq xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x78,0x00]
-          vcvttpd2udqx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvttpd2udq xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x78,0xc7]
           vcvttpd2udq xmm0, ymm23
 
-// CHECK: vcvttpd2udq xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x78,0xc7]
-          vcvttpd2udqy xmm0, ymm23
-
 // CHECK: vcvttpd2udq xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x78,0x00]
           vcvttpd2udq xmm16, ymmword ptr [rax]
 
-// CHECK: vcvttpd2udq xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x78,0x00]
-          vcvttpd2udqy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvtqq2ps xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x5b,0xc7]
           vcvtqq2ps xmm0, xmm23
 
-// CHECK: vcvtqq2ps xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x08,0x5b,0xc7]
-          vcvtqq2psx xmm0, xmm23
-
 // CHECK: vcvtqq2ps xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x5b,0x00]
           vcvtqq2ps xmm16, xmmword ptr [rax]
 
-// CHECK: vcvtqq2ps xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x08,0x5b,0x00]
-          vcvtqq2psx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvtqq2ps xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x5b,0xc7]
           vcvtqq2ps xmm0, ymm23
 
-// CHECK: vcvtqq2ps xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xfc,0x28,0x5b,0xc7]
-          vcvtqq2psy xmm0, ymm23
-
 // CHECK: vcvtqq2ps xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x5b,0x00]
           vcvtqq2ps xmm16, ymmword ptr [rax]
 
-// CHECK: vcvtqq2ps xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xfc,0x28,0x5b,0x00]
-          vcvtqq2psy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvtuqq2ps xmm0, xmm23 
 // CHECK: encoding: [0x62,0xb1,0xff,0x08,0x7a,0xc7]
           vcvtuqq2ps xmm0, xmm23
 
-// CHECK: vcvtuqq2ps xmm0, xmm23 
-// CHECK: encoding: [0x62,0xb1,0xff,0x08,0x7a,0xc7]
-          vcvtuqq2psx xmm0, xmm23
-
 // CHECK: vcvtuqq2ps xmm16, xmmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xff,0x08,0x7a,0x00]
           vcvtuqq2ps xmm16, xmmword ptr [rax]
 
-// CHECK: vcvtuqq2ps xmm16, xmmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xff,0x08,0x7a,0x00]
-          vcvtuqq2psx xmm16, xmmword ptr [rax]
-
 // CHECK: vcvtuqq2ps xmm0, ymm23 
 // CHECK: encoding: [0x62,0xb1,0xff,0x28,0x7a,0xc7]
           vcvtuqq2ps xmm0, ymm23
 
-// CHECK: vcvtuqq2ps xmm0, ymm23 
-// CHECK: encoding: [0x62,0xb1,0xff,0x28,0x7a,0xc7]
-          vcvtuqq2psy xmm0, ymm23
-
 // CHECK: vcvtuqq2ps xmm16, ymmword ptr [rax]
 // CHECK: encoding: [0x62,0xe1,0xff,0x28,0x7a,0x00]
           vcvtuqq2ps xmm16, ymmword ptr [rax]
 
-// CHECK: vcvtuqq2ps xmm16, ymmword ptr [rax]
-// CHECK: encoding: [0x62,0xe1,0xff,0x28,0x7a,0x00]
-          vcvtuqq2psy xmm16, ymmword ptr [rax]
-
 // CHECK: vcvtps2pd xmm1 {k2} {z}, qword ptr [rcx + 128]
 // CHECK:  encoding: [0x62,0xf1,0x7c,0x8a,0x5a,0x49,0x10]
           vcvtps2pd xmm1 {k2} {z}, qword ptr [rcx+0x80]
diff --git a/llvm/test/MC/X86/intel-syntax-x86-avx512dq_vl.s b/llvm/test/MC/X86/intel-syntax-x86-avx512dq_vl.s
index 7693caba450..e2d6850623a 100644
--- a/llvm/test/MC/X86/intel-syntax-x86-avx512dq_vl.s
+++ b/llvm/test/MC/X86/intel-syntax-x86-avx512dq_vl.s
@@ -95,3 +95,99 @@
 // CHECK:  vcvttps2uqq xmm1, qword ptr [rcx + 128]
 // CHECK:  encoding: [0x62,0xf1,0x7d,0x08,0x78,0x49,0x10]
           vcvttps2uqq xmm1, qword ptr [rcx + 128]
+
+// CHECK: vfpclasspd k2, xmm18, 171
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0xd2,0xab]
+          vfpclasspd k2, xmm18, 0xab
+
+// CHECK: vfpclasspd k2 {k7}, xmm18, 171
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x0f,0x66,0xd2,0xab]
+          vfpclasspd k2 {k7}, xmm18, 0xab
+
+// CHECK: vfpclasspd k2, xmmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x11,0x7b]
+          vfpclasspd k2, xmmword ptr [rcx], 0x7b
+
+// CHECK: vfpclasspd k2 {k7}, xmmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x0f,0x66,0x11,0x7b]
+          vfpclasspd k2 {k7}, xmmword ptr [rcx], 0x7b
+
+// CHECK: vfpclasspd k2, qword ptr [rcx]{1to2}, 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x11,0x7b]
+          vfpclasspd k2, qword ptr [rcx]{1to2}, 0x7b
+
+// CHECK: vfpclasspd k2 {k7}, qword ptr [rcx]{1to2}, 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x1f,0x66,0x11,0x7b]
+          vfpclasspd k2 {k7}, qword ptr [rcx]{1to2}, 0x7b
+
+// CHECK: vfpclassps k2, xmm18, 171
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xd2,0xab]
+          vfpclassps k2, xmm18, 0xab
+
+// CHECK: vfpclassps k2 {k7}, xmm18, 171
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x0f,0x66,0xd2,0xab]
+          vfpclassps k2 {k7}, xmm18, 0xab
+
+// CHECK: vfpclassps k2, xmmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x11,0x7b]
+          vfpclassps k2, xmmword ptr [rcx], 0x7b
+
+// CHECK: vfpclassps k2 {k7}, xmmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x0f,0x66,0x11,0x7b]
+          vfpclassps k2 {k7}, xmmword ptr [rcx], 0x7b
+
+// CHECK: vfpclassps k2, dword ptr [rcx]{1to4}, 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x11,0x7b]
+          vfpclassps k2, dword ptr [rcx]{1to4}, 0x7b
+
+// CHECK: vfpclassps k2 {k7}, dword ptr [rcx]{1to4}, 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x1f,0x66,0x11,0x7b]
+          vfpclassps k2 {k7}, dword ptr [rcx]{1to4}, 0x7b
+
+// CHECK: vfpclasspd k2, ymm18, 171
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x28,0x66,0xd2,0xab]
+          vfpclasspd k2, ymm18, 0xab
+
+// CHECK: vfpclasspd k2 {k7}, ymm18, 171
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x2f,0x66,0xd2,0xab]
+          vfpclasspd k2 {k7}, ymm18, 0xab
+
+// CHECK: vfpclasspd k2, ymmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x11,0x7b]
+          vfpclasspd k2, ymmword ptr [rcx], 0x7b
+
+// CHECK: vfpclasspd k2 {k7}, ymmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x2f,0x66,0x11,0x7b]
+          vfpclasspd k2 {k7}, ymmword ptr [rcx], 0x7b
+
+// CHECK: vfpclasspd k2, qword ptr [rcx]{1to4}, 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x11,0x7b]
+          vfpclasspd k2, qword ptr [rcx]{1to4}, 0x7b
+
+// CHECK: vfpclasspd k2 {k7}, qword ptr [rcx]{1to4}, 123
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x3f,0x66,0x11,0x7b]
+          vfpclasspd k2 {k7}, qword ptr [rcx]{1to4}, 0x7b
+
+// CHECK: vfpclassps k2, ymm18, 171
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xd2,0xab]
+          vfpclassps k2, ymm18, 0xab
+
+// CHECK: vfpclassps k2 {k7}, ymm18, 171
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x2f,0x66,0xd2,0xab]
+          vfpclassps k2 {k7}, ymm18, 0xab
+
+// CHECK: vfpclassps k2, ymmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x11,0x7b]
+          vfpclassps k2, ymmword ptr [rcx], 0x7b
+
+// CHECK: vfpclassps k2 {k7}, ymmword ptr [rcx], 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x2f,0x66,0x11,0x7b]
+          vfpclassps k2 {k7}, ymmword ptr [rcx], 0x7b
+
+// CHECK: vfpclassps k2, dword ptr [rcx]{1to8}, 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x11,0x7b]
+          vfpclassps k2, dword ptr [rcx]{1to8}, 0x7b
+
+// CHECK: vfpclassps k2 {k7}, dword ptr [rcx]{1to8}, 123
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x3f,0x66,0x11,0x7b]
+          vfpclassps k2 {k7}, dword ptr [rcx]{1to8}, 0x7b
diff --git a/llvm/test/MC/X86/x86-64-avx512dq.s b/llvm/test/MC/X86/x86-64-avx512dq.s
index 91014a7cb43..4510352ee7c 100644
--- a/llvm/test/MC/X86/x86-64-avx512dq.s
+++ b/llvm/test/MC/X86/x86-64-avx512dq.s
@@ -3495,14 +3495,26 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd1,0xab]
           vfpclasspd $0xab, %zmm17, %k2
 
+// CHECK: vfpclasspd $171, %zmm17, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd1,0xab]
+          vfpclasspdz $0xab, %zmm17, %k2
+
 // CHECK: vfpclasspd $171, %zmm17, %k2 {%k1}
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x49,0x66,0xd1,0xab]
           vfpclasspd $0xab, %zmm17, %k2 {%k1}
 
+// CHECK: vfpclasspd $171, %zmm17, %k2 {%k1}
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x49,0x66,0xd1,0xab]
+          vfpclasspdz $0xab, %zmm17, %k2 {%k1}
+
 // CHECK: vfpclasspd $123,  %zmm17, %k2
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd1,0x7b]
           vfpclasspd $0x7b, %zmm17, %k2
 
+// CHECK: vfpclasspd $123,  %zmm17, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd1,0x7b]
+          vfpclasspdz $0x7b, %zmm17, %k2
+
 // CHECK: vfpclasspdz $123, (%rcx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x11,0x7b]
           vfpclasspdz $0x7b,(%rcx), %k2
@@ -3511,9 +3523,9 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0x94,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspdz $0x7b,291(%rax,%r14,8), %k2
 
-// CHECK: vfpclasspdq $123, (%rcx){1to8}, %k2
+// CHECK: vfpclasspd $123, (%rcx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x11,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to8}, %k2
+          vfpclasspd $0x7b,(%rcx){1to8}, %k2
 
 // CHECK: vfpclasspdz $123, 8128(%rdx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x52,0x7f,0x7b]
@@ -3531,34 +3543,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x92,0xc0,0xdf,0xff,0xff,0x7b]
           vfpclasspdz $0x7b,-8256(%rdx), %k2
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, 1016(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to8}, %k2
+          vfpclasspd $0x7b,1016(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, 1016(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x7f,0x7b]
+          vfpclasspdz $0x7b,1016(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspd $0x7b,1024(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to8}, %k2
+          vfpclasspdz $0x7b,1024(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x80,0x7b]
+          vfpclasspd $0x7b,-1024(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, -1024(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to8}, %k2
+          vfpclasspdz $0x7b,-1024(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, -1032(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to8}, %k2
+          vfpclasspd $0x7b,-1032(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspdz $0x7b,-1032(%rdx){1to8}, %k2
 
 // CHECK: vfpclassps $171, %zmm21, %k2
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xd5,0xab]
           vfpclassps $0xab, %zmm21, %k2
 
+// CHECK: vfpclassps $171, %zmm21, %k2
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xd5,0xab]
+          vfpclasspsz $0xab, %zmm21, %k2
+
 // CHECK: vfpclassps $171, %zmm21, %k2 {%k2}
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x4a,0x66,0xd5,0xab]
           vfpclassps $0xab, %zmm21, %k2 {%k2}
 
+// CHECK: vfpclassps $171, %zmm21, %k2 {%k2}
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x4a,0x66,0xd5,0xab]
+          vfpclasspsz $0xab, %zmm21, %k2 {%k2}
+
 // CHECK: vfpclassps $123,  %zmm21, %k2
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xd5,0x7b]
           vfpclassps $0x7b, %zmm21, %k2
 
+// CHECK: vfpclassps $123,  %zmm21, %k2
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xd5,0x7b]
+          vfpclasspsz $0x7b, %zmm21, %k2
+
 // CHECK: vfpclasspsz $123, (%rcx), %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0x11,0x7b]
           vfpclasspsz $0x7b,(%rcx), %k2
@@ -3567,9 +3607,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0x94,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspsz $0x7b,291(%rax,%r14,8), %k2
 
-// CHECK: vfpclasspsl $123, (%rcx){1to16}, %k2
+// CHECK: vfpclassps $123, (%rcx){1to16}, %k2
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x11,0x7b]
+          vfpclassps $0x7b,(%rcx){1to16}, %k2
+
+// CHECK: vfpclassps $123, (%rcx){1to16}, %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x11,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to16}, %k2
+          vfpclasspsz $0x7b,(%rcx){1to16}, %k2
 
 // CHECK: vfpclasspsz $123, 8128(%rdx), %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0x52,0x7f,0x7b]
@@ -3587,34 +3631,62 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0x92,0xc0,0xdf,0xff,0xff,0x7b]
           vfpclasspsz $0x7b,-8256(%rdx), %k2
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to16}, %k2
+// CHECK: vfpclassps $123, 508(%rdx){1to16}, %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x52,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to16}, %k2
+          vfpclassps $0x7b,508(%rdx){1to16}, %k2
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to16}, %k2
+// CHECK: vfpclassps $123, 508(%rdx){1to16}, %k2
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x52,0x7f,0x7b]
+          vfpclasspsz $0x7b,508(%rdx){1to16}, %k2
+
+// CHECK: vfpclassps $123, 512(%rdx){1to16}, %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x92,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to16}, %k2
+          vfpclassps $0x7b,512(%rdx){1to16}, %k2
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to16}, %k2
+// CHECK: vfpclassps $123, 512(%rdx){1to16}, %k2
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x92,0x00,0x02,0x00,0x00,0x7b]
+          vfpclasspsz $0x7b,512(%rdx){1to16}, %k2
+
+// CHECK: vfpclassps $123, -512(%rdx){1to16}, %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x52,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to16}, %k2
+          vfpclassps $0x7b,-512(%rdx){1to16}, %k2
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to16}, %k2
+// CHECK: vfpclassps $123, -512(%rdx){1to16}, %k2
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x52,0x80,0x7b]
+          vfpclasspsz $0x7b,-512(%rdx){1to16}, %k2
+
+// CHECK: vfpclassps $123, -516(%rdx){1to16}, %k2
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x92,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclassps $0x7b,-516(%rdx){1to16}, %k2
+
+// CHECK: vfpclassps $123, -516(%rdx){1to16}, %k2
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x92,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to16}, %k2
+          vfpclasspsz $0x7b,-516(%rdx){1to16}, %k2
 
 // CHECK: vfpclasspd $171, %zmm19, %k2
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd3,0xab]
           vfpclasspd $0xab, %zmm19, %k2
 
+// CHECK: vfpclasspd $171, %zmm19, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd3,0xab]
+          vfpclasspdz $0xab, %zmm19, %k2
+
 // CHECK: vfpclasspd $171, %zmm19, %k2 {%k6}
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x4e,0x66,0xd3,0xab]
           vfpclasspd $0xab, %zmm19, %k2 {%k6}
 
+// CHECK: vfpclasspd $171, %zmm19, %k2 {%k6}
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x4e,0x66,0xd3,0xab]
+          vfpclasspdz $0xab, %zmm19, %k2 {%k6}
+
 // CHECK: vfpclasspd $123,  %zmm19, %k2
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd3,0x7b]
           vfpclasspd $0x7b, %zmm19, %k2
 
+// CHECK: vfpclasspd $123,  %zmm19, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0xd3,0x7b]
+          vfpclasspdz $0x7b, %zmm19, %k2
+
 // CHECK: vfpclasspdz $123, (%rcx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x11,0x7b]
           vfpclasspdz $0x7b,(%rcx), %k2
@@ -3623,9 +3695,13 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x48,0x66,0x94,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspdz $0x7b,4660(%rax,%r14,8), %k2
 
-// CHECK: vfpclasspdq $123, (%rcx){1to8}, %k2
+// CHECK: vfpclasspd $123, (%rcx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x11,0x7b]
+          vfpclasspd $0x7b,(%rcx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, (%rcx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x11,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to8}, %k2
+          vfpclasspdz $0x7b,(%rcx){1to8}, %k2
 
 // CHECK: vfpclasspdz $123, 8128(%rdx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x52,0x7f,0x7b]
@@ -3643,34 +3719,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x48,0x66,0x92,0xc0,0xdf,0xff,0xff,0x7b]
           vfpclasspdz $0x7b,-8256(%rdx), %k2
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, 1016(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x7f,0x7b]
+          vfpclasspd $0x7b,1016(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, 1016(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to8}, %k2
+          vfpclasspdz $0x7b,1016(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspd $0x7b,1024(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, 1024(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to8}, %k2
+          vfpclasspdz $0x7b,1024(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, -1024(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to8}, %k2
+          vfpclasspd $0x7b,-1024(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x52,0x80,0x7b]
+          vfpclasspdz $0x7b,-1024(%rdx){1to8}, %k2
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to8}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspd $0x7b,-1032(%rdx){1to8}, %k2
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to8}, %k2
+// CHECK: vfpclasspd $123, -1032(%rdx){1to8}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x58,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to8}, %k2
+          vfpclasspdz $0x7b,-1032(%rdx){1to8}, %k2
 
 // CHECK: vfpclassps $171, %zmm17, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xe1,0xab]
           vfpclassps $0xab, %zmm17, %k4
 
+// CHECK: vfpclassps $171, %zmm17, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xe1,0xab]
+          vfpclasspsz $0xab, %zmm17, %k4
+
 // CHECK: vfpclassps $171, %zmm17, %k4 {%k2}
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x4a,0x66,0xe1,0xab]
           vfpclassps $0xab, %zmm17, %k4 {%k2}
 
+// CHECK: vfpclassps $171, %zmm17, %k4 {%k2}
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x4a,0x66,0xe1,0xab]
+          vfpclasspsz $0xab, %zmm17, %k4 {%k2}
+
 // CHECK: vfpclassps $123,  %zmm17, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xe1,0x7b]
           vfpclassps $0x7b, %zmm17, %k4
 
+// CHECK: vfpclassps $123,  %zmm17, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xe1,0x7b]
+          vfpclasspsz $0x7b, %zmm17, %k4
+
 // CHECK: vfpclasspsz $123, (%rcx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0x21,0x7b]
           vfpclasspsz $0x7b,(%rcx), %k4
@@ -3679,9 +3783,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x48,0x66,0xa4,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspsz $0x7b,4660(%rax,%r14,8), %k4
 
-// CHECK: vfpclasspsl $123, (%rcx){1to16}, %k4
+// CHECK: vfpclassps $123, (%rcx){1to16}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x21,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to16}, %k4
+          vfpclassps $0x7b,(%rcx){1to16}, %k4
+
+// CHECK: vfpclassps $123, (%rcx){1to16}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x21,0x7b]
+          vfpclasspsz $0x7b,(%rcx){1to16}, %k4
 
 // CHECK: vfpclasspsz $123, 8128(%rdx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0x62,0x7f,0x7b]
@@ -3699,22 +3807,37 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x48,0x66,0xa2,0xc0,0xdf,0xff,0xff,0x7b]
           vfpclasspsz $0x7b,-8256(%rdx), %k4
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to16}, %k4
+// CHECK: vfpclassps $123, 508(%rdx){1to16}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x62,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to16}, %k4
+          vfpclassps $0x7b,508(%rdx){1to16}, %k4
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to16}, %k4
+// CHECK: vfpclassps $123, 508(%rdx){1to16}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x62,0x7f,0x7b]
+          vfpclasspsz $0x7b,508(%rdx){1to16}, %k4
+
+// CHECK: vfpclassps $123, 512(%rdx){1to16}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to16}, %k4
+          vfpclassps $0x7b,512(%rdx){1to16}, %k4
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to16}, %k4
+// CHECK: vfpclassps $123, 512(%rdx){1to16}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
+          vfpclasspsz $0x7b,512(%rdx){1to16}, %k4
+
+// CHECK: vfpclassps $123, -512(%rdx){1to16}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x62,0x80,0x7b]
+          vfpclassps $0x7b,-512(%rdx){1to16}, %k4
+
+// CHECK: vfpclassps $123, -512(%rdx){1to16}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0x62,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to16}, %k4
+          vfpclasspsz $0x7b,-512(%rdx){1to16}, %k4
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to16}, %k4
+// CHECK: vfpclassps $123, -516(%rdx){1to16}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to16}, %k4
+          vfpclassps $0x7b,-516(%rdx){1to16}, %k4
 
+// CHECK: vfpclassps $123, -516(%rdx){1to16}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x58,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclasspsz $0x7b,-516(%rdx){1to16}, %k4
 
 // CHECK: vcvtuqq2ps {rn-sae}, %zmm21, %ymm18
 // CHECK:  encoding: [0x62,0xa1,0xff,0x18,0x7a,0xd5]
diff --git a/llvm/test/MC/X86/x86-64-avx512dq_vl.s b/llvm/test/MC/X86/x86-64-avx512dq_vl.s
index 59f0ad0ff8a..b8c555fec19 100644
--- a/llvm/test/MC/X86/x86-64-avx512dq_vl.s
+++ b/llvm/test/MC/X86/x86-64-avx512dq_vl.s
@@ -3252,226 +3252,854 @@
 // CHECK:  encoding: [0x62,0x01,0xfc,0x08,0x5b,0xcc]
           vcvtqq2ps %xmm28, %xmm25
 
+// CHECK: vcvtqq2ps %xmm28, %xmm25
+// CHECK:  encoding: [0x62,0x01,0xfc,0x08,0x5b,0xcc]
+          vcvtqq2psx %xmm28, %xmm25
+
 // CHECK: vcvtqq2ps %xmm28, %xmm25 {%k6}
 // CHECK:  encoding: [0x62,0x01,0xfc,0x0e,0x5b,0xcc]
           vcvtqq2ps %xmm28, %xmm25 {%k6}
 
+// CHECK: vcvtqq2ps %xmm28, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x01,0xfc,0x0e,0x5b,0xcc]
+          vcvtqq2psx %xmm28, %xmm25 {%k6}
+
 // CHECK: vcvtqq2ps %xmm28, %xmm25 {%k6} {z}
 // CHECK:  encoding: [0x62,0x01,0xfc,0x8e,0x5b,0xcc]
           vcvtqq2ps %xmm28, %xmm25 {%k6} {z}
 
+// CHECK: vcvtqq2ps %xmm28, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x01,0xfc,0x8e,0x5b,0xcc]
+          vcvtqq2psx %xmm28, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx (%rcx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x09]
           vcvtqq2psx (%rcx), %xmm25
 
+// CHECK: vcvtqq2psx (%rcx), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0e,0x5b,0x09]
+          vcvtqq2psx (%rcx), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx (%rcx), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8e,0x5b,0x09]
+          vcvtqq2psx (%rcx), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx 291(%rax,%r14,8), %xmm25
 // CHECK:  encoding: [0x62,0x21,0xfc,0x08,0x5b,0x8c,0xf0,0x23,0x01,0x00,0x00]
           vcvtqq2psx 291(%rax,%r14,8), %xmm25
 
+// CHECK: vcvtqq2psx 291(%rax,%r14,8), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x0e,0x5b,0x8c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtqq2psx 291(%rax,%r14,8), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx 291(%rax,%r14,8), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x8e,0x5b,0x8c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtqq2psx 291(%rax,%r14,8), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x09]
           vcvtqq2ps (%rcx){1to2}, %xmm25
 
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x09]
+          vcvtqq2psx (%rcx){1to2}, %xmm25
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x09]
+          vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x09]
+          vcvtqq2psx (%rcx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x09]
+          vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6} {z}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x09]
+          vcvtqq2psx (%rcx){1to2}, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx 2032(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x4a,0x7f]
           vcvtqq2psx 2032(%rdx), %xmm25
 
+// CHECK: vcvtqq2psx 2032(%rdx), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0e,0x5b,0x4a,0x7f]
+          vcvtqq2psx 2032(%rdx), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx 2032(%rdx), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8e,0x5b,0x4a,0x7f]
+          vcvtqq2psx 2032(%rdx), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx 2048(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x8a,0x00,0x08,0x00,0x00]
           vcvtqq2psx 2048(%rdx), %xmm25
 
+// CHECK: vcvtqq2psx 2048(%rdx), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0e,0x5b,0x8a,0x00,0x08,0x00,0x00]
+          vcvtqq2psx 2048(%rdx), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx 2048(%rdx), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8e,0x5b,0x8a,0x00,0x08,0x00,0x00]
+          vcvtqq2psx 2048(%rdx), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx -2048(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x4a,0x80]
           vcvtqq2psx -2048(%rdx), %xmm25
 
+// CHECK: vcvtqq2psx -2048(%rdx), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0e,0x5b,0x4a,0x80]
+          vcvtqq2psx -2048(%rdx), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx -2048(%rdx), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8e,0x5b,0x4a,0x80]
+          vcvtqq2psx -2048(%rdx), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2psx -2064(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x8a,0xf0,0xf7,0xff,0xff]
           vcvtqq2psx -2064(%rdx), %xmm25
 
+// CHECK: vcvtqq2psx -2064(%rdx), %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0e,0x5b,0x8a,0xf0,0xf7,0xff,0xff]
+          vcvtqq2psx -2064(%rdx), %xmm25 {%k6}
+
+// CHECK: vcvtqq2psx -2064(%rdx), %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8e,0x5b,0x8a,0xf0,0xf7,0xff,0xff]
+          vcvtqq2psx -2064(%rdx), %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x4a,0x7f]
           vcvtqq2ps 1016(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x4a,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x4a,0x7f]
+          vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x4a,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x4a,0x7f]
+          vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6} {z}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x4a,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x8a,0x00,0x04,0x00,0x00]
           vcvtqq2ps 1024(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x8a,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x8a,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x8a,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x8a,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6} {z}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x8a,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x4a,0x80]
           vcvtqq2ps -1024(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x4a,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x4a,0x80]
+          vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x4a,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x4a,0x80]
+          vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6} {z}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x4a,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
           vcvtqq2ps -1032(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1e,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm25 {%k6}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6} {z}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm25 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9e,0x5b,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm25 {%k6} {z}
+
 // CHECK: vcvtqq2ps %ymm22, %xmm27
 // CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x5b,0xde]
           vcvtqq2ps %ymm22, %xmm27
 
+// CHECK: vcvtqq2ps %ymm22, %xmm27
+// CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x5b,0xde]
+          vcvtqq2psy %ymm22, %xmm27
+
 // CHECK: vcvtqq2ps %ymm22, %xmm27 {%k3}
 // CHECK:  encoding: [0x62,0x21,0xfc,0x2b,0x5b,0xde]
           vcvtqq2ps %ymm22, %xmm27 {%k3}
 
+// CHECK: vcvtqq2ps %ymm22, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x2b,0x5b,0xde]
+          vcvtqq2psy %ymm22, %xmm27 {%k3}
+
 // CHECK: vcvtqq2ps %ymm22, %xmm27 {%k3} {z}
 // CHECK:  encoding: [0x62,0x21,0xfc,0xab,0x5b,0xde]
           vcvtqq2ps %ymm22, %xmm27 {%k3} {z}
 
+// CHECK: vcvtqq2ps %ymm22, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0xab,0x5b,0xde]
+          vcvtqq2psy %ymm22, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy (%rcx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x5b,0x19]
           vcvtqq2psy (%rcx), %xmm27
 
+// CHECK: vcvtqq2psy (%rcx), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2b,0x5b,0x19]
+          vcvtqq2psy (%rcx), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy (%rcx), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xab,0x5b,0x19]
+          vcvtqq2psy (%rcx), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy 291(%rax,%r14,8), %xmm27
 // CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x5b,0x9c,0xf0,0x23,0x01,0x00,0x00]
           vcvtqq2psy 291(%rax,%r14,8), %xmm27
 
+// CHECK: vcvtqq2psy 291(%rax,%r14,8), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x2b,0x5b,0x9c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtqq2psy 291(%rax,%r14,8), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy 291(%rax,%r14,8), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0xab,0x5b,0x9c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtqq2psy 291(%rax,%r14,8), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps (%rcx){1to4}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x19]
           vcvtqq2ps (%rcx){1to4}, %xmm27
 
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x19]
+          vcvtqq2ps (%rcx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x19]
+          vcvtqq2ps (%rcx){1to4}, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy 4064(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x5b,0x5a,0x7f]
           vcvtqq2psy 4064(%rdx), %xmm27
 
+// CHECK: vcvtqq2psy 4064(%rdx), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2b,0x5b,0x5a,0x7f]
+          vcvtqq2psy 4064(%rdx), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy 4064(%rdx), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xab,0x5b,0x5a,0x7f]
+          vcvtqq2psy 4064(%rdx), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy 4096(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x5b,0x9a,0x00,0x10,0x00,0x00]
           vcvtqq2psy 4096(%rdx), %xmm27
 
+// CHECK: vcvtqq2psy 4096(%rdx), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2b,0x5b,0x9a,0x00,0x10,0x00,0x00]
+          vcvtqq2psy 4096(%rdx), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy 4096(%rdx), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xab,0x5b,0x9a,0x00,0x10,0x00,0x00]
+          vcvtqq2psy 4096(%rdx), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy -4096(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x5b,0x5a,0x80]
           vcvtqq2psy -4096(%rdx), %xmm27
 
+// CHECK: vcvtqq2psy -4096(%rdx), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2b,0x5b,0x5a,0x80]
+          vcvtqq2psy -4096(%rdx), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy -4096(%rdx), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xab,0x5b,0x5a,0x80]
+          vcvtqq2psy -4096(%rdx), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2psy -4128(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x5b,0x9a,0xe0,0xef,0xff,0xff]
           vcvtqq2psy -4128(%rdx), %xmm27
 
+// CHECK: vcvtqq2psy -4128(%rdx), %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2b,0x5b,0x9a,0xe0,0xef,0xff,0xff]
+          vcvtqq2psy -4128(%rdx), %xmm27 {%k3}
+
+// CHECK: vcvtqq2psy -4128(%rdx), %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xab,0x5b,0x9a,0xe0,0xef,0xff,0xff]
+          vcvtqq2psy -4128(%rdx), %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x5a,0x7f]
           vcvtqq2ps 1016(%rdx){1to4}, %xmm27
 
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x5a,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm27
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x5a,0x7f]
+          vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x5a,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x5a,0x7f]
+          vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3} {z}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x5a,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x9a,0x00,0x04,0x00,0x00]
           vcvtqq2ps 1024(%rdx){1to4}, %xmm27
 
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x9a,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm27
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x9a,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x9a,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x9a,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3} {z}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x9a,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x5a,0x80]
           vcvtqq2ps -1024(%rdx){1to4}, %xmm27
 
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x5a,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm27
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x5a,0x80]
+          vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x5a,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x5a,0x80]
+          vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3} {z}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x5a,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
           vcvtqq2ps -1032(%rdx){1to4}, %xmm27
 
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm27
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3b,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm27 {%k3}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3} {z}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm27 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbb,0x5b,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm27 {%k3} {z}
+
 // CHECK: vcvtqq2ps %xmm26, %xmm30
 // CHECK:  encoding: [0x62,0x01,0xfc,0x08,0x5b,0xf2]
           vcvtqq2ps %xmm26, %xmm30
 
+// CHECK: vcvtqq2ps %xmm26, %xmm30
+// CHECK:  encoding: [0x62,0x01,0xfc,0x08,0x5b,0xf2]
+          vcvtqq2psx %xmm26, %xmm30
+
 // CHECK: vcvtqq2ps %xmm26, %xmm30 {%k4}
 // CHECK:  encoding: [0x62,0x01,0xfc,0x0c,0x5b,0xf2]
           vcvtqq2ps %xmm26, %xmm30 {%k4}
 
+// CHECK: vcvtqq2ps %xmm26, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x01,0xfc,0x0c,0x5b,0xf2]
+          vcvtqq2psx %xmm26, %xmm30 {%k4}
+
 // CHECK: vcvtqq2ps %xmm26, %xmm30 {%k4} {z}
 // CHECK:  encoding: [0x62,0x01,0xfc,0x8c,0x5b,0xf2]
           vcvtqq2ps %xmm26, %xmm30 {%k4} {z}
 
+// CHECK: vcvtqq2ps %xmm26, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x01,0xfc,0x8c,0x5b,0xf2]
+          vcvtqq2psx %xmm26, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx (%rcx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x31]
           vcvtqq2psx (%rcx), %xmm30
 
+// CHECK: vcvtqq2psx (%rcx), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0c,0x5b,0x31]
+          vcvtqq2psx (%rcx), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx (%rcx), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8c,0x5b,0x31]
+          vcvtqq2psx (%rcx), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx 4660(%rax,%r14,8), %xmm30
 // CHECK:  encoding: [0x62,0x21,0xfc,0x08,0x5b,0xb4,0xf0,0x34,0x12,0x00,0x00]
           vcvtqq2psx 4660(%rax,%r14,8), %xmm30
 
+// CHECK: vcvtqq2psx 4660(%rax,%r14,8), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x0c,0x5b,0xb4,0xf0,0x34,0x12,0x00,0x00]
+          vcvtqq2psx 4660(%rax,%r14,8), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx 4660(%rax,%r14,8), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x8c,0x5b,0xb4,0xf0,0x34,0x12,0x00,0x00]
+          vcvtqq2psx 4660(%rax,%r14,8), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x31]
           vcvtqq2ps (%rcx){1to2}, %xmm30
 
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x31]
+          vcvtqq2psx (%rcx){1to2}, %xmm30
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x31]
+          vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x31]
+          vcvtqq2psx (%rcx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x31]
+          vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4} {z}
+
+// CHECK: vcvtqq2ps (%rcx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x31]
+          vcvtqq2psx (%rcx){1to2}, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx 2032(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x72,0x7f]
           vcvtqq2psx 2032(%rdx), %xmm30
 
+// CHECK: vcvtqq2psx 2032(%rdx), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0c,0x5b,0x72,0x7f]
+          vcvtqq2psx 2032(%rdx), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx 2032(%rdx), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8c,0x5b,0x72,0x7f]
+          vcvtqq2psx 2032(%rdx), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx 2048(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0xb2,0x00,0x08,0x00,0x00]
           vcvtqq2psx 2048(%rdx), %xmm30
 
+// CHECK: vcvtqq2psx 2048(%rdx), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0c,0x5b,0xb2,0x00,0x08,0x00,0x00]
+          vcvtqq2psx 2048(%rdx), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx 2048(%rdx), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8c,0x5b,0xb2,0x00,0x08,0x00,0x00]
+          vcvtqq2psx 2048(%rdx), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx -2048(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0x72,0x80]
           vcvtqq2psx -2048(%rdx), %xmm30
 
+// CHECK: vcvtqq2psx -2048(%rdx), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0c,0x5b,0x72,0x80]
+          vcvtqq2psx -2048(%rdx), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx -2048(%rdx), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8c,0x5b,0x72,0x80]
+          vcvtqq2psx -2048(%rdx), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2psx -2064(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x5b,0xb2,0xf0,0xf7,0xff,0xff]
           vcvtqq2psx -2064(%rdx), %xmm30
 
+// CHECK: vcvtqq2psx -2064(%rdx), %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0c,0x5b,0xb2,0xf0,0xf7,0xff,0xff]
+          vcvtqq2psx -2064(%rdx), %xmm30 {%k4}
+
+// CHECK: vcvtqq2psx -2064(%rdx), %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8c,0x5b,0xb2,0xf0,0xf7,0xff,0xff]
+          vcvtqq2psx -2064(%rdx), %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x72,0x7f]
           vcvtqq2ps 1016(%rdx){1to2}, %xmm30
 
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x72,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm30
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x72,0x7f]
+          vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x72,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x72,0x7f]
+          vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4} {z}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x72,0x7f]
+          vcvtqq2psx 1016(%rdx){1to2}, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0xb2,0x00,0x04,0x00,0x00]
           vcvtqq2ps 1024(%rdx){1to2}, %xmm30
 
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0xb2,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm30
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0xb2,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0xb2,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0xb2,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4} {z}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0xb2,0x00,0x04,0x00,0x00]
+          vcvtqq2psx 1024(%rdx){1to2}, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x72,0x80]
           vcvtqq2ps -1024(%rdx){1to2}, %xmm30
 
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0x72,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm30
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x72,0x80]
+          vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0x72,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x72,0x80]
+          vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4} {z}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0x72,0x80]
+          vcvtqq2psx -1024(%rdx){1to2}, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
           vcvtqq2ps -1032(%rdx){1to2}, %xmm30
 
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm30
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1c,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm30 {%k4}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4} {z}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to2}, %xmm30 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9c,0x5b,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psx -1032(%rdx){1to2}, %xmm30 {%k4} {z}
+
 // CHECK: vcvtqq2ps %ymm28, %xmm20
 // CHECK:  encoding: [0x62,0x81,0xfc,0x28,0x5b,0xe4]
           vcvtqq2ps %ymm28, %xmm20
 
+// CHECK: vcvtqq2ps %ymm28, %xmm20
+// CHECK:  encoding: [0x62,0x81,0xfc,0x28,0x5b,0xe4]
+          vcvtqq2psy %ymm28, %xmm20
+
 // CHECK: vcvtqq2ps %ymm28, %xmm20 {%k3}
 // CHECK:  encoding: [0x62,0x81,0xfc,0x2b,0x5b,0xe4]
           vcvtqq2ps %ymm28, %xmm20 {%k3}
 
+// CHECK: vcvtqq2ps %ymm28, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0x81,0xfc,0x2b,0x5b,0xe4]
+          vcvtqq2psy %ymm28, %xmm20 {%k3}
+
 // CHECK: vcvtqq2ps %ymm28, %xmm20 {%k3} {z}
 // CHECK:  encoding: [0x62,0x81,0xfc,0xab,0x5b,0xe4]
           vcvtqq2ps %ymm28, %xmm20 {%k3} {z}
 
+// CHECK: vcvtqq2ps %ymm28, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0x81,0xfc,0xab,0x5b,0xe4]
+          vcvtqq2psy %ymm28, %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy (%rcx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x5b,0x21]
           vcvtqq2psy (%rcx), %xmm20
 
+// CHECK: vcvtqq2psy (%rcx), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2b,0x5b,0x21]
+          vcvtqq2psy (%rcx), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy (%rcx), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xab,0x5b,0x21]
+          vcvtqq2psy (%rcx), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy 4660(%rax,%r14,8), %xmm20
 // CHECK:  encoding: [0x62,0xa1,0xfc,0x28,0x5b,0xa4,0xf0,0x34,0x12,0x00,0x00]
           vcvtqq2psy 4660(%rax,%r14,8), %xmm20
 
+// CHECK: vcvtqq2psy 4660(%rax,%r14,8), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x2b,0x5b,0xa4,0xf0,0x34,0x12,0x00,0x00]
+          vcvtqq2psy 4660(%rax,%r14,8), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy 4660(%rax,%r14,8), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0xab,0x5b,0xa4,0xf0,0x34,0x12,0x00,0x00]
+          vcvtqq2psy 4660(%rax,%r14,8), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x21]
           vcvtqq2ps (%rcx){1to4}, %xmm20
 
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x21]
+          vcvtqq2psy (%rcx){1to4}, %xmm20
+
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x21]
+          vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x21]
+          vcvtqq2psy (%rcx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x21]
+          vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3} {z}
+
+// CHECK: vcvtqq2ps (%rcx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x21]
+          vcvtqq2psy (%rcx){1to4}, %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy 4064(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x5b,0x62,0x7f]
           vcvtqq2psy 4064(%rdx), %xmm20
 
+// CHECK: vcvtqq2psy 4064(%rdx), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2b,0x5b,0x62,0x7f]
+          vcvtqq2psy 4064(%rdx), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy 4064(%rdx), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xab,0x5b,0x62,0x7f]
+          vcvtqq2psy 4064(%rdx), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy 4096(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x5b,0xa2,0x00,0x10,0x00,0x00]
           vcvtqq2psy 4096(%rdx), %xmm20
 
+// CHECK: vcvtqq2psy 4096(%rdx), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2b,0x5b,0xa2,0x00,0x10,0x00,0x00]
+          vcvtqq2psy 4096(%rdx), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy 4096(%rdx), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xab,0x5b,0xa2,0x00,0x10,0x00,0x00]
+          vcvtqq2psy 4096(%rdx), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy -4096(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x5b,0x62,0x80]
           vcvtqq2psy -4096(%rdx), %xmm20
 
+// CHECK: vcvtqq2psy -4096(%rdx), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2b,0x5b,0x62,0x80]
+          vcvtqq2psy -4096(%rdx), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy -4096(%rdx), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xab,0x5b,0x62,0x80]
+          vcvtqq2psy -4096(%rdx), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2psy -4128(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x5b,0xa2,0xe0,0xef,0xff,0xff]
           vcvtqq2psy -4128(%rdx), %xmm20
 
+// CHECK: vcvtqq2psy -4128(%rdx), %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2b,0x5b,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtqq2psy -4128(%rdx), %xmm20 {%k3}
+
+// CHECK: vcvtqq2psy -4128(%rdx), %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xab,0x5b,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtqq2psy -4128(%rdx), %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x62,0x7f]
           vcvtqq2ps 1016(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x62,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x62,0x7f]
+          vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x62,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x62,0x7f]
+          vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3} {z}
+
+// CHECK: vcvtqq2ps 1016(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x62,0x7f]
+          vcvtqq2psy 1016(%rdx){1to4}, %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0xa2,0x00,0x04,0x00,0x00]
           vcvtqq2ps 1024(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0xa2,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0xa2,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0xa2,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0xa2,0x00,0x04,0x00,0x00]
+          vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3} {z}
+
+// CHECK: vcvtqq2ps 1024(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0xa2,0x00,0x04,0x00,0x00]
+          vcvtqq2psy 1024(%rdx){1to4}, %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x62,0x80]
           vcvtqq2ps -1024(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0x62,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x62,0x80]
+          vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0x62,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x62,0x80]
+          vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3} {z}
+
+// CHECK: vcvtqq2ps -1024(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0x62,0x80]
+          vcvtqq2psy -1024(%rdx){1to4}, %xmm20 {%k3} {z}
+
 // CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
           vcvtqq2ps -1032(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3b,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm20 {%k3}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3} {z}
+
+// CHECK: vcvtqq2ps -1032(%rdx){1to4}, %xmm20 {%k3} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xbb,0x5b,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtqq2psy -1032(%rdx){1to4}, %xmm20 {%k3} {z}
+
 // CHECK: vcvtuqq2pd %xmm20, %xmm19
 // CHECK:  encoding: [0x62,0xa1,0xfe,0x08,0x7a,0xdc]
           vcvtuqq2pd %xmm20, %xmm19
@@ -3588,226 +4216,870 @@
 // CHECK:  encoding: [0x62,0x81,0xff,0x08,0x7a,0xeb]
           vcvtuqq2ps %xmm27, %xmm21
 
+// CHECK: vcvtuqq2ps %xmm27, %xmm21
+// CHECK:  encoding: [0x62,0x81,0xff,0x08,0x7a,0xeb]
+          vcvtuqq2psx %xmm27, %xmm21
+
 // CHECK: vcvtuqq2ps %xmm27, %xmm21 {%k7}
 // CHECK:  encoding: [0x62,0x81,0xff,0x0f,0x7a,0xeb]
           vcvtuqq2ps %xmm27, %xmm21 {%k7}
 
+// CHECK: vcvtuqq2ps %xmm27, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0x81,0xff,0x0f,0x7a,0xeb]
+          vcvtuqq2psx %xmm27, %xmm21 {%k7}
+
 // CHECK: vcvtuqq2ps %xmm27, %xmm21 {%k7} {z}
 // CHECK:  encoding: [0x62,0x81,0xff,0x8f,0x7a,0xeb]
           vcvtuqq2ps %xmm27, %xmm21 {%k7} {z}
 
+// CHECK: vcvtuqq2ps %xmm27, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0x81,0xff,0x8f,0x7a,0xeb]
+          vcvtuqq2psx %xmm27, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx (%rcx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x29]
           vcvtuqq2psx (%rcx), %xmm21
 
+// CHECK: vcvtuqq2psx (%rcx), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0f,0x7a,0x29]
+          vcvtuqq2psx (%rcx), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx (%rcx), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8f,0x7a,0x29]
+          vcvtuqq2psx (%rcx), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx 291(%rax,%r14,8), %xmm21
 // CHECK:  encoding: [0x62,0xa1,0xff,0x08,0x7a,0xac,0xf0,0x23,0x01,0x00,0x00]
           vcvtuqq2psx 291(%rax,%r14,8), %xmm21
 
+// CHECK: vcvtuqq2psx 291(%rax,%r14,8), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x0f,0x7a,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvtuqq2psx 291(%rax,%r14,8), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx 291(%rax,%r14,8), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x8f,0x7a,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvtuqq2psx 291(%rax,%r14,8), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x29]
           vcvtuqq2ps (%rcx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x29]
+          vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x29]
+          vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7} {z}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx 2032(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x6a,0x7f]
           vcvtuqq2psx 2032(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx 2032(%rdx), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0f,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 2032(%rdx), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx 2032(%rdx), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8f,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 2032(%rdx), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx 2048(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0xaa,0x00,0x08,0x00,0x00]
           vcvtuqq2psx 2048(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx 2048(%rdx), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0f,0x7a,0xaa,0x00,0x08,0x00,0x00]
+          vcvtuqq2psx 2048(%rdx), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx 2048(%rdx), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8f,0x7a,0xaa,0x00,0x08,0x00,0x00]
+          vcvtuqq2psx 2048(%rdx), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx -2048(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x6a,0x80]
           vcvtuqq2psx -2048(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx -2048(%rdx), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0f,0x7a,0x6a,0x80]
+          vcvtuqq2psx -2048(%rdx), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx -2048(%rdx), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8f,0x7a,0x6a,0x80]
+          vcvtuqq2psx -2048(%rdx), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2psx -2064(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
           vcvtuqq2psx -2064(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx -2064(%rdx), %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0f,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvtuqq2psx -2064(%rdx), %xmm21 {%k7}
+
+// CHECK: vcvtuqq2psx -2064(%rdx), %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8f,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvtuqq2psx -2064(%rdx), %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x7f]
           vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x6a,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x6a,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7} {z}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0x00,0x04,0x00,0x00]
           vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7} {z}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x80]
           vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x6a,0x80]
+          vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x6a,0x80]
+          vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7} {z}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
           vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1f,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21 {%k7}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7} {z}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k7} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9f,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21 {%k7} {z}
+
 // CHECK: vcvtuqq2ps %ymm24, %xmm28
 // CHECK:  encoding: [0x62,0x01,0xff,0x28,0x7a,0xe0]
           vcvtuqq2ps %ymm24, %xmm28
 
+// CHECK: vcvtuqq2ps %ymm24, %xmm28
+// CHECK:  encoding: [0x62,0x01,0xff,0x28,0x7a,0xe0]
+          vcvtuqq2psy %ymm24, %xmm28
+
 // CHECK: vcvtuqq2ps %ymm24, %xmm28 {%k3}
 // CHECK:  encoding: [0x62,0x01,0xff,0x2b,0x7a,0xe0]
           vcvtuqq2ps %ymm24, %xmm28 {%k3}
 
+// CHECK: vcvtuqq2ps %ymm24, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x01,0xff,0x2b,0x7a,0xe0]
+          vcvtuqq2psy %ymm24, %xmm28 {%k3}
+
 // CHECK: vcvtuqq2ps %ymm24, %xmm28 {%k3} {z}
 // CHECK:  encoding: [0x62,0x01,0xff,0xab,0x7a,0xe0]
           vcvtuqq2ps %ymm24, %xmm28 {%k3} {z}
 
+// CHECK: vcvtuqq2ps %ymm24, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x01,0xff,0xab,0x7a,0xe0]
+          vcvtuqq2psy %ymm24, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy (%rcx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x21]
           vcvtuqq2psy (%rcx), %xmm28
 
+// CHECK: vcvtuqq2psy (%rcx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0x7a,0x21]
+          vcvtuqq2psy (%rcx), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy (%rcx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0x7a,0x21]
+          vcvtuqq2psy (%rcx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy 291(%rax,%r14,8), %xmm28
 // CHECK:  encoding: [0x62,0x21,0xff,0x28,0x7a,0xa4,0xf0,0x23,0x01,0x00,0x00]
           vcvtuqq2psy 291(%rax,%r14,8), %xmm28
 
+// CHECK: vcvtuqq2psy 291(%rax,%r14,8), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xff,0x2b,0x7a,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtuqq2psy 291(%rax,%r14,8), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy 291(%rax,%r14,8), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0xab,0x7a,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtuqq2psy 291(%rax,%r14,8), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x21]
           vcvtuqq2ps (%rcx){1to4}, %xmm28
 
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x21]
+          vcvtuqq2psy (%rcx){1to4}, %xmm28
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x21]
+          vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x21]
+          vcvtuqq2psy (%rcx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x21]
+          vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x21]
+          vcvtuqq2psy (%rcx){1to4}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy 4064(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x62,0x7f]
           vcvtuqq2psy 4064(%rdx), %xmm28
 
+// CHECK: vcvtuqq2psy 4064(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0x7a,0x62,0x7f]
+          vcvtuqq2psy 4064(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy 4064(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0x7a,0x62,0x7f]
+          vcvtuqq2psy 4064(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy 4096(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0xa2,0x00,0x10,0x00,0x00]
           vcvtuqq2psy 4096(%rdx), %xmm28
 
+// CHECK: vcvtuqq2psy 4096(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0x7a,0xa2,0x00,0x10,0x00,0x00]
+          vcvtuqq2psy 4096(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy 4096(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0x7a,0xa2,0x00,0x10,0x00,0x00]
+          vcvtuqq2psy 4096(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy -4096(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x62,0x80]
           vcvtuqq2psy -4096(%rdx), %xmm28
 
+// CHECK: vcvtuqq2psy -4096(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0x7a,0x62,0x80]
+          vcvtuqq2psy -4096(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy -4096(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0x7a,0x62,0x80]
+          vcvtuqq2psy -4096(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2psy -4128(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0xa2,0xe0,0xef,0xff,0xff]
           vcvtuqq2psy -4128(%rdx), %xmm28
 
+// CHECK: vcvtuqq2psy -4128(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0x7a,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtuqq2psy -4128(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtuqq2psy -4128(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0x7a,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtuqq2psy -4128(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x62,0x7f]
           vcvtuqq2ps 1016(%rdx){1to4}, %xmm28
 
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x62,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm28
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x62,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x62,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x62,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x62,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0xa2,0x00,0x04,0x00,0x00]
           vcvtuqq2ps 1024(%rdx){1to4}, %xmm28
 
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm28
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x62,0x80]
           vcvtuqq2ps -1024(%rdx){1to4}, %xmm28
 
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x62,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm28
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x62,0x80]
+          vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0x62,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x62,0x80]
+          vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0x62,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
           vcvtuqq2ps -1032(%rdx){1to4}, %xmm28
 
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm28
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm28 {%k3}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0x7a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtuqq2ps %xmm22, %xmm21
 // CHECK:  encoding: [0x62,0xa1,0xff,0x08,0x7a,0xee]
           vcvtuqq2ps %xmm22, %xmm21
 
+// CHECK: vcvtuqq2ps %xmm22, %xmm21
+// CHECK:  encoding: [0x62,0xa1,0xff,0x08,0x7a,0xee]
+          vcvtuqq2psx %xmm22, %xmm21
+
 // CHECK: vcvtuqq2ps %xmm22, %xmm21 {%k6}
 // CHECK:  encoding: [0x62,0xa1,0xff,0x0e,0x7a,0xee]
           vcvtuqq2ps %xmm22, %xmm21 {%k6}
 
+// CHECK: vcvtuqq2ps %xmm22, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x0e,0x7a,0xee]
+          vcvtuqq2psx %xmm22, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps %xmm22, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x8e,0x7a,0xee]
+          vcvtuqq2ps %xmm22, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps %xmm22, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x8e,0x7a,0xee]
+          vcvtuqq2psx %xmm22, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps %xmm22, %xmm21 {%k6} {z}
 // CHECK:  encoding: [0x62,0xa1,0xff,0x8e,0x7a,0xee]
-          vcvtuqq2ps %xmm22, %xmm21 {%k6} {z}
+          vcvtuqq2psx %xmm22, %xmm21 {%k6} {z}
 
 // CHECK: vcvtuqq2psx (%rcx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x29]
           vcvtuqq2psx (%rcx), %xmm21
 
+// CHECK: vcvtuqq2psx (%rcx), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0e,0x7a,0x29]
+          vcvtuqq2psx (%rcx), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx (%rcx), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8e,0x7a,0x29]
+          vcvtuqq2psx (%rcx), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2psx 4660(%rax,%r14,8), %xmm21
 // CHECK:  encoding: [0x62,0xa1,0xff,0x08,0x7a,0xac,0xf0,0x34,0x12,0x00,0x00]
           vcvtuqq2psx 4660(%rax,%r14,8), %xmm21
 
+// CHECK: vcvtuqq2psx 4660(%rax,%r14,8), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x0e,0x7a,0xac,0xf0,0x34,0x12,0x00,0x00]
+          vcvtuqq2psx 4660(%rax,%r14,8), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx 4660(%rax,%r14,8), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xa1,0xff,0x8e,0x7a,0xac,0xf0,0x34,0x12,0x00,0x00]
+          vcvtuqq2psx 4660(%rax,%r14,8), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x29]
           vcvtuqq2ps (%rcx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x29]
+          vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x29]
+          vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps (%rcx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x29]
+          vcvtuqq2psx (%rcx){1to2}, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2psx 2032(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x6a,0x7f]
           vcvtuqq2psx 2032(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx 2032(%rdx), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0e,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 2032(%rdx), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx 2032(%rdx), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8e,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 2032(%rdx), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2psx 2048(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0xaa,0x00,0x08,0x00,0x00]
           vcvtuqq2psx 2048(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx 2048(%rdx), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0e,0x7a,0xaa,0x00,0x08,0x00,0x00]
+          vcvtuqq2psx 2048(%rdx), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx 2048(%rdx), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8e,0x7a,0xaa,0x00,0x08,0x00,0x00]
+          vcvtuqq2psx 2048(%rdx), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2psx -2048(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0x6a,0x80]
           vcvtuqq2psx -2048(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx -2048(%rdx), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0e,0x7a,0x6a,0x80]
+          vcvtuqq2psx -2048(%rdx), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx -2048(%rdx), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8e,0x7a,0x6a,0x80]
+          vcvtuqq2psx -2048(%rdx), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2psx -2064(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x08,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
           vcvtuqq2psx -2064(%rdx), %xmm21
 
+// CHECK: vcvtuqq2psx -2064(%rdx), %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x0e,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvtuqq2psx -2064(%rdx), %xmm21 {%k6}
+
+// CHECK: vcvtuqq2psx -2064(%rdx), %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x8e,0x7a,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvtuqq2psx -2064(%rdx), %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x7f]
           vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x6a,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x6a,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x6a,0x7f]
+          vcvtuqq2psx 1016(%rdx){1to2}, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0x00,0x04,0x00,0x00]
           vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0xaa,0x00,0x04,0x00,0x00]
+          vcvtuqq2psx 1024(%rdx){1to2}, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x80]
           vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x6a,0x80]
+          vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x6a,0x80]
+          vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0x6a,0x80]
+          vcvtuqq2psx -1024(%rdx){1to2}, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
           vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
 
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xff,0x18,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x1e,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21 {%k6}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6} {z}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to2}, %xmm21 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xff,0x9e,0x7a,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psx -1032(%rdx){1to2}, %xmm21 {%k6} {z}
+
 // CHECK: vcvtuqq2ps %ymm17, %xmm26
 // CHECK:  encoding: [0x62,0x21,0xff,0x28,0x7a,0xd1]
           vcvtuqq2ps %ymm17, %xmm26
 
+// CHECK: vcvtuqq2ps %ymm17, %xmm26
+// CHECK:  encoding: [0x62,0x21,0xff,0x28,0x7a,0xd1]
+          vcvtuqq2psy %ymm17, %xmm26
+
 // CHECK: vcvtuqq2ps %ymm17, %xmm26 {%k4}
 // CHECK:  encoding: [0x62,0x21,0xff,0x2c,0x7a,0xd1]
           vcvtuqq2ps %ymm17, %xmm26 {%k4}
 
+// CHECK: vcvtuqq2ps %ymm17, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x21,0xff,0x2c,0x7a,0xd1]
+          vcvtuqq2psy %ymm17, %xmm26 {%k4}
+
 // CHECK: vcvtuqq2ps %ymm17, %xmm26 {%k4} {z}
 // CHECK:  encoding: [0x62,0x21,0xff,0xac,0x7a,0xd1]
           vcvtuqq2ps %ymm17, %xmm26 {%k4} {z}
 
+// CHECK: vcvtuqq2ps %ymm17, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0xac,0x7a,0xd1]
+          vcvtuqq2psy %ymm17, %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy (%rcx), %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x11]
           vcvtuqq2psy (%rcx), %xmm26
 
+// CHECK: vcvtuqq2psy (%rcx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2c,0x7a,0x11]
+          vcvtuqq2psy (%rcx), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy (%rcx), %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xac,0x7a,0x11]
+          vcvtuqq2psy (%rcx), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy 4660(%rax,%r14,8), %xmm26
 // CHECK:  encoding: [0x62,0x21,0xff,0x28,0x7a,0x94,0xf0,0x34,0x12,0x00,0x00]
           vcvtuqq2psy 4660(%rax,%r14,8), %xmm26
 
+// CHECK: vcvtuqq2psy 4660(%rax,%r14,8), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x21,0xff,0x2c,0x7a,0x94,0xf0,0x34,0x12,0x00,0x00]
+          vcvtuqq2psy 4660(%rax,%r14,8), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy 4660(%rax,%r14,8), %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0xac,0x7a,0x94,0xf0,0x34,0x12,0x00,0x00]
+          vcvtuqq2psy 4660(%rax,%r14,8), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x11]
           vcvtuqq2ps (%rcx){1to4}, %xmm26
 
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x11]
+          vcvtuqq2psy (%rcx){1to4}, %xmm26
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x11]
+          vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x11]
+          vcvtuqq2psy (%rcx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x11]
+          vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4} {z}
+
+// CHECK: vcvtuqq2ps (%rcx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x11]
+          vcvtuqq2psy (%rcx){1to4}, %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy 4064(%rdx), %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x52,0x7f]
           vcvtuqq2psy 4064(%rdx), %xmm26
 
+// CHECK: vcvtuqq2psy 4064(%rdx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2c,0x7a,0x52,0x7f]
+          vcvtuqq2psy 4064(%rdx), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy 4064(%rdx), %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xac,0x7a,0x52,0x7f]
+          vcvtuqq2psy 4064(%rdx), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy 4096(%rdx), %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x92,0x00,0x10,0x00,0x00]
           vcvtuqq2psy 4096(%rdx), %xmm26
 
+// CHECK: vcvtuqq2psy 4096(%rdx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2c,0x7a,0x92,0x00,0x10,0x00,0x00]
+          vcvtuqq2psy 4096(%rdx), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy 4096(%rdx), %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xac,0x7a,0x92,0x00,0x10,0x00,0x00]
+          vcvtuqq2psy 4096(%rdx), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy -4096(%rdx), %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x52,0x80]
           vcvtuqq2psy -4096(%rdx), %xmm26
 
+// CHECK: vcvtuqq2psy -4096(%rdx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2c,0x7a,0x52,0x80]
+          vcvtuqq2psy -4096(%rdx), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy -4096(%rdx), %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xac,0x7a,0x52,0x80]
+          vcvtuqq2psy -4096(%rdx), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2psy -4128(%rdx), %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0x7a,0x92,0xe0,0xef,0xff,0xff]
           vcvtuqq2psy -4128(%rdx), %xmm26
 
+// CHECK: vcvtuqq2psy -4128(%rdx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2c,0x7a,0x92,0xe0,0xef,0xff,0xff]
+          vcvtuqq2psy -4128(%rdx), %xmm26 {%k4}
+
+// CHECK: vcvtuqq2psy -4128(%rdx), %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0xac,0x7a,0x92,0xe0,0xef,0xff,0xff]
+          vcvtuqq2psy -4128(%rdx), %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x52,0x7f]
           vcvtuqq2ps 1016(%rdx){1to4}, %xmm26
 
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x52,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm26
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x52,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x52,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x52,0x7f]
+          vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4} {z}
+
+// CHECK: vcvtuqq2ps 1016(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x52,0x7f]
+          vcvtuqq2psy 1016(%rdx){1to4}, %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x92,0x00,0x04,0x00,0x00]
           vcvtuqq2ps 1024(%rdx){1to4}, %xmm26
 
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x92,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm26
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x92,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x92,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x92,0x00,0x04,0x00,0x00]
+          vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4} {z}
+
+// CHECK: vcvtuqq2ps 1024(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x92,0x00,0x04,0x00,0x00]
+          vcvtuqq2psy 1024(%rdx){1to4}, %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x52,0x80]
           vcvtuqq2ps -1024(%rdx){1to4}, %xmm26
 
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x52,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm26
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x52,0x80]
+          vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x52,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x52,0x80]
+          vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4} {z}
+
+// CHECK: vcvtuqq2ps -1024(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x52,0x80]
+          vcvtuqq2psy -1024(%rdx){1to4}, %xmm26 {%k4} {z}
+
 // CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x92,0xf8,0xfb,0xff,0xff]
           vcvtuqq2ps -1032(%rdx){1to4}, %xmm26
 
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0x7a,0x92,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm26
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x92,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3c,0x7a,0x92,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm26 {%k4}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x92,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4} {z}
+
+// CHECK: vcvtuqq2ps -1032(%rdx){1to4}, %xmm26 {%k4} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbc,0x7a,0x92,0xf8,0xfb,0xff,0xff]
+          vcvtuqq2psy -1032(%rdx){1to4}, %xmm26 {%k4} {z}
+
 // CHECK: vinsertf64x2 $171, %xmm23, %ymm27, %ymm21
 // CHECK:  encoding: [0x62,0xa3,0xa5,0x20,0x18,0xef,0xab]
           vinsertf64x2 $0xab, %xmm23, %ymm27, %ymm21
@@ -4164,14 +5436,26 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0xd2,0xab]
           vfpclasspd $0xab, %xmm18, %k2
 
+// CHECK: vfpclasspd $171, %xmm18, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0xd2,0xab]
+          vfpclasspdx $0xab, %xmm18, %k2
+
 // CHECK: vfpclasspd $171, %xmm18, %k2 {%k7}
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x0f,0x66,0xd2,0xab]
           vfpclasspd $0xab, %xmm18, %k2 {%k7}
 
+// CHECK: vfpclasspd $171, %xmm18, %k2 {%k7}
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x0f,0x66,0xd2,0xab]
+          vfpclasspdx $0xab, %xmm18, %k2 {%k7}
+
 // CHECK: vfpclasspd $123,  %xmm18, %k2
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0xd2,0x7b]
           vfpclasspd $0x7b, %xmm18, %k2
 
+// CHECK: vfpclasspd $123,  %xmm18, %k2
+// CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0xd2,0x7b]
+          vfpclasspdx $0x7b, %xmm18, %k2
+
 // CHECK: vfpclasspdx $123, (%rcx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x11,0x7b]
           vfpclasspdx $0x7b,(%rcx), %k2
@@ -4180,9 +5464,13 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0x94,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspdx $0x7b,291(%rax,%r14,8), %k2
 
-// CHECK: vfpclasspdq $123, (%rcx){1to2}, %k2
+// CHECK: vfpclasspd $123, (%rcx){1to2}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x11,0x7b]
+          vfpclasspd $0x7b,(%rcx){1to2}, %k2
+
+// CHECK: vfpclasspd $123, (%rcx){1to2}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x11,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to2}, %k2
+          vfpclasspdx $0x7b,(%rcx){1to2}, %k2
 
 // CHECK: vfpclasspdx $123, 2032(%rdx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x52,0x7f,0x7b]
@@ -4200,34 +5488,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x92,0xf0,0xf7,0xff,0xff,0x7b]
           vfpclasspdx $0x7b,-2064(%rdx), %k2
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to2}, %k2
+// CHECK: vfpclasspd $123, 1016(%rdx){1to2}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x52,0x7f,0x7b]
+          vfpclasspd $0x7b,1016(%rdx){1to2}, %k2
+
+// CHECK: vfpclasspd $123, 1016(%rdx){1to2}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x52,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to2}, %k2
+          vfpclasspdx $0x7b,1016(%rdx){1to2}, %k2
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to2}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspd $0x7b,1024(%rdx){1to2}, %k2
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to2}, %k2
+// CHECK: vfpclasspd $123, 1024(%rdx){1to2}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to2}, %k2
+          vfpclasspdx $0x7b,1024(%rdx){1to2}, %k2
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to2}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x52,0x80,0x7b]
+          vfpclasspd $0x7b,-1024(%rdx){1to2}, %k2
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to2}, %k2
+// CHECK: vfpclasspd $123, -1024(%rdx){1to2}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x52,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to2}, %k2
+          vfpclasspdx $0x7b,-1024(%rdx){1to2}, %k2
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to2}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspd $0x7b,-1032(%rdx){1to2}, %k2
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to2}, %k2
+// CHECK: vfpclasspd $123, -1032(%rdx){1to2}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to2}, %k2
+          vfpclasspdx $0x7b,-1032(%rdx){1to2}, %k2
 
 // CHECK: vfpclasspd $171, %ymm25, %k4
 // CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xe1,0xab]
           vfpclasspd $0xab, %ymm25, %k4
 
+// CHECK: vfpclasspd $171, %ymm25, %k4
+// CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xe1,0xab]
+          vfpclasspdy $0xab, %ymm25, %k4
+
 // CHECK: vfpclasspd $171, %ymm25, %k4 {%k6}
 // CHECK:  encoding: [0x62,0x93,0xfd,0x2e,0x66,0xe1,0xab]
           vfpclasspd $0xab, %ymm25, %k4 {%k6}
 
+// CHECK: vfpclasspd $171, %ymm25, %k4 {%k6}
+// CHECK:  encoding: [0x62,0x93,0xfd,0x2e,0x66,0xe1,0xab]
+          vfpclasspdy $0xab, %ymm25, %k4 {%k6}
+
 // CHECK: vfpclasspd $123,  %ymm25, %k4
 // CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xe1,0x7b]
           vfpclasspd $0x7b, %ymm25, %k4
 
+// CHECK: vfpclasspd $123,  %ymm25, %k4
+// CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xe1,0x7b]
+          vfpclasspdy $0x7b, %ymm25, %k4
+
 // CHECK: vfpclasspdy $123, (%rcx), %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x21,0x7b]
           vfpclasspdy $0x7b,(%rcx), %k4
@@ -4236,9 +5552,13 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x28,0x66,0xa4,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspdy $0x7b,291(%rax,%r14,8), %k4
 
-// CHECK: vfpclasspdq $123, (%rcx){1to4}, %k4
+// CHECK: vfpclasspd $123, (%rcx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x21,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to4}, %k4
+          vfpclasspd $0x7b,(%rcx){1to4}, %k4
+
+// CHECK: vfpclasspd $123, (%rcx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x21,0x7b]
+          vfpclasspdy $0x7b,(%rcx){1to4}, %k4
 
 // CHECK: vfpclasspdy $123, 4064(%rdx), %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x62,0x7f,0x7b]
@@ -4256,34 +5576,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0xa2,0xe0,0xef,0xff,0xff,0x7b]
           vfpclasspdy $0x7b,-4128(%rdx), %k4
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to4}, %k4
+// CHECK: vfpclasspd $123, 1016(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x62,0x7f,0x7b]
+          vfpclasspd $0x7b,1016(%rdx){1to4}, %k4
+
+// CHECK: vfpclasspd $123, 1016(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x62,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to4}, %k4
+          vfpclasspdy $0x7b,1016(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to4}, %k4
+// CHECK: vfpclasspd $123, 1024(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0xa2,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to4}, %k4
+          vfpclasspd $0x7b,1024(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to4}, %k4
+// CHECK: vfpclasspd $123, 1024(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0xa2,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspdy $0x7b,1024(%rdx){1to4}, %k4
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x62,0x80,0x7b]
+          vfpclasspd $0x7b,-1024(%rdx){1to4}, %k4
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x62,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to4}, %k4
+          vfpclasspdy $0x7b,-1024(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to4}, %k4
+// CHECK: vfpclasspd $123, -1032(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0xa2,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to4}, %k4
+          vfpclasspd $0x7b,-1032(%rdx){1to4}, %k4
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0xa2,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspdy $0x7b,-1032(%rdx){1to4}, %k4
 
 // CHECK: vfpclassps $171, %xmm20, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xe4,0xab]
           vfpclassps $0xab, %xmm20, %k4
 
+// CHECK: vfpclassps $171, %xmm20, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xe4,0xab]
+          vfpclasspsx $0xab, %xmm20, %k4
+
 // CHECK: vfpclassps $171, %xmm20, %k4 {%k5}
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x0d,0x66,0xe4,0xab]
           vfpclassps $0xab, %xmm20, %k4 {%k5}
 
+// CHECK: vfpclassps $171, %xmm20, %k4 {%k5}
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x0d,0x66,0xe4,0xab]
+          vfpclasspsx $0xab, %xmm20, %k4 {%k5}
+
 // CHECK: vfpclassps $123,  %xmm20, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xe4,0x7b]
           vfpclassps $0x7b, %xmm20, %k4
 
+// CHECK: vfpclassps $123,  %xmm20, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xe4,0x7b]
+          vfpclasspsx $0x7b, %xmm20, %k4
+
 // CHECK: vfpclasspsx $123, (%rcx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x21,0x7b]
           vfpclasspsx $0x7b,(%rcx), %k4
@@ -4292,9 +5640,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0xa4,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspsx $0x7b,291(%rax,%r14,8), %k4
 
-// CHECK: vfpclasspsl $123, (%rcx){1to4}, %k4
+// CHECK: vfpclassps $123, (%rcx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x21,0x7b]
+          vfpclassps $0x7b,(%rcx){1to4}, %k4
+
+// CHECK: vfpclassps $123, (%rcx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x21,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to4}, %k4
+          vfpclasspsx $0x7b,(%rcx){1to4}, %k4
 
 // CHECK: vfpclasspsx $123, 2032(%rdx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x62,0x7f,0x7b]
@@ -4312,34 +5664,62 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0xa2,0xf0,0xf7,0xff,0xff,0x7b]
           vfpclasspsx $0x7b,-2064(%rdx), %k4
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to4}, %k4
+// CHECK: vfpclassps $123, 508(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x62,0x7f,0x7b]
+          vfpclassps $0x7b,508(%rdx){1to4}, %k4
+
+// CHECK: vfpclassps $123, 508(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x62,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to4}, %k4
+          vfpclasspsx $0x7b,508(%rdx){1to4}, %k4
+
+// CHECK: vfpclassps $123, 512(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
+          vfpclassps $0x7b,512(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to4}, %k4
+// CHECK: vfpclassps $123, 512(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to4}, %k4
+          vfpclasspsx $0x7b,512(%rdx){1to4}, %k4
+
+// CHECK: vfpclassps $123, -512(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x62,0x80,0x7b]
+          vfpclassps $0x7b,-512(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to4}, %k4
+// CHECK: vfpclassps $123, -512(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x62,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to4}, %k4
+          vfpclasspsx $0x7b,-512(%rdx){1to4}, %k4
+
+// CHECK: vfpclassps $123, -516(%rdx){1to4}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclassps $0x7b,-516(%rdx){1to4}, %k4
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to4}, %k4
+// CHECK: vfpclassps $123, -516(%rdx){1to4}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to4}, %k4
+          vfpclasspsx $0x7b,-516(%rdx){1to4}, %k4
 
 // CHECK: vfpclassps $171, %ymm17, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xe1,0xab]
           vfpclassps $0xab, %ymm17, %k4
 
+// CHECK: vfpclassps $171, %ymm17, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xe1,0xab]
+          vfpclasspsy $0xab, %ymm17, %k4
+
 // CHECK: vfpclassps $171, %ymm17, %k4 {%k5}
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x2d,0x66,0xe1,0xab]
           vfpclassps $0xab, %ymm17, %k4 {%k5}
 
+// CHECK: vfpclassps $171, %ymm17, %k4 {%k5}
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x2d,0x66,0xe1,0xab]
+          vfpclasspsy $0xab, %ymm17, %k4 {%k5}
+
 // CHECK: vfpclassps $123,  %ymm17, %k4
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xe1,0x7b]
           vfpclassps $0x7b, %ymm17, %k4
 
+// CHECK: vfpclassps $123,  %ymm17, %k4
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xe1,0x7b]
+          vfpclasspsy $0x7b, %ymm17, %k4
+
 // CHECK: vfpclasspsy $123, (%rcx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x21,0x7b]
           vfpclasspsy $0x7b,(%rcx), %k4
@@ -4348,9 +5728,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xa4,0xf0,0x23,0x01,0x00,0x00,0x7b]
           vfpclasspsy $0x7b,291(%rax,%r14,8), %k4
 
-// CHECK: vfpclasspsl $123, (%rcx){1to8}, %k4
+// CHECK: vfpclassps $123, (%rcx){1to8}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x21,0x7b]
+          vfpclassps $0x7b,(%rcx){1to8}, %k4
+
+// CHECK: vfpclassps $123, (%rcx){1to8}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x21,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to8}, %k4
+          vfpclasspsy $0x7b,(%rcx){1to8}, %k4
 
 // CHECK: vfpclasspsy $123, 4064(%rdx), %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x62,0x7f,0x7b]
@@ -4368,34 +5752,62 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0xa2,0xe0,0xef,0xff,0xff,0x7b]
           vfpclasspsy $0x7b,-4128(%rdx), %k4
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to8}, %k4
+// CHECK: vfpclassps $123, 508(%rdx){1to8}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x62,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to8}, %k4
+          vfpclassps $0x7b,508(%rdx){1to8}, %k4
+
+// CHECK: vfpclassps $123, 508(%rdx){1to8}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x62,0x7f,0x7b]
+          vfpclasspsy $0x7b,508(%rdx){1to8}, %k4
+
+// CHECK: vfpclassps $123, 512(%rdx){1to8}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
+          vfpclassps $0x7b,512(%rdx){1to8}, %k4
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to8}, %k4
+// CHECK: vfpclassps $123, 512(%rdx){1to8}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0xa2,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to8}, %k4
+          vfpclasspsy $0x7b,512(%rdx){1to8}, %k4
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to8}, %k4
+// CHECK: vfpclassps $123, -512(%rdx){1to8}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x62,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to8}, %k4
+          vfpclassps $0x7b,-512(%rdx){1to8}, %k4
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to8}, %k4
+// CHECK: vfpclassps $123, -512(%rdx){1to8}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x62,0x80,0x7b]
+          vfpclasspsy $0x7b,-512(%rdx){1to8}, %k4
+
+// CHECK: vfpclassps $123, -516(%rdx){1to8}, %k4
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclassps $0x7b,-516(%rdx){1to8}, %k4
+
+// CHECK: vfpclassps $123, -516(%rdx){1to8}, %k4
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to8}, %k4
+          vfpclasspsy $0x7b,-516(%rdx){1to8}, %k4
 
 // CHECK: vfpclasspd $171, %xmm26, %k3
 // CHECK:  encoding: [0x62,0x93,0xfd,0x08,0x66,0xda,0xab]
           vfpclasspd $0xab, %xmm26, %k3
 
+// CHECK: vfpclasspd $171, %xmm26, %k3
+// CHECK:  encoding: [0x62,0x93,0xfd,0x08,0x66,0xda,0xab]
+          vfpclasspdx $0xab, %xmm26, %k3
+
 // CHECK: vfpclasspd $171, %xmm26, %k3 {%k5}
 // CHECK:  encoding: [0x62,0x93,0xfd,0x0d,0x66,0xda,0xab]
           vfpclasspd $0xab, %xmm26, %k3 {%k5}
 
+// CHECK: vfpclasspd $171, %xmm26, %k3 {%k5}
+// CHECK:  encoding: [0x62,0x93,0xfd,0x0d,0x66,0xda,0xab]
+          vfpclasspdx $0xab, %xmm26, %k3 {%k5}
+
 // CHECK: vfpclasspd $123,  %xmm26, %k3
 // CHECK:  encoding: [0x62,0x93,0xfd,0x08,0x66,0xda,0x7b]
           vfpclasspd $0x7b, %xmm26, %k3
 
+// CHECK: vfpclasspd $123,  %xmm26, %k3
+// CHECK:  encoding: [0x62,0x93,0xfd,0x08,0x66,0xda,0x7b]
+          vfpclasspdx $0x7b, %xmm26, %k3
+
 // CHECK: vfpclasspdx $123, (%rcx), %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x19,0x7b]
           vfpclasspdx $0x7b,(%rcx), %k3
@@ -4404,9 +5816,13 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x08,0x66,0x9c,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspdx $0x7b,4660(%rax,%r14,8), %k3
 
-// CHECK: vfpclasspdq $123, (%rcx){1to2}, %k3
+// CHECK: vfpclasspd $123, (%rcx){1to2}, %k3
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x19,0x7b]
+          vfpclasspd $0x7b,(%rcx){1to2}, %k3
+
+// CHECK: vfpclasspd $123, (%rcx){1to2}, %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x19,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to2}, %k3
+          vfpclasspdx $0x7b,(%rcx){1to2}, %k3
 
 // CHECK: vfpclasspdx $123, 2032(%rdx), %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x5a,0x7f,0x7b]
@@ -4424,34 +5840,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x08,0x66,0x9a,0xf0,0xf7,0xff,0xff,0x7b]
           vfpclasspdx $0x7b,-2064(%rdx), %k3
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to2}, %k3
+// CHECK: vfpclasspd $123, 1016(%rdx){1to2}, %k3
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x5a,0x7f,0x7b]
+          vfpclasspd $0x7b,1016(%rdx){1to2}, %k3
+
+// CHECK: vfpclasspd $123, 1016(%rdx){1to2}, %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x5a,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to2}, %k3
+          vfpclasspdx $0x7b,1016(%rdx){1to2}, %k3
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to2}, %k3
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x9a,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspd $0x7b,1024(%rdx){1to2}, %k3
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to2}, %k3
+// CHECK: vfpclasspd $123, 1024(%rdx){1to2}, %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x9a,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to2}, %k3
+          vfpclasspdx $0x7b,1024(%rdx){1to2}, %k3
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to2}, %k3
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x5a,0x80,0x7b]
+          vfpclasspd $0x7b,-1024(%rdx){1to2}, %k3
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to2}, %k3
+// CHECK: vfpclasspd $123, -1024(%rdx){1to2}, %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x5a,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to2}, %k3
+          vfpclasspdx $0x7b,-1024(%rdx){1to2}, %k3
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to2}, %k3
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x9a,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspd $0x7b,-1032(%rdx){1to2}, %k3
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to2}, %k3
+// CHECK: vfpclasspd $123, -1032(%rdx){1to2}, %k3
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x18,0x66,0x9a,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to2}, %k3
+          vfpclasspdx $0x7b,-1032(%rdx){1to2}, %k3
 
 // CHECK: vfpclasspd $171, %ymm26, %k2
 // CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xd2,0xab]
           vfpclasspd $0xab, %ymm26, %k2
 
+// CHECK: vfpclasspd $171, %ymm26, %k2
+// CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xd2,0xab]
+          vfpclasspdy $0xab, %ymm26, %k2
+
 // CHECK: vfpclasspd $171, %ymm26, %k2 {%k6}
 // CHECK:  encoding: [0x62,0x93,0xfd,0x2e,0x66,0xd2,0xab]
           vfpclasspd $0xab, %ymm26, %k2 {%k6}
 
+// CHECK: vfpclasspd $171, %ymm26, %k2 {%k6}
+// CHECK:  encoding: [0x62,0x93,0xfd,0x2e,0x66,0xd2,0xab]
+          vfpclasspdy $0xab, %ymm26, %k2 {%k6}
+
 // CHECK: vfpclasspd $123,  %ymm26, %k2
 // CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xd2,0x7b]
           vfpclasspd $0x7b, %ymm26, %k2
 
+// CHECK: vfpclasspd $123,  %ymm26, %k2
+// CHECK:  encoding: [0x62,0x93,0xfd,0x28,0x66,0xd2,0x7b]
+          vfpclasspdy $0x7b, %ymm26, %k2
+
 // CHECK: vfpclasspdy $123, (%rcx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x11,0x7b]
           vfpclasspdy $0x7b,(%rcx), %k2
@@ -4460,9 +5904,13 @@
 // CHECK:  encoding: [0x62,0xb3,0xfd,0x28,0x66,0x94,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspdy $0x7b,4660(%rax,%r14,8), %k2
 
-// CHECK: vfpclasspdq $123, (%rcx){1to4}, %k2
+// CHECK: vfpclasspd $123, (%rcx){1to4}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x11,0x7b]
-          vfpclasspdq $0x7b,(%rcx){1to4}, %k2
+          vfpclasspd $0x7b,(%rcx){1to4}, %k2
+
+// CHECK: vfpclasspd $123, (%rcx){1to4}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x11,0x7b]
+          vfpclasspdy $0x7b,(%rcx){1to4}, %k2
 
 // CHECK: vfpclasspdy $123, 4064(%rdx), %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x52,0x7f,0x7b]
@@ -4480,34 +5928,62 @@
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x28,0x66,0x92,0xe0,0xef,0xff,0xff,0x7b]
           vfpclasspdy $0x7b,-4128(%rdx), %k2
 
-// CHECK: vfpclasspdq $123, 1016(%rdx){1to4}, %k2
+// CHECK: vfpclasspd $123, 1016(%rdx){1to4}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x52,0x7f,0x7b]
+          vfpclasspd $0x7b,1016(%rdx){1to4}, %k2
+
+// CHECK: vfpclasspd $123, 1016(%rdx){1to4}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x52,0x7f,0x7b]
-          vfpclasspdq $0x7b,1016(%rdx){1to4}, %k2
+          vfpclasspdy $0x7b,1016(%rdx){1to4}, %k2
 
-// CHECK: vfpclasspdq $123, 1024(%rdx){1to4}, %k2
+// CHECK: vfpclasspd $123, 1024(%rdx){1to4}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
-          vfpclasspdq $0x7b,1024(%rdx){1to4}, %k2
+          vfpclasspd $0x7b,1024(%rdx){1to4}, %k2
+
+// CHECK: vfpclasspd $123, 1024(%rdx){1to4}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x92,0x00,0x04,0x00,0x00,0x7b]
+          vfpclasspdy $0x7b,1024(%rdx){1to4}, %k2
+
+// CHECK: vfpclasspd $123, -1024(%rdx){1to4}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x52,0x80,0x7b]
+          vfpclasspd $0x7b,-1024(%rdx){1to4}, %k2
 
-// CHECK: vfpclasspdq $123, -1024(%rdx){1to4}, %k2
+// CHECK: vfpclasspd $123, -1024(%rdx){1to4}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x52,0x80,0x7b]
-          vfpclasspdq $0x7b,-1024(%rdx){1to4}, %k2
+          vfpclasspdy $0x7b,-1024(%rdx){1to4}, %k2
 
-// CHECK: vfpclasspdq $123, -1032(%rdx){1to4}, %k2
+// CHECK: vfpclasspd $123, -1032(%rdx){1to4}, %k2
 // CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
-          vfpclasspdq $0x7b,-1032(%rdx){1to4}, %k2
+          vfpclasspd $0x7b,-1032(%rdx){1to4}, %k2
+
+// CHECK: vfpclasspd $123, -1032(%rdx){1to4}, %k2
+// CHECK:  encoding: [0x62,0xf3,0xfd,0x38,0x66,0x92,0xf8,0xfb,0xff,0xff,0x7b]
+          vfpclasspdy $0x7b,-1032(%rdx){1to4}, %k2
 
 // CHECK: vfpclassps $171, %xmm29, %k3
 // CHECK:  encoding: [0x62,0x93,0x7d,0x08,0x66,0xdd,0xab]
           vfpclassps $0xab, %xmm29, %k3
 
-// CHECK: vfpclassps $171, %xmm29, %k3 {%k6}
-// CHECK:  encoding: [0x62,0x93,0x7d,0x0e,0x66,0xdd,0xab]
+// CHECK: vfpclassps $171, %xmm29, %k3
+// CHECK:  encoding: [0x62,0x93,0x7d,0x08,0x66,0xdd,0xab]
+          vfpclasspsx $0xab, %xmm29, %k3
+
+// check: vfpclassps $171, %xmm29, %k3 {%k6}
+// check:  encoding: [0x62,0x93,0x7d,0x0e,0x66,0xdd,0xab]
           vfpclassps $0xab, %xmm29, %k3 {%k6}
 
+// CHECK: vfpclassps $171, %xmm29, %k3
+// CHECK:  encoding: [0x62,0x93,0x7d,0x08,0x66,0xdd,0xab]
+          vfpclasspsx $0xab, %xmm29, %k3
+
 // CHECK: vfpclassps $123,  %xmm29, %k3
 // CHECK:  encoding: [0x62,0x93,0x7d,0x08,0x66,0xdd,0x7b]
           vfpclassps $0x7b, %xmm29, %k3
 
+// CHECK: vfpclassps $123,  %xmm29, %k3
+// CHECK:  encoding: [0x62,0x93,0x7d,0x08,0x66,0xdd,0x7b]
+          vfpclasspsx $0x7b, %xmm29, %k3
+
 // CHECK: vfpclasspsx $123, (%rcx), %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x19,0x7b]
           vfpclasspsx $0x7b,(%rcx), %k3
@@ -4516,9 +5992,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x08,0x66,0x9c,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspsx $0x7b,4660(%rax,%r14,8), %k3
 
-// CHECK: vfpclasspsl $123, (%rcx){1to4}, %k3
+// CHECK: vfpclassps $123, (%rcx){1to4}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x19,0x7b]
+          vfpclassps $0x7b,(%rcx){1to4}, %k3
+
+// CHECK: vfpclassps $123, (%rcx){1to4}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x19,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to4}, %k3
+          vfpclasspsx $0x7b,(%rcx){1to4}, %k3
 
 // CHECK: vfpclasspsx $123, 2032(%rdx), %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x5a,0x7f,0x7b]
@@ -4536,34 +6016,62 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x08,0x66,0x9a,0xf0,0xf7,0xff,0xff,0x7b]
           vfpclasspsx $0x7b,-2064(%rdx), %k3
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to4}, %k3
+// CHECK: vfpclassps $123, 508(%rdx){1to4}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x5a,0x7f,0x7b]
+          vfpclassps $0x7b,508(%rdx){1to4}, %k3
+
+// CHECK: vfpclassps $123, 508(%rdx){1to4}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x5a,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to4}, %k3
+          vfpclasspsx $0x7b,508(%rdx){1to4}, %k3
+
+// CHECK: vfpclassps $123, 512(%rdx){1to4}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x9a,0x00,0x02,0x00,0x00,0x7b]
+          vfpclassps $0x7b,512(%rdx){1to4}, %k3
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to4}, %k3
+// CHECK: vfpclassps $123, 512(%rdx){1to4}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x9a,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to4}, %k3
+          vfpclasspsx $0x7b,512(%rdx){1to4}, %k3
+
+// CHECK: vfpclassps $123, -512(%rdx){1to4}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x5a,0x80,0x7b]
+          vfpclassps $0x7b,-512(%rdx){1to4}, %k3
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to4}, %k3
+// CHECK: vfpclassps $123, -512(%rdx){1to4}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x5a,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to4}, %k3
+          vfpclasspsx $0x7b,-512(%rdx){1to4}, %k3
+
+// CHECK: vfpclassps $123, -516(%rdx){1to4}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x9a,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclassps $0x7b,-516(%rdx){1to4}, %k3
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to4}, %k3
+// CHECK: vfpclassps $123, -516(%rdx){1to4}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x18,0x66,0x9a,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to4}, %k3
+          vfpclasspsx $0x7b,-516(%rdx){1to4}, %k3
 
 // CHECK: vfpclassps $171, %ymm19, %k3
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xdb,0xab]
           vfpclassps $0xab, %ymm19, %k3
 
+// CHECK: vfpclassps $171, %ymm19, %k3
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xdb,0xab]
+          vfpclasspsy $0xab, %ymm19, %k3
+
 // CHECK: vfpclassps $171, %ymm19, %k3 {%k3}
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x2b,0x66,0xdb,0xab]
           vfpclassps $0xab, %ymm19, %k3 {%k3}
 
+// CHECK: vfpclassps $171, %ymm19, %k3 {%k3}
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x2b,0x66,0xdb,0xab]
+          vfpclasspsy $0xab, %ymm19, %k3 {%k3}
+
 // CHECK: vfpclassps $123,  %ymm19, %k3
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xdb,0x7b]
           vfpclassps $0x7b, %ymm19, %k3
 
+// CHECK: vfpclassps $123,  %ymm19, %k3
+// CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0xdb,0x7b]
+          vfpclasspsy $0x7b, %ymm19, %k3
+
 // CHECK: vfpclasspsy $123, (%rcx), %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x19,0x7b]
           vfpclasspsy $0x7b,(%rcx), %k3
@@ -4572,9 +6080,13 @@
 // CHECK:  encoding: [0x62,0xb3,0x7d,0x28,0x66,0x9c,0xf0,0x34,0x12,0x00,0x00,0x7b]
           vfpclasspsy $0x7b,4660(%rax,%r14,8), %k3
 
-// CHECK: vfpclasspsl $123, (%rcx){1to8}, %k3
+// CHECK: vfpclassps $123, (%rcx){1to8}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x19,0x7b]
+          vfpclassps $0x7b,(%rcx){1to8}, %k3
+
+// CHECK: vfpclassps $123, (%rcx){1to8}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x19,0x7b]
-          vfpclasspsl $0x7b,(%rcx){1to8}, %k3
+          vfpclasspsy $0x7b,(%rcx){1to8}, %k3
 
 // CHECK: vfpclasspsy $123, 4064(%rdx), %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x5a,0x7f,0x7b]
@@ -4592,21 +6104,37 @@
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x28,0x66,0x9a,0xe0,0xef,0xff,0xff,0x7b]
           vfpclasspsy $0x7b,-4128(%rdx), %k3
 
-// CHECK: vfpclasspsl $123, 508(%rdx){1to8}, %k3
+// CHECK: vfpclassps $123, 508(%rdx){1to8}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x5a,0x7f,0x7b]
-          vfpclasspsl $0x7b,508(%rdx){1to8}, %k3
+          vfpclassps $0x7b,508(%rdx){1to8}, %k3
 
-// CHECK: vfpclasspsl $123, 512(%rdx){1to8}, %k3
+// CHECK: vfpclassps $123, 508(%rdx){1to8}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x5a,0x7f,0x7b]
+          vfpclasspsy $0x7b,508(%rdx){1to8}, %k3
+
+// CHECK: vfpclassps $123, 512(%rdx){1to8}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x9a,0x00,0x02,0x00,0x00,0x7b]
+          vfpclassps $0x7b,512(%rdx){1to8}, %k3
+
+// CHECK: vfpclassps $123, 512(%rdx){1to8}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x9a,0x00,0x02,0x00,0x00,0x7b]
-          vfpclasspsl $0x7b,512(%rdx){1to8}, %k3
+          vfpclasspsy $0x7b,512(%rdx){1to8}, %k3
 
-// CHECK: vfpclasspsl $123, -512(%rdx){1to8}, %k3
+// CHECK: vfpclassps $123, -512(%rdx){1to8}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x5a,0x80,0x7b]
-          vfpclasspsl $0x7b,-512(%rdx){1to8}, %k3
+          vfpclassps $0x7b,-512(%rdx){1to8}, %k3
+
+// CHECK: vfpclassps $123, -512(%rdx){1to8}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x5a,0x80,0x7b]
+          vfpclasspsy $0x7b,-512(%rdx){1to8}, %k3
+
+// CHECK: vfpclassps $123, -516(%rdx){1to8}, %k3
+// CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x9a,0xfc,0xfd,0xff,0xff,0x7b]
+          vfpclassps $0x7b,-516(%rdx){1to8}, %k3
 
-// CHECK: vfpclasspsl $123, -516(%rdx){1to8}, %k3
+// CHECK: vfpclassps $123, -516(%rdx){1to8}, %k3
 // CHECK:  encoding: [0x62,0xf3,0x7d,0x38,0x66,0x9a,0xfc,0xfd,0xff,0xff,0x7b]
-          vfpclasspsl $0x7b,-516(%rdx){1to8}, %k3
+          vfpclasspsy $0x7b,-516(%rdx){1to8}, %k3
 
 // CHECK: vbroadcasti32x2 %xmm30, %xmm30
 // CHECK:  encoding: [0x62,0x02,0x7d,0x08,0x59,0xf6]
diff --git a/llvm/test/MC/X86/x86-64-avx512f_vl.s b/llvm/test/MC/X86/x86-64-avx512f_vl.s
index 4899086cd41..d41f15ad83d 100644
--- a/llvm/test/MC/X86/x86-64-avx512f_vl.s
+++ b/llvm/test/MC/X86/x86-64-avx512f_vl.s
@@ -17841,225 +17841,866 @@ vaddpd  {rz-sae}, %zmm2, %zmm1, %zmm1
 // CHECK:  encoding: [0x62,0x01,0xfd,0x08,0x5a,0xdb]
           vcvtpd2ps %xmm27, %xmm27
 
+// CHECK: vcvtpd2ps %xmm27, %xmm27
+// CHECK:  encoding: [0x62,0x01,0xfd,0x08,0x5a,0xdb]
+          vcvtpd2psx %xmm27, %xmm27
+
 // CHECK: vcvtpd2ps %xmm27, %xmm27 {%k7}
 // CHECK:  encoding: [0x62,0x01,0xfd,0x0f,0x5a,0xdb]
           vcvtpd2ps %xmm27, %xmm27 {%k7}
 
+// CHECK: vcvtpd2ps %xmm27, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x01,0xfd,0x0f,0x5a,0xdb]
+          vcvtpd2psx %xmm27, %xmm27 {%k7}
+
 // CHECK: vcvtpd2ps %xmm27, %xmm27 {%k7} {z}
 // CHECK:  encoding: [0x62,0x01,0xfd,0x8f,0x5a,0xdb]
           vcvtpd2ps %xmm27, %xmm27 {%k7} {z}
 
+// CHECK: vcvtpd2ps %xmm27, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x01,0xfd,0x8f,0x5a,0xdb]
+          vcvtpd2psx %xmm27, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx (%rcx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0x5a,0x19]
           vcvtpd2psx (%rcx), %xmm27
 
+// CHECK: vcvtpd2psx (%rcx), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0f,0x5a,0x19]
+          vcvtpd2psx (%rcx), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx (%rcx), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8f,0x5a,0x19]
+          vcvtpd2psx (%rcx), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx 291(%rax,%r14,8), %xmm27
 // CHECK:  encoding: [0x62,0x21,0xfd,0x08,0x5a,0x9c,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2psx 291(%rax,%r14,8), %xmm27
 
+// CHECK: vcvtpd2psx 291(%rax,%r14,8), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x0f,0x5a,0x9c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2psx 291(%rax,%r14,8), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx 291(%rax,%r14,8), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x8f,0x5a,0x9c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2psx 291(%rax,%r14,8), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x19]
           vcvtpd2ps (%rcx){1to2}, %xmm27
 
+// CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x19]
+          vcvtpd2psx (%rcx){1to2}, %xmm27
+
+// CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x19]
+          vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x19]
+          vcvtpd2psx (%rcx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x19]
+          vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7} {z}
+
+// CHECK: vcvtpd2ps (%rcx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x19]
+          vcvtpd2psx (%rcx){1to2}, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx 2032(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0x5a,0x5a,0x7f]
           vcvtpd2psx 2032(%rdx), %xmm27
 
+// CHECK: vcvtpd2psx 2032(%rdx), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0f,0x5a,0x5a,0x7f]
+          vcvtpd2psx 2032(%rdx), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx 2032(%rdx), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8f,0x5a,0x5a,0x7f]
+          vcvtpd2psx 2032(%rdx), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx 2048(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0x5a,0x9a,0x00,0x08,0x00,0x00]
           vcvtpd2psx 2048(%rdx), %xmm27
 
+// CHECK: vcvtpd2psx 2048(%rdx), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0f,0x5a,0x9a,0x00,0x08,0x00,0x00]
+          vcvtpd2psx 2048(%rdx), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx 2048(%rdx), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8f,0x5a,0x9a,0x00,0x08,0x00,0x00]
+          vcvtpd2psx 2048(%rdx), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx -2048(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0x5a,0x5a,0x80]
           vcvtpd2psx -2048(%rdx), %xmm27
 
+// CHECK: vcvtpd2psx -2048(%rdx), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0f,0x5a,0x5a,0x80]
+          vcvtpd2psx -2048(%rdx), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx -2048(%rdx), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8f,0x5a,0x5a,0x80]
+          vcvtpd2psx -2048(%rdx), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2psx -2064(%rdx), %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0x5a,0x9a,0xf0,0xf7,0xff,0xff]
           vcvtpd2psx -2064(%rdx), %xmm27
 
+// CHECK: vcvtpd2psx -2064(%rdx), %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0f,0x5a,0x9a,0xf0,0xf7,0xff,0xff]
+          vcvtpd2psx -2064(%rdx), %xmm27 {%k7}
+
+// CHECK: vcvtpd2psx -2064(%rdx), %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8f,0x5a,0x9a,0xf0,0xf7,0xff,0xff]
+          vcvtpd2psx -2064(%rdx), %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x5a,0x7f]
           vcvtpd2ps 1016(%rdx){1to2}, %xmm27
 
+// CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x5a,0x7f]
+          vcvtpd2psx 1016(%rdx){1to2}, %xmm27
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x5a,0x7f]
+          vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x5a,0x7f]
+          vcvtpd2psx 1016(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x5a,0x7f]
+          vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7} {z}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x5a,0x7f]
+          vcvtpd2psx 1016(%rdx){1to2}, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x9a,0x00,0x04,0x00,0x00]
           vcvtpd2ps 1024(%rdx){1to2}, %xmm27
 
+// CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x9a,0x00,0x04,0x00,0x00]
+          vcvtpd2psx 1024(%rdx){1to2}, %xmm27
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x9a,0x00,0x04,0x00,0x00]
+          vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x9a,0x00,0x04,0x00,0x00]
+          vcvtpd2psx 1024(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x9a,0x00,0x04,0x00,0x00]
+          vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7} {z}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x9a,0x00,0x04,0x00,0x00]
+          vcvtpd2psx 1024(%rdx){1to2}, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x5a,0x80]
           vcvtpd2ps -1024(%rdx){1to2}, %xmm27
 
+// CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x5a,0x80]
+          vcvtpd2psx -1024(%rdx){1to2}, %xmm27
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x5a,0x80]
+          vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x5a,0x80]
+          vcvtpd2psx -1024(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x5a,0x80]
+          vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7} {z}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x5a,0x80]
+          vcvtpd2psx -1024(%rdx){1to2}, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
           vcvtpd2ps -1032(%rdx){1to2}, %xmm27
 
+// CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psx -1032(%rdx){1to2}, %xmm27
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1f,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psx -1032(%rdx){1to2}, %xmm27 {%k7}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7} {z}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to2}, %xmm27 {%k7} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9f,0x5a,0x9a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psx -1032(%rdx){1to2}, %xmm27 {%k7} {z}
+
 // CHECK: vcvtpd2ps %ymm20, %xmm20
 // CHECK:  encoding: [0x62,0xa1,0xfd,0x28,0x5a,0xe4]
           vcvtpd2ps %ymm20, %xmm20
 
+// CHECK: vcvtpd2ps %ymm20, %xmm20
+// CHECK:  encoding: [0x62,0xa1,0xfd,0x28,0x5a,0xe4]
+          vcvtpd2psy %ymm20, %xmm20
+
 // CHECK: vcvtpd2ps %ymm20, %xmm20 {%k6}
 // CHECK:  encoding: [0x62,0xa1,0xfd,0x2e,0x5a,0xe4]
           vcvtpd2ps %ymm20, %xmm20 {%k6}
 
+// CHECK: vcvtpd2ps %ymm20, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xa1,0xfd,0x2e,0x5a,0xe4]
+          vcvtpd2psy %ymm20, %xmm20 {%k6}
+
 // CHECK: vcvtpd2ps %ymm20, %xmm20 {%k6} {z}
 // CHECK:  encoding: [0x62,0xa1,0xfd,0xae,0x5a,0xe4]
           vcvtpd2ps %ymm20, %xmm20 {%k6} {z}
 
+// CHECK: vcvtpd2ps %ymm20, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfd,0xae,0x5a,0xe4]
+          vcvtpd2psy %ymm20, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy (%rcx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x28,0x5a,0x21]
           vcvtpd2psy (%rcx), %xmm20
 
+// CHECK: vcvtpd2psy (%rcx), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x2e,0x5a,0x21]
+          vcvtpd2psy (%rcx), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy (%rcx), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xae,0x5a,0x21]
+          vcvtpd2psy (%rcx), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy 291(%rax,%r14,8), %xmm20
 // CHECK:  encoding: [0x62,0xa1,0xfd,0x28,0x5a,0xa4,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2psy 291(%rax,%r14,8), %xmm20
 
+// CHECK: vcvtpd2psy 291(%rax,%r14,8), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xa1,0xfd,0x2e,0x5a,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2psy 291(%rax,%r14,8), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy 291(%rax,%r14,8), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfd,0xae,0x5a,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2psy 291(%rax,%r14,8), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x21]
           vcvtpd2ps (%rcx){1to4}, %xmm20
 
+// CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x21]
+          vcvtpd2psy (%rcx){1to4}, %xmm20
+
+// CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x21]
+          vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x21]
+          vcvtpd2psy (%rcx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x21]
+          vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6} {z}
+
+// CHECK: vcvtpd2ps (%rcx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x21]
+          vcvtpd2psy (%rcx){1to4}, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy 4064(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x28,0x5a,0x62,0x7f]
           vcvtpd2psy 4064(%rdx), %xmm20
 
+// CHECK: vcvtpd2psy 4064(%rdx), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x2e,0x5a,0x62,0x7f]
+          vcvtpd2psy 4064(%rdx), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy 4064(%rdx), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xae,0x5a,0x62,0x7f]
+          vcvtpd2psy 4064(%rdx), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy 4096(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x28,0x5a,0xa2,0x00,0x10,0x00,0x00]
           vcvtpd2psy 4096(%rdx), %xmm20
 
+// CHECK: vcvtpd2psy 4096(%rdx), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x2e,0x5a,0xa2,0x00,0x10,0x00,0x00]
+          vcvtpd2psy 4096(%rdx), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy 4096(%rdx), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xae,0x5a,0xa2,0x00,0x10,0x00,0x00]
+          vcvtpd2psy 4096(%rdx), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy -4096(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x28,0x5a,0x62,0x80]
           vcvtpd2psy -4096(%rdx), %xmm20
 
+// CHECK: vcvtpd2psy -4096(%rdx), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x2e,0x5a,0x62,0x80]
+          vcvtpd2psy -4096(%rdx), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy -4096(%rdx), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xae,0x5a,0x62,0x80]
+          vcvtpd2psy -4096(%rdx), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2psy -4128(%rdx), %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x28,0x5a,0xa2,0xe0,0xef,0xff,0xff]
           vcvtpd2psy -4128(%rdx), %xmm20
 
+// CHECK: vcvtpd2psy -4128(%rdx), %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x2e,0x5a,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtpd2psy -4128(%rdx), %xmm20 {%k6}
+
+// CHECK: vcvtpd2psy -4128(%rdx), %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xae,0x5a,0xa2,0xe0,0xef,0xff,0xff]
+          vcvtpd2psy -4128(%rdx), %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x62,0x7f]
           vcvtpd2ps 1016(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x62,0x7f]
+          vcvtpd2psy 1016(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x62,0x7f]
+          vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x62,0x7f]
+          vcvtpd2psy 1016(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x62,0x7f]
+          vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6} {z}
+
+// CHECK: vcvtpd2ps 1016(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x62,0x7f]
+          vcvtpd2psy 1016(%rdx){1to4}, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0xa2,0x00,0x04,0x00,0x00]
           vcvtpd2ps 1024(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2psy 1024(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2psy 1024(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6} {z}
+
+// CHECK: vcvtpd2ps 1024(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2psy 1024(%rdx){1to4}, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x62,0x80]
           vcvtpd2ps -1024(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0x62,0x80]
+          vcvtpd2psy -1024(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x62,0x80]
+          vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0x62,0x80]
+          vcvtpd2psy -1024(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x62,0x80]
+          vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6} {z}
+
+// CHECK: vcvtpd2ps -1024(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0x62,0x80]
+          vcvtpd2psy -1024(%rdx){1to4}, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20
 // CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
           vcvtpd2ps -1032(%rdx){1to4}, %xmm20
 
+// CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x38,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psy -1032(%rdx){1to4}, %xmm20
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0x3e,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psy -1032(%rdx){1to4}, %xmm20 {%k6}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6} {z}
+
+// CHECK: vcvtpd2ps -1032(%rdx){1to4}, %xmm20 {%k6} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfd,0xbe,0x5a,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2psy -1032(%rdx){1to4}, %xmm20 {%k6} {z}
+
 // CHECK: vcvtpd2udq %xmm22, %xmm28
 // CHECK:  encoding: [0x62,0x21,0xfc,0x08,0x79,0xe6]
           vcvtpd2udq %xmm22, %xmm28
 
+// CHECK: vcvtpd2udq %xmm22, %xmm28
+// CHECK:  encoding: [0x62,0x21,0xfc,0x08,0x79,0xe6]
+          vcvtpd2udqx %xmm22, %xmm28
+
 // CHECK: vcvtpd2udq %xmm22, %xmm28 {%k3}
 // CHECK:  encoding: [0x62,0x21,0xfc,0x0b,0x79,0xe6]
           vcvtpd2udq %xmm22, %xmm28 {%k3}
 
+// CHECK: vcvtpd2udq %xmm22, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x0b,0x79,0xe6]
+          vcvtpd2udqx %xmm22, %xmm28 {%k3}
+
 // CHECK: vcvtpd2udq %xmm22, %xmm28 {%k3} {z}
 // CHECK:  encoding: [0x62,0x21,0xfc,0x8b,0x79,0xe6]
           vcvtpd2udq %xmm22, %xmm28 {%k3} {z}
 
+// CHECK: vcvtpd2udq %xmm22, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x8b,0x79,0xe6]
+          vcvtpd2udqx %xmm22, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx (%rcx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x79,0x21]
           vcvtpd2udqx (%rcx), %xmm28
 
+// CHECK: vcvtpd2udqx (%rcx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0b,0x79,0x21]
+          vcvtpd2udqx (%rcx), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx (%rcx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8b,0x79,0x21]
+          vcvtpd2udqx (%rcx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx 291(%rax,%r14,8), %xmm28
 // CHECK:  encoding: [0x62,0x21,0xfc,0x08,0x79,0xa4,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2udqx 291(%rax,%r14,8), %xmm28
 
+// CHECK: vcvtpd2udqx 291(%rax,%r14,8), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x0b,0x79,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2udqx 291(%rax,%r14,8), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx 291(%rax,%r14,8), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x8b,0x79,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2udqx 291(%rax,%r14,8), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x21]
           vcvtpd2udq (%rcx){1to2}, %xmm28
 
+// CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x21]
+          vcvtpd2udqx (%rcx){1to2}, %xmm28
+
+// CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x21]
+          vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x21]
+          vcvtpd2udqx (%rcx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x21]
+          vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtpd2udq (%rcx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x21]
+          vcvtpd2udqx (%rcx){1to2}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx 2032(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x79,0x62,0x7f]
           vcvtpd2udqx 2032(%rdx), %xmm28
 
+// CHECK: vcvtpd2udqx 2032(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0b,0x79,0x62,0x7f]
+          vcvtpd2udqx 2032(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx 2032(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8b,0x79,0x62,0x7f]
+          vcvtpd2udqx 2032(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx 2048(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x79,0xa2,0x00,0x08,0x00,0x00]
           vcvtpd2udqx 2048(%rdx), %xmm28
 
+// CHECK: vcvtpd2udqx 2048(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0b,0x79,0xa2,0x00,0x08,0x00,0x00]
+          vcvtpd2udqx 2048(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx 2048(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8b,0x79,0xa2,0x00,0x08,0x00,0x00]
+          vcvtpd2udqx 2048(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx -2048(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x79,0x62,0x80]
           vcvtpd2udqx -2048(%rdx), %xmm28
 
+// CHECK: vcvtpd2udqx -2048(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0b,0x79,0x62,0x80]
+          vcvtpd2udqx -2048(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx -2048(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8b,0x79,0x62,0x80]
+          vcvtpd2udqx -2048(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udqx -2064(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x08,0x79,0xa2,0xf0,0xf7,0xff,0xff]
           vcvtpd2udqx -2064(%rdx), %xmm28
 
+// CHECK: vcvtpd2udqx -2064(%rdx), %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x0b,0x79,0xa2,0xf0,0xf7,0xff,0xff]
+          vcvtpd2udqx -2064(%rdx), %xmm28 {%k3}
+
+// CHECK: vcvtpd2udqx -2064(%rdx), %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x8b,0x79,0xa2,0xf0,0xf7,0xff,0xff]
+          vcvtpd2udqx -2064(%rdx), %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x62,0x7f]
           vcvtpd2udq 1016(%rdx){1to2}, %xmm28
 
+// CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x62,0x7f]
+          vcvtpd2udqx 1016(%rdx){1to2}, %xmm28
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x62,0x7f]
+          vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x62,0x7f]
+          vcvtpd2udqx 1016(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x62,0x7f]
+          vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x62,0x7f]
+          vcvtpd2udqx 1016(%rdx){1to2}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0xa2,0x00,0x04,0x00,0x00]
           vcvtpd2udq 1024(%rdx){1to2}, %xmm28
 
+// CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2udqx 1024(%rdx){1to2}, %xmm28
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2udqx 1024(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0xa2,0x00,0x04,0x00,0x00]
+          vcvtpd2udqx 1024(%rdx){1to2}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x62,0x80]
           vcvtpd2udq -1024(%rdx){1to2}, %xmm28
 
+// CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0x62,0x80]
+          vcvtpd2udqx -1024(%rdx){1to2}, %xmm28
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x62,0x80]
+          vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0x62,0x80]
+          vcvtpd2udqx -1024(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x62,0x80]
+          vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0x62,0x80]
+          vcvtpd2udqx -1024(%rdx){1to2}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0xa2,0xf8,0xfb,0xff,0xff]
           vcvtpd2udq -1032(%rdx){1to2}, %xmm28
 
+// CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x18,0x79,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqx -1032(%rdx){1to2}, %xmm28
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x1b,0x79,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqx -1032(%rdx){1to2}, %xmm28 {%k3}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3} {z}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to2}, %xmm28 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x9b,0x79,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqx -1032(%rdx){1to2}, %xmm28 {%k3} {z}
+
 // CHECK: vcvtpd2udq %ymm20, %xmm21
 // CHECK:  encoding: [0x62,0xa1,0xfc,0x28,0x79,0xec]
           vcvtpd2udq %ymm20, %xmm21
 
+// CHECK: vcvtpd2udq %ymm20, %xmm21
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x28,0x79,0xec]
+          vcvtpd2udqy %ymm20, %xmm21
+
 // CHECK: vcvtpd2udq %ymm20, %xmm21 {%k2}
 // CHECK:  encoding: [0x62,0xa1,0xfc,0x2a,0x79,0xec]
           vcvtpd2udq %ymm20, %xmm21 {%k2}
 
+// CHECK: vcvtpd2udq %ymm20, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x2a,0x79,0xec]
+          vcvtpd2udqy %ymm20, %xmm21 {%k2}
+
 // CHECK: vcvtpd2udq %ymm20, %xmm21 {%k2} {z}
 // CHECK:  encoding: [0x62,0xa1,0xfc,0xaa,0x79,0xec]
           vcvtpd2udq %ymm20, %xmm21 {%k2} {z}
 
+// CHECK: vcvtpd2udq %ymm20, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0xaa,0x79,0xec]
+          vcvtpd2udqy %ymm20, %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy (%rcx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x79,0x29]
           vcvtpd2udqy (%rcx), %xmm21
 
+// CHECK: vcvtpd2udqy (%rcx), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2a,0x79,0x29]
+          vcvtpd2udqy (%rcx), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy (%rcx), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xaa,0x79,0x29]
+          vcvtpd2udqy (%rcx), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy 291(%rax,%r14,8), %xmm21
 // CHECK:  encoding: [0x62,0xa1,0xfc,0x28,0x79,0xac,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2udqy 291(%rax,%r14,8), %xmm21
 
+// CHECK: vcvtpd2udqy 291(%rax,%r14,8), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x2a,0x79,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2udqy 291(%rax,%r14,8), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy 291(%rax,%r14,8), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0xaa,0x79,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2udqy 291(%rax,%r14,8), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x29]
           vcvtpd2udq (%rcx){1to4}, %xmm21
 
+// CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x29]
+          vcvtpd2udqy (%rcx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x29]
+          vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x29]
+          vcvtpd2udqy (%rcx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x29]
+          vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2} {z}
+
+// CHECK: vcvtpd2udq (%rcx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x29]
+          vcvtpd2udqy (%rcx){1to4}, %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy 4064(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x79,0x6a,0x7f]
           vcvtpd2udqy 4064(%rdx), %xmm21
 
+// CHECK: vcvtpd2udqy 4064(%rdx), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2a,0x79,0x6a,0x7f]
+          vcvtpd2udqy 4064(%rdx), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy 4064(%rdx), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xaa,0x79,0x6a,0x7f]
+          vcvtpd2udqy 4064(%rdx), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy 4096(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x79,0xaa,0x00,0x10,0x00,0x00]
           vcvtpd2udqy 4096(%rdx), %xmm21
 
+// CHECK: vcvtpd2udqy 4096(%rdx), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2a,0x79,0xaa,0x00,0x10,0x00,0x00]
+          vcvtpd2udqy 4096(%rdx), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy 4096(%rdx), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xaa,0x79,0xaa,0x00,0x10,0x00,0x00]
+          vcvtpd2udqy 4096(%rdx), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy -4096(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x79,0x6a,0x80]
           vcvtpd2udqy -4096(%rdx), %xmm21
 
+// CHECK: vcvtpd2udqy -4096(%rdx), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2a,0x79,0x6a,0x80]
+          vcvtpd2udqy -4096(%rdx), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy -4096(%rdx), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xaa,0x79,0x6a,0x80]
+          vcvtpd2udqy -4096(%rdx), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udqy -4128(%rdx), %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x28,0x79,0xaa,0xe0,0xef,0xff,0xff]
           vcvtpd2udqy -4128(%rdx), %xmm21
 
+// CHECK: vcvtpd2udqy -4128(%rdx), %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x2a,0x79,0xaa,0xe0,0xef,0xff,0xff]
+          vcvtpd2udqy -4128(%rdx), %xmm21 {%k2}
+
+// CHECK: vcvtpd2udqy -4128(%rdx), %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xaa,0x79,0xaa,0xe0,0xef,0xff,0xff]
+          vcvtpd2udqy -4128(%rdx), %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x6a,0x7f]
           vcvtpd2udq 1016(%rdx){1to4}, %xmm21
 
+// CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x6a,0x7f]
+          vcvtpd2udqy 1016(%rdx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x6a,0x7f]
+          vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x6a,0x7f]
+          vcvtpd2udqy 1016(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x6a,0x7f]
+          vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2} {z}
+
+// CHECK: vcvtpd2udq 1016(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x6a,0x7f]
+          vcvtpd2udqy 1016(%rdx){1to4}, %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0xaa,0x00,0x04,0x00,0x00]
           vcvtpd2udq 1024(%rdx){1to4}, %xmm21
 
+// CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0xaa,0x00,0x04,0x00,0x00]
+          vcvtpd2udqy 1024(%rdx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0xaa,0x00,0x04,0x00,0x00]
+          vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0xaa,0x00,0x04,0x00,0x00]
+          vcvtpd2udqy 1024(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0xaa,0x00,0x04,0x00,0x00]
+          vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2} {z}
+
+// CHECK: vcvtpd2udq 1024(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0xaa,0x00,0x04,0x00,0x00]
+          vcvtpd2udqy 1024(%rdx){1to4}, %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x6a,0x80]
           vcvtpd2udq -1024(%rdx){1to4}, %xmm21
 
+// CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0x6a,0x80]
+          vcvtpd2udqy -1024(%rdx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x6a,0x80]
+          vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0x6a,0x80]
+          vcvtpd2udqy -1024(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x6a,0x80]
+          vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2} {z}
+
+// CHECK: vcvtpd2udq -1024(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0x6a,0x80]
+          vcvtpd2udqy -1024(%rdx){1to4}, %xmm21 {%k2} {z}
+
 // CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0xaa,0xf8,0xfb,0xff,0xff]
           vcvtpd2udq -1032(%rdx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x38,0x79,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqy -1032(%rdx){1to4}, %xmm21
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x3a,0x79,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqy -1032(%rdx){1to4}, %xmm21 {%k2}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2} {z}
+
+// CHECK: vcvtpd2udq -1032(%rdx){1to4}, %xmm21 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0xba,0x79,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvtpd2udqy -1032(%rdx){1to4}, %xmm21 {%k2} {z}
+
 // CHECK: vcvtps2udq %xmm19, %xmm30
 // CHECK:  encoding: [0x62,0x21,0x7c,0x08,0x79,0xf3]
           vcvtps2udq %xmm19, %xmm30
@@ -18176,114 +18817,434 @@ vaddpd  {rz-sae}, %zmm2, %zmm1, %zmm1
 // CHECK:  encoding: [0x62,0x21,0xfd,0x08,0xe6,0xef]
           vcvttpd2dq %xmm23, %xmm29
 
+// CHECK: vcvttpd2dq %xmm23, %xmm29
+// CHECK:  encoding: [0x62,0x21,0xfd,0x08,0xe6,0xef]
+          vcvttpd2dqx %xmm23, %xmm29
+
 // CHECK: vcvttpd2dq %xmm23, %xmm29 {%k6}
 // CHECK:  encoding: [0x62,0x21,0xfd,0x0e,0xe6,0xef]
           vcvttpd2dq %xmm23, %xmm29 {%k6}
 
+// CHECK: vcvttpd2dq %xmm23, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x0e,0xe6,0xef]
+          vcvttpd2dqx %xmm23, %xmm29 {%k6}
+
 // CHECK: vcvttpd2dq %xmm23, %xmm29 {%k6} {z}
 // CHECK:  encoding: [0x62,0x21,0xfd,0x8e,0xe6,0xef]
           vcvttpd2dq %xmm23, %xmm29 {%k6} {z}
 
+// CHECK: vcvttpd2dq %xmm23, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x8e,0xe6,0xef]
+          vcvttpd2dqx %xmm23, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx (%rcx), %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0xe6,0x29]
           vcvttpd2dqx (%rcx), %xmm29
 
+// CHECK: vcvttpd2dqx (%rcx), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0e,0xe6,0x29]
+          vcvttpd2dqx (%rcx), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx (%rcx), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8e,0xe6,0x29]
+          vcvttpd2dqx (%rcx), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx 291(%rax,%r14,8), %xmm29
 // CHECK:  encoding: [0x62,0x21,0xfd,0x08,0xe6,0xac,0xf0,0x23,0x01,0x00,0x00]
           vcvttpd2dqx 291(%rax,%r14,8), %xmm29
 
+// CHECK: vcvttpd2dqx 291(%rax,%r14,8), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x0e,0xe6,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2dqx 291(%rax,%r14,8), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx 291(%rax,%r14,8), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x8e,0xe6,0xac,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2dqx 291(%rax,%r14,8), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x29]
           vcvttpd2dq (%rcx){1to2}, %xmm29
 
+// CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x29]
+          vcvttpd2dqx (%rcx){1to2}, %xmm29
+
+// CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x29]
+          vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x29]
+          vcvttpd2dqx (%rcx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x29]
+          vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6} {z}
+
+// CHECK: vcvttpd2dq (%rcx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x29]
+          vcvttpd2dqx (%rcx){1to2}, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx 2032(%rdx), %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0xe6,0x6a,0x7f]
           vcvttpd2dqx 2032(%rdx), %xmm29
 
+// CHECK: vcvttpd2dqx 2032(%rdx), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0e,0xe6,0x6a,0x7f]
+          vcvttpd2dqx 2032(%rdx), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx 2032(%rdx), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8e,0xe6,0x6a,0x7f]
+          vcvttpd2dqx 2032(%rdx), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx 2048(%rdx), %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0xe6,0xaa,0x00,0x08,0x00,0x00]
           vcvttpd2dqx 2048(%rdx), %xmm29
 
+// CHECK: vcvttpd2dqx 2048(%rdx), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0e,0xe6,0xaa,0x00,0x08,0x00,0x00]
+          vcvttpd2dqx 2048(%rdx), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx 2048(%rdx), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8e,0xe6,0xaa,0x00,0x08,0x00,0x00]
+          vcvttpd2dqx 2048(%rdx), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx -2048(%rdx), %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0xe6,0x6a,0x80]
           vcvttpd2dqx -2048(%rdx), %xmm29
 
+// CHECK: vcvttpd2dqx -2048(%rdx), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0e,0xe6,0x6a,0x80]
+          vcvttpd2dqx -2048(%rdx), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx -2048(%rdx), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8e,0xe6,0x6a,0x80]
+          vcvttpd2dqx -2048(%rdx), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dqx -2064(%rdx), %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x08,0xe6,0xaa,0xf0,0xf7,0xff,0xff]
           vcvttpd2dqx -2064(%rdx), %xmm29
 
+// CHECK: vcvttpd2dqx -2064(%rdx), %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x0e,0xe6,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvttpd2dqx -2064(%rdx), %xmm29 {%k6}
+
+// CHECK: vcvttpd2dqx -2064(%rdx), %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x8e,0xe6,0xaa,0xf0,0xf7,0xff,0xff]
+          vcvttpd2dqx -2064(%rdx), %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x6a,0x7f]
           vcvttpd2dq 1016(%rdx){1to2}, %xmm29
 
+// CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x6a,0x7f]
+          vcvttpd2dqx 1016(%rdx){1to2}, %xmm29
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x6a,0x7f]
+          vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x6a,0x7f]
+          vcvttpd2dqx 1016(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x6a,0x7f]
+          vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6} {z}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x6a,0x7f]
+          vcvttpd2dqx 1016(%rdx){1to2}, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0xaa,0x00,0x04,0x00,0x00]
           vcvttpd2dq 1024(%rdx){1to2}, %xmm29
 
+// CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0xaa,0x00,0x04,0x00,0x00]
+          vcvttpd2dqx 1024(%rdx){1to2}, %xmm29
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0xaa,0x00,0x04,0x00,0x00]
+          vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0xaa,0x00,0x04,0x00,0x00]
+          vcvttpd2dqx 1024(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0xaa,0x00,0x04,0x00,0x00]
+          vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6} {z}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0xaa,0x00,0x04,0x00,0x00]
+          vcvttpd2dqx 1024(%rdx){1to2}, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x6a,0x80]
           vcvttpd2dq -1024(%rdx){1to2}, %xmm29
 
+// CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0x6a,0x80]
+          vcvttpd2dqx -1024(%rdx){1to2}, %xmm29
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x6a,0x80]
+          vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0x6a,0x80]
+          vcvttpd2dqx -1024(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x6a,0x80]
+          vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6} {z}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0x6a,0x80]
+          vcvttpd2dqx -1024(%rdx){1to2}, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29
 // CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
           vcvttpd2dq -1032(%rdx){1to2}, %xmm29
 
+// CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29
+// CHECK:  encoding: [0x62,0x61,0xfd,0x18,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqx -1032(%rdx){1to2}, %xmm29
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x1e,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqx -1032(%rdx){1to2}, %xmm29 {%k6}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6} {z}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to2}, %xmm29 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x9e,0xe6,0xaa,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqx -1032(%rdx){1to2}, %xmm29 {%k6} {z}
+
 // CHECK: vcvttpd2dq %ymm29, %xmm30
 // CHECK:  encoding: [0x62,0x01,0xfd,0x28,0xe6,0xf5]
           vcvttpd2dq %ymm29, %xmm30
 
+// CHECK: vcvttpd2dq %ymm29, %xmm30
+// CHECK:  encoding: [0x62,0x01,0xfd,0x28,0xe6,0xf5]
+          vcvttpd2dqy %ymm29, %xmm30
+
 // CHECK: vcvttpd2dq %ymm29, %xmm30 {%k6}
 // CHECK:  encoding: [0x62,0x01,0xfd,0x2e,0xe6,0xf5]
           vcvttpd2dq %ymm29, %xmm30 {%k6}
 
+// CHECK: vcvttpd2dq %ymm29, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x01,0xfd,0x2e,0xe6,0xf5]
+          vcvttpd2dqy %ymm29, %xmm30 {%k6}
+
 // CHECK: vcvttpd2dq %ymm29, %xmm30 {%k6} {z}
 // CHECK:  encoding: [0x62,0x01,0xfd,0xae,0xe6,0xf5]
           vcvttpd2dq %ymm29, %xmm30 {%k6} {z}
 
+// CHECK: vcvttpd2dq %ymm29, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x01,0xfd,0xae,0xe6,0xf5]
+          vcvttpd2dqy %ymm29, %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy (%rcx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x28,0xe6,0x31]
           vcvttpd2dqy (%rcx), %xmm30
 
+// CHECK: vcvttpd2dqy (%rcx), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x2e,0xe6,0x31]
+          vcvttpd2dqy (%rcx), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy (%rcx), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xae,0xe6,0x31]
+          vcvttpd2dqy (%rcx), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy 291(%rax,%r14,8), %xmm30
 // CHECK:  encoding: [0x62,0x21,0xfd,0x28,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
           vcvttpd2dqy 291(%rax,%r14,8), %xmm30
 
+// CHECK: vcvttpd2dqy 291(%rax,%r14,8), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfd,0x2e,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2dqy 291(%rax,%r14,8), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy 291(%rax,%r14,8), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfd,0xae,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2dqy 291(%rax,%r14,8), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x31]
           vcvttpd2dq (%rcx){1to4}, %xmm30
 
+// CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x31]
+          vcvttpd2dqy (%rcx){1to4}, %xmm30
+
+// CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x31]
+          vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x31]
+          vcvttpd2dqy (%rcx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x31]
+          vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6} {z}
+
+// CHECK: vcvttpd2dq (%rcx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x31]
+          vcvttpd2dqy (%rcx){1to4}, %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy 4064(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x28,0xe6,0x72,0x7f]
           vcvttpd2dqy 4064(%rdx), %xmm30
 
+// CHECK: vcvttpd2dqy 4064(%rdx), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x2e,0xe6,0x72,0x7f]
+          vcvttpd2dqy 4064(%rdx), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy 4064(%rdx), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xae,0xe6,0x72,0x7f]
+          vcvttpd2dqy 4064(%rdx), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy 4096(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x28,0xe6,0xb2,0x00,0x10,0x00,0x00]
           vcvttpd2dqy 4096(%rdx), %xmm30
 
+// CHECK: vcvttpd2dqy 4096(%rdx), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x2e,0xe6,0xb2,0x00,0x10,0x00,0x00]
+          vcvttpd2dqy 4096(%rdx), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy 4096(%rdx), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xae,0xe6,0xb2,0x00,0x10,0x00,0x00]
+          vcvttpd2dqy 4096(%rdx), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy -4096(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x28,0xe6,0x72,0x80]
           vcvttpd2dqy -4096(%rdx), %xmm30
 
+// CHECK: vcvttpd2dqy -4096(%rdx), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x2e,0xe6,0x72,0x80]
+          vcvttpd2dqy -4096(%rdx), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy -4096(%rdx), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xae,0xe6,0x72,0x80]
+          vcvttpd2dqy -4096(%rdx), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dqy -4128(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x28,0xe6,0xb2,0xe0,0xef,0xff,0xff]
           vcvttpd2dqy -4128(%rdx), %xmm30
 
+// CHECK: vcvttpd2dqy -4128(%rdx), %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x2e,0xe6,0xb2,0xe0,0xef,0xff,0xff]
+          vcvttpd2dqy -4128(%rdx), %xmm30 {%k6}
+
+// CHECK: vcvttpd2dqy -4128(%rdx), %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xae,0xe6,0xb2,0xe0,0xef,0xff,0xff]
+          vcvttpd2dqy -4128(%rdx), %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x72,0x7f]
           vcvttpd2dq 1016(%rdx){1to4}, %xmm30
 
+// CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x72,0x7f]
+          vcvttpd2dqy 1016(%rdx){1to4}, %xmm30
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x72,0x7f]
+          vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x72,0x7f]
+          vcvttpd2dqy 1016(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x72,0x7f]
+          vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6} {z}
+
+// CHECK: vcvttpd2dq 1016(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x72,0x7f]
+          vcvttpd2dqy 1016(%rdx){1to4}, %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0xb2,0x00,0x04,0x00,0x00]
           vcvttpd2dq 1024(%rdx){1to4}, %xmm30
 
+// CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvttpd2dqy 1024(%rdx){1to4}, %xmm30
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvttpd2dqy 1024(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6} {z}
+
+// CHECK: vcvttpd2dq 1024(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvttpd2dqy 1024(%rdx){1to4}, %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x72,0x80]
           vcvttpd2dq -1024(%rdx){1to4}, %xmm30
 
+// CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0x72,0x80]
+          vcvttpd2dqy -1024(%rdx){1to4}, %xmm30
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x72,0x80]
+          vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0x72,0x80]
+          vcvttpd2dqy -1024(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x72,0x80]
+          vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6} {z}
+
+// CHECK: vcvttpd2dq -1024(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0x72,0x80]
+          vcvttpd2dqy -1024(%rdx){1to4}, %xmm30 {%k6} {z}
+
 // CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
           vcvttpd2dq -1032(%rdx){1to4}, %xmm30
 
+// CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xfd,0x38,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqy -1032(%rdx){1to4}, %xmm30
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfd,0x3e,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqy -1032(%rdx){1to4}, %xmm30 {%k6}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6} {z}
+
+// CHECK: vcvttpd2dq -1032(%rdx){1to4}, %xmm30 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfd,0xbe,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2dqy -1032(%rdx){1to4}, %xmm30 {%k6} {z}
+
 // CHECK: vcvttps2dq %xmm22, %xmm17
 // CHECK:  encoding: [0x62,0xa1,0x7e,0x08,0x5b,0xce]
           vcvttps2dq %xmm22, %xmm17
@@ -20991,114 +21952,490 @@ vaddpd  {rz-sae}, %zmm2, %zmm1, %zmm1
 // CHECK:  encoding: [0x62,0x21,0xff,0x08,0xe6,0xcc]
           vcvtpd2dq %xmm20, %xmm25
 
+// CHECK: vcvtpd2dq %xmm20, %xmm25
+// CHECK:  encoding: [0x62,0x21,0xff,0x08,0xe6,0xcc]
+          vcvtpd2dqx %xmm20, %xmm25
+
 // CHECK: vcvtpd2dq %xmm20, %xmm25 {%k2}
 // CHECK:  encoding: [0x62,0x21,0xff,0x0a,0xe6,0xcc]
           vcvtpd2dq %xmm20, %xmm25 {%k2}
 
+// CHECK: vcvtpd2dq %xmm20, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x21,0xff,0x0a,0xe6,0xcc]
+          vcvtpd2dqx %xmm20, %xmm25 {%k2}
+
 // CHECK: vcvtpd2dq %xmm20, %xmm25 {%k2} {z}
 // CHECK:  encoding: [0x62,0x21,0xff,0x8a,0xe6,0xcc]
           vcvtpd2dq %xmm20, %xmm25 {%k2} {z}
 
+// CHECK: vcvtpd2dq %xmm20, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0x8a,0xe6,0xcc]
+          vcvtpd2dqx %xmm20, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx (%rcx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x08,0xe6,0x09]
           vcvtpd2dqx (%rcx), %xmm25
 
+// CHECK: vcvtpd2dqx (%rcx), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x0a,0xe6,0x09]
+          vcvtpd2dqx (%rcx), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx (%rcx), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x8a,0xe6,0x09]
+          vcvtpd2dqx (%rcx), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx 291(%rax,%r14,8), %xmm25
 // CHECK:  encoding: [0x62,0x21,0xff,0x08,0xe6,0x8c,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2dqx 291(%rax,%r14,8), %xmm25
 
+// CHECK: vcvtpd2dqx 291(%rax,%r14,8), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x21,0xff,0x0a,0xe6,0x8c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqx 291(%rax,%r14,8), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx 291(%rax,%r14,8), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0x8a,0xe6,0x8c,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqx 291(%rax,%r14,8), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x09]
           vcvtpd2dq (%rcx){1to2}, %xmm25
 
+// CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x09]
+          vcvtpd2dqx (%rcx){1to2}, %xmm25
+
+// CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x09]
+          vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x09]
+          vcvtpd2dqx (%rcx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x09]
+          vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2} {z}
+
+// CHECK: vcvtpd2dq (%rcx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x09]
+          vcvtpd2dqx (%rcx){1to2}, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx 2032(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x08,0xe6,0x4a,0x7f]
           vcvtpd2dqx 2032(%rdx), %xmm25
 
+// CHECK: vcvtpd2dqx 2032(%rdx), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x0a,0xe6,0x4a,0x7f]
+          vcvtpd2dqx 2032(%rdx), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx 2032(%rdx), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x8a,0xe6,0x4a,0x7f]
+          vcvtpd2dqx 2032(%rdx), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx 2048(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x08,0xe6,0x8a,0x00,0x08,0x00,0x00]
           vcvtpd2dqx 2048(%rdx), %xmm25
 
+// CHECK: vcvtpd2dqx 2048(%rdx), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x0a,0xe6,0x8a,0x00,0x08,0x00,0x00]
+          vcvtpd2dqx 2048(%rdx), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx 2048(%rdx), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x8a,0xe6,0x8a,0x00,0x08,0x00,0x00]
+          vcvtpd2dqx 2048(%rdx), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx -2048(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x08,0xe6,0x4a,0x80]
           vcvtpd2dqx -2048(%rdx), %xmm25
 
+// CHECK: vcvtpd2dqx -2048(%rdx), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x0a,0xe6,0x4a,0x80]
+          vcvtpd2dqx -2048(%rdx), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx -2048(%rdx), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x8a,0xe6,0x4a,0x80]
+          vcvtpd2dqx -2048(%rdx), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dqx -2064(%rdx), %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x08,0xe6,0x8a,0xf0,0xf7,0xff,0xff]
           vcvtpd2dqx -2064(%rdx), %xmm25
 
+// CHECK: vcvtpd2dqx -2064(%rdx), %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x0a,0xe6,0x8a,0xf0,0xf7,0xff,0xff]
+          vcvtpd2dqx -2064(%rdx), %xmm25 {%k2}
+
+// CHECK: vcvtpd2dqx -2064(%rdx), %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x8a,0xe6,0x8a,0xf0,0xf7,0xff,0xff]
+          vcvtpd2dqx -2064(%rdx), %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x4a,0x7f]
           vcvtpd2dq 1016(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x4a,0x7f]
+          vcvtpd2dqx 1016(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x4a,0x7f]
+          vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x4a,0x7f]
+          vcvtpd2dqx 1016(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x4a,0x7f]
+          vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2} {z}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x4a,0x7f]
+          vcvtpd2dqx 1016(%rdx){1to2}, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x8a,0x00,0x04,0x00,0x00]
           vcvtpd2dq 1024(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x8a,0x00,0x04,0x00,0x00]
+          vcvtpd2dqx 1024(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x8a,0x00,0x04,0x00,0x00]
+          vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x8a,0x00,0x04,0x00,0x00]
+          vcvtpd2dqx 1024(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x8a,0x00,0x04,0x00,0x00]
+          vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2} {z}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x8a,0x00,0x04,0x00,0x00]
+          vcvtpd2dqx 1024(%rdx){1to2}, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x4a,0x80]
           vcvtpd2dq -1024(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x4a,0x80]
+          vcvtpd2dqx -1024(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x4a,0x80]
+          vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x4a,0x80]
+          vcvtpd2dqx -1024(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x4a,0x80]
+          vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2} {z}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x4a,0x80]
+          vcvtpd2dqx -1024(%rdx){1to2}, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25
 // CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
           vcvtpd2dq -1032(%rdx){1to2}, %xmm25
 
+// CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25
+// CHECK:  encoding: [0x62,0x61,0xff,0x18,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqx -1032(%rdx){1to2}, %xmm25
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2}
+// CHECK:  encoding: [0x62,0x61,0xff,0x1a,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqx -1032(%rdx){1to2}, %xmm25 {%k2}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2} {z}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to2}, %xmm25 {%k2} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0x9a,0xe6,0x8a,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqx -1032(%rdx){1to2}, %xmm25 {%k2} {z}
+
 // CHECK: vcvtpd2dq %ymm28, %xmm30
 // CHECK:  encoding: [0x62,0x01,0xff,0x28,0xe6,0xf4]
           vcvtpd2dq %ymm28, %xmm30
 
+// CHECK: vcvtpd2dq %ymm28, %xmm30
+// CHECK:  encoding: [0x62,0x01,0xff,0x28,0xe6,0xf4]
+          vcvtpd2dqy %ymm28, %xmm30
+
 // CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3}
 // CHECK:  encoding: [0x62,0x01,0xff,0x2b,0xe6,0xf4]
           vcvtpd2dq %ymm28, %xmm30 {%k3}
 
+// CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x01,0xff,0x2b,0xe6,0xf4]
+          vcvtpd2dqy %ymm28, %xmm30 {%k3}
+
 // CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
 // CHECK:  encoding: [0x62,0x01,0xff,0xab,0xe6,0xf4]
           vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
 
+// CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x01,0xff,0xab,0xe6,0xf4]
+          vcvtpd2dqy %ymm28, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dqy (%rcx), %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0x31]
+          vcvtpd2dqy (%rcx), %xmm30
+
+// CHECK: vcvtpd2dqy (%rcx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0x31]
+          vcvtpd2dqy (%rcx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy (%rcx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0x31]
+          vcvtpd2dqy (%rcx), %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30
+// CHECK:  encoding: [0x62,0x21,0xff,0x28,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqy 291(%rax,%r14,8), %xmm30
+
+// CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xff,0x2b,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0xab,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x31]
+          vcvtpd2dq (%rcx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x31]
+          vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x31]
+          vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x01,0xff,0xab,0xe6,0xf4]
+          vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq %ymm28, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x01,0xff,0xab,0xe6,0xf4]
+          vcvtpd2dqy %ymm28, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy (%rcx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0x31]
           vcvtpd2dqy (%rcx), %xmm30
 
+// CHECK: vcvtpd2dqy (%rcx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0x31]
+          vcvtpd2dqy (%rcx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy (%rcx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0x31]
+          vcvtpd2dqy (%rcx), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30
 // CHECK:  encoding: [0x62,0x21,0xff,0x28,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
           vcvtpd2dqy 291(%rax,%r14,8), %xmm30
 
+// CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x21,0xff,0x2b,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x21,0xff,0xab,0xe6,0xb4,0xf0,0x23,0x01,0x00,0x00]
+          vcvtpd2dqy 291(%rax,%r14,8), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x31]
           vcvtpd2dq (%rcx){1to4}, %xmm30
 
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x31]
+          vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x31]
+          vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq (%rcx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x31]
+          vcvtpd2dqy (%rcx){1to4}, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy 4064(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0x72,0x7f]
           vcvtpd2dqy 4064(%rdx), %xmm30
 
+// CHECK: vcvtpd2dqy 4064(%rdx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0x72,0x7f]
+          vcvtpd2dqy 4064(%rdx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy 4064(%rdx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0x72,0x7f]
+          vcvtpd2dqy 4064(%rdx), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy 4096(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0xb2,0x00,0x10,0x00,0x00]
           vcvtpd2dqy 4096(%rdx), %xmm30
 
+// CHECK: vcvtpd2dqy 4096(%rdx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0xb2,0x00,0x10,0x00,0x00]
+          vcvtpd2dqy 4096(%rdx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy 4096(%rdx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0xb2,0x00,0x10,0x00,0x00]
+          vcvtpd2dqy 4096(%rdx), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy -4096(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0x72,0x80]
           vcvtpd2dqy -4096(%rdx), %xmm30
 
+// CHECK: vcvtpd2dqy -4096(%rdx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0x72,0x80]
+          vcvtpd2dqy -4096(%rdx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy -4096(%rdx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0x72,0x80]
+          vcvtpd2dqy -4096(%rdx), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dqy -4128(%rdx), %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x28,0xe6,0xb2,0xe0,0xef,0xff,0xff]
           vcvtpd2dqy -4128(%rdx), %xmm30
 
+// CHECK: vcvtpd2dqy -4128(%rdx), %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x2b,0xe6,0xb2,0xe0,0xef,0xff,0xff]
+          vcvtpd2dqy -4128(%rdx), %xmm30 {%k3}
+
+// CHECK: vcvtpd2dqy -4128(%rdx), %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xab,0xe6,0xb2,0xe0,0xef,0xff,0xff]
+          vcvtpd2dqy -4128(%rdx), %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x72,0x7f]
           vcvtpd2dq 1016(%rdx){1to4}, %xmm30
 
+// CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x72,0x7f]
+          vcvtpd2dqy 1016(%rdx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x72,0x7f]
+          vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x72,0x7f]
+          vcvtpd2dqy 1016(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x72,0x7f]
+          vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq 1016(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x72,0x7f]
+          vcvtpd2dqy 1016(%rdx){1to4}, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0xb2,0x00,0x04,0x00,0x00]
           vcvtpd2dq 1024(%rdx){1to4}, %xmm30
 
+// CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvtpd2dqy 1024(%rdx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvtpd2dqy 1024(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq 1024(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0xb2,0x00,0x04,0x00,0x00]
+          vcvtpd2dqy 1024(%rdx){1to4}, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x72,0x80]
           vcvtpd2dq -1024(%rdx){1to4}, %xmm30
 
+// CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0x72,0x80]
+          vcvtpd2dqy -1024(%rdx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x72,0x80]
+          vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0x72,0x80]
+          vcvtpd2dqy -1024(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x72,0x80]
+          vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq -1024(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0x72,0x80]
+          vcvtpd2dqy -1024(%rdx){1to4}, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30
 // CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
           vcvtpd2dq -1032(%rdx){1to4}, %xmm30
 
+// CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30
+// CHECK:  encoding: [0x62,0x61,0xff,0x38,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqy -1032(%rdx){1to4}, %xmm30
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3}
+// CHECK:  encoding: [0x62,0x61,0xff,0x3b,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqy -1032(%rdx){1to4}, %xmm30 {%k3}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3} {z}
+
+// CHECK: vcvtpd2dq -1032(%rdx){1to4}, %xmm30 {%k3} {z}
+// CHECK:  encoding: [0x62,0x61,0xff,0xbb,0xe6,0xb2,0xf8,0xfb,0xff,0xff]
+          vcvtpd2dqy -1032(%rdx){1to4}, %xmm30 {%k3} {z}
+
 // CHECK: vcvtpd2ps %xmm27, %xmm27
 // CHECK:  encoding: [0x62,0x01,0xfd,0x08,0x5a,0xdb]
           vcvtpd2ps %xmm27, %xmm27
@@ -21215,114 +22552,434 @@ vaddpd  {rz-sae}, %zmm2, %zmm1, %zmm1
 // CHECK:  encoding: [0x62,0x81,0xfc,0x08,0x78,0xfa]
           vcvttpd2udq %xmm26, %xmm23
 
+// CHECK: vcvttpd2udq %xmm26, %xmm23
+// CHECK:  encoding: [0x62,0x81,0xfc,0x08,0x78,0xfa]
+          vcvttpd2udqx %xmm26, %xmm23
+
 // CHECK: vcvttpd2udq %xmm26, %xmm23 {%k2}
 // CHECK:  encoding: [0x62,0x81,0xfc,0x0a,0x78,0xfa]
           vcvttpd2udq %xmm26, %xmm23 {%k2}
 
+// CHECK: vcvttpd2udq %xmm26, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0x81,0xfc,0x0a,0x78,0xfa]
+          vcvttpd2udqx %xmm26, %xmm23 {%k2}
+
 // CHECK: vcvttpd2udq %xmm26, %xmm23 {%k2} {z}
 // CHECK:  encoding: [0x62,0x81,0xfc,0x8a,0x78,0xfa]
           vcvttpd2udq %xmm26, %xmm23 {%k2} {z}
 
+// CHECK: vcvttpd2udq %xmm26, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0x81,0xfc,0x8a,0x78,0xfa]
+          vcvttpd2udqx %xmm26, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx (%rcx), %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x08,0x78,0x39]
           vcvttpd2udqx (%rcx), %xmm23
 
+// CHECK: vcvttpd2udqx (%rcx), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x0a,0x78,0x39]
+          vcvttpd2udqx (%rcx), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx (%rcx), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x8a,0x78,0x39]
+          vcvttpd2udqx (%rcx), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx 291(%rax,%r14,8), %xmm23
 // CHECK:  encoding: [0x62,0xa1,0xfc,0x08,0x78,0xbc,0xf0,0x23,0x01,0x00,0x00]
           vcvttpd2udqx 291(%rax,%r14,8), %xmm23
 
+// CHECK: vcvttpd2udqx 291(%rax,%r14,8), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x0a,0x78,0xbc,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2udqx 291(%rax,%r14,8), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx 291(%rax,%r14,8), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xa1,0xfc,0x8a,0x78,0xbc,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2udqx 291(%rax,%r14,8), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x39]
           vcvttpd2udq (%rcx){1to2}, %xmm23
 
+// CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x39]
+          vcvttpd2udqx (%rcx){1to2}, %xmm23
+
+// CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x39]
+          vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x39]
+          vcvttpd2udqx (%rcx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x39]
+          vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2} {z}
+
+// CHECK: vcvttpd2udq (%rcx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x39]
+          vcvttpd2udqx (%rcx){1to2}, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx 2032(%rdx), %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x08,0x78,0x7a,0x7f]
           vcvttpd2udqx 2032(%rdx), %xmm23
 
+// CHECK: vcvttpd2udqx 2032(%rdx), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x0a,0x78,0x7a,0x7f]
+          vcvttpd2udqx 2032(%rdx), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx 2032(%rdx), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x8a,0x78,0x7a,0x7f]
+          vcvttpd2udqx 2032(%rdx), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx 2048(%rdx), %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x08,0x78,0xba,0x00,0x08,0x00,0x00]
           vcvttpd2udqx 2048(%rdx), %xmm23
 
+// CHECK: vcvttpd2udqx 2048(%rdx), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x0a,0x78,0xba,0x00,0x08,0x00,0x00]
+          vcvttpd2udqx 2048(%rdx), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx 2048(%rdx), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x8a,0x78,0xba,0x00,0x08,0x00,0x00]
+          vcvttpd2udqx 2048(%rdx), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx -2048(%rdx), %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x08,0x78,0x7a,0x80]
           vcvttpd2udqx -2048(%rdx), %xmm23
 
+// CHECK: vcvttpd2udqx -2048(%rdx), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x0a,0x78,0x7a,0x80]
+          vcvttpd2udqx -2048(%rdx), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx -2048(%rdx), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x8a,0x78,0x7a,0x80]
+          vcvttpd2udqx -2048(%rdx), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udqx -2064(%rdx), %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x08,0x78,0xba,0xf0,0xf7,0xff,0xff]
           vcvttpd2udqx -2064(%rdx), %xmm23
 
+// CHECK: vcvttpd2udqx -2064(%rdx), %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x0a,0x78,0xba,0xf0,0xf7,0xff,0xff]
+          vcvttpd2udqx -2064(%rdx), %xmm23 {%k2}
+
+// CHECK: vcvttpd2udqx -2064(%rdx), %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x8a,0x78,0xba,0xf0,0xf7,0xff,0xff]
+          vcvttpd2udqx -2064(%rdx), %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x7a,0x7f]
           vcvttpd2udq 1016(%rdx){1to2}, %xmm23
 
+// CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x7a,0x7f]
+          vcvttpd2udqx 1016(%rdx){1to2}, %xmm23
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x7a,0x7f]
+          vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x7a,0x7f]
+          vcvttpd2udqx 1016(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x7a,0x7f]
+          vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2} {z}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x7a,0x7f]
+          vcvttpd2udqx 1016(%rdx){1to2}, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0xba,0x00,0x04,0x00,0x00]
           vcvttpd2udq 1024(%rdx){1to2}, %xmm23
 
+// CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0xba,0x00,0x04,0x00,0x00]
+          vcvttpd2udqx 1024(%rdx){1to2}, %xmm23
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0xba,0x00,0x04,0x00,0x00]
+          vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0xba,0x00,0x04,0x00,0x00]
+          vcvttpd2udqx 1024(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0xba,0x00,0x04,0x00,0x00]
+          vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2} {z}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0xba,0x00,0x04,0x00,0x00]
+          vcvttpd2udqx 1024(%rdx){1to2}, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x7a,0x80]
           vcvttpd2udq -1024(%rdx){1to2}, %xmm23
 
+// CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0x7a,0x80]
+          vcvttpd2udqx -1024(%rdx){1to2}, %xmm23
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x7a,0x80]
+          vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0x7a,0x80]
+          vcvttpd2udqx -1024(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x7a,0x80]
+          vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2} {z}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0x7a,0x80]
+          vcvttpd2udqx -1024(%rdx){1to2}, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23
 // CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0xba,0xf8,0xfb,0xff,0xff]
           vcvttpd2udq -1032(%rdx){1to2}, %xmm23
 
+// CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x18,0x78,0xba,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqx -1032(%rdx){1to2}, %xmm23
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0xba,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x1a,0x78,0xba,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqx -1032(%rdx){1to2}, %xmm23 {%k2}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0xba,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2} {z}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to2}, %xmm23 {%k2} {z}
+// CHECK:  encoding: [0x62,0xe1,0xfc,0x9a,0x78,0xba,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqx -1032(%rdx){1to2}, %xmm23 {%k2} {z}
+
 // CHECK: vcvttpd2udq %ymm23, %xmm28
 // CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x78,0xe7]
           vcvttpd2udq %ymm23, %xmm28
 
+// CHECK: vcvttpd2udq %ymm23, %xmm28
+// CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x78,0xe7]
+          vcvttpd2udqy %ymm23, %xmm28
+
 // CHECK: vcvttpd2udq %ymm23, %xmm28 {%k6}
 // CHECK:  encoding: [0x62,0x21,0xfc,0x2e,0x78,0xe7]
           vcvttpd2udq %ymm23, %xmm28 {%k6}
 
+// CHECK: vcvttpd2udq %ymm23, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x2e,0x78,0xe7]
+          vcvttpd2udqy %ymm23, %xmm28 {%k6}
+
 // CHECK: vcvttpd2udq %ymm23, %xmm28 {%k6} {z}
 // CHECK:  encoding: [0x62,0x21,0xfc,0xae,0x78,0xe7]
           vcvttpd2udq %ymm23, %xmm28 {%k6} {z}
 
+// CHECK: vcvttpd2udq %ymm23, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0xae,0x78,0xe7]
+          vcvttpd2udqy %ymm23, %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy (%rcx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x78,0x21]
           vcvttpd2udqy (%rcx), %xmm28
 
+// CHECK: vcvttpd2udqy (%rcx), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2e,0x78,0x21]
+          vcvttpd2udqy (%rcx), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy (%rcx), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xae,0x78,0x21]
+          vcvttpd2udqy (%rcx), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy 291(%rax,%r14,8), %xmm28
 // CHECK:  encoding: [0x62,0x21,0xfc,0x28,0x78,0xa4,0xf0,0x23,0x01,0x00,0x00]
           vcvttpd2udqy 291(%rax,%r14,8), %xmm28
 
+// CHECK: vcvttpd2udqy 291(%rax,%r14,8), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x21,0xfc,0x2e,0x78,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2udqy 291(%rax,%r14,8), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy 291(%rax,%r14,8), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x21,0xfc,0xae,0x78,0xa4,0xf0,0x23,0x01,0x00,0x00]
+          vcvttpd2udqy 291(%rax,%r14,8), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x21]
           vcvttpd2udq (%rcx){1to4}, %xmm28
 
+// CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x21]
+          vcvttpd2udqy (%rcx){1to4}, %xmm28
+
+// CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x21]
+          vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x21]
+          vcvttpd2udqy (%rcx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x21]
+          vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6} {z}
+
+// CHECK: vcvttpd2udq (%rcx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x21]
+          vcvttpd2udqy (%rcx){1to4}, %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy 4064(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x78,0x62,0x7f]
           vcvttpd2udqy 4064(%rdx), %xmm28
 
+// CHECK: vcvttpd2udqy 4064(%rdx), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2e,0x78,0x62,0x7f]
+          vcvttpd2udqy 4064(%rdx), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy 4064(%rdx), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xae,0x78,0x62,0x7f]
+          vcvttpd2udqy 4064(%rdx), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy 4096(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x78,0xa2,0x00,0x10,0x00,0x00]
           vcvttpd2udqy 4096(%rdx), %xmm28
 
+// CHECK: vcvttpd2udqy 4096(%rdx), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2e,0x78,0xa2,0x00,0x10,0x00,0x00]
+          vcvttpd2udqy 4096(%rdx), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy 4096(%rdx), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xae,0x78,0xa2,0x00,0x10,0x00,0x00]
+          vcvttpd2udqy 4096(%rdx), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy -4096(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x78,0x62,0x80]
           vcvttpd2udqy -4096(%rdx), %xmm28
 
+// CHECK: vcvttpd2udqy -4096(%rdx), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2e,0x78,0x62,0x80]
+          vcvttpd2udqy -4096(%rdx), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy -4096(%rdx), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xae,0x78,0x62,0x80]
+          vcvttpd2udqy -4096(%rdx), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udqy -4128(%rdx), %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x28,0x78,0xa2,0xe0,0xef,0xff,0xff]
           vcvttpd2udqy -4128(%rdx), %xmm28
 
+// CHECK: vcvttpd2udqy -4128(%rdx), %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x2e,0x78,0xa2,0xe0,0xef,0xff,0xff]
+          vcvttpd2udqy -4128(%rdx), %xmm28 {%k6}
+
+// CHECK: vcvttpd2udqy -4128(%rdx), %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xae,0x78,0xa2,0xe0,0xef,0xff,0xff]
+          vcvttpd2udqy -4128(%rdx), %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x62,0x7f]
           vcvttpd2udq 1016(%rdx){1to4}, %xmm28
 
+// CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x62,0x7f]
+          vcvttpd2udqy 1016(%rdx){1to4}, %xmm28
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x62,0x7f]
+          vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x62,0x7f]
+          vcvttpd2udqy 1016(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x62,0x7f]
+          vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6} {z}
+
+// CHECK: vcvttpd2udq 1016(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x62,0x7f]
+          vcvttpd2udqy 1016(%rdx){1to4}, %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0xa2,0x00,0x04,0x00,0x00]
           vcvttpd2udq 1024(%rdx){1to4}, %xmm28
 
+// CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0xa2,0x00,0x04,0x00,0x00]
+          vcvttpd2udqy 1024(%rdx){1to4}, %xmm28
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0xa2,0x00,0x04,0x00,0x00]
+          vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0xa2,0x00,0x04,0x00,0x00]
+          vcvttpd2udqy 1024(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0xa2,0x00,0x04,0x00,0x00]
+          vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6} {z}
+
+// CHECK: vcvttpd2udq 1024(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0xa2,0x00,0x04,0x00,0x00]
+          vcvttpd2udqy 1024(%rdx){1to4}, %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x62,0x80]
           vcvttpd2udq -1024(%rdx){1to4}, %xmm28
 
+// CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0x62,0x80]
+          vcvttpd2udqy -1024(%rdx){1to4}, %xmm28
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x62,0x80]
+          vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0x62,0x80]
+          vcvttpd2udqy -1024(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x62,0x80]
+          vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6} {z}
+
+// CHECK: vcvttpd2udq -1024(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0x62,0x80]
+          vcvttpd2udqy -1024(%rdx){1to4}, %xmm28 {%k6} {z}
+
 // CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28
 // CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0xa2,0xf8,0xfb,0xff,0xff]
           vcvttpd2udq -1032(%rdx){1to4}, %xmm28
 
+// CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28
+// CHECK:  encoding: [0x62,0x61,0xfc,0x38,0x78,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqy -1032(%rdx){1to4}, %xmm28
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6}
+// CHECK:  encoding: [0x62,0x61,0xfc,0x3e,0x78,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqy -1032(%rdx){1to4}, %xmm28 {%k6}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6} {z}
+
+// CHECK: vcvttpd2udq -1032(%rdx){1to4}, %xmm28 {%k6} {z}
+// CHECK:  encoding: [0x62,0x61,0xfc,0xbe,0x78,0xa2,0xf8,0xfb,0xff,0xff]
+          vcvttpd2udqy -1032(%rdx){1to4}, %xmm28 {%k6} {z}
+
 // CHECK: vpternlogd $171, %xmm25, %xmm19, %xmm27
 // CHECK:  encoding: [0x62,0x03,0x65,0x00,0x25,0xd9,0xab]
           vpternlogd $0xab, %xmm25, %xmm19, %xmm27
