AVX512F: GATHER assembler Intel syntax

[igorb]

Summary

AVX512F: Add GATHER/SCATTER assembler Intel syntax tests for knl/skx . Change memory operand parser handling.

[igorb]

change GATHER/SCATTER AVX version.

[delena]

LGTM

lib/Target/X86/AsmParser/X86Operand.h

bool isMem128() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 128);
   }
   bool isMem256() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 256);
   }
   bool isMem512() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 512);
   }
-
   bool isMemVX32() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
       getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM15;
   }
-  bool isMemVX32X() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
-      getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM31;
-  }
   bool isMemVY32() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
       getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM15;
   }
-  bool isMemVY32X() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
-      getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM31;
-  }
   bool isMemVX64() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
       getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM15;
   }
-  bool isMemVX64X() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
-      getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM31;
-  }
   bool isMemVY64() const {
     return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
       getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM15;
   }
-  bool isMemVY64X() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
+  bool isMem128VX() const {
+    return isMem128() &&
+      getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM31;
+  }
+  bool isMem256VX() const {
+    return isMem256() &&
+      getMemIndexReg() >= X86::XMM0 && getMemIndexReg() <= X86::XMM31;
+  }
+  bool isMem256VY() const {
+    return isMem256() &&
       getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM31;
   }
-  bool isMemVZ32() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
-      getMemIndexReg() >= X86::ZMM0 && getMemIndexReg() <= X86::ZMM31;
+  bool isMem512VY() const {
+    return isMem512() &&
+      getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM31;
   }
-  bool isMemVZ64() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
+  bool isMem512VZ() const {
+    return isMem512() &&
       getMemIndexReg() >= X86::ZMM0 && getMemIndexReg() <= X86::ZMM31;
   }
-
   bool isAbsMem() const {
     return Kind == Memory && !getMemSegReg() && !getMemBaseReg() &&
       !getMemIndexReg() && getMemScale() == 1;
   }
   bool isAVX512RC() const{
       return isImm();
   }
 

lib/Target/X86/X86InstrAVX512.td

def rm  : AVX5128I<opc, MRMSrcMem, (outs _.RC:$dst, _.KRCWM:$mask_wb),
               (GatherNode  (_.VT _.RC:$src1), _.KRCWM:$mask,
                      vectoraddr:$src2))]>, EVEX, EVEX_K,
              EVEX_CD8<_.EltSize, CD8VT1>;
 }
 
 multiclass avx512_gather_q_pd<bits<8> dopc, bits<8> qopc,
                         AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
   defm NAME##D##SUFF##Z: avx512_gather<dopc, OpcodeStr##"d", _.info512,
-                                      vy32xmem, mgatherv8i32>, EVEX_V512, VEX_W;
+                                      vy512mem, mgatherv8i32>, EVEX_V512, VEX_W;
   defm NAME##Q##SUFF##Z: avx512_gather<qopc, OpcodeStr##"q", _.info512,
-                                      vz64mem,  mgatherv8i64>, EVEX_V512, VEX_W;
+                                      vz512mem,  mgatherv8i64>, EVEX_V512, VEX_W;
 let Predicates = [HasVLX] in {
   defm NAME##D##SUFF##Z256: avx512_gather<dopc, OpcodeStr##"d", _.info256,
-                              vx32xmem, mgatherv4i32>, EVEX_V256, VEX_W;
+                              vx256mem, mgatherv4i32>, EVEX_V256, VEX_W;
   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info256,
-                              vy64xmem, mgatherv4i64>, EVEX_V256, VEX_W;
+                              vy256mem, mgatherv4i64>, EVEX_V256, VEX_W;
   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
-                              vx32xmem, mgatherv4i32>, EVEX_V128, VEX_W;
+                              vx128mem, mgatherv4i32>, EVEX_V128, VEX_W;
   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
-                              vx64xmem, mgatherv2i64>, EVEX_V128, VEX_W;
+                              vx128mem, mgatherv2i64>, EVEX_V128, VEX_W;
 }
 }
 
 multiclass avx512_gather_d_ps<bits<8> dopc, bits<8> qopc,
                        AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
-  defm NAME##D##SUFF##Z: avx512_gather<dopc, OpcodeStr##"d", _.info512, vz32mem,
+  defm NAME##D##SUFF##Z: avx512_gather<dopc, OpcodeStr##"d", _.info512, vz512mem,
                                        mgatherv16i32>, EVEX_V512;
-  defm NAME##Q##SUFF##Z: avx512_gather<qopc, OpcodeStr##"q", _.info256, vz64mem,
+  defm NAME##Q##SUFF##Z: avx512_gather<qopc, OpcodeStr##"q", _.info256, vz512mem,
                                        mgatherv8i64>, EVEX_V512;
 let Predicates = [HasVLX] in {
   defm NAME##D##SUFF##Z256: avx512_gather<dopc, OpcodeStr##"d", _.info256,
-                                          vy32xmem, mgatherv8i32>, EVEX_V256;
+                                          vy256mem, mgatherv8i32>, EVEX_V256;
   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info128,
-                                          vy64xmem, mgatherv4i64>, EVEX_V256;
+                                          vy256mem, mgatherv4i64>, EVEX_V256;
   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
-                                          vx32xmem, mgatherv4i32>, EVEX_V128;
+                                          vx128mem, mgatherv4i32>, EVEX_V128;
   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
-                                          vx64xmem, mgatherv2i64>, EVEX_V128;
+                                          vx128mem, mgatherv2i64>, EVEX_V128;
 }
 }
 
 
 defm VGATHER : avx512_gather_q_pd<0x92, 0x93, avx512vl_f64_info, "vgather", "PD">,
                avx512_gather_d_ps<0x92, 0x93, avx512vl_f32_info, "vgather", "PS">;
 
 defm VPGATHER : avx512_gather_q_pd<0x90, 0x91, avx512vl_i64_info, "vpgather", "Q">,
def mr  : AVX5128I<opc, MRMDestMem, (outs _.KRCWM:$mask_wb),
             [(set _.KRCWM:$mask_wb, (ScatterNode (_.VT _.RC:$src),
                                      _.KRCWM:$mask,  vectoraddr:$dst))]>,
             EVEX, EVEX_K, EVEX_CD8<_.EltSize, CD8VT1>;
 }
 
 multiclass avx512_scatter_q_pd<bits<8> dopc, bits<8> qopc,
                         AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
   defm NAME##D##SUFF##Z: avx512_scatter<dopc, OpcodeStr##"d", _.info512,
-                                      vy32xmem, mscatterv8i32>, EVEX_V512, VEX_W;
+                                      vy512mem, mscatterv8i32>, EVEX_V512, VEX_W;
   defm NAME##Q##SUFF##Z: avx512_scatter<qopc, OpcodeStr##"q", _.info512,
-                                      vz64mem,  mscatterv8i64>, EVEX_V512, VEX_W;
+                                      vz512mem,  mscatterv8i64>, EVEX_V512, VEX_W;
 let Predicates = [HasVLX] in {
   defm NAME##D##SUFF##Z256: avx512_scatter<dopc, OpcodeStr##"d", _.info256,
-                              vx32xmem, mscatterv4i32>, EVEX_V256, VEX_W;
+                              vx256mem, mscatterv4i32>, EVEX_V256, VEX_W;
   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info256,
-                              vy64xmem, mscatterv4i64>, EVEX_V256, VEX_W;
+                              vy256mem, mscatterv4i64>, EVEX_V256, VEX_W;
   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
-                              vx32xmem, mscatterv4i32>, EVEX_V128, VEX_W;
+                              vx128mem, mscatterv4i32>, EVEX_V128, VEX_W;
   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
-                              vx64xmem, mscatterv2i64>, EVEX_V128, VEX_W;
+                              vx128mem, mscatterv2i64>, EVEX_V128, VEX_W;
 }
 }
 
 multiclass avx512_scatter_d_ps<bits<8> dopc, bits<8> qopc,
                        AVX512VLVectorVTInfo _, string OpcodeStr, string SUFF> {
-  defm NAME##D##SUFF##Z: avx512_scatter<dopc, OpcodeStr##"d", _.info512, vz32mem,
+  defm NAME##D##SUFF##Z: avx512_scatter<dopc, OpcodeStr##"d", _.info512, vz512mem,
                                        mscatterv16i32>, EVEX_V512;
-  defm NAME##Q##SUFF##Z: avx512_scatter<qopc, OpcodeStr##"q", _.info256, vz64mem,
+  defm NAME##Q##SUFF##Z: avx512_scatter<qopc, OpcodeStr##"q", _.info256, vz512mem,
                                        mscatterv8i64>, EVEX_V512;
 let Predicates = [HasVLX] in {
   defm NAME##D##SUFF##Z256: avx512_scatter<dopc, OpcodeStr##"d", _.info256,
-                                          vy32xmem, mscatterv8i32>, EVEX_V256;
+                                          vy256mem, mscatterv8i32>, EVEX_V256;
   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
-                                          vy64xmem, mscatterv4i64>, EVEX_V256;
+                                          vy256mem, mscatterv4i64>, EVEX_V256;
   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
-                                          vx32xmem, mscatterv4i32>, EVEX_V128;
+                                          vx128mem, mscatterv4i32>, EVEX_V128;
   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
-                                          vx64xmem, mscatterv2i64>, EVEX_V128;
+                                          vx128mem, mscatterv2i64>, EVEX_V128;
 }
 }
 
 defm VSCATTER : avx512_scatter_q_pd<0xA2, 0xA3, avx512vl_f64_info, "vscatter", "PD">,
                avx512_scatter_d_ps<0xA2, 0xA3, avx512vl_f32_info, "vscatter", "PS">;
 
 defm VPSCATTER : avx512_scatter_q_pd<0xA0, 0xA1, avx512vl_i64_info, "vpscatter", "Q">,
                 avx512_scatter_d_ps<0xA0, 0xA1, avx512vl_i32_info, "vpscatter", "D">;
 
 // prefetch
 multiclass avx512_gather_scatter_prefetch<bits<8> opc, Format F, string OpcodeStr,
                        RegisterClass KRC, X86MemOperand memop> {
   let Predicates = [HasPFI], hasSideEffects = 1 in
   def m  : AVX5128I<opc, F, (outs), (ins KRC:$mask, memop:$src),
             !strconcat(OpcodeStr, "\t{$src {${mask}}|{${mask}}, $src}"),
             []>, EVEX, EVEX_K;
 }
 
 defm VGATHERPF0DPS: avx512_gather_scatter_prefetch<0xC6, MRM1m, "vgatherpf0dps",
-                     VK16WM, vz32mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
+                     VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
 
 defm VGATHERPF0QPS: avx512_gather_scatter_prefetch<0xC7, MRM1m, "vgatherpf0qps",
-                     VK8WM, vz64mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
 
 defm VGATHERPF0DPD: avx512_gather_scatter_prefetch<0xC6, MRM1m, "vgatherpf0dpd",
                      VK8WM, vy32mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
 
 defm VGATHERPF0QPD: avx512_gather_scatter_prefetch<0xC7, MRM1m, "vgatherpf0qpd",
-                     VK8WM, vz64mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
 
 defm VGATHERPF1DPS: avx512_gather_scatter_prefetch<0xC6, MRM2m, "vgatherpf1dps",
-                     VK16WM, vz32mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
+                     VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
 
 defm VGATHERPF1QPS: avx512_gather_scatter_prefetch<0xC7, MRM2m, "vgatherpf1qps",
-                     VK8WM, vz64mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
 
 defm VGATHERPF1DPD: avx512_gather_scatter_prefetch<0xC6, MRM2m, "vgatherpf1dpd",
                      VK8WM, vy32mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
 
 defm VGATHERPF1QPD: avx512_gather_scatter_prefetch<0xC7, MRM2m, "vgatherpf1qpd",
-                     VK8WM, vz64mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
 
 defm VSCATTERPF0DPS: avx512_gather_scatter_prefetch<0xC6, MRM5m, "vscatterpf0dps",
-                     VK16WM, vz32mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
+                     VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
 
 defm VSCATTERPF0QPS: avx512_gather_scatter_prefetch<0xC7, MRM5m, "vscatterpf0qps",
-                     VK8WM, vz64mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
 
 defm VSCATTERPF0DPD: avx512_gather_scatter_prefetch<0xC6, MRM5m, "vscatterpf0dpd",
                      VK8WM, vy32mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
 
 defm VSCATTERPF0QPD: avx512_gather_scatter_prefetch<0xC7, MRM5m, "vscatterpf0qpd",
-                     VK8WM, vz64mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
 
 defm VSCATTERPF1DPS: avx512_gather_scatter_prefetch<0xC6, MRM6m, "vscatterpf1dps",
-                     VK16WM, vz32mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
+                     VK16WM, vz512mem>, EVEX_V512, EVEX_CD8<32, CD8VT1>;
 
 defm VSCATTERPF1QPS: avx512_gather_scatter_prefetch<0xC7, MRM6m, "vscatterpf1qps",
-                     VK8WM, vz64mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, EVEX_CD8<64, CD8VT1>;
 
 defm VSCATTERPF1DPD: avx512_gather_scatter_prefetch<0xC6, MRM6m, "vscatterpf1dpd",
                      VK8WM, vy32mem>, EVEX_V512, VEX_W, EVEX_CD8<32, CD8VT1>;
 
 defm VSCATTERPF1QPD: avx512_gather_scatter_prefetch<0xC7, MRM6m, "vscatterpf1qpd",
-                     VK8WM, vz64mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
+                     VK8WM, vz512mem>, EVEX_V512, VEX_W, EVEX_CD8<64, CD8VT1>;
 
 // Helper fragments to match sext vXi1 to vXiY.
 def v16i1sextv16i32  : PatLeaf<(v16i32 (X86vsrai VR512:$src, (i8 31)))>;
 def v8i1sextv8i64  : PatLeaf<(v8i64 (X86vsrai VR512:$src, (i8 63)))>;
 
 multiclass cvt_by_vec_width<bits<8> opc, X86VectorVTInfo Vec, string OpcodeStr > {
 def rr : AVX512XS8I<opc, MRMSrcReg, (outs Vec.RC:$dst), (ins Vec.KRC:$src),
                   !strconcat(OpcodeStr##Vec.Suffix, "\t{$src, $dst|$dst, $src}"),

lib/Target/X86/X86InstrInfo.td

let RenderMethod = "addMemOperands", SuperClasses = [X86MemAsmOperand] in {
   def X86Mem64AsmOperand  : AsmOperandClass { let Name = "Mem64"; }
   def X86Mem80AsmOperand  : AsmOperandClass { let Name = "Mem80"; }
   def X86Mem128AsmOperand : AsmOperandClass { let Name = "Mem128"; }
   def X86Mem256AsmOperand : AsmOperandClass { let Name = "Mem256"; }
   def X86Mem512AsmOperand : AsmOperandClass { let Name = "Mem512"; }
   // Gather mem operands
   def X86MemVX32Operand : AsmOperandClass { let Name = "MemVX32"; }
   def X86MemVY32Operand : AsmOperandClass { let Name = "MemVY32"; }
-  def X86MemVZ32Operand : AsmOperandClass { let Name = "MemVZ32"; }
   def X86MemVX64Operand : AsmOperandClass { let Name = "MemVX64"; }
   def X86MemVY64Operand : AsmOperandClass { let Name = "MemVY64"; }
-  def X86MemVZ64Operand : AsmOperandClass { let Name = "MemVZ64"; }
-  def X86MemVX32XOperand : AsmOperandClass { let Name = "MemVX32X"; }
-  def X86MemVY32XOperand : AsmOperandClass { let Name = "MemVY32X"; }
-  def X86MemVX64XOperand : AsmOperandClass { let Name = "MemVX64X"; }
-  def X86MemVY64XOperand : AsmOperandClass { let Name = "MemVY64X"; }
+  
+  def X86Mem128VXOperand : AsmOperandClass { let Name = "Mem128VX"; }
+  def X86Mem256VXOperand : AsmOperandClass { let Name = "Mem256VX"; }
+  def X86Mem256VYOperand : AsmOperandClass { let Name = "Mem256VY"; }  
+  def X86Mem512VYOperand : AsmOperandClass { let Name = "Mem512VY"; }  
+  def X86Mem512VZOperand : AsmOperandClass { let Name = "Mem512VZ"; }
 }
 
 def X86AbsMemAsmOperand : AsmOperandClass {
   let Name = "AbsMem";
   let SuperClasses = [X86MemAsmOperand];
 }
 
 class X86MemOperand<string printMethod,

 def v512mem : X86VMemOperand<VR512, "printf512mem", X86Mem512AsmOperand>;
 
 // Gather mem operands
 def vx32mem  : X86VMemOperand<VR128,  "printi32mem", X86MemVX32Operand>;
 def vy32mem  : X86VMemOperand<VR256,  "printi32mem", X86MemVY32Operand>;
 def vx64mem  : X86VMemOperand<VR128,  "printi64mem", X86MemVX64Operand>;
 def vy64mem  : X86VMemOperand<VR256,  "printi64mem", X86MemVY64Operand>;
 
-def vx32xmem : X86VMemOperand<VR128X, "printi32mem", X86MemVX32XOperand>;
-def vx64xmem : X86VMemOperand<VR128X, "printi32mem", X86MemVX64XOperand>;
-def vy32xmem : X86VMemOperand<VR256X, "printi32mem", X86MemVY32XOperand>;
-def vy64xmem : X86VMemOperand<VR256X, "printi64mem", X86MemVY64XOperand>;
-def vz32mem  : X86VMemOperand<VR512,  "printi32mem", X86MemVZ32Operand>;
-def vz64mem  : X86VMemOperand<VR512,  "printi64mem", X86MemVZ64Operand>;
+def vx128mem : X86VMemOperand<VR128X, "printi128mem", X86Mem128VXOperand>;
+def vx256mem : X86VMemOperand<VR128X, "printi256mem", X86Mem256VXOperand>;
+def vy256mem : X86VMemOperand<VR256X, "printi256mem", X86Mem256VYOperand>;
+def vy512mem : X86VMemOperand<VR256X, "printi512mem", X86Mem512VYOperand>;
+def vz512mem : X86VMemOperand<VR512,  "printi512mem", X86Mem512VZOperand>;
 
 // A version of i8mem for use on x86-64 and x32 that uses a NOREX GPR instead
 // of a plain GPR, so that it doesn't potentially require a REX prefix.
 def ptr_rc_norex : PointerLikeRegClass<2>;
 def ptr_rc_norex_nosp : PointerLikeRegClass<3>;
 
 def i8mem_NOREX : Operand<iPTR> {
   let PrintMethod = "printi8mem";

test/MC/X86/intel-syntax-avx512.s

 // CHECK: vpermi2pd zmm21, zmm27, qword ptr [rdx - 1024]{1to8}
 // CHECK:  encoding: [0x62,0xe2,0xa5,0x50,0x77,0x6a,0x80]
           vpermi2pd zmm21, zmm27, qword ptr [rdx - 1024]{1to8}
 
 // CHECK: vpermi2pd zmm21, zmm27, qword ptr [rdx - 1032]{1to8}
 // CHECK:  encoding: [0x62,0xe2,0xa5,0x50,0x77,0xaa,0xf8,0xfb,0xff,0xff]
           vpermi2pd zmm21, zmm27, qword ptr [rdx - 1032]{1to8}
 
+// CHECK: vgatherdpd zmm6 {k1}, zmmword ptr [r14 + 8*ymm16 + 123]
+// CHECK:  encoding: [0x62,0xd2,0xfd,0x41,0x92,0xb4,0xc6,0x7b,0x00,0x00,0x00]
+          vgatherdpd zmm6 {k1},ZMMWORD PTR [r14+ymm16*8+0x7b]
+
+// CHECK: vgatherdpd zmm6 {k1}, zmmword ptr [r9 + ymm16 + 256]
+// CHECK:  encoding: [0x62,0xd2,0xfd,0x41,0x92,0x74,0x01,0x20]
+          vgatherdpd zmm6{k1},ZMMWORD PTR [r9+ymm16*1+0x100]
+
+// CHECK: vgatherdpd zmm6 {k1}, zmmword ptr [rcx + 4*ymm16 + 1024]
+// CHECK:  encoding: [0x62,0xf2,0xfd,0x41,0x92,0xb4,0x81,0x00,0x04,0x00,0x00]
+          vgatherdpd zmm6{k1},ZMMWORD PTR [rcx+ymm16*4+0x400]
+
+// CHECK: vgatherdps zmm9 {k1}, zmmword ptr [r14 + 8*zmm19 + 123]
+// CHECK:  encoding: [0x62,0x52,0x7d,0x41,0x92,0x8c,0xde,0x7b,0x00,0x00,0x00]
+          vgatherdps zmm9{k1},ZMMWORD PTR [r14+zmm19*8+0x7b]
+
+// CHECK: vgatherdps zmm9 {k1}, zmmword ptr [r9 + zmm19 + 256]
+// CHECK:  encoding: [0x62,0x52,0x7d,0x41,0x92,0x4c,0x19,0x40]
+          vgatherdps zmm9{k1},ZMMWORD PTR [r9+zmm19*1+0x100]
+
+// CHECK: vgatherdps zmm9 {k1}, zmmword ptr [rcx + 4*zmm19 + 1024]
+// CHECK:  encoding: [0x62,0x72,0x7d,0x41,0x92,0x8c,0x99,0x00,0x04,0x00,0x00]
+          vgatherdps zmm9{k1},ZMMWORD PTR [rcx+zmm19*4+0x400]
+
+// CHECK: vgatherqpd zmm29 {k1}, zmmword ptr [r14 + 8*zmm2 + 123]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x93,0xac,0xd6,0x7b,0x00,0x00,0x00]
+          vgatherqpd zmm29{k1},ZMMWORD PTR [r14+zmm2*8+0x7b]
+
+// CHECK: vgatherqpd zmm29 {k1}, zmmword ptr [r9 + zmm2 + 256]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x93,0x6c,0x11,0x20]
+          vgatherqpd zmm29{k1},ZMMWORD PTR [r9+zmm2*1+0x100]
+
+// CHECK: vgatherqpd zmm29 {k1}, zmmword ptr [rcx + 4*zmm2 + 1024]
+// CHECK:  encoding: [0x62,0x62,0xfd,0x49,0x93,0xac,0x91,0x00,0x04,0x00,0x00]
+          vgatherqpd zmm29{k1},ZMMWORD PTR [rcx+zmm2*4+0x400]
+
+// CHECK: vgatherqps ymm18 {k1}, zmmword ptr [r14 + 8*zmm4 + 123]
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0x93,0x94,0xe6,0x7b,0x00,0x00,0x00]
+          vgatherqps ymm18{k1},ZMMWORD PTR [r14+zmm4*8+0x7b]
+
+// CHECK: vgatherqps ymm18 {k1}, zmmword ptr [r9 + zmm4 + 256]
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0x93,0x54,0x21,0x40]
+          vgatherqps ymm18{k1},ZMMWORD PTR [r9+zmm4*1+0x100]
+
+// CHECK: vgatherqps ymm18 {k1}, zmmword ptr [rcx + 4*zmm4 + 1024]
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x49,0x93,0x94,0xa1,0x00,0x04,0x00,0x00]
+          vgatherqps ymm18{k1},ZMMWORD PTR [rcx+zmm4*4+0x400]
+
+// CHECK: vpgatherdd zmm17 {k1}, zmmword ptr [r14 + 8*zmm11 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x49,0x90,0x8c,0xde,0x7b,0x00,0x00,0x00]
+          vpgatherdd zmm17{k1},ZMMWORD PTR [r14+zmm11*8+0x7b]
+
+// CHECK: vpgatherdd zmm17 {k1}, zmmword ptr [r9 + zmm11 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x49,0x90,0x4c,0x19,0x40]
+          vpgatherdd zmm17{k1},ZMMWORD PTR [r9+zmm11*1+0x100]
+
+// CHECK: vpgatherdd zmm17 {k1}, zmmword ptr [rcx + 4*zmm11 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x49,0x90,0x8c,0x99,0x00,0x04,0x00,0x00]
+          vpgatherdd zmm17{k1},ZMMWORD PTR [rcx+zmm11*4+0x400]
+
+// CHECK: vpgatherdq zmm8 {k1}, zmmword ptr [r14 + 8*ymm14 + 123]
+// CHECK:  encoding: [0x62,0x12,0xfd,0x49,0x90,0x84,0xf6,0x7b,0x00,0x00,0x00]
+          vpgatherdq zmm8{k1},ZMMWORD PTR [r14+ymm14*8+0x7b]
+
+// CHECK: vpgatherdq zmm8 {k1}, zmmword ptr [r9 + ymm14 + 256]
+// CHECK:  encoding: [0x62,0x12,0xfd,0x49,0x90,0x44,0x31,0x20]
+          vpgatherdq zmm8{k1},ZMMWORD PTR [r9+ymm14*1+0x100]
+
+// CHECK: vpgatherdq zmm8 {k1}, zmmword ptr [rcx + 4*ymm14 + 1024]
+// CHECK:  encoding: [0x62,0x32,0xfd,0x49,0x90,0x84,0xb1,0x00,0x04,0x00,0x00]
+          vpgatherdq zmm8{k1},ZMMWORD PTR [rcx+ymm14*4+0x400]
+
+// CHECK: vpgatherqd ymm3 {k1}, zmmword ptr [r14 + 8*zmm17 + 123]
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0x91,0x9c,0xce,0x7b,0x00,0x00,0x00]
+          vpgatherqd ymm3{k1},ZMMWORD PTR [r14+zmm17*8+0x7b]
+
+// CHECK: vpgatherqd ymm3 {k1}, zmmword ptr [r9 + zmm17 + 256]
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0x91,0x5c,0x09,0x40]
+          vpgatherqd ymm3{k1},ZMMWORD PTR [r9+zmm17*1+0x100]
+
+// CHECK: vpgatherqd ymm3 {k1}, zmmword ptr [rcx + 4*zmm17 + 1024]
+// CHECK:  encoding: [0x62,0xf2,0x7d,0x41,0x91,0x9c,0x89,0x00,0x04,0x00,0x00]
+          vpgatherqd ymm3{k1},ZMMWORD PTR [rcx+zmm17*4+0x400]
+
+// CHECK: vpgatherqq zmm17 {k1}, zmmword ptr [r14 + 8*zmm21 + 123]
+// CHECK:  encoding: [0x62,0xc2,0xfd,0x41,0x91,0x8c,0xee,0x7b,0x00,0x00,0x00]
+          vpgatherqq zmm17{k1},ZMMWORD PTR [r14+zmm21*8+0x7b]
+
+// CHECK: vpgatherqq zmm17 {k1}, zmmword ptr [r9 + zmm21 + 256]
+// CHECK:  encoding: [0x62,0xc2,0xfd,0x41,0x91,0x4c,0x29,0x20]
+          vpgatherqq zmm17{k1},ZMMWORD PTR [r9+zmm21*1+0x100]
+
+// CHECK: vpgatherqq zmm17 {k1}, zmmword ptr [rcx + 4*zmm21 + 1024]
+// CHECK:  encoding: [0x62,0xe2,0xfd,0x41,0x91,0x8c,0xa9,0x00,0x04,0x00,0x00]
+          vpgatherqq zmm17{k1},ZMMWORD PTR [rcx+zmm21*4+0x400]
+
+// CHECK: vpscatterdd zmmword ptr [r14 + 8*zmm16 + 123] {k1}, zmm19
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa0,0x9c,0xc6,0x7b,0x00,0x00,0x00]
+          vpscatterdd ZMMWORD PTR [r14+zmm16*8+0x7b]{k1},zmm19
+
+// CHECK: vpscatterdd zmmword ptr [r14 + 8*zmm16 + 123] {k1}, zmm19
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa0,0x9c,0xc6,0x7b,0x00,0x00,0x00]
+          vpscatterdd ZMMWORD PTR [r14+zmm16*8+0x7b]{k1},zmm19
+
+// CHECK: vpscatterdd zmmword ptr [r9 + zmm16 + 256] {k1}, zmm19
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa0,0x5c,0x01,0x40]
+          vpscatterdd ZMMWORD PTR [r9+zmm16*1+0x100]{k1},zmm19
+
+// CHECK: vpscatterdd zmmword ptr [rcx + 4*zmm16 + 1024] {k1}, zmm19
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x41,0xa0,0x9c,0x81,0x00,0x04,0x00,0x00]
+          vpscatterdd ZMMWORD PTR [rcx+zmm16*4+0x400]{k1},zmm19
+
+// CHECK: vpscatterdq zmmword ptr [r14 + 8*ymm6 + 123] {k1}, zmm5
+// CHECK:  encoding: [0x62,0xd2,0xfd,0x49,0xa0,0xac,0xf6,0x7b,0x00,0x00,0x00]
+          vpscatterdq ZMMWORD PTR [r14+ymm6*8+0x7b]{k1},zmm5
+
+// CHECK: vpscatterdq zmmword ptr [r14 + 8*ymm6 + 123] {k1}, zmm5
+// CHECK:  encoding: [0x62,0xd2,0xfd,0x49,0xa0,0xac,0xf6,0x7b,0x00,0x00,0x00]
+          vpscatterdq ZMMWORD PTR [r14+ymm6*8+0x7b]{k1},zmm5
+
+// CHECK: vpscatterdq zmmword ptr [r9 + ymm6 + 256] {k1}, zmm5
+// CHECK:  encoding: [0x62,0xd2,0xfd,0x49,0xa0,0x6c,0x31,0x20]
+          vpscatterdq ZMMWORD PTR [r9+ymm6*1+0x100]{k1},zmm5
+
+// CHECK: vpscatterdq zmmword ptr [rcx + 4*ymm6 + 1024] {k1}, zmm5
+// CHECK:  encoding: [0x62,0xf2,0xfd,0x49,0xa0,0xac,0xb1,0x00,0x04,0x00,0x00]
+          vpscatterdq ZMMWORD PTR [rcx+ymm6*4+0x400]{k1},zmm5
+
+// CHECK: vpscatterqd zmmword ptr [r14 + 8*zmm2 + 123] {k1}, ymm20
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa1,0xa4,0xd6,0x7b,0x00,0x00,0x00]
+          vpscatterqd ZMMWORD PTR [r14+zmm2*8+0x7b]{k1},ymm20
+
+// CHECK: vpscatterqd zmmword ptr [r14 + 8*zmm2 + 123] {k1}, ymm20
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa1,0xa4,0xd6,0x7b,0x00,0x00,0x00]
+          vpscatterqd ZMMWORD PTR [r14+zmm2*8+0x7b]{k1},ymm20
+
+// CHECK: vpscatterqd zmmword ptr [r9 + zmm2 + 256] {k1}, ymm20
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa1,0x64,0x11,0x40]
+          vpscatterqd ZMMWORD PTR [r9+zmm2*1+0x100]{k1},ymm20
+
+// CHECK: vpscatterqd zmmword ptr [rcx + 4*zmm2 + 1024] {k1}, ymm20
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x49,0xa1,0xa4,0x91,0x00,0x04,0x00,0x00]
+          vpscatterqd ZMMWORD PTR [rcx+zmm2*4+0x400]{k1},ymm20
+
+// CHECK: vpscatterqq zmmword ptr [r14 + 8*zmm20 + 123] {k1}, zmm14
+// CHECK:  encoding: [0x62,0x52,0xfd,0x41,0xa1,0xb4,0xe6,0x7b,0x00,0x00,0x00]
+          vpscatterqq ZMMWORD PTR [r14+zmm20*8+0x7b]{k1},zmm14
+
+// CHECK: vpscatterqq zmmword ptr [r14 + 8*zmm20 + 123] {k1}, zmm14
+// CHECK:  encoding: [0x62,0x52,0xfd,0x41,0xa1,0xb4,0xe6,0x7b,0x00,0x00,0x00]
+          vpscatterqq ZMMWORD PTR [r14+zmm20*8+0x7b]{k1},zmm14
+
+// CHECK: vpscatterqq zmmword ptr [r9 + zmm20 + 256] {k1}, zmm14
+// CHECK:  encoding: [0x62,0x52,0xfd,0x41,0xa1,0x74,0x21,0x20]
+          vpscatterqq ZMMWORD PTR [r9+zmm20*1+0x100]{k1},zmm14
+
+// CHECK: vpscatterqq zmmword ptr [rcx + 4*zmm20 + 1024] {k1}, zmm14
+// CHECK:  encoding: [0x62,0x72,0xfd,0x41,0xa1,0xb4,0xa1,0x00,0x04,0x00,0x00]
+          vpscatterqq ZMMWORD PTR [rcx+zmm20*4+0x400]{k1},zmm14
+
+// CHECK: vscatterdpd zmmword ptr [r14 + 8*ymm24 + 123] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x94,0xc6,0x7b,0x00,0x00,0x00]
+          vscatterdpd ZMMWORD PTR [r14+ymm24*8+0x7b]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [r14 + 8*ymm24 + 123] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x94,0xc6,0x7b,0x00,0x00,0x00]
+          vscatterdpd ZMMWORD PTR [r14+ymm24*8+0x7b]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [r9 + ymm24 + 256] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x54,0x01,0x20]
+          vscatterdpd ZMMWORD PTR [r9+ymm24*1+0x100]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [rcx + 4*ymm24 + 1024] {k1}, zmm18
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x41,0xa2,0x94,0x81,0x00,0x04,0x00,0x00]
+          vscatterdpd ZMMWORD PTR [rcx+ymm24*4+0x400]{k1},zmm18
+
+// CHECK: vscatterdps zmmword ptr [r14 + 8*zmm19 + 123] {k1}, zmm17
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa2,0x8c,0xde,0x7b,0x00,0x00,0x00]
+          vscatterdps ZMMWORD PTR [r14+zmm19*8+0x7b]{k1},zmm17
+
+// CHECK: vscatterdps zmmword ptr [r14 + 8*zmm19 + 123] {k1}, zmm17
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa2,0x8c,0xde,0x7b,0x00,0x00,0x00]
+          vscatterdps ZMMWORD PTR [r14+zmm19*8+0x7b]{k1},zmm17
+
+// CHECK: vscatterdps zmmword ptr [r9 + zmm19 + 256] {k1}, zmm17
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa2,0x4c,0x19,0x40]
+          vscatterdps ZMMWORD PTR [r9+zmm19*1+0x100]{k1},zmm17
+
+// CHECK: vscatterdps zmmword ptr [rcx + 4*zmm19 + 1024] {k1}, zmm17
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x41,0xa2,0x8c,0x99,0x00,0x04,0x00,0x00]
+          vscatterdps ZMMWORD PTR [rcx+zmm19*4+0x400]{k1},zmm17
+
+// CHECK: vscatterqpd zmmword ptr [r14 + 8*zmm28 + 123] {k1}, zmm22
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa3,0xb4,0xe6,0x7b,0x00,0x00,0x00]
+          vscatterqpd ZMMWORD PTR [r14+zmm28*8+0x7b]{k1},zmm22
+
+// CHECK: vscatterqpd zmmword ptr [r14 + 8*zmm28 + 123] {k1}, zmm22
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa3,0xb4,0xe6,0x7b,0x00,0x00,0x00]
+          vscatterqpd ZMMWORD PTR [r14+zmm28*8+0x7b]{k1},zmm22
+
+// CHECK: vscatterqpd zmmword ptr [r9 + zmm28 + 256] {k1}, zmm22
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa3,0x74,0x21,0x20]
+          vscatterqpd ZMMWORD PTR [r9+zmm28*1+0x100]{k1},zmm22
+
+// CHECK: vscatterqpd zmmword ptr [rcx + 4*zmm28 + 1024] {k1}, zmm22
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x41,0xa3,0xb4,0xa1,0x00,0x04,0x00,0x00]
+          vscatterqpd ZMMWORD PTR [rcx+zmm28*4+0x400]{k1},zmm22
+
+// CHECK: vscatterqps zmmword ptr [r14 + 8*zmm27 + 123] {k1}, ymm6
+// CHECK:  encoding: [0x62,0x92,0x7d,0x41,0xa3,0xb4,0xde,0x7b,0x00,0x00,0x00]
+          vscatterqps ZMMWORD PTR [r14+zmm27*8+0x7b]{k1},ymm6
+
+// CHECK: vscatterqps zmmword ptr [r14 + 8*zmm27 + 123] {k1}, ymm6
+// CHECK:  encoding: [0x62,0x92,0x7d,0x41,0xa3,0xb4,0xde,0x7b,0x00,0x00,0x00]
+          vscatterqps ZMMWORD PTR [r14+zmm27*8+0x7b]{k1},ymm6
+
+// CHECK: vscatterqps zmmword ptr [r9 + zmm27 + 256] {k1}, ymm6
+// CHECK:  encoding: [0x62,0x92,0x7d,0x41,0xa3,0x74,0x19,0x40]
+          vscatterqps ZMMWORD PTR [r9+zmm27*1+0x100]{k1},ymm6
+
+// CHECK: vscatterqps zmmword ptr [rcx + 4*zmm27 + 1024] {k1}, ymm6
+// CHECK:  encoding: [0x62,0xb2,0x7d,0x41,0xa3,0xb4,0x99,0x00,0x04,0x00,0x00]
+          vscatterqps ZMMWORD PTR [rcx+zmm27*4+0x400]{k1},ymm6
+
+// CHECK: vscatterdpd zmmword ptr [r14 + 8*ymm27 - 123] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x94,0xde,0x85,0xff,0xff,0xff]
+          vscatterdpd ZMMWORD PTR [r14+ymm27*8-0x7b]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [r14 + 8*ymm27 - 123] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x94,0xde,0x85,0xff,0xff,0xff]
+          vscatterdpd ZMMWORD PTR [r14+ymm27*8-0x7b]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [r9 + ymm27 + 256] {k1}, zmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x41,0xa2,0x54,0x19,0x20]
+          vscatterdpd ZMMWORD PTR [r9+ymm27*1+0x100]{k1},zmm18
+
+// CHECK: vscatterdpd zmmword ptr [rcx + 4*ymm27 + 1024] {k1}, zmm18
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x41,0xa2,0x94,0x99,0x00,0x04,0x00,0x00]
+          vscatterdpd ZMMWORD PTR [rcx+ymm27*4+0x400]{k1},zmm18
+
+// CHECK: vscatterdps zmmword ptr [r14 + 8*zmm17 - 123] {k1}, zmm1
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0xa2,0x8c,0xce,0x85,0xff,0xff,0xff]
+          vscatterdps ZMMWORD PTR [r14+zmm17*8-0x7b]{k1},zmm1
+
+// CHECK: vscatterdps zmmword ptr [r14 + 8*zmm17 - 123] {k1}, zmm1
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0xa2,0x8c,0xce,0x85,0xff,0xff,0xff]
+          vscatterdps ZMMWORD PTR [r14+zmm17*8-0x7b]{k1},zmm1
+
+// CHECK: vscatterdps zmmword ptr [r9 + zmm17 + 256] {k1}, zmm1
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0xa2,0x4c,0x09,0x40]
+          vscatterdps ZMMWORD PTR [r9+zmm17*1+0x100]{k1},zmm1
+
+// CHECK: vscatterdps zmmword ptr [rcx + 4*zmm17 + 1024] {k1}, zmm1
+// CHECK:  encoding: [0x62,0xf2,0x7d,0x41,0xa2,0x8c,0x89,0x00,0x04,0x00,0x00]
+          vscatterdps ZMMWORD PTR [rcx+zmm17*4+0x400]{k1},zmm1
+
+// CHECK: vscatterqpd zmmword ptr [r14 + 8*zmm25 - 123] {k1}, zmm8
+// CHECK:  encoding: [0x62,0x12,0xfd,0x41,0xa3,0x84,0xce,0x85,0xff,0xff,0xff]
+          vscatterqpd ZMMWORD PTR [r14+zmm25*8-0x7b]{k1},zmm8
+
+// CHECK: vscatterqpd zmmword ptr [r14 + 8*zmm25 - 123] {k1}, zmm8
+// CHECK:  encoding: [0x62,0x12,0xfd,0x41,0xa3,0x84,0xce,0x85,0xff,0xff,0xff]
+          vscatterqpd ZMMWORD PTR [r14+zmm25*8-0x7b]{k1},zmm8
+
+// CHECK: vscatterqpd zmmword ptr [r9 + zmm25 + 256] {k1}, zmm8
+// CHECK:  encoding: [0x62,0x12,0xfd,0x41,0xa3,0x44,0x09,0x20]
+          vscatterqpd ZMMWORD PTR [r9+zmm25*1+0x100]{k1},zmm8
+
+// CHECK: vscatterqpd zmmword ptr [rcx + 4*zmm25 + 1024] {k1}, zmm8
+// CHECK:  encoding: [0x62,0x32,0xfd,0x41,0xa3,0x84,0x89,0x00,0x04,0x00,0x00]
+          vscatterqpd ZMMWORD PTR [rcx+zmm25*4+0x400]{k1},zmm8
+
+// CHECK: vscatterqps zmmword ptr [r14 + 8*zmm10 - 123] {k1}, ymm13
+// CHECK:  encoding: [0x62,0x12,0x7d,0x49,0xa3,0xac,0xd6,0x85,0xff,0xff,0xff]
+          vscatterqps ZMMWORD PTR [r14+zmm10*8-0x7b]{k1},ymm13
+
+// CHECK: vscatterqps zmmword ptr [r14 + 8*zmm10 - 123] {k1}, ymm13
+// CHECK:  encoding: [0x62,0x12,0x7d,0x49,0xa3,0xac,0xd6,0x85,0xff,0xff,0xff]
+          vscatterqps ZMMWORD PTR [r14+zmm10*8-0x7b]{k1},ymm13
+
+// CHECK: vscatterqps zmmword ptr [r9 + zmm10 + 256] {k1}, ymm13
+// CHECK:  encoding: [0x62,0x12,0x7d,0x49,0xa3,0x6c,0x11,0x40]
+          vscatterqps ZMMWORD PTR [r9+zmm10*1+0x100]{k1},ymm13
+
+// CHECK: vscatterqps zmmword ptr [rcx + 4*zmm10 + 1024] {k1}, ymm13
+// CHECK:  encoding: [0x62,0x32,0x7d,0x49,0xa3,0xac,0x91,0x00,0x04,0x00,0x00]
+          vscatterqps ZMMWORD PTR [rcx+zmm10*4+0x400]{k1},ymm13
+
+// CHECK: vgatherdpd zmm30 {k1}, zmmword ptr [r14 + 8*ymm5 - 123]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x92,0xb4,0xee,0x85,0xff,0xff,0xff]
+          vgatherdpd zmm30{k1},ZMMWORD PTR [r14+ymm5*8-0x7b]
+
+// CHECK: vgatherdpd zmm30 {k1}, zmmword ptr [r9 + ymm5 + 256]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x92,0x74,0x29,0x20]
+          vgatherdpd zmm30{k1},ZMMWORD PTR [r9+ymm5*1+0x100]
+
+// CHECK: vgatherdpd zmm30 {k1}, zmmword ptr [rcx + 4*ymm5 + 1024]
+// CHECK:  encoding: [0x62,0x62,0xfd,0x49,0x92,0xb4,0xa9,0x00,0x04,0x00,0x00]
+          vgatherdpd zmm30{k1},ZMMWORD PTR [rcx+ymm5*4+0x400]
+
+// CHECK: vgatherdps zmm8 {k1}, zmmword ptr [r14 + 8*zmm26 - 123]
+// CHECK:  encoding: [0x62,0x12,0x7d,0x41,0x92,0x84,0xd6,0x85,0xff,0xff,0xff]
+          vgatherdps zmm8{k1},ZMMWORD PTR [r14+zmm26*8-0x7b]
+
+// CHECK: vgatherdps zmm8 {k1}, zmmword ptr [r9 + zmm26 + 256]
+// CHECK:  encoding: [0x62,0x12,0x7d,0x41,0x92,0x44,0x11,0x40]
+          vgatherdps zmm8{k1},ZMMWORD PTR [r9+zmm26*1+0x100]
+
+// CHECK: vgatherdps zmm8 {k1}, zmmword ptr [rcx + 4*zmm26 + 1024]
+// CHECK:  encoding: [0x62,0x32,0x7d,0x41,0x92,0x84,0x91,0x00,0x04,0x00,0x00]
+          vgatherdps zmm8{k1},ZMMWORD PTR [rcx+zmm26*4+0x400]
+
+// CHECK: vgatherqpd zmm27 {k1}, zmmword ptr [r14 + 8*zmm13 - 123]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x49,0x93,0x9c,0xee,0x85,0xff,0xff,0xff]
+          vgatherqpd zmm27{k1},ZMMWORD PTR [r14+zmm13*8-0x7b]
+
+// CHECK: vgatherqpd zmm27 {k1}, zmmword ptr [r9 + zmm13 + 256]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x49,0x93,0x5c,0x29,0x20]
+          vgatherqpd zmm27{k1},ZMMWORD PTR [r9+zmm13*1+0x100]
+
+// CHECK: vgatherqpd zmm27 {k1}, zmmword ptr [rcx + 4*zmm13 + 1024]
+// CHECK:  encoding: [0x62,0x22,0xfd,0x49,0x93,0x9c,0xa9,0x00,0x04,0x00,0x00]
+          vgatherqpd zmm27{k1},ZMMWORD PTR [rcx+zmm13*4+0x400]
+
+// CHECK: vgatherqps ymm27 {k1}, zmmword ptr [r14 + 8*zmm14 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x49,0x93,0x9c,0xf6,0x85,0xff,0xff,0xff]
+          vgatherqps ymm27{k1},ZMMWORD PTR [r14+zmm14*8-0x7b]
+
+// CHECK: vgatherqps ymm27 {k1}, zmmword ptr [r9 + zmm14 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x49,0x93,0x5c,0x31,0x40]
+          vgatherqps ymm27{k1},ZMMWORD PTR [r9+zmm14*1+0x100]
+
+// CHECK: vgatherqps ymm27 {k1}, zmmword ptr [rcx + 4*zmm14 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x49,0x93,0x9c,0xb1,0x00,0x04,0x00,0x00]
+          vgatherqps ymm27{k1},ZMMWORD PTR [rcx+zmm14*4+0x400]
+
+// CHECK: vpgatherdd zmm7 {k1}, zmmword ptr [r14 + 8*zmm16 - 123]
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0x90,0xbc,0xc6,0x85,0xff,0xff,0xff]
+          vpgatherdd zmm7{k1},ZMMWORD PTR [r14+zmm16*8-0x7b]
+
+// CHECK: vpgatherdd zmm7 {k1}, zmmword ptr [r9 + zmm16 + 256]
+// CHECK:  encoding: [0x62,0xd2,0x7d,0x41,0x90,0x7c,0x01,0x40]
+          vpgatherdd zmm7{k1},ZMMWORD PTR [r9+zmm16*1+0x100]
+
+// CHECK: vpgatherdd zmm7 {k1}, zmmword ptr [rcx + 4*zmm16 + 1024]
+// CHECK:  encoding: [0x62,0xf2,0x7d,0x41,0x90,0xbc,0x81,0x00,0x04,0x00,0x00]
+          vpgatherdd zmm7{k1},ZMMWORD PTR [rcx+zmm16*4+0x400]
+
+// CHECK: vpgatherdq zmm25 {k1}, zmmword ptr [r14 + 8*ymm7 - 123]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x90,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherdq zmm25{k1},ZMMWORD PTR [r14+ymm7*8-0x7b]
+
+// CHECK: vpgatherdq zmm25 {k1}, zmmword ptr [r9 + ymm7 + 256]
+// CHECK:  encoding: [0x62,0x42,0xfd,0x49,0x90,0x4c,0x39,0x20]
+          vpgatherdq zmm25{k1},ZMMWORD PTR [r9+ymm7*1+0x100]
+
+// CHECK: vpgatherdq zmm25 {k1}, zmmword ptr [rcx + 4*ymm7 + 1024]
+// CHECK:  encoding: [0x62,0x62,0xfd,0x49,0x90,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdq zmm25{k1},ZMMWORD PTR [rcx+ymm7*4+0x400]
+
+// CHECK: vpgatherqd ymm19 {k1}, zmmword ptr [r14 + 8*zmm17 - 123]
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0x91,0x9c,0xce,0x85,0xff,0xff,0xff]
+          vpgatherqd ymm19{k1},ZMMWORD PTR [r14+zmm17*8-0x7b]
+
+// CHECK: vpgatherqd ymm19 {k1}, zmmword ptr [r9 + zmm17 + 256]
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0x91,0x5c,0x09,0x40]
+          vpgatherqd ymm19{k1},ZMMWORD PTR [r9+zmm17*1+0x100]
+
+// CHECK: vpgatherqd ymm19 {k1}, zmmword ptr [rcx + 4*zmm17 + 1024]
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x41,0x91,0x9c,0x89,0x00,0x04,0x00,0x00]
+          vpgatherqd ymm19{k1},ZMMWORD PTR [rcx+zmm17*4+0x400]
+
+// CHECK: vpgatherqq zmm10 {k1}, zmmword ptr [r14 + 8*zmm13 - 123]
+// CHECK:  encoding: [0x62,0x12,0xfd,0x49,0x91,0x94,0xee,0x85,0xff,0xff,0xff]
+          vpgatherqq zmm10{k1},ZMMWORD PTR [r14+zmm13*8-0x7b]
+
+// CHECK: vpgatherqq zmm10 {k1}, zmmword ptr [r9 + zmm13 + 256]
+// CHECK:  encoding: [0x62,0x12,0xfd,0x49,0x91,0x54,0x29,0x20]
+          vpgatherqq zmm10{k1},ZMMWORD PTR [r9+zmm13*1+0x100]
+
+// CHECK: vpgatherqq zmm10 {k1}, zmmword ptr [rcx + 4*zmm13 + 1024]
+// CHECK:  encoding: [0x62,0x32,0xfd,0x49,0x91,0x94,0xa9,0x00,0x04,0x00,0x00]
+          vpgatherqq zmm10{k1},ZMMWORD PTR [rcx+zmm13*4+0x400]
+
+// CHECK: vpscatterdd zmmword ptr [r14 + 8*zmm4 - 123] {k1}, zmm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa0,0xbc,0xe6,0x85,0xff,0xff,0xff]
+          vpscatterdd ZMMWORD PTR [r14+zmm4*8-0x7b]{k1},zmm23
+
+// CHECK: vpscatterdd zmmword ptr [r14 + 8*zmm4 - 123] {k1}, zmm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa0,0xbc,0xe6,0x85,0xff,0xff,0xff]
+          vpscatterdd ZMMWORD PTR [r14+zmm4*8-0x7b]{k1},zmm23
+
+// CHECK: vpscatterdd zmmword ptr [r9 + zmm4 + 256] {k1}, zmm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x49,0xa0,0x7c,0x21,0x40]
+          vpscatterdd ZMMWORD PTR [r9+zmm4*1+0x100]{k1},zmm23
+
+// CHECK: vpscatterdd zmmword ptr [rcx + 4*zmm4 + 1024] {k1}, zmm23
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x49,0xa0,0xbc,0xa1,0x00,0x04,0x00,0x00]
+          vpscatterdd ZMMWORD PTR [rcx+zmm4*4+0x400]{k1},zmm23
+
+// CHECK: vpscatterdq zmmword ptr [r14 + 8*ymm25 - 123] {k1}, zmm1
+// CHECK:  encoding: [0x62,0x92,0xfd,0x41,0xa0,0x8c,0xce,0x85,0xff,0xff,0xff]
+          vpscatterdq ZMMWORD PTR [r14+ymm25*8-0x7b]{k1},zmm1
+
+// CHECK: vpscatterdq zmmword ptr [r14 + 8*ymm25 - 123] {k1}, zmm1
+// CHECK:  encoding: [0x62,0x92,0xfd,0x41,0xa0,0x8c,0xce,0x85,0xff,0xff,0xff]
+          vpscatterdq ZMMWORD PTR [r14+ymm25*8-0x7b]{k1},zmm1
+
+// CHECK: vpscatterdq zmmword ptr [r9 + ymm25 + 256] {k1}, zmm1
+// CHECK:  encoding: [0x62,0x92,0xfd,0x41,0xa0,0x4c,0x09,0x20]
+          vpscatterdq ZMMWORD PTR [r9+ymm25*1+0x100]{k1},zmm1
+
+// CHECK: vpscatterdq zmmword ptr [rcx + 4*ymm25 + 1024] {k1}, zmm1
+// CHECK:  encoding: [0x62,0xb2,0xfd,0x41,0xa0,0x8c,0x89,0x00,0x04,0x00,0x00]
+          vpscatterdq ZMMWORD PTR [rcx+ymm25*4+0x400]{k1},zmm1
+
+// CHECK: vpscatterqd zmmword ptr [r14 + 8*zmm22 - 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa1,0xbc,0xf6,0x85,0xff,0xff,0xff]
+          vpscatterqd ZMMWORD PTR [r14+zmm22*8-0x7b]{k1},ymm23
+
+// CHECK: vpscatterqd zmmword ptr [r14 + 8*zmm22 - 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa1,0xbc,0xf6,0x85,0xff,0xff,0xff]
+          vpscatterqd ZMMWORD PTR [r14+zmm22*8-0x7b]{k1},ymm23
+
+// CHECK: vpscatterqd zmmword ptr [r9 + zmm22 + 256] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xc2,0x7d,0x41,0xa1,0x7c,0x31,0x40]
+          vpscatterqd ZMMWORD PTR [r9+zmm22*1+0x100]{k1},ymm23
+
+// CHECK: vpscatterqd zmmword ptr [rcx + 4*zmm22 + 1024] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xe2,0x7d,0x41,0xa1,0xbc,0xb1,0x00,0x04,0x00,0x00]
+          vpscatterqd ZMMWORD PTR [rcx+zmm22*4+0x400]{k1},ymm23
+
+// CHECK: vpscatterqq zmmword ptr [r14 + 8*zmm8 - 123] {k1}, zmm2
+// CHECK:  encoding: [0x62,0x92,0xfd,0x49,0xa1,0x94,0xc6,0x85,0xff,0xff,0xff]
+          vpscatterqq ZMMWORD PTR [r14+zmm8*8-0x7b]{k1},zmm2
+
+// CHECK: vpscatterqq zmmword ptr [r14 + 8*zmm8 - 123] {k1}, zmm2
+// CHECK:  encoding: [0x62,0x92,0xfd,0x49,0xa1,0x94,0xc6,0x85,0xff,0xff,0xff]
+          vpscatterqq ZMMWORD PTR [r14+zmm8*8-0x7b]{k1},zmm2
+
+// CHECK: vpscatterqq zmmword ptr [r9 + zmm8 + 256] {k1}, zmm2
+// CHECK:  encoding: [0x62,0x92,0xfd,0x49,0xa1,0x54,0x01,0x20]
+          vpscatterqq ZMMWORD PTR [r9+zmm8*1+0x100]{k1},zmm2
+
+// CHECK: vpscatterqq zmmword ptr [rcx + 4*zmm8 + 1024] {k1}, zmm2
+// CHECK:  encoding: [0x62,0xb2,0xfd,0x49,0xa1,0x94,0x81,0x00,0x04,0x00,0x00]
+          vpscatterqq ZMMWORD PTR [rcx+zmm8*4+0x400]{k1},zmm2

test/MC/X86/intel-syntax-x86-64-avx512f_vl.s

 
 // CHECK:  vcmpps k4, ymm19, dword ptr [rdx - 512]{1to8}, 123
 // CHECK:  encoding: [0x62,0xf1,0x64,0x30,0xc2,0x62,0x80,0x7b]
           vcmpps k4,ymm19,DWORD PTR [rdx-0x200]{1to8},0x7b
 
 // CHECK:  vcmpps k4, ymm19, dword ptr [rdx - 516]{1to8}, 123
 // CHECK:  encoding: [0x62,0xf1,0x64,0x30,0xc2,0xa2,0xfc,0xfd,0xff,0xff,0x7b]
           vcmpps k4,ymm19,DWORD PTR [rdx-0x204]{1to8},0x7b
+
+// CHECK: vgatherdpd xmm17 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x92,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherdpd xmm17{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vgatherdpd xmm17 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x92,0x4c,0x39,0x20]
+          vgatherdpd xmm17{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdpd xmm17 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x92,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdpd xmm17{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdpd ymm23 {k1}, ymmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x92,0xbc,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherdpd ymm23{k1},YMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vgatherdpd ymm23 {k1}, ymmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x92,0x7c,0x39,0x20]
+          vgatherdpd ymm23{k1},YMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdpd ymm23 {k1}, ymmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0x92,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdpd ymm23{k1},YMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdpd xmm23 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x92,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vgatherdpd xmm23{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vgatherdpd xmm23 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x92,0x7c,0x39,0x20]
+          vgatherdpd xmm23{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdpd xmm23 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x92,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdpd xmm23{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdpd ymm18 {k1}, ymmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x92,0x94,0xfe,0x85,0xff,0xff,0xff]
+          vgatherdpd ymm18{k1},YMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vgatherdpd ymm18 {k1}, ymmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x92,0x54,0x39,0x20]
+          vgatherdpd ymm18{k1},YMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdpd ymm18 {k1}, ymmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0x92,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdpd ymm18{k1},YMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdps xmm18 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x92,0x94,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherdps xmm18{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vgatherdps xmm18 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x92,0x54,0x39,0x40]
+          vgatherdps xmm18{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdps xmm18 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x92,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdps xmm18{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdps ymm27 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x92,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherdps ymm27{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vgatherdps ymm27 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x92,0x5c,0x39,0x40]
+          vgatherdps ymm27{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherdps ymm27 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0x92,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdps ymm27{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vgatherdps xmm29 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0x92,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vgatherdps xmm29{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vgatherdps xmm29 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0x92,0x6c,0x39,0x40]
+          vgatherdps xmm29{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherdps xmm29 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0x92,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdps xmm29{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherdps ymm21 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x92,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vgatherdps ymm21{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vgatherdps ymm21 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x92,0x6c,0x39,0x40]
+          vgatherdps ymm21{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherdps ymm21 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x21,0x92,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherdps ymm21{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vgatherqpd xmm17 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x93,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqpd xmm17{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vgatherqpd xmm17 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x93,0x4c,0x39,0x20]
+          vgatherqpd xmm17{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherqpd xmm17 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x93,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqpd xmm17{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherqpd ymm29 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x93,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqpd ymm29{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vgatherqpd ymm29 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x93,0x6c,0x39,0x20]
+          vgatherqpd ymm29{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherqpd ymm29 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0x93,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqpd ymm29{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vgatherqpd xmm18 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x93,0x94,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqpd xmm18{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vgatherqpd xmm18 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x93,0x54,0x39,0x20]
+          vgatherqpd xmm18{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherqpd xmm18 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x93,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqpd xmm18{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherqpd ymm21 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x93,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqpd ymm21{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vgatherqpd ymm21 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x93,0x6c,0x39,0x20]
+          vgatherqpd ymm21{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherqpd ymm21 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0x93,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqpd ymm21{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vgatherqps xmm21 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x93,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqps xmm21{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vgatherqps xmm21 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x93,0x6c,0x39,0x40]
+          vgatherqps xmm21{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherqps xmm21 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x93,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps xmm21{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherqps xmm19 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x93,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqps xmm19{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vgatherqps xmm19 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x93,0x5c,0x39,0x40]
+          vgatherqps xmm19{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherqps xmm19 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x21,0x93,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps xmm19{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vgatherqps xmm22 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x93,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqps xmm22{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vgatherqps xmm22 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x93,0x74,0x39,0x40]
+          vgatherqps xmm22{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vgatherqps xmm22 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x93,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps xmm22{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vgatherqps xmm30 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x93,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqps xmm30{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vgatherqps xmm30 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x93,0x74,0x39,0x40]
+          vgatherqps xmm30{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vgatherqps xmm30 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0x93,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps xmm30{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherdd xmm17 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x90,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherdd xmm17{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vpgatherdd xmm17 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x90,0x4c,0x39,0x40]
+          vpgatherdd xmm17{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdd xmm17 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x90,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdd xmm17{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherdd ymm19 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x90,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherdd ymm19{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vpgatherdd ymm19 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0x90,0x5c,0x39,0x40]
+          vpgatherdd ymm19{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherdd ymm19 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x21,0x90,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdd ymm19{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherdd xmm22 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x90,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherdd xmm22{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vpgatherdd xmm22 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x90,0x74,0x39,0x40]
+          vpgatherdd xmm22{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdd xmm22 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x90,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdd xmm22{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherdd ymm29 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x90,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherdd ymm29{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vpgatherdd ymm29 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x90,0x6c,0x39,0x40]
+          vpgatherdd ymm29{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherdd ymm29 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0x90,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdd ymm29{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherdq xmm17 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x90,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherdq xmm17{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vpgatherdq xmm17 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x90,0x4c,0x39,0x20]
+          vpgatherdq xmm17{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdq xmm17 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x90,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdq xmm17{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherdq ymm26 {k1}, ymmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x90,0x94,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherdq ymm26{k1},YMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vpgatherdq ymm26 {k1}, ymmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x90,0x54,0x39,0x20]
+          vpgatherdq ymm26{k1},YMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdq ymm26 {k1}, ymmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0x90,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdq ymm26{k1},YMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherdq xmm25 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0x90,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherdq xmm25{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vpgatherdq xmm25 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0x90,0x4c,0x39,0x20]
+          vpgatherdq xmm25{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdq xmm25 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0xfd,0x01,0x90,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdq xmm25{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherdq ymm22 {k1}, ymmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x90,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherdq ymm22{k1},YMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vpgatherdq ymm22 {k1}, ymmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x90,0x74,0x39,0x20]
+          vpgatherdq ymm22{k1},YMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherdq ymm22 {k1}, ymmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0x90,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherdq ymm22{k1},YMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherqd xmm21 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x91,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqd xmm21{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vpgatherqd xmm21 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0x91,0x6c,0x39,0x40]
+          vpgatherqd xmm21{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherqd xmm21 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0x91,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd xmm21{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherqd xmm25 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x91,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqd xmm25{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vpgatherqd xmm25 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x91,0x4c,0x39,0x40]
+          vpgatherqd xmm25{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherqd xmm25 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0x91,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd xmm25{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherqd xmm30 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0x91,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqd xmm30{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vpgatherqd xmm30 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0x91,0x74,0x39,0x40]
+          vpgatherqd xmm30{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherqd xmm30 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0x91,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd xmm30{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherqd xmm28 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x91,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqd xmm28{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vpgatherqd xmm28 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0x91,0x64,0x39,0x40]
+          vpgatherqd xmm28{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherqd xmm28 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0x91,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd xmm28{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherqq xmm18 {k1}, xmmword ptr [r14 + 8*xmm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x91,0x94,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqq xmm18{k1},XMMWORD PTR [r14+xmm31*8+0x7b]
+
+// CHECK: vpgatherqq xmm18 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x91,0x54,0x39,0x20]
+          vpgatherqq xmm18{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherqq xmm18 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x91,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqq xmm18{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherqq ymm19 {k1}, ymmword ptr [r14 + 8*ymm31 + 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x91,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqq ymm19{k1},YMMWORD PTR [r14+ymm31*8+0x7b]
+
+// CHECK: vpgatherqq ymm19 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0x91,0x5c,0x39,0x20]
+          vpgatherqq ymm19{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherqq ymm19 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0x91,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqq ymm19{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpgatherqq xmm23 {k1}, xmmword ptr [r14 + 8*xmm31 - 123]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x91,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqq xmm23{k1},XMMWORD PTR [r14+xmm31*8-0x7b]
+
+// CHECK: vpgatherqq xmm23 {k1}, xmmword ptr [r9 + xmm31 + 256]
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0x91,0x7c,0x39,0x20]
+          vpgatherqq xmm23{k1},XMMWORD PTR [r9+xmm31*1+0x100]
+
+// CHECK: vpgatherqq xmm23 {k1}, xmmword ptr [rcx + 4*xmm31 + 1024]
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0x91,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqq xmm23{k1},XMMWORD PTR [rcx+xmm31*4+0x400]
+
+// CHECK: vpgatherqq ymm26 {k1}, ymmword ptr [r14 + 8*ymm31 - 123]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x91,0x94,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqq ymm26{k1},YMMWORD PTR [r14+ymm31*8-0x7b]
+
+// CHECK: vpgatherqq ymm26 {k1}, ymmword ptr [r9 + ymm31 + 256]
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0x91,0x54,0x39,0x20]
+          vpgatherqq ymm26{k1},YMMWORD PTR [r9+ymm31*1+0x100]
+
+// CHECK: vpgatherqq ymm26 {k1}, ymmword ptr [rcx + 4*ymm31 + 1024]
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0x91,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqq ymm26{k1},YMMWORD PTR [rcx+ymm31*4+0x400]
+
+// CHECK: vpscatterdd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm20
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm20
+
+// CHECK: vpscatterdd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm20
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm20
+
+// CHECK: vpscatterdd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm20
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0x64,0x39,0x40]
+          vpscatterdd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm20
+
+// CHECK: vpscatterdd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm20
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0xa0,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm20
+
+// CHECK: vpscatterdd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm28
+
+// CHECK: vpscatterdd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm28
+
+// CHECK: vpscatterdd ymmword ptr [r9 + ymm31 + 256] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0x64,0x39,0x40]
+          vpscatterdd YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm28
+
+// CHECK: vpscatterdd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa0,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm28
+
+// CHECK: vpscatterdd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm17
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm17
+
+// CHECK: vpscatterdd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm17
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm17
+
+// CHECK: vpscatterdd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm17
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa0,0x4c,0x39,0x40]
+          vpscatterdd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm17
+
+// CHECK: vpscatterdd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm17
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0xa0,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm17
+
+// CHECK: vpscatterdd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0x84,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm24
+
+// CHECK: vpscatterdd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0x84,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm24
+
+// CHECK: vpscatterdd ymmword ptr [r9 + ymm31 + 256] {k1}, ymm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa0,0x44,0x39,0x40]
+          vpscatterdd YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm24
+
+// CHECK: vpscatterdd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm24
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa0,0x84,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm24
+
+// CHECK: vpscatterdq xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa0,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdq XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm21
+
+// CHECK: vpscatterdq xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa0,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdq XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm21
+
+// CHECK: vpscatterdq xmmword ptr [r9 + xmm31 + 256] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa0,0x6c,0x39,0x20]
+          vpscatterdq XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm21
+
+// CHECK: vpscatterdq xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm21
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0xa0,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdq XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm21
+
+// CHECK: vpscatterdq ymmword ptr [r14 + 8*xmm31 + 123] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdq YMMWORD PTR [r14+xmm31*8+0x7b]{k1},ymm28
+
+// CHECK: vpscatterdq ymmword ptr [r14 + 8*xmm31 + 123] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa0,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterdq YMMWORD PTR [r14+xmm31*8+0x7b]{k1},ymm28
+
+// CHECK: vpscatterdq ymmword ptr [r9 + xmm31 + 256] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa0,0x64,0x39,0x20]
+          vpscatterdq YMMWORD PTR [r9+xmm31*1+0x100]{k1},ymm28
+
+// CHECK: vpscatterdq ymmword ptr [rcx + 4*xmm31 + 1024] {k1}, ymm28
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0xa0,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdq YMMWORD PTR [rcx+xmm31*4+0x400]{k1},ymm28
+
+// CHECK: vpscatterdq xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa0,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdq XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm28
+
+// CHECK: vpscatterdq xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa0,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdq XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm28
+
+// CHECK: vpscatterdq xmmword ptr [r9 + xmm31 + 256] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa0,0x64,0x39,0x20]
+          vpscatterdq XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm28
+
+// CHECK: vpscatterdq xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x22,0xfd,0x01,0xa0,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdq XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm28
+
+// CHECK: vpscatterdq ymmword ptr [r14 + 8*xmm31 - 123] {k1}, ymm20
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa0,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdq YMMWORD PTR [r14+xmm31*8-0x7b]{k1},ymm20
+
+// CHECK: vpscatterdq ymmword ptr [r14 + 8*xmm31 - 123] {k1}, ymm20
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa0,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterdq YMMWORD PTR [r14+xmm31*8-0x7b]{k1},ymm20
+
+// CHECK: vpscatterdq ymmword ptr [r9 + xmm31 + 256] {k1}, ymm20
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa0,0x64,0x39,0x20]
+          vpscatterdq YMMWORD PTR [r9+xmm31*1+0x100]{k1},ymm20
+
+// CHECK: vpscatterdq ymmword ptr [rcx + 4*xmm31 + 1024] {k1}, ymm20
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0xa0,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterdq YMMWORD PTR [rcx+xmm31*4+0x400]{k1},ymm20
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0x74,0x39,0x40]
+          vpscatterqd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0xa1,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm22
+
+// CHECK: vpscatterqd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},xmm24
+
+// CHECK: vpscatterqd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},xmm24
+
+// CHECK: vpscatterqd ymmword ptr [r9 + ymm31 + 256] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0x44,0x39,0x40]
+          vpscatterqd YMMWORD PTR [r9+ymm31*1+0x100]{k1},xmm24
+
+// CHECK: vpscatterqd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa1,0x84,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},xmm24
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm22
+// CHECK:  encoding: [0x62,0x82,0x7d,0x01,0xa1,0x74,0x39,0x40]
+          vpscatterqd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm22
+
+// CHECK: vpscatterqd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x01,0xa1,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm22
+
+// CHECK: vpscatterqd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},xmm29
+
+// CHECK: vpscatterqd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},xmm29
+
+// CHECK: vpscatterqd ymmword ptr [r9 + ymm31 + 256] {k1}, xmm29
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa1,0x6c,0x39,0x40]
+          vpscatterqd YMMWORD PTR [r9+ymm31*1+0x100]{k1},xmm29
+
+// CHECK: vpscatterqd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm29
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa1,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},xmm29
+
+// CHECK: vpscatterqq xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqq XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm28
+
+// CHECK: vpscatterqq xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqq XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm28
+
+// CHECK: vpscatterqq xmmword ptr [r9 + xmm31 + 256] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0x64,0x39,0x20]
+          vpscatterqq XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm28
+
+// CHECK: vpscatterqq xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x22,0xfd,0x01,0xa1,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqq XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm28
+
+// CHECK: vpscatterqq ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqq YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm19
+
+// CHECK: vpscatterqq ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqq YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm19
+
+// CHECK: vpscatterqq ymmword ptr [r9 + ymm31 + 256] {k1}, ymm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x5c,0x39,0x20]
+          vpscatterqq YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm19
+
+// CHECK: vpscatterqq ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm19
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0xa1,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqq YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm19
+
+// CHECK: vpscatterqq xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0x84,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqq XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm24
+
+// CHECK: vpscatterqq xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0x84,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqq XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm24
+
+// CHECK: vpscatterqq xmmword ptr [r9 + xmm31 + 256] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0xfd,0x01,0xa1,0x44,0x39,0x20]
+          vpscatterqq XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm24
+
+// CHECK: vpscatterqq xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x22,0xfd,0x01,0xa1,0x84,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqq XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm24
+
+// CHECK: vpscatterqq ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm17
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqq YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm17
+
+// CHECK: vpscatterqq ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm17
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqq YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm17
+
+// CHECK: vpscatterqq ymmword ptr [r9 + ymm31 + 256] {k1}, ymm17
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa1,0x4c,0x39,0x20]
+          vpscatterqq YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm17
+
+// CHECK: vpscatterqq ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm17
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0xa1,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqq YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm17
+
+// CHECK: vscatterdpd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x94,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdpd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm18
+
+// CHECK: vscatterdpd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x94,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdpd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm18
+
+// CHECK: vscatterdpd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm18
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x54,0x39,0x20]
+          vscatterdpd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm18
+
+// CHECK: vscatterdpd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm18
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0xa2,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdpd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm18
+
+// CHECK: vscatterdpd ymmword ptr [r14 + 8*xmm31 + 123] {k1}, ymm30
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdpd YMMWORD PTR [r14+xmm31*8+0x7b]{k1},ymm30
+
+// CHECK: vscatterdpd ymmword ptr [r14 + 8*xmm31 + 123] {k1}, ymm30
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdpd YMMWORD PTR [r14+xmm31*8+0x7b]{k1},ymm30
+
+// CHECK: vscatterdpd ymmword ptr [r9 + xmm31 + 256] {k1}, ymm30
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0x74,0x39,0x20]
+          vscatterdpd YMMWORD PTR [r9+xmm31*1+0x100]{k1},ymm30
+
+// CHECK: vscatterdpd ymmword ptr [rcx + 4*xmm31 + 1024] {k1}, ymm30
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0xa2,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdpd YMMWORD PTR [rcx+xmm31*4+0x400]{k1},ymm30
+
+// CHECK: vscatterdpd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdpd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm19
+
+// CHECK: vscatterdpd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdpd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm19
+
+// CHECK: vscatterdpd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa2,0x5c,0x39,0x20]
+          vscatterdpd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm19
+
+// CHECK: vscatterdpd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm19
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0xa2,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdpd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm19
+
+// CHECK: vscatterdpd ymmword ptr [r14 + 8*xmm31 - 123] {k1}, ymm26
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0x94,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdpd YMMWORD PTR [r14+xmm31*8-0x7b]{k1},ymm26
+
+// CHECK: vscatterdpd ymmword ptr [r14 + 8*xmm31 - 123] {k1}, ymm26
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0x94,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdpd YMMWORD PTR [r14+xmm31*8-0x7b]{k1},ymm26
+
+// CHECK: vscatterdpd ymmword ptr [r9 + xmm31 + 256] {k1}, ymm26
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa2,0x54,0x39,0x20]
+          vscatterdpd YMMWORD PTR [r9+xmm31*1+0x100]{k1},ymm26
+
+// CHECK: vscatterdpd ymmword ptr [rcx + 4*xmm31 + 1024] {k1}, ymm26
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0xa2,0x94,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdpd YMMWORD PTR [rcx+xmm31*4+0x400]{k1},ymm26
+
+// CHECK: vscatterdps xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdps XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm24
+
+// CHECK: vscatterdps xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdps XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm24
+
+// CHECK: vscatterdps xmmword ptr [r9 + xmm31 + 256] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0x44,0x39,0x40]
+          vscatterdps XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm24
+
+// CHECK: vscatterdps xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm24
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0xa2,0x84,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdps XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm24
+
+// CHECK: vscatterdps ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa2,0xbc,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdps YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm23
+
+// CHECK: vscatterdps ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa2,0xbc,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterdps YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm23
+
+// CHECK: vscatterdps ymmword ptr [r9 + ymm31 + 256] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa2,0x7c,0x39,0x40]
+          vscatterdps YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm23
+
+// CHECK: vscatterdps ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x21,0xa2,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdps YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm23
+
+// CHECK: vscatterdps xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdps XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm28
+
+// CHECK: vscatterdps xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdps XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm28
+
+// CHECK: vscatterdps xmmword ptr [r9 + xmm31 + 256] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa2,0x64,0x39,0x40]
+          vscatterdps XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm28
+
+// CHECK: vscatterdps xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0xa2,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdps XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm28
+
+// CHECK: vscatterdps ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa2,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdps YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm25
+
+// CHECK: vscatterdps ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa2,0x8c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterdps YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm25
+
+// CHECK: vscatterdps ymmword ptr [r9 + ymm31 + 256] {k1}, ymm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa2,0x4c,0x39,0x40]
+          vscatterdps YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm25
+
+// CHECK: vscatterdps ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm25
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa2,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterdps YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm25
+
+// CHECK: vscatterqpd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqpd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm21
+
+// CHECK: vscatterqpd xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqpd XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm21
+
+// CHECK: vscatterqpd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm21
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0x6c,0x39,0x20]
+          vscatterqpd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm21
+
+// CHECK: vscatterqpd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm21
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0xa3,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqpd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm21
+
+// CHECK: vscatterqpd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa3,0xbc,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqpd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm23
+
+// CHECK: vscatterqpd ymmword ptr [r14 + 8*ymm31 + 123] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa3,0xbc,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqpd YMMWORD PTR [r14+ymm31*8+0x7b]{k1},ymm23
+
+// CHECK: vscatterqpd ymmword ptr [r9 + ymm31 + 256] {k1}, ymm23
+// CHECK:  encoding: [0x62,0x82,0xfd,0x21,0xa3,0x7c,0x39,0x20]
+          vscatterqpd YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm23
+
+// CHECK: vscatterqpd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm23
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x21,0xa3,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqpd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm23
+
+// CHECK: vscatterqpd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqpd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm19
+
+// CHECK: vscatterqpd xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqpd XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm19
+
+// CHECK: vscatterqpd xmmword ptr [r9 + xmm31 + 256] {k1}, xmm19
+// CHECK:  encoding: [0x62,0x82,0xfd,0x01,0xa3,0x5c,0x39,0x20]
+          vscatterqpd XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm19
+
+// CHECK: vscatterqpd xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm19
+// CHECK:  encoding: [0x62,0xa2,0xfd,0x01,0xa3,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqpd XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm19
+
+// CHECK: vscatterqpd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm29
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa3,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqpd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm29
+
+// CHECK: vscatterqpd ymmword ptr [r14 + 8*ymm31 - 123] {k1}, ymm29
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa3,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqpd YMMWORD PTR [r14+ymm31*8-0x7b]{k1},ymm29
+
+// CHECK: vscatterqpd ymmword ptr [r9 + ymm31 + 256] {k1}, ymm29
+// CHECK:  encoding: [0x62,0x02,0xfd,0x21,0xa3,0x6c,0x39,0x20]
+          vscatterqpd YMMWORD PTR [r9+ymm31*1+0x100]{k1},ymm29
+
+// CHECK: vscatterqpd ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, ymm29
+// CHECK:  encoding: [0x62,0x22,0xfd,0x21,0xa3,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqpd YMMWORD PTR [rcx+ymm31*4+0x400]{k1},ymm29
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm28
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps XMMWORD PTR [r14+xmm31*8+0x7b]{k1},xmm28
+
+// CHECK: vscatterqps xmmword ptr [r9 + xmm31 + 256] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0x64,0x39,0x40]
+          vscatterqps XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm28
+
+// CHECK: vscatterqps xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0xa3,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm28
+
+// CHECK: vscatterqps ymmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa3,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps YMMWORD PTR [r14+ymm31*8+0x7b]{k1},xmm25
+
+// CHECK: vscatterqps ymmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa3,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps YMMWORD PTR [r14+ymm31*8+0x7b]{k1},xmm25
+
+// CHECK: vscatterqps ymmword ptr [r9 + ymm31 + 256] {k1}, xmm25
+// CHECK:  encoding: [0x62,0x02,0x7d,0x21,0xa3,0x4c,0x39,0x40]
+          vscatterqps YMMWORD PTR [r9+ymm31*1+0x100]{k1},xmm25
+
+// CHECK: vscatterqps ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm25
+// CHECK:  encoding: [0x62,0x22,0x7d,0x21,0xa3,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps YMMWORD PTR [rcx+ymm31*4+0x400]{k1},xmm25
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm27
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps XMMWORD PTR [r14+xmm31*8-0x7b]{k1},xmm27
+
+// CHECK: vscatterqps xmmword ptr [r9 + xmm31 + 256] {k1}, xmm27
+// CHECK:  encoding: [0x62,0x02,0x7d,0x01,0xa3,0x5c,0x39,0x40]
+          vscatterqps XMMWORD PTR [r9+xmm31*1+0x100]{k1},xmm27
+
+// CHECK: vscatterqps xmmword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm27
+// CHECK:  encoding: [0x62,0x22,0x7d,0x01,0xa3,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps XMMWORD PTR [rcx+xmm31*4+0x400]{k1},xmm27
+
+// CHECK: vscatterqps ymmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa3,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps YMMWORD PTR [r14+ymm31*8-0x7b]{k1},xmm23
+
+// CHECK: vscatterqps ymmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa3,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps YMMWORD PTR [r14+ymm31*8-0x7b]{k1},xmm23
+
+// CHECK: vscatterqps ymmword ptr [r9 + ymm31 + 256] {k1}, xmm23
+// CHECK:  encoding: [0x62,0x82,0x7d,0x21,0xa3,0x7c,0x39,0x40]
+          vscatterqps YMMWORD PTR [r9+ymm31*1+0x100]{k1},xmm23
+
+// CHECK: vscatterqps ymmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm23
+// CHECK:  encoding: [0x62,0xa2,0x7d,0x21,0xa3,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps YMMWORD PTR [rcx+ymm31*4+0x400]{k1},xmm23
+

utils/TableGen/X86RecognizableInstr.cpp

OperandType RecognizableInstr::typeFromString(const std::string &s,
   TYPE("VK16",                TYPE_VK16)
   TYPE("VK16WM",              TYPE_VK16)
   TYPE("VK32",                TYPE_VK32)
   TYPE("VK32WM",              TYPE_VK32)
   TYPE("VK64",                TYPE_VK64)
   TYPE("VK64WM",              TYPE_VK64)
   TYPE("GR32_NOAX",           TYPE_Rv)
   TYPE("vx32mem",             TYPE_M32)
-  TYPE("vx32xmem",            TYPE_M32)
   TYPE("vy32mem",             TYPE_M32)
-  TYPE("vy32xmem",            TYPE_M32)
-  TYPE("vz32mem",             TYPE_M32)
   TYPE("vx64mem",             TYPE_M64)
-  TYPE("vx64xmem",            TYPE_M64)
   TYPE("vy64mem",             TYPE_M64)
-  TYPE("vy64xmem",            TYPE_M64)
-  TYPE("vz64mem",             TYPE_M64)
+  TYPE("vx128mem",            TYPE_M128)
+  TYPE("vx256mem",            TYPE_M256)
+  TYPE("vy256mem",            TYPE_M256)
+  TYPE("vy512mem",            TYPE_M512)
+  TYPE("vz512mem",            TYPE_M512)
   TYPE("BNDR",                TYPE_BNDR)
   errs() << "Unhandled type string " << s << "\n";
   llvm_unreachable("Unhandled type string");
 }
 #undef TYPE
 
 #define ENCODING(str, encoding) if (s == str) return encoding;
 OperandEncoding
RecognizableInstr::memoryEncodingFromString(const std::string &s,
   ENCODING("lea64_32mem",     ENCODING_RM)
   ENCODING("lea64mem",        ENCODING_RM)
   ENCODING("anymem",          ENCODING_RM)
   ENCODING("opaque32mem",     ENCODING_RM)
   ENCODING("opaque48mem",     ENCODING_RM)
   ENCODING("opaque80mem",     ENCODING_RM)
   ENCODING("opaque512mem",    ENCODING_RM)
   ENCODING("vx32mem",         ENCODING_RM)
-  ENCODING("vx32xmem",        ENCODING_RM)
   ENCODING("vy32mem",         ENCODING_RM)
-  ENCODING("vy32xmem",        ENCODING_RM)
-  ENCODING("vz32mem",         ENCODING_RM)
   ENCODING("vx64mem",         ENCODING_RM)
-  ENCODING("vx64xmem",        ENCODING_RM)
   ENCODING("vy64mem",         ENCODING_RM)
-  ENCODING("vy64xmem",        ENCODING_RM)
-  ENCODING("vz64mem",         ENCODING_RM)
+  ENCODING("vx128mem",        ENCODING_RM)
+  ENCODING("vx256mem",        ENCODING_RM)
+  ENCODING("vy256mem",        ENCODING_RM)
+  ENCODING("vy512mem",        ENCODING_RM)
+  ENCODING("vz512mem",        ENCODING_RM)
   errs() << "Unhandled memory encoding " << s << "\n";
   llvm_unreachable("Unhandled memory encoding");
 }
 
 OperandEncoding
 RecognizableInstr::relocationEncodingFromString(const std::string &s,
                                                 uint8_t OpSize) {
   if(OpSize != X86Local::OpSize16) {