[X86] Add support for {vex2}, {vex3}, and {evex} to the assembler to match gas. Use {evex} to improve the one our 32-bit AVX512 tests.

[craig.topper]

Summary

These can be used to force the encoding used for instructions.

{vex2} will fail if the instruction is not VEX encoded, but otherwise won't do anything since we prefer vex2 when possible. Might need to skip use of the _REV MOV instructions for this too, but I haven't done that yet.

{vex3} will force the instruction to use the 3 byte VEX encoding or fail if there is no VEX form.

{evex} will force the instruction to use the EVEX version or fail if there is no EVEX version.

[RKSimon]

Might need to skip use of the _REV MOV instructions for this too, but I haven't done that yet.

Can you elaborate?

[craig.topper]

In D59266#1428241, @RKSimon wrote:

Might need to skip use of the _REV MOV instructions for this too, but I haven't done that yet.

Can you elaborate?

We have aliases like this which look for xmm8-15 and xmm0-7 being used in the wrong spots of the modrm byte requiring the 3 byte vex prefix to be used. So we switch to the otherwise redundant move encoding that has the operands swapped in modrm. This enables a 2 byte vex prefix. gcc has the same optimization, but seems to disable it when {vex3} is specified.

// Aliases to help the assembler pick two byte VEX encodings by swapping the
// operands relative to the normal instructions to use VEX.R instead of VEX.B.
def : InstAlias<"vmovdqa\t{$src, $dst|$dst, $src}",
                (VMOVDQArr_REV VR128L:$dst, VR128H:$src), 0>;
def : InstAlias<"vmovdqa\t{$src, $dst|$dst, $src}",
                (VMOVDQAYrr_REV VR256L:$dst, VR256H:$src), 0>;
def : InstAlias<"vmovdqu\t{$src, $dst|$dst, $src}",
                (VMOVDQUrr_REV VR128L:$dst, VR128H:$src), 0>;
def : InstAlias<"vmovdqu\t{$src, $dst|$dst, $src}",
                (VMOVDQUYrr_REV VR256L:$dst, VR256H:$src), 0>;

[craig.topper]

I forgot about another issue I know about. Currently the EVEX form of instruction like "vcvtss2si (%rax), %ebx" are removed from the assembly matcher table. Since none of the operands are xmm/ymm/zmm registers when the source is memory there was never a reason to use EVEX. And the sorting criteria in the AsmMatcherTable can't order it correctly to put VEX first since the operands are identical. Normally the fact that VR128 is a subclass of VR128X is what give VEX preference over EVEX in the table. But that doesn't apply here so they get sorted by the enum value from X86GenInstrInfo.inc which puts EVEX first.

With this feature, we should pick the EVEX encoding when {evex} is specified. Not sure how to make this work other than rejecting the EVEX form for a specific list of instructions in checkTargetMatchPredicate unless {evex} has been specified.

[craig.topper]

Ping. Should I address those other issues or is this a good starting point?

[RKSimon]

Couple of minors but I think this is a good starting point - please make sure the issues you mentioned are included as TODOs somewhere or raised as bugs

lib/Target/X86/AsmParser/X86AsmParser.cpp

3140 ↗

(On Diff #190291)

missing assert message

test/MC/X86/AVX-32.s

9 ↗

(On Diff #190291)

I take it you will be adding full vex3 testing as a separate (bulky) commit?

[craig.topper]

test/MC/X86/AVX-32.s

9 ↗

(On Diff #190291)

Maybe if I can get my hands on the script that generated these tests. Updating the scalar test was painful. Also need to figure out what happened to the effort to get the rest of the reviews committed.

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

static const char OpPrecedence[] = {
   0, // IC_IMM
   0  // IC_REGISTER
 };
 
 class X86AsmParser : public MCTargetAsmParser {
   ParseInstructionInfo *InstInfo;
   bool Code16GCC;
 
+  enum VEXEncoding {
+    VEXEncoding_Default,
+    VEXEncoding_VEX2,
+    VEXEncoding_VEX3,
+    VEXEncoding_EVEX,
+  };
+
+  VEXEncoding ForcedVEXEncoding = VEXEncoding_Default;
+
 private:
   SMLoc consumeToken() {
     MCAsmParser &Parser = getParser();
     SMLoc Result = Parser.getTok().getLoc();
     Parser.Lex();
     return Result;
   }
 
private:
   bool parseDirectiveFPOSetFrame(SMLoc L);
   bool parseDirectiveFPOPushReg(SMLoc L);
   bool parseDirectiveFPOStackAlloc(SMLoc L);
   bool parseDirectiveFPOStackAlign(SMLoc L);
   bool parseDirectiveFPOEndPrologue(SMLoc L);
   bool parseDirectiveFPOEndProc(SMLoc L);
   bool parseDirectiveFPOData(SMLoc L);
 
+  unsigned checkTargetMatchPredicate(MCInst &Inst) override;
+
   bool validateInstruction(MCInst &Inst, const OperandVector &Ops);
   bool processInstruction(MCInst &Inst, const OperandVector &Ops);
 
   /// Wrapper around MCStreamer::EmitInstruction(). Possibly adds
   /// instrumentation around Inst.
   void EmitInstruction(MCInst &Inst, OperandVector &Operands, MCStreamer &Out);
 
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
private:
   /// {
 
 #define GET_ASSEMBLER_HEADER
 #include "X86GenAsmMatcher.inc"
 
   /// }
 
 public:
+  enum X86MatchResultTy {
+    Match_Unsupported = FIRST_TARGET_MATCH_RESULT_TY,
+  };
 
   X86AsmParser(const MCSubtargetInfo &sti, MCAsmParser &Parser,
                const MCInstrInfo &mii, const MCTargetOptions &Options)
       : MCTargetAsmParser(Options, sti, mii),  InstInfo(nullptr),
         Code16GCC(false) {
 
     Parser.addAliasForDirective(".word", ".2byte");
 
bool X86AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
   }
   return Parser.parsePrimaryExpr(Res, EndLoc);
 }
 
 bool X86AsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                     SMLoc NameLoc, OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
   InstInfo = &Info;
+  std::string TempName; // Used when we parse a pseudo prefix.
+
+  // Reset the forced VEX encoding.
+  ForcedVEXEncoding = VEXEncoding_Default;
+
+  // Parse pseudo prefixes.
+  while (1) {
+    if (Name == "{") {
+      if (getLexer().isNot(AsmToken::Identifier))
+        return Error(Parser.getTok().getLoc(), "Unexpected token after '{'");
+      std::string Prefix = Parser.getTok().getString().lower();
+      Parser.Lex(); // Eat identifier.
+      if (getLexer().isNot(AsmToken::RCurly))
+        return Error(Parser.getTok().getLoc(), "Expected '}'");
+      Parser.Lex(); // Eat curly.
+
+      if (Prefix == "vex2")
+        ForcedVEXEncoding = VEXEncoding_VEX2;
+      else if (Prefix == "vex3")
+        ForcedVEXEncoding = VEXEncoding_VEX3;
+      else if (Prefix == "evex")
+        ForcedVEXEncoding = VEXEncoding_EVEX;
+      else
+        return Error(NameLoc, "unknown prefix");
+
+      NameLoc = Parser.getTok().getLoc();
+      if (getLexer().is(AsmToken::LCurly)) {
+        Parser.Lex();
+        Name = "{";
+      } else {
+        if (getLexer().isNot(AsmToken::Identifier))
+          return Error(Parser.getTok().getLoc(), "Expected identifier");
+        TempName = Parser.getTok().getString().lower();
+        Name = TempName;
+        Parser.Lex();
+      }
+      continue;
+    }
+
+    break;
+  }
+
   StringRef PatchedName = Name;
 
   if ((Name.equals("jmp") || Name.equals("jc") || Name.equals("jz")) &&
       isParsingIntelSyntax() && isParsingInlineAsm()) {
     StringRef NextTok = Parser.getTok().getString();
     if (NextTok == "short") {
       SMLoc NameEndLoc =
           NameLoc.getFromPointer(NameLoc.getPointer() + Name.size());
static unsigned getPrefixes(OperandVector &Operands) {
   X86Operand &Prefix = static_cast<X86Operand &>(*Operands.back());
   if (Prefix.isPrefix()) {
     Result = Prefix.getPrefix();
     Operands.pop_back();
   }
   return Result;
 }
 
+unsigned X86AsmParser::checkTargetMatchPredicate(MCInst &Inst) {
+  unsigned Opc = Inst.getOpcode();
+  const MCInstrDesc &MCID = MII.get(Opc);
+
+  if (ForcedVEXEncoding == VEXEncoding_EVEX &&
+      (MCID.TSFlags & X86II::EncodingMask) != X86II::EVEX)
+    return Match_Unsupported;
+
+  if ((ForcedVEXEncoding == VEXEncoding_VEX2 ||
+       ForcedVEXEncoding == VEXEncoding_VEX3) &&
+      (MCID.TSFlags & X86II::EncodingMask) != X86II::VEX)
+    return Match_Unsupported;
+
+  return Match_Success;
+}
+
 bool X86AsmParser::MatchAndEmitATTInstruction(SMLoc IDLoc, unsigned &Opcode,
                                               OperandVector &Operands,
                                               MCStreamer &Out,
                                               uint64_t &ErrorInfo,
                                               bool MatchingInlineAsm) {
   assert(!Operands.empty() && "Unexpect empty operand list!");
   assert((*Operands[0]).isToken() && "Leading operand should always be a mnemonic!");
   SMRange EmptyRange = None;
 
   // First, handle aliases that expand to multiple instructions.
   MatchFPUWaitAlias(IDLoc, static_cast<X86Operand &>(*Operands[0]), Operands,
                     Out, MatchingInlineAsm);
   X86Operand &Op = static_cast<X86Operand &>(*Operands[0]);
-  bool WasOriginallyInvalidOperand = false;
   unsigned Prefixes = getPrefixes(Operands);
 
   MCInst Inst;
 
+  // If VEX3 encoding is forced, we need to pass the USE_VEX3 flag to the
+  // encoder.
+  if (ForcedVEXEncoding == VEXEncoding_VEX3)
+    Prefixes |= X86::IP_USE_VEX3;
+
   if (Prefixes)
     Inst.setFlags(Prefixes);
 
   // First, try a direct match.
   FeatureBitset MissingFeatures;
-  switch (MatchInstruction(Operands, Inst, ErrorInfo, MissingFeatures,
-                           MatchingInlineAsm, isParsingIntelSyntax())) {
+  unsigned OriginalError = MatchInstruction(Operands, Inst, ErrorInfo,
+                                            MissingFeatures, MatchingInlineAsm,
+                                            isParsingIntelSyntax());
+  switch (OriginalError) {
   default: llvm_unreachable("Unexpected match result!");
   case Match_Success:
     if (!MatchingInlineAsm && validateInstruction(Inst, Operands))
       return true;
     // Some instructions need post-processing to, for example, tweak which
     // encoding is selected. Loop on it while changes happen so the
     // individual transformations can chain off each other.
     if (!MatchingInlineAsm)
       while (processInstruction(Inst, Operands))
         ;
 
     Inst.setLoc(IDLoc);
     if (!MatchingInlineAsm)
       EmitInstruction(Inst, Operands, Out);
     Opcode = Inst.getOpcode();
     return false;
   case Match_MissingFeature:
     return ErrorMissingFeature(IDLoc, MissingFeatures, MatchingInlineAsm);
   case Match_InvalidOperand:
-    WasOriginallyInvalidOperand = true;
-    break;
   case Match_MnemonicFail:
+  case Match_Unsupported:
     break;
   }
   if (Op.getToken().empty()) {
     Error(IDLoc, "instruction must have size higher than 0", EmptyRange,
           MatchingInlineAsm);
     return true;
   }
 
if (NumSuccessfulMatches > 1) {
     return true;
   }
 
   // Okay, we know that none of the variants matched successfully.
 
   // If all of the instructions reported an invalid mnemonic, then the original
   // mnemonic was invalid.
   if (std::count(std::begin(Match), std::end(Match), Match_MnemonicFail) == 4) {
-    if (!WasOriginallyInvalidOperand) {
+    if (OriginalError == Match_MnemonicFail)
       return Error(IDLoc, "invalid instruction mnemonic '" + Base + "'",
                    Op.getLocRange(), MatchingInlineAsm);
-    }
 
+    if (OriginalError == Match_Unsupported)
+      return Error(IDLoc, "unsupported instruction", EmptyRange,
+                   MatchingInlineAsm);
+
+    assert(OriginalError == Match_InvalidOperand && "Unexpected error");
     // Recover location info for the operand if we know which was the problem.
     if (ErrorInfo != ~0ULL) {
       if (ErrorInfo >= Operands.size())
         return Error(IDLoc, "too few operands for instruction", EmptyRange,
                      MatchingInlineAsm);
 
       X86Operand &Operand = (X86Operand &)*Operands[ErrorInfo];
       if (Operand.getStartLoc().isValid()) {
         SMRange OperandRange = Operand.getLocRange();
         return Error(Operand.getStartLoc(), "invalid operand for instruction",
                      OperandRange, MatchingInlineAsm);
       }
     }
 
     return Error(IDLoc, "invalid operand for instruction", EmptyRange,
                  MatchingInlineAsm);
   }
 
+  // If one instruction matched as unsupported, report this as unsupported.
+  if (std::count(std::begin(Match), std::end(Match),
+                 Match_Unsupported) == 1) {
+    return Error(IDLoc, "unsupported instruction", EmptyRange,
+                 MatchingInlineAsm);
+  }
+
   // If one instruction matched with a missing feature, report this as a
   // missing feature.
   if (std::count(std::begin(Match), std::end(Match),
                  Match_MissingFeature) == 1) {
     ErrorInfo = Match_MissingFeature;
     return ErrorMissingFeature(IDLoc, ErrorInfoMissingFeatures,
                                MatchingInlineAsm);
   }
bool X86AsmParser::MatchAndEmitIntelInstruction(SMLoc IDLoc, unsigned &Opcode,
   unsigned Prefixes = getPrefixes(Operands);
 
   // First, handle aliases that expand to multiple instructions.
   MatchFPUWaitAlias(IDLoc, static_cast<X86Operand &>(*Operands[0]), Operands, Out, MatchingInlineAsm);
   X86Operand &Op = static_cast<X86Operand &>(*Operands[0]);
 
   MCInst Inst;
 
+  // If VEX3 encoding is forced, we need to pass the USE_VEX3 flag to the
+  // encoder.
+  if (ForcedVEXEncoding == VEXEncoding_VEX3)
+    Prefixes |= X86::IP_USE_VEX3;
+
   if (Prefixes)
     Inst.setFlags(Prefixes);
 
   // Find one unsized memory operand, if present.
   X86Operand *UnsizedMemOp = nullptr;
   for (const auto &Op : Operands) {
     X86Operand *X86Op = static_cast<X86Operand *>(Op.get());
     if (X86Op->isMemUnsized()) {
bool X86AsmParser::MatchAndEmitIntelInstruction(SMLoc IDLoc, unsigned &Opcode,
   } else if (NumSuccessfulMatches > 1) {
     assert(UnsizedMemOp &&
            "multiple matches only possible with unsized memory operands");
     return Error(UnsizedMemOp->getStartLoc(),
                  "ambiguous operand size for instruction '" + Mnemonic + "\'",
                  UnsizedMemOp->getLocRange());
   }
 
+  // If one instruction matched as unsupported, report this as unsupported.
+  if (std::count(std::begin(Match), std::end(Match),
+                 Match_Unsupported) == 1) {
+    return Error(IDLoc, "unsupported instruction", EmptyRange,
+                 MatchingInlineAsm);
+  }
+
   // If one instruction matched with a missing feature, report this as a
   // missing feature.
   if (std::count(std::begin(Match), std::end(Match),
                  Match_MissingFeature) == 1) {
     ErrorInfo = Match_MissingFeature;
     return ErrorMissingFeature(IDLoc, ErrorInfoMissingFeatures,
                                MatchingInlineAsm);
   }

llvm/trunk/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

namespace X86 {
   /// The constants to describe instr prefixes if there are
   enum IPREFIXES {
     IP_NO_PREFIX = 0,
     IP_HAS_OP_SIZE = 1,
     IP_HAS_AD_SIZE = 2,
     IP_HAS_REPEAT_NE = 4,
     IP_HAS_REPEAT = 8,
     IP_HAS_LOCK = 16,
-    IP_HAS_NOTRACK = 32
+    IP_HAS_NOTRACK = 32,
+    IP_USE_VEX3 = 64,
   };
 
   enum OperandType : unsigned {
     /// AVX512 embedded rounding control. This should only have values 0-3.
     OPERAND_ROUNDING_CONTROL = MCOI::OPERAND_FIRST_TARGET,
     OPERAND_COND_CODE,
   };
 

llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp

if (Encoding == X86II::VEX || Encoding == X86II::XOP) {
     //
     //  XOP uses a similar prefix:
     //    +-----+ +--------------+ +-------------------+
     //    | 8Fh | | RXB | m-mmmm | | W | vvvv | L | pp |
     //    +-----+ +--------------+ +-------------------+
     uint8_t LastByte = VEX_PP | (VEX_L << 2) | (VEX_4V << 3);
 
     // Can we use the 2 byte VEX prefix?
-    if (Encoding == X86II::VEX && VEX_B && VEX_X && !VEX_W && (VEX_5M == 1)) {
+    if (!(MI.getFlags() & X86::IP_USE_VEX3) &&
+        Encoding == X86II::VEX && VEX_B && VEX_X && !VEX_W && (VEX_5M == 1)) {
       EmitByte(0xC5, CurByte, OS);
       EmitByte(LastByte | (VEX_R << 7), CurByte, OS);
       return;
     }
 
     // 3 byte VEX prefix
     EmitByte(Encoding == X86II::XOP ? 0x8F : 0xC4, CurByte, OS);
     EmitByte(VEX_R << 7 | VEX_X << 6 | VEX_B << 5 | VEX_5M, CurByte, OS);

llvm/trunk/test/MC/X86/AVX-32.s

 // RUN: llvm-mc -triple i386-unknown-unknown --show-encoding %s | FileCheck %s
 
 // CHECK: vaddpd -485498096(%edx,%eax,4), %xmm1, %xmm1 
 // CHECK: encoding: [0xc5,0xf1,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]      
 vaddpd -485498096(%edx,%eax,4), %xmm1, %xmm1 
 
+// CHECK: vaddpd -485498096(%edx,%eax,4), %xmm1, %xmm1 
+// CHECK: encoding: [0xc4,0xe1,0x71,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{vex3} vaddpd -485498096(%edx,%eax,4), %xmm1, %xmm1 
+
 // CHECK: vaddpd 485498096(%edx,%eax,4), %xmm1, %xmm1 
 // CHECK: encoding: [0xc5,0xf1,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]      
 vaddpd 485498096(%edx,%eax,4), %xmm1, %xmm1 
 
 // CHECK: vaddpd -485498096(%edx,%eax,4), %ymm4, %ymm4 
 // CHECK: encoding: [0xc5,0xdd,0x58,0xa4,0x82,0x10,0xe3,0x0f,0xe3]      
 vaddpd -485498096(%edx,%eax,4), %ymm4, %ymm4 
 

llvm/trunk/test/MC/X86/AVX512F_SCALAR-32.s

 // RUN: llvm-mc -triple i386-unknown-unknown -mcpu=skx --show-encoding %s | FileCheck %s
 
 // FIXME some of these tests use VEX encodings because we have no way to force
 // an EVEX encoding. gas has an {evex} prefix that can force the mode, but
 // we don't have that.
 
 // CHECK: vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vaddsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
-vaddsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vaddsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
-vaddsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddsd 485498096, %xmm1, %xmm1
 
 // CHECK: vaddsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
 vaddsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x8c,0x02,0x00,0x02,0x00,0x00]
-vaddsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x4c,0x02,0x40
+{evex} vaddsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vaddsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x4c,0x02,0x40]
 vaddsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x4c,0x02,0x40]
 vaddsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0x0a]
-vaddsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0x0a]
+{evex} vaddsd (%edx), %xmm1, %xmm1
 
 // CHECK: vaddsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0x0a]
 vaddsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0x0a]
 vaddsd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x58,0xc9]
 vaddsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x58,0xc9]
 vaddsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x58,0xc9]
-vaddsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x58,0xc9]
+{evex} vaddsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vaddsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x58,0xc9]
 vaddsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x58,0xc9]
 vaddsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x8c,0x02,0x00,0x01,0x00,0x00]
-vaddss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x4c,0x02,0x40]
+{evex} vaddss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vaddss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x4c,0x02,0x40]
 vaddss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x4c,0x02,0x40]
 vaddss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vaddss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
-vaddss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vaddss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x8a,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
-vaddss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vaddss 485498096, %xmm1, %xmm1
 
 // CHECK: vaddss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x0d,0xf0,0x1c,0xf0,0x1c]
 vaddss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0x0a]
-vaddss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0x0a]
+{evex} vaddss (%edx), %xmm1, %xmm1
 
 // CHECK: vaddss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0x0a]
 vaddss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0x0a]
 vaddss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x7a,0x58,0xc9]
 vaddss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0xfa,0x58,0xc9]
 vaddss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vaddss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x58,0xc9]
-vaddss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x58,0xc9]
+{evex} vaddss %xmm1, %xmm1, %xmm1
 
 // CHECK: vaddss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x58,0xc9]
 vaddss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vaddss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x58,0xc9]
 vaddss %xmm1, %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x08,0xc2,0xd1,0x00]
 vcmpeqss %xmm1, %xmm1, %k2
 
 // CHECK: vcmpeqss %xmm1, %xmm1, %k2 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0xc2,0xd1,0x00]
 vcmpeqss %xmm1, %xmm1, %k2 {%k2}
 
 // CHECK: vcomisd -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcomisd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vcomisd -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vcomisd 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcomisd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomisd 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vcomisd 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcomisd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomisd 485498096(%edx), %xmm1
 
 // CHECK: vcomisd 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcomisd 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomisd 485498096, %xmm1
 
 // CHECK: vcomisd 512(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x8c,0x02,0x00,0x02,0x00,0x00]
-vcomisd 512(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x4c,0x02,0x40]
+{evex} vcomisd 512(%edx,%eax), %xmm1
 
 // CHECK: vcomisd (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0x0a]
-vcomisd (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0x0a]
+{evex} vcomisd (%edx), %xmm1
 
 // CHECK: vcomisd {sae}, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0xfd,0x18,0x2f,0xc9]
 vcomisd {sae}, %xmm1, %xmm1
 
 // CHECK: vcomisd %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2f,0xc9]
-vcomisd %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2f,0xc9]
+{evex} vcomisd %xmm1, %xmm1
 
 // CHECK: vcomiss 256(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x8c,0x02,0x00,0x01,0x00,0x00]
-vcomiss 256(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x4c,0x02,0x40]
+{evex} vcomiss 256(%edx,%eax), %xmm1
 
 // CHECK: vcomiss -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcomiss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vcomiss -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vcomiss 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcomiss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomiss 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vcomiss 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcomiss 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomiss 485498096(%edx), %xmm1
 
 // CHECK: vcomiss 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcomiss 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcomiss 485498096, %xmm1
 
 // CHECK: vcomiss (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0x0a]
-vcomiss (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0x0a]
+{evex} vcomiss (%edx), %xmm1
 
 // CHECK: vcomiss {sae}, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x7c,0x18,0x2f,0xc9]
 vcomiss {sae}, %xmm1, %xmm1
 
 // CHECK: vcomiss %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2f,0xc9]
-vcomiss %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2f,0xc9]
+{evex} vcomiss %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3
+{evex} vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vcvtsd2ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcvtsd2ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsd2ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcvtsd2ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsd2ss 485498096, %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
 vcvtsd2ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x8c,0x02,0x00,0x02,0x00,0x00]
-vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x4c,0x02,0x40]
+{evex} vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x4c,0x02,0x40]
 vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x4c,0x02,0x40]
 vcvtsd2ss 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0x0a]
-vcvtsd2ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0x0a]
+{evex} vcvtsd2ss (%edx), %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0x0a]
 vcvtsd2ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0x0a]
 vcvtsd2ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x5a,0xc9]
 vcvtsd2ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x5a,0xc9]
 vcvtsd2ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsd2ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5a,0xc9]
-vcvtsd2ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5a,0xc9]
+{evex} vcvtsd2ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vcvtsd2ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5a,0xc9]
 vcvtsd2ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtsd2ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5a,0xc9]
 vcvtsd2ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtsi2sdl 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x8c,0x02,0x00,0x01,0x00,0x00]
-vcvtsi2sdl 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x4c,0x02,0x40]
+{evex} vcvtsi2sdl 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vcvtsi2sdl -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcvtsi2sdl -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vcvtsi2sdl -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsi2sdl 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2sdl 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2sdl 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsi2sdl 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2sdl 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2sdl 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vcvtsi2sdl 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2sdl 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2sdl 485498096, %xmm1, %xmm1
 
 // CHECK: vcvtsi2sdl (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x2a,0x0a]
-vcvtsi2sdl (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x77,0x08,0x2a,0x0a]
+{evex} vcvtsi2sdl (%edx), %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x8c,0x02,0x00,0x01,0x00,0x00]
-vcvtsi2ssl 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x4c,0x02,0x40]
+{evex} vcvtsi2ssl 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcvtsi2ssl -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vcvtsi2ssl -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2ssl 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2ssl 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2ssl 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2ssl 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcvtsi2ssl 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtsi2ssl 485498096, %xmm1, %xmm1
 
 // CHECK: vcvtsi2ssl (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x2a,0x0a]
-vcvtsi2ssl (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x2a,0x0a]
+{evex} vcvtsi2ssl (%edx), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x8c,0x02,0x00,0x01,0x00,0x00]
-vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x4c,0x02,0x40]
+{evex} vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x4c,0x02,0x40]
 vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x4c,0x02,0x40]
 vcvtss2sd 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vcvtss2sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
-vcvtss2sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtss2sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x8a,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
-vcvtss2sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vcvtss2sd 485498096, %xmm1, %xmm1
 
 // CHECK: vcvtss2sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x0d,0xf0,0x1c,0xf0,0x1c]
 vcvtss2sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0x0a]
-vcvtss2sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0x0a]
+{evex} vcvtss2sd (%edx), %xmm1, %xmm1
 
 // CHECK: vcvtss2sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0x0a]
 vcvtss2sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0x0a]
 vcvtss2sd (%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x76,0x18,0x5a,0xc9]
 vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1
 
 // CHECK: vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x1a,0x5a,0xc9]
 vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x9a,0x5a,0xc9]
 vcvtss2sd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vcvtss2sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5a,0xc9]
-vcvtss2sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5a,0xc9]
+{evex} vcvtss2sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vcvtss2sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5a,0xc9]
 vcvtss2sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vcvtss2sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5a,0xc9]
 vcvtss2sd %xmm1, %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x08,0x7b,0x0d,0xf0,0x1c,0xf0,0x1c]
 vcvtusi2ssl 485498096, %xmm1, %xmm1
 
 // CHECK: vcvtusi2ssl (%edx), %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x76,0x08,0x7b,0x0a]
 vcvtusi2ssl (%edx), %xmm1, %xmm1
 
 // CHECK: vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vdivsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
-vdivsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vdivsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
-vdivsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivsd 485498096, %xmm1, %xmm1
 
 // CHECK: vdivsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
 vdivsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x8c,0x02,0x00,0x02,0x00,0x00]
-vdivsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x4c,0x02,0x40]
+{evex} vdivsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vdivsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x4c,0x02,0x40]
 vdivsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x4c,0x02,0x40]
 vdivsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0x0a]
-vdivsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0x0a]
+{evex} vdivsd (%edx), %xmm1, %xmm1
 
 // CHECK: vdivsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0x0a]
 vdivsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0x0a]
 vdivsd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x5e,0xc9]
 vdivsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x5e,0xc9]
 vdivsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5e,0xc9]
-vdivsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5e,0xc9]
+{evex} vdivsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vdivsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5e,0xc9]
 vdivsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5e,0xc9]
 vdivsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x8c,0x02,0x00,0x01,0x00,0x00]
-vdivss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x4c,0x02,0x40]
+{evex} vdivss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vdivss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x4c,0x02,0x40]
 vdivss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x4c,0x02,0x40]
 vdivss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vdivss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
-vdivss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vdivss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x8a,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
-vdivss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vdivss 485498096, %xmm1, %xmm1
 
 // CHECK: vdivss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x0d,0xf0,0x1c,0xf0,0x1c]
 vdivss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0x0a]
-vdivss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0x0a]
+{evex} vdivss (%edx), %xmm1, %xmm1
 
 // CHECK: vdivss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0x0a]
 vdivss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0x0a]
 vdivss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x7a,0x5e,0xc9]
 vdivss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0xfa,0x5e,0xc9]
 vdivss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vdivss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5e,0xc9]
-vdivss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5e,0xc9]
+{evex} vdivss %xmm1, %xmm1, %xmm1
 
 // CHECK: vdivss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5e,0xc9]
 vdivss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vdivss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5e,0xc9]
 vdivss %xmm1, %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf3,0x75,0x0a,0x55,0xc9,0x00]
 vfixupimmss $0, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfixupimmss $0, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf3,0x75,0x8a,0x55,0xc9,0x00]
 vfixupimmss $0, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd132sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd132sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd132sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x4c,0x02,0x40]
+{evex} vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x4c,0x02,0x40]
 vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x4c,0x02,0x40]
 vfmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0x0a]
-vfmadd132sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0x0a]
+{evex} vfmadd132sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd132sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0x0a]
 vfmadd132sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0x0a]
 vfmadd132sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0x99,0xc9]
 vfmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0x99,0xc9]
 vfmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x99,0xc9]
-vfmadd132sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x99,0xc9]
+{evex} vfmadd132sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd132sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x99,0xc9]
 vfmadd132sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x99,0xc9]
 vfmadd132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x4c,0x02,0x40]
+{evex} vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x4c,0x02,0x40]
 vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x4c,0x02,0x40]
 vfmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd132ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd132ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd132ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd132ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0x0a]
-vfmadd132ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0x0a]
+{evex} vfmadd132ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd132ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0x0a]
 vfmadd132ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0x0a]
 vfmadd132ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0x99,0xc9]
 vfmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0x99,0xc9]
 vfmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd132ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x99,0xc9]
-vfmadd132ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x99,0xc9]
+{evex} vfmadd132ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd132ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x99,0xc9]
 vfmadd132ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x99,0xc9]
 vfmadd132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd213sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd213sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd213sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x4c,0x02,0x40]
+{evex} vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x4c,0x02,0x40]
 vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x4c,0x02,0x40]
 vfmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0x0a]
-vfmadd213sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0x0a]
+{evex} vfmadd213sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd213sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0x0a]
 vfmadd213sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0x0a]
 vfmadd213sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xa9,0xc9]
 vfmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xa9,0xc9]
 vfmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xa9,0xc9]
-vfmadd213sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xa9,0xc9]
+{evex} vfmadd213sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd213sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xa9,0xc9]
 vfmadd213sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xa9,0xc9]
 vfmadd213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x4c,0x02,0x40]
+{evex} vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x4c,0x02,0x40]
 vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x4c,0x02,0x40]
 vfmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd213ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd213ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd213ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd213ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0x0a]
-vfmadd213ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0x0a]
+{evex} vfmadd213ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd213ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0x0a]
 vfmadd213ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0x0a]
 vfmadd213ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xa9,0xc9]
 vfmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xa9,0xc9]
 vfmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd213ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xa9,0xc9]
-vfmadd213ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xa9,0xc9]
+{evex} vfmadd213ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd213ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xa9,0xc9]
 vfmadd213ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xa9,0xc9]
 vfmadd213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd231sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd231sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd231sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x4c,0x02,0x40]
+{evex} vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x4c,0x02,0x40]
 vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x4c,0x02,0x40]
 vfmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0x0a]
-vfmadd231sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0x0a]
+{evex} vfmadd231sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd231sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0x0a]
 vfmadd231sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0x0a]
 vfmadd231sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xb9,0xc9]
 vfmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xb9,0xc9]
 vfmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xb9,0xc9]
-vfmadd231sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xb9,0xc9]
+{evex} vfmadd231sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd231sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xb9,0xc9]
 vfmadd231sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb9,0xc9]
 vfmadd231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x4c,0x02,0x40]
+{evex} vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x4c,0x02,0x40]
 vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x4c,0x02,0x40]
 vfmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmadd231ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmadd231ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmadd231ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmadd231ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmadd231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0x0a]
-vfmadd231ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0x0a]
+{evex} vfmadd231ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmadd231ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0x0a]
 vfmadd231ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0x0a]
 vfmadd231ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xb9,0xc9]
 vfmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xb9,0xc9]
 vfmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmadd231ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xb9,0xc9]
-vfmadd231ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xb9,0xc9]
+{evex} vfmadd231ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmadd231ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xb9,0xc9]
 vfmadd231ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmadd231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xb9,0xc9]
 vfmadd231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub132sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub132sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub132sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x4c,0x02,0x40]
+{evex} vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x4c,0x02,0x40]
 vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x4c,0x02,0x40]
 vfmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0x0a]
-vfmsub132sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0x0a]
+{evex} vfmsub132sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub132sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0x0a]
 vfmsub132sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0x0a]
 vfmsub132sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0x9b,0xc9]
 vfmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0x9b,0xc9]
 vfmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9b,0xc9]
-vfmsub132sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9b,0xc9]
+{evex} vfmsub132sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub132sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9b,0xc9]
 vfmsub132sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9b,0xc9]
 vfmsub132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x4c,0x02,0x40]
+{evex} vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x4c,0x02,0x40]
 vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x4c,0x02,0x40]
 vfmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub132ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub132ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub132ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub132ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0x0a]
-vfmsub132ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0x0a]
+{evex} vfmsub132ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub132ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0x0a]
 vfmsub132ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0x0a]
 vfmsub132ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0x9b,0xc9]
 vfmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0x9b,0xc9]
 vfmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub132ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9b,0xc9]
-vfmsub132ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9b,0xc9]
+{evex} vfmsub132ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub132ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9b,0xc9]
 vfmsub132ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9b,0xc9]
 vfmsub132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub213sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub213sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub213sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x4c,0x02,0x40]
+{evex} vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x4c,0x02,0x40]
 vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x4c,0x02,0x40]
 vfmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0x0a]
-vfmsub213sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0x0a]
+{evex} vfmsub213sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub213sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0x0a]
 vfmsub213sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0x0a]
 vfmsub213sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xab,0xc9]
 vfmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xab,0xc9]
 vfmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xab,0xc9]
-vfmsub213sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xab,0xc9]
+{evex} vfmsub213sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub213sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xab,0xc9]
 vfmsub213sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xab,0xc9]
 vfmsub213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x4c,0x02,0x40]
+{evex} vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x4c,0x02,0x40]
 vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x4c,0x02,0x40]
 vfmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub213ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub213ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub213ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub213ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0x0a]
-vfmsub213ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0x0a]
+{evex} vfmsub213ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub213ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0x0a]
 vfmsub213ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0x0a]
 vfmsub213ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xab,0xc9]
 vfmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xab,0xc9]
 vfmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub213ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xab,0xc9]
-vfmsub213ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xab,0xc9]
+{evex} vfmsub213ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub213ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xab,0xc9]
 vfmsub213ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xab,0xc9]
 vfmsub213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub231sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub231sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub231sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x4c,0x02,0x40]
+{evex} vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x4c,0x02,0x40]
 vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x4c,0x02,0x40]
 vfmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0x0a]
-vfmsub231sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0x0a]
+{evex} vfmsub231sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub231sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0x0a]
 vfmsub231sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0x0a]
 vfmsub231sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xbb,0xc9]
 vfmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xbb,0xc9]
 vfmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbb,0xc9]
-vfmsub231sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbb,0xc9]
+{evex} vfmsub231sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub231sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbb,0xc9]
 vfmsub231sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbb,0xc9]
 vfmsub231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x4c,0x02,0x40]
+{evex} vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x4c,0x02,0x40]
 vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x4c,0x02,0x40]
 vfmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfmsub231ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfmsub231ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfmsub231ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfmsub231ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfmsub231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0x0a]
-vfmsub231ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0x0a]
+{evex} vfmsub231ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfmsub231ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0x0a]
 vfmsub231ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0x0a]
 vfmsub231ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xbb,0xc9]
 vfmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xbb,0xc9]
 vfmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfmsub231ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbb,0xc9]
-vfmsub231ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbb,0xc9]
+{evex} vfmsub231ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfmsub231ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbb,0xc9]
 vfmsub231ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfmsub231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbb,0xc9]
 vfmsub231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x4c,0x02,0x40]
+{evex} vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x4c,0x02,0x40]
 vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x4c,0x02,0x40]
 vfnmadd132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0x0a]
-vfnmadd132sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0x0a]
+{evex} vfnmadd132sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0x0a]
 vfnmadd132sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0x0a]
 vfnmadd132sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0x9d,0xc9]
 vfnmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0x9d,0xc9]
 vfnmadd132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9d,0xc9]
-vfnmadd132sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9d,0xc9]
+{evex} vfnmadd132sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd132sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9d,0xc9]
 vfnmadd132sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9d,0xc9]
 vfnmadd132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x4c,0x02,0x40]
+{evex} vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x4c,0x02,0x40]
 vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x4c,0x02,0x40]
 vfnmadd132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd132ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd132ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0x0a]
-vfnmadd132ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0x0a]
+{evex} vfnmadd132ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0x0a]
 vfnmadd132ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0x0a]
 vfnmadd132ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0x9d,0xc9]
 vfnmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0x9d,0xc9]
 vfnmadd132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd132ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9d,0xc9]
-vfnmadd132ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9d,0xc9]
+{evex} vfnmadd132ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd132ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9d,0xc9]
 vfnmadd132ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9d,0xc9]
 vfnmadd132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x4c,0x02,0x40]
+{evex} vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x4c,0x02,0x40]
 vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x4c,0x02,0x40]
 vfnmadd213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0x0a]
-vfnmadd213sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0x0a]
+{evex} vfnmadd213sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0x0a]
 vfnmadd213sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0x0a]
 vfnmadd213sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xad,0xc9]
 vfnmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xad,0xc9]
 vfnmadd213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xad,0xc9]
-vfnmadd213sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xad,0xc9]
+{evex} vfnmadd213sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd213sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xad,0xc9]
 vfnmadd213sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xad,0xc9]
 vfnmadd213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x4c,0x02,0x40]
+{evex} vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x4c,0x02,0x40]
 vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x4c,0x02,0x40]
 vfnmadd213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd213ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd213ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0x0a]
-vfnmadd213ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0x0a]
+{evex} vfnmadd213ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0x0a]
 vfnmadd213ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0x0a]
 vfnmadd213ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xad,0xc9]
 vfnmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xad,0xc9]
 vfnmadd213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd213ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xad,0xc9]
-vfnmadd213ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xad,0xc9]
+{evex} vfnmadd213ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd213ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xad,0xc9]
 vfnmadd213ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xad,0xc9]
 vfnmadd213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x4c,0x02,0x40]
+{evex} vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x4c,0x02,0x40]
 vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x4c,0x02,0x40]
 vfnmadd231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0x0a]
-vfnmadd231sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0x0a]
+{evex} vfnmadd231sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0x0a]
 vfnmadd231sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0x0a]
 vfnmadd231sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xbd,0xc9]
 vfnmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xbd,0xc9]
 vfnmadd231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbd,0xc9]
-vfnmadd231sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbd,0xc9]
+{evex} vfnmadd231sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd231sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbd,0xc9]
 vfnmadd231sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbd,0xc9]
 vfnmadd231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x4c,0x02,0x40]
+{evex} vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x4c,0x02,0x40]
 vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x4c,0x02,0x40]
 vfnmadd231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmadd231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmadd231ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmadd231ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmadd231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0x0a]
-vfnmadd231ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0x0a]
+{evex} vfnmadd231ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0x0a]
 vfnmadd231ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0x0a]
 vfnmadd231ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xbd,0xc9]
 vfnmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xbd,0xc9]
 vfnmadd231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmadd231ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbd,0xc9]
-vfnmadd231ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbd,0xc9]
+{evex} vfnmadd231ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmadd231ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbd,0xc9]
 vfnmadd231ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmadd231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbd,0xc9]
 vfnmadd231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub132sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x4c,0x02,0x40]
+{evex} vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x4c,0x02,0x40]
 vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x4c,0x02,0x40]
 vfnmsub132sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0x0a]
-vfnmsub132sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0x0a]
+{evex} vfnmsub132sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0x0a]
 vfnmsub132sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0x0a]
 vfnmsub132sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0x9f,0xc9]
 vfnmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0x9f,0xc9]
 vfnmsub132sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0x9f,0xc9]
-vfnmsub132sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0x9f,0xc9]
+{evex} vfnmsub132sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub132sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0x9f,0xc9]
 vfnmsub132sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0x9f,0xc9]
 vfnmsub132sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x4c,0x02,0x40]
+{evex} vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x4c,0x02,0x40]
 vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x4c,0x02,0x40]
 vfnmsub132ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub132ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub132ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub132ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub132ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0x0a]
-vfnmsub132ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0x0a]
+{evex} vfnmsub132ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0x0a]
 vfnmsub132ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0x0a]
 vfnmsub132ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0x9f,0xc9]
 vfnmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0x9f,0xc9]
 vfnmsub132ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub132ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0x9f,0xc9]
-vfnmsub132ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0x9f,0xc9]
+{evex} vfnmsub132ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub132ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x9f,0xc9]
 vfnmsub132ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x9f,0xc9]
 vfnmsub132ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub213sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x4c,0x02,0x40]
+{evex} vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x4c,0x02,0x40]
 vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x4c,0x02,0x40]
 vfnmsub213sd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0x0a]
-vfnmsub213sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0x0a]
+{evex} vfnmsub213sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0x0a]
 vfnmsub213sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0x0a]
 vfnmsub213sd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xaf,0xc9]
 vfnmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xaf,0xc9]
 vfnmsub213sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xaf,0xc9]
-vfnmsub213sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xaf,0xc9]
+{evex} vfnmsub213sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub213sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xaf,0xc9]
 vfnmsub213sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xaf,0xc9]
 vfnmsub213sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x4c,0x02,0x40]
+{evex} vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x4c,0x02,0x40]
 vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x4c,0x02,0x40]
 vfnmsub213ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub213ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub213ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub213ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub213ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0x0a]
-vfnmsub213ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0x0a]
+{evex} vfnmsub213ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0x0a]
 vfnmsub213ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0x0a]
 vfnmsub213ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xaf,0xc9]
 vfnmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xaf,0xc9]
 vfnmsub213ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub213ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xaf,0xc9]
-vfnmsub213ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xaf,0xc9]
+{evex} vfnmsub213ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub213ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xaf,0xc9]
 vfnmsub213ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xaf,0xc9]
 vfnmsub213ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub231sd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231sd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231sd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231sd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231sd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231sd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231sd 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231sd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xb
 vfnmsub231sd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231sd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x8c,0x02,0x00,0x02,0x00,0x00]
-vfnmsub231sd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x4c,0x02,0x40]
+{evex} vfnmsub231sd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x4c,0x02,0x40]
 vfnmsub231sd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0x0a]
-vfnmsub231sd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0x0a]
+{evex} vfnmsub231sd (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0x0a]
 vfnmsub231sd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd {rd-sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf2,0xf5,0x38,0xbf,0xc9]
 vfnmsub231sd {rd-sae}, %xmm1, %xmm1, %xmm1

 // CHECK: encoding: [0x62,0xf2,0xf5,0x7a,0xbf,0xc9]
 vfnmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0xfa,0xbf,0xc9]
 vfnmsub231sd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231sd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0xf1,0xbf,0xc9]
-vfnmsub231sd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0xf5,0x08,0xbf,0xc9]
+{evex} vfnmsub231sd %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub231sd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x0a,0xbf,0xc9]
 vfnmsub231sd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0xf5,0x8a,0xbf,0xc9]
 vfnmsub231sd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x8c,0x02,0x00,0x01,0x00,0x00]
-vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x4c,0x02,0x40]
+{evex} vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x4c,0x02,0x40]
 vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x4c,0x02,0x40]
 vfnmsub231ss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vfnmsub231ss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231ss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231ss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x8a,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
-vfnmsub231ss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vfnmsub231ss 485498096, %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x0d,0xf0,0x1c,0xf0,0x1c]
 vfnmsub231ss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0x0a]
-vfnmsub231ss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0x0a]
+{evex} vfnmsub231ss (%edx), %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0x0a]
 vfnmsub231ss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0x0a]
 vfnmsub231ss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x7a,0xbf,0xc9]
 vfnmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0xfa,0xbf,0xc9]
 vfnmsub231ss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vfnmsub231ss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc4,0xe2,0x71,0xbf,0xc9]
-vfnmsub231ss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x75,0x08,0xbf,0xc9]
+{evex} vfnmsub231ss %xmm1, %xmm1, %xmm1
 
 // CHECK: vfnmsub231ss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0xbf,0xc9]
 vfnmsub231ss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vfnmsub231ss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0xbf,0xc9]
 vfnmsub231ss %xmm1, %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf3,0x75,0x0a,0x27,0xc9,0x00]
 vgetmantss $0, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vgetmantss $0, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf3,0x75,0x8a,0x27,0xc9,0x00]
 vgetmantss $0, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmaxsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmaxsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vmaxsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmaxsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxsd 485498096, %xmm1, %xmm1
 
 // CHECK: vmaxsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmaxsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x8c,0x02,0x00,0x02,0x00,0x00]
-vmaxsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x4c,0x02,0x40]
+{evex} vmaxsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vmaxsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x4c,0x02,0x40]
 vmaxsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x4c,0x02,0x40]
 vmaxsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0x0a]
-vmaxsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0x0a]
+{evex} vmaxsd (%edx), %xmm1, %xmm1
 
 // CHECK: vmaxsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0x0a]
 vmaxsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0x0a]
 vmaxsd (%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd {sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0xf7,0x18,0x5f,0xc9]
 vmaxsd {sae}, %xmm1, %xmm1, %xmm1
 
 // CHECK: vmaxsd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x1a,0x5f,0xc9]
 vmaxsd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x9a,0x5f,0xc9]
 vmaxsd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5f,0xc9]
-vmaxsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5f,0xc9]
+{evex} vmaxsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vmaxsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5f,0xc9]
 vmaxsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5f,0xc9]
 vmaxsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x8c,0x02,0x00,0x01,0x00,0x00]
-vmaxss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x4c,0x02,0x40]
+{evex} vmaxss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vmaxss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x4c,0x02,0x40]
 vmaxss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x4c,0x02,0x40]
 vmaxss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmaxss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmaxss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vmaxss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmaxss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmaxss 485498096, %xmm1, %xmm1
 
 // CHECK: vmaxss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmaxss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0x0a]
-vmaxss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0x0a]
+{evex} vmaxss (%edx), %xmm1, %xmm1
 
 // CHECK: vmaxss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0x0a]
 vmaxss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0x0a]
 vmaxss (%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss {sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x76,0x18,0x5f,0xc9]
 vmaxss {sae}, %xmm1, %xmm1, %xmm1
 
 // CHECK: vmaxss {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x1a,0x5f,0xc9]
 vmaxss {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x9a,0x5f,0xc9]
 vmaxss {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmaxss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5f,0xc9]
-vmaxss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5f,0xc9]
+{evex} vmaxss %xmm1, %xmm1, %xmm1
 
 // CHECK: vmaxss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5f,0xc9]
 vmaxss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmaxss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5f,0xc9]
 vmaxss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vminsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
-vminsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vminsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vminsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
-vminsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vminsd 485498096, %xmm1, %xmm1
 
 // CHECK: vminsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vminsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x8c,0x02,0x00,0x02,0x00,0x00]
-vminsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x4c,0x02,0x40]
+{evex} vminsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vminsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x4c,0x02,0x40]
 vminsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x4c,0x02,0x40]
 vminsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0x0a]
-vminsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0x0a]
+{evex} vminsd (%edx), %xmm1, %xmm1
 
 // CHECK: vminsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0x0a]
 vminsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0x0a]
 vminsd (%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd {sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0xf7,0x18,0x5d,0xc9]
 vminsd {sae}, %xmm1, %xmm1, %xmm1
 
 // CHECK: vminsd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x1a,0x5d,0xc9]
 vminsd {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x9a,0x5d,0xc9]
 vminsd {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5d,0xc9]
-vminsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5d,0xc9]
+{evex} vminsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vminsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5d,0xc9]
 vminsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5d,0xc9]
 vminsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x8c,0x02,0x00,0x01,0x00,0x00]
-vminss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x4c,0x02,0x40]
+{evex} vminss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vminss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x4c,0x02,0x40]
 vminss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x4c,0x02,0x40]
 vminss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vminss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vminss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vminss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vminss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vminss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vminss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vminss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vminss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
-vminss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vminss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vminss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x8a,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
-vminss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vminss 485498096, %xmm1, %xmm1
 
 // CHECK: vminss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x0d,0xf0,0x1c,0xf0,0x1c]
 vminss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0x0a]
-vminss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0x0a]
+{evex} vminss (%edx), %xmm1, %xmm1
 
 // CHECK: vminss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0x0a]
 vminss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0x0a]
 vminss (%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss {sae}, %xmm1, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x76,0x18,0x5d,0xc9]
 vminss {sae}, %xmm1, %xmm1, %xmm1
 
 // CHECK: vminss {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x1a,0x5d,0xc9]
 vminss {sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x9a,0x5d,0xc9]
 vminss {sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vminss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5d,0xc9]
-vminss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5d,0xc9]
+{evex} vminss %xmm1, %xmm1, %xmm1
 
 // CHECK: vminss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5d,0xc9]
 vminss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vminss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5d,0xc9]
 vminss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmovsd -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmovsd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmovsd -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vmovsd 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmovsd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vmovsd -485498096(%edx,%eax,4), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovsd -485498096(%edx,%eax,4), %xmm1 {%k2}
 
 // CHECK: vmovsd 485498096(%edx,%eax,4), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096(%edx,%eax,4), %xmm1 {%k2}
 
 // CHECK: vmovsd -485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovsd -485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 
 // CHECK: vmovsd 485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 
 // CHECK: vmovsd 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmovsd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd 485498096(%edx), %xmm1
 
 // CHECK: vmovsd 485498096(%edx), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096(%edx), %xmm1 {%k2}
 
 // CHECK: vmovsd 485498096(%edx), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096(%edx), %xmm1 {%k2} {z}
 
 // CHECK: vmovsd 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmovsd 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd 485498096, %xmm1
 
 // CHECK: vmovsd 485498096, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096, %xmm1 {%k2}
 
 // CHECK: vmovsd 485498096, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovsd 485498096, %xmm1 {%k2} {z}
 
 // CHECK: vmovsd 512(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x8c,0x02,0x00,0x02,0x00,0x00]
-vmovsd 512(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x4c,0x02,0x40]
+{evex} vmovsd 512(%edx,%eax), %xmm1
 
 // CHECK: vmovsd 512(%edx,%eax), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x4c,0x02,0x40]
 vmovsd 512(%edx,%eax), %xmm1 {%k2}
 
 // CHECK: vmovsd 512(%edx,%eax), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x4c,0x02,0x40]
 vmovsd 512(%edx,%eax), %xmm1 {%k2} {z}
 
 // CHECK: vmovsd (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xfb,0x10,0x0a]
-vmovsd (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x10,0x0a]
+{evex} vmovsd (%edx), %xmm1
 
 // CHECK: vmovsd (%edx), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x10,0x0a]
 vmovsd (%edx), %xmm1 {%k2}
 
 // CHECK: vmovsd (%edx), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xff,0x8a,0x10,0x0a]
 vmovsd (%edx), %xmm1 {%k2} {z}
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x11,0xc9]
-vmovsd.s %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x11,0xc9]
+{evex} vmovsd.s %xmm1, %xmm1, %xmm1
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x11,0xc9]
 vmovsd.s %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x11,0xc9]
 vmovsd.s %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmovsd %xmm1, -485498096(%edx,%eax,4)
-// CHECK: encoding: [0xc5,0xfb,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmovsd %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmovsd %xmm1, -485498096(%edx,%eax,4)
 
 // CHECK: vmovsd %xmm1, 485498096(%edx,%eax,4)
-// CHECK: encoding: [0xc5,0xfb,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmovsd %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd %xmm1, 485498096(%edx,%eax,4)
 
 // CHECK: vmovsd %xmm1, -485498096(%edx,%eax,4) {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovsd %xmm1, -485498096(%edx,%eax,4) {%k2}
 
 // CHECK: vmovsd %xmm1, 485498096(%edx,%eax,4) {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovsd %xmm1, 485498096(%edx,%eax,4) {%k2}
 
 // CHECK: vmovsd %xmm1, 485498096(%edx)
-// CHECK: encoding: [0xc5,0xfb,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmovsd %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd %xmm1, 485498096(%edx)
 
 // CHECK: vmovsd %xmm1, 485498096(%edx) {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovsd %xmm1, 485498096(%edx) {%k2}
 
 // CHECK: vmovsd %xmm1, 485498096
-// CHECK: encoding: [0xc5,0xfb,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmovsd %xmm1, 485498096
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovsd %xmm1, 485498096
 
 // CHECK: vmovsd %xmm1, 485498096 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovsd %xmm1, 485498096 {%k2}
 
 // CHECK: vmovsd %xmm1, 512(%edx,%eax)
-// CHECK: encoding: [0xc5,0xfb,0x11,0x8c,0x02,0x00,0x02,0x00,0x00]
-vmovsd %xmm1, 512(%edx,%eax)
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x4c,0x02,0x40]
+{evex} vmovsd %xmm1, 512(%edx,%eax)
 
 // CHECK: vmovsd %xmm1, 512(%edx,%eax) {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x4c,0x02,0x40]
 vmovsd %xmm1, 512(%edx,%eax) {%k2}
 
 // CHECK: vmovsd %xmm1, (%edx)
-// CHECK: encoding: [0xc5,0xfb,0x11,0x0a]
-vmovsd %xmm1, (%edx)
+// CHECK: encoding: [0x62,0xf1,0xff,0x08,0x11,0x0a]
+{evex} vmovsd %xmm1, (%edx)
 
 // CHECK: vmovsd %xmm1, (%edx) {%k2}
 // CHECK: encoding: [0x62,0xf1,0xff,0x0a,0x11,0x0a]
 vmovsd %xmm1, (%edx) {%k2}
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x10,0xc9]
-vmovsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x10,0xc9]
+{evex} vmovsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x10,0xc9]
 vmovsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmovsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x10,0xc9]
 vmovsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmovss 256(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x8c,0x02,0x00,0x01,0x00,0x00]
-vmovss 256(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x4c,0x02,0x40]
+{evex} vmovss 256(%edx,%eax), %xmm1
 
 // CHECK: vmovss 256(%edx,%eax), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x4c,0x02,0x40]
 vmovss 256(%edx,%eax), %xmm1 {%k2}
 
 // CHECK: vmovss 256(%edx,%eax), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x4c,0x02,0x40]
 vmovss 256(%edx,%eax), %xmm1 {%k2} {z}
 
 // CHECK: vmovss -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmovss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmovss -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vmovss 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmovss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovss 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vmovss -485498096(%edx,%eax,4), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovss -485498096(%edx,%eax,4), %xmm1 {%k2}
 
 // CHECK: vmovss 485498096(%edx,%eax,4), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096(%edx,%eax,4), %xmm1 {%k2}
 
 // CHECK: vmovss -485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovss -485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 
 // CHECK: vmovss 485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096(%edx,%eax,4), %xmm1 {%k2} {z}
 
 // CHECK: vmovss 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmovss 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovss 485498096(%edx), %xmm1
 
 // CHECK: vmovss 485498096(%edx), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096(%edx), %xmm1 {%k2}
 
 // CHECK: vmovss 485498096(%edx), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096(%edx), %xmm1 {%k2} {z}
 
 // CHECK: vmovss 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmovss 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovss 485498096, %xmm1
 
 // CHECK: vmovss 485498096, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096, %xmm1 {%k2}
 
 // CHECK: vmovss 485498096, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovss 485498096, %xmm1 {%k2} {z}
 
 // CHECK: vmovss (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xfa,0x10,0x0a]
-vmovss (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x10,0x0a]
+{evex} vmovss (%edx), %xmm1
 
 // CHECK: vmovss (%edx), %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x10,0x0a]
 vmovss (%edx), %xmm1 {%k2}
 
 // CHECK: vmovss (%edx), %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x8a,0x10,0x0a]
 vmovss (%edx), %xmm1 {%k2} {z}
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x11,0xc9]
-vmovss.s %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x11,0xc9]
+{evex} vmovss.s %xmm1, %xmm1, %xmm1
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x11,0xc9]
 vmovss.s %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x11,0xc9]
 vmovss.s %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmovss %xmm1, 256(%edx,%eax)
-// CHECK: encoding: [0xc5,0xfa,0x11,0x8c,0x02,0x00,0x01,0x00,0x00]
-vmovss %xmm1, 256(%edx,%eax)
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x4c,0x02,0x40]
+{evex} vmovss %xmm1, 256(%edx,%eax)
 
 // CHECK: vmovss %xmm1, 256(%edx,%eax) {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x4c,0x02,0x40]
 vmovss %xmm1, 256(%edx,%eax) {%k2}
 
 // CHECK: vmovss %xmm1, -485498096(%edx,%eax,4)
-// CHECK: encoding: [0xc5,0xfa,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmovss %xmm1, -485498096(%edx,%eax,4)
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmovss %xmm1, -485498096(%edx,%eax,4)
 
 // CHECK: vmovss %xmm1, 485498096(%edx,%eax,4)
-// CHECK: encoding: [0xc5,0xfa,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmovss %xmm1, 485498096(%edx,%eax,4)
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovss %xmm1, 485498096(%edx,%eax,4)
 
 // CHECK: vmovss %xmm1, -485498096(%edx,%eax,4) {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmovss %xmm1, -485498096(%edx,%eax,4) {%k2}
 
 // CHECK: vmovss %xmm1, 485498096(%edx,%eax,4) {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmovss %xmm1, 485498096(%edx,%eax,4) {%k2}
 
 // CHECK: vmovss %xmm1, 485498096(%edx)
-// CHECK: encoding: [0xc5,0xfa,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmovss %xmm1, 485498096(%edx)
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmovss %xmm1, 485498096(%edx)
 
 // CHECK: vmovss %xmm1, 485498096(%edx) {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmovss %xmm1, 485498096(%edx) {%k2}
 
 // CHECK: vmovss %xmm1, 485498096
-// CHECK: encoding: [0xc5,0xfa,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmovss %xmm1, 485498096
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x0d,0xf0,0x1c,0xf0,0x1c
+{evex} vmovss %xmm1, 485498096
 
 // CHECK: vmovss %xmm1, 485498096 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmovss %xmm1, 485498096 {%k2}
 
 // CHECK: vmovss %xmm1, (%edx)
-// CHECK: encoding: [0xc5,0xfa,0x11,0x0a]
-vmovss %xmm1, (%edx)
+// CHECK: encoding: [0x62,0xf1,0x7e,0x08,0x11,0x0a]
+{evex} vmovss %xmm1, (%edx)
 
 // CHECK: vmovss %xmm1, (%edx) {%k2}
 // CHECK: encoding: [0x62,0xf1,0x7e,0x0a,0x11,0x0a]
 vmovss %xmm1, (%edx) {%k2}
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x10,0xc9]
-vmovss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x10,0xc9]
+{evex} vmovss %xmm1, %xmm1, %xmm1
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x10,0xc9]
 vmovss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmovss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x10,0xc9]
 vmovss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmulsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmulsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vmulsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmulsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulsd 485498096, %xmm1, %xmm1
 
 // CHECK: vmulsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmulsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x8c,0x02,0x00,0x02,0x00,0x00]
-vmulsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x4c,0x02,0x40]
+{evex} vmulsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vmulsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x4c,0x02,0x40]
 vmulsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x4c,0x02,0x40]
 vmulsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0x0a]
-vmulsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0x0a]
+{evex} vmulsd (%edx), %xmm1, %xmm1
 
 // CHECK: vmulsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0x0a]
 vmulsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0x0a]
 vmulsd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x59,0xc9]
 vmulsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x59,0xc9]
 vmulsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x59,0xc9]
-vmulsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x59,0xc9]
+{evex} vmulsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vmulsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x59,0xc9]
 vmulsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x59,0xc9]
 vmulsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x8c,0x02,0x00,0x01,0x00,0x00]
-vmulss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x4c,0x02,0x40]
+{evex} vmulss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vmulss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x4c,0x02,0x40]
 vmulss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x4c,0x02,0x40]
 vmulss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vmulss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
-vmulss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vmulss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x8a,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
-vmulss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vmulss 485498096, %xmm1, %xmm1
 
 // CHECK: vmulss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x0d,0xf0,0x1c,0xf0,0x1c]
 vmulss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0x0a]
-vmulss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0x0a]
+{evex} vmulss (%edx), %xmm1, %xmm1
 
 // CHECK: vmulss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0x0a]
 vmulss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0x0a]
 vmulss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x7a,0x59,0xc9]
 vmulss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0xfa,0x59,0xc9]
 vmulss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vmulss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x59,0xc9]
-vmulss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x59,0xc9]
+{evex} vmulss %xmm1, %xmm1, %xmm1
 
 // CHECK: vmulss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x59,0xc9]
 vmulss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vmulss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x59,0xc9]
 vmulss %xmm1, %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf2,0x75,0x0a,0x2d,0xc9]
 vscalefss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vscalefss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf2,0x75,0x8a,0x2d,0xc9]
 vscalefss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsqrtsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
-vsqrtsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vsqrtsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
-vsqrtsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtsd 485498096, %xmm1, %xmm1
 
 // CHECK: vsqrtsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsqrtsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x8c,0x02,0x00,0x02,0x00,0x00]
-vsqrtsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x4c,0x02,0x40]
+{evex} vsqrtsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vsqrtsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x4c,0x02,0x40]
 vsqrtsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x4c,0x02,0x40]
 vsqrtsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0x0a]
-vsqrtsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0x0a]
+{evex} vsqrtsd (%edx), %xmm1, %xmm1
 
 // CHECK: vsqrtsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0x0a]
 vsqrtsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0x0a]
 vsqrtsd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x51,0xc9]
 vsqrtsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x51,0xc9]
 vsqrtsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x51,0xc9]
-vsqrtsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x51,0xc9]
+{evex} vsqrtsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vsqrtsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x51,0xc9]
 vsqrtsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x51,0xc9]
 vsqrtsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x8c,0x02,0x00,0x01,0x00,0x00]
-vsqrtss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x4c,0x02,0x40
+{evex} vsqrtss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vsqrtss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x4c,0x02,0x40]
 vsqrtss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x4c,0x02,0x40]
 vsqrtss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsqrtss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
-vsqrtss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vsqrtss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
-vsqrtss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vsqrtss 485498096, %xmm1, %xmm1
 
 // CHECK: vsqrtss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsqrtss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0x0a]
-vsqrtss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0x0a]
+{evex} vsqrtss (%edx), %xmm1, %xmm1
 
 // CHECK: vsqrtss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0x0a]
 vsqrtss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0x0a]
 vsqrtss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x7a,0x51,0xc9]
 vsqrtss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0xfa,0x51,0xc9]
 vsqrtss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsqrtss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x51,0xc9]
-vsqrtss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x51,0xc9]
+{evex} vsqrtss %xmm1, %xmm1, %xmm1
 
 // CHECK: vsqrtss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x51,0xc9]
 vsqrtss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsqrtss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x51,0xc9]
 vsqrtss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsubsd -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
-vsubsd 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubsd 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vsubsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
-vsubsd 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubsd 485498096, %xmm1, %xmm1
 
 // CHECK: vsubsd 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsubsd 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd 512(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x8c,0x02,0x00,0x02,0x00,0x00]
-vsubsd 512(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x4c,0x02,0x40]
+{evex} vsubsd 512(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vsubsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x4c,0x02,0x40]
 vsubsd 512(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x4c,0x02,0x40]
 vsubsd 512(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0x0a]
-vsubsd (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0x0a]
+{evex} vsubsd (%edx), %xmm1, %xmm1
 
 // CHECK: vsubsd (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0x0a]
 vsubsd (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0x0a]
 vsubsd (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0xf7,0x7a,0x5c,0xc9]
 vsubsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0xfa,0x5c,0xc9]
 vsubsd {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubsd %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf3,0x5c,0xc9]
-vsubsd %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xf7,0x08,0x5c,0xc9]
+{evex} vsubsd %xmm1, %xmm1, %xmm1
 
 // CHECK: vsubsd %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x0a,0x5c,0xc9]
 vsubsd %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0xf7,0x8a,0x5c,0xc9]
 vsubsd %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss 256(%edx,%eax), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x8c,0x02,0x00,0x01,0x00,0x00]
-vsubss 256(%edx,%eax), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x4c,0x02,0x40]
+{evex} vsubss 256(%edx,%eax), %xmm1, %xmm1
 
 // CHECK: vsubss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x4c,0x02,0x40]
 vsubss 256(%edx,%eax), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x4c,0x02,0x40]
 vsubss 256(%edx,%eax), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1
 
 // CHECK: vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
 vsubss -485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096(%edx,%eax,4), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss 485498096(%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
-vsubss 485498096(%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubss 485498096(%edx), %xmm1, %xmm1
 
 // CHECK: vsubss 485498096(%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096(%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x8a,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096(%edx), %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss 485498096, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
-vsubss 485498096, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vsubss 485498096, %xmm1, %xmm1
 
 // CHECK: vsubss 485498096, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss 485498096, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x0d,0xf0,0x1c,0xf0,0x1c]
 vsubss 485498096, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss (%edx), %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0x0a]
-vsubss (%edx), %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0x0a]
+{evex} vsubss (%edx), %xmm1, %xmm1
 
 // CHECK: vsubss (%edx), %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0x0a]
 vsubss (%edx), %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss (%edx), %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0x0a]
 vsubss (%edx), %xmm1, %xmm1 {%k2} {z}

 // CHECK: encoding: [0x62,0xf1,0x76,0x7a,0x5c,0xc9]
 vsubss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0xfa,0x5c,0xc9]
 vsubss {rz-sae}, %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vsubss %xmm1, %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf2,0x5c,0xc9]
-vsubss %xmm1, %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x76,0x08,0x5c,0xc9]
+{evex} vsubss %xmm1, %xmm1, %xmm1
 
 // CHECK: vsubss %xmm1, %xmm1, %xmm1 {%k2}
 // CHECK: encoding: [0x62,0xf1,0x76,0x0a,0x5c,0xc9]
 vsubss %xmm1, %xmm1, %xmm1 {%k2}
 
 // CHECK: vsubss %xmm1, %xmm1, %xmm1 {%k2} {z}
 // CHECK: encoding: [0x62,0xf1,0x76,0x8a,0x5c,0xc9]
 vsubss %xmm1, %xmm1, %xmm1 {%k2} {z}
 
 // CHECK: vucomisd -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vucomisd -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vucomisd -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vucomisd 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vucomisd 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vucomisd 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vucomisd 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c]
-vucomisd 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c
+{evex} vucomisd 485498096(%edx), %xmm1
 
 // CHECK: vucomisd 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
-vucomisd 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vucomisd 485498096, %xmm1
 
 // CHECK: vucomisd 512(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x8c,0x02,0x00,0x02,0x00,0x00]
-vucomisd 512(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x4c,0x02,0x40]
+{evex} vucomisd 512(%edx,%eax), %xmm1
 
 // CHECK: vucomisd (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0x0a]
-vucomisd (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0x0a]
+{evex} vucomisd (%edx), %xmm1
 
 // CHECK: vucomisd {sae}, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0xfd,0x18,0x2e,0xc9]
 vucomisd {sae}, %xmm1, %xmm1
 
 // CHECK: vucomisd %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf9,0x2e,0xc9]
-vucomisd %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0xfd,0x08,0x2e,0xc9]
+{evex} vucomisd %xmm1, %xmm1
 
 // CHECK: vucomiss 256(%edx,%eax), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x8c,0x02,0x00,0x01,0x00,0x00]
-vucomiss 256(%edx,%eax), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x4c,0x02,0x40]
+{evex} vucomiss 256(%edx,%eax), %xmm1
 
 // CHECK: vucomiss -485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
-vucomiss -485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x8c,0x82,0x10,0xe3,0x0f,0xe3]
+{evex} vucomiss -485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vucomiss 485498096(%edx,%eax,4), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
-vucomiss 485498096(%edx,%eax,4), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x8c,0x82,0xf0,0x1c,0xf0,0x1c]
+{evex} vucomiss 485498096(%edx,%eax,4), %xmm1
 
 // CHECK: vucomiss 485498096(%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c]
-vucomiss 485498096(%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x8a,0xf0,0x1c,0xf0,0x1c]
+{evex} vucomiss 485498096(%edx), %xmm1
 
 // CHECK: vucomiss 485498096, %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
-vucomiss 485498096, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x0d,0xf0,0x1c,0xf0,0x1c]
+{evex} vucomiss 485498096, %xmm1
 
 // CHECK: vucomiss (%edx), %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0x0a]
-vucomiss (%edx), %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0x0a]
+{evex} vucomiss (%edx), %xmm1
 
 // CHECK: vucomiss {sae}, %xmm1, %xmm1
 // CHECK: encoding: [0x62,0xf1,0x7c,0x18,0x2e,0xc9]
 vucomiss {sae}, %xmm1, %xmm1
 
 // CHECK: vucomiss %xmm1, %xmm1
-// CHECK: encoding: [0xc5,0xf8,0x2e,0xc9]
-vucomiss %xmm1, %xmm1
+// CHECK: encoding: [0x62,0xf1,0x7c,0x08,0x2e,0xc9]
+{evex} vucomiss %xmm1, %xmm1
 

llvm/trunk/test/MC/X86/x86_errors.s

 // 32: error: instruction requires: 64-bit mode
 cqto
 
 // 32: error: instruction requires: 64-bit mode
 cltq
 
 // 32: error: instruction requires: 64-bit mode
 cmpxchg16b (%eax)
+
+// 32: error: unsupported instruction
+// 64: error: unsupported instruction
+{vex2} vmovdqu32 %xmm0, %xmm0
+
+// 32: error: unsupported instruction
+// 64: error: unsupported instruction
+{vex3} vmovdqu32 %xmm0, %xmm0
+
+// 32: error: unsupported instruction
+// 64: error: unsupported instruction
+{evex} vmovdqu %xmm0, %xmm0