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

llvm/trunk/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 isMemIndexReg(unsigned LowR, unsigned HighR) const {
+    assert(Kind == Memory && "Invalid access!");
+    return Mem.IndexReg >= LowR && Mem.IndexReg <= HighR;
+  }
+
+  bool isMem64_RC128() const {
+    return isMem64() && isMemIndexReg(X86::XMM0, X86::XMM15);
+  }
+  bool isMem128_RC128() const {
+    return isMem128() && isMemIndexReg(X86::XMM0, X86::XMM15);
+  }
+  bool isMem128_RC256() const {
+    return isMem128() && isMemIndexReg(X86::YMM0, X86::YMM15);
+  }
+  bool isMem256_RC128() const {
+    return isMem256() && isMemIndexReg(X86::XMM0, X86::XMM15);
+  }
+  bool isMem256_RC256() const {
+    return isMem256() && isMemIndexReg(X86::YMM0, X86::YMM15);
+  }
 
-  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) &&
-      getMemIndexReg() >= X86::YMM0 && getMemIndexReg() <= X86::YMM31;
-  }
-  bool isMemVZ32() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 32) &&
-      getMemIndexReg() >= X86::ZMM0 && getMemIndexReg() <= X86::ZMM31;
-  }
-  bool isMemVZ64() const {
-    return Kind == Memory && (!Mem.Size || Mem.Size == 64) &&
-      getMemIndexReg() >= X86::ZMM0 && getMemIndexReg() <= X86::ZMM31;
+  bool isMem64_RC128X() const {
+    return isMem64() && isMemIndexReg(X86::XMM0, X86::XMM31);
+  }
+  bool isMem128_RC128X() const {
+    return isMem128() && isMemIndexReg(X86::XMM0, X86::XMM31);
+  }
+  bool isMem128_RC256X() const {
+    return isMem128() && isMemIndexReg(X86::YMM0, X86::YMM31);
+  }
+  bool isMem256_RC128X() const {
+    return isMem256() && isMemIndexReg(X86::XMM0, X86::XMM31);
+  }
+  bool isMem256_RC256X() const {
+    return isMem256() && isMemIndexReg(X86::YMM0, X86::YMM31);
+  }
+  bool isMem512_RC256X() const {
+    return isMem512() && isMemIndexReg(X86::YMM0, X86::YMM31);
+  }
+  bool isMem512_RC512() const {
+    return isMem512() && isMemIndexReg(X86::ZMM0, X86::ZMM31);
   }
 
   bool isAbsMem() const {
     return Kind == Memory && !getMemSegReg() && !getMemBaseReg() &&
       !getMemIndexReg() && getMemScale() == 1;
   }
   bool isAVX512RC() const{
       return isImm();

llvm/trunk/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;
+                              vx256xmem, mgatherv4i32>, EVEX_V256, VEX_W;
   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info256,
-                              vy64xmem, mgatherv4i64>, EVEX_V256, VEX_W;
+                              vy256xmem, mgatherv4i64>, EVEX_V256, VEX_W;
   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
-                              vx32xmem, mgatherv4i32>, EVEX_V128, VEX_W;
+                              vx128xmem, mgatherv4i32>, EVEX_V128, VEX_W;
   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
-                              vx64xmem, mgatherv2i64>, EVEX_V128, VEX_W;
+                              vx128xmem, 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;
+                                          vy256xmem, mgatherv8i32>, EVEX_V256;
   defm NAME##Q##SUFF##Z256: avx512_gather<qopc, OpcodeStr##"q", _.info128,
-                                          vy64xmem, mgatherv4i64>, EVEX_V256;
+                                          vy128xmem, mgatherv4i64>, EVEX_V256;
   defm NAME##D##SUFF##Z128: avx512_gather<dopc, OpcodeStr##"d", _.info128,
-                                          vx32xmem, mgatherv4i32>, EVEX_V128;
+                                          vx128xmem, mgatherv4i32>, EVEX_V128;
   defm NAME##Q##SUFF##Z128: avx512_gather<qopc, OpcodeStr##"q", _.info128,
                                           vx64xmem, 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">;
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;
+                              vx256xmem, mscatterv4i32>, EVEX_V256, VEX_W;
   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info256,
-                              vy64xmem, mscatterv4i64>, EVEX_V256, VEX_W;
+                              vy256xmem, mscatterv4i64>, EVEX_V256, VEX_W;
   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
-                              vx32xmem, mscatterv4i32>, EVEX_V128, VEX_W;
+                              vx128xmem, mscatterv4i32>, EVEX_V128, VEX_W;
   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
-                              vx64xmem, mscatterv2i64>, EVEX_V128, VEX_W;
+                              vx128xmem, 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;
+                                          vy256xmem, mscatterv8i32>, EVEX_V256;
   defm NAME##Q##SUFF##Z256: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
-                                          vy64xmem, mscatterv4i64>, EVEX_V256;
+                                          vy128xmem, mscatterv4i64>, EVEX_V256;
   defm NAME##D##SUFF##Z128: avx512_scatter<dopc, OpcodeStr##"d", _.info128,
-                                          vx32xmem, mscatterv4i32>, EVEX_V128;
+                                          vx128xmem, mscatterv4i32>, EVEX_V128;
   defm NAME##Q##SUFF##Z128: avx512_scatter<qopc, OpcodeStr##"q", _.info128,
                                           vx64xmem, 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>;
+                     VK8WM, vy512mem>, 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>;
+                     VK8WM, vy512mem>, 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>;
+                     VK8WM, vy512mem>, 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>;
+                     VK8WM, vy512mem>, 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}"),

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

let RenderMethod = "addMemOperands", SuperClasses = [X86MemAsmOperand] in {
   def X86Mem16AsmOperand  : AsmOperandClass { let Name = "Mem16"; }
   def X86Mem32AsmOperand  : AsmOperandClass { let Name = "Mem32"; }
   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 X86Mem64_RC128Operand  : AsmOperandClass { let Name = "Mem64_RC128"; }
+  def X86Mem128_RC128Operand : AsmOperandClass { let Name = "Mem128_RC128"; }
+  def X86Mem256_RC128Operand : AsmOperandClass { let Name = "Mem256_RC128"; }
+  def X86Mem128_RC256Operand : AsmOperandClass { let Name = "Mem128_RC256"; }
+  def X86Mem256_RC256Operand : AsmOperandClass { let Name = "Mem256_RC256"; }
+
+  def X86Mem64_RC128XOperand  : AsmOperandClass { let Name = "Mem64_RC128X"; }
+  def X86Mem128_RC128XOperand : AsmOperandClass { let Name = "Mem128_RC128X"; }
+  def X86Mem256_RC128XOperand : AsmOperandClass { let Name = "Mem256_RC128X"; }
+  def X86Mem128_RC256XOperand : AsmOperandClass { let Name = "Mem128_RC256X"; }
+  def X86Mem256_RC256XOperand : AsmOperandClass { let Name = "Mem256_RC256X"; }
+  def X86Mem512_RC256XOperand : AsmOperandClass { let Name = "Mem512_RC256X"; }
+  def X86Mem512_RC512Operand  : AsmOperandClass { let Name = "Mem512_RC512"; }
 }
 
 def X86AbsMemAsmOperand : AsmOperandClass {
   let Name = "AbsMem";
   let SuperClasses = [X86MemAsmOperand];
 }
 
 class X86MemOperand<string printMethod,

 def f80mem  : X86MemOperand<"printf80mem",  X86Mem80AsmOperand>;
 def f128mem : X86MemOperand<"printf128mem", X86Mem128AsmOperand>;
 def f256mem : X86MemOperand<"printf256mem", X86Mem256AsmOperand>;
 def f512mem : X86MemOperand<"printf512mem", X86Mem512AsmOperand>;
 
 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 vx64mem  : X86VMemOperand<VR128,  "printi64mem",  X86Mem64_RC128Operand>;
+def vx128mem : X86VMemOperand<VR128,  "printi128mem", X86Mem128_RC128Operand>;
+def vx256mem : X86VMemOperand<VR128,  "printi256mem", X86Mem256_RC128Operand>;
+def vy128mem : X86VMemOperand<VR256,  "printi128mem", X86Mem128_RC256Operand>;
+def vy256mem : X86VMemOperand<VR256,  "printi256mem", X86Mem256_RC256Operand>;
+
+def vx64xmem  : X86VMemOperand<VR128X, "printi64mem",  X86Mem64_RC128XOperand>;
+def vx128xmem : X86VMemOperand<VR128X, "printi128mem", X86Mem128_RC128XOperand>;
+def vx256xmem : X86VMemOperand<VR128X, "printi256mem", X86Mem256_RC128XOperand>;
+def vy128xmem : X86VMemOperand<VR256,  "printi128mem", X86Mem128_RC256XOperand>;
+def vy256xmem : X86VMemOperand<VR256X, "printi256mem", X86Mem256_RC256XOperand>;
+def vy512mem  : X86VMemOperand<VR256X, "printi512mem", X86Mem512_RC256XOperand>;
+def vz512mem  : X86VMemOperand<VR512,  "printi512mem", X86Mem512_RC512Operand>;
 
 // 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";

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

def Yrm : AVX28I<opc, MRMSrcMem, (outs RC256:$dst, RC256:$mask_wb),
             !strconcat(OpcodeStr,
               "\t{$mask, $src2, $dst|$dst, $src2, $mask}"),
             []>, VEX_4VOp3, VEX_L;
 }
 
 let mayLoad = 1, Constraints
   = "@earlyclobber $dst,@earlyclobber $mask_wb, $src1 = $dst, $mask = $mask_wb"
   in {
-  defm VPGATHERDQ : avx2_gather<0x90, "vpgatherdq", VR256, vx64mem, vx64mem>, VEX_W;
-  defm VPGATHERQQ : avx2_gather<0x91, "vpgatherqq", VR256, vx64mem, vy64mem>, VEX_W;
-  defm VPGATHERDD : avx2_gather<0x90, "vpgatherdd", VR256, vx32mem, vy32mem>;
-  defm VPGATHERQD : avx2_gather<0x91, "vpgatherqd", VR128, vx32mem, vy32mem>;
+  defm VPGATHERDQ : avx2_gather<0x90, "vpgatherdq", VR256, vx128mem, vx256mem>, VEX_W;
+  defm VPGATHERQQ : avx2_gather<0x91, "vpgatherqq", VR256, vx128mem, vy256mem>, VEX_W;
+  defm VPGATHERDD : avx2_gather<0x90, "vpgatherdd", VR256, vx128mem, vy256mem>;
+  defm VPGATHERQD : avx2_gather<0x91, "vpgatherqd", VR128, vx64mem, vy128mem>;
 
   let ExeDomain = SSEPackedDouble in {
-    defm VGATHERDPD : avx2_gather<0x92, "vgatherdpd", VR256, vx64mem, vx64mem>, VEX_W;
-    defm VGATHERQPD : avx2_gather<0x93, "vgatherqpd", VR256, vx64mem, vy64mem>, VEX_W;
+    defm VGATHERDPD : avx2_gather<0x92, "vgatherdpd", VR256, vx128mem, vx256mem>, VEX_W;
+    defm VGATHERQPD : avx2_gather<0x93, "vgatherqpd", VR256, vx128mem, vy256mem>, VEX_W;
   }
 
   let ExeDomain = SSEPackedSingle in {
-    defm VGATHERDPS : avx2_gather<0x92, "vgatherdps", VR256, vx32mem, vy32mem>;
-    defm VGATHERQPS : avx2_gather<0x93, "vgatherqps", VR128, vx32mem, vy32mem>;
+    defm VGATHERDPS : avx2_gather<0x92, "vgatherdps", VR256, vx128mem, vy256mem>;
+    defm VGATHERQPS : avx2_gather<0x93, "vgatherqps", VR128, vx64mem, vy128mem>;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Extra selection patterns for FR128, f128, f128mem
 
 // movaps is shorter than movdqa. movaps is in SSE and movdqa is in SSE2.
 def : Pat<(store (f128 FR128:$src), addr:$dst),

llvm/trunk/test/MC/Disassembler/X86/intel-syntax.txt

 0x66 0xc3
 
 # CHECK: retf
 0x66 0xcb
 
 # CHECK: vshufpd xmm0, xmm1, xmm2, 1
 0xc5 0xf1 0xc6 0xc2 0x01
 
-# CHECK: vpgatherqq ymm2, qword ptr [rdi + 2*ymm1], ymm0
+# CHECK: vpgatherqq ymm2, ymmword ptr [rdi + 2*ymm1], ymm0
 0xc4 0xe2 0xfd 0x91 0x14 0x4f
 
-# CHECK: vpgatherdd xmm10, dword ptr [r15 + 2*xmm9], xmm8
+# CHECK: vpgatherdd xmm10, xmmword ptr [r15 + 2*xmm9], xmm8
 0xc4 0x02 0x39 0x90 0x14 0x4f
 
 # CHECK: xsave64 opaque ptr [rax]
 0x48 0x0f 0xae 0x20
 
 # CHECK: xrstor64 opaque ptr [rax]
 0x48 0x0f 0xae 0x28
 

llvm/trunk/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

llvm/trunk/test/MC/X86/intel-syntax-x86-64-avx.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown -x86-asm-syntax=intel -output-asm-variant=1 --show-encoding %s | FileCheck %s
+
+// CHECK: vgatherdpd    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+// CHECK: encoding: [0xc4,0xe2,0xf9,0x92,0x14,0x4f]
+          vgatherdpd    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+
+// CHECK: vgatherqpd    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+// CHECK: encoding: [0xc4,0xe2,0xf9,0x93,0x14,0x4f]
+          vgatherqpd    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+
+// CHECK: vgatherdpd    ymm2, ymmword ptr [rdi + 2*xmm1], ymm0 
+// CHECK: encoding: [0xc4,0xe2,0xfd,0x92,0x14,0x4f]
+          vgatherdpd    ymm2, ymmword ptr [rdi + 2*xmm1], ymm0 
+
+// CHECK: vgatherqpd    ymm2, ymmword ptr [rdi + 2*ymm1], ymm0 
+// CHECK: encoding: [0xc4,0xe2,0xfd,0x93,0x14,0x4f]
+          vgatherqpd    ymm2, ymmword ptr [rdi + 2*ymm1], ymm0 
+
+// CHECK: vgatherdps    xmm10, xmmword ptr [r15 + 2*xmm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x39,0x92,0x14,0x4f]
+          vgatherdps    xmm10, xmmword ptr [r15 + 2*xmm9], xmm8 
+
+// CHECK: vgatherqps    xmm10, qword ptr [r15 + 2*xmm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x39,0x93,0x14,0x4f]
+          vgatherqps    xmm10, qword ptr [r15 + 2*xmm9], xmm8 
+
+// CHECK: vgatherdps    ymm10, ymmword ptr [r15 + 2*ymm9], ymm8 
+// CHECK: encoding: [0xc4,0x02,0x3d,0x92,0x14,0x4f]
+          vgatherdps    ymm10, ymmword ptr [r15 + 2*ymm9], ymm8 
+
+// CHECK: vgatherqps    xmm10, xmmword ptr [r15 + 2*ymm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x3d,0x93,0x14,0x4f]
+          vgatherqps    xmm10, xmmword ptr [r15 + 2*ymm9], xmm8 
+
+// CHECK: vpgatherdq    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+// CHECK: encoding: [0xc4,0xe2,0xf9,0x90,0x14,0x4f]
+          vpgatherdq    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+
+// CHECK: vpgatherqq    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+// CHECK: encoding: [0xc4,0xe2,0xf9,0x91,0x14,0x4f]
+          vpgatherqq    xmm2, xmmword ptr [rdi + 2*xmm1], xmm0 
+
+// CHECK: vpgatherdq    ymm2, ymmword ptr [rdi + 2*xmm1], ymm0 
+// CHECK: encoding: [0xc4,0xe2,0xfd,0x90,0x14,0x4f]
+          vpgatherdq    ymm2, ymmword ptr [rdi + 2*xmm1], ymm0 
+
+// CHECK: vpgatherqq    ymm2, ymmword ptr [rdi + 2*ymm1], ymm0 
+// CHECK: encoding: [0xc4,0xe2,0xfd,0x91,0x14,0x4f]
+          vpgatherqq    ymm2, ymmword ptr [rdi + 2*ymm1], ymm0 
+
+// CHECK: vpgatherdd    xmm10, xmmword ptr [r15 + 2*xmm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x39,0x90,0x14,0x4f]
+          vpgatherdd    xmm10, xmmword ptr [r15 + 2*xmm9], xmm8 
+
+// CHECK: vpgatherqd    xmm10, qword ptr [r15 + 2*xmm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x39,0x91,0x14,0x4f]
+          vpgatherqd    xmm10, qword ptr [r15 + 2*xmm9], xmm8 
+
+// CHECK: vpgatherdd    ymm10, ymmword ptr [r15 + 2*ymm9], ymm8 
+// CHECK: encoding: [0xc4,0x02,0x3d,0x90,0x14,0x4f]
+          vpgatherdd    ymm10, ymmword ptr [r15 + 2*ymm9], ymm8 
+
+// CHECK: vpgatherqd    xmm10, xmmword ptr [r15 + 2*ymm9], xmm8 
+// CHECK: encoding: [0xc4,0x02,0x3d,0x91,0x14,0x4f]
+          vpgatherqd    xmm10, xmmword ptr [r15 + 2*ymm9], xmm8 

llvm/trunk/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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// CHECK: vgatherqps  xmm21 {k1}, qword ptr [r14 + 8*xmm31 + 123] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x93,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqps  xmm21 {k1}, qword ptr [r14 + 8*xmm31 + 123] 
+
+// CHECK: vgatherqps  xmm21 {k1}, qword ptr [r9 + xmm31 + 256] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x93,0x6c,0x39,0x40]
+          vgatherqps  xmm21 {k1}, qword ptr [r9 + xmm31 + 256] 
+
+// CHECK: vgatherqps  xmm21 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x01,0x93,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps  xmm21 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+
+// CHECK: vgatherqps  xmm19 {k1}, xmmword ptr [r14 + 8*ymm31 + 123] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x21,0x93,0x9c,0xfe,0x7b,0x00,0x00,0x00]
+          vgatherqps  xmm19 {k1}, xmmword ptr [r14 + 8*ymm31 + 123] 
+
+// CHECK: vgatherqps  xmm19 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x21,0x93,0x5c,0x39,0x40]
+          vgatherqps  xmm19 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+
+// CHECK: vgatherqps  xmm19 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x21,0x93,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps  xmm19 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+
+// CHECK: vgatherqps  xmm22 {k1}, qword ptr [r14 + 8*xmm31 - 123] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x93,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqps  xmm22 {k1}, qword ptr [r14 + 8*xmm31 - 123] 
+
+// CHECK: vgatherqps  xmm22 {k1}, qword ptr [r9 + xmm31 + 256] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x93,0x74,0x39,0x40]
+          vgatherqps  xmm22 {k1}, qword ptr [r9 + xmm31 + 256] 
+
+// CHECK: vgatherqps  xmm22 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x01,0x93,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps  xmm22 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+
+// CHECK: vgatherqps  xmm30 {k1}, xmmword ptr [r14 + 8*ymm31 - 123] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x93,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vgatherqps  xmm30 {k1}, xmmword ptr [r14 + 8*ymm31 - 123] 
+
+// CHECK: vgatherqps  xmm30 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x93,0x74,0x39,0x40]
+          vgatherqps  xmm30 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+
+// CHECK: vgatherqps  xmm30 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0x93,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vgatherqps  xmm30 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// CHECK: vpgatherqd  xmm21 {k1}, qword ptr [r14 + 8*xmm31 + 123] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x91,0xac,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqd  xmm21 {k1}, qword ptr [r14 + 8*xmm31 + 123] 
+
+// CHECK: vpgatherqd  xmm21 {k1}, qword ptr [r9 + xmm31 + 256] 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0x91,0x6c,0x39,0x40]
+          vpgatherqd  xmm21 {k1}, qword ptr [r9 + xmm31 + 256] 
+
+// CHECK: vpgatherqd  xmm21 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x01,0x91,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd  xmm21 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+
+// CHECK: vpgatherqd  xmm25 {k1}, xmmword ptr [r14 + 8*ymm31 + 123] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x91,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vpgatherqd  xmm25 {k1}, xmmword ptr [r14 + 8*ymm31 + 123] 
+
+// CHECK: vpgatherqd  xmm25 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x91,0x4c,0x39,0x40]
+          vpgatherqd  xmm25 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+
+// CHECK: vpgatherqd  xmm25 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0x91,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd  xmm25 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+
+// CHECK: vpgatherqd  xmm30 {k1}, qword ptr [r14 + 8*xmm31 - 123] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0x91,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqd  xmm30 {k1}, qword ptr [r14 + 8*xmm31 - 123] 
+
+// CHECK: vpgatherqd  xmm30 {k1}, qword ptr [r9 + xmm31 + 256] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0x91,0x74,0x39,0x40]
+          vpgatherqd  xmm30 {k1}, qword ptr [r9 + xmm31 + 256] 
+
+// CHECK: vpgatherqd  xmm30 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+// CHECK: encoding: [0x62,0x22,0x7d,0x01,0x91,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd  xmm30 {k1}, qword ptr [rcx + 4*xmm31 + 1024] 
+
+// CHECK: vpgatherqd  xmm28 {k1}, xmmword ptr [r14 + 8*ymm31 - 123] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x91,0xa4,0xfe,0x85,0xff,0xff,0xff]
+          vpgatherqd  xmm28 {k1}, xmmword ptr [r14 + 8*ymm31 - 123] 
+
+// CHECK: vpgatherqd  xmm28 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0x91,0x64,0x39,0x40]
+          vpgatherqd  xmm28 {k1}, xmmword ptr [r9 + ymm31 + 256] 
+
+// CHECK: vpgatherqd  xmm28 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0x91,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vpgatherqd  xmm28 {k1}, xmmword ptr [rcx + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 + 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*xmm31 + 1024] 
+
+// 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 + 8*ymm31 - 123] 
+
+// 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 + 256] 
+
+// 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 + 4*ymm31 + 1024] 
+
+// 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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 + 123] {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 + 8*ymm31 + 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 - 123] {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 + 8*ymm31 - 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {k1}, ymm20 
+
+// CHECK: vpscatterqd qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd  qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd  qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [r9 + xmm31 + 256] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0x74,0x39,0x40]
+          vpscatterqd  qword ptr [r9 + xmm31 + 256] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x01,0xa1,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd  qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22 
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd  xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24 
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0x84,0xfe,0x7b,0x00,0x00,0x00]
+          vpscatterqd  xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm24 
+
+// CHECK: vpscatterqd xmmword ptr [r9 + ymm31 + 256] {k1}, xmm24 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0x44,0x39,0x40]
+          vpscatterqd  xmmword ptr [r9 + ymm31 + 256] {k1}, xmm24 
+
+// CHECK: vpscatterqd xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm24 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0xa1,0x84,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd  xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm24 
+
+// CHECK: vpscatterqd qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd  qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0xb4,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd  qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [r9 + xmm31 + 256] {k1}, xmm22 
+// CHECK: encoding: [0x62,0x82,0x7d,0x01,0xa1,0x74,0x39,0x40]
+          vpscatterqd  qword ptr [r9 + xmm31 + 256] {k1}, xmm22 
+
+// CHECK: vpscatterqd qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x01,0xa1,0xb4,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd  qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm22 
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd  xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29 
+
+// CHECK: vpscatterqd xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0xac,0xfe,0x85,0xff,0xff,0xff]
+          vpscatterqd  xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm29 
+
+// CHECK: vpscatterqd xmmword ptr [r9 + ymm31 + 256] {k1}, xmm29 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa1,0x6c,0x39,0x40]
+          vpscatterqd  xmmword ptr [r9 + ymm31 + 256] {k1}, xmm29 
+
+// CHECK: vpscatterqd xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm29 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0xa1,0xac,0xb9,0x00,0x04,0x00,0x00]
+          vpscatterqd  xmmword ptr [rcx + 4*ymm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 + 123] {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 + 8*ymm31 + 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 - 123] {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 + 8*ymm31 - 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 + 123] {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 + 8*ymm31 + 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 - 123] {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 + 8*ymm31 - 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 + 123] {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 + 8*xmm31 + 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 + 123] {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 + 8*ymm31 + 123] {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 + 256] {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 + 4*ymm31 + 1024] {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 + 8*xmm31 - 123] {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 + 8*xmm31 - 123] {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 + 256] {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 + 4*xmm31 + 1024] {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 + 8*ymm31 - 123] {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 + 8*ymm31 - 123] {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 + 256] {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 + 4*ymm31 + 1024] {k1}, ymm29 
+
+// CHECK: vscatterqps qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps  qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28 
+
+// CHECK: vscatterqps qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0xa4,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps  qword ptr [r14 + 8*xmm31 + 123] {k1}, xmm28 
+
+// CHECK: vscatterqps qword ptr [r9 + xmm31 + 256] {k1}, xmm28 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0x64,0x39,0x40]
+          vscatterqps  qword ptr [r9 + xmm31 + 256] {k1}, xmm28 
+
+// CHECK: vscatterqps qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28 
+// CHECK: encoding: [0x62,0x22,0x7d,0x01,0xa3,0xa4,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps  qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm28 
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa3,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps  xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25 
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa3,0x8c,0xfe,0x7b,0x00,0x00,0x00]
+          vscatterqps  xmmword ptr [r14 + 8*ymm31 + 123] {k1}, xmm25 
+
+// CHECK: vscatterqps xmmword ptr [r9 + ymm31 + 256] {k1}, xmm25 
+// CHECK: encoding: [0x62,0x02,0x7d,0x21,0xa3,0x4c,0x39,0x40]
+          vscatterqps  xmmword ptr [r9 + ymm31 + 256] {k1}, xmm25 
+
+// CHECK: vscatterqps xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm25 
+// CHECK: encoding: [0x62,0x22,0x7d,0x21,0xa3,0x8c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps  xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm25 
+
+// CHECK: vscatterqps qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps  qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27 
+
+// CHECK: vscatterqps qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0x9c,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps  qword ptr [r14 + 8*xmm31 - 123] {k1}, xmm27 
+
+// CHECK: vscatterqps qword ptr [r9 + xmm31 + 256] {k1}, xmm27 
+// CHECK: encoding: [0x62,0x02,0x7d,0x01,0xa3,0x5c,0x39,0x40]
+          vscatterqps  qword ptr [r9 + xmm31 + 256] {k1}, xmm27 
+
+// CHECK: vscatterqps qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm27 
+// CHECK: encoding: [0x62,0x22,0x7d,0x01,0xa3,0x9c,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps  qword ptr [rcx + 4*xmm31 + 1024] {k1}, xmm27 
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23 
+// CHECK: encoding: [0x62,0x82,0x7d,0x21,0xa3,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps  xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23 
+
+// CHECK: vscatterqps xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23 
+// CHECK: encoding: [0x62,0x82,0x7d,0x21,0xa3,0xbc,0xfe,0x85,0xff,0xff,0xff]
+          vscatterqps  xmmword ptr [r14 + 8*ymm31 - 123] {k1}, xmm23 
+
+// CHECK: vscatterqps xmmword ptr [r9 + ymm31 + 256] {k1}, xmm23 
+// CHECK: encoding: [0x62,0x82,0x7d,0x21,0xa3,0x7c,0x39,0x40]
+          vscatterqps  xmmword ptr [r9 + ymm31 + 256] {k1}, xmm23 
+
+// CHECK: vscatterqps xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm23 
+// CHECK: encoding: [0x62,0xa2,0x7d,0x21,0xa3,0xbc,0xb9,0x00,0x04,0x00,0x00]
+          vscatterqps  xmmword ptr [rcx + 4*ymm31 + 1024] {k1}, xmm23 
+

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

// CHECK: movq %fs:320, %rax
     mov RAX, QWORD PTR FS:320
 // CHECK: movq %rax, %fs:320
     mov QWORD PTR FS:320, RAX
 // CHECK: movq %rax, %fs:20(%rbx)
     mov QWORD PTR FS:20[rbx], RAX
 // CHECK: vshufpd $1, %xmm2, %xmm1, %xmm0
     vshufpd XMM0, XMM1, XMM2, 1
 // CHECK: vpgatherdd %xmm8, (%r15,%xmm9,2), %xmm1
-    vpgatherdd XMM10, DWORD PTR [R15 + 2*XMM9], XMM8
-// CHECK: movsd -8, %xmm5
+    vpgatherdd XMM10, XMMWORD PTR [R15 + 2*XMM9], XMM8
+// CHECK: movsd -8, %xmm5
     movsd   XMM5, QWORD PTR [-8]
 // CHECK: movl %ecx, (%eax)
     mov [eax], ecx
 // CHECK: movl %ecx, (,%ebx,4)
     mov [4*ebx], ecx
  // CHECK:   movl %ecx, (,%ebx,4)
     mov [ebx*4], ecx
 // CHECK: movl %ecx, 1024

llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp

OperandType RecognizableInstr::typeFromString(const std::string &s,
   TYPE("VK8WM",               TYPE_VK8)
   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("vx128mem",            TYPE_M128)
+  TYPE("vx256mem",            TYPE_M256)
+  TYPE("vy128mem",            TYPE_M128)
+  TYPE("vy256mem",            TYPE_M256)
   TYPE("vx64xmem",            TYPE_M64)
-  TYPE("vy64mem",             TYPE_M64)
-  TYPE("vy64xmem",            TYPE_M64)
-  TYPE("vz64mem",             TYPE_M64)
+  TYPE("vx128xmem",           TYPE_M128)
+  TYPE("vx256xmem",           TYPE_M256)
+  TYPE("vy128xmem",           TYPE_M128)
+  TYPE("vy256xmem",           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("f80mem",          ENCODING_RM)
   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("vx128mem",        ENCODING_RM)
+  ENCODING("vx256mem",        ENCODING_RM)
+  ENCODING("vy128mem",        ENCODING_RM)
+  ENCODING("vy256mem",        ENCODING_RM)
   ENCODING("vx64xmem",        ENCODING_RM)
-  ENCODING("vy64mem",         ENCODING_RM)
-  ENCODING("vy64xmem",        ENCODING_RM)
-  ENCODING("vz64mem",         ENCODING_RM)
+  ENCODING("vx128xmem",       ENCODING_RM)
+  ENCODING("vx256xmem",       ENCODING_RM)
+  ENCODING("vy128xmem",       ENCODING_RM)
+  ENCODING("vy256xmem",       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) {