[AMDGPU][MC] Improved diagnostics for invalid literals

[dp]

Summary

Corrected error positions (bug 47518) and improved diagnostic messages for invalid literals.

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

enum ImmTy {
     ImmTyGprIdxMode,
     ImmTyHigh,
     ImmTyBLGP,
     ImmTyCBSZ,
     ImmTyABID,
     ImmTyEndpgm,
   };
 
+  enum ImmKindTy {
+    ImmKindTyNone,
+    ImmKindTyLiteral,
+    ImmKindTyConst,
+  };
+
 private:
   struct TokOp {
     const char *Data;
     unsigned Length;
   };
 
   struct ImmOp {
     int64_t Val;
     ImmTy Type;
     bool IsFPImm;
+    mutable ImmKindTy Kind;
     Modifiers Mods;
   };
 
   struct RegOp {
     unsigned RegNo;
     Modifiers Mods;
   };
 
public:
   bool isSymbolRefExpr() const {
     return isExpr() && Expr && isa<MCSymbolRefExpr>(Expr);
   }
 
   bool isImm() const override {
     return Kind == Immediate;
   }
 
+  void setImmKindNone() const {
+    assert(isImm());
+    Imm.Kind = ImmKindTyNone;
+  }
+
+  void setImmKindLiteral() const {
+    assert(isImm());
+    Imm.Kind = ImmKindTyLiteral;
+  }
+
+  void setImmKindConst() const {
+    assert(isImm());
+    Imm.Kind = ImmKindTyConst;
+  }
+
+  bool IsImmKindLiteral() const {
+    return isImm() && Imm.Kind == ImmKindTyLiteral;
+  }
+
+  bool isImmKindConst() const {
+    return isImm() && Imm.Kind == ImmKindTyConst;
+  }
+
   bool isInlinableImm(MVT type) const;
   bool isLiteralImm(MVT type) const;
 
   bool isRegKind() const {
     return Kind == Register;
   }
 
   bool isReg() const override {
public:
 
   static AMDGPUOperand::Ptr CreateImm(const AMDGPUAsmParser *AsmParser,
                                       int64_t Val, SMLoc Loc,
                                       ImmTy Type = ImmTyNone,
                                       bool IsFPImm = false) {
     auto Op = std::make_unique<AMDGPUOperand>(Immediate, AsmParser);
     Op->Imm.Val = Val;
     Op->Imm.IsFPImm = IsFPImm;
+    Op->Imm.Kind = ImmKindTyNone;
     Op->Imm.Type = Type;
     Op->Imm.Mods = Modifiers();
     Op->StartLoc = Loc;
     Op->EndLoc = Loc;
     return Op;
   }
 
   static AMDGPUOperand::Ptr CreateToken(const AMDGPUAsmParser *AsmParser,
private:
   OperandMatchResultTy parseExpTgtImpl(StringRef Str, uint8_t &Val);
   SMLoc getFlatOffsetLoc(const OperandVector &Operands) const;
   SMLoc getSMEMOffsetLoc(const OperandVector &Operands) const;
 
   SMLoc getOperandLoc(std::function<bool(const AMDGPUOperand&)> Test,
                       const OperandVector &Operands) const;
   SMLoc getImmLoc(AMDGPUOperand::ImmTy Type, const OperandVector &Operands) const;
   SMLoc getRegLoc(unsigned Reg, const OperandVector &Operands) const;
+  SMLoc getLitLoc(const OperandVector &Operands) const;
+  SMLoc getConstLoc(const OperandVector &Operands) const;
 
   bool validateInstruction(const MCInst &Inst, const SMLoc &IDLoc, const OperandVector &Operands);
   bool validateFlatOffset(const MCInst &Inst, const OperandVector &Operands);
   bool validateSMEMOffset(const MCInst &Inst, const OperandVector &Operands);
   bool validateSOPLiteral(const MCInst &Inst) const;
   bool validateConstantBusLimitations(const MCInst &Inst);
   bool validateEarlyClobberLimitations(const MCInst &Inst);
   bool validateIntClampSupported(const MCInst &Inst);
   bool validateMIMGAtomicDMask(const MCInst &Inst);
   bool validateMIMGGatherDMask(const MCInst &Inst);
   bool validateMovrels(const MCInst &Inst);
   bool validateMIMGDataSize(const MCInst &Inst);
   bool validateMIMGAddrSize(const MCInst &Inst);
   bool validateMIMGD16(const MCInst &Inst);
   bool validateMIMGDim(const MCInst &Inst);
   bool validateLdsDirect(const MCInst &Inst);
   bool validateOpSel(const MCInst &Inst);
   bool validateVccOperand(unsigned Reg) const;
-  bool validateVOP3Literal(const MCInst &Inst) const;
+  bool validateVOP3Literal(const MCInst &Inst, const OperandVector &Operands);
   bool validateMAIAccWrite(const MCInst &Inst);
   bool validateDivScale(const MCInst &Inst);
   bool validateCoherencyBits(const MCInst &Inst, const OperandVector &Operands,
                              const SMLoc &IDLoc);
   unsigned getConstantBusLimit(unsigned Opcode) const;
   bool usesConstantBus(const MCInst &Inst, unsigned OpIdx);
   bool isInlineConstant(const MCInst &Inst, unsigned OpIdx) const;
   unsigned findImplicitSGPRReadInVOP(const MCInst &Inst) const;
void AMDGPUOperand::addImmOperands(MCInst &Inst, unsigned N, bool ApplyModifiers) const {
   if (AMDGPU::isSISrcOperand(AsmParser->getMII()->get(Inst.getOpcode()),
                              Inst.getNumOperands())) {
     addLiteralImmOperand(Inst, Imm.Val,
                          ApplyModifiers &
                          isImmTy(ImmTyNone) && Imm.Mods.hasFPModifiers());
   } else {
     assert(!isImmTy(ImmTyNone) || !hasModifiers());
     Inst.addOperand(MCOperand::createImm(Imm.Val));
+    setImmKindNone();
   }
 }
 
 void AMDGPUOperand::addLiteralImmOperand(MCInst &Inst, int64_t Val, bool ApplyModifiers) const {
   const auto& InstDesc = AsmParser->getMII()->get(Inst.getOpcode());
   auto OpNum = Inst.getNumOperands();
   // Check that this operand accepts literals
   assert(AMDGPU::isSISrcOperand(InstDesc, OpNum));
if (Imm.IsFPImm) { // We got fp literal token
     switch (OpTy) {
     case AMDGPU::OPERAND_REG_IMM_INT64:
     case AMDGPU::OPERAND_REG_IMM_FP64:
     case AMDGPU::OPERAND_REG_INLINE_C_INT64:
     case AMDGPU::OPERAND_REG_INLINE_C_FP64:
       if (AMDGPU::isInlinableLiteral64(Literal.getZExtValue(),
                                        AsmParser->hasInv2PiInlineImm())) {
         Inst.addOperand(MCOperand::createImm(Literal.getZExtValue()));
+        setImmKindConst();
         return;
       }
 
       // Non-inlineable
       if (AMDGPU::isSISrcFPOperand(InstDesc, OpNum)) { // Expected 64-bit fp operand
         // For fp operands we check if low 32 bits are zeros
         if (Literal.getLoBits(32) != 0) {
           const_cast<AMDGPUAsmParser *>(AsmParser)->Warning(Inst.getLoc(),
           "Can't encode literal as exact 64-bit floating-point operand. "
           "Low 32-bits will be set to zero");
         }
 
         Inst.addOperand(MCOperand::createImm(Literal.lshr(32).getZExtValue()));
+        setImmKindLiteral();
         return;
       }
 
       // We don't allow fp literals in 64-bit integer instructions. It is
       // unclear how we should encode them. This case should be checked earlier
       // in predicate methods (isLiteralImm())
       llvm_unreachable("fp literal in 64-bit integer instruction.");
 
case AMDGPU::OPERAND_REG_IMM_V2FP16: {
       // Convert literal to single precision
       FPLiteral.convert(*getOpFltSemantics(OpTy),
                         APFloat::rmNearestTiesToEven, &lost);
       // We allow precision lost but not overflow or underflow. This should be
       // checked earlier in isLiteralImm()
 
       uint64_t ImmVal = FPLiteral.bitcastToAPInt().getZExtValue();
       Inst.addOperand(MCOperand::createImm(ImmVal));
+      setImmKindLiteral();
       return;
     }
     default:
       llvm_unreachable("invalid operand size");
     }
 
     return;
   }
 
   // We got int literal token.
   // Only sign extend inline immediates.
   switch (OpTy) {
   case AMDGPU::OPERAND_REG_IMM_INT32:
   case AMDGPU::OPERAND_REG_IMM_FP32:
   case AMDGPU::OPERAND_REG_INLINE_C_INT32:
   case AMDGPU::OPERAND_REG_INLINE_C_FP32:
   case AMDGPU::OPERAND_REG_INLINE_AC_INT32:
   case AMDGPU::OPERAND_REG_INLINE_AC_FP32:
   case AMDGPU::OPERAND_REG_IMM_V2INT16:
   case AMDGPU::OPERAND_REG_IMM_V2FP16:
     if (isSafeTruncation(Val, 32) &&
         AMDGPU::isInlinableLiteral32(static_cast<int32_t>(Val),
                                      AsmParser->hasInv2PiInlineImm())) {
       Inst.addOperand(MCOperand::createImm(Val));
+      setImmKindConst();
       return;
     }
 
     Inst.addOperand(MCOperand::createImm(Val & 0xffffffff));
+    setImmKindLiteral();
     return;
 
   case AMDGPU::OPERAND_REG_IMM_INT64:
   case AMDGPU::OPERAND_REG_IMM_FP64:
   case AMDGPU::OPERAND_REG_INLINE_C_INT64:
   case AMDGPU::OPERAND_REG_INLINE_C_FP64:
     if (AMDGPU::isInlinableLiteral64(Val, AsmParser->hasInv2PiInlineImm())) {
       Inst.addOperand(MCOperand::createImm(Val));
+      setImmKindConst();
       return;
     }
 
     Inst.addOperand(MCOperand::createImm(Lo_32(Val)));
+    setImmKindLiteral();
     return;
 
   case AMDGPU::OPERAND_REG_IMM_INT16:
   case AMDGPU::OPERAND_REG_IMM_FP16:
   case AMDGPU::OPERAND_REG_INLINE_C_INT16:
   case AMDGPU::OPERAND_REG_INLINE_C_FP16:
   case AMDGPU::OPERAND_REG_INLINE_AC_INT16:
   case AMDGPU::OPERAND_REG_INLINE_AC_FP16:
     if (isSafeTruncation(Val, 16) &&
         AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val),
                                      AsmParser->hasInv2PiInlineImm())) {
       Inst.addOperand(MCOperand::createImm(Val));
+      setImmKindConst();
       return;
     }
 
     Inst.addOperand(MCOperand::createImm(Val & 0xffff));
+    setImmKindLiteral();
     return;
 
   case AMDGPU::OPERAND_REG_INLINE_C_V2INT16:
   case AMDGPU::OPERAND_REG_INLINE_C_V2FP16:
   case AMDGPU::OPERAND_REG_INLINE_AC_V2INT16:
   case AMDGPU::OPERAND_REG_INLINE_AC_V2FP16: {
     assert(isSafeTruncation(Val, 16));
     assert(AMDGPU::isInlinableLiteral16(static_cast<int16_t>(Val),
                                         AsmParser->hasInv2PiInlineImm()));
 
     Inst.addOperand(MCOperand::createImm(Val));
     return;
   }
   default:
     llvm_unreachable("invalid operand size");
   }
 }
 
 template <unsigned Bitwidth>
 void AMDGPUOperand::addKImmFPOperands(MCInst &Inst, unsigned N) const {
   APInt Literal(64, Imm.Val);
+  setImmKindNone();
 
   if (!Imm.IsFPImm) {
     // We got int literal token.
     Inst.addOperand(MCOperand::createImm(Literal.getLoBits(Bitwidth).getZExtValue()));
     return;
   }
 
   bool Lost;

 // Check if VCC register matches wavefront size
 bool AMDGPUAsmParser::validateVccOperand(unsigned Reg) const {
   auto FB = getFeatureBits();
   return (FB[AMDGPU::FeatureWavefrontSize64] && Reg == AMDGPU::VCC) ||
     (FB[AMDGPU::FeatureWavefrontSize32] && Reg == AMDGPU::VCC_LO);
 }
 
 // VOP3 literal is only allowed in GFX10+ and only one can be used
-bool AMDGPUAsmParser::validateVOP3Literal(const MCInst &Inst) const {
+bool AMDGPUAsmParser::validateVOP3Literal(const MCInst &Inst,
+                                          const OperandVector &Operands) {
   unsigned Opcode = Inst.getOpcode();
   const MCInstrDesc &Desc = MII.get(Opcode);
   if (!(Desc.TSFlags & (SIInstrFlags::VOP3 | SIInstrFlags::VOP3P)))
     return true;
 
   const int Src0Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src0);
   const int Src1Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src1);
   const int Src2Idx = AMDGPU::getNamedOperandIdx(Opcode, AMDGPU::OpName::src2);
for (int OpIdx : OpIndices) {
 
     const MCOperand &MO = Inst.getOperand(OpIdx);
     if (!MO.isImm() && !MO.isExpr())
       continue;
     if (!AMDGPU::isSISrcOperand(Desc, OpIdx))
       continue;
 
     if (OpIdx == Src2Idx && (Desc.TSFlags & SIInstrFlags::IsMAI) &&
-        getFeatureBits()[AMDGPU::FeatureMFMAInlineLiteralBug])
+        getFeatureBits()[AMDGPU::FeatureMFMAInlineLiteralBug]) {
+      Error(getConstLoc(Operands),
+            "inline constants are not allowed for this operand");
       return false;
+    }
 
     if (MO.isImm() && !isInlineConstant(Inst, OpIdx)) {
       uint32_t Value = static_cast<uint32_t>(MO.getImm());
       if (NumLiterals == 0 || LiteralValue != Value) {
         LiteralValue = Value;
         ++NumLiterals;
       }
     } else if (MO.isExpr()) {
       ++NumExprs;
     }
   }
   NumLiterals += NumExprs;
 
-  return !NumLiterals ||
-         (NumLiterals == 1 && getFeatureBits()[AMDGPU::FeatureVOP3Literal]);
+  if (!NumLiterals)
+    return true;
+
+  if (!getFeatureBits()[AMDGPU::FeatureVOP3Literal]) {
+    Error(getLitLoc(Operands), "literal operands are not supported");
+    return false;
+  }
+
+  if (NumLiterals > 1) {
+    Error(getLitLoc(Operands), "only one literal operand is allowed");
+    return false;
+  }
+
+  return true;
 }
 
 bool AMDGPUAsmParser::validateCoherencyBits(const MCInst &Inst,
                                             const OperandVector &Operands,
                                             const SMLoc &IDLoc) {
   int GLCPos = AMDGPU::getNamedOperandIdx(Inst.getOpcode(),
                                           AMDGPU::OpName::glc1);
   if (GLCPos != -1) {
bool AMDGPUAsmParser::validateInstruction(const MCInst &Inst,
                                           const SMLoc &IDLoc,
                                           const OperandVector &Operands) {
   if (!validateLdsDirect(Inst)) {
     Error(getRegLoc(AMDGPU::LDS_DIRECT, Operands),
       "invalid use of lds_direct");
     return false;
   }
   if (!validateSOPLiteral(Inst)) {
-    Error(IDLoc,
+    Error(getLitLoc(Operands),
       "only one literal operand is allowed");
     return false;
   }
-  if (!validateVOP3Literal(Inst)) {
-    Error(IDLoc,
-      "invalid literal operand");
+  if (!validateVOP3Literal(Inst, Operands)) {
     return false;
   }
   if (!validateConstantBusLimitations(Inst)) {
     Error(IDLoc,
       "invalid operand (violates constant bus restrictions)");
     return false;
   }
   if (!validateEarlyClobberLimitations(Inst)) {

 AMDGPUAsmParser::getRegLoc(unsigned Reg,
                            const OperandVector &Operands) const {
   auto Test = [=](const AMDGPUOperand& Op) {
     return Op.isRegKind() && Op.getReg() == Reg;
   };
   return getOperandLoc(Test, Operands);
 }
 
+SMLoc
+AMDGPUAsmParser::getLitLoc(const OperandVector &Operands) const {
+  auto Test = [](const AMDGPUOperand& Op) {
+    return Op.IsImmKindLiteral() || Op.isExpr();
+  };
+  return getOperandLoc(Test, Operands);
+}
+
+SMLoc
+AMDGPUAsmParser::getConstLoc(const OperandVector &Operands) const {
+  auto Test = [](const AMDGPUOperand& Op) {
+    return Op.isImmKindConst();
+  };
+  return getOperandLoc(Test, Operands);
+}
+
 //===----------------------------------------------------------------------===//
 // swizzle
 //===----------------------------------------------------------------------===//
 
 LLVM_READNONE
 static unsigned
 encodeBitmaskPerm(const unsigned AndMask,
                   const unsigned OrMask,

llvm/test/MC/AMDGPU/expressions-gfx10.s

 
 s_sub_u32 s0, u, u
 // NOGFX10: error: only one literal operand is allowed
 
 s_sub_u32 s0, u, u1
 // NOGFX10: error: only one literal operand is allowed
 
 v_bfe_u32 v0, v2, 123, u
-// NOGFX10: error: invalid literal operand
+// NOGFX10: error: only one literal operand is allowed
 
 v_bfe_u32 v0, v2, u, u
-// NOGFX10: error: invalid literal operand
+// NOGFX10: error: only one literal operand is allowed
 
 v_bfe_u32 v0, v2, u, u1
-// NOGFX10: error: invalid literal operand
+// NOGFX10: error: only one literal operand is allowed

llvm/test/MC/AMDGPU/expressions-gfx9.s

 
 s_sub_u32 s0, u, u
 // NOGFX9: error: only one literal operand is allowed
 
 s_sub_u32 s0, u, u1
 // NOGFX9: error: only one literal operand is allowed
 
 v_bfe_u32 v0, v2, v3, u
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 
 //===----------------------------------------------------------------------===//
 // Constant expressions may be used with 'sext' modifier
 //===----------------------------------------------------------------------===//
 
 i1=1
 
 v_mov_b32_sdwa v1, sext(i1-2)

llvm/test/MC/AMDGPU/gfx10_err_pos.s

 // invalid instruction
 
 v_dot_f32_f16 v0, v1, v2
 // CHECK: error: invalid instruction
 // CHECK-NEXT:{{^}}v_dot_f32_f16 v0, v1, v2
 // CHECK-NEXT:{{^}}^
 
 //==============================================================================
-// invalid literal operand
-
-v_add_f64 v[0:1], 1.23456, -abs(1.2345)
-// CHECK: error: invalid literal operand
-// CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345)
-// CHECK-NEXT:{{^}}^
-
-v_min3_i16 v5, 0x5678, 0x5678, 0x5679
-// CHECK: error: invalid literal operand
-// CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679
-// CHECK-NEXT:{{^}}^
-
-v_pk_add_f16 v1, 25.0, 25.1
-// CHECK: error: invalid literal operand
-// CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1
-// CHECK-NEXT:{{^}}^
-
-//==============================================================================
 // invalid mask
 
 ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2")
 // CHECK: error: invalid mask
 // CHECK-NEXT:{{^}}ds_swizzle_b32 v8, v2 offset:swizzle(BITMASK_PERM, "pppi2")
 // CHECK-NEXT:{{^}}                                                   ^
 
 //==============================================================================

 // CHECK-NEXT:{{^}}                 ^
 
 //==============================================================================
 // only one literal operand is allowed
 
 s_and_b32 s2, 0x12345678, 0x12345679
 // CHECK: error: only one literal operand is allowed
 // CHECK-NEXT:{{^}}s_and_b32 s2, 0x12345678, 0x12345679
-// CHECK-NEXT:{{^}}^
+// CHECK-NEXT:{{^}}                          ^
 
+v_add_f64 v[0:1], 1.23456, -abs(1.2345)
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_add_f64 v[0:1], 1.23456, -abs(1.2345)
+// CHECK-NEXT:{{^}}                                ^
+
+v_min3_i16 v5, 0x5678, 0x5678, 0x5679
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_min3_i16 v5, 0x5678, 0x5678, 0x5679
+// CHECK-NEXT:{{^}}                               ^
+
+v_pk_add_f16 v1, 25.0, 25.1
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_pk_add_f16 v1, 25.0, 25.1
+// CHECK-NEXT:{{^}}                       ^
+
+v_fma_mix_f32 v5, 0x7c, 0x7b, 1
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_fma_mix_f32 v5, 0x7c, 0x7b, 1
+// CHECK-NEXT:{{^}}                        ^
+
+v_pk_add_i16 v5, 0x7c, 0x4000
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x7c, 0x4000
+// CHECK-NEXT:{{^}}                       ^
+
+v_pk_add_i16 v5, 0x4400, 0x4000
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_pk_add_i16 v5, 0x4400, 0x4000
+// CHECK-NEXT:{{^}}                         ^
+
+v_bfe_u32 v0, v2, 123, undef
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, 123, undef
+// CHECK-NEXT:{{^}}                       ^
+
+v_bfe_u32 v0, v2, undef, 123
+// CHECK: error: only one literal operand is allowed
+// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, 123
+// CHECK-NEXT:{{^}}                         ^
+
 //==============================================================================
 // out of bounds attr
 
 v_interp_p1_f32 v0, v1, attr64.w
 // CHECK: error: out of bounds attr
 // CHECK-NEXT:{{^}}v_interp_p1_f32 v0, v1, attr64.w
 // CHECK-NEXT:{{^}}                        ^
 

llvm/test/MC/AMDGPU/gfx7_err_pos.s

 // integer clamping is not supported on this GPU
 
 v_add_co_u32 v84, s[4:5], v13, v31 clamp
 // CHECK: error: integer clamping is not supported on this GPU
 // CHECK-NEXT:{{^}}v_add_co_u32 v84, s[4:5], v13, v31 clamp
 // CHECK-NEXT:{{^}}                                   ^
 
 //==============================================================================
-// invalid literal operand
+// literal operands are not supported
 
 v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
-// CHECK: error: invalid literal operand
+// CHECK: error: literal operands are not supported
 // CHECK-NEXT:{{^}}v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
-// CHECK-NEXT:{{^}}^
+// CHECK-NEXT:{{^}}                  ^

llvm/test/MC/AMDGPU/gfx8_asm_all.s

 
 v_cvt_f16_u16_e64 v5, 0
 // CHECK: [0x05,0x00,0x79,0xd1,0x80,0x00,0x00,0x00]
 
 v_cvt_f16_u16_e64 v5, -1
 // CHECK: [0x05,0x00,0x79,0xd1,0xc1,0x00,0x00,0x00]
 
 v_cvt_f16_u16_e64 v5, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cvt_f16_u16_e64 v5, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cvt_f16_u16_e64 v5, v1 clamp
 // CHECK: [0x05,0x80,0x79,0xd1,0x01,0x01,0x00,0x00]
 
 v_cvt_f16_i16 v5, v1
 // CHECK: [0x01,0x75,0x0a,0x7e]
 
 v_cvt_f16_i16 v255, v1

 
 v_cvt_f16_i16_e64 v5, 0
 // CHECK: [0x05,0x00,0x7a,0xd1,0x80,0x00,0x00,0x00]
 
 v_cvt_f16_i16_e64 v5, -1
 // CHECK: [0x05,0x00,0x7a,0xd1,0xc1,0x00,0x00,0x00]
 
 v_cvt_f16_i16_e64 v5, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cvt_f16_i16_e64 v5, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cvt_f16_i16_e64 v5, v1 clamp
 // CHECK: [0x05,0x80,0x7a,0xd1,0x01,0x01,0x00,0x00]
 
 v_cvt_u16_f16 v5, v1
 // CHECK: [0x01,0x77,0x0a,0x7e]
 
 v_cvt_u16_f16 v255, v1

 
 v_add_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x26,0xd1,0x80,0x04,0x02,0x00]
 
 v_add_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x26,0xd1,0xc1,0x04,0x02,0x00]
 
 v_add_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x26,0xd1,0x01,0xff,0x03,0x00]
 
 v_add_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x05,0x00,0x00]
 
 v_add_u16_e64 v5, v1, s101

 
 v_add_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x01,0x01,0x00]
 
 v_add_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x26,0xd1,0x01,0x83,0x01,0x00]
 
 v_add_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x4e]
 
 v_sub_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x4f]
 
 v_sub_u16 v5, v255, v2

 
 v_sub_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00]
 
 v_sub_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00]
 
 v_sub_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00]
 
 v_sub_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00]
 
 v_sub_u16_e64 v5, v1, s101

 
 v_sub_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00]
 
 v_sub_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00]
 
 v_sub_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x50]
 
 v_subrev_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x51]
 
 v_subrev_u16 v5, v255, v2

 
 v_subrev_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00]
 
 v_subrev_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00]
 
 v_subrev_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00]
 
 v_subrev_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00]
 
 v_subrev_u16_e64 v5, v1, s101

 
 v_subrev_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x01,0x01,0x00]
 
 v_subrev_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x83,0x01,0x00]
 
 v_subrev_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x52]
 
 v_mul_lo_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x53]
 
 v_mul_lo_u16 v5, v255, v2

 
 v_mul_lo_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00]
 
 v_mul_lo_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00]
 
 v_mul_lo_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00]
 
 v_mul_lo_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00]
 
 v_mul_lo_u16_e64 v5, v1, s101

 
 v_mul_lo_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00]
 
 v_mul_lo_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00]
 
 v_mul_lo_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x54]
 
 v_lshlrev_b16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x55]
 
 v_lshlrev_b16 v5, v255, v2

 
 v_lshlrev_b16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00]
 
 v_lshlrev_b16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00]
 
 v_lshlrev_b16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00]
 
 v_lshlrev_b16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00]
 
 v_lshlrev_b16_e64 v5, v1, s101

 
 v_lshlrev_b16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00]
 
 v_lshlrev_b16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00]
 
 v_lshlrev_b16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x56]
 
 v_lshrrev_b16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x57]
 
 v_lshrrev_b16 v5, v255, v2

 
 v_lshrrev_b16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00]
 
 v_lshrrev_b16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00]
 
 v_lshrrev_b16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00]
 
 v_lshrrev_b16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00]
 
 v_lshrrev_b16_e64 v5, v1, s101

 
 v_lshrrev_b16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00]
 
 v_lshrrev_b16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00]
 
 v_lshrrev_b16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x58]
 
 v_ashrrev_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x59]
 
 v_ashrrev_i16 v5, v255, v2

 
 v_ashrrev_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00]
 
 v_ashrrev_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00]
 
 v_ashrrev_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00]
 
 v_ashrrev_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00]
 
 v_ashrrev_i16_e64 v5, v1, s101

 
 v_ashrrev_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00]
 
 v_ashrrev_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00]
 
 v_ashrrev_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_f16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x5a]
 
 v_max_f16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x5b]
 
 v_max_f16 v5, v255, v2

 
 v_max_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00]
 
 v_max_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00]
 
 v_max_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00]
 
 v_max_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00]
 
 v_max_u16_e64 v5, v1, s101

 
 v_max_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00]
 
 v_max_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00]
 
 v_max_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x60]
 
 v_max_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x61]
 
 v_max_i16 v5, v255, v2

 
 v_max_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00]
 
 v_max_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00]
 
 v_max_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00]
 
 v_max_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00]
 
 v_max_i16_e64 v5, v1, s101

 
 v_max_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00]
 
 v_max_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00]
 
 v_max_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x62]
 
 v_min_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x63]
 
 v_min_u16 v5, v255, v2

 
 v_min_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00]
 
 v_min_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00]
 
 v_min_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00]
 
 v_min_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00]
 
 v_min_u16_e64 v5, v1, s101

 
 v_min_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00]
 
 v_min_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00]
 
 v_min_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x64]
 
 v_min_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x65]
 
 v_min_i16 v5, v255, v2

 
 v_min_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00]
 
 v_min_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00]
 
 v_min_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00]
 
 v_min_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00]
 
 v_min_i16_e64 v5, v1, s101

 
 v_min_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00]
 
 v_min_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00]
 
 v_min_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ldexp_f16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x66]
 
 v_ldexp_f16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x67]
 
 v_ldexp_f16 v5, v255, v2

 
 v_mad_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_mad_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0xff,0x0f,0x04]
 
 v_mad_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0c,0x04]
 
 v_mad_u16 v5, v1, s101, v3

 
 v_mad_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04]
 
 v_mad_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0xfe,0x07]
 
 v_mad_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x0e,0x00]
 
 v_mad_u16 v5, v1, v2, s101

 
 v_mad_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x02,0x02]
 
 v_mad_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xeb,0xd1,0x01,0x05,0x06,0x03]
 
 v_mad_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, v3 clamp
 // CHECK: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04]
 
 v_mad_i16 v5, v1, v2, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x04]
 
 v_mad_i16 v255, v1, v2, v3

 
 v_mad_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_mad_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0xff,0x0f,0x04]
 
 v_mad_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0c,0x04]
 
 v_mad_i16 v5, v1, s101, v3

 
 v_mad_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x01,0x0d,0x04]
 
 v_mad_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0xfe,0x07]
 
 v_mad_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x0e,0x00]
 
 v_mad_i16 v5, v1, v2, s101

 
 v_mad_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02]
 
 v_mad_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xec,0xd1,0x01,0x05,0x06,0x03]
 
 v_mad_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, v3 clamp
 // CHECK: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04]
 
 v_perm_b32 v5, v1, v2, v3
 // CHECK: [0x05,0x00,0xed,0xd1,0x01,0x05,0x0e,0x04]
 
 v_perm_b32 v255, v1, v2, v3

 
 v_cmp_f_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_f_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_f_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, s101

 
 v_cmp_f_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x42,0x7d]
 
 v_cmp_lt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x42,0x7d]
 
 v_cmp_lt_i16 vcc, s1, v2

 
 v_cmp_lt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, s101

 
 v_cmp_lt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x44,0x7d]
 
 v_cmp_eq_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x44,0x7d]
 
 v_cmp_eq_i16 vcc, s1, v2

 
 v_cmp_eq_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, s101

 
 v_cmp_eq_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x46,0x7d]
 
 v_cmp_le_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x46,0x7d]
 
 v_cmp_le_i16 vcc, s1, v2

 
 v_cmp_le_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_le_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_le_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, s101

 
 v_cmp_le_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x48,0x7d]
 
 v_cmp_gt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x48,0x7d]
 
 v_cmp_gt_i16 vcc, s1, v2

 
 v_cmp_gt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, s101

 
 v_cmp_gt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4a,0x7d]
 
 v_cmp_ne_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4a,0x7d]
 
 v_cmp_ne_i16 vcc, s1, v2

 
 v_cmp_ne_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, s101

 
 v_cmp_ne_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4c,0x7d]
 
 v_cmp_ge_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4c,0x7d]
 
 v_cmp_ge_i16 vcc, s1, v2

 
 v_cmp_ge_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, s101

 
 v_cmp_ge_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4e,0x7d]
 
 v_cmp_t_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4e,0x7d]
 
 v_cmp_t_i16 vcc, s1, v2

 
 v_cmp_t_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_t_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_t_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, s101

 
 v_cmp_t_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x50,0x7d]
 
 v_cmp_f_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x50,0x7d]
 
 v_cmp_f_u16 vcc, s1, v2

 
 v_cmp_f_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_f_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_f_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, s101

 
 v_cmp_f_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x52,0x7d]
 
 v_cmp_lt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x52,0x7d]
 
 v_cmp_lt_u16 vcc, s1, v2

 
 v_cmp_lt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, s101

 
 v_cmp_lt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x54,0x7d]
 
 v_cmp_eq_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x54,0x7d]
 
 v_cmp_eq_u16 vcc, s1, v2

 
 v_cmp_eq_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, s101

 
 v_cmp_eq_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x56,0x7d]
 
 v_cmp_le_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x56,0x7d]
 
 v_cmp_le_u16 vcc, s1, v2

 
 v_cmp_le_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_le_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_le_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, s101

 
 v_cmp_le_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x58,0x7d]
 
 v_cmp_gt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x58,0x7d]
 
 v_cmp_gt_u16 vcc, s1, v2

 
 v_cmp_gt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, s101

 
 v_cmp_gt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5a,0x7d]
 
 v_cmp_ne_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5a,0x7d]
 
 v_cmp_ne_u16 vcc, s1, v2

 
 v_cmp_ne_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, s101

 
 v_cmp_ne_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5c,0x7d]
 
 v_cmp_ge_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5c,0x7d]
 
 v_cmp_ge_u16 vcc, s1, v2

 
 v_cmp_ge_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, s101

 
 v_cmp_ge_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5e,0x7d]
 
 v_cmp_t_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5e,0x7d]
 
 v_cmp_t_u16 vcc, s1, v2

 
 v_cmp_t_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_t_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_t_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, s101

 
 v_cmp_t_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x60,0x7d]
 
 v_cmpx_f_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x60,0x7d]
 
 v_cmpx_f_i16 vcc, s1, v2

 
 v_cmpx_f_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, s101

 
 v_cmpx_f_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x62,0x7d]
 
 v_cmpx_lt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x62,0x7d]
 
 v_cmpx_lt_i16 vcc, s1, v2

 
 v_cmpx_lt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, s101

 
 v_cmpx_lt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x64,0x7d]
 
 v_cmpx_eq_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x64,0x7d]
 
 v_cmpx_eq_i16 vcc, s1, v2

 
 v_cmpx_eq_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, s101

 
 v_cmpx_eq_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x66,0x7d]
 
 v_cmpx_le_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x66,0x7d]
 
 v_cmpx_le_i16 vcc, s1, v2

 
 v_cmpx_le_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, s101

 
 v_cmpx_le_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x68,0x7d]
 
 v_cmpx_gt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x68,0x7d]
 
 v_cmpx_gt_i16 vcc, s1, v2

 
 v_cmpx_gt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, s101

 
 v_cmpx_gt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6a,0x7d]
 
 v_cmpx_ne_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6a,0x7d]
 
 v_cmpx_ne_i16 vcc, s1, v2

 
 v_cmpx_ne_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, s101

 
 v_cmpx_ne_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6c,0x7d]
 
 v_cmpx_ge_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6c,0x7d]
 
 v_cmpx_ge_i16 vcc, s1, v2

 
 v_cmpx_ge_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, s101

 
 v_cmpx_ge_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6e,0x7d]
 
 v_cmpx_t_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6e,0x7d]
 
 v_cmpx_t_i16 vcc, s1, v2

 
 v_cmpx_t_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, s101

 
 v_cmpx_t_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x70,0x7d]
 
 v_cmpx_f_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x70,0x7d]
 
 v_cmpx_f_u16 vcc, s1, v2

 
 v_cmpx_f_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, s101

 
 v_cmpx_f_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x72,0x7d]
 
 v_cmpx_lt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x72,0x7d]
 
 v_cmpx_lt_u16 vcc, s1, v2

 
 v_cmpx_lt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, s101

 
 v_cmpx_lt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x74,0x7d]
 
 v_cmpx_eq_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x74,0x7d]
 
 v_cmpx_eq_u16 vcc, s1, v2

 
 v_cmpx_eq_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, s101

 
 v_cmpx_eq_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x76,0x7d]
 
 v_cmpx_le_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x76,0x7d]
 
 v_cmpx_le_u16 vcc, s1, v2

 
 v_cmpx_le_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, s101

 
 v_cmpx_le_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x78,0x7d]
 
 v_cmpx_gt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x78,0x7d]
 
 v_cmpx_gt_u16 vcc, s1, v2

 
 v_cmpx_gt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, s101

 
 v_cmpx_gt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7a,0x7d]
 
 v_cmpx_ne_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7a,0x7d]
 
 v_cmpx_ne_u16 vcc, s1, v2

 
 v_cmpx_ne_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, s101

 
 v_cmpx_ne_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7c,0x7d]
 
 v_cmpx_ge_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7c,0x7d]
 
 v_cmpx_ge_u16 vcc, s1, v2

 
 v_cmpx_ge_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, s101

 
 v_cmpx_ge_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7e,0x7d]
 
 v_cmpx_t_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7e,0x7d]
 
 v_cmpx_t_u16 vcc, s1, v2

 
 v_cmpx_t_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, s101

 
 v_cmpx_t_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i32 vcc, v1, v2
 // CHECK: [0x01,0x05,0x80,0x7d]
 
 v_cmp_f_i32 vcc, v255, v2
 // CHECK: [0xff,0x05,0x80,0x7d]
 
 v_cmp_f_i32 vcc, s1, v2

llvm/test/MC/AMDGPU/gfx9-asm-err.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9ERR --implicit-check-not=error: %s
 
 v_cvt_f16_u16_e64 v5, 0.5
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_cvt_f16_u16_e64 v5, -4.0
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, v1, 0.5
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, v1, -4.0
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_cvt_f16_i16_e64 v5, 0.5
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_cvt_f16_i16_e64 v5, -4.0
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, 0.5, v2
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_add_u16_e64 v5, -4.0, v2
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, v1, 0.5
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, v1, -4.0
-// GFX9ERR: error: invalid literal operand
+// GFX9ERR: error: literal operands are not supported

llvm/test/MC/AMDGPU/gfx908_err_pos.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx908 %s 2>&1 | FileCheck %s --implicit-check-not=error: --strict-whitespace
 
 //==============================================================================
+// inline constants are not allowed for this operand
+
+v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
+// CHECK: error: inline constants are not allowed for this operand
+// CHECK-NEXT:{{^}}v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
+// CHECK-NEXT:{{^}}                                       ^
+
+//==============================================================================
 // invalid neg_hi value
 
 v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2]
 // CHECK: error: invalid neg_hi value
 // CHECK-NEXT:{{^}}v_dot2_f32_f16 v0, v1, v2, v3 neg_hi:[0,2]
 // CHECK-NEXT:{{^}}                                        ^
 
 //==============================================================================

llvm/test/MC/AMDGPU/gfx9_asm_all.s

 
 v_sub_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x27,0xd1,0x80,0x04,0x02,0x00]
 
 v_sub_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x27,0xd1,0xc1,0x04,0x02,0x00]
 
 v_sub_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0xff,0x03,0x00]
 
 v_sub_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x05,0x00,0x00]
 
 v_sub_u16_e64 v5, v1, s101

 
 v_sub_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x01,0x01,0x00]
 
 v_sub_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x27,0xd1,0x01,0x83,0x01,0x00]
 
 v_sub_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x50]
 
 v_subrev_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x51]
 
 v_subrev_u16 v5, v255, v2

 
 v_subrev_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x28,0xd1,0x80,0x04,0x02,0x00]
 
 v_subrev_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x28,0xd1,0xc1,0x04,0x02,0x00]
 
 v_subrev_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_subrev_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0xff,0x03,0x00]
 
 v_subrev_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x28,0xd1,0x01,0x05,0x00,0x00]
 
 v_subrev_u16_e64 v5, v1, s101

 
 v_mul_lo_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x29,0xd1,0x80,0x04,0x02,0x00]
 
 v_mul_lo_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x29,0xd1,0xc1,0x04,0x02,0x00]
 
 v_mul_lo_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0xff,0x03,0x00]
 
 v_mul_lo_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x05,0x00,0x00]
 
 v_mul_lo_u16_e64 v5, v1, s101

 
 v_mul_lo_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x01,0x01,0x00]
 
 v_mul_lo_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x29,0xd1,0x01,0x83,0x01,0x00]
 
 v_mul_lo_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mul_lo_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x54]
 
 v_lshlrev_b16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x55]
 
 v_lshlrev_b16 v5, v255, v2

 
 v_lshlrev_b16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2a,0xd1,0x80,0x04,0x02,0x00]
 
 v_lshlrev_b16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2a,0xd1,0xc1,0x04,0x02,0x00]
 
 v_lshlrev_b16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0xff,0x03,0x00]
 
 v_lshlrev_b16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x05,0x00,0x00]
 
 v_lshlrev_b16_e64 v5, v1, s101

 
 v_lshlrev_b16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x01,0x01,0x00]
 
 v_lshlrev_b16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2a,0xd1,0x01,0x83,0x01,0x00]
 
 v_lshlrev_b16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshlrev_b16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x56]
 
 v_lshrrev_b16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x57]
 
 v_lshrrev_b16 v5, v255, v2

 
 v_lshrrev_b16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2b,0xd1,0x80,0x04,0x02,0x00]
 
 v_lshrrev_b16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2b,0xd1,0xc1,0x04,0x02,0x00]
 
 v_lshrrev_b16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0xff,0x03,0x00]
 
 v_lshrrev_b16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x05,0x00,0x00]
 
 v_lshrrev_b16_e64 v5, v1, s101

 
 v_lshrrev_b16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x01,0x01,0x00]
 
 v_lshrrev_b16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2b,0xd1,0x01,0x83,0x01,0x00]
 
 v_lshrrev_b16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_lshrrev_b16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x58]
 
 v_ashrrev_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x59]
 
 v_ashrrev_i16 v5, v255, v2

 
 v_ashrrev_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2c,0xd1,0x80,0x04,0x02,0x00]
 
 v_ashrrev_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2c,0xd1,0xc1,0x04,0x02,0x00]
 
 v_ashrrev_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0xff,0x03,0x00]
 
 v_ashrrev_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x05,0x00,0x00]
 
 v_ashrrev_i16_e64 v5, v1, s101

 
 v_ashrrev_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x01,0x01,0x00]
 
 v_ashrrev_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2c,0xd1,0x01,0x83,0x01,0x00]
 
 v_ashrrev_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ashrrev_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_f16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x5a]
 
 v_max_f16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x5b]
 
 v_max_f16 v5, v255, v2

 
 v_max_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x2f,0xd1,0x80,0x04,0x02,0x00]
 
 v_max_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x2f,0xd1,0xc1,0x04,0x02,0x00]
 
 v_max_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0xff,0x03,0x00]
 
 v_max_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x05,0x00,0x00]
 
 v_max_u16_e64 v5, v1, s101

 
 v_max_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x01,0x01,0x00]
 
 v_max_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x2f,0xd1,0x01,0x83,0x01,0x00]
 
 v_max_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x60]
 
 v_max_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x61]
 
 v_max_i16 v5, v255, v2

 
 v_max_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x30,0xd1,0x80,0x04,0x02,0x00]
 
 v_max_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x30,0xd1,0xc1,0x04,0x02,0x00]
 
 v_max_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0xff,0x03,0x00]
 
 v_max_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x05,0x00,0x00]
 
 v_max_i16_e64 v5, v1, s101

 
 v_max_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x01,0x01,0x00]
 
 v_max_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x30,0xd1,0x01,0x83,0x01,0x00]
 
 v_max_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x62]
 
 v_min_u16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x63]
 
 v_min_u16 v5, v255, v2

 
 v_min_u16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x31,0xd1,0x80,0x04,0x02,0x00]
 
 v_min_u16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x31,0xd1,0xc1,0x04,0x02,0x00]
 
 v_min_u16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0xff,0x03,0x00]
 
 v_min_u16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x05,0x00,0x00]
 
 v_min_u16_e64 v5, v1, s101

 
 v_min_u16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x01,0x01,0x00]
 
 v_min_u16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x31,0xd1,0x01,0x83,0x01,0x00]
 
 v_min_u16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_u16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x64]
 
 v_min_i16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x65]
 
 v_min_i16 v5, v255, v2

 
 v_min_i16_e64 v5, 0, v2
 // CHECK: [0x05,0x00,0x32,0xd1,0x80,0x04,0x02,0x00]
 
 v_min_i16_e64 v5, -1, v2
 // CHECK: [0x05,0x00,0x32,0xd1,0xc1,0x04,0x02,0x00]
 
 v_min_i16_e64 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, v1, v255
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0xff,0x03,0x00]
 
 v_min_i16_e64 v5, v1, s2
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x05,0x00,0x00]
 
 v_min_i16_e64 v5, v1, s101

 
 v_min_i16_e64 v5, v1, 0
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x01,0x01,0x00]
 
 v_min_i16_e64 v5, v1, -1
 // CHECK: [0x05,0x00,0x32,0xd1,0x01,0x83,0x01,0x00]
 
 v_min_i16_e64 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min_i16_e64 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_ldexp_f16 v5, v1, v2
 // CHECK: [0x01,0x05,0x0a,0x66]
 
 v_ldexp_f16 v255, v1, v2
 // CHECK: [0x01,0x05,0xfe,0x67]
 
 v_ldexp_f16 v5, v255, v2

 
 v_mad_u32_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_u32_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_mad_u32_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u32_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u32_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0xff,0x0f,0x04]
 
 v_mad_u32_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0c,0x04]
 
 v_mad_u32_u16 v5, v1, s101, v3

 
 v_mad_u32_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x01,0x0d,0x04]
 
 v_mad_u32_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_u32_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u32_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u32_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0xfe,0x07]
 
 v_mad_u32_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf1,0xd1,0x01,0x05,0x0e,0x00]
 
 v_mad_u32_u16 v5, v1, v2, s101

 
 v_mad_i32_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_i32_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_mad_i32_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i32_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i32_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0xff,0x0f,0x04]
 
 v_mad_i32_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0c,0x04]
 
 v_mad_i32_i16 v5, v1, s101, v3

 
 v_mad_i32_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x01,0x0d,0x04]
 
 v_mad_i32_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_i32_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i32_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i32_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0xfe,0x07]
 
 v_mad_i32_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf2,0xd1,0x01,0x05,0x0e,0x00]
 
 v_mad_i32_i16 v5, v1, v2, s101

 
 v_min3_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x80,0x04,0x0e,0x04]
 
 v_min3_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_min3_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0xff,0x0f,0x04]
 
 v_min3_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0c,0x04]
 
 v_min3_i16 v5, v1, s101, v3

 
 v_min3_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x01,0x0d,0x04]
 
 v_min3_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x83,0x0d,0x04]
 
 v_min3_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0xfe,0x07]
 
 v_min3_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x00]
 
 v_min3_i16 v5, v1, v2, s101

 
 v_min3_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x02,0x02]
 
 v_min3_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x06,0x03]
 
 v_min3_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xf5,0xd1,0x01,0x05,0x0e,0x04]
 
 v_min3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xf5,0xd1,0x01,0x05,0x0e,0x04]
 
 v_min3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_min3_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x80,0x04,0x0e,0x04]
 
 v_min3_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_min3_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0xff,0x0f,0x04]
 
 v_min3_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0c,0x04]
 
 v_min3_u16 v5, v1, s101, v3

 
 v_min3_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x01,0x0d,0x04]
 
 v_min3_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x83,0x0d,0x04]
 
 v_min3_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0xfe,0x07]
 
 v_min3_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x00]
 
 v_min3_u16 v5, v1, v2, s101

 
 v_min3_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x02,0x02]
 
 v_min3_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x06,0x03]
 
 v_min3_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_min3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xf6,0xd1,0x01,0x05,0x0e,0x04]
 
 v_min3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xf6,0xd1,0x01,0x05,0x0e,0x04]
 
 v_min3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_max3_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x80,0x04,0x0e,0x04]
 
 v_max3_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_max3_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0xff,0x0f,0x04]
 
 v_max3_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0c,0x04]
 
 v_max3_i16 v5, v1, s101, v3

 
 v_max3_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x01,0x0d,0x04]
 
 v_max3_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x83,0x0d,0x04]
 
 v_max3_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0xfe,0x07]
 
 v_max3_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x00]
 
 v_max3_i16 v5, v1, v2, s101

 
 v_max3_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x02,0x02]
 
 v_max3_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x06,0x03]
 
 v_max3_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xf8,0xd1,0x01,0x05,0x0e,0x04]
 
 v_max3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xf8,0xd1,0x01,0x05,0x0e,0x04]
 
 v_max3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_max3_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x80,0x04,0x0e,0x04]
 
 v_max3_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_max3_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0xff,0x0f,0x04]
 
 v_max3_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0c,0x04]
 
 v_max3_u16 v5, v1, s101, v3

 
 v_max3_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x01,0x0d,0x04]
 
 v_max3_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x83,0x0d,0x04]
 
 v_max3_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0xfe,0x07]
 
 v_max3_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x00]
 
 v_max3_u16 v5, v1, v2, s101

 
 v_max3_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x02,0x02]
 
 v_max3_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x06,0x03]
 
 v_max3_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_max3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xf9,0xd1,0x01,0x05,0x0e,0x04]
 
 v_max3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xf9,0xd1,0x01,0x05,0x0e,0x04]
 
 v_max3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_med3_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x80,0x04,0x0e,0x04]
 
 v_med3_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_med3_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0xff,0x0f,0x04]
 
 v_med3_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0c,0x04]
 
 v_med3_i16 v5, v1, s101, v3

 
 v_med3_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x01,0x0d,0x04]
 
 v_med3_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x83,0x0d,0x04]
 
 v_med3_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0xfe,0x07]
 
 v_med3_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x00]
 
 v_med3_i16 v5, v1, v2, s101

 
 v_med3_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x02,0x02]
 
 v_med3_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x06,0x03]
 
 v_med3_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xfb,0xd1,0x01,0x05,0x0e,0x04]
 
 v_med3_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xfb,0xd1,0x01,0x05,0x0e,0x04]
 
 v_med3_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_med3_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x80,0x04,0x0e,0x04]
 
 v_med3_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0xc1,0x04,0x0e,0x04]
 
 v_med3_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0xff,0x0f,0x04]
 
 v_med3_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0c,0x04]
 
 v_med3_u16 v5, v1, s101, v3

 
 v_med3_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x01,0x0d,0x04]
 
 v_med3_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x83,0x0d,0x04]
 
 v_med3_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0xfe,0x07]
 
 v_med3_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x00]
 
 v_med3_u16 v5, v1, v2, s101

 
 v_med3_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x02,0x02]
 
 v_med3_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x06,0x03]
 
 v_med3_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_med3_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0xfc,0xd1,0x01,0x05,0x0e,0x04]
 
 v_med3_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0xfc,0xd1,0x01,0x05,0x0e,0x04]
 
 v_med3_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_mad_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04]
 
 v_mad_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0xc1,0x04,0x0e,0x04]
 
 v_mad_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0xff,0x0f,0x04]
 
 v_mad_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0c,0x04]
 
 v_mad_u16 v5, v1, s101, v3

 
 v_mad_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x01,0x0d,0x04]
 
 v_mad_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04]
 
 v_mad_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0xfe,0x07]
 
 v_mad_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x00]
 
 v_mad_u16 v5, v1, v2, s101

 
 v_mad_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x02,0x02]
 
 v_mad_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x06,0x03]
 
 v_mad_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0x04,0xd2,0x01,0x05,0x0e,0x04]
 
 v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04]
 
 v_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_mad_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0x80,0x04,0x0e,0x04]
 
 v_mad_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0xc1,0x04,0x0e,0x04]
 
 v_mad_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0xff,0x0f,0x04]
 
 v_mad_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0c,0x04]
 
 v_mad_i16 v5, v1, s101, v3

 
 v_mad_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x01,0x0d,0x04]
 
 v_mad_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04]
 
 v_mad_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0xfe,0x07]
 
 v_mad_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x00]
 
 v_mad_i16 v5, v1, v2, s101

 
 v_mad_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x02,0x02]
 
 v_mad_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x06,0x03]
 
 v_mad_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,0]
 // CHECK: [0x05,0x00,0x05,0xd2,0x01,0x05,0x0e,0x04]
 
 v_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // CHECK: [0x05,0x08,0x05,0xd2,0x01,0x05,0x0e,0x04]
 
 v_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0,0]

 
 v_add_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x9e,0xd2,0x80,0x04,0x02,0x00]
 
 v_add_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x9e,0xd2,0xc1,0x04,0x02,0x00]
 
 v_add_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0xff,0x03,0x00]
 
 v_add_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x00,0x00]
 
 v_add_i16 v5, v1, s101

 
 v_add_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x01,0x01,0x00]
 
 v_add_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x83,0x01,0x00]
 
 v_add_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_add_i16 v5, v1, v2 op_sel:[0,0,0]
 // CHECK: [0x05,0x00,0x9e,0xd2,0x01,0x05,0x02,0x00]
 
 v_add_i16 v5, v1, v2 op_sel:[1,0,0]
 // CHECK: [0x05,0x08,0x9e,0xd2,0x01,0x05,0x02,0x00]
 
 v_add_i16 v5, v1, v2 op_sel:[0,1,0]

 
 v_sub_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x9f,0xd2,0x80,0x04,0x02,0x00]
 
 v_sub_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x9f,0xd2,0xc1,0x04,0x02,0x00]
 
 v_sub_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0xff,0x03,0x00]
 
 v_sub_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x00,0x00]
 
 v_sub_i16 v5, v1, s101

 
 v_sub_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x01,0x01,0x00]
 
 v_sub_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x83,0x01,0x00]
 
 v_sub_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_sub_i16 v5, v1, v2 op_sel:[0,0,0]
 // CHECK: [0x05,0x00,0x9f,0xd2,0x01,0x05,0x02,0x00]
 
 v_sub_i16 v5, v1, v2 op_sel:[1,0,0]
 // CHECK: [0x05,0x08,0x9f,0xd2,0x01,0x05,0x02,0x00]
 
 v_sub_i16 v5, v1, v2 op_sel:[0,1,0]

 
 v_pk_mad_i16 v5, 0, v2, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0x80,0x04,0x0e,0x1c]
 
 v_pk_mad_i16 v5, -1, v2, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0xc1,0x04,0x0e,0x1c]
 
 v_pk_mad_i16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, v1, v255, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0xff,0x0f,0x1c]
 
 v_pk_mad_i16 v5, v1, s2, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0c,0x1c]
 
 v_pk_mad_i16 v5, v1, s101, v3

 
 v_pk_mad_i16 v5, v1, 0, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x01,0x0d,0x1c]
 
 v_pk_mad_i16 v5, v1, -1, v3
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x83,0x0d,0x1c]
 
 v_pk_mad_i16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, v1, v2, v255
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0xfe,0x1f]
 
 v_pk_mad_i16 v5, v1, v2, s3
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x0e,0x18]
 
 v_pk_mad_i16 v5, v1, v2, s101

 
 v_pk_mad_i16 v5, v1, v2, 0
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x02,0x1a]
 
 v_pk_mad_i16 v5, v1, v2, -1
 // CHECK: [0x05,0x40,0x80,0xd3,0x01,0x05,0x06,0x1b]
 
 v_pk_mad_i16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_i16 v5, v1, v2, v3 op_sel:[1,0,0]
 // CHECK: [0x05,0x48,0x80,0xd3,0x01,0x05,0x0e,0x1c]
 
 v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,1,0]
 // CHECK: [0x05,0x50,0x80,0xd3,0x01,0x05,0x0e,0x1c]
 
 v_pk_mad_i16 v5, v1, v2, v3 op_sel:[0,0,1]

 
 v_pk_mul_lo_u16 v5, 0, v2
 // CHECK: [0x05,0x00,0x81,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_mul_lo_u16 v5, -1, v2
 // CHECK: [0x05,0x00,0x81,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_mul_lo_u16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mul_lo_u16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mul_lo_u16 v5, v1, v255
 // CHECK: [0x05,0x00,0x81,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_mul_lo_u16 v5, v1, s2
 // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_mul_lo_u16 v5, v1, s101

 
 v_pk_mul_lo_u16 v5, v1, 0
 // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_mul_lo_u16 v5, v1, -1
 // CHECK: [0x05,0x00,0x81,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_mul_lo_u16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mul_lo_u16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x81,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_mul_lo_u16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x81,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_mul_lo_u16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_add_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x82,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_add_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x82,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_add_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x82,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_add_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_add_i16 v5, v1, s101

 
 v_pk_add_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_add_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x82,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_add_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x82,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_add_i16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x82,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_add_i16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_sub_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x83,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_sub_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x83,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_sub_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x83,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_sub_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_sub_i16 v5, v1, s101

 
 v_pk_sub_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_sub_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x83,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_sub_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_i16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x83,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_sub_i16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x83,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_sub_i16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_lshlrev_b16 v5, 0, v2
 // CHECK: [0x05,0x00,0x84,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_lshlrev_b16 v5, -1, v2
 // CHECK: [0x05,0x00,0x84,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_lshlrev_b16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshlrev_b16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshlrev_b16 v5, v1, v255
 // CHECK: [0x05,0x00,0x84,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_lshlrev_b16 v5, v1, s2
 // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_lshlrev_b16 v5, v1, s101

 
 v_pk_lshlrev_b16 v5, v1, 0
 // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_lshlrev_b16 v5, v1, -1
 // CHECK: [0x05,0x00,0x84,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_lshlrev_b16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshlrev_b16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x84,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_lshlrev_b16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x84,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_lshlrev_b16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_lshrrev_b16 v5, 0, v2
 // CHECK: [0x05,0x00,0x85,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_lshrrev_b16 v5, -1, v2
 // CHECK: [0x05,0x00,0x85,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_lshrrev_b16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshrrev_b16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshrrev_b16 v5, v1, v255
 // CHECK: [0x05,0x00,0x85,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_lshrrev_b16 v5, v1, s2
 // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_lshrrev_b16 v5, v1, s101

 
 v_pk_lshrrev_b16 v5, v1, 0
 // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_lshrrev_b16 v5, v1, -1
 // CHECK: [0x05,0x00,0x85,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_lshrrev_b16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshrrev_b16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x85,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_lshrrev_b16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x85,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_lshrrev_b16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_ashrrev_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x86,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_ashrrev_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x86,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_ashrrev_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_ashrrev_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_ashrrev_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x86,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_ashrrev_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_ashrrev_i16 v5, v1, s101

 
 v_pk_ashrrev_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_ashrrev_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x86,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_ashrrev_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_ashrrev_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x86,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_ashrrev_i16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x86,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_ashrrev_i16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_max_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x87,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_max_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x87,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_max_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x87,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_max_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_max_i16 v5, v1, s101

 
 v_pk_max_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_max_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x87,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_max_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_i16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x87,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_max_i16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x87,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_max_i16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_min_i16 v5, 0, v2
 // CHECK: [0x05,0x00,0x88,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_min_i16 v5, -1, v2
 // CHECK: [0x05,0x00,0x88,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_min_i16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_i16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_i16 v5, v1, v255
 // CHECK: [0x05,0x00,0x88,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_min_i16 v5, v1, s2
 // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_min_i16 v5, v1, s101

 
 v_pk_min_i16 v5, v1, 0
 // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_min_i16 v5, v1, -1
 // CHECK: [0x05,0x00,0x88,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_min_i16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_i16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_i16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x88,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_min_i16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x88,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_min_i16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_mad_u16 v5, 0, v2, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0x80,0x04,0x0e,0x1c]
 
 v_pk_mad_u16 v5, -1, v2, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0xc1,0x04,0x0e,0x1c]
 
 v_pk_mad_u16 v5, 0.5, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, -4.0, v2, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, v1, v255, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0xff,0x0f,0x1c]
 
 v_pk_mad_u16 v5, v1, s2, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0c,0x1c]
 
 v_pk_mad_u16 v5, v1, s101, v3

 
 v_pk_mad_u16 v5, v1, 0, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x01,0x0d,0x1c]
 
 v_pk_mad_u16 v5, v1, -1, v3
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x83,0x0d,0x1c]
 
 v_pk_mad_u16 v5, v1, 0.5, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, v1, -4.0, v3
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, v1, v2, v255
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0xfe,0x1f]
 
 v_pk_mad_u16 v5, v1, v2, s3
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x0e,0x18]
 
 v_pk_mad_u16 v5, v1, v2, s101

 
 v_pk_mad_u16 v5, v1, v2, 0
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x02,0x1a]
 
 v_pk_mad_u16 v5, v1, v2, -1
 // CHECK: [0x05,0x40,0x89,0xd3,0x01,0x05,0x06,0x1b]
 
 v_pk_mad_u16 v5, v1, v2, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, v1, v2, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0]
 // CHECK: [0x05,0x48,0x89,0xd3,0x01,0x05,0x0e,0x1c]
 
 v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,1,0]
 // CHECK: [0x05,0x50,0x89,0xd3,0x01,0x05,0x0e,0x1c]
 
 v_pk_mad_u16 v5, v1, v2, v3 op_sel:[0,0,1]

 
 v_pk_add_u16 v5, 0, v2
 // CHECK: [0x05,0x00,0x8a,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_add_u16 v5, -1, v2
 // CHECK: [0x05,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_add_u16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v5, v1, v255
 // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_add_u16 v5, v1, s2
 // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_add_u16 v5, v1, s101

 
 v_pk_add_u16 v5, v1, 0
 // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_add_u16 v5, v1, -1
 // CHECK: [0x05,0x00,0x8a,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_add_u16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x8a,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_add_u16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x8a,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_add_u16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_sub_u16 v5, 0, v2
 // CHECK: [0x05,0x00,0x8b,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_sub_u16 v5, -1, v2
 // CHECK: [0x05,0x00,0x8b,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_sub_u16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_u16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_u16 v5, v1, v255
 // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_sub_u16 v5, v1, s2
 // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_sub_u16 v5, v1, s101

 
 v_pk_sub_u16 v5, v1, 0
 // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_sub_u16 v5, v1, -1
 // CHECK: [0x05,0x00,0x8b,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_sub_u16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_u16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_sub_u16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x8b,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_sub_u16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x8b,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_sub_u16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_max_u16 v5, 0, v2
 // CHECK: [0x05,0x00,0x8c,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_max_u16 v5, -1, v2
 // CHECK: [0x05,0x00,0x8c,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_max_u16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_u16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_u16 v5, v1, v255
 // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_max_u16 v5, v1, s2
 // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_max_u16 v5, v1, s101

 
 v_pk_max_u16 v5, v1, 0
 // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_max_u16 v5, v1, -1
 // CHECK: [0x05,0x00,0x8c,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_max_u16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_u16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_max_u16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x8c,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_max_u16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x8c,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_max_u16 v5, v1, v2 op_sel:[1,1]

 
 v_pk_min_u16 v5, 0, v2
 // CHECK: [0x05,0x00,0x8d,0xd3,0x80,0x04,0x02,0x18]
 
 v_pk_min_u16 v5, -1, v2
 // CHECK: [0x05,0x00,0x8d,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_min_u16 v5, 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_u16 v5, -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_u16 v5, v1, v255
 // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0xff,0x03,0x18]
 
 v_pk_min_u16 v5, v1, s2
 // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x05,0x00,0x18]
 
 v_pk_min_u16 v5, v1, s101

 
 v_pk_min_u16 v5, v1, 0
 // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x01,0x01,0x18]
 
 v_pk_min_u16 v5, v1, -1
 // CHECK: [0x05,0x00,0x8d,0xd3,0x01,0x83,0x01,0x18]
 
 v_pk_min_u16 v5, v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_u16 v5, v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_pk_min_u16 v5, v1, v2 op_sel:[1,0]
 // CHECK: [0x05,0x08,0x8d,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_min_u16 v5, v1, v2 op_sel:[0,1]
 // CHECK: [0x05,0x10,0x8d,0xd3,0x01,0x05,0x02,0x18]
 
 v_pk_min_u16 v5, v1, v2 op_sel:[1,1]

 
 v_cmp_f_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_f_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_f_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, s101

 
 v_cmp_f_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa0,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_f_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x42,0x7d]
 
 v_cmp_lt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x42,0x7d]
 
 v_cmp_lt_i16 vcc, s1, v2

 
 v_cmp_lt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, s101

 
 v_cmp_lt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa1,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_lt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x44,0x7d]
 
 v_cmp_eq_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x44,0x7d]
 
 v_cmp_eq_i16 vcc, s1, v2

 
 v_cmp_eq_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, s101

 
 v_cmp_eq_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa2,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_eq_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x46,0x7d]
 
 v_cmp_le_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x46,0x7d]
 
 v_cmp_le_i16 vcc, s1, v2

 
 v_cmp_le_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_le_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_le_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, s101

 
 v_cmp_le_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa3,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_le_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x48,0x7d]
 
 v_cmp_gt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x48,0x7d]
 
 v_cmp_gt_i16 vcc, s1, v2

 
 v_cmp_gt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, s101

 
 v_cmp_gt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa4,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_gt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4a,0x7d]
 
 v_cmp_ne_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4a,0x7d]
 
 v_cmp_ne_i16 vcc, s1, v2

 
 v_cmp_ne_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, s101

 
 v_cmp_ne_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa5,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ne_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4c,0x7d]
 
 v_cmp_ge_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4c,0x7d]
 
 v_cmp_ge_i16 vcc, s1, v2

 
 v_cmp_ge_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, s101

 
 v_cmp_ge_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa6,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ge_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x4e,0x7d]
 
 v_cmp_t_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x4e,0x7d]
 
 v_cmp_t_i16 vcc, s1, v2

 
 v_cmp_t_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_t_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_t_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, s101

 
 v_cmp_t_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa7,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_t_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x50,0x7d]
 
 v_cmp_f_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x50,0x7d]
 
 v_cmp_f_u16 vcc, s1, v2

 
 v_cmp_f_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_f_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_f_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, s101

 
 v_cmp_f_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa8,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_f_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x52,0x7d]
 
 v_cmp_lt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x52,0x7d]
 
 v_cmp_lt_u16 vcc, s1, v2

 
 v_cmp_lt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, s101

 
 v_cmp_lt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xa9,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_lt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_lt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x54,0x7d]
 
 v_cmp_eq_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x54,0x7d]
 
 v_cmp_eq_u16 vcc, s1, v2

 
 v_cmp_eq_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, s101

 
 v_cmp_eq_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xaa,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_eq_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_eq_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x56,0x7d]
 
 v_cmp_le_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x56,0x7d]
 
 v_cmp_le_u16 vcc, s1, v2

 
 v_cmp_le_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xab,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_le_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xab,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_le_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, s101

 
 v_cmp_le_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xab,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_le_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_le_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x58,0x7d]
 
 v_cmp_gt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x58,0x7d]
 
 v_cmp_gt_u16 vcc, s1, v2

 
 v_cmp_gt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xac,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xac,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, s101

 
 v_cmp_gt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xac,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_gt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_gt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5a,0x7d]
 
 v_cmp_ne_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5a,0x7d]
 
 v_cmp_ne_u16 vcc, s1, v2

 
 v_cmp_ne_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xad,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xad,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, s101

 
 v_cmp_ne_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xad,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ne_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ne_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5c,0x7d]
 
 v_cmp_ge_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5c,0x7d]
 
 v_cmp_ge_u16 vcc, s1, v2

 
 v_cmp_ge_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xae,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xae,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, s101

 
 v_cmp_ge_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xae,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_ge_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_ge_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x5e,0x7d]
 
 v_cmp_t_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x5e,0x7d]
 
 v_cmp_t_u16 vcc, s1, v2

 
 v_cmp_t_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmp_t_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmp_t_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, s101

 
 v_cmp_t_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xaf,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmp_t_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_t_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x60,0x7d]
 
 v_cmpx_f_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x60,0x7d]
 
 v_cmpx_f_i16 vcc, s1, v2

 
 v_cmpx_f_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, s101

 
 v_cmpx_f_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb0,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_f_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x62,0x7d]
 
 v_cmpx_lt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x62,0x7d]
 
 v_cmpx_lt_i16 vcc, s1, v2

 
 v_cmpx_lt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, s101

 
 v_cmpx_lt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb1,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_lt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x64,0x7d]
 
 v_cmpx_eq_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x64,0x7d]
 
 v_cmpx_eq_i16 vcc, s1, v2

 
 v_cmpx_eq_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, s101

 
 v_cmpx_eq_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb2,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_eq_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x66,0x7d]
 
 v_cmpx_le_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x66,0x7d]
 
 v_cmpx_le_i16 vcc, s1, v2

 
 v_cmpx_le_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, s101

 
 v_cmpx_le_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb3,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_le_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x68,0x7d]
 
 v_cmpx_gt_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x68,0x7d]
 
 v_cmpx_gt_i16 vcc, s1, v2

 
 v_cmpx_gt_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, s101

 
 v_cmpx_gt_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb4,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_gt_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6a,0x7d]
 
 v_cmpx_ne_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6a,0x7d]
 
 v_cmpx_ne_i16 vcc, s1, v2

 
 v_cmpx_ne_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, s101

 
 v_cmpx_ne_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb5,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ne_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6c,0x7d]
 
 v_cmpx_ge_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6c,0x7d]
 
 v_cmpx_ge_i16 vcc, s1, v2

 
 v_cmpx_ge_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, s101

 
 v_cmpx_ge_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb6,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ge_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x6e,0x7d]
 
 v_cmpx_t_i16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x6e,0x7d]
 
 v_cmpx_t_i16 vcc, s1, v2

 
 v_cmpx_t_i16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, s101

 
 v_cmpx_t_i16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb7,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_t_i16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_i16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x70,0x7d]
 
 v_cmpx_f_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x70,0x7d]
 
 v_cmpx_f_u16 vcc, s1, v2

 
 v_cmpx_f_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, s101

 
 v_cmpx_f_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb8,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_f_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_f_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x72,0x7d]
 
 v_cmpx_lt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x72,0x7d]
 
 v_cmpx_lt_u16 vcc, s1, v2

 
 v_cmpx_lt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, s101

 
 v_cmpx_lt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xb9,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_lt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_lt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x74,0x7d]
 
 v_cmpx_eq_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x74,0x7d]
 
 v_cmpx_eq_u16 vcc, s1, v2

 
 v_cmpx_eq_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xba,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xba,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, s101

 
 v_cmpx_eq_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xba,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_eq_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_eq_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x76,0x7d]
 
 v_cmpx_le_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x76,0x7d]
 
 v_cmpx_le_u16 vcc, s1, v2

 
 v_cmpx_le_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, s101

 
 v_cmpx_le_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbb,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_le_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_le_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x78,0x7d]
 
 v_cmpx_gt_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x78,0x7d]
 
 v_cmpx_gt_u16 vcc, s1, v2

 
 v_cmpx_gt_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, s101

 
 v_cmpx_gt_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbc,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_gt_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_gt_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7a,0x7d]
 
 v_cmpx_ne_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7a,0x7d]
 
 v_cmpx_ne_u16 vcc, s1, v2

 
 v_cmpx_ne_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, s101

 
 v_cmpx_ne_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbd,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ne_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ne_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7c,0x7d]
 
 v_cmpx_ge_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7c,0x7d]
 
 v_cmpx_ge_u16 vcc, s1, v2

 
 v_cmpx_ge_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, s101

 
 v_cmpx_ge_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbe,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_ge_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_ge_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16 vcc, v1, v2
 // CHECK: [0x01,0x05,0x7e,0x7d]
 
 v_cmpx_t_u16 vcc, v255, v2
 // CHECK: [0xff,0x05,0x7e,0x7d]
 
 v_cmpx_t_u16 vcc, s1, v2

 
 v_cmpx_t_u16_e64 s[10:11], 0, v2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x80,0x04,0x02,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], -1, v2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0xc1,0x04,0x02,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], 0.5, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], -4.0, v2
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], v1, v255
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0xff,0x03,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, s2
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x05,0x00,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, s101

 
 v_cmpx_t_u16_e64 s[10:11], v1, 0
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x01,0x01,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, -1
 // CHECK: [0x0a,0x00,0xbf,0xd0,0x01,0x83,0x01,0x00]
 
 v_cmpx_t_u16_e64 s[10:11], v1, 0.5
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmpx_t_u16_e64 s[10:11], v1, -4.0
-// CHECK-ERR: error: invalid literal operand
+// CHECK-ERR: error: literal operands are not supported
 
 v_cmp_f_i32 vcc, v1, v2
 // CHECK: [0x01,0x05,0x80,0x7d]
 
 v_cmp_f_i32 vcc, v255, v2
 // CHECK: [0xff,0x05,0x80,0x7d]
 
 v_cmp_f_i32 vcc, s1, v2

llvm/test/MC/AMDGPU/gfx9_err_pos.s

 // invalid operand (violates constant bus restrictions)
 
 v_add_f32_e64 v0, flat_scratch_hi, m0
 // CHECK: error: invalid operand (violates constant bus restrictions)
 // CHECK-NEXT:{{^}}v_add_f32_e64 v0, flat_scratch_hi, m0
 // CHECK-NEXT:{{^}}^
 
 //==============================================================================
+// literal operands are not supported
+
+v_bfe_u32 v0, v2, v3, undef
+// CHECK: error: literal operands are not supported
+// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, v3, undef
+// CHECK-NEXT:{{^}}                      ^
+
+v_bfe_u32 v0, v2, undef, v3
+// CHECK: error: literal operands are not supported
+// CHECK-NEXT:{{^}}v_bfe_u32 v0, v2, undef, v3
+// CHECK-NEXT:{{^}}                  ^
+
+v_add_i16 v5, v1, 0.5
+// CHECK: error: literal operands are not supported
+// CHECK-NEXT:{{^}}v_add_i16 v5, v1, 0.5
+// CHECK-NEXT:{{^}}                  ^
+
+v_add_i16 v5, 0.5, v2
+// CHECK: error: literal operands are not supported
+// CHECK-NEXT:{{^}}v_add_i16 v5, 0.5, v2
+// CHECK-NEXT:{{^}}              ^
+
+//==============================================================================
 // r128 modifier is not supported on this GPU
 
 image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
 // CHECK: error: r128 modifier is not supported on this GPU
 // CHECK-NEXT:{{^}}image_atomic_add v10, v6, s[8:15] dmask:0x1 r128
 // CHECK-NEXT:{{^}}                                            ^
 
 //==============================================================================

llvm/test/MC/AMDGPU/literals.s

 // SICI: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x42,0x00,0x7e,0xd2,0x04,0x00,0x00]
 // GFX89: v_trunc_f32_e32 v0, 0x4d2 ; encoding: [0xff,0x38,0x00,0x7e,0xd2,0x04,0x00,0x00]
 v_trunc_f32_e32 v0, 1234
 
 // SICI: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x7c,0x00,0x7e,0xd2,0x04,0x00,0x00]
 // GFX89: v_fract_f64_e32 v[0:1], 0x4d2 ; encoding: [0xff,0x64,0x00,0x7e,0xd2,0x04,0x00,0x00]
 v_fract_f64_e32 v[0:1], 1234
 
-// NOSICI: error: invalid literal operand
-// NOGFX89: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
+// NOGFX89: error: literal operands are not supported
 v_trunc_f32_e64 v0, 1234
 
-// NOSICI: error: invalid literal operand
-// NOGFX89: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
+// NOGFX89: error: literal operands are not supported
 v_fract_f64_e64 v[0:1], 1234
 
 // SICI: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x42,0x00,0x7e,0xcf,0x2b,0xff,0xff]
 // GFX89: v_trunc_f32_e32 v0, 0xffff2bcf ; encoding: [0xff,0x38,0x00,0x7e,0xcf,0x2b,0xff,0xff]
 v_trunc_f32_e32 v0, -54321
 
 // SICI: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x7c,0x00,0x7e,0xcf,0x2b,0xff,0xff]
 // GFX89: v_fract_f64_e32 v[0:1], 0xffff2bcf ; encoding: [0xff,0x64,0x00,0x7e,0xcf,0x2b,0xff,0xff]

 // SICI: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x04,0x80,0xbe,0xd2,0x04,0x00,0x00]
 // GFX89: s_mov_b64 s[0:1], 0x4d2 ; encoding: [0xff,0x01,0x80,0xbe,0xd2,0x04,0x00,0x00]
 s_mov_b64_e32 s[0:1], 1234
 
 // SICI: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x36,0xd2,0x04,0x00,0x00]
 // GFX89: v_and_b32_e32 v0, 0x4d2, v1 ; encoding: [0xff,0x02,0x00,0x26,0xd2,0x04,0x00,0x00]
 v_and_b32_e32 v0, 1234, v1
 
-// NOSICI: error: invalid literal operand
-// NOGFX89: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
+// NOGFX89: error: literal operands are not supported
 v_and_b32_e64 v0, 1234, v1
 
 // SICI: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x04,0x80,0xbe,0xcf,0x2b,0xff,0xff]
 // GFX89: s_mov_b64 s[0:1], 0xffff2bcf ; encoding: [0xff,0x01,0x80,0xbe,0xcf,0x2b,0xff,0xff]
 s_mov_b64_e32 s[0:1], -54321
 
 // SICI: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x36,0xcf,0x2b,0xff,0xff]
 // GFX89: v_and_b32_e32 v0, 0xffff2bcf, v1 ; encoding: [0xff,0x02,0x00,0x26,0xcf,0x2b,0xff,0xff]

 // NOSICI: error: invalid operand for instruction
 // NOGFX89: error: invalid operand for instruction
 v_trunc_f32_e64 v0, 0x3fc45f306dc9c882
 
 // NOSICI: error: invalid operand for instruction
 // GFX89: v_fract_f64_e64 v[0:1], 0.15915494309189532 ; encoding: [0x00,0x00,0x72,0xd1,0xf8,0x00,0x00,0x00]
 v_fract_f64_e64 v[0:1], 0x3fc45f306dc9c882
 
-// NOSICI: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
 // GFX89: v_trunc_f32_e64 v0, 0.15915494 ; encoding: [0x00,0x00,0x5c,0xd1,0xf8,0x00,0x00,0x00]
 v_trunc_f32_e64 v0, 0x3e22f983
 
-// NOSICI: error: invalid literal operand
-// NOGFX89: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
+// NOGFX89: error: literal operands are not supported
 v_fract_f64_e64 v[0:1], 0x3e22f983
 
 // NOSICI: error: invalid operand for instruction
 // GFX89: s_mov_b64 s[0:1], 0.15915494309189532 ; encoding: [0xf8,0x01,0x80,0xbe]
 s_mov_b64_e32 s[0:1], 0.159154943091895317852646485335
 
 // SICI: v_and_b32_e32 v0, 0x3e22f983, v1 ; encoding: [0xff,0x02,0x00,0x36,0x83,0xf9,0x22,0x3e]
 // GFX89: v_and_b32_e32 v0, 0.15915494, v1 ; encoding: [0xf8,0x02,0x00,0x26]
 v_and_b32_e32 v0, 0.159154943091895317852646485335, v1
 
-// NOSICI: error: invalid literal operand
+// NOSICI: error: literal operands are not supported
 // GFX89: v_and_b32_e64 v0, 0.15915494, v1 ; encoding: [0x00,0x00,0x13,0xd1,0xf8,0x02,0x02,0x00]
 v_and_b32_e64 v0, 0.159154943091895317852646485335, v1
 
 // SICI: v_fract_f64_e32 v[0:1], 0x3fc45f30 ; encoding: [0xff,0x7c,0x00,0x7e,0x30,0x5f,0xc4,0x3f]
 // GFX89: v_fract_f64_e32 v[0:1], 0.15915494309189532 ; encoding: [0xf8,0x64,0x00,0x7e]
 v_fract_f64 v[0:1], 0.159154943091895317852646485335
 
 // SICI: v_trunc_f32_e32 v0, 0x3e22f983 ; encoding: [0xff,0x42,0x00,0x7e,0x83,0xf9,0x22,0x3e]

llvm/test/MC/AMDGPU/literalv216-err.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck -check-prefix=GFX9 --implicit-check-not=error: %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 %s 2>&1 | FileCheck -check-prefix=GFX10 --implicit-check-not=error: %s
 
 v_pk_add_f16 v1, -17, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, 65, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, 64.0, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, -0.15915494, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, -0.0, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, -32768, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, 32767, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, 0xffffffffffff000f, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_add_f16 v1, 0x1000ffff, v2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_mad_i16 v5, 0x3c00, 0x4000, 0x4400
-// GFX9: error: invalid literal operand
-// GFX10: error: invalid literal operand
+// GFX9: error: literal operands are not supported
+// GFX10: error: only one literal operand is allowed
 
 v_pk_mad_i16 v5, 0x3c00, 0x4000, 2
-// GFX9: error: invalid literal operand
-// GFX10: error: invalid literal operand
+// GFX9: error: literal operands are not supported
+// GFX10: error: only one literal operand is allowed
 
 v_pk_mad_i16 v5, 0x3c00, 3, 2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_mad_i16 v5, 3, 0x3c00, 2
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported
 
 v_pk_mad_i16 v5, 3, 2, 0x3c00
-// GFX9: error: invalid literal operand
+// GFX9: error: literal operands are not supported

llvm/test/MC/AMDGPU/literalv216.s

 // GFX9: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x8f,0xd3,0xc1,0x04,0x02,0x18]
 // GFX10: v_pk_add_f16 v1, -1, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xc1,0x04,0x02,0x18]
 
 //===----------------------------------------------------------------------===//
 // Integer literals
 //===----------------------------------------------------------------------===//
 
 v_pk_add_f16 v5, v1, 0x12345678
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_f16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
 
 v_pk_add_f16 v5, 0x12345678, v2
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_f16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
 
 v_pk_add_f16 v5, -256, v2
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_f16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff]
 
 v_pk_add_f16 v5, v1, 256
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_f16 v5, v1, 0x100      ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00]
 
 v_pk_add_u16 v5, v1, 0x12345678
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_u16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
 
 v_pk_add_u16 v5, 0x12345678, v2
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_u16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
 
 v_pk_add_u16 v5, -256, v2
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_u16 v5, 0xffffff00, v2 ; encoding: [0x05,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x00,0xff,0xff,0xff]
 
 v_pk_add_u16 v5, v1, 256
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_u16 v5, v1, 0x100      ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0x00,0x01,0x00,0x00]
 
 v_pk_add_f16 v5, v1, 0x123456780
 // NOGFX9: error: invalid operand for instruction
 // NOGFX10: error: invalid operand for instruction
 
 v_pk_add_u16 v5, v1, 0x123456780
 // NOGFX9: error: invalid operand for instruction
 // NOGFX10: error: invalid operand for instruction
 
 v_pk_fma_f16 v5, 0xaf123456, v2, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf]
 
 v_pk_fma_f16 v5, v1, 0xaf123456, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf]
 
 v_pk_fma_f16 v5, v1, v2, 0xaf123456
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf]
 
 v_pk_mad_i16 v5, 0xaf123456, v2, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0x56,0x34,0x12,0xaf]
 
 v_pk_mad_i16 v5, v1, 0xaf123456, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0x56,0x34,0x12,0xaf]
 
 v_pk_mad_i16 v5, v1, v2, 0xaf123456
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0x56,0x34,0x12,0xaf]
 
 v_pk_ashrrev_i16 v5, 0x12345678, v2
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_ashrrev_i16 v5, 0x12345678, v2 ; encoding: [0x05,0x00,0x06,0xcc,0xff,0x04,0x02,0x18,0x78,0x56,0x34,0x12]
 
 v_pk_ashrrev_i16 v5, v1, 0x12345678
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_ashrrev_i16 v5, v1, 0x12345678 ; encoding: [0x05,0x00,0x06,0xcc,0x01,0xff,0x01,0x18,0x78,0x56,0x34,0x12]
 
 //===----------------------------------------------------------------------===//
 // Floating-point literals (allowed if lossless conversion to f16 is possible)
 //===----------------------------------------------------------------------===//
 
 v_pk_add_f16 v5, v1, 0.1234
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_f16 v5, v1, 0x2fe6     ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00]
 
 v_pk_add_u16 v5, v1, 0.1234
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_add_u16 v5, v1, 0x2fe6     ; encoding: [0x05,0x00,0x0a,0xcc,0x01,0xff,0x01,0x18,0xe6,0x2f,0x00,0x00]
 
 v_pk_fma_f16 v5, 0.1234, v2, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00]
 
 v_pk_fma_f16 v5, v1, 0.1234, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00]
 
 v_pk_fma_f16 v5, v1, v2, 0.1234
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_fma_f16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x0e,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00]
 
 v_pk_mad_i16 v5, 0.1234, v2, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, 0x2fe6, v2, v3 ; encoding: [0x05,0x40,0x00,0xcc,0xff,0x04,0x0e,0x1c,0xe6,0x2f,0x00,0x00]
 
 v_pk_mad_i16 v5, v1, 0.1234, v3
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, v1, 0x2fe6, v3 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0xff,0x0d,0x1c,0xe6,0x2f,0x00,0x00]
 
 v_pk_mad_i16 v5, v1, v2, 0.1234
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // GFX10: v_pk_mad_i16 v5, v1, v2, 0x2fe6 ; encoding: [0x05,0x40,0x00,0xcc,0x01,0x05,0xfe,0x1b,0xe6,0x2f,0x00,0x00]
 
 v_pk_add_f16 v5, v1, 123456.0
 // NOGFX9: error: invalid operand for instruction
 // NOGFX10: error: invalid operand for instruction
 
 v_pk_add_u16 v5, v1, 123456.0
 // NOGFX9: error: invalid operand for instruction

llvm/test/MC/AMDGPU/mai-err.s

 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 65
 // GFX908: error: invalid operand for instruction
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, 0
 // GFX900: error: instruction not supported on this GPU
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x1f32 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x1f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x1f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2f32 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f32 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4f16 a[0:31], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x4f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x4f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x8f16 a[0:15], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], v[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], v[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x16f16 a[0:3], a[0:1], a[1:2], -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], v0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], v0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], a0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x4i8 a[0:31], a0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x4i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_4x4x4i8 a[0:3], a0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], v0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], v0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], a0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_32x32x8i8 a[0:15], a0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], v0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], v0, a1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], a0, v1, 2 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_i32_16x16x16i8 a[0:3], a0, a1, 2
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x2bf16 a[0:31], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x2bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_4x4x2bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_32x32x4bf16 a[0:15], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], v0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], v0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], a0, v1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU
 
 v_mfma_f32_16x16x8bf16 a[0:3], a0, a1, -2.0 cbsz:3 abid:2 blgp:7
-// GFX908: error: invalid literal operand
+// GFX908: error: inline constants are not allowed for this operand
 // GFX900: error: instruction not supported on this GPU

llvm/test/MC/AMDGPU/vop2-err.s

 // RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck --implicit-check-not=error: %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck --implicit-check-not=error: %s
 
 //===----------------------------------------------------------------------===//
 // Generic checks
 //===----------------------------------------------------------------------===//
 
 v_mul_i32_i24 v1, v2, 100
-// CHECK: error: invalid literal operand
+// CHECK: error: literal operands are not supported
 
 //===----------------------------------------------------------------------===//
 // _e32 checks
 //===----------------------------------------------------------------------===//
 
 // Immediate src1
 v_mul_i32_i24_e32 v1, v2, 100
 // CHECK: error: invalid operand for instruction
 
 // sgpr src1
 v_mul_i32_i24_e32 v1, v2, s3
 // CHECK: error: invalid operand for instruction
 
 v_cndmask_b32_e32 v1, v2, v3, s[0:1]
 // CHECK: error: invalid operand for instruction
 
 //===----------------------------------------------------------------------===//
 // _e64 checks
 //===----------------------------------------------------------------------===//
 
 // Immediate src0
 v_mul_i32_i24_e64 v1, 100, v3
-// CHECK: error: invalid literal operand
+// CHECK: error: literal operands are not supported
 
 // Immediate src1
 v_mul_i32_i24_e64 v1, v2, 100
-// CHECK: error: invalid literal operand
+// CHECK: error: literal operands are not supported
 
 v_add_i32_e32 v1, s[0:1], v2, v3
 // CHECK: error: invalid operand for instruction
 
 v_addc_u32_e32 v1, vcc, v2, v3, s[2:3]
 // CHECK: error: invalid operand for instruction
 
 v_addc_u32_e32 v1, s[0:1], v2, v3, s[2:3]

llvm/test/MC/AMDGPU/vop3-errs.s

 // RUN: not llvm-mc -arch=amdgcn %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error:
 // RUN: not llvm-mc -arch=amdgcn -mcpu=tahiti %s 2>&1 | FileCheck %s --check-prefix=GFX67 --check-prefix=GCN --implicit-check-not=error:
 // RUN: not llvm-mc -arch=amdgcn -mcpu=fiji %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error:
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900 %s 2>&1 | FileCheck %s --check-prefix=GFX89 --check-prefix=GCN --implicit-check-not=error:
 
 v_add_f32_e64 v0, v1
 // GCN: error: too few operands for instruction
 
 v_div_scale_f32  v24, vcc, v22, 1.1, v22
-// GCN: error: invalid literal operand
+// GCN: error: literal operands are not supported
 
 v_mqsad_u32_u8 v[0:3], s[2:3], v4, v[0:3]
 // GFX67: error: instruction not supported on this GPU
 // GFX89: error: destination must be different than all sources
 
 v_mqsad_pk_u16_u8 v[0:1], v[1:2], v9, v[4:5]
 // GCN: error: destination must be different than all sources
 

llvm/test/MC/AMDGPU/vop3-gfx9.s

 // VI: v_mad_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_i16 v5, v1, -1, v3
 // GFX9: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x05,0xd2,0x01,0x83,0x0d,0x04]
 // NOSICI: error: instruction not supported on this GPU
 // VI: v_mad_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_i16 v5, v1, v2, -4.0
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOSICI: error: instruction not supported on this GPU
-// NOVI: error: invalid literal operand
+// NOVI: error: literal operands are not supported
 
 v_mad_i16 v5, v1, v2, v3 clamp
 // GFX9: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x05,0xd2,0x01,0x05,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 // VI: v_mad_i16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xec,0xd1,0x01,0x05,0x0e,0x04]
 
 v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1]
 // GFX9: v_mad_i16 v5, v1, v2, v3 op_sel:[0,0,0,1] ; encoding: [0x05,0x40,0x05,0xd2,0x01,0x05,0x0e,0x04]

 // GFX9: v_mad_legacy_i16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x80,0x04,0x0e,0x04]
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_i16 v5, v1, -1, v3
 // GFX9: v_mad_legacy_i16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x83,0x0d,0x04]
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_i16 v5, v1, v2, -4.0
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_i16 v5, v1, v2, -4.0 clamp
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_u16_e64 v5, 0, v2, v3
 // GFX9: v_mad_legacy_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_u16 v5, v1, -1, v3
 // GFX9: v_mad_legacy_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_u16 v5, v1, v2, -4.0
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_legacy_u16 v5, v1, v2, -4.0 clamp
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOGCN: error: instruction not supported on this GPU
 
 v_mad_u16_e64 v5, 0, v2, v3
 // GFX9: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x80,0x04,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 // VI: v_mad_u16 v5, 0, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x80,0x04,0x0e,0x04]
 
 v_mad_u16 v5, v1, -1, v3
 // GFX9: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0x04,0xd2,0x01,0x83,0x0d,0x04]
 // NOSICI: error: instruction not supported on this GPU
 // VI: v_mad_u16 v5, v1, -1, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x83,0x0d,0x04]
 
 v_mad_u16 v5, v1, v2, -4.0
-// NOGFX9: error: invalid literal operand
+// NOGFX9: error: literal operands are not supported
 // NOSICI: error: instruction not supported on this GPU
-// NOVI: error: invalid literal operand
+// NOVI: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, v3 clamp
 // GFX9: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0x04,0xd2,0x01,0x05,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 // VI: v_mad_u16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xeb,0xd1,0x01,0x05,0x0e,0x04]
 
 v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0]
 // GFX9: v_mad_u16 v5, v1, v2, v3 op_sel:[1,0,0,0] ; encoding: [0x05,0x08,0x04,0xd2,0x01,0x05,0x0e,0x04]

llvm/test/MC/AMDGPU/vop3-literal.s

 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 -show-encoding %s | FileCheck -check-prefix=GFX10 %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900  -show-encoding %s | FileCheck -check-prefix=GFX9 %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx1010 -mattr=-wavefrontsize32,+wavefrontsize64 %s 2>&1 | FileCheck -check-prefix=GFX10-ERR --implicit-check-not=error: %s
 // RUN: not llvm-mc -arch=amdgcn -mcpu=gfx900  %s 2>&1 | FileCheck -check-prefix=GFX9-ERR --implicit-check-not=error: %s
 
 v_bfe_u32 v0, 0x3039, v1, s1
 // GFX10:     v_bfe_u32 v0, 0x3039, v1, s1    ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x06,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, v1, 0x3039, s1
 // GFX10:     v_bfe_u32 v0, v1, 0x3039, s1    ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0x05,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, v1, s1, 0x3039
 // GFX10:     v_bfe_u32 v0, v1, s1, 0x3039    ; encoding: [0x00,0x00,0x48,0xd5,0x01,0x03,0xfc,0x03,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, 0x3039, s1
 // GFX10:     v_bfe_u32 v0, 0x3039, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0x05,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, s1, 0x3039
 // GFX10:     v_bfe_u32 v0, 0x3039, s1, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0xfc,0x03,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, v1, 0x3039, 0x3039
 // GFX10:     v_bfe_u32 v0, v1, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xff,0xfd,0x03,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, 0x3039, 0x3039
 // GFX10:     v_bfe_u32 v0, 0x3039, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x48,0xd5,0xff,0xfe,0xfd,0x03,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, s1, 0x3038
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, v1, v2
 // GFX10:    v_bfe_u32 v0, 0x3039, v1, v2    ; encoding: [0x00,0x00,0x48,0xd5,0xff,0x02,0x0a,0x04,0x39,0x30,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_bfe_u32 v0, 0x3039, 0x12345, v2
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfe_u32 v0, s1, 0x3039, s1
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 // GFX10: v_bfe_u32 v0, s1, 0x3039, s1 ; encoding: [0x00,0x00,0x48,0xd5,0x01,0xfe,0x05,0x00,0x39,0x30,0x00,0x00]
 
 v_bfe_u32 v0, s1, 0x3039, s2
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 // GFX10-ERR: error: invalid operand (violates constant bus restrictions)
 
 v_bfm_b32_e64 v0, 0x3039, s1
 // GFX10:     v_bfm_b32_e64 v0, 0x3039, s1    ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x00,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_bfm_b32_e64 v0, 0x3039, v1
 // GFX10:    v_bfm_b32_e64 v0, 0x3039, v1    ; encoding: [0x00,0x00,0x63,0xd7,0xff,0x02,0x02,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_bfm_b32_e64 v0, 0x3039, 0x3039
 // GFX10:    v_bfm_b32_e64 v0, 0x3039, 0x3039 ; encoding: [0x00,0x00,0x63,0xd7,0xff,0xfe,0x01,0x00,0x39,0x30,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_bfm_b32_e64 v0, 0x3039, 0x3038
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_pk_add_f16 v1, 25.0, v2
 // GFX10:    v_pk_add_f16 v1, 0x4e40, v2     ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0x4e,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v1, 123456, v2
 // GFX10:    v_pk_add_f16 v1, 0x1e240, v2    ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x40,0xe2,0x01,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v1, -200, v2
 // GFX10:    v_pk_add_f16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v1, 25.0, 25.0
 // GFX10:    v_pk_add_f16 v1, 0x4e40, 0x4e40 ; encoding: [0x01,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x40,0x4e,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v1, 25.0, 25.1
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_pk_add_u16 v1, -200, v2
 // GFX10:    v_pk_add_u16 v1, 0xffffff38, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x38,0xff,0xff,0xff]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v1, 64, v2
 // GFX10: v_pk_add_u16 v1, 64, v2         ; encoding: [0x01,0x00,0x0a,0xcc,0xc0,0x04,0x02,0x18]
 // GFX9:  v_pk_add_u16 v1, 64, v2         ; encoding: [0x01,0x00,0x8a,0xd3,0xc0,0x04,0x02,0x18]
 
 v_pk_add_u16 v1, 65, v2
 // GFX10: v_pk_add_u16 v1, 0x41, v2       ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x41,0x00,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v1, -1, v2
 // GFX10: v_pk_add_u16 v1, -1, v2         ; encoding: [0x01,0x00,0x0a,0xcc,0xc1,0x04,0x02,0x18]
 // GFX9:  v_pk_add_u16 v1, -1, v2         ; encoding: [0x01,0x00,0x8a,0xd3,0xc1,0x04,0x02,0x18]
 
 v_pk_add_u16 v1, -5, v2
 // GFX10: v_pk_add_u16 v1, -5, v2         ; encoding: [0x01,0x00,0x0a,0xcc,0xc5,0x04,0x02,0x18]
 // GFX9:  v_pk_add_u16 v1, -5, v2         ; encoding: [0x01,0x00,0x8a,0xd3,0xc5,0x04,0x02,0x18]
 
 v_pk_add_u16 v1, -100, v2
 // GFX10: v_pk_add_u16 v1, 0xffffff9c, v2 ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0x04,0x02,0x18,0x9c,0xff,0xff,0xff]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_u16 v1, -100, -100
 // GFX10: v_pk_add_u16 v1, 0xffffff9c, 0xffffff9c ; encoding: [0x01,0x00,0x0a,0xcc,0xff,0xfe,0x01,0x18,0x9c,0xff,0xff,0xff]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f32_e64 v1, neg(abs(0x123)), v3
 // GFX10: v_add_f32_e64 v1, -|0x123|, v3  ; encoding: [0x01,0x01,0x03,0xd5,0xff,0x06,0x02,0x20,0x23,0x01,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f32_e64 v1, v3, neg(0x123)
 // GFX10: v_add_f32_e64 v1, v3, neg(0x123) ; encoding: [0x01,0x00,0x03,0xd5,0x03,0xff,0x01,0x40,0x23,0x01,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f32_e64 v1, neg(abs(0x12345678)), neg(0x12345678)
 // GFX10: v_add_f32_e64 v1, -|0x12345678|, neg(0x12345678) ; encoding: [0x01,0x01,0x03,0xd5,0xff,0xfe,0x01,0x60,0x78,0x56,0x34,0x12]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f16_e64 v0, v0, 0xfe0b
 // GFX10: v_add_f16_e64 v0, v0, 0xfe0b      ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x00,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f16_e64 v0, v0, neg(0xfe0b)
 // GFX10: v_add_f16_e64 v0, v0, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0x00,0xff,0x01,0x40,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f16_e64 v0, 0x3456, v0
 // GFX10: v_add_f16_e64 v0, 0x3456, v0      ; encoding: [0x00,0x00,0x32,0xd5,0xff,0x00,0x02,0x00,0x56,0x34,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b)
 // GFX10: v_add_f16_e64 v0, 0xfe0b, neg(0xfe0b) ; encoding: [0x00,0x00,0x32,0xd5,0xff,0xfe,0x01,0x40,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f64 v[0:1], 1.23456, v[0:1]
 // GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, v[0:1] ; encoding: [0x00,0x00,0x64,0xd5,0xff,0x00,0x02,0x00,0xc1,0xc0,0xf3,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f64 v[0:1], v[0:1], -abs(1.23456)
 // GFX10: v_add_f64 v[0:1], v[0:1], -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0x00,0xff,0x01,0x40,0xc1,0xc0,0xf3,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f64 v[0:1], 1.23456, -abs(1.23456)
 // GFX10: v_add_f64 v[0:1], 0x3ff3c0c1, -|0x3ff3c0c1| ; encoding: [0x00,0x02,0x64,0xd5,0xff,0xfe,0x01,0x40,0xc1,0xc0,0xf3,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_add_f64 v[0:1], 1.23456, -abs(1.2345)
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_max_i16_e64 v5, 0xfe0b, v2
 // GFX10: v_max_i16_e64 v5, 0xfe0b, v2    ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, v1, 0x123
 // GFX10: v_max_i16_e64 v5, v1, 0x123     ; encoding: [0x05,0x00,0x0a,0xd7,0x01,0xff,0x01,0x00,0x23,0x01,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_max_i16_e64 v5, 0x1234, 0x1234
 // GFX10: v_max_i16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x0a,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, 0xfe0b, v2, v3
 // GFX10: v_min3_i16 v5, 0xfe0b, v2, v3   ; encoding: [0x05,0x00,0x52,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, 0x1234, v3
 // GFX10: v_min3_i16 v5, v1, 0x1234, v3   ; encoding: [0x05,0x00,0x52,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, v1, v2, 0x5678
 // GFX10: v_min3_i16 v5, v1, v2, 0x5678   ; encoding: [0x05,0x00,0x52,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, 0x5678, 0x5678, 0x5678
 // GFX10: v_min3_i16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x52,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_min3_i16 v5, 0x5678, 0x5679, 0x5678
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_min3_i16 v5, 0x5678, 0x5678, 0x5679
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_add_nc_u16 v5, 0xfe0b, v2
 // GFX10: v_add_nc_u16_e64 v5, 0xfe0b, v2 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0x04,0x02,0x00,0x0b,0xfe,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_add_nc_u16 v5, v1, 0x1234
 // GFX10: v_add_nc_u16_e64 v5, v1, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0x01,0xff,0x01,0x00,0x34,0x12,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_add_nc_u16 v5, 0x1234, 0x1234
 // GFX10: v_add_nc_u16_e64 v5, 0x1234, 0x1234 ; encoding: [0x05,0x00,0x03,0xd7,0xff,0xfe,0x01,0x00,0x34,0x12,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_ashrrev_i16_e64 v5, 0x3456, v2
 // GFX10: v_ashrrev_i16_e64 v5, 0x3456, v2 ; encoding: [0x05,0x00,0x08,0xd7,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, 0xfe0b, v2, v3
 // GFX10: v_mad_u16 v5, 0xfe0b, v2, v3    ; encoding: [0x05,0x00,0x40,0xd7,0xff,0x04,0x0e,0x04,0x0b,0xfe,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, 0x1234, v3
 // GFX10: v_mad_u16 v5, v1, 0x1234, v3    ; encoding: [0x05,0x00,0x40,0xd7,0x01,0xff,0x0d,0x04,0x34,0x12,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, v1, v2, 0x5678
 // GFX10: v_mad_u16 v5, v1, v2, 0x5678    ; encoding: [0x05,0x00,0x40,0xd7,0x01,0x05,0xfe,0x03,0x78,0x56,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_u16 v5, 0x5678, 0x5678, 0x5678
 // GFX10: v_mad_u16 v5, 0x5678, 0x5678, 0x5678 ; encoding: [0x05,0x00,0x40,0xd7,0xff,0xfe,0xfd,0x03,0x78,0x56,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_legacy_f32 v5, 0xaf123456, v2, v3
 // GFX10: v_mad_legacy_f32 v5, 0xaf123456, v2, v3 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0x04,0x0e,0x04,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_legacy_f32 v5, v1, 0xaf123456, v3
 // GFX10: v_mad_legacy_f32 v5, v1, 0xaf123456, v3 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0xff,0x0d,0x04,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_legacy_f32 v5, v1, v2, 0xaf123456
 // GFX10: v_mad_legacy_f32 v5, v1, v2, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0x01,0x05,0xfe,0x03,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456
 // GFX10: v_mad_legacy_f32 v5, 0xaf123456, 0xaf123456, 0xaf123456 ; encoding: [0x05,0x00,0x40,0xd5,0xff,0xfe,0xfd,0x03,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2
 // GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, v2 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456
 // GFX10: v_cmp_f_i32_e64 s[10:11], v1, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456
 // GFX10: v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123456 ; encoding: [0x0a,0x00,0x80,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_i32_e64 s[10:11], 0xaf123456, 0xaf123455
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR: error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3]
 // GFX10: v_cmp_f_u64_e64 s[10:11], 0xaf123456, v[2:3] ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273
 // GFX10: v_cmp_f_u64_e64 s[10:11], v[1:2], 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273
 // GFX10: v_cmp_f_u64_e64 s[10:11], 0x3f717273, 0x3f717273 ; encoding: [0x0a,0x00,0xe0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_cmpx_class_f32_e64 0xaf123456, v2
 // GFX10: v_cmpx_class_f32_e64 0xaf123456, v2 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_class_f32_e64 v1, 0xaf123456
 // GFX10: v_cmpx_class_f32_e64 v1, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x12,0xaf]
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_class_f32_e64 0xaf123456, 0xaf123456
 // GFX10: v_cmpx_class_f32_e64 0xaf123456, 0xaf123456 ; encoding: [0x00,0x00,0x98,0xd4,0xff,0xfe,0x01,0x00,0x56,0x34,0x12,0xaf]
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_class_f32_e64 0xaf123456, 0xaf123455
-// GFX10-ERR: error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_lt_i16_e64 v1, 0x3456
 // GFX10: v_cmpx_lt_i16_e64 v1, 0x3456    ; encoding: [0x00,0x00,0x99,0xd4,0x01,0xff,0x01,0x00,0x56,0x34,0x00,0x00]
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_lt_i16_e64 0x3456, v2
 // GFX10: v_cmpx_lt_i16_e64 0x3456, v2    ; encoding: [0x00,0x00,0x99,0xd4,0xff,0x04,0x02,0x00,0x56,0x34,0x00,0x00]

 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_cmpx_f_i64_e64 0x3f717273, 0x3f717273
 // GFX10: v_cmpx_f_i64_e64 0x3f717273, 0x3f717273 ; encoding: [0x00,0x00,0xb0,0xd4,0xff,0xfe,0x01,0x00,0x73,0x72,0x71,0x3f]
 // GFX9-ERR: error: operands are not valid for this GPU or mode
 
 v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3]
 // GFX10: v_lshlrev_b64 v[5:6], 0xaf123456, v[2:3] ; encoding: [0x05,0x00,0xff,0xd6,0xff,0x04,0x02,0x00,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_lshlrev_b64 v[5:6], v1, 0x3f717273
 // GFX10: v_lshlrev_b64 v[5:6], v1, 0x3f717273 ; encoding: [0x05,0x00,0xff,0xd6,0x01,0xff,0x01,0x00,0x73,0x72,0x71,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_fma_mix_f32 v5, 0x123, v2, v3
 // GFX10: v_fma_mix_f32 v5, 0x123, v2, v3 ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0x0e,0x04,0x23,0x01,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_fma_mix_f32 v5, v1, 0x7b, v3
 // GFX10: v_fma_mix_f32 v5, v1, 0x7b, v3  ; encoding: [0x05,0x00,0x20,0xcc,0x01,0xff,0x0d,0x04,0x7b,0x00,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_fma_mix_f32 v5, v1, v2, 0x1c8
 // GFX10: v_fma_mix_f32 v5, v1, v2, 0x1c8 ; encoding: [0x05,0x00,0x20,0xcc,0x01,0x05,0xfe,0x03,0xc8,0x01,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a
 // GFX10: v_fma_mix_f32 v5, 0x1c8a, v2, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0x04,0xfe,0x03,0x8a,0x1c,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a
 // GFX10: v_fma_mix_f32 v5, 0x1c8a, 0x1c8a, 0x1c8a ; encoding: [0x05,0x00,0x20,0xcc,0xff,0xfe,0xfd,0x03,0x8a,0x1c,0x00,0x00]
 // GFX9-ERR: error: instruction not supported on this GPU
 
 v_pk_add_f16 v5, 0xaf123456, v2
 // GFX10: v_pk_add_f16 v5, 0xaf123456, v2 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0x04,0x02,0x18,0x56,0x34,0x12,0xaf]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v5, v1, 0x3f717273
 // GFX10: v_pk_add_f16 v5, v1, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0x01,0xff,0x01,0x18,0x73,0x72,0x71,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_f16 v5, 0x3f717273, 0x3f717273
 // GFX10: v_pk_add_f16 v5, 0x3f717273, 0x3f717273 ; encoding: [0x05,0x00,0x0f,0xcc,0xff,0xfe,0x01,0x18,0x73,0x72,0x71,0x3f]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, 0x7b, v2
 // GFX10: v_pk_add_i16 v5, 0x7b, v2       ; encoding: [0x05,0x00,0x02,0xcc,0xff,0x04,0x02,0x18,0x7b,0x00,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, v1, 0x7b
 // GFX10: v_pk_add_i16 v5, v1, 0x7b       ; encoding: [0x05,0x00,0x02,0xcc,0x01,0xff,0x01,0x18,0x7b,0x00,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, 0xab7b, 0xab7b
 // GFX10: v_pk_add_i16 v5, 0xab7b, 0xab7b ; encoding: [0x05,0x00,0x02,0xcc,0xff,0xfe,0x01,0x18,0x7b,0xab,0x00,0x00]
-// GFX9-ERR: error: invalid literal operand
+// GFX9-ERR: error: literal operands are not supported
 
 v_pk_add_i16 v5, 0xab7b, 0xab7a
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f32 v5, v1, 0x123, v3
 // GFX10: v_div_fmas_f32 v5, v1, 0x123, v3 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0x0d,0x04,0x23,0x01,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f32 v5, v1, 0x123, 0x123
 // GFX10: v_div_fmas_f32 v5, v1, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0x01,0xff,0xfd,0x03,0x23,0x01,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f32 v5, 0x123, 0x123, 0x123
 // GFX10: v_div_fmas_f32 v5, 0x123, 0x123, 0x123 ; encoding: [0x05,0x00,0x6f,0xd5,0xff,0xfe,0xfd,0x03,0x23,0x01,0x00,0x00]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4]
 // GFX10: v_div_fmas_f64 v[5:6], 0x12345678, v[2:3], v[3:4] ; encoding: [0x05,0x00,0x70,0xd5,0xff,0x04,0x0e,0x04,0x78,0x56,0x34,0x12]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678
 // GFX10: v_div_fmas_f64 v[5:6], 0x12345678, 0x12345678, 0x12345678 ; encoding: [0x05,0x00,0x70,0xd5,0xff,0xfe,0xfd,0x03,0x78,0x56,0x34,0x12]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_div_fmas_f64 v[5:6], v[1:2], 0x123457, 0x123456
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported
 
 v_ldexp_f64 v[5:6], 0.12345, v2
 // GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, v2 ; encoding: [0x05,0x00,0x68,0xd5,0xff,0x04,0x02,0x00,0x6b,0x9a,0xbf,0x3f]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6b
 // GFX10: v_ldexp_f64 v[5:6], 0x3fbf9a6b, 0x3fbf9a6b ; encoding: [0x05,0x00,0x68,0xd5,0xff,0xfe,0x01,0x00,0x6b,0x9a,0xbf,0x3f]
-// GFX9-ERR:  error: invalid literal operand
+// GFX9-ERR:  error: literal operands are not supported
 
 v_ldexp_f64 v[5:6], 0.12345, 0x3fbf9a6c
-// GFX10-ERR: error: invalid literal operand
-// GFX9-ERR:  error: invalid literal operand
+// GFX10-ERR: error: only one literal operand is allowed
+// GFX9-ERR:  error: literal operands are not supported

llvm/test/MC/AMDGPU/vop3.s

 // VI: v_mad_f16 v5, v1, v2, v3 clamp ; encoding: [0x05,0x80,0xea,0xd1,0x01,0x05,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_i16_e64 v5, -1, v2, v3
 // VI: v_mad_i16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xec,0xd1,0xc1,0x04,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_i16 v5, v1, -4.0, v3
-// NOVI: error: invalid literal operand
+// NOVI: error: literal operands are not supported
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_i16 v5, v1, v2, 0
 // VI: v_mad_i16 v5, v1, v2, 0 ; encoding: [0x05,0x00,0xec,0xd1,0x01,0x05,0x02,0x02]
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_u16_e64 v5, -1, v2, v3
 // VI: v_mad_u16 v5, -1, v2, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0xc1,0x04,0x0e,0x04]
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_u16 v5, v1, 0, v3
 // VI: v_mad_u16 v5, v1, 0, v3 ; encoding: [0x05,0x00,0xeb,0xd1,0x01,0x01,0x0d,0x04]
 // NOSICI: error: instruction not supported on this GPU
 
 v_mad_u16 v5, v1, v2, -4.0
-// NOVI: error: invalid literal operand
+// NOVI: error: literal operands are not supported
 // NOSICI: error: instruction not supported on this GPU
 
 ///===---------------------------------------------------------------------===//
 // VOP3 with Integer Clamp
 ///===---------------------------------------------------------------------===//
 
 v_mad_i32_i24 v5, v1, v2, v3 clamp
 // NOSICI: error: integer clamping is not supported on this GPU