[llvm] [ARM][TableGen][MC] Change the ARM mnemonic operands to be optional for ASM parsing (PR #83436)
Alfie Richards via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 7 02:49:11 PST 2024
https://github.com/AlfieRichardsArm updated https://github.com/llvm/llvm-project/pull/83436
>From 7cf6d153798090b46aada7cdcc516f64f07d8f90 Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Fri, 1 Mar 2024 14:42:43 +0000
Subject: [PATCH 1/6] [TableGen] Add `PreferSmallerInstructions` for Targets.
This option means that in assembly matching instructions with smaller
encodings will be preferred.
This will be used for the ARM instruciton set where this is the correct
behaviour after some other refactoring.
---
llvm/include/llvm/Target/Target.td | 9 ++++++
llvm/utils/TableGen/AsmMatcherEmitter.cpp | 38 +++++++++++++++++------
llvm/utils/TableGen/CodeGenTarget.cpp | 4 +++
llvm/utils/TableGen/CodeGenTarget.h | 5 +++
4 files changed, 46 insertions(+), 10 deletions(-)
diff --git a/llvm/include/llvm/Target/Target.td b/llvm/include/llvm/Target/Target.td
index 0d97a47190b196..177050cf7d747c 100644
--- a/llvm/include/llvm/Target/Target.td
+++ b/llvm/include/llvm/Target/Target.td
@@ -1545,6 +1545,10 @@ class AsmParser {
// method shall be called for all operands as opposed to only those
// that have their own specified custom parsers.
bit CallCustomParserForAllOperands = false;
+
+ // PreferSmallerInstructions - Should the assembly matcher prefer the smaller
+ // instructions.
+ bit PreferSmallerInstructions = false;
}
def DefaultAsmParser : AsmParser;
@@ -1724,6 +1728,11 @@ class Target {
// setting hasExtraDefRegAllocReq and hasExtraSrcRegAllocReq to 1
// for all opcodes if this flag is set to 0.
int AllowRegisterRenaming = 0;
+
+ // PreferSmallerInstructions = Should the assembly matcher prefer the smaller
+ // instructions. 1 if the instruction set should sort by size,
+ // 0 otherwise.
+ bit PreferSmallerInstructions = 0;
}
//===----------------------------------------------------------------------===//
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index febd96086df27b..6b32d19860d149 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -502,6 +502,9 @@ struct MatchableInfo {
/// matchable came from.
Record *const TheDef;
+ // ResInstSize - The size of the resulting instruction for this matchable.
+ unsigned ResInstSize;
+
/// DefRec - This is the definition that it came from.
PointerUnion<const CodeGenInstruction *, const CodeGenInstAlias *> DefRec;
@@ -543,10 +546,12 @@ struct MatchableInfo {
MatchableInfo(const CodeGenInstruction &CGI)
: AsmVariantID(0), AsmString(CGI.AsmString), TheDef(CGI.TheDef),
- DefRec(&CGI), UseInstAsmMatchConverter(true) {}
+ ResInstSize(TheDef->getValueAsInt("Size")), DefRec(&CGI),
+ UseInstAsmMatchConverter(true) {}
MatchableInfo(std::unique_ptr<const CodeGenInstAlias> Alias)
: AsmVariantID(0), AsmString(Alias->AsmString), TheDef(Alias->TheDef),
+ ResInstSize(Alias->ResultInst->TheDef->getValueAsInt("Size")),
DefRec(Alias.release()), UseInstAsmMatchConverter(TheDef->getValueAsBit(
"UseInstAsmMatchConverter")) {}
@@ -608,12 +613,18 @@ struct MatchableInfo {
void buildInstructionResultOperands();
void buildAliasResultOperands(bool AliasConstraintsAreChecked);
- /// operator< - Compare two matchables.
- bool operator<(const MatchableInfo &RHS) const {
+ /// shouldBeMatchedBefore - Compare two matchables for ordering.
+ bool shouldBeMatchedBefore(const MatchableInfo &RHS,
+ const CodeGenTarget &Target) const {
// The primary comparator is the instruction mnemonic.
if (int Cmp = Mnemonic.compare_insensitive(RHS.Mnemonic))
return Cmp == -1;
+ // Sort by the resultant instuctions size, eg. for ARM instructions
+ // we must choose the smallest matching instruction.
+ if (Target.getPreferSmallerInstructions() && ResInstSize != RHS.ResInstSize)
+ return ResInstSize < RHS.ResInstSize;
+
if (AsmOperands.size() != RHS.AsmOperands.size())
return AsmOperands.size() < RHS.AsmOperands.size();
@@ -652,7 +663,8 @@ struct MatchableInfo {
/// couldMatchAmbiguouslyWith - Check whether this matchable could
/// ambiguously match the same set of operands as \p RHS (without being a
/// strictly superior match).
- bool couldMatchAmbiguouslyWith(const MatchableInfo &RHS) const {
+ bool couldMatchAmbiguouslyWith(const MatchableInfo &RHS,
+ const CodeGenTarget &Target) const {
// The primary comparator is the instruction mnemonic.
if (Mnemonic != RHS.Mnemonic)
return false;
@@ -661,6 +673,11 @@ struct MatchableInfo {
if (AsmVariantID != RHS.AsmVariantID)
return false;
+ // Sort by the resultant instuctions size, eg. for ARM instructions
+ // we must choose the smallest matching instruction.
+ if (Target.getPreferSmallerInstructions() && ResInstSize != RHS.ResInstSize)
+ return false;
+
// The number of operands is unambiguous.
if (AsmOperands.size() != RHS.AsmOperands.size())
return false;
@@ -3224,17 +3241,18 @@ void AsmMatcherEmitter::run(raw_ostream &OS) {
// Sort the instruction table using the partial order on classes. We use
// stable_sort to ensure that ambiguous instructions are still
// deterministically ordered.
- llvm::stable_sort(
- Info.Matchables,
- [](const std::unique_ptr<MatchableInfo> &a,
- const std::unique_ptr<MatchableInfo> &b) { return *a < *b; });
+ llvm::stable_sort(Info.Matchables,
+ [&Target](const std::unique_ptr<MatchableInfo> &a,
+ const std::unique_ptr<MatchableInfo> &b) {
+ return a->shouldBeMatchedBefore(*b, Target);
+ });
#ifdef EXPENSIVE_CHECKS
// Verify that the table is sorted and operator < works transitively.
for (auto I = Info.Matchables.begin(), E = Info.Matchables.end(); I != E;
++I) {
for (auto J = I; J != E; ++J) {
- assert(!(**J < **I));
+ assert(!((*J)->shouldBeMatchedBefore(**I, Target)));
}
}
#endif
@@ -3253,7 +3271,7 @@ void AsmMatcherEmitter::run(raw_ostream &OS) {
const MatchableInfo &A = **I;
const MatchableInfo &B = **J;
- if (A.couldMatchAmbiguouslyWith(B)) {
+ if (A.couldMatchAmbiguouslyWith(B, Target)) {
errs() << "warning: ambiguous matchables:\n";
A.dump();
errs() << "\nis incomparable with:\n";
diff --git a/llvm/utils/TableGen/CodeGenTarget.cpp b/llvm/utils/TableGen/CodeGenTarget.cpp
index 980c9bdb6367f7..9cc703b31a74fe 100644
--- a/llvm/utils/TableGen/CodeGenTarget.cpp
+++ b/llvm/utils/TableGen/CodeGenTarget.cpp
@@ -342,6 +342,10 @@ Record *CodeGenTarget::getAsmParser() const {
return LI[AsmParserNum];
}
+bool CodeGenTarget::getPreferSmallerInstructions() const {
+ return getAsmParser()->getValueAsBit("PreferSmallerInstructions");
+}
+
/// getAsmParserVariant - Return the AssemblyParserVariant definition for
/// this target.
///
diff --git a/llvm/utils/TableGen/CodeGenTarget.h b/llvm/utils/TableGen/CodeGenTarget.h
index 2ae3a3a2204dd0..7e2dd43cbf1387 100644
--- a/llvm/utils/TableGen/CodeGenTarget.h
+++ b/llvm/utils/TableGen/CodeGenTarget.h
@@ -99,6 +99,11 @@ class CodeGenTarget {
///
bool getAllowRegisterRenaming() const;
+ /// getPreferSmallerInstructions - Return the PreferSmallerInstructions
+ /// flag value for this target.
+ ///
+ bool getPreferSmallerInstructions() const;
+
/// getAsmParser - Return the AssemblyParser definition for this target.
///
Record *getAsmParser() const;
>From 11d99d9c08dbd9290d5528ba5c574fb6ed7ca45c Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Fri, 1 Mar 2024 15:30:40 +0000
Subject: [PATCH 2/6] [TableGen] Bug fix for tied optional operands resolution
---
llvm/utils/TableGen/AsmMatcherEmitter.cpp | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index 6b32d19860d149..8f57c402adc763 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -2003,9 +2003,9 @@ emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
}
CvtOS << " assert(Kind < CVT_NUM_SIGNATURES && \"Invalid signature!\");\n";
CvtOS << " const uint8_t *Converter = ConversionTable[Kind];\n";
- CvtOS << " unsigned OpIdx;\n";
CvtOS << " Inst.setOpcode(Opcode);\n";
CvtOS << " for (const uint8_t *p = Converter; *p; p += 2) {\n";
+ CvtOS << " unsigned OpIdx;\n";
if (HasOptionalOperands) {
// When optional operands are involved, formal and actual operand indices
// may differ. Map the former to the latter by subtracting the number of
@@ -2016,16 +2016,17 @@ emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
}
CvtOS << " switch (*p) {\n";
CvtOS << " default: llvm_unreachable(\"invalid conversion entry!\");\n";
- CvtOS << " case CVT_Reg:\n";
+ CvtOS << " case CVT_Reg:{\n";
CvtOS << " static_cast<" << TargetOperandClass
<< " &>(*Operands[OpIdx]).addRegOperands(Inst, 1);\n";
CvtOS << " break;\n";
+ CvtOS << " }\n";
CvtOS << " case CVT_Tied: {\n";
- CvtOS << " assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -\n";
+ CvtOS << " assert(*(p + 1) < (size_t)(std::end(TiedAsmOperandTable) -\n";
CvtOS
<< " std::begin(TiedAsmOperandTable)) &&\n";
CvtOS << " \"Tied operand not found\");\n";
- CvtOS << " unsigned TiedResOpnd = TiedAsmOperandTable[OpIdx][0];\n";
+ CvtOS << " unsigned TiedResOpnd = TiedAsmOperandTable[*(p + 1)][0];\n";
CvtOS << " if (TiedResOpnd != (uint8_t)-1)\n";
CvtOS << " Inst.addOperand(Inst.getOperand(TiedResOpnd));\n";
CvtOS << " break;\n";
>From 524e7fd0fc06ba5e16444c598650c58b36463110 Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Fri, 1 Mar 2024 14:46:05 +0000
Subject: [PATCH 3/6] [ARM][TableGen][MC] Change the ARM mnemonic operands to
be optional for ASM parsing
This changs the way the assembly matcher works for Aarch32 parsing.
Previously there was a pile of hacks which dictated whether the CC
and CCOut operands should be present which de-facto chose if the
wide/narrow (or thumb1/thumb2/arm) instruction version were chosen.
This meant much of the TableGen machinery present for the assembly
matching was effectively being bypassed and worked around.
This patch makes the CC and CCOut operands optional which allows
the ASM matcher operate as it was designed and means we can avoid
doing some of the hacks done previously. This also adds the option
for the target to allow the prioritizing the smaller instruction
encodings as is required for Aarch32.
---
llvm/include/llvm/Target/Target.td | 11 +-
llvm/lib/Target/ARM/ARM.td | 1 +
llvm/lib/Target/ARM/ARMInstrFormats.td | 17 +-
.../lib/Target/ARM/AsmParser/ARMAsmParser.cpp | 1155 +++++++++--------
llvm/test/MC/ARM/arm-branch-errors.s | 4 +-
llvm/test/MC/ARM/arm-reg-addr-errors.s | 16 +-
llvm/test/MC/ARM/arm11-hint-instr.s | 8 +-
llvm/test/MC/ARM/cps.s | 2 +-
llvm/test/MC/ARM/d16.s | 2 +-
.../MC/ARM/directive-arch_extension-crypto.s | 15 +-
llvm/test/MC/ARM/lsl-zero-errors.s | 8 +-
llvm/test/MC/ARM/mve-misc.s | 55 +-
llvm/test/MC/ARM/negative-immediates-fail.s | 10 +-
llvm/test/MC/ARM/not-armv4.s | 14 +-
llvm/test/MC/ARM/register-token-source-loc.s | 3 +
llvm/test/MC/ARM/tMOVSr.s | 5 +-
llvm/test/MC/ARM/thumb-diagnostics.s | 33 +-
llvm/test/MC/ARM/thumb-mov.s | 16 +-
llvm/test/MC/ARM/thumb2-diagnostics.s | 4 +-
llvm/utils/TableGen/AsmMatcherEmitter.cpp | 24 +-
llvm/utils/TableGen/CodeGenTarget.h | 2 +-
21 files changed, 801 insertions(+), 604 deletions(-)
diff --git a/llvm/include/llvm/Target/Target.td b/llvm/include/llvm/Target/Target.td
index 177050cf7d747c..3cbdc3ccf8b558 100644
--- a/llvm/include/llvm/Target/Target.td
+++ b/llvm/include/llvm/Target/Target.td
@@ -948,9 +948,18 @@ class AsmOperandClass {
/// error will be suppressed if all of the remaining unmatched operands are
/// marked as IsOptional.
///
- /// Optional arguments must be at the end of the operand list.
+ /// Note: Optional arguments have caveats if they are not at the end of this list
+ /// when regarding custom operand parsing. See below
bit IsOptional = false;
+ // Fixme: Ideally this would not be necessary however this would involve interleaving the
+ // parsing and matching processes.
+ /// Set to 1 if the parser should assume this operand will always be present
+ /// for the sake of calculating the operand index in regards to which custom operand
+ /// parser should be used.
+ /// This is only used for custom operands that are not at the end of the instruction.
+ bit OptionalShouldOffsetCustomParsers = true;
+
/// The name of the method on the target specific asm parser that returns the
/// default operand for this optional operand. This method is only used if
/// IsOptional == 1. If not set, this will default to "defaultFooOperands",
diff --git a/llvm/lib/Target/ARM/ARM.td b/llvm/lib/Target/ARM/ARM.td
index b62e1a032631fd..7472970b7f283b 100644
--- a/llvm/lib/Target/ARM/ARM.td
+++ b/llvm/lib/Target/ARM/ARM.td
@@ -1747,4 +1747,5 @@ def ARM : Target {
let AssemblyParsers = [ARMAsmParser];
let AssemblyParserVariants = [ARMAsmParserVariant];
let AllowRegisterRenaming = 1;
+ let PreferSmallerInstructions= true;
}
diff --git a/llvm/lib/Target/ARM/ARMInstrFormats.td b/llvm/lib/Target/ARM/ARMInstrFormats.td
index 14e315534570d2..6e0466f1bc11bd 100644
--- a/llvm/lib/Target/ARM/ARMInstrFormats.td
+++ b/llvm/lib/Target/ARM/ARMInstrFormats.td
@@ -155,7 +155,13 @@ def iflags_op : Operand<i32> {
// ARM Predicate operand. Default to 14 = always (AL). Second part is CC
// register whose default is 0 (no register).
-def CondCodeOperand : AsmOperandClass { let Name = "CondCode"; }
+def CondCodeOperand : AsmOperandClass {
+ let Name = "CondCode";
+ let PredicateMethod = "isCondCode";
+ let DefaultMethod = "defaultCondCodeOp";
+ let IsOptional = true;
+ let OptionalShouldOffsetCustomParsers = false;
+}
def pred : PredicateOperand<OtherVT, (ops i32imm, i32imm),
(ops (i32 14), (i32 zero_reg))> {
let PrintMethod = "printPredicateOperand";
@@ -174,7 +180,12 @@ def cmovpred : Operand<i32>, PredicateOp,
}
// Conditional code result for instructions whose 's' bit is set, e.g. subs.
-def CCOutOperand : AsmOperandClass { let Name = "CCOut"; }
+def CCOutOperand : AsmOperandClass {
+ let Name = "CCOut";
+ let DefaultMethod = "defaultCCOutOp";
+ let IsOptional = true;
+ let OptionalShouldOffsetCustomParsers = false;
+}
def cc_out : OptionalDefOperand<OtherVT, (ops CCR), (ops (i32 zero_reg))> {
let EncoderMethod = "getCCOutOpValue";
let PrintMethod = "printSBitModifierOperand";
@@ -468,7 +479,7 @@ class InstThumb<AddrMode am, int sz, IndexMode im,
// These are aliases that require C++ handling to convert to the target
// instruction, while InstAliases can be handled directly by tblgen.
class AsmPseudoInst<string asm, dag iops, dag oops = (outs)>
- : InstTemplate<AddrModeNone, 0, IndexModeNone, Pseudo, GenericDomain,
+ : InstTemplate<AddrModeNone, 4, IndexModeNone, Pseudo, GenericDomain,
"", NoItinerary> {
let OutOperandList = oops;
let InOperandList = iops;
diff --git a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
index efec163c6ed634..a51e12c6605cf0 100644
--- a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
+++ b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
@@ -18,6 +18,7 @@
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
@@ -47,6 +48,7 @@
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/SMLoc.h"
@@ -79,6 +81,7 @@ extern const ARMInstrTable ARMDescs;
} // end namespace llvm
namespace {
+class ARMOperand;
enum class ImplicitItModeTy { Always, Never, ARMOnly, ThumbOnly };
@@ -446,9 +449,10 @@ class ARMAsmParser : public MCTargetAsmParser {
}
bool validatetLDMRegList(const MCInst &Inst, const OperandVector &Operands,
- unsigned ListNo, bool IsARPop = false);
+ unsigned MnemonicOpsEndInd, unsigned ListIndex,
+ bool IsARPop = false);
bool validatetSTMRegList(const MCInst &Inst, const OperandVector &Operands,
- unsigned ListNo);
+ unsigned MnemonicOpsEndInd, unsigned ListIndex);
int tryParseRegister();
bool tryParseRegisterWithWriteBack(OperandVector &);
@@ -504,6 +508,9 @@ class ARMAsmParser : public MCTargetAsmParser {
bool parseDirectiveSEHEpilogEnd(SMLoc L);
bool parseDirectiveSEHCustom(SMLoc L);
+ std::unique_ptr<ARMOperand> defaultCondCodeOp();
+ std::unique_ptr<ARMOperand> defaultCCOutOp();
+
bool isMnemonicVPTPredicable(StringRef Mnemonic, StringRef ExtraToken);
StringRef splitMnemonic(StringRef Mnemonic, StringRef ExtraToken,
ARMCC::CondCodes &PredicationCode,
@@ -516,9 +523,13 @@ class ARMAsmParser : public MCTargetAsmParser {
bool &CanAcceptVPTPredicationCode);
bool enableArchExtFeature(StringRef Name, SMLoc &ExtLoc);
- void tryConvertingToTwoOperandForm(StringRef Mnemonic, bool CarrySetting,
- OperandVector &Operands);
- bool CDEConvertDualRegOperand(StringRef Mnemonic, OperandVector &Operands);
+ void tryConvertingToTwoOperandForm(StringRef Mnemonic,
+ ARMCC::CondCodes PredicationCode,
+ bool CarrySetting, OperandVector &Operands,
+ unsigned MnemonicOpsEndInd);
+
+ bool CDEConvertDualRegOperand(StringRef Mnemonic, OperandVector &Operands,
+ unsigned MnemonicOpsEndInd);
bool isThumb() const {
// FIXME: Can tablegen auto-generate this?
@@ -658,15 +669,20 @@ class ARMAsmParser : public MCTargetAsmParser {
void cvtThumbBranches(MCInst &Inst, const OperandVector &);
void cvtMVEVMOVQtoDReg(MCInst &Inst, const OperandVector &);
- bool validateInstruction(MCInst &Inst, const OperandVector &Ops);
- bool processInstruction(MCInst &Inst, const OperandVector &Ops, MCStreamer &Out);
- bool shouldOmitCCOutOperand(StringRef Mnemonic, OperandVector &Operands);
- bool shouldOmitPredicateOperand(StringRef Mnemonic, OperandVector &Operands);
- bool shouldOmitVectorPredicateOperand(StringRef Mnemonic, OperandVector &Operands);
+ bool validateInstruction(MCInst &Inst, const OperandVector &Ops,
+ unsigned MnemonicOpsEndInd);
+ bool processInstruction(MCInst &Inst, const OperandVector &Ops,
+ unsigned MnemonicOpsEndInd, MCStreamer &Out);
+ bool shouldOmitVectorPredicateOperand(StringRef Mnemonic,
+ OperandVector &Operands,
+ unsigned MnemonicOpsEndInd);
bool isITBlockTerminator(MCInst &Inst) const;
- void fixupGNULDRDAlias(StringRef Mnemonic, OperandVector &Operands);
- bool validateLDRDSTRD(MCInst &Inst, const OperandVector &Operands,
- bool Load, bool ARMMode, bool Writeback);
+
+ void fixupGNULDRDAlias(StringRef Mnemonic, OperandVector &Operands,
+ unsigned MnemonicOpsEndInd);
+ bool validateLDRDSTRD(MCInst &Inst, const OperandVector &Operands, bool Load,
+ bool ARMMode, bool Writeback,
+ unsigned MnemonicOpsEndInd);
public:
enum ARMMatchResultTy {
@@ -676,6 +692,7 @@ class ARMAsmParser : public MCTargetAsmParser {
Match_RequiresThumb2,
Match_RequiresV8,
Match_RequiresFlagSetting,
+ Match_RequiresDestinationRegisterMatchASourceRegister,
#define GET_OPERAND_DIAGNOSTIC_TYPES
#include "ARMGenAsmMatcher.inc"
@@ -715,6 +732,9 @@ class ARMAsmParser : public MCTargetAsmParser {
unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
unsigned Kind) override;
unsigned checkTargetMatchPredicate(MCInst &Inst) override;
+ unsigned
+ checkEarlyTargetMatchPredicate(MCInst &Inst,
+ const OperandVector &Operands) override;
bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
OperandVector &Operands, MCStreamer &Out,
@@ -4053,6 +4073,65 @@ static MCRegister MatchRegisterName(StringRef Name);
/// }
+static bool isDataTypeToken(StringRef Tok) {
+ static const DenseSet<StringRef> DataTypes{
+ ".8", ".16", ".32", ".64", ".i8", ".i16", ".i32", ".i64",
+ ".u8", ".u16", ".u32", ".u64", ".s8", ".s16", ".s32", ".s64",
+ ".p8", ".p16", ".f32", ".f64", ".f", ".d"};
+ return DataTypes.contains(Tok);
+}
+
+static unsigned getMnemonicOpsEndInd(const OperandVector &Operands) {
+ unsigned MnemonicOpsEndInd = 1;
+ // Special case for CPS which has a Mnemonic side token for possibly storing
+ // ie/id variant
+ if (Operands[0]->isToken() &&
+ static_cast<ARMOperand &>(*Operands[0]).getToken() == "cps") {
+ if (Operands.size() > 1 && Operands[1]->isImm() &&
+ static_cast<ARMOperand &>(*Operands[1]).getImm()->getKind() ==
+ llvm::MCExpr::Constant &&
+ (dyn_cast<MCConstantExpr>(
+ static_cast<ARMOperand &>(*Operands[1]).getImm())
+ ->getValue() == ARM_PROC::IE ||
+ dyn_cast<MCConstantExpr>(
+ static_cast<ARMOperand &>(*Operands[1]).getImm())
+ ->getValue() == ARM_PROC::ID))
+ ++MnemonicOpsEndInd;
+ }
+
+ // In some circumstances the code code moves to the right
+ bool RHSCondCode = false;
+ while (MnemonicOpsEndInd < Operands.size()) {
+ auto Op = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]);
+ // Special case for it instructions which have a condition code on the RHS
+ if (Op.isITMask()) {
+ RHSCondCode = true;
+ MnemonicOpsEndInd++;
+ }
+ // Special case for it instructions which have a condition code on the RHS
+ else if (Op.isToken() &&
+ (
+ // There are several special cases not covered by
+ // isDataTypeToken
+ Op.getToken() == ".w" || Op.getToken() == ".bf16" ||
+ Op.getToken() == ".p64" || Op.getToken() == ".f16" ||
+ isDataTypeToken(Op.getToken()))) {
+ // In the mnemonic operators the cond code must always precede the data
+ // type. So we can now safely assume any subsequent cond code is on the
+ // RHS. As is the cdase for VCMP and VPT.
+ RHSCondCode = true;
+ MnemonicOpsEndInd++;
+ }
+ // Skip all mnemonic operator types
+ else if (Op.isCCOut() || (Op.isCondCode() && !RHSCondCode) ||
+ Op.isVPTPred() || (Op.isToken() && Op.getToken() == ".w"))
+ MnemonicOpsEndInd++;
+ else
+ break;
+ }
+ return MnemonicOpsEndInd;
+}
+
bool ARMAsmParser::parseRegister(MCRegister &Reg, SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
@@ -5598,37 +5677,86 @@ ParseStatus ARMAsmParser::parseAM3Offset(OperandVector &Operands) {
return ParseStatus::Success;
}
+// Finds the index of the first CondCode operator, if there is none returns 0
+unsigned findCondCodeInd(const OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
+ for (unsigned I = 1; I < MnemonicOpsEndInd; ++I) {
+ auto Op = static_cast<ARMOperand &>(*Operands[I]);
+ if (Op.isCondCode())
+ return I;
+ }
+ return 0;
+}
+
+unsigned findCCOutInd(const OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
+ for (unsigned I = 1; I < MnemonicOpsEndInd; ++I) {
+ auto Op = static_cast<ARMOperand &>(*Operands[I]);
+ if (Op.isCCOut())
+ return I;
+ }
+ return 0;
+}
+
/// Convert parsed operands to MCInst. Needed here because this instruction
/// only has two register operands, but multiplication is commutative so
/// assemblers should accept both "mul rD, rN, rD" and "mul rD, rD, rN".
void ARMAsmParser::cvtThumbMultiply(MCInst &Inst,
const OperandVector &Operands) {
- ((ARMOperand &)*Operands[3]).addRegOperands(Inst, 1);
- ((ARMOperand &)*Operands[1]).addCCOutOperands(Inst, 1);
- // If we have a three-operand form, make sure to set Rn to be the operand
- // that isn't the same as Rd.
- unsigned RegOp = 4;
- if (Operands.size() == 6 &&
- ((ARMOperand &)*Operands[4]).getReg() ==
- ((ARMOperand &)*Operands[3]).getReg())
- RegOp = 5;
- ((ARMOperand &)*Operands[RegOp]).addRegOperands(Inst, 1);
- Inst.addOperand(Inst.getOperand(0));
- ((ARMOperand &)*Operands[2]).addCondCodeOperands(Inst, 2);
+ unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
+ unsigned CondI = findCondCodeInd(Operands, MnemonicOpsEndInd);
+ unsigned CondOutI = findCCOutInd(Operands, MnemonicOpsEndInd);
+
+ // 2 operand form
+ unsigned RegRd = MnemonicOpsEndInd;
+ unsigned RegRn = MnemonicOpsEndInd + 1;
+ unsigned RegRm = MnemonicOpsEndInd;
+
+ if (Operands.size() == MnemonicOpsEndInd + 3) {
+ // If we have a three-operand form, make sure to set Rn to be the operand
+ // that isn't the same as Rd.
+ if (((ARMOperand &)*Operands[RegRd]).getReg() ==
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 1]).getReg()) {
+ RegRn = MnemonicOpsEndInd + 2;
+ RegRm = MnemonicOpsEndInd + 1;
+ } else {
+ RegRn = MnemonicOpsEndInd + 1;
+ RegRm = MnemonicOpsEndInd + 2;
+ }
+ }
+
+ // Rd
+ ((ARMOperand &)*Operands[RegRd]).addRegOperands(Inst, 1);
+ // CCOut
+ if (CondOutI != 0) {
+ ((ARMOperand &)*Operands[CondOutI]).addCCOutOperands(Inst, 1);
+ } else {
+ ARMOperand Op = *ARMOperand::CreateCCOut(0, Operands[0]->getEndLoc());
+ Op.addCCOutOperands(Inst, 1);
+ }
+ // Rn
+ ((ARMOperand &)*Operands[RegRn]).addRegOperands(Inst, 1);
+ // Rm
+ ((ARMOperand &)*Operands[RegRm]).addRegOperands(Inst, 1);
+
+ // Cond code
+ if (CondI != 0) {
+ ((ARMOperand &)*Operands[CondI]).addCondCodeOperands(Inst, 2);
+ } else {
+ ARMOperand Op =
+ *ARMOperand::CreateCondCode(llvm::ARMCC::AL, Operands[0]->getEndLoc());
+ Op.addCondCodeOperands(Inst, 2);
+ }
}
void ARMAsmParser::cvtThumbBranches(MCInst &Inst,
const OperandVector &Operands) {
- int CondOp = -1, ImmOp = -1;
- switch(Inst.getOpcode()) {
- case ARM::tB:
- case ARM::tBcc: CondOp = 1; ImmOp = 2; break;
-
- case ARM::t2B:
- case ARM::t2Bcc: CondOp = 1; ImmOp = 3; break;
+ unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
+ unsigned CondI = findCondCodeInd(Operands, MnemonicOpsEndInd);
+ unsigned Cond =
+ (CondI == 0 ? ARMCC::AL
+ : static_cast<ARMOperand &>(*Operands[CondI]).getCondCode());
- default: llvm_unreachable("Unexpected instruction in cvtThumbBranches");
- }
// first decide whether or not the branch should be conditional
// by looking at it's location relative to an IT block
if(inITBlock()) {
@@ -5639,9 +5767,6 @@ void ARMAsmParser::cvtThumbBranches(MCInst &Inst,
case ARM::t2Bcc: Inst.setOpcode(ARM::t2B); break;
}
} else {
- // outside IT blocks we can only have unconditional branches with AL
- // condition code or conditional branches with non-AL condition code
- unsigned Cond = static_cast<ARMOperand &>(*Operands[CondOp]).getCondCode();
switch(Inst.getOpcode()) {
case ARM::tB:
case ARM::tBcc:
@@ -5658,36 +5783,56 @@ void ARMAsmParser::cvtThumbBranches(MCInst &Inst,
switch(Inst.getOpcode()) {
// classify tB as either t2B or t1B based on range of immediate operand
case ARM::tB: {
- ARMOperand &op = static_cast<ARMOperand &>(*Operands[ImmOp]);
+ ARMOperand &op = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]);
if (!op.isSignedOffset<11, 1>() && isThumb() && hasV8MBaseline())
Inst.setOpcode(ARM::t2B);
break;
}
// classify tBcc as either t2Bcc or t1Bcc based on range of immediate operand
case ARM::tBcc: {
- ARMOperand &op = static_cast<ARMOperand &>(*Operands[ImmOp]);
+ ARMOperand &op = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]);
if (!op.isSignedOffset<8, 1>() && isThumb() && hasV8MBaseline())
Inst.setOpcode(ARM::t2Bcc);
break;
}
}
- ((ARMOperand &)*Operands[ImmOp]).addImmOperands(Inst, 1);
- ((ARMOperand &)*Operands[CondOp]).addCondCodeOperands(Inst, 2);
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd]).addImmOperands(Inst, 1);
+ if (CondI != 0) {
+ ((ARMOperand &)*Operands[CondI]).addCondCodeOperands(Inst, 2);
+ } else {
+ ARMOperand Op =
+ *ARMOperand::CreateCondCode(llvm::ARMCC::AL, Operands[0]->getEndLoc());
+ Op.addCondCodeOperands(Inst, 2);
+ }
}
void ARMAsmParser::cvtMVEVMOVQtoDReg(
MCInst &Inst, const OperandVector &Operands) {
- // mnemonic, condition code, Rt, Rt2, Qd, idx, Qd again, idx2
- assert(Operands.size() == 8);
+ unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
+ unsigned CondI = findCondCodeInd(Operands, MnemonicOpsEndInd);
- ((ARMOperand &)*Operands[2]).addRegOperands(Inst, 1); // Rt
- ((ARMOperand &)*Operands[3]).addRegOperands(Inst, 1); // Rt2
- ((ARMOperand &)*Operands[4]).addRegOperands(Inst, 1); // Qd
- ((ARMOperand &)*Operands[5]).addMVEPairVectorIndexOperands(Inst, 1); // idx
+ // mnemonic, condition code, Rt, Rt2, Qd, idx, Qd again, idx2
+ assert(Operands.size() == MnemonicOpsEndInd + 6);
+
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd]).addRegOperands(Inst, 1); // Rt
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 1])
+ .addRegOperands(Inst, 1); // Rt2
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 2])
+ .addRegOperands(Inst, 1); // Qd
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 3])
+ .addMVEPairVectorIndexOperands(Inst, 1); // idx
// skip second copy of Qd in Operands[6]
- ((ARMOperand &)*Operands[7]).addMVEPairVectorIndexOperands(Inst, 1); // idx2
- ((ARMOperand &)*Operands[1]).addCondCodeOperands(Inst, 2); // condition code
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 5])
+ .addMVEPairVectorIndexOperands(Inst, 1); // idx2
+ if (CondI != 0) {
+ ((ARMOperand &)*Operands[CondI])
+ .addCondCodeOperands(Inst, 2); // condition code
+ } else {
+ ARMOperand Op =
+ *ARMOperand::CreateCondCode(ARMCC::AL, Operands[0]->getEndLoc());
+ Op.addCondCodeOperands(Inst, 2);
+ }
}
/// Parse an ARM memory expression, return false if successful else return true
@@ -5972,10 +6117,19 @@ ParseStatus ARMAsmParser::parseFPImm(OperandVector &Operands) {
// integer constant. Make sure we don't try to parse an FPImm
// for these:
// vmov.i{8|16|32|64} <dreg|qreg>, #imm
- ARMOperand &TyOp = static_cast<ARMOperand &>(*Operands[2]);
- bool isVmovf = TyOp.isToken() &&
- (TyOp.getToken() == ".f32" || TyOp.getToken() == ".f64" ||
- TyOp.getToken() == ".f16");
+
+ bool isVmovf = false;
+ unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
+ for (unsigned I = 1; I < MnemonicOpsEndInd; ++I) {
+ ARMOperand &TyOp = static_cast<ARMOperand &>(*Operands[I]);
+ if (TyOp.isToken() &&
+ (TyOp.getToken() == ".f32" || TyOp.getToken() == ".f64" ||
+ TyOp.getToken() == ".f16")) {
+ isVmovf = true;
+ break;
+ }
+ }
+
ARMOperand &Mnemonic = static_cast<ARMOperand &>(*Operands[0]);
bool isFconst = Mnemonic.isToken() && (Mnemonic.getToken() == "fconstd" ||
Mnemonic.getToken() == "fconsts");
@@ -6488,18 +6642,30 @@ void ARMAsmParser::getMnemonicAcceptInfo(StringRef Mnemonic,
CanAcceptPredicationCode = true;
}
+bool operandsContainWide(OperandVector &Operands, unsigned MnemonicOpsEndInd) {
+ for (unsigned I = 0; I < MnemonicOpsEndInd; ++I) {
+ auto &Op = static_cast<ARMOperand &>(*Operands[I]);
+ if (Op.isToken() && Op.getToken() == ".w")
+ return true;
+ }
+ return false;
+};
+
// Some Thumb instructions have two operand forms that are not
// available as three operand, convert to two operand form if possible.
//
// FIXME: We would really like to be able to tablegen'erate this.
-void ARMAsmParser::tryConvertingToTwoOperandForm(StringRef Mnemonic,
- bool CarrySetting,
- OperandVector &Operands) {
- if (Operands.size() != 6)
+void ARMAsmParser::tryConvertingToTwoOperandForm(
+ StringRef Mnemonic, ARMCC::CondCodes PredicationCode, bool CarrySetting,
+ OperandVector &Operands, unsigned MnemonicOpsEndInd) {
+
+ if (operandsContainWide(Operands, MnemonicOpsEndInd))
+ return;
+ if (Operands.size() != MnemonicOpsEndInd + 3)
return;
- const auto &Op3 = static_cast<ARMOperand &>(*Operands[3]);
- auto &Op4 = static_cast<ARMOperand &>(*Operands[4]);
+ const auto &Op3 = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]);
+ auto &Op4 = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]);
if (!Op3.isReg() || !Op4.isReg())
return;
@@ -6510,7 +6676,7 @@ void ARMAsmParser::tryConvertingToTwoOperandForm(StringRef Mnemonic,
// it in processInstruction(), but the 3 operand form of ADD (t2ADDrr)
// won't accept SP or PC so we do the transformation here taking care
// with immediate range in the 'add sp, sp #imm' case.
- auto &Op5 = static_cast<ARMOperand &>(*Operands[5]);
+ auto &Op5 = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 2]);
if (isThumbTwo()) {
if (Mnemonic != "add")
return;
@@ -6570,7 +6736,7 @@ void ARMAsmParser::tryConvertingToTwoOperandForm(StringRef Mnemonic,
if (Transform) {
if (Swap)
std::swap(Op4, Op5);
- Operands.erase(Operands.begin() + 3);
+ Operands.erase(Operands.begin() + MnemonicOpsEndInd);
}
}
@@ -6595,183 +6761,9 @@ static bool isThumbI8Relocation(MCParsedAsmOperand &MCOp) {
return false;
}
-bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic,
- OperandVector &Operands) {
- // FIXME: This is all horribly hacky. We really need a better way to deal
- // with optional operands like this in the matcher table.
-
- // The 'mov' mnemonic is special. One variant has a cc_out operand, while
- // another does not. Specifically, the MOVW instruction does not. So we
- // special case it here and remove the defaulted (non-setting) cc_out
- // operand if that's the instruction we're trying to match.
- //
- // We do this as post-processing of the explicit operands rather than just
- // conditionally adding the cc_out in the first place because we need
- // to check the type of the parsed immediate operand.
- if (Mnemonic == "mov" && Operands.size() > 4 && !isThumb() &&
- !static_cast<ARMOperand &>(*Operands[4]).isModImm() &&
- static_cast<ARMOperand &>(*Operands[4]).isImm0_65535Expr() &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0)
- return true;
-
- if (Mnemonic == "movs" && Operands.size() > 3 && isThumb() &&
- isThumbI8Relocation(*Operands[3]))
- return true;
-
- // Register-register 'add' for thumb does not have a cc_out operand
- // when there are only two register operands.
- if (isThumb() && Mnemonic == "add" && Operands.size() == 5 &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0)
- return true;
- // Register-register 'add' for thumb does not have a cc_out operand
- // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do
- // have to check the immediate range here since Thumb2 has a variant
- // that can handle a different range and has a cc_out operand.
- if (((isThumb() && Mnemonic == "add") ||
- (isThumbTwo() && Mnemonic == "sub")) &&
- Operands.size() == 6 && static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).getReg() == ARM::SP &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0 &&
- ((Mnemonic == "add" && static_cast<ARMOperand &>(*Operands[5]).isReg()) ||
- static_cast<ARMOperand &>(*Operands[5]).isImm0_1020s4()))
- return true;
- // For Thumb2, add/sub immediate does not have a cc_out operand for the
- // imm0_4095 variant. That's the least-preferred variant when
- // selecting via the generic "add" mnemonic, so to know that we
- // should remove the cc_out operand, we have to explicitly check that
- // it's not one of the other variants. Ugh.
- if (isThumbTwo() && (Mnemonic == "add" || Mnemonic == "sub") &&
- Operands.size() == 6 && static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- static_cast<ARMOperand &>(*Operands[5]).isImm()) {
- // Nest conditions rather than one big 'if' statement for readability.
- //
- // If both registers are low, we're in an IT block, and the immediate is
- // in range, we should use encoding T1 instead, which has a cc_out.
- if (inITBlock() &&
- isARMLowRegister(static_cast<ARMOperand &>(*Operands[3]).getReg()) &&
- isARMLowRegister(static_cast<ARMOperand &>(*Operands[4]).getReg()) &&
- static_cast<ARMOperand &>(*Operands[5]).isImm0_7())
- return false;
- // Check against T3. If the second register is the PC, this is an
- // alternate form of ADR, which uses encoding T4, so check for that too.
- if (static_cast<ARMOperand &>(*Operands[4]).getReg() != ARM::PC &&
- (static_cast<ARMOperand &>(*Operands[5]).isT2SOImm() ||
- static_cast<ARMOperand &>(*Operands[5]).isT2SOImmNeg()))
- return false;
-
- // Otherwise, we use encoding T4, which does not have a cc_out
- // operand.
- return true;
- }
-
- // The thumb2 multiply instruction doesn't have a CCOut register, so
- // if we have a "mul" mnemonic in Thumb mode, check if we'll be able to
- // use the 16-bit encoding or not.
- if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 6 &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0 &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- static_cast<ARMOperand &>(*Operands[5]).isReg() &&
- // If the registers aren't low regs, the destination reg isn't the
- // same as one of the source regs, or the cc_out operand is zero
- // outside of an IT block, we have to use the 32-bit encoding, so
- // remove the cc_out operand.
- (!isARMLowRegister(static_cast<ARMOperand &>(*Operands[3]).getReg()) ||
- !isARMLowRegister(static_cast<ARMOperand &>(*Operands[4]).getReg()) ||
- !isARMLowRegister(static_cast<ARMOperand &>(*Operands[5]).getReg()) ||
- !inITBlock() || (static_cast<ARMOperand &>(*Operands[3]).getReg() !=
- static_cast<ARMOperand &>(*Operands[5]).getReg() &&
- static_cast<ARMOperand &>(*Operands[3]).getReg() !=
- static_cast<ARMOperand &>(*Operands[4]).getReg())))
- return true;
-
- // Also check the 'mul' syntax variant that doesn't specify an explicit
- // destination register.
- if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 5 &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0 &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- // If the registers aren't low regs or the cc_out operand is zero
- // outside of an IT block, we have to use the 32-bit encoding, so
- // remove the cc_out operand.
- (!isARMLowRegister(static_cast<ARMOperand &>(*Operands[3]).getReg()) ||
- !isARMLowRegister(static_cast<ARMOperand &>(*Operands[4]).getReg()) ||
- !inITBlock()))
- return true;
-
- // Register-register 'add/sub' for thumb does not have a cc_out operand
- // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also
- // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't
- // right, this will result in better diagnostics (which operand is off)
- // anyway.
- if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") &&
- (Operands.size() == 5 || Operands.size() == 6) &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[3]).getReg() == ARM::SP &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0 &&
- (static_cast<ARMOperand &>(*Operands[4]).isImm() ||
- (Operands.size() == 6 &&
- static_cast<ARMOperand &>(*Operands[5]).isImm()))) {
- // Thumb2 (add|sub){s}{p}.w GPRnopc, sp, #{T2SOImm} has cc_out
- return (!(isThumbTwo() &&
- (static_cast<ARMOperand &>(*Operands[4]).isT2SOImm() ||
- static_cast<ARMOperand &>(*Operands[4]).isT2SOImmNeg())));
- }
- // Fixme: Should join all the thumb+thumb2 (add|sub) in a single if case
- // Thumb2 ADD r0, #4095 -> ADDW r0, r0, #4095 (T4)
- // Thumb2 SUB r0, #4095 -> SUBW r0, r0, #4095
- if (isThumbTwo() && (Mnemonic == "add" || Mnemonic == "sub") &&
- (Operands.size() == 5) &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[3]).getReg() != ARM::SP &&
- static_cast<ARMOperand &>(*Operands[3]).getReg() != ARM::PC &&
- static_cast<ARMOperand &>(*Operands[1]).getReg() == 0 &&
- static_cast<ARMOperand &>(*Operands[4]).isImm()) {
- const ARMOperand &IMM = static_cast<ARMOperand &>(*Operands[4]);
- if (IMM.isT2SOImm() || IMM.isT2SOImmNeg())
- return false; // add.w / sub.w
- if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(IMM.getImm())) {
- const int64_t Value = CE->getValue();
- // Thumb1 imm8 sub / add
- if ((Value < ((1 << 7) - 1) << 2) && inITBlock() && (!(Value & 3)) &&
- isARMLowRegister(static_cast<ARMOperand &>(*Operands[3]).getReg()))
- return false;
- return true; // Thumb2 T4 addw / subw
- }
- }
- return false;
-}
-
-bool ARMAsmParser::shouldOmitPredicateOperand(StringRef Mnemonic,
- OperandVector &Operands) {
- // VRINT{Z, X} have a predicate operand in VFP, but not in NEON
- unsigned RegIdx = 3;
- if ((((Mnemonic == "vrintz" || Mnemonic == "vrintx") && !hasMVE()) ||
- Mnemonic == "vrintr") &&
- (static_cast<ARMOperand &>(*Operands[2]).getToken() == ".f32" ||
- static_cast<ARMOperand &>(*Operands[2]).getToken() == ".f16")) {
- if (static_cast<ARMOperand &>(*Operands[3]).isToken() &&
- (static_cast<ARMOperand &>(*Operands[3]).getToken() == ".f32" ||
- static_cast<ARMOperand &>(*Operands[3]).getToken() == ".f16"))
- RegIdx = 4;
-
- if (static_cast<ARMOperand &>(*Operands[RegIdx]).isReg() &&
- (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(
- static_cast<ARMOperand &>(*Operands[RegIdx]).getReg()) ||
- ARMMCRegisterClasses[ARM::QPRRegClassID].contains(
- static_cast<ARMOperand &>(*Operands[RegIdx]).getReg())))
- return true;
- }
- return false;
-}
-
-bool ARMAsmParser::shouldOmitVectorPredicateOperand(StringRef Mnemonic,
- OperandVector &Operands) {
- if (!hasMVE() || Operands.size() < 3)
+bool ARMAsmParser::shouldOmitVectorPredicateOperand(
+ StringRef Mnemonic, OperandVector &Operands, unsigned MnemonicOpsEndInd) {
+ if (!hasMVE() || Operands.size() < MnemonicOpsEndInd)
return true;
if (Mnemonic.starts_with("vld2") || Mnemonic.starts_with("vld4") ||
@@ -6803,22 +6795,13 @@ bool ARMAsmParser::shouldOmitVectorPredicateOperand(StringRef Mnemonic,
if (static_cast<ARMOperand &>(*Operand).isVectorIndex() ||
(Operand->isReg() &&
(ARMMCRegisterClasses[ARM::QPRRegClassID].contains(
- Operand->getReg()))))
+ Operand->getReg()))))
return false;
}
return true;
}
}
-static bool isDataTypeToken(StringRef Tok) {
- return Tok == ".8" || Tok == ".16" || Tok == ".32" || Tok == ".64" ||
- Tok == ".i8" || Tok == ".i16" || Tok == ".i32" || Tok == ".i64" ||
- Tok == ".u8" || Tok == ".u16" || Tok == ".u32" || Tok == ".u64" ||
- Tok == ".s8" || Tok == ".s16" || Tok == ".s32" || Tok == ".s64" ||
- Tok == ".p8" || Tok == ".p16" || Tok == ".f32" || Tok == ".f64" ||
- Tok == ".f" || Tok == ".d";
-}
-
// FIXME: This bit should probably be handled via an explicit match class
// in the .td files that matches the suffix instead of having it be
// a literal string token the way it is now.
@@ -6839,14 +6822,15 @@ static void applyMnemonicAliases(StringRef &Mnemonic,
// bail out, and let the assembly parser report an error on the instruction as
// it is written.
void ARMAsmParser::fixupGNULDRDAlias(StringRef Mnemonic,
- OperandVector &Operands) {
+ OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
if (Mnemonic != "ldrd" && Mnemonic != "strd")
return;
- if (Operands.size() < 4)
+ if (Operands.size() < MnemonicOpsEndInd + 2)
return;
- ARMOperand &Op2 = static_cast<ARMOperand &>(*Operands[2]);
- ARMOperand &Op3 = static_cast<ARMOperand &>(*Operands[3]);
+ ARMOperand &Op2 = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]);
+ ARMOperand &Op3 = static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]);
if (!Op2.isReg())
return;
@@ -6871,7 +6855,7 @@ void ARMAsmParser::fixupGNULDRDAlias(StringRef Mnemonic,
return;
Operands.insert(
- Operands.begin() + 3,
+ Operands.begin() + MnemonicOpsEndInd + 1,
ARMOperand::CreateReg(PairedReg, Op2.getStartLoc(), Op2.getEndLoc()));
}
@@ -6881,19 +6865,17 @@ void ARMAsmParser::fixupGNULDRDAlias(StringRef Mnemonic,
// operand. If the conversion fails an error is diagnosed, and the function
// returns true.
bool ARMAsmParser::CDEConvertDualRegOperand(StringRef Mnemonic,
- OperandVector &Operands) {
+ OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
assert(MS.isCDEDualRegInstr(Mnemonic));
- bool isPredicable =
- Mnemonic == "cx1da" || Mnemonic == "cx2da" || Mnemonic == "cx3da";
- size_t NumPredOps = isPredicable ? 1 : 0;
- if (Operands.size() <= 3 + NumPredOps)
+ if (Operands.size() < 2 + MnemonicOpsEndInd)
return false;
StringRef Op2Diag(
"operand must be an even-numbered register in the range [r0, r10]");
- const MCParsedAsmOperand &Op2 = *Operands[2 + NumPredOps];
+ const MCParsedAsmOperand &Op2 = *Operands[MnemonicOpsEndInd + 1];
if (!Op2.isReg())
return Error(Op2.getStartLoc(), Op2Diag);
@@ -6928,16 +6910,43 @@ bool ARMAsmParser::CDEConvertDualRegOperand(StringRef Mnemonic,
break;
}
- const MCParsedAsmOperand &Op3 = *Operands[3 + NumPredOps];
+ const MCParsedAsmOperand &Op3 = *Operands[MnemonicOpsEndInd + 2];
if (!Op3.isReg() || Op3.getReg() != RNext)
return Error(Op3.getStartLoc(), "operand must be a consecutive register");
- Operands.erase(Operands.begin() + 3 + NumPredOps);
- Operands[2 + NumPredOps] =
+ Operands.erase(Operands.begin() + MnemonicOpsEndInd + 2);
+ Operands[MnemonicOpsEndInd + 1] =
ARMOperand::CreateReg(RPair, Op2.getStartLoc(), Op2.getEndLoc());
return false;
}
+void removeCondCode(OperandVector &Operands, unsigned &MnemonicOpsEndInd) {
+ for (unsigned I = 0; I < MnemonicOpsEndInd; ++I)
+ if (static_cast<ARMOperand &>(*Operands[I]).isCondCode()) {
+ Operands.erase(Operands.begin() + I);
+ --MnemonicOpsEndInd;
+ break;
+ }
+}
+
+void removeCCOut(OperandVector &Operands, unsigned &MnemonicOpsEndInd) {
+ for (unsigned I = 0; I < MnemonicOpsEndInd; ++I)
+ if (static_cast<ARMOperand &>(*Operands[I]).isCCOut()) {
+ Operands.erase(Operands.begin() + I);
+ --MnemonicOpsEndInd;
+ break;
+ }
+}
+
+void removeVPTCondCode(OperandVector &Operands, unsigned &MnemonicOpsEndInd) {
+ for (unsigned I = 0; I < MnemonicOpsEndInd; ++I)
+ if (static_cast<ARMOperand &>(*Operands[I]).isVPTPred()) {
+ Operands.erase(Operands.begin() + I);
+ --MnemonicOpsEndInd;
+ break;
+ }
+}
+
/// Parse an arm instruction mnemonic followed by its operands.
bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) {
@@ -7118,6 +7127,11 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
}
+ // This marks the end of the LHS Mnemonic operators
+ // This is used for indexing into the non-menmonic operators as some of the
+ // mnemonic operators are optional and therfore indexes can differ.
+ unsigned MnemonicOpsEndInd = Operands.size();
+
// Read the remaining operands.
if (getLexer().isNot(AsmToken::EndOfStatement)) {
// Read the first operand.
@@ -7136,7 +7150,17 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
if (parseToken(AsmToken::EndOfStatement, "unexpected token in argument list"))
return true;
- tryConvertingToTwoOperandForm(Mnemonic, CarrySetting, Operands);
+ // Remove the optional tokens if they are the default values
+ // This can only be done after parsing as the index of the operands
+ // is used for custom parsers.
+ // CCOut
+ if (!CarrySetting && CanAcceptCarrySet)
+ removeCCOut(Operands, MnemonicOpsEndInd);
+ if (PredicationCode == llvm::ARMCC::AL && CanAcceptPredicationCode)
+ removeCondCode(Operands, MnemonicOpsEndInd);
+
+ tryConvertingToTwoOperandForm(Mnemonic, PredicationCode, CarrySetting,
+ Operands, MnemonicOpsEndInd);
if (hasCDE() && MS.isCDEInstr(Mnemonic)) {
// Dual-register instructions use even-odd register pairs as their
@@ -7147,33 +7171,16 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
// returns false, the function either succeeded or an error (e.g. missing
// operand) will be diagnosed elsewhere.
if (MS.isCDEDualRegInstr(Mnemonic)) {
- bool GotError = CDEConvertDualRegOperand(Mnemonic, Operands);
+ bool GotError =
+ CDEConvertDualRegOperand(Mnemonic, Operands, MnemonicOpsEndInd);
if (GotError)
return GotError;
}
}
- // Some instructions, mostly Thumb, have forms for the same mnemonic that
- // do and don't have a cc_out optional-def operand. With some spot-checks
- // of the operand list, we can figure out which variant we're trying to
- // parse and adjust accordingly before actually matching. We shouldn't ever
- // try to remove a cc_out operand that was explicitly set on the
- // mnemonic, of course (CarrySetting == true). Reason number #317 the
- // table driven matcher doesn't fit well with the ARM instruction set.
- if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands))
- Operands.erase(Operands.begin() + 1);
-
- // Some instructions have the same mnemonic, but don't always
- // have a predicate. Distinguish them here and delete the
- // appropriate predicate if needed. This could be either the scalar
- // predication code or the vector predication code.
- if (PredicationCode == ARMCC::AL &&
- shouldOmitPredicateOperand(Mnemonic, Operands))
- Operands.erase(Operands.begin() + 1);
-
-
if (hasMVE()) {
- if (!shouldOmitVectorPredicateOperand(Mnemonic, Operands) &&
+ if (!shouldOmitVectorPredicateOperand(Mnemonic, Operands,
+ MnemonicOpsEndInd) &&
Mnemonic == "vmov" && PredicationCode == ARMCC::LT) {
// Very nasty hack to deal with the vector predicated variant of vmovlt
// the scalar predicated vmov with condition 'lt'. We can not tell them
@@ -7188,7 +7195,8 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
Operands.insert(Operands.begin(),
ARMOperand::CreateToken(StringRef("vmovlt"), MLoc));
} else if (Mnemonic == "vcvt" && PredicationCode == ARMCC::NE &&
- !shouldOmitVectorPredicateOperand(Mnemonic, Operands)) {
+ !shouldOmitVectorPredicateOperand(Mnemonic, Operands,
+ MnemonicOpsEndInd)) {
// Another nasty hack to deal with the ambiguity between vcvt with scalar
// predication 'ne' and vcvtn with vector predication 'e'. As above we
// can only distinguish between the two after we have parsed their
@@ -7203,11 +7211,12 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
Operands.insert(Operands.begin(),
ARMOperand::CreateToken(StringRef("vcvtn"), MLoc));
} else if (Mnemonic == "vmul" && PredicationCode == ARMCC::LT &&
- !shouldOmitVectorPredicateOperand(Mnemonic, Operands)) {
+ !shouldOmitVectorPredicateOperand(Mnemonic, Operands,
+ MnemonicOpsEndInd)) {
// Another hack, this time to distinguish between scalar predicated vmul
// with 'lt' predication code and the vector instruction vmullt with
// vector predication code "none"
- Operands.erase(Operands.begin() + 1);
+ removeCondCode(Operands, MnemonicOpsEndInd);
Operands.erase(Operands.begin());
SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
Operands.insert(Operands.begin(),
@@ -7223,16 +7232,19 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
!Mnemonic.starts_with("vcvtn") &&
!Mnemonic.starts_with("vcvtp") &&
!Mnemonic.starts_with("vcvtm"))) {
- if (!shouldOmitVectorPredicateOperand(Mnemonic, Operands)) {
+ if (!shouldOmitVectorPredicateOperand(Mnemonic, Operands,
+ MnemonicOpsEndInd)) {
// We could not split the vector predicate off vcvt because it might
// have been the scalar vcvtt instruction. Now we know its a vector
// instruction, we still need to check whether its the vector
// predicated vcvt with 'Then' predication or the vector vcvtt. We can
// distinguish the two based on the suffixes, if it is any of
// ".f16.f32", ".f32.f16", ".f16.f64" or ".f64.f16" then it is the vcvtt.
- if (Mnemonic.starts_with("vcvtt") && Operands.size() >= 4) {
- auto Sz1 = static_cast<ARMOperand &>(*Operands[2]);
- auto Sz2 = static_cast<ARMOperand &>(*Operands[3]);
+ if (Mnemonic.starts_with("vcvtt") && MnemonicOpsEndInd > 2) {
+ auto Sz1 =
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd - 2]);
+ auto Sz2 =
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd - 1]);
if (!(Sz1.isToken() && Sz1.getToken().starts_with(".f") &&
Sz2.isToken() && Sz2.getToken().starts_with(".f"))) {
Operands.erase(Operands.begin());
@@ -7244,24 +7256,25 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
ARMOperand::CreateToken(Mnemonic, MLoc));
}
}
- Operands.erase(Operands.begin() + 1);
+ // Remove CondCode
+ removeCondCode(Operands, MnemonicOpsEndInd);
SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
Mnemonic.size() + CarrySetting);
+ // Add VPTPred
Operands.insert(Operands.begin() + 1,
ARMOperand::CreateVPTPred(
ARMVCC::VPTCodes(VPTPredicationCode), PLoc));
+ ++MnemonicOpsEndInd;
}
} else if (CanAcceptVPTPredicationCode) {
// For all other instructions, make sure only one of the two
// predication operands is left behind, depending on whether we should
// use the vector predication.
- if (shouldOmitVectorPredicateOperand(Mnemonic, Operands)) {
- if (CanAcceptPredicationCode)
- Operands.erase(Operands.begin() + 2);
- else
- Operands.erase(Operands.begin() + 1);
+ if (shouldOmitVectorPredicateOperand(Mnemonic, Operands,
+ MnemonicOpsEndInd)) {
+ removeVPTCondCode(Operands, MnemonicOpsEndInd);
} else if (CanAcceptPredicationCode && PredicationCode == ARMCC::AL) {
- Operands.erase(Operands.begin() + 1);
+ removeCondCode(Operands, MnemonicOpsEndInd);
}
}
}
@@ -7286,69 +7299,73 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
}
- // ARM mode 'blx' need special handling, as the register operand version
- // is predicable, but the label operand version is not. So, we can't rely
- // on the Mnemonic based checking to correctly figure out when to put
- // a k_CondCode operand in the list. If we're trying to match the label
- // version, remove the k_CondCode operand here.
- if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
- static_cast<ARMOperand &>(*Operands[2]).isImm())
- Operands.erase(Operands.begin() + 1);
-
- // Adjust operands of ldrexd/strexd to MCK_GPRPair.
- // ldrexd/strexd require even/odd GPR pair. To enforce this constraint,
- // a single GPRPair reg operand is used in the .td file to replace the two
- // GPRs. However, when parsing from asm, the two GRPs cannot be
- // automatically
- // expressed as a GPRPair, so we have to manually merge them.
- // FIXME: We would really like to be able to tablegen'erate this.
- if (!isThumb() && Operands.size() > 4 &&
- (Mnemonic == "ldrexd" || Mnemonic == "strexd" || Mnemonic == "ldaexd" ||
- Mnemonic == "stlexd")) {
- bool isLoad = (Mnemonic == "ldrexd" || Mnemonic == "ldaexd");
- unsigned Idx = isLoad ? 2 : 3;
- ARMOperand &Op1 = static_cast<ARMOperand &>(*Operands[Idx]);
- ARMOperand &Op2 = static_cast<ARMOperand &>(*Operands[Idx + 1]);
-
- const MCRegisterClass &MRC = MRI->getRegClass(ARM::GPRRegClassID);
- // Adjust only if Op1 and Op2 are GPRs.
- if (Op1.isReg() && Op2.isReg() && MRC.contains(Op1.getReg()) &&
- MRC.contains(Op2.getReg())) {
- unsigned Reg1 = Op1.getReg();
- unsigned Reg2 = Op2.getReg();
- unsigned Rt = MRI->getEncodingValue(Reg1);
- unsigned Rt2 = MRI->getEncodingValue(Reg2);
-
- // Rt2 must be Rt + 1 and Rt must be even.
- if (Rt + 1 != Rt2 || (Rt & 1)) {
- return Error(Op2.getStartLoc(),
- isLoad ? "destination operands must be sequential"
- : "source operands must be sequential");
- }
- unsigned NewReg = MRI->getMatchingSuperReg(
- Reg1, ARM::gsub_0, &(MRI->getRegClass(ARM::GPRPairRegClassID)));
- Operands[Idx] =
- ARMOperand::CreateReg(NewReg, Op1.getStartLoc(), Op2.getEndLoc());
- Operands.erase(Operands.begin() + Idx + 1);
+ // ARM mode 'blx' need special handling, as the register operand version
+ // is predicable, but the label operand version is not. So, we can't rely
+ // on the Mnemonic based checking to correctly figure out when to put
+ // a k_CondCode operand in the list. If we're trying to match the label
+ // version, remove the k_CondCode operand here.
+ if (!isThumb() && Mnemonic == "blx" &&
+ Operands.size() == MnemonicOpsEndInd + 1 &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]).isImm())
+ removeCondCode(Operands, MnemonicOpsEndInd);
+
+ // Adjust operands of ldrexd/strexd to MCK_GPRPair.
+ // ldrexd/strexd require even/odd GPR pair. To enforce this constraint,
+ // a single GPRPair reg operand is used in the .td file to replace the two
+ // GPRs. However, when parsing from asm, the two GRPs cannot be
+ // automatically
+ // expressed as a GPRPair, so we have to manually merge them.
+ // FIXME: We would really like to be able to tablegen'erate this.
+ if (!isThumb() && Operands.size() > MnemonicOpsEndInd + 1 &&
+ (Mnemonic == "ldrexd" || Mnemonic == "strexd" || Mnemonic == "ldaexd" ||
+ Mnemonic == "stlexd")) {
+ bool isLoad = (Mnemonic == "ldrexd" || Mnemonic == "ldaexd");
+ unsigned Idx = isLoad ? MnemonicOpsEndInd : MnemonicOpsEndInd + 1;
+ ARMOperand &Op1 = static_cast<ARMOperand &>(*Operands[Idx]);
+ ARMOperand &Op2 = static_cast<ARMOperand &>(*Operands[Idx + 1]);
+
+ const MCRegisterClass &MRC = MRI->getRegClass(ARM::GPRRegClassID);
+ // Adjust only if Op1 and Op2 are GPRs.
+ if (Op1.isReg() && Op2.isReg() && MRC.contains(Op1.getReg()) &&
+ MRC.contains(Op2.getReg())) {
+ unsigned Reg1 = Op1.getReg();
+ unsigned Reg2 = Op2.getReg();
+ unsigned Rt = MRI->getEncodingValue(Reg1);
+ unsigned Rt2 = MRI->getEncodingValue(Reg2);
+
+ // Rt2 must be Rt + 1 and Rt must be even.
+ if (Rt + 1 != Rt2 || (Rt & 1)) {
+ return Error(Op2.getStartLoc(),
+ isLoad ? "destination operands must be sequential"
+ : "source operands must be sequential");
}
+ unsigned NewReg = MRI->getMatchingSuperReg(
+ Reg1, ARM::gsub_0, &(MRI->getRegClass(ARM::GPRPairRegClassID)));
+ Operands[Idx] =
+ ARMOperand::CreateReg(NewReg, Op1.getStartLoc(), Op2.getEndLoc());
+ Operands.erase(Operands.begin() + Idx + 1);
+ }
}
// GNU Assembler extension (compatibility).
- fixupGNULDRDAlias(Mnemonic, Operands);
+ fixupGNULDRDAlias(Mnemonic, Operands, MnemonicOpsEndInd);
// FIXME: As said above, this is all a pretty gross hack. This instruction
// does not fit with other "subs" and tblgen.
// Adjust operands of B9.3.19 SUBS PC, LR, #imm (Thumb2) system instruction
// so the Mnemonic is the original name "subs" and delete the predicate
// operand so it will match the table entry.
- if (isThumbTwo() && Mnemonic == "sub" && Operands.size() == 6 &&
- static_cast<ARMOperand &>(*Operands[3]).isReg() &&
- static_cast<ARMOperand &>(*Operands[3]).getReg() == ARM::PC &&
- static_cast<ARMOperand &>(*Operands[4]).isReg() &&
- static_cast<ARMOperand &>(*Operands[4]).getReg() == ARM::LR &&
- static_cast<ARMOperand &>(*Operands[5]).isImm()) {
+ if (isThumbTwo() && Mnemonic == "sub" &&
+ Operands.size() == MnemonicOpsEndInd + 3 &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]).isReg() &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]).getReg() ==
+ ARM::PC &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]).isReg() &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]).getReg() ==
+ ARM::LR &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 2]).isImm()) {
Operands.front() = ARMOperand::CreateToken(Name, NameLoc);
- Operands.erase(Operands.begin() + 1);
+ removeCCOut(Operands, MnemonicOpsEndInd);
}
return false;
}
@@ -7393,49 +7410,61 @@ static bool instIsBreakpoint(const MCInst &Inst) {
Inst.getOpcode() == ARM::HLT;
}
+unsigned getRegListInd(const OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
+ for (unsigned I = MnemonicOpsEndInd; I < Operands.size(); ++I) {
+ const ARMOperand &Op = static_cast<const ARMOperand &>(*Operands[I]);
+ if (Op.isRegList()) {
+ return I;
+ }
+ }
+ return 0;
+}
+
bool ARMAsmParser::validatetLDMRegList(const MCInst &Inst,
const OperandVector &Operands,
- unsigned ListNo, bool IsARPop) {
- const ARMOperand &Op = static_cast<const ARMOperand &>(*Operands[ListNo]);
- bool HasWritebackToken = Op.isToken() && Op.getToken() == "!";
-
- bool ListContainsSP = listContainsReg(Inst, ListNo, ARM::SP);
- bool ListContainsLR = listContainsReg(Inst, ListNo, ARM::LR);
- bool ListContainsPC = listContainsReg(Inst, ListNo, ARM::PC);
+ unsigned MnemonicOpsEndInd,
+ unsigned ListIndex, bool IsARPop) {
+ bool ListContainsSP = listContainsReg(Inst, ListIndex, ARM::SP);
+ bool ListContainsLR = listContainsReg(Inst, ListIndex, ARM::LR);
+ bool ListContainsPC = listContainsReg(Inst, ListIndex, ARM::PC);
if (!IsARPop && ListContainsSP)
- return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
- "SP may not be in the register list");
- else if (ListContainsPC && ListContainsLR)
- return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
- "PC and LR may not be in the register list simultaneously");
+ return Error(
+ Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
+ "SP may not be in the register list");
+ if (ListContainsPC && ListContainsLR)
+ return Error(
+ Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
+ "PC and LR may not be in the register list simultaneously");
return false;
}
bool ARMAsmParser::validatetSTMRegList(const MCInst &Inst,
const OperandVector &Operands,
- unsigned ListNo) {
- const ARMOperand &Op = static_cast<const ARMOperand &>(*Operands[ListNo]);
- bool HasWritebackToken = Op.isToken() && Op.getToken() == "!";
-
- bool ListContainsSP = listContainsReg(Inst, ListNo, ARM::SP);
- bool ListContainsPC = listContainsReg(Inst, ListNo, ARM::PC);
+ unsigned MnemonicOpsEndInd,
+ unsigned ListIndex) {
+ bool ListContainsSP = listContainsReg(Inst, ListIndex, ARM::SP);
+ bool ListContainsPC = listContainsReg(Inst, ListIndex, ARM::PC);
if (ListContainsSP && ListContainsPC)
- return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
- "SP and PC may not be in the register list");
- else if (ListContainsSP)
- return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
- "SP may not be in the register list");
- else if (ListContainsPC)
- return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
- "PC may not be in the register list");
+ return Error(
+ Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
+ "SP and PC may not be in the register list");
+ if (ListContainsSP)
+ return Error(
+ Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
+ "SP may not be in the register list");
+ if (ListContainsPC)
+ return Error(
+ Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
+ "PC may not be in the register list");
return false;
}
-bool ARMAsmParser::validateLDRDSTRD(MCInst &Inst,
- const OperandVector &Operands,
- bool Load, bool ARMMode, bool Writeback) {
+bool ARMAsmParser::validateLDRDSTRD(MCInst &Inst, const OperandVector &Operands,
+ bool Load, bool ARMMode, bool Writeback,
+ unsigned MnemonicOpsEndInd) {
unsigned RtIndex = Load || !Writeback ? 0 : 1;
unsigned Rt = MRI->getEncodingValue(Inst.getOperand(RtIndex).getReg());
unsigned Rt2 = MRI->getEncodingValue(Inst.getOperand(RtIndex + 1).getReg());
@@ -7443,21 +7472,21 @@ bool ARMAsmParser::validateLDRDSTRD(MCInst &Inst,
if (ARMMode) {
// Rt can't be R14.
if (Rt == 14)
- return Error(Operands[3]->getStartLoc(),
- "Rt can't be R14");
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Rt can't be R14");
// Rt must be even-numbered.
if ((Rt & 1) == 1)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"Rt must be even-numbered");
// Rt2 must be Rt + 1.
if (Rt2 != Rt + 1) {
if (Load)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination operands must be sequential");
else
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"source operands must be sequential");
}
@@ -7467,7 +7496,7 @@ bool ARMAsmParser::validateLDRDSTRD(MCInst &Inst,
if (!ARMMode && Load) {
if (Rt2 == Rt)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination operands can't be identical");
}
@@ -7476,11 +7505,11 @@ bool ARMAsmParser::validateLDRDSTRD(MCInst &Inst,
if (Rn == Rt || Rn == Rt2) {
if (Load)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"base register needs to be different from destination "
"registers");
else
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"source register and base register can't be identical");
}
@@ -7518,7 +7547,8 @@ static bool isARMMCExpr(MCParsedAsmOperand &MCOp) {
// FIXME: We would really like to be able to tablegen'erate this.
bool ARMAsmParser::validateInstruction(MCInst &Inst,
- const OperandVector &Operands) {
+ const OperandVector &Operands,
+ unsigned MnemonicOpsEndInd) {
const MCInstrDesc &MCID = MII.get(Inst.getOpcode());
SMLoc Loc = Operands[0]->getStartLoc();
@@ -7533,7 +7563,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm());
if (Cond != currentITCond()) {
// Find the condition code Operand to get its SMLoc information.
- SMLoc CondLoc;
+ SMLoc CondLoc = Operands[0]->getEndLoc();
for (unsigned I = 1; I < Operands.size(); ++I)
if (static_cast<ARMOperand &>(*Operands[I]).isCondCode())
CondLoc = Operands[I]->getStartLoc();
@@ -7612,50 +7642,50 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
break;
}
case ARM::LDRD:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/true, /*ARMMode*/true,
- /*Writeback*/false))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ true, /*ARMMode*/ true,
+ /*Writeback*/ false, MnemonicOpsEndInd))
return true;
break;
case ARM::LDRD_PRE:
case ARM::LDRD_POST:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/true, /*ARMMode*/true,
- /*Writeback*/true))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ true, /*ARMMode*/ true,
+ /*Writeback*/ true, MnemonicOpsEndInd))
return true;
break;
case ARM::t2LDRDi8:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/true, /*ARMMode*/false,
- /*Writeback*/false))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ true, /*ARMMode*/ false,
+ /*Writeback*/ false, MnemonicOpsEndInd))
return true;
break;
case ARM::t2LDRD_PRE:
case ARM::t2LDRD_POST:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/true, /*ARMMode*/false,
- /*Writeback*/true))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ true, /*ARMMode*/ false,
+ /*Writeback*/ true, MnemonicOpsEndInd))
return true;
break;
case ARM::t2BXJ: {
const unsigned RmReg = Inst.getOperand(0).getReg();
// Rm = SP is no longer unpredictable in v8-A
if (RmReg == ARM::SP && !hasV8Ops())
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"r13 (SP) is an unpredictable operand to BXJ");
return false;
}
case ARM::STRD:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/false, /*ARMMode*/true,
- /*Writeback*/false))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ false, /*ARMMode*/ true,
+ /*Writeback*/ false, MnemonicOpsEndInd))
return true;
break;
case ARM::STRD_PRE:
case ARM::STRD_POST:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/false, /*ARMMode*/true,
- /*Writeback*/true))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ false, /*ARMMode*/ true,
+ /*Writeback*/ true, MnemonicOpsEndInd))
return true;
break;
case ARM::t2STRD_PRE:
case ARM::t2STRD_POST:
- if (validateLDRDSTRD(Inst, Operands, /*Load*/false, /*ARMMode*/false,
- /*Writeback*/true))
+ if (validateLDRDSTRD(Inst, Operands, /*Load*/ false, /*ARMMode*/ false,
+ /*Writeback*/ true, MnemonicOpsEndInd))
return true;
break;
case ARM::STR_PRE_IMM:
@@ -7679,7 +7709,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Rn = MRI->getEncodingValue(Inst.getOperand(2).getReg());
if (Rt == Rn)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
"source register and base register can't be identical");
return false;
}
@@ -7692,19 +7722,19 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Rn = MRI->getEncodingValue(Inst.getOperand(1).getReg());
if (Rt == Rn)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination register and base register can't be identical");
if (Inst.getOpcode() == ARM::t2LDR_POST_imm ||
Inst.getOpcode() == ARM::t2STR_POST_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 255 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [-255, 255]");
}
if (Inst.getOpcode() == ARM::t2STR_PRE_imm ||
Inst.getOpcode() == ARM::t2STR_POST_imm) {
if (Inst.getOperand(0).getReg() == ARM::PC) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"operand must be a register in range [r0, r14]");
}
}
@@ -7723,17 +7753,17 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
Inst.getOpcode() == ARM::t2STRB_PRE_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 255 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [-255, 255]");
} else if (Inst.getOpcode() == ARM::t2LDRB_OFFSET_imm ||
Inst.getOpcode() == ARM::t2STRB_OFFSET_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 0 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [0, 255] with a negative sign");
}
if (Inst.getOperand(0).getReg() == ARM::PC) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"if operand is PC, should call the LDRB (literal)");
}
return false;
@@ -7751,17 +7781,17 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
Inst.getOpcode() == ARM::t2STRH_PRE_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 255 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [-255, 255]");
} else if (Inst.getOpcode() == ARM::t2LDRH_OFFSET_imm ||
Inst.getOpcode() == ARM::t2STRH_OFFSET_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 0 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [0, 255] with a negative sign");
}
if (Inst.getOperand(0).getReg() == ARM::PC) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"if operand is PC, should call the LDRH (literal)");
}
return false;
@@ -7774,16 +7804,16 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
Inst.getOpcode() == ARM::t2LDRSB_PRE_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 255 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [-255, 255]");
} else if (Inst.getOpcode() == ARM::t2LDRSB_OFFSET_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 0 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [0, 255] with a negative sign");
}
if (Inst.getOperand(0).getReg() == ARM::PC) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"if operand is PC, should call the LDRH (literal)");
}
return false;
@@ -7796,16 +7826,16 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
Inst.getOpcode() == ARM::t2LDRSH_PRE_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 255 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [-255, 255]");
} else if (Inst.getOpcode() == ARM::t2LDRSH_OFFSET_imm) {
int Imm = Inst.getOperand(2).getImm();
if (Imm > 0 || Imm < -255)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"operand must be in range [0, 255] with a negative sign");
}
if (Inst.getOperand(0).getReg() == ARM::PC) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"if operand is PC, should call the LDRH (literal)");
}
return false;
@@ -7840,7 +7870,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Rn = MRI->getEncodingValue(Inst.getOperand(2).getReg());
if (Rt == Rn)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination register and base register can't be identical");
return false;
}
@@ -7884,10 +7914,10 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Qm = MRI->getEncodingValue(Inst.getOperand(QmIdx).getReg());
if (Qd == Qm) {
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
Twine("destination vector register and vector ") +
- (QmIsPointer ? "pointer" : "offset") +
- " register can't be identical");
+ (QmIsPointer ? "pointer" : "offset") +
+ " register can't be identical");
}
return false;
}
@@ -7900,7 +7930,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
unsigned LSB = Inst.getOperand(2).getImm();
unsigned Widthm1 = Inst.getOperand(3).getImm();
if (Widthm1 >= 32 - LSB)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"bitfield width must be in range [1,32-lsb]");
return false;
}
@@ -7914,24 +7944,29 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
// in the register list.
unsigned Rn = Inst.getOperand(0).getReg();
bool HasWritebackToken =
- (static_cast<ARMOperand &>(*Operands[3]).isToken() &&
- static_cast<ARMOperand &>(*Operands[3]).getToken() == "!");
+ (static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isToken() &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .getToken() == "!");
+
+ unsigned RegStart =
+ HasWritebackToken ? MnemonicOpsEndInd + 2 : MnemonicOpsEndInd + 1;
bool ListContainsBase;
if (checkLowRegisterList(Inst, 3, Rn, 0, ListContainsBase) && !isThumbTwo())
- return Error(Operands[3 + HasWritebackToken]->getStartLoc(),
+ return Error(Operands[RegStart]->getStartLoc(),
"registers must be in range r0-r7");
// If we should have writeback, then there should be a '!' token.
if (!ListContainsBase && !HasWritebackToken && !isThumbTwo())
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[RegStart]->getStartLoc(),
"writeback operator '!' expected");
// If we should not have writeback, there must not be a '!'. This is
// true even for the 32-bit wide encodings.
if (ListContainsBase && HasWritebackToken)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"writeback operator '!' not allowed when base register "
"in register list");
- if (validatetLDMRegList(Inst, Operands, 3))
+ if (validatetLDMRegList(Inst, Operands, MnemonicOpsEndInd, 3))
return true;
break;
}
@@ -7949,12 +7984,12 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
break;
case ARM::t2LDMIA:
case ARM::t2LDMDB:
- if (validatetLDMRegList(Inst, Operands, 3))
+ if (validatetLDMRegList(Inst, Operands, MnemonicOpsEndInd, 3))
return true;
break;
case ARM::t2STMIA:
case ARM::t2STMDB:
- if (validatetSTMRegList(Inst, Operands, 3))
+ if (validatetSTMRegList(Inst, Operands, MnemonicOpsEndInd, 3))
return true;
break;
case ARM::t2LDMIA_UPD:
@@ -7966,10 +8001,10 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
"writeback register not allowed in register list");
if (Opcode == ARM::t2LDMIA_UPD || Opcode == ARM::t2LDMDB_UPD) {
- if (validatetLDMRegList(Inst, Operands, 3))
+ if (validatetLDMRegList(Inst, Operands, MnemonicOpsEndInd, 3))
return true;
} else {
- if (validatetSTMRegList(Inst, Operands, 3))
+ if (validatetSTMRegList(Inst, Operands, MnemonicOpsEndInd, 3))
return true;
}
break;
@@ -7979,7 +8014,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::sysLDMDB_UPD:
case ARM::sysLDMIB_UPD:
if (!listContainsReg(Inst, 3, ARM::PC))
- return Error(Operands[4]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
"writeback register only allowed on system LDM "
"if PC in register-list");
break;
@@ -7987,7 +8022,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::sysSTMDA_UPD:
case ARM::sysSTMDB_UPD:
case ARM::sysSTMIB_UPD:
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"system STM cannot have writeback register");
case ARM::tMUL:
// The second source operand must be the same register as the destination
@@ -7998,11 +8033,12 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
// this first statement is always true for the new Inst. Essentially, the
// destination is unconditionally copied into the second source operand
// without checking to see if it matches what we actually parsed.
- if (Operands.size() == 6 && (((ARMOperand &)*Operands[3]).getReg() !=
- ((ARMOperand &)*Operands[5]).getReg()) &&
- (((ARMOperand &)*Operands[3]).getReg() !=
- ((ARMOperand &)*Operands[4]).getReg())) {
- return Error(Operands[3]->getStartLoc(),
+ if (Operands.size() == MnemonicOpsEndInd + 3 &&
+ (((ARMOperand &)*Operands[MnemonicOpsEndInd]).getReg() !=
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 2]).getReg()) &&
+ (((ARMOperand &)*Operands[MnemonicOpsEndInd]).getReg() !=
+ ((ARMOperand &)*Operands[MnemonicOpsEndInd + 1]).getReg())) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination register must match source register");
}
break;
@@ -8014,9 +8050,9 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
bool ListContainsBase;
if (checkLowRegisterList(Inst, 2, 0, ARM::PC, ListContainsBase) &&
!isThumbTwo())
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"registers must be in range r0-r7 or pc");
- if (validatetLDMRegList(Inst, Operands, 2, !isMClass()))
+ if (validatetLDMRegList(Inst, Operands, MnemonicOpsEndInd, 2, !isMClass()))
return true;
break;
}
@@ -8024,9 +8060,9 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
bool ListContainsBase;
if (checkLowRegisterList(Inst, 2, 0, ARM::LR, ListContainsBase) &&
!isThumbTwo())
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"registers must be in range r0-r7 or lr");
- if (validatetSTMRegList(Inst, Operands, 2))
+ if (validatetSTMRegList(Inst, Operands, MnemonicOpsEndInd, 2))
return true;
break;
}
@@ -8035,17 +8071,17 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
InvalidLowList = checkLowRegisterList(Inst, 4, Inst.getOperand(0).getReg(),
0, ListContainsBase);
if (InvalidLowList && !isThumbTwo())
- return Error(Operands[4]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"registers must be in range r0-r7");
// This would be converted to a 32-bit stm, but that's not valid if the
// writeback register is in the list.
if (InvalidLowList && ListContainsBase)
- return Error(Operands[4]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"writeback operator '!' not allowed when base register "
"in register list");
- if (validatetSTMRegList(Inst, Operands, 4))
+ if (validatetSTMRegList(Inst, Operands, MnemonicOpsEndInd, 4))
return true;
break;
}
@@ -8054,7 +8090,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
// same, we need thumb2 (for the wide encoding), or we have an error.
if (!isThumbTwo() &&
Inst.getOperand(0).getReg() != Inst.getOperand(2).getReg()) {
- return Error(Operands[4]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"source register must be the same as destination");
}
break;
@@ -8065,17 +8101,20 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::t2SUBrs:
if (Inst.getOperand(0).getReg() == ARM::SP &&
Inst.getOperand(1).getReg() != ARM::SP)
- return Error(Operands[4]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
"source register must be sp if destination is sp");
break;
// Final range checking for Thumb unconditional branch instructions.
case ARM::tB:
- if (!(static_cast<ARMOperand &>(*Operands[2])).isSignedOffset<11, 1>())
- return Error(Operands[2]->getStartLoc(), "branch target out of range");
+ if (!(static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd]))
+ .isSignedOffset<11, 1>())
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "branch target out of range");
break;
case ARM::t2B: {
- int op = (Operands[2]->isImm()) ? 2 : 3;
+ int op = (Operands[MnemonicOpsEndInd]->isImm()) ? MnemonicOpsEndInd
+ : MnemonicOpsEndInd + 1;
ARMOperand &Operand = static_cast<ARMOperand &>(*Operands[op]);
// Delay the checks of symbolic expressions until they are resolved.
if (!isa<MCBinaryExpr>(Operand.getImm()) &&
@@ -8085,19 +8124,24 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
}
// Final range checking for Thumb conditional branch instructions.
case ARM::tBcc:
- if (!static_cast<ARMOperand &>(*Operands[2]).isSignedOffset<8, 1>())
- return Error(Operands[2]->getStartLoc(), "branch target out of range");
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd])
+ .isSignedOffset<8, 1>())
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "branch target out of range");
break;
case ARM::t2Bcc: {
- int Op = (Operands[2]->isImm()) ? 2 : 3;
+ int Op = (Operands[MnemonicOpsEndInd]->isImm()) ? MnemonicOpsEndInd
+ : MnemonicOpsEndInd + 1;
if (!static_cast<ARMOperand &>(*Operands[Op]).isSignedOffset<20, 1>())
return Error(Operands[Op]->getStartLoc(), "branch target out of range");
break;
}
case ARM::tCBZ:
case ARM::tCBNZ: {
- if (!static_cast<ARMOperand &>(*Operands[2]).isUnsignedOffset<6, 1>())
- return Error(Operands[2]->getStartLoc(), "branch target out of range");
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isUnsignedOffset<6, 1>())
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
+ "branch target out of range");
break;
}
case ARM::MOVi16:
@@ -8111,7 +8155,8 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
// want the behavior of silently truncating, which can be unexpected and
// lead to bugs that are difficult to find since this is an easy mistake
// to make.
- int i = (Operands[3]->isImm()) ? 3 : 4;
+ int i = (Operands[MnemonicOpsEndInd]->isImm()) ? MnemonicOpsEndInd
+ : MnemonicOpsEndInd + 1;
ARMOperand &Op = static_cast<ARMOperand &>(*Operands[i]);
const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op.getImm());
if (CE) break;
@@ -8126,7 +8171,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
break;
}
case ARM::tADDi8: {
- MCParsedAsmOperand &Op = *Operands[4];
+ MCParsedAsmOperand &Op = *Operands[MnemonicOpsEndInd + 1];
if (isARMMCExpr(Op) && !isThumbI8Relocation(Op))
return Error(Op.getStartLoc(),
"Immediate expression for Thumb adds requires :lower0_7:,"
@@ -8134,7 +8179,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
break;
}
case ARM::tMOVi8: {
- MCParsedAsmOperand &Op = *Operands[2];
+ MCParsedAsmOperand &Op = *Operands[MnemonicOpsEndInd];
if (isARMMCExpr(Op) && !isThumbI8Relocation(Op))
return Error(Op.getStartLoc(),
"Immediate expression for Thumb movs requires :lower0_7:,"
@@ -8161,30 +8206,36 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::t2BFr:
case ARM::t2BFLi:
case ARM::t2BFLr: {
- if (!static_cast<ARMOperand &>(*Operands[2]).isUnsignedOffset<4, 1>() ||
- (Inst.getOperand(0).isImm() && Inst.getOperand(0).getImm() == 0))
- return Error(Operands[2]->getStartLoc(),
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd])
+ .isUnsignedOffset<4, 1>() ||
+ (Inst.getOperand(0).isImm() && Inst.getOperand(0).getImm() == 0)) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"branch location out of range or not a multiple of 2");
+ }
if (Opcode == ARM::t2BFi) {
- if (!static_cast<ARMOperand &>(*Operands[3]).isSignedOffset<16, 1>())
- return Error(Operands[3]->getStartLoc(),
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isSignedOffset<16, 1>())
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"branch target out of range or not a multiple of 2");
} else if (Opcode == ARM::t2BFLi) {
- if (!static_cast<ARMOperand &>(*Operands[3]).isSignedOffset<18, 1>())
- return Error(Operands[3]->getStartLoc(),
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isSignedOffset<18, 1>())
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"branch target out of range or not a multiple of 2");
}
break;
}
case ARM::t2BFic: {
- if (!static_cast<ARMOperand &>(*Operands[1]).isUnsignedOffset<4, 1>() ||
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd])
+ .isUnsignedOffset<4, 1>() ||
(Inst.getOperand(0).isImm() && Inst.getOperand(0).getImm() == 0))
return Error(Operands[1]->getStartLoc(),
"branch location out of range or not a multiple of 2");
- if (!static_cast<ARMOperand &>(*Operands[2]).isSignedOffset<16, 1>())
- return Error(Operands[2]->getStartLoc(),
+ if (!static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isSignedOffset<16, 1>())
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
"branch target out of range or not a multiple of 2");
assert(Inst.getOperand(0).isImm() == Inst.getOperand(2).isImm() &&
@@ -8205,7 +8256,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
if (Inst.getOperand(i).isReg() &&
!ARMMCRegisterClasses[ARM::GPRwithAPSRnospRegClassID].contains(
Inst.getOperand(i).getReg())) {
- return Error(Operands[2]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"invalid register in register list. Valid registers are "
"r0-r12, lr/r14 and APSR.");
}
@@ -8237,7 +8288,7 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Sm = MRI->getEncodingValue(Inst.getOperand(2).getReg());
const unsigned Sm1 = MRI->getEncodingValue(Inst.getOperand(3).getReg());
if (Sm1 != Sm + 1)
- return Error(Operands[5]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
"source operands must be sequential");
break;
}
@@ -8246,16 +8297,17 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
const unsigned Sm = MRI->getEncodingValue(Inst.getOperand(0).getReg());
const unsigned Sm1 = MRI->getEncodingValue(Inst.getOperand(1).getReg());
if (Sm1 != Sm + 1)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"destination operands must be sequential");
break;
}
case ARM::VLDMDIA:
case ARM::VSTMDIA: {
- ARMOperand &Op = static_cast<ARMOperand&>(*Operands[3]);
+ ARMOperand &Op =
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]);
auto &RegList = Op.getRegList();
if (RegList.size() < 1 || RegList.size() > 16)
- return Error(Operands[3]->getStartLoc(),
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
"list of registers must be at least 1 and at most 16");
break;
}
@@ -8266,13 +8318,15 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::MVE_VMULLTs32:
case ARM::MVE_VMULLBu32:
case ARM::MVE_VMULLTu32: {
- if (Operands[3]->getReg() == Operands[4]->getReg()) {
- return Error (Operands[3]->getStartLoc(),
- "Qd register and Qn register can't be identical");
+ if (Operands[MnemonicOpsEndInd]->getReg() ==
+ Operands[MnemonicOpsEndInd + 1]->getReg()) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Qd register and Qn register can't be identical");
}
- if (Operands[3]->getReg() == Operands[5]->getReg()) {
- return Error (Operands[3]->getStartLoc(),
- "Qd register and Qm register can't be identical");
+ if (Operands[MnemonicOpsEndInd]->getReg() ==
+ Operands[MnemonicOpsEndInd + 2]->getReg()) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Qd register and Qm register can't be identical");
}
break;
}
@@ -8281,41 +8335,56 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::MVE_VREV64_32:
case ARM::MVE_VQDMULL_qr_s32bh:
case ARM::MVE_VQDMULL_qr_s32th: {
- if (Operands[3]->getReg() == Operands[4]->getReg()) {
- return Error (Operands[3]->getStartLoc(),
- "Qd register and Qn register can't be identical");
+ if (Operands[MnemonicOpsEndInd]->getReg() ==
+ Operands[MnemonicOpsEndInd + 1]->getReg()) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Qd register and Qn register can't be identical");
}
break;
}
case ARM::MVE_VCADDi32:
case ARM::MVE_VCADDf32:
case ARM::MVE_VHCADDs32: {
- if (Operands[3]->getReg() == Operands[5]->getReg()) {
- return Error (Operands[3]->getStartLoc(),
- "Qd register and Qm register can't be identical");
+ if (Operands[MnemonicOpsEndInd]->getReg() ==
+ Operands[MnemonicOpsEndInd + 2]->getReg()) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Qd register and Qm register can't be identical");
}
break;
}
case ARM::MVE_VMOV_rr_q: {
- if (Operands[4]->getReg() != Operands[6]->getReg())
- return Error (Operands[4]->getStartLoc(), "Q-registers must be the same");
- if (static_cast<ARMOperand &>(*Operands[5]).getVectorIndex() !=
- static_cast<ARMOperand &>(*Operands[7]).getVectorIndex() + 2)
- return Error (Operands[5]->getStartLoc(), "Q-register indexes must be 2 and 0 or 3 and 1");
+ if (Operands[MnemonicOpsEndInd + 2]->getReg() !=
+ Operands[MnemonicOpsEndInd + 4]->getReg())
+ return Error(Operands[MnemonicOpsEndInd + 2]->getStartLoc(),
+ "Q-registers must be the same");
+ if (static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 3])
+ .getVectorIndex() !=
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 5])
+ .getVectorIndex() +
+ 2)
+ return Error(Operands[MnemonicOpsEndInd + 3]->getStartLoc(),
+ "Q-register indexes must be 2 and 0 or 3 and 1");
break;
}
case ARM::MVE_VMOV_q_rr: {
- if (Operands[2]->getReg() != Operands[4]->getReg())
- return Error (Operands[2]->getStartLoc(), "Q-registers must be the same");
- if (static_cast<ARMOperand &>(*Operands[3]).getVectorIndex() !=
- static_cast<ARMOperand &>(*Operands[5]).getVectorIndex() + 2)
- return Error (Operands[3]->getStartLoc(), "Q-register indexes must be 2 and 0 or 3 and 1");
+ if (Operands[MnemonicOpsEndInd]->getReg() !=
+ Operands[MnemonicOpsEndInd + 2]->getReg())
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
+ "Q-registers must be the same");
+ if (static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .getVectorIndex() !=
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 3])
+ .getVectorIndex() +
+ 2)
+ return Error(Operands[MnemonicOpsEndInd + 1]->getStartLoc(),
+ "Q-register indexes must be 2 and 0 or 3 and 1");
break;
}
case ARM::MVE_SQRSHR:
case ARM::MVE_UQRSHL: {
- if (Operands[2]->getReg() == Operands[3]->getReg()) {
- return Error(Operands[2]->getStartLoc(),
+ if (Operands[MnemonicOpsEndInd]->getReg() ==
+ Operands[MnemonicOpsEndInd + 1]->getReg()) {
+ return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"Rda register and Rm register can't be identical");
}
break;
@@ -8719,6 +8788,7 @@ static unsigned getRealVLDOpcode(unsigned Opc, unsigned &Spacing) {
bool ARMAsmParser::processInstruction(MCInst &Inst,
const OperandVector &Operands,
+ unsigned MnemonicOpsEndInd,
MCStreamer &Out) {
// Check if we have the wide qualifier, because if it's present we
// must avoid selecting a 16-bit thumb instruction.
@@ -9039,9 +9109,7 @@ bool ARMAsmParser::processInstruction(MCInst &Inst,
else if (Inst.getOpcode() == ARM::t2LDRConstPool)
TmpInst.setOpcode(ARM::t2LDRpci);
const ARMOperand &PoolOperand =
- (HasWideQualifier ?
- static_cast<ARMOperand &>(*Operands[4]) :
- static_cast<ARMOperand &>(*Operands[3]));
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1]);
const MCExpr *SubExprVal = PoolOperand.getConstantPoolImm();
// If SubExprVal is a constant we may be able to use a MOV
if (isa<MCConstantExpr>(SubExprVal) &&
@@ -10468,7 +10536,8 @@ bool ARMAsmParser::processInstruction(MCInst &Inst,
// to encoding T2 if <Rd> is specified and encoding T2 is preferred
// to encoding T1 if <Rd> is omitted."
if (Inst.getOperand(3).isImm() &&
- (unsigned)Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) {
+ (unsigned)Inst.getOperand(3).getImm() < 8 &&
+ Operands.size() == MnemonicOpsEndInd + 3) {
Inst.setOpcode(ARM::tADDi3);
return true;
}
@@ -10478,7 +10547,8 @@ bool ARMAsmParser::processInstruction(MCInst &Inst,
// explicitly specified. From the ARM ARM: "Encoding T1 is preferred
// to encoding T2 if <Rd> is specified and encoding T2 is preferred
// to encoding T1 if <Rd> is omitted."
- if ((unsigned)Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) {
+ if ((unsigned)Inst.getOperand(3).getImm() < 8 &&
+ Operands.size() == MnemonicOpsEndInd + 3) {
Inst.setOpcode(ARM::tSUBi3);
return true;
}
@@ -10598,8 +10668,10 @@ bool ARMAsmParser::processInstruction(MCInst &Inst,
// an error in validateInstruction().
unsigned Rn = Inst.getOperand(0).getReg();
bool hasWritebackToken =
- (static_cast<ARMOperand &>(*Operands[3]).isToken() &&
- static_cast<ARMOperand &>(*Operands[3]).getToken() == "!");
+ (static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .isToken() &&
+ static_cast<ARMOperand &>(*Operands[MnemonicOpsEndInd + 1])
+ .getToken() == "!");
bool listContainsBase;
if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) ||
(!listContainsBase && !hasWritebackToken) ||
@@ -10898,6 +10970,26 @@ bool ARMAsmParser::processInstruction(MCInst &Inst,
return false;
}
+unsigned
+ARMAsmParser::checkEarlyTargetMatchPredicate(MCInst &Inst,
+ const OperandVector &Operands) {
+ unsigned Opc = Inst.getOpcode();
+ switch (Opc) {
+ // Prevent the mov r8 r8 encoding for nop being selected when the v6/thumb 2
+ // encoding is available
+ case ARM::tMOVr: {
+ if (Operands[0]->isToken() &&
+ static_cast<ARMOperand &>(*Operands[0]).getToken() == "nop" &&
+ ((isThumb() && !isThumbOne()) || hasV6MOps())) {
+ return Match_MnemonicFail;
+ }
+ }
+ LLVM_FALLTHROUGH;
+ default:
+ return Match_Success;
+ }
+}
+
unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
// 16-bit thumb arithmetic instructions either require or preclude the 'S'
// suffix depending on whether they're in an IT block or not.
@@ -10908,22 +11000,23 @@ unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
"optionally flag setting instruction missing optional def operand");
assert(MCID.NumOperands == Inst.getNumOperands() &&
"operand count mismatch!");
- // Find the optional-def operand (cc_out).
- unsigned OpNo;
- for (OpNo = 0;
- OpNo < MCID.NumOperands && !MCID.operands()[OpNo].isOptionalDef();
- ++OpNo)
- ;
+ bool IsCPSR = false;
+ // Check if the instruction has CPSR set.
+ for (unsigned OpNo = 0; OpNo < MCID.NumOperands; ++OpNo) {
+ if (MCID.operands()[OpNo].isOptionalDef() &&
+ Inst.getOperand(OpNo).isReg() &&
+ Inst.getOperand(OpNo).getReg() == ARM::CPSR)
+ IsCPSR = true;
+ }
+
// If we're parsing Thumb1, reject it completely.
- if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR)
+ if (isThumbOne() && !IsCPSR)
return Match_RequiresFlagSetting;
// If we're parsing Thumb2, which form is legal depends on whether we're
// in an IT block.
- if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR &&
- !inITBlock())
+ if (isThumbTwo() && !IsCPSR && !inITBlock())
return Match_RequiresITBlock;
- if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR &&
- inITBlock())
+ if (isThumbTwo() && IsCPSR && inITBlock())
return Match_RequiresNotITBlock;
// LSL with zero immediate is not allowed in an IT block
if (Opc == ARM::tLSLri && Inst.getOperand(3).getImm() == 0 && inITBlock())
@@ -10984,6 +11077,12 @@ unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
if (!hasV8Ops() && (Inst.getOperand(0).getReg() == ARM::SP))
return Match_RequiresV8;
break;
+ case ARM::tMUL:
+ // The second source operand must be the same register as the destination
+ // operand.
+ if (Inst.getOperand(0).getReg() != Inst.getOperand(3).getReg())
+ return Match_RequiresDestinationRegisterMatchASourceRegister;
+ break;
default:
break;
}
@@ -11142,6 +11241,9 @@ bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
MatchResult = MatchInstruction(Operands, Inst, NearMisses, MatchingInlineAsm,
PendConditionalInstruction, Out);
+ // Find the number of operators that are part of the Mnumonic (LHS)
+ unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
+
switch (MatchResult) {
case Match_Success:
LLVM_DEBUG(dbgs() << "Parsed as: ";
@@ -11150,7 +11252,7 @@ bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
// Context sensitive operand constraints aren't handled by the matcher,
// so check them here.
- if (validateInstruction(Inst, Operands)) {
+ if (validateInstruction(Inst, Operands, MnemonicOpsEndInd)) {
// Still progress the IT block, otherwise one wrong condition causes
// nasty cascading errors.
forwardITPosition();
@@ -11163,7 +11265,7 @@ bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
// encoding is selected. Loop on it while changes happen so the
// individual transformations can chain off each other. E.g.,
// tPOP(r8)->t2LDMIA_UPD(sp,r8)->t2STR_POST(sp,r8)
- while (processInstruction(Inst, Operands, Out))
+ while (processInstruction(Inst, Operands, MnemonicOpsEndInd, Out))
LLVM_DEBUG(dbgs() << "Changed to: ";
Inst.dump_pretty(dbgs(), MII.getName(Inst.getOpcode()));
dbgs() << "\n");
@@ -12612,6 +12714,9 @@ ARMAsmParser::FilterNearMisses(SmallVectorImpl<NearMissInfo> &NearMissesIn,
case Match_RequiresFlagSetting:
Message.Message = "no flag-preserving variant of this instruction available";
break;
+ case Match_RequiresDestinationRegisterMatchASourceRegister:
+ Message.Message = "destination register must match a source register";
+ break;
case Match_InvalidOperand:
Message.Message = "invalid operand for instruction";
break;
@@ -12863,3 +12968,11 @@ bool ARMAsmParser::isMnemonicVPTPredicable(StringRef Mnemonic,
std::begin(predicable_prefixes), std::end(predicable_prefixes),
[&Mnemonic](const char *prefix) { return Mnemonic.starts_with(prefix); });
}
+
+std::unique_ptr<ARMOperand> ARMAsmParser::defaultCondCodeOp() {
+ return ARMOperand::CreateCondCode(ARMCC::AL, SMLoc());
+}
+
+std::unique_ptr<ARMOperand> ARMAsmParser::defaultCCOutOp() {
+ return ARMOperand::CreateCCOut(0, SMLoc());
+}
diff --git a/llvm/test/MC/ARM/arm-branch-errors.s b/llvm/test/MC/ARM/arm-branch-errors.s
index bbf6445f5c18a4..5d7ae12fb3bc00 100644
--- a/llvm/test/MC/ARM/arm-branch-errors.s
+++ b/llvm/test/MC/ARM/arm-branch-errors.s
@@ -10,13 +10,13 @@
@ CHECK: error: invalid instruction, any one of the following would fix this:
@ CHECK: b #2
-@ CHECK: note: instruction requires: thumb
@ CHECK: note: invalid operand for instruction
+@ CHECK: note: instruction requires: thumb
@ CHECK: error: invalid instruction, any one of the following would fix this:
@ CHECK: bl #2
@ CHECK: note: instruction requires: thumb
@ CHECK: note: invalid operand for instruction
@ CHECK: error: invalid instruction, any one of the following would fix this:
@ CHECK: beq #2
-@ CHECK: note: instruction requires: thumb
@ CHECK: note: invalid operand for instruction
+@ CHECK: note: instruction requires: thumb
diff --git a/llvm/test/MC/ARM/arm-reg-addr-errors.s b/llvm/test/MC/ARM/arm-reg-addr-errors.s
index 069baead38b499..47188932b1fff4 100644
--- a/llvm/test/MC/ARM/arm-reg-addr-errors.s
+++ b/llvm/test/MC/ARM/arm-reg-addr-errors.s
@@ -27,21 +27,21 @@ ldr r4, [r3], q12
ldr r4, [r3], cpsr
@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
add r3, r0, s1, lsl #2
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, d1, lsl #2
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, q1, lsl #2
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, cpsr, lsl #2
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, r1, lsl s6
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, r1, lsl d6
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, r1, lsl q6
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
add r3, r0, r1, lsl cpsr
-@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
+@ CHECK: [[@LINE-1]]{{.*}} too many operands for instruction
ldrd r2, r3, [s4]
@ CHECK: [[@LINE-1]]{{.*}} invalid operand for instruction
ldrd r2, r3, [r4, s5]
diff --git a/llvm/test/MC/ARM/arm11-hint-instr.s b/llvm/test/MC/ARM/arm11-hint-instr.s
index 4193a686870aba..d9eaa5a89ab230 100644
--- a/llvm/test/MC/ARM/arm11-hint-instr.s
+++ b/llvm/test/MC/ARM/arm11-hint-instr.s
@@ -65,7 +65,13 @@
@ CHECK-THUMB: wfe @ encoding: [0x20,0xbf]
@ CHECK-THUMB: wfi @ encoding: [0x30,0xbf]
@ CHECK-THUMB: sev @ encoding: [0x40,0xbf]
-@ CHECK-ERROR-THUMB: error: instruction requires: v7 clrex
+@ CHECK-ERROR-THUMB: error: invalid instruction, any one of the following would fix this:
+@ CHECK-ERROR-THUMB: clrex
+@ CHECK-ERROR-THUMB: ^
+@ CHECK-ERROR-THUMB: note: instruction requires: v7 clrex
+@ CHECK-ERROR-THUMB: clrex
+@ CHECK-ERROR-THUMB: ^
+@ CHECK-ERROR-THUMB: note: instruction requires: arm-mode
@ CHECK-ERROR-THUMB: clrex
@ CHECK-ERROR-THUMB: ^
diff --git a/llvm/test/MC/ARM/cps.s b/llvm/test/MC/ARM/cps.s
index bafdfdea537b8b..1034ed93810dd4 100644
--- a/llvm/test/MC/ARM/cps.s
+++ b/llvm/test/MC/ARM/cps.s
@@ -26,6 +26,6 @@
@ V6-ERRORS: note: too many operands for instruction
@ V6-ERRORS: error: invalid instruction, any one of the following would fix this:
@ V6-ERRORS: cps #0
-@ V6-ERRORS: note: too few operands for instruction
@ V6-ERRORS: note: instruction requires: arm-mode
@ V6-ERRORS: note: instruction requires: thumb2
+@ V6-ERRORS: note: too few operands for instruction
diff --git a/llvm/test/MC/ARM/d16.s b/llvm/test/MC/ARM/d16.s
index 67b5095a13282c..755c9a8a312894 100644
--- a/llvm/test/MC/ARM/d16.s
+++ b/llvm/test/MC/ARM/d16.s
@@ -5,8 +5,8 @@
@ D16: error: invalid instruction, any one of the following would fix this:
@ D16-NEXT: vadd.f64 d1, d2, d16
-@ D16: note: operand must be a register in range [d0, d15]
@ D16: note: too many operands for instruction
+@ D16: note: operand must be a register in range [d0, d15]
vadd.f64 d1, d2, d16
@ D16: error: operand must be a register in range [d0, d15]
diff --git a/llvm/test/MC/ARM/directive-arch_extension-crypto.s b/llvm/test/MC/ARM/directive-arch_extension-crypto.s
index 8d3cd9e5e1d0da..05b6d9e040188e 100644
--- a/llvm/test/MC/ARM/directive-arch_extension-crypto.s
+++ b/llvm/test/MC/ARM/directive-arch_extension-crypto.s
@@ -10,15 +10,16 @@
.syntax unified
.arch_extension crypto
-@ CHECK-V7: error: architectural extension 'crypto' is not allowed for the current base architecture
+@ CHECK-V7: architectural extension 'crypto' is not allowed for the current base architecture
@ CHECK-V7-NEXT: .arch_extension crypto
@ CHECK-V7-NEXT: ^
.type crypto,%function
crypto:
vmull.p64 q0, d0, d1
-@ CHECK-V7: error: instruction requires: aes armv8
-
+@ CHECK-V7: error: invalid instruction, any one of the following would fix this:
+@ CHECK-V7: note: invalid operand for instruction
+@ CHECK-V7: note: instruction requires: aes armv8
aesd.8 q0, q1
@ CHECK-V7: error: instruction requires: aes armv8
aese.8 q0, q1
@@ -51,14 +52,18 @@ crypto:
@ CHECK-V7: error: instruction requires: sha2 armv8
.arch_extension nocrypto
+@ CHECK-V7: error: architectural extension 'sha2' is not allowed for the current base architecture
+@ CHECK-V7: error: architectural extension 'aes' is not allowed for the current base architecture
@ CHECK-V7: error: architectural extension 'crypto' is not allowed for the current base architecture
-@ CHECK-V7-NEXT: .arch_extension nocrypto
+@ CHECK-V7-NEXT: .arch_extension nocrypto
@ CHECK-V7-NEXT: ^
.type nocrypto,%function
nocrypto:
vmull.p64 q0, d0, d1
-@ CHECK-V7: error: instruction requires: aes armv8
+@ CHECK-V7: error: invalid instruction, any one of the following
+@ CHECK-V7: note: invalid operand for instruction
+@ CHECK-V7: note: instruction requires: aes armv8
@ CHECK-V8: error: instruction requires: aes
aesd.8 q0, q1
diff --git a/llvm/test/MC/ARM/lsl-zero-errors.s b/llvm/test/MC/ARM/lsl-zero-errors.s
index e021aa9eb986d5..1e51c587211d1b 100644
--- a/llvm/test/MC/ARM/lsl-zero-errors.s
+++ b/llvm/test/MC/ARM/lsl-zero-errors.s
@@ -55,22 +55,22 @@
// CHECK-NONARM: error: invalid instruction, any one of the following would fix this:
// CHECK-NONARM-NEXT: mov pc, r0, lsl #0
-// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-THUMBV7: note: operand must be a register in range [r0, r12] or r14
// CHECK-THUMBV8: note: operand must be a register in range [r0, r14]
+// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-NONARM: error: invalid instruction, any one of the following would fix this:
// CHECK-NONARM-NEXT: mov r0, pc, lsl #0
-// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-NONARM: note: invalid operand for instruction
// CHECK-NONARM: note: invalid operand for instruction
// CHECK-NONARM: note: operand must be an immediate in the range [256,65535]
+// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-NONARM: error: invalid instruction, any one of the following would fix this:
// CHECK-NONARM-NEXT: mov pc, pc, lsl #0
-// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-THUMBV7: note: operand must be a register in range [r0, r12] or r14
// CHECK-THUMBV8: note: operand must be a register in range [r0, r14]
+// CHECK-NONARM: note: operand must be a register in range [r0, r15]
// CHECK-NONARM: error: invalid instruction, any one of the following would fix this:
// CHECK-NONARM-NEXT: movs pc, r0, lsl #0
@@ -134,8 +134,8 @@
// FIXME: We should consistently have the "requires ARMv8" error here
// CHECK-THUMBV7: error: invalid instruction, any one of the following would fix this:
// CHECK-THUMBV7-NEXT: mov sp, sp, lsl #0
-// CHECK-THUMBV7: note: operand must be a register in range [r0, r15]
// CHECK-THUMBV7: note: operand must be a register in range [r0, r12] or r14
+// CHECK-THUMBV7: note: operand must be a register in range [r0, r15]
// CHECK-THUMBV7: error: invalid instruction, any one of the following would fix this:
// CHECK-THUMBV7-NEXT: movs sp, sp, lsl #0
diff --git a/llvm/test/MC/ARM/mve-misc.s b/llvm/test/MC/ARM/mve-misc.s
index f3af9e0afe64fb..7f9a2c56c2d82b 100644
--- a/llvm/test/MC/ARM/mve-misc.s
+++ b/llvm/test/MC/ARM/mve-misc.s
@@ -15,55 +15,55 @@ vpsel q0, q5, q2
vpnot
# CHECK: wlstp.8 lr, r0, #1668 @ encoding: [0x00,0xf0,0x43,0xc3]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r0, #1668
# CHECK: wlstp.16 lr, r0, #1668 @ encoding: [0x10,0xf0,0x43,0xc3]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.16 lr, r0, #1668
# CHECK: wlstp.32 lr, r4, #2706 @ encoding: [0x24,0xf0,0x49,0xcd]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.32 lr, r4, #2706
# CHECK: wlstp.64 lr, lr, #3026 @ encoding: [0x3e,0xf0,0xe9,0xcd]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.64 lr, lr, #3026
# CHECK: wlstp.8 lr, r5, #3436 @ encoding: [0x05,0xf0,0xb7,0xc6]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r5, #3436
# CHECK: wlstp.16 lr, r1, #1060 @ encoding: [0x11,0xf0,0x13,0xc2]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.16 lr, r1, #1060
# CHECK: wlstp.32 lr, r7, #4036 @ encoding: [0x27,0xf0,0xe3,0xc7]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.32 lr, r7, #4036
# CHECK: wlstp.8 lr, r1, #538 @ encoding: [0x01,0xf0,0x0d,0xc9]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r1, #538
# CHECK: wlstp.8 lr, r10, #1404 @ encoding: [0x0a,0xf0,0xbf,0xc2]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r10, #1404
# CHECK: wlstp.8 lr, r10, #1408 @ encoding: [0x0a,0xf0,0xc1,0xc2]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r10, #1408
# CHECK: wlstp.8 lr, r10, #2358 @ encoding: [0x0a,0xf0,0x9b,0xcc]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r10, #2358
# CHECK: wlstp.8 lr, r10, #4086 @ encoding: [0x0a,0xf0,0xfb,0xcf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r10, #4086
# CHECK: wlstp.8 lr, r11, #1442 @ encoding: [0x0b,0xf0,0xd1,0xca]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r11, #1442
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: loop end is out of range or not a positive multiple of 2
@@ -87,39 +87,39 @@ wlstp.16 lr, sp, #1442
wlstp.32 r10, r11, #1442
# CHECK: wlstp.8 lr, r1, .Lendloop @ encoding: [0x01'A',0xf0'A',0x01'A',0xc0'A']
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.8 lr, r1, .Lendloop
# CHECK: wlstp.16 lr, r2, .Lendloop @ encoding: [0x12'A',0xf0'A',0x01'A',0xc0'A']
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.16 lr, r2, .Lendloop
# CHECK: wlstp.32 lr, r3, .Lendloop @ encoding: [0x23'A',0xf0'A',0x01'A',0xc0'A']
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.32 lr, r3, .Lendloop
# CHECK: wlstp.64 lr, r5, .Lendloop @ encoding: [0x35'A',0xf0'A',0x01'A',0xc0'A']
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.64 lr, r5, .Lendloop
# CHECK: wlstp.64 lr, r5, #0 @ encoding: [0x35,0xf0,0x01,0xc0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
wlstp.64 lr, r5, #0
# CHECK: dlstp.8 lr, r5 @ encoding: [0x05,0xf0,0x01,0xe0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
dlstp.8 lr, r5
# CHECK: dlstp.16 lr, r5 @ encoding: [0x15,0xf0,0x01,0xe0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
dlstp.16 lr, r5
# CHECK: dlstp.32 lr, r7 @ encoding: [0x27,0xf0,0x01,0xe0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
dlstp.32 lr, r7
# CHECK: dlstp.64 lr, r2 @ encoding: [0x32,0xf0,0x01,0xe0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
dlstp.64 lr, r2
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: operand must be a register in range [r0, r12] or r14
@@ -135,15 +135,15 @@ dlstp.64 r10, r0
dlstp.64 lr, pc
# CHECK: letp lr, #-2 @ encoding: [0x1f,0xf0,0x01,0xc8]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
letp lr, #-2
# CHECK: letp lr, #-8 @ encoding: [0x1f,0xf0,0x05,0xc0]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
letp lr, #-8
# CHECK: letp lr, #-4094 @ encoding: [0x1f,0xf0,0xff,0xcf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
letp lr, #-4094
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: invalid operand for instruction
@@ -159,7 +159,7 @@ letp lr, #8
letp lr, #-4096
# CHECK: letp lr, .Lstartloop @ encoding: [0x1f'A',0xf0'A',0x01'A',0xc0'A']
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
letp lr, .Lstartloop
# CHECK: lctp @ encoding: [0x0f,0xf0,0x01,0xe0]
@@ -172,8 +172,11 @@ it eq
# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
lctpeq
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vpste
+# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
vpselt.s16 q0, q1, q2
+# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
vpsele.i32 q0, q1, q2
# CHECK: vpste @ encoding: [0x71,0xfe,0x4d,0x8f]
# CHECK: vpselt q0, q1, q2 @ encoding: [0x33,0xfe,0x05,0x0f]
diff --git a/llvm/test/MC/ARM/negative-immediates-fail.s b/llvm/test/MC/ARM/negative-immediates-fail.s
index 9bc4c92b5ee665..4b352743d73e8a 100644
--- a/llvm/test/MC/ARM/negative-immediates-fail.s
+++ b/llvm/test/MC/ARM/negative-immediates-fail.s
@@ -4,25 +4,25 @@
ADC r0, r1, #0xFFFFFEEE
# CHECK: error: invalid instruction, any one of the following would fix this:
-# CHECK: note: invalid operand for instruction
+# CHECK: note: too many operands for instruction
# CHECK: note: operand must be a register in range [r0, r15]
ADC r0, r1, #0xABFEABFF
# CHECK: error: invalid instruction, any one of the following would fix this:
-# CHECK: note: invalid operand for instruction
+# CHECK: note: too many operands for instruction
# CHECK: note: operand must be a register in range [r0, r15]
ADC r0, r1, #0xFFFFFE02
# CHECK: error: invalid instruction, any one of the following would fix this:
-# CHECK: note: invalid operand for instruction
+# CHECK: note: too many operands for instruction
# CHECK: note: operand must be a register in range [r0, r15]
ADD.W r0, r0, #0xFF01FF01
# CHECK: error: invalid instruction, any one of the following would fix this:
-# CHECK: note: invalid operand for instruction
+# CHECK: note: too many operands for instruction
# CHECK: note: operand must be a register in range [r0, r15]
ORR r0, r1, #0xFFFFFF00
# CHECK: error: invalid instruction, any one of the following would fix this:
-# CHECK: note: invalid operand for instruction
+# CHECK: note: too many operands for instruction
# CHECK: note: operand must be a register in range [r0, r15]
# CHECK: note: instruction requires: thumb2
ORN r0, r1, #0xFFFFFF00
diff --git a/llvm/test/MC/ARM/not-armv4.s b/llvm/test/MC/ARM/not-armv4.s
index c62c50c26c31d5..b65b12976f78a8 100644
--- a/llvm/test/MC/ARM/not-armv4.s
+++ b/llvm/test/MC/ARM/not-armv4.s
@@ -1,13 +1,21 @@
@ RUN: not llvm-mc < %s -triple armv4-unknown-unknown -show-encoding 2>&1 | FileCheck %s
@ PR18524
-@ CHECK: instruction requires: armv5t
+@ CHECK: error: invalid instruction, any one of the following would fix this:
+@ CHECK: note: instruction requires: armv5t
+@ CHECK: note: instruction requires: thumb2
clz r4,r9
-@ CHECK: instruction requires: armv6t2
+@ CHECK: error: invalid instruction, any one of the following would fix this:
+@ CHECK: note: instruction requires: armv6t2
+@ CHECK: note: instruction requires: thumb2
rbit r4,r9
@ CHECK: error: instruction requires: armv6t2
movw r4,#0x1234
-@ CHECK: error: instruction requires: armv6t2
+
+@ CHECK: error: invalid instruction, any one of the following would fix this:
+@ CHECK: note: invalid operand for instruction
+@ CHECK: note: operand must be a register in range [r0, r15]
+@ CHECK: note: instruction requires: armv6t2
mov r4,#0x1234
diff --git a/llvm/test/MC/ARM/register-token-source-loc.s b/llvm/test/MC/ARM/register-token-source-loc.s
index afb6ba0c61a39e..7560f95999e71b 100644
--- a/llvm/test/MC/ARM/register-token-source-loc.s
+++ b/llvm/test/MC/ARM/register-token-source-loc.s
@@ -3,6 +3,9 @@
// CHECK: error: invalid instruction, any one of the following would fix this:
// CHECK-NEXT: add sp, r0, #4
// CHECK-NEXT: ^
+// CHECK-NEXT: note: operand must be a register in range [r0, r7]
+// CHECK-NEXT: add sp, r0, #4
+// CHECK-NEXT: ^
// CHECK-NEXT: note: operand must be a register sp
// CHECK-NEXT: add sp, r0, #4
// CHECK-NEXT: ^
diff --git a/llvm/test/MC/ARM/tMOVSr.s b/llvm/test/MC/ARM/tMOVSr.s
index 198c90aa5ceb46..09602fecd68513 100644
--- a/llvm/test/MC/ARM/tMOVSr.s
+++ b/llvm/test/MC/ARM/tMOVSr.s
@@ -1,6 +1,7 @@
@ REQUIRES: asserts
-@ RUN: llvm-mc --triple=thumbv8 --debug %s 2>&1 | FileCheck %s --match-full-lines
+@ RUN: llvm-mc --triple=thumbv8 %s --show-encoding 2>&1 | FileCheck %s --match-full-lines
-@ CHECK: Changed to: <MCInst #{{[0-9]+}} tMOVSr <MCOperand Reg:{{[0-9]+}}> <MCOperand Reg:{{[0-9]+}}>>
+// Note this makes sure the narrow instruciton is selected
+@ CHECK: movs r2, r3 @ encoding: [0x1a,0x00]
.text
movs r2, r3
diff --git a/llvm/test/MC/ARM/thumb-diagnostics.s b/llvm/test/MC/ARM/thumb-diagnostics.s
index cacd7f21cb9d36..171d60ac13f9a8 100644
--- a/llvm/test/MC/ARM/thumb-diagnostics.s
+++ b/llvm/test/MC/ARM/thumb-diagnostics.s
@@ -28,9 +28,12 @@
@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: instruction variant requires Thumb2
@ CHECK-ERRORS: note: operand must be a register sp
-@ CHECK-ERRORS-V5: error: instruction variant requires ARMv6 or later
+@ CHECK-ERRORS-V5: error: invalid instruction, any one of the following would fix this:
@ CHECK-ERRORS-V5: mov r2, r3
@ CHECK-ERRORS-V5: ^
+@ CHECK-ERRORS-V5: note: instruction requires: arm-mode
+@ CHECK-ERRORS-V5: note: operand must be an immediate in the range [0,255] or a relocatable expression
+@ CHECK-ERRORS-V5: note: instruction variant requires ARMv6 or later
@ Immediates where registers were expected
adds #0, r1, r2
@@ -225,10 +228,11 @@
@ Mismatched source/destination operands for MUL instruction.
muls r1, r2, r3
-@ CHECK-ERRORS: error: destination register must match source register
+@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
@ CHECK-ERRORS: muls r1, r2, r3
-@ CHECK-ERRORS: ^
-
+@ CHECK-ERRORS: ^
+@ CHECK-ERRORS: note: destination register must match a source register
+@ CHECK-ERRORS: note: too many operands for instruction
@ Out of range immediates for STR instruction.
str r2, [r7, #-1]
@@ -274,30 +278,33 @@
@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
@ CHECK-ERRORS: add sp, #-1
@ CHECK-ERRORS: ^
+@ CHECK-ERRORS: note: instruction requires: thumb2
+@ CHECK-ERRORS: add sp, #-1
+@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: operand must be a register in range [r0, r15]
@ CHECK-ERRORS: add sp, #-1
@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: invalid operand for instruction
@ CHECK-ERRORS: add sp, #-1
@ CHECK-ERRORS: ^
-@ CHECK-ERRORS: note: instruction requires: thumb2
-@ CHECK-ERRORS: add sp, #-1
-@ CHECK-ERRORS: ^
@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
@ CHECK-ERRORS: add sp, #3
@ CHECK-ERRORS: ^
+@ CHECK-ERRORS: note: instruction requires: thumb2
+@ CHECK-ERRORS: add sp, #3
+@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: operand must be a register in range [r0, r15]
@ CHECK-ERRORS: add sp, #3
@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: invalid operand for instruction
@ CHECK-ERRORS: add sp, #3
@ CHECK-ERRORS: ^
-@ CHECK-ERRORS: note: instruction requires: thumb2
-@ CHECK-ERRORS: add sp, #3
-@ CHECK-ERRORS: ^
@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
@ CHECK-ERRORS: add sp, sp, #512
@ CHECK-ERRORS: ^
+@ CHECK-ERRORS: note: instruction requires: thumb2
+@ CHECK-ERRORS: add sp, sp, #512
+@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: operand must be a register in range [r0, r15]
@ CHECK-ERRORS: add sp, sp, #512
@ CHECK-ERRORS: ^
@@ -305,9 +312,6 @@
@ CHECK-ERRORS: add sp, sp, #512
@ CHECK-ERRORS: ^
@ CHECK-ERRORS: note: instruction requires: thumb2
-@ CHECK-ERRORS: add sp, sp, #512
-@ CHECK-ERRORS: ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
@ CHECK-ERRORS: add r2, sp, #1024
@ CHECK-ERRORS: ^
add r2, sp, ip
@@ -407,7 +411,8 @@
adds
adds r0
@ CHECK-ERRORS: error: too few operands for instruction
-@ CHECK-ERRORS: error: too few operands for instruction
+@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
+@ CHECK-ERRORS: note: too few operands for instruction
@------------------------------------------------------------------------------
@ Out of range width for SBFX/UBFX
diff --git a/llvm/test/MC/ARM/thumb-mov.s b/llvm/test/MC/ARM/thumb-mov.s
index 6f662f3ee2c720..e910722f2edf49 100644
--- a/llvm/test/MC/ARM/thumb-mov.s
+++ b/llvm/test/MC/ARM/thumb-mov.s
@@ -58,10 +58,16 @@
movs sp, r0
movs r0, sp
movs sp, sp
-// CHECK-V7: error: instruction variant requires ARMv8 or later
+// CHECK-V7: error: invalid instruction, any one of the following would fix this:
// CHECK-V7-NEXT: movs sp, r0
-// CHECK-V7: instruction variant requires ARMv8 or later
+// CHECK-V7: note: instruction variant requires ARMv8 or later
+// CHECK-V7: note: operand must be a register in range [r0, r7]
+// CHECK-V7: error: invalid instruction, any one of the following would fix this:
// CHECK-V7-NEXT: movs r0, sp
+// CHECK-V7: note: instruction variant requires ARMv8 or later
+// CHECK-V7: note: invalid operand for instruction
+// CHECK-V7: note: operand must be an immediate in the range [0,255] or a relocatable expression
+// CHECK-V7: note: operand must be a register in range [r0, r7]
// CHECK-V7: error: instruction variant requires ARMv8 or later
// CHECK-V7-NEXT: movs sp, sp
// CHECK-V8: movs.w sp, r0 @ encoding: [0x5f,0xea,0x00,0x0d]
@@ -69,8 +75,9 @@
// CHECK-V8: movs.w sp, sp @ encoding: [0x5f,0xea,0x0d,0x0d]
mov.w sp, sp
-// CHECK-V7: error: instruction variant requires ARMv8 or later
+// CHECK-V7: error: invalid instruction, any one of the following would fix this:
// CHECK-V7-NEXT: mov.w sp, sp
+// CHECK-V7: note: instruction variant requires ARMv8 or later
// CHECK-V8: mov.w sp, sp @ encoding: [0x4f,0xea,0x0d,0x0d]
movs.w sp, r0
@@ -78,8 +85,9 @@
movs.w sp, sp
// CHECK-V7: error: instruction variant requires ARMv8 or later
// CHECK-V7-NEXT: movs.w sp, r0
-// CHECK-V7: instruction variant requires ARMv8 or later
+// CHECK-V7: error: invalid instruction, any one of the following would fix this:
// CHECK-V7-NEXT: movs.w r0, sp
+// CHECK-V7: note: instruction variant requires ARMv8 or later
// CHECK-V7: error: instruction variant requires ARMv8 or later
// CHECK-V7-NEXT: movs.w sp, sp
// CHECK-V8: movs.w sp, r0 @ encoding: [0x5f,0xea,0x00,0x0d]
diff --git a/llvm/test/MC/ARM/thumb2-diagnostics.s b/llvm/test/MC/ARM/thumb2-diagnostics.s
index 45efd3c62120c1..afb12ce4309812 100644
--- a/llvm/test/MC/ARM/thumb2-diagnostics.s
+++ b/llvm/test/MC/ARM/thumb2-diagnostics.s
@@ -156,7 +156,9 @@ foo2:
adds
adds r0
@ CHECK-ERRORS: error: too few operands for instruction
-@ CHECK-ERRORS: error: too few operands for instruction
+@ CHECK-ERRORS: error: invalid instruction, any one of the following would fix this:
+@ CHECK-ERRORS: note: too few operands for instruction
+@ CHECK-ERRORS: note: operand must be a register in range [r0, r15]
tst sp, #3
tst sp, r5
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index 8f57c402adc763..afadd25dcc52d3 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -107,6 +107,7 @@
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/MC/TargetRegistry.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
@@ -216,6 +217,19 @@ struct ClassInfo {
/// Is this operand optional and not always required.
bool IsOptional;
+ /// OptionalShouldOffsetCustomParsers - Only used if IsOptional is true.
+ /// Specifies if this optional operand should be assumed to be
+ /// present for the sake of determining if a custom parser should be
+ /// used, which is determined by the mnemonic and operand index.
+ /// If true, then the parser will always assume a value representing this
+ /// operand will always be present when parsing and thus the custom parser
+ /// will be applied to later tokens in the input stream.
+ /// If false, then the parse will assume it will not be present in the operand
+ /// vector and therefore will apply the custom parser earlier.
+ /// For example of usage, see ARMAsmParser and the CondCode operands which are
+ /// always present at parse time.
+ bool OptionalShouldOffsetCustomParsers;
+
/// DefaultMethod - The name of the method that returns the default operand
/// for optional operand
std::string DefaultMethod;
@@ -1450,6 +1464,11 @@ void AsmMatcherInfo::buildOperandClasses() {
if (BitInit *BI = dyn_cast<BitInit>(IsOptional))
CI->IsOptional = BI->getValue();
+ Init *OptionalShouldOffsetCustomParsers =
+ Rec->getValueInit("OptionalShouldOffsetCustomParsers");
+ if (BitInit *BI = dyn_cast<BitInit>(OptionalShouldOffsetCustomParsers))
+ CI->OptionalShouldOffsetCustomParsers = BI->getValue();
+
// Get or construct the default method name.
Init *DMName = Rec->getValueInit("DefaultMethod");
if (StringInit *SI = dyn_cast<StringInit>(DMName)) {
@@ -1491,7 +1510,7 @@ void AsmMatcherInfo::buildOperandMatchInfo() {
OperandMask |= maskTrailingOnes<unsigned>(NumOptionalOps + 1)
<< (i - NumOptionalOps);
}
- if (Op.Class->IsOptional)
+ if (Op.Class->IsOptional && Op.Class->OptionalShouldOffsetCustomParsers)
++NumOptionalOps;
}
@@ -3748,6 +3767,9 @@ void AsmMatcherEmitter::run(raw_ostream &OS) {
OS << " } else {\n";
OS << " DEBUG_WITH_TYPE(\"asm-matcher\", dbgs() << \"but formal "
"operand not required\\n\");\n";
+ OS << " if (isSubclass(Formal, OptionalMatchClass)) {\n";
+ OS << " OptionalOperandsMask.set(FormalIdx);\n";
+ OS << " }\n";
OS << " }\n";
OS << " continue;\n";
} else {
diff --git a/llvm/utils/TableGen/CodeGenTarget.h b/llvm/utils/TableGen/CodeGenTarget.h
index 7e2dd43cbf1387..36bebf0760a2b2 100644
--- a/llvm/utils/TableGen/CodeGenTarget.h
+++ b/llvm/utils/TableGen/CodeGenTarget.h
@@ -99,7 +99,7 @@ class CodeGenTarget {
///
bool getAllowRegisterRenaming() const;
- /// getPreferSmallerInstructions - Return the PreferSmallerInstructions
+ /// getPreferSmallerInstructions - Return the PreferSmallerInstructions
/// flag value for this target.
///
bool getPreferSmallerInstructions() const;
>From ab1edd5c9f004796dda16c97556ad5ab8d8da01a Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Tue, 5 Mar 2024 13:32:07 +0000
Subject: [PATCH 4/6] Make VPTPred optional also
---
llvm/include/llvm/Target/Target.td | 11 -
llvm/lib/Target/ARM/ARM.td | 2 +-
llvm/lib/Target/ARM/ARMInstrFormats.td | 6 +-
llvm/lib/Target/ARM/ARMInstrThumb2.td | 2 +-
.../lib/Target/ARM/AsmParser/ARMAsmParser.cpp | 135 ++-
llvm/test/MC/ARM/cde-fp-vec.s | 22 +-
llvm/test/MC/ARM/cde-vec-pred.s | 2 +-
llvm/test/MC/ARM/diagnostics.s | 2 +-
llvm/test/MC/ARM/invalid-fp-armv8.s | 4 +-
llvm/test/MC/ARM/mve-load-store.s | 912 +++++++++---------
llvm/test/MC/ARM/mve-misc.s | 4 +-
llvm/test/MC/ARM/neon-complex.s | 24 +-
llvm/test/MC/ARM/no-mve.s | 6 +-
llvm/test/MC/ARM/vfp4.s | 4 +-
llvm/utils/TableGen/AsmMatcherEmitter.cpp | 20 +-
15 files changed, 588 insertions(+), 568 deletions(-)
diff --git a/llvm/include/llvm/Target/Target.td b/llvm/include/llvm/Target/Target.td
index 3cbdc3ccf8b558..c1509a6959ed42 100644
--- a/llvm/include/llvm/Target/Target.td
+++ b/llvm/include/llvm/Target/Target.td
@@ -947,19 +947,8 @@ class AsmOperandClass {
/// instruction if it hasn't matched all the operands yet. However, this
/// error will be suppressed if all of the remaining unmatched operands are
/// marked as IsOptional.
- ///
- /// Note: Optional arguments have caveats if they are not at the end of this list
- /// when regarding custom operand parsing. See below
bit IsOptional = false;
- // Fixme: Ideally this would not be necessary however this would involve interleaving the
- // parsing and matching processes.
- /// Set to 1 if the parser should assume this operand will always be present
- /// for the sake of calculating the operand index in regards to which custom operand
- /// parser should be used.
- /// This is only used for custom operands that are not at the end of the instruction.
- bit OptionalShouldOffsetCustomParsers = true;
-
/// The name of the method on the target specific asm parser that returns the
/// default operand for this optional operand. This method is only used if
/// IsOptional == 1. If not set, this will default to "defaultFooOperands",
diff --git a/llvm/lib/Target/ARM/ARM.td b/llvm/lib/Target/ARM/ARM.td
index 7472970b7f283b..cb5a9a180ec78c 100644
--- a/llvm/lib/Target/ARM/ARM.td
+++ b/llvm/lib/Target/ARM/ARM.td
@@ -1732,6 +1732,7 @@ def ARMAsmWriter : AsmWriter {
def ARMAsmParser : AsmParser {
bit ReportMultipleNearMisses = 1;
+ let PreferSmallerInstructions = true;
}
def ARMAsmParserVariant : AsmParserVariant {
@@ -1747,5 +1748,4 @@ def ARM : Target {
let AssemblyParsers = [ARMAsmParser];
let AssemblyParserVariants = [ARMAsmParserVariant];
let AllowRegisterRenaming = 1;
- let PreferSmallerInstructions= true;
}
diff --git a/llvm/lib/Target/ARM/ARMInstrFormats.td b/llvm/lib/Target/ARM/ARMInstrFormats.td
index 6e0466f1bc11bd..d34f4d8ba037b2 100644
--- a/llvm/lib/Target/ARM/ARMInstrFormats.td
+++ b/llvm/lib/Target/ARM/ARMInstrFormats.td
@@ -160,7 +160,6 @@ def CondCodeOperand : AsmOperandClass {
let PredicateMethod = "isCondCode";
let DefaultMethod = "defaultCondCodeOp";
let IsOptional = true;
- let OptionalShouldOffsetCustomParsers = false;
}
def pred : PredicateOperand<OtherVT, (ops i32imm, i32imm),
(ops (i32 14), (i32 zero_reg))> {
@@ -184,7 +183,6 @@ def CCOutOperand : AsmOperandClass {
let Name = "CCOut";
let DefaultMethod = "defaultCCOutOp";
let IsOptional = true;
- let OptionalShouldOffsetCustomParsers = false;
}
def cc_out : OptionalDefOperand<OtherVT, (ops CCR), (ops (i32 zero_reg))> {
let EncoderMethod = "getCCOutOpValue";
@@ -213,10 +211,14 @@ def inv_cond_XFORM : SDNodeXForm<imm, [{
def VPTPredNOperand : AsmOperandClass {
let Name = "VPTPredN";
let PredicateMethod = "isVPTPred";
+ let DefaultMethod = "defaultVPTPredOp";
+ let IsOptional = true;
}
def VPTPredROperand : AsmOperandClass {
let Name = "VPTPredR";
let PredicateMethod = "isVPTPred";
+ let DefaultMethod = "defaultVPTPredOp";
+ let IsOptional = true;
}
// Operand classes for the cluster of MC operands describing a
diff --git a/llvm/lib/Target/ARM/ARMInstrThumb2.td b/llvm/lib/Target/ARM/ARMInstrThumb2.td
index acd46e8093aa78..70686bce2280d1 100644
--- a/llvm/lib/Target/ARM/ARMInstrThumb2.td
+++ b/llvm/lib/Target/ARM/ARMInstrThumb2.td
@@ -5092,7 +5092,7 @@ def : InstAlias<"dmb${p}.w", (t2DMB 0xf, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"dsb${p}.w\t$opt", (t2DSB memb_opt:$opt, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"dsb${p}", (t2DSB 0xf, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"dsb${p}.w", (t2DSB 0xf, pred:$p), 0>, Requires<[HasDB]>;
-def : InstAlias<"isb${p}.w\t$opt", (t2ISB memb_opt:$opt, pred:$p), 0>, Requires<[HasDB]>;
+def : InstAlias<"isb${p}.w\t$opt", (t2ISB instsyncb_opt:$opt, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"isb${p}", (t2ISB 0xf, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"isb${p}.w", (t2ISB 0xf, pred:$p), 0>, Requires<[HasDB]>;
diff --git a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
index a51e12c6605cf0..789a4d9de7bedb 100644
--- a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
+++ b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
@@ -26,6 +26,7 @@
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
+#include "llvm/IR/DerivedTypes.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h"
@@ -510,6 +511,7 @@ class ARMAsmParser : public MCTargetAsmParser {
std::unique_ptr<ARMOperand> defaultCondCodeOp();
std::unique_ptr<ARMOperand> defaultCCOutOp();
+ std::unique_ptr<ARMOperand> defaultVPTPredOp();
bool isMnemonicVPTPredicable(StringRef Mnemonic, StringRef ExtraToken);
StringRef splitMnemonic(StringRef Mnemonic, StringRef ExtraToken,
@@ -1366,6 +1368,14 @@ class ARMOperand : public MCParsedAsmOperand {
bool isRegListWithAPSR() const {
return Kind == k_RegisterListWithAPSR || Kind == k_RegisterList;
}
+ bool isDReg() const {
+ return isReg() &&
+ ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg.RegNum);
+ }
+ bool isQReg() const {
+ return isReg() &&
+ ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg.RegNum);
+ }
bool isDPRRegList() const { return Kind == k_DPRRegisterList; }
bool isSPRRegList() const { return Kind == k_SPRRegisterList; }
bool isFPSRegListWithVPR() const { return Kind == k_FPSRegisterListWithVPR; }
@@ -2031,6 +2041,8 @@ class ARMOperand : public MCParsedAsmOperand {
bool isProcIFlags() const { return Kind == k_ProcIFlags; }
// NEON operands.
+ bool isVectorList() const { return Kind == k_VectorList; }
+
bool isSingleSpacedVectorList() const {
return Kind == k_VectorList && !VectorList.isDoubleSpaced;
}
@@ -2471,6 +2483,20 @@ class ARMOperand : public MCParsedAsmOperand {
CC == ARMCC::GT || CC == ARMCC::LE || CC == ARMCC::GE;
}
+ void setVecListDPair(unsigned int DPair) {
+ Kind = k_VectorList;
+ VectorList.RegNum = DPair;
+ VectorList.Count = 2;
+ VectorList.isDoubleSpaced = false;
+ }
+
+ void setVecListOneD(unsigned int DReg) {
+ Kind = k_VectorList;
+ VectorList.RegNum = DReg;
+ VectorList.Count = 1;
+ VectorList.isDoubleSpaced = false;
+ }
+
void addExpr(MCInst &Inst, const MCExpr *Expr) const {
// Add as immediates when possible. Null MCExpr = 0.
if (!Expr)
@@ -4757,6 +4783,8 @@ ParseStatus ARMAsmParser::parseVectorList(OperandVector &Operands) {
// As an extension (to match gas), support a plain D register or Q register
// (without encosing curly braces) as a single or double entry list,
// respectively.
+ // If there is no lane supplied, just parse as a register and
+ // use the custom matcher to convert to list if necessary
if (!hasMVE() && Parser.getTok().is(AsmToken::Identifier)) {
SMLoc E = Parser.getTok().getEndLoc();
int Reg = tryParseRegister();
@@ -4768,7 +4796,7 @@ ParseStatus ARMAsmParser::parseVectorList(OperandVector &Operands) {
return Res;
switch (LaneKind) {
case NoLanes:
- Operands.push_back(ARMOperand::CreateVectorList(Reg, 1, false, S, E));
+ Operands.push_back(ARMOperand::CreateReg(Reg, S, E));
break;
case AllLanes:
Operands.push_back(ARMOperand::CreateVectorListAllLanes(Reg, 1, false,
@@ -4789,9 +4817,7 @@ ParseStatus ARMAsmParser::parseVectorList(OperandVector &Operands) {
return Res;
switch (LaneKind) {
case NoLanes:
- Reg = MRI->getMatchingSuperReg(Reg, ARM::dsub_0,
- &ARMMCRegisterClasses[ARM::DPairRegClassID]);
- Operands.push_back(ARMOperand::CreateVectorList(Reg, 2, false, S, E));
+ Operands.push_back(ARMOperand::CreateReg(Reg, S, E));
break;
case AllLanes:
Reg = MRI->getMatchingSuperReg(Reg, ARM::dsub_0,
@@ -4807,7 +4833,8 @@ ParseStatus ARMAsmParser::parseVectorList(OperandVector &Operands) {
}
return ParseStatus::Success;
}
- return Error(S, "vector register expected");
+ Operands.push_back(ARMOperand::CreateReg(Reg, S, E));
+ return ParseStatus::Success;
}
if (Parser.getTok().isNot(AsmToken::LCurly))
@@ -5137,6 +5164,10 @@ ParseStatus ARMAsmParser::parseProcIFlagsOperand(OperandVector &Operands) {
/// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
ParseStatus ARMAsmParser::parseMSRMaskOperand(OperandVector &Operands) {
+ // Don't parse two MSR registers in a row
+ if (static_cast<ARMOperand &>(*Operands.back()).isMSRMask() ||
+ static_cast<ARMOperand &>(*Operands.back()).isBankedReg())
+ return ParseStatus::NoMatch;
MCAsmParser &Parser = getParser();
SMLoc S = Parser.getTok().getLoc();
const AsmToken &Tok = Parser.getTok();
@@ -5234,6 +5265,10 @@ ParseStatus ARMAsmParser::parseMSRMaskOperand(OperandVector &Operands) {
/// parseBankedRegOperand - Try to parse a banked register (e.g. "lr_irq") for
/// use in the MRS/MSR instructions added to support virtualization.
ParseStatus ARMAsmParser::parseBankedRegOperand(OperandVector &Operands) {
+ // Don't parse two Banked registers in a row
+ if (static_cast<ARMOperand &>(*Operands.back()).isBankedReg() ||
+ static_cast<ARMOperand &>(*Operands.back()).isMSRMask())
+ return ParseStatus::NoMatch;
MCAsmParser &Parser = getParser();
SMLoc S = Parser.getTok().getLoc();
const AsmToken &Tok = Parser.getTok();
@@ -5267,7 +5302,7 @@ ParseStatus ARMAsmParser::parsePKHImm(OperandVector &Operands, StringRef Op,
// There must be a '#' and a shift amount.
if (Parser.getTok().isNot(AsmToken::Hash) &&
Parser.getTok().isNot(AsmToken::Dollar))
- return Error(Parser.getTok().getLoc(), "'#' expected");
+ return ParseStatus::NoMatch;
Parser.Lex(); // Eat hash token.
const MCExpr *ShiftAmount;
@@ -5317,7 +5352,7 @@ ParseStatus ARMAsmParser::parseShifterImm(OperandVector &Operands) {
const AsmToken &Tok = Parser.getTok();
SMLoc S = Tok.getLoc();
if (Tok.isNot(AsmToken::Identifier))
- return Error(S, "shift operator 'asr' or 'lsl' expected");
+ return ParseStatus::NoMatch;
StringRef ShiftName = Tok.getString();
bool isASR;
if (ShiftName == "lsl" || ShiftName == "LSL")
@@ -5325,7 +5360,7 @@ ParseStatus ARMAsmParser::parseShifterImm(OperandVector &Operands) {
else if (ShiftName == "asr" || ShiftName == "ASR")
isASR = true;
else
- return Error(S, "shift operator 'asr' or 'lsl' expected");
+ return ParseStatus::NoMatch;
Parser.Lex(); // Eat the operator.
// A '#' and a shift amount.
@@ -5518,7 +5553,7 @@ ParseStatus ARMAsmParser::parseBitfield(OperandVector &Operands) {
// The bitfield descriptor is really two operands, the LSB and the width.
if (Parser.getTok().isNot(AsmToken::Hash) &&
Parser.getTok().isNot(AsmToken::Dollar))
- return Error(Parser.getTok().getLoc(), "'#' expected");
+ return ParseStatus::NoMatch;
Parser.Lex(); // Eat hash token.
const MCExpr *LSBExpr;
@@ -6091,6 +6126,8 @@ bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
/// parseFPImm - A floating point immediate expression operand.
ParseStatus ARMAsmParser::parseFPImm(OperandVector &Operands) {
+ LLVM_DEBUG(dbgs() << "PARSE FPImm, Ops: " << Operands.size());
+
MCAsmParser &Parser = getParser();
// Anything that can accept a floating point constant as an operand
// needs to go through here, as the regular parseExpression is
@@ -6136,7 +6173,11 @@ ParseStatus ARMAsmParser::parseFPImm(OperandVector &Operands) {
if (!(isVmovf || isFconst))
return ParseStatus::NoMatch;
- Parser.Lex(); // Eat '#' or '$'.
+ if (Parser.getTok().getKind() == llvm::AsmToken::Hash ||
+ Parser.getTok().getKind() == llvm::AsmToken::Dollar)
+ Parser.Lex(); // Eat '#' or '$'.
+ else
+ return ParseStatus::NoMatch;
// Handle negation, as that still comes through as a separate token.
bool isNegative = false;
@@ -6763,7 +6804,7 @@ static bool isThumbI8Relocation(MCParsedAsmOperand &MCOp) {
bool ARMAsmParser::shouldOmitVectorPredicateOperand(
StringRef Mnemonic, OperandVector &Operands, unsigned MnemonicOpsEndInd) {
- if (!hasMVE() || Operands.size() < MnemonicOpsEndInd)
+ if (!hasMVE() || Operands.size() <= MnemonicOpsEndInd)
return true;
if (Mnemonic.starts_with("vld2") || Mnemonic.starts_with("vld4") ||
@@ -6793,9 +6834,7 @@ bool ARMAsmParser::shouldOmitVectorPredicateOperand(
// MQPR, to more accurately report errors when using Q registers
// outside of the allowed range.
if (static_cast<ARMOperand &>(*Operand).isVectorIndex() ||
- (Operand->isReg() &&
- (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(
- Operand->getReg()))))
+ static_cast<ARMOperand &>(*Operand).isQReg())
return false;
}
return true;
@@ -7059,14 +7098,14 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
// Add the carry setting operand, if necessary.
- if (CanAcceptCarrySet) {
+ if (CanAcceptCarrySet && CarrySetting != 0) {
SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
Loc));
}
// Add the predication code operand, if necessary.
- if (CanAcceptPredicationCode) {
+ if (CanAcceptPredicationCode && PredicationCode != llvm::ARMCC::AL) {
SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
CarrySetting);
Operands.push_back(ARMOperand::CreateCondCode(
@@ -7074,14 +7113,9 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
// Add the VPT predication code operand, if necessary.
- // FIXME: We don't add them for the instructions filtered below as these can
- // have custom operands which need special parsing. This parsing requires
- // the operand to be in the same place in the OperandVector as their
- // definition in tblgen. Since these instructions may also have the
- // scalar predication operand we do not add the vector one and leave until
- // now to fix it up.
- if (CanAcceptVPTPredicationCode && Mnemonic != "vmov" &&
- !Mnemonic.starts_with("vcmp") &&
+ // Dont add in certain cases of VCVT as this needs to be disambiguated
+ // after operand parsing
+ if (CanAcceptVPTPredicationCode && VPTPredicationCode != llvm::ARMVCC::None &&
!(Mnemonic.starts_with("vcvt") && Mnemonic != "vcvta" &&
Mnemonic != "vcvtn" && Mnemonic != "vcvtp" && Mnemonic != "vcvtm")) {
SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
@@ -7150,15 +7184,6 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
if (parseToken(AsmToken::EndOfStatement, "unexpected token in argument list"))
return true;
- // Remove the optional tokens if they are the default values
- // This can only be done after parsing as the index of the operands
- // is used for custom parsers.
- // CCOut
- if (!CarrySetting && CanAcceptCarrySet)
- removeCCOut(Operands, MnemonicOpsEndInd);
- if (PredicationCode == llvm::ARMCC::AL && CanAcceptPredicationCode)
- removeCondCode(Operands, MnemonicOpsEndInd);
-
tryConvertingToTwoOperandForm(Mnemonic, PredicationCode, CarrySetting,
Operands, MnemonicOpsEndInd);
@@ -7221,17 +7246,10 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc MLoc = SMLoc::getFromPointer(NameLoc.getPointer());
Operands.insert(Operands.begin(),
ARMOperand::CreateToken(StringRef("vmullt"), MLoc));
- }
- // For vmov and vcmp, as mentioned earlier, we did not add the vector
- // predication code, since these may contain operands that require
- // special parsing. So now we have to see if they require vector
- // predication and replace the scalar one with the vector predication
- // operand if that is the case.
- else if (Mnemonic == "vmov" || Mnemonic.starts_with("vcmp") ||
- (Mnemonic.starts_with("vcvt") && !Mnemonic.starts_with("vcvta") &&
- !Mnemonic.starts_with("vcvtn") &&
- !Mnemonic.starts_with("vcvtp") &&
- !Mnemonic.starts_with("vcvtm"))) {
+ } else if (Mnemonic.starts_with("vcvt") && !Mnemonic.starts_with("vcvta") &&
+ !Mnemonic.starts_with("vcvtn") &&
+ !Mnemonic.starts_with("vcvtp") &&
+ !Mnemonic.starts_with("vcvtm")) {
if (!shouldOmitVectorPredicateOperand(Mnemonic, Operands,
MnemonicOpsEndInd)) {
// We could not split the vector predicate off vcvt because it might
@@ -7256,8 +7274,6 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
ARMOperand::CreateToken(Mnemonic, MLoc));
}
}
- // Remove CondCode
- removeCondCode(Operands, MnemonicOpsEndInd);
SMLoc PLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
Mnemonic.size() + CarrySetting);
// Add VPTPred
@@ -7273,8 +7289,6 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
if (shouldOmitVectorPredicateOperand(Mnemonic, Operands,
MnemonicOpsEndInd)) {
removeVPTCondCode(Operands, MnemonicOpsEndInd);
- } else if (CanAcceptPredicationCode && PredicationCode == ARMCC::AL) {
- removeCondCode(Operands, MnemonicOpsEndInd);
}
}
}
@@ -12916,11 +12930,24 @@ unsigned ARMAsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
if (hasV8Ops() && Op.isReg() && Op.getReg() == ARM::SP)
return Match_Success;
return Match_rGPR;
- case MCK_GPRPair:
- if (Op.isReg() &&
- MRI->getRegClass(ARM::GPRRegClassID).contains(Op.getReg()))
+ // If trying to match a VecListDPair with a Q register, convert Q to list
+ case MCK_VecListDPair:
+ if (Op.isQReg() && !hasMVE()) {
+ auto DPair = getDRegFromQReg(Op.getReg());
+ DPair = MRI->getMatchingSuperReg(
+ DPair, ARM::dsub_0, &ARMMCRegisterClasses[ARM::DPairRegClassID]);
+ Op.setVecListDPair(DPair);
return Match_Success;
- break;
+ }
+ return Match_InvalidOperand;
+ // If trying to match a VecListDPair with a D register, convert D singleton
+ // list
+ case MCK_VecListOneD:
+ if (Op.isDReg() && !hasMVE()) {
+ Op.setVecListOneD(Op.getReg());
+ return Match_Success;
+ }
+ return Match_InvalidOperand;
}
return Match_InvalidOperand;
}
@@ -12976,3 +13003,7 @@ std::unique_ptr<ARMOperand> ARMAsmParser::defaultCondCodeOp() {
std::unique_ptr<ARMOperand> ARMAsmParser::defaultCCOutOp() {
return ARMOperand::CreateCCOut(0, SMLoc());
}
+
+std::unique_ptr<ARMOperand> ARMAsmParser::defaultVPTPredOp() {
+ return ARMOperand::CreateVPTPred(ARMVCC::None, SMLoc());
+}
diff --git a/llvm/test/MC/ARM/cde-fp-vec.s b/llvm/test/MC/ARM/cde-fp-vec.s
index 4b139579b719ba..fa18ffa766e2e3 100644
--- a/llvm/test/MC/ARM/cde-fp-vec.s
+++ b/llvm/test/MC/ARM/cde-fp-vec.s
@@ -12,7 +12,7 @@ ittt eq
vcx1a p1, s7, #2047
// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: instructions in IT block must be predicable
vcx2 p0, d0, d15, #0
-// ERROR-FP: [[@LINE+2]]:{{[0-9]+}}: error: invalid instruction
+// ERROR-FP: [[@LINE+2]]:{{[0-9]+}}: error: instruction requires: mve
// ERROR-MVE: [[@LINE+1]]:{{[0-9]+}}: error: instructions in IT block must be predicable
vcx3 p0, q0, q7, q0, #12
nop
@@ -33,12 +33,15 @@ vcx1a p1, d3, #2047
// ERROR-FP: [[@LINE+1]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this:
vcx1 p0, q1, #1234
// CHECK-MVE-NEXT: vcx1a p1, q5, #4095 @ encoding: [0x2f,0xfd,0xff,0xa1]
-// ERROR-FP: [[@LINE+1]]:{{[0-9]+}}: error: invalid instruction
+// ERROR-FP: [[@LINE+1]]:{{[0-9]+}}: error: instruction requires: mve
vcx1a p1, q5, #4095
// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: invalid instruction
vcx1a p1, s7, s7, #2047
-// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: operand must be an immediate in the range [0,2047]
+// ERROR-FP: [[@LINE+4]]:{{[0-9]+}}: error: operand must be an immediate in the range [0,2047]
+// ERROR-MVE: [[@LINE+3]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this
+// ERROR-MVE: [[@LINE+2]]:{{[0-9]+}}: note: operand must be a register in range [q0, q7]
+// ERROR-MVE: [[@LINE+1]]:{{[0-9]+}}: note: operand must be an immediate in the range [0,2047]
vcx1 p0, d0, #2048
// ERROR-FP: [[@LINE+1]]:{{[0-9]+}}: error: operand must be an immediate in the range [0,2047]
vcx1a p1, s0, #2048
@@ -51,10 +54,13 @@ vcx1 p8, d0, #1234
vcx1 p0, d16, #1234
// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: invalid instruction
vcx1 p0, s32, #1234
-// ERROR-FP: [[@LINE+4]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this:
-// ERROR-FP: [[@LINE+3]]:{{[0-9]+}}: note: operand must be a register in range [s0, s31]
-// ERROR-FP: [[@LINE+2]]:{{[0-9]+}}: note: operand must be a register in range [d0, d15]
-// ERROR-MVE: [[@LINE+1]]:{{[0-9]+}}: error: operand must be a register in range [q0, q7]
+// ERROR-FP: [[@LINE+7]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this:
+// ERROR-FP: [[@LINE+6]]:{{[0-9]+}}: note: operand must be a register in range [s0, s31]
+// ERROR-FP: [[@LINE+5]]:{{[0-9]+}}: note: operand must be a register in range [d0, d15]
+// ERROR-MVE: [[@LINE+4]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this:
+// ERROR-MVE: [[@LINE+3]]:{{[0-9]+}}: note: operand must be a register in range [q0, q7]
+// ERROR-MVE: [[@LINE+2]]:{{[0-9]+}}: note: operand must be a register in range [s0, s31]
+// ERROR-MVE: [[@LINE+1]]:{{[0-9]+}}: note: operand must be a register in range [d0, d15]
vcx1 p0, q8, #1234
// ERROR: [[@LINE+3]]:{{[0-9]+}}: error: invalid instruction, any one of the following would fix this:
// ERROR: [[@LINE+2]]:{{[0-9]+}}: note: operand must be a register in range [s0, s31]
@@ -116,7 +122,7 @@ vcx3a p1, d1, d11, d12, #8
// ERROR-MVE: [[@LINE+2]]:{{[0-9]+}}: error: operand must be an immediate in the range [0,15]
// ERROR-FP: error: invalid instruction
vcx3a p1, q1, q2, q3, #16
-// ERROR-MVE: [[@LINE+2]]:{{[0-9]+}}: error: invalid instruction
+// ERROR-MVE: [[@LINE+2]]:{{[0-9]+}}: error: operand must be a register in range [d0, d15]
// ERROR-FP: [[@LINE+1]]:{{[0-9]+}}: error: operand must be a register in range [d0, d15]
vcx3 p0, d0, q0, d7, #1
// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: operand must be a register in range [s0, s31]
diff --git a/llvm/test/MC/ARM/cde-vec-pred.s b/llvm/test/MC/ARM/cde-vec-pred.s
index 6274fafa1224a4..9932f8d000337c 100644
--- a/llvm/test/MC/ARM/cde-vec-pred.s
+++ b/llvm/test/MC/ARM/cde-vec-pred.s
@@ -19,7 +19,7 @@ vcx3at p1, q3, q7, q6, #15
vcx3e p0, q0, q2, q0, #12
vpt.i8 eq, q0, q0
-// ERROR: [[@LINE+1]]:{{[0-9]+}}: error: incorrect predication in VPT block; got 'none', but expected 't'
+// ERROR: error: incorrect predication in VPT block; got 'none', but expected 't'
vcx1 p0, q1, #1234
vpt.i8 eq, q0, q0
diff --git a/llvm/test/MC/ARM/diagnostics.s b/llvm/test/MC/ARM/diagnostics.s
index e6d80ea7a6280c..fa23a7da1e4048 100644
--- a/llvm/test/MC/ARM/diagnostics.s
+++ b/llvm/test/MC/ARM/diagnostics.s
@@ -288,7 +288,7 @@
@ CHECK-ERRORS: error: 'asr' shift amount must be in range [1,32]
@ CHECK-ERRORS: ssat r8, #1, r10, asr #33
@ CHECK-ERRORS: ^
-@ CHECK-ERRORS: error: shift operator 'asr' or 'lsl' expected
+@ CHECK-ERRORS: error: operand must be a register in range [r0, r14]
@ CHECK-ERRORS: ssat r8, #1, r10, lsr #5
@ CHECK-ERRORS: ^
@ CHECK-ERRORS: error: '#' expected
diff --git a/llvm/test/MC/ARM/invalid-fp-armv8.s b/llvm/test/MC/ARM/invalid-fp-armv8.s
index dca0e448d1140f..c8ce261791cfd0 100644
--- a/llvm/test/MC/ARM/invalid-fp-armv8.s
+++ b/llvm/test/MC/ARM/invalid-fp-armv8.s
@@ -88,6 +88,8 @@ vrinta.f64.f64 s3, q0
vrintn.f32.f32 d3, d0
@ V8: error: instruction requires: NEON
vrintp.f32 q3, q0
-@ V8: error: instruction requires: NEON
+@ V8: error: invalid instruction, any one of the following would fix this:
+@ V8: note: instruction requires: mve.fp
+@ V8: note: instruction requires: NEON
vrintmlt.f32 q3, q0
@ V8: error: instruction 'vrintm' is not predicable, but condition code specified
diff --git a/llvm/test/MC/ARM/mve-load-store.s b/llvm/test/MC/ARM/mve-load-store.s
index 5c6d2a172b252c..797ab1e22dd010 100644
--- a/llvm/test/MC/ARM/mve-load-store.s
+++ b/llvm/test/MC/ARM/mve-load-store.s
@@ -5,55 +5,55 @@
# RUN: FileCheck --check-prefix=ERROR-NOMVE < %t %s
# CHECK: vldrb.u8 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r0]
# CHECK: vldrb.u8 q1, [r0] @ encoding: [0x90,0xed,0x00,0x3e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q1, [r0]
# CHECK: vldrb.u8 q0, [r11] @ encoding: [0x9b,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r11]
# CHECK: vldrb.u8 q3, [r11] @ encoding: [0x9b,0xed,0x00,0x7e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q3, [r11]
# CHECK: vldrb.u8 q0, [r4, #56] @ encoding: [0x94,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r4, #56]
# CHECK: vldrb.u8 q4, [r4, #56] @ encoding: [0x94,0xed,0x38,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q4, [r4, #56]
# CHECK: vldrb.u8 q0, [r8, #56] @ encoding: [0x98,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r8, #56]
# CHECK: vldrb.u8 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [r4, #56]!
# CHECK: vldrb.u8 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [r4, #56]!
# CHECK: vldrb.u8 q5, [r4], #-25 @ encoding: [0x34,0xec,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [r4], #-25
# CHECK: vldrb.u8 q5, [r10], #-25 @ encoding: [0x3a,0xec,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [r10], #-25
# CHECK: vldrb.u8 q5, [sp, #-25] @ encoding: [0x1d,0xed,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [sp, #-25]
# CHECK: vldrb.u8 q5, [sp, #-127] @ encoding: [0x1d,0xed,0x7f,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q5, [sp, #-127]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: invalid operand for instruction
@@ -69,55 +69,55 @@ vldrb.u8 q0, [r0, #-128]!
vldrb.u8 q0, [r0], #128
# CHECK: vstrb.8 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q0, [r0]
# CHECK: vstrb.8 q1, [r0] @ encoding: [0x80,0xed,0x00,0x3e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q1, [r0]
# CHECK: vstrb.8 q0, [r11] @ encoding: [0x8b,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q0, [r11]
# CHECK: vstrb.8 q3, [r11] @ encoding: [0x8b,0xed,0x00,0x7e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q3, [r11]
# CHECK: vstrb.8 q0, [r4, #56] @ encoding: [0x84,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q0, [r4, #56]
# CHECK: vstrb.8 q4, [r4, #56] @ encoding: [0x84,0xed,0x38,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q4, [r4, #56]
# CHECK: vstrb.8 q0, [r8, #56] @ encoding: [0x88,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q0, [r8, #56]
# CHECK: vstrb.8 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [r4, #56]!
# CHECK: vstrb.8 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [r4, #56]!
# CHECK: vstrb.8 q5, [r4], #-25 @ encoding: [0x24,0xec,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [r4], #-25
# CHECK: vstrb.8 q5, [r10], #-25 @ encoding: [0x2a,0xec,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [r10], #-25
# CHECK: vstrb.8 q5, [sp, #-25] @ encoding: [0x0d,0xed,0x19,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [sp, #-25]
# CHECK: vstrb.8 q5, [sp, #127] @ encoding: [0x8d,0xed,0x7f,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q5, [sp, #127]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: invalid operand for instruction
@@ -133,735 +133,735 @@ vstrb.u8 q0, [r0, #-128]!
vstrb.u8 q0, [r0], #128
# CHECK: vldrb.u16 q0, [r0] @ encoding: [0x90,0xfd,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r0]
# CHECK: vldrb.u16 q1, [r0] @ encoding: [0x90,0xfd,0x80,0x2e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q1, [r0]
# CHECK: vldrb.u16 q0, [r7] @ encoding: [0x97,0xfd,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r7]
# CHECK: vldrb.u16 q3, [r7] @ encoding: [0x97,0xfd,0x80,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q3, [r7]
# CHECK: vldrb.u16 q0, [r4, #56] @ encoding: [0x94,0xfd,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r4, #56]
# CHECK: vldrb.u16 q4, [r4, #56] @ encoding: [0x94,0xfd,0xb8,0x8e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q4, [r4, #56]
# CHECK: vldrb.u16 q0, [r2, #56] @ encoding: [0x92,0xfd,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r2, #56]
# CHECK: vldrb.u16 q5, [r4, #56]! @ encoding: [0xb4,0xfd,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r4, #56]!
# CHECK: vldrb.u16 q5, [r4, #56]! @ encoding: [0xb4,0xfd,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r4, #56]!
# CHECK: vldrb.u16 q5, [r4], #-1 @ encoding: [0x34,0xfc,0x81,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r4], #-1
# CHECK: vldrb.u16 q5, [r3], #-25 @ encoding: [0x33,0xfc,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r3], #-25
# CHECK: vldrb.u16 q5, [r6, #-25] @ encoding: [0x16,0xfd,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r6, #-25]
# CHECK: vldrb.u16 q5, [r6, #-64] @ encoding: [0x16,0xfd,0xc0,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q5, [r6, #-64]
# CHECK: vldrb.s16 q0, [r0] @ encoding: [0x90,0xed,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r0]
# CHECK: vldrb.s16 q1, [r0] @ encoding: [0x90,0xed,0x80,0x2e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q1, [r0]
# CHECK: vldrb.s16 q0, [r7] @ encoding: [0x97,0xed,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r7]
# CHECK: vldrb.s16 q3, [r7] @ encoding: [0x97,0xed,0x80,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q3, [r7]
# CHECK: vldrb.s16 q0, [r4, #56] @ encoding: [0x94,0xed,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r4, #56]
# CHECK: vldrb.s16 q4, [r4, #56] @ encoding: [0x94,0xed,0xb8,0x8e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q4, [r4, #56]
# CHECK: vldrb.s16 q0, [r2, #56] @ encoding: [0x92,0xed,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r2, #56]
# CHECK: vldrb.s16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r4, #56]!
# CHECK: vldrb.s16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r4, #56]!
# CHECK: vldrb.s16 q5, [r4], #-25 @ encoding: [0x34,0xec,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r4], #-25
# CHECK: vldrb.s16 q5, [r3], #-25 @ encoding: [0x33,0xec,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r3], #-25
# CHECK: vldrb.s16 q5, [r6, #-25] @ encoding: [0x16,0xed,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r6, #-25]
# CHECK: vldrb.s16 q5, [r6, #-64] @ encoding: [0x16,0xed,0xc0,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q5, [r6, #-64]
# CHECK: vstrb.16 q0, [r0] @ encoding: [0x80,0xed,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q0, [r0]
# CHECK: vstrb.16 q1, [r0] @ encoding: [0x80,0xed,0x80,0x2e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q1, [r0]
# CHECK: vstrb.16 q0, [r7] @ encoding: [0x87,0xed,0x80,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q0, [r7]
# CHECK: vstrb.16 q3, [r7] @ encoding: [0x87,0xed,0x80,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q3, [r7]
# CHECK: vstrb.16 q0, [r4, #56] @ encoding: [0x84,0xed,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q0, [r4, #56]
# CHECK: vstrb.16 q4, [r4, #56] @ encoding: [0x84,0xed,0xb8,0x8e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q4, [r4, #56]
# CHECK: vstrb.16 q0, [r5, #56] @ encoding: [0x85,0xed,0xb8,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q0, [r5, #56]
# CHECK: vstrb.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r4, #56]!
# CHECK: vstrb.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0xb8,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r4, #56]!
# CHECK: vstrb.16 q5, [r4], #-25 @ encoding: [0x24,0xec,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r4], #-25
# CHECK: vstrb.16 q5, [r3], #-25 @ encoding: [0x23,0xec,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r3], #-25
# CHECK: vstrb.16 q5, [r2, #-25] @ encoding: [0x02,0xed,0x99,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r2, #-25]
# CHECK: vstrb.16 q5, [r2, #-64] @ encoding: [0x02,0xed,0xc0,0xae]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q5, [r2, #-64]
# CHECK: vldrb.u32 q0, [r0] @ encoding: [0x90,0xfd,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r0]
# CHECK: vldrb.u32 q1, [r0] @ encoding: [0x90,0xfd,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q1, [r0]
# CHECK: vldrb.u32 q0, [r7] @ encoding: [0x97,0xfd,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r7]
# CHECK: vldrb.u32 q3, [r7] @ encoding: [0x97,0xfd,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q3, [r7]
# CHECK: vldrb.u32 q0, [r4, #56] @ encoding: [0x94,0xfd,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r4, #56]
# CHECK: vldrb.u32 q4, [r4, #56] @ encoding: [0x94,0xfd,0x38,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q4, [r4, #56]
# CHECK: vldrb.u32 q0, [r2, #56] @ encoding: [0x92,0xfd,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r2, #56]
# CHECK: vldrb.u32 q5, [r4, #56]! @ encoding: [0xb4,0xfd,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r4, #56]!
# CHECK: vldrb.u32 q5, [r4, #56]! @ encoding: [0xb4,0xfd,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r4, #56]!
# CHECK: vldrb.u32 q5, [r4], #-25 @ encoding: [0x34,0xfc,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r4], #-25
# CHECK: vldrb.u32 q5, [r3], #-25 @ encoding: [0x33,0xfc,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r3], #-25
# CHECK: vldrb.u32 q5, [r6, #-25] @ encoding: [0x16,0xfd,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r6, #-25]
# CHECK: vldrb.u32 q5, [r6, #-64] @ encoding: [0x16,0xfd,0x40,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q5, [r6, #-64]
# CHECK: vldrb.s32 q0, [r0] @ encoding: [0x90,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r0]
# CHECK: vldrb.s32 q1, [r0] @ encoding: [0x90,0xed,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q1, [r0]
# CHECK: vldrb.s32 q0, [r7] @ encoding: [0x97,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r7]
# CHECK: vldrb.s32 q3, [r7] @ encoding: [0x97,0xed,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q3, [r7]
# CHECK: vldrb.s32 q0, [r4, #56] @ encoding: [0x94,0xed,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r4, #56]
# CHECK: vldrb.s32 q4, [r4, #56] @ encoding: [0x94,0xed,0x38,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q4, [r4, #56]
# CHECK: vldrb.s32 q0, [r2, #56] @ encoding: [0x92,0xed,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r2, #56]
# CHECK: vldrb.s32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r4, #56]!
# CHECK: vldrb.s32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r4, #56]!
# CHECK: vldrb.s32 q5, [r4], #-25 @ encoding: [0x34,0xec,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r4], #-25
# CHECK: vldrb.s32 q5, [r3], #-25 @ encoding: [0x33,0xec,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r3], #-25
# CHECK: vldrb.s32 q5, [r6, #-25] @ encoding: [0x16,0xed,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r6, #-25]
# CHECK: vldrb.s32 q5, [r6, #-64] @ encoding: [0x16,0xed,0x40,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q5, [r6, #-64]
# CHECK: vstrb.32 q0, [r0] @ encoding: [0x80,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q0, [r0]
# CHECK: vstrb.32 q1, [r0] @ encoding: [0x80,0xed,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q1, [r0]
# CHECK: vstrb.32 q0, [r7] @ encoding: [0x87,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q0, [r7]
# CHECK: vstrb.32 q3, [r7] @ encoding: [0x87,0xed,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q3, [r7]
# CHECK: vstrb.32 q0, [r4, #56] @ encoding: [0x84,0xed,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q0, [r4, #56]
# CHECK: vstrb.32 q4, [r4, #56] @ encoding: [0x84,0xed,0x38,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q4, [r4, #56]
# CHECK: vstrb.32 q0, [r5, #56] @ encoding: [0x85,0xed,0x38,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q0, [r5, #56]
# CHECK: vstrb.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r4, #56]!
# CHECK: vstrb.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r4, #56]!
# CHECK: vstrb.32 q5, [r4], #-25 @ encoding: [0x24,0xec,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r4], #-25
# CHECK: vstrb.32 q5, [r3], #-25 @ encoding: [0x23,0xec,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r3], #-25
# CHECK: vstrb.32 q5, [r2, #-25] @ encoding: [0x02,0xed,0x19,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r2, #-25]
# CHECK: vstrb.32 q5, [r2, #-64] @ encoding: [0x02,0xed,0x40,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q5, [r2, #-64]
# CHECK: vldrh.u16 q0, [r0] @ encoding: [0x90,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r0]
# CHECK: vldrh.u16 q1, [r0] @ encoding: [0x90,0xed,0x80,0x3e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q1, [r0]
# CHECK: vldrh.u16 q0, [r11] @ encoding: [0x9b,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r11]
# CHECK: vldrh.u16 q3, [r11] @ encoding: [0x9b,0xed,0x80,0x7e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q3, [r11]
# CHECK: vldrh.u16 q0, [r4, #56] @ encoding: [0x94,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r4, #56]
# CHECK: vldrh.u16 q4, [r4, #56] @ encoding: [0x94,0xed,0x9c,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q4, [r4, #56]
# CHECK: vldrh.u16 q0, [r8, #56] @ encoding: [0x98,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r8, #56]
# CHECK: vldrh.u16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [r4, #56]!
# CHECK: vldrh.u16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [r4, #56]!
# CHECK: vldrh.u16 q5, [r4], #-26 @ encoding: [0x34,0xec,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [r4], #-26
# CHECK: vldrh.u16 q5, [r10], #-26 @ encoding: [0x3a,0xec,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [r10], #-26
# CHECK: vldrh.u16 q5, [sp, #-26] @ encoding: [0x1d,0xed,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [sp, #-26]
# CHECK: vldrh.u16 q5, [sp, #-64] @ encoding: [0x1d,0xed,0xa0,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [sp, #-64]
# CHECK: vldrh.u16 q5, [sp, #-254] @ encoding: [0x1d,0xed,0xff,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [sp, #-254]
# CHECK: vldrh.u16 q5, [r10], #254 @ encoding: [0xba,0xec,0xff,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q5, [r10], #254
# CHECK: vstrh.16 q0, [r0] @ encoding: [0x80,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r0]
# CHECK: vstrh.16 q1, [r0] @ encoding: [0x80,0xed,0x80,0x3e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q1, [r0]
# CHECK: vstrh.16 q0, [r11] @ encoding: [0x8b,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r11]
# CHECK: vstrh.16 q3, [r11] @ encoding: [0x8b,0xed,0x80,0x7e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q3, [r11]
# CHECK: vstrh.16 q0, [r4, #56] @ encoding: [0x84,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r4, #56]
# CHECK: vstrh.16 q4, [r4, #56] @ encoding: [0x84,0xed,0x9c,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q4, [r4, #56]
# CHECK: vstrh.16 q0, [r8, #56] @ encoding: [0x88,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r8, #56]
# CHECK: vstrh.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [r4, #56]!
# CHECK: vstrh.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [r4, #56]!
# CHECK: vstrh.16 q5, [r4], #-26 @ encoding: [0x24,0xec,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [r4], #-26
# CHECK: vstrh.16 q5, [r10], #-26 @ encoding: [0x2a,0xec,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [r10], #-26
# CHECK: vstrh.16 q5, [sp, #-26] @ encoding: [0x0d,0xed,0x8d,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [sp, #-26]
# CHECK: vstrh.16 q5, [sp, #-64] @ encoding: [0x0d,0xed,0xa0,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [sp, #-64]
# CHECK: vstrh.16 q5, [sp, #-254] @ encoding: [0x0d,0xed,0xff,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [sp, #-254]
# CHECK: vstrh.16 q5, [r10], #254 @ encoding: [0xaa,0xec,0xff,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q5, [r10], #254
# CHECK: vldrh.u32 q0, [r0] @ encoding: [0x98,0xfd,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r0]
# CHECK: vldrh.u32 q1, [r0] @ encoding: [0x98,0xfd,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q1, [r0]
# CHECK: vldrh.u32 q0, [r7] @ encoding: [0x9f,0xfd,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r7]
# CHECK: vldrh.u32 q3, [r7] @ encoding: [0x9f,0xfd,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q3, [r7]
# CHECK: vldrh.u32 q0, [r4, #56] @ encoding: [0x9c,0xfd,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r4, #56]
# CHECK: vldrh.u32 q4, [r4, #56] @ encoding: [0x9c,0xfd,0x1c,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q4, [r4, #56]
# CHECK: vldrh.u32 q0, [r2, #56] @ encoding: [0x9a,0xfd,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r2, #56]
# CHECK: vldrh.u32 q5, [r4, #56]! @ encoding: [0xbc,0xfd,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r4, #56]!
# CHECK: vldrh.u32 q5, [r4, #56]! @ encoding: [0xbc,0xfd,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r4, #56]!
# CHECK: vldrh.u32 q5, [r4], #-26 @ encoding: [0x3c,0xfc,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r4], #-26
# CHECK: vldrh.u32 q5, [r3], #-26 @ encoding: [0x3b,0xfc,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r3], #-26
# CHECK: vldrh.u32 q5, [r6, #-26] @ encoding: [0x1e,0xfd,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r6, #-26]
# CHECK: vldrh.u32 q5, [r6, #-64] @ encoding: [0x1e,0xfd,0x20,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r6, #-64]
# CHECK: vldrh.u32 q5, [r6, #-254] @ encoding: [0x1e,0xfd,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r6, #-254]
# CHECK: vldrh.u32 q5, [r4, #254]! @ encoding: [0xbc,0xfd,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q5, [r4, #254]!
# CHECK: vldrh.s32 q0, [r0] @ encoding: [0x98,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r0]
# CHECK: vldrh.s32 q1, [r0] @ encoding: [0x98,0xed,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q1, [r0]
# CHECK: vldrh.s32 q0, [r7] @ encoding: [0x9f,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r7]
# CHECK: vldrh.s32 q3, [r7] @ encoding: [0x9f,0xed,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q3, [r7]
# CHECK: vldrh.s32 q0, [r4, #56] @ encoding: [0x9c,0xed,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r4, #56]
# CHECK: vldrh.s32 q4, [r4, #56] @ encoding: [0x9c,0xed,0x1c,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q4, [r4, #56]
# CHECK: vldrh.s32 q0, [r2, #56] @ encoding: [0x9a,0xed,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r2, #56]
# CHECK: vldrh.s32 q5, [r4, #56]! @ encoding: [0xbc,0xed,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r4, #56]!
# CHECK: vldrh.s32 q5, [r4, #56]! @ encoding: [0xbc,0xed,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r4, #56]!
# CHECK: vldrh.s32 q5, [r4], #-26 @ encoding: [0x3c,0xec,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r4], #-26
# CHECK: vldrh.s32 q5, [r3], #-26 @ encoding: [0x3b,0xec,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r3], #-26
# CHECK: vldrh.s32 q5, [r6, #-26] @ encoding: [0x1e,0xed,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r6, #-26]
# CHECK: vldrh.s32 q5, [r6, #-64] @ encoding: [0x1e,0xed,0x20,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r6, #-64]
# CHECK: vldrh.s32 q5, [r6, #-254] @ encoding: [0x1e,0xed,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r6, #-254]
# CHECK: vldrh.s32 q5, [r4, #254]! @ encoding: [0xbc,0xed,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q5, [r4, #254]!
# CHECK: vstrh.32 q0, [r0] @ encoding: [0x88,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q0, [r0]
# CHECK: vstrh.32 q1, [r0] @ encoding: [0x88,0xed,0x00,0x2f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q1, [r0]
# CHECK: vstrh.32 q0, [r7] @ encoding: [0x8f,0xed,0x00,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q0, [r7]
# CHECK: vstrh.32 q3, [r7] @ encoding: [0x8f,0xed,0x00,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q3, [r7]
# CHECK: vstrh.32 q0, [r4, #56] @ encoding: [0x8c,0xed,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q0, [r4, #56]
# CHECK: vstrh.32 q4, [r4, #56] @ encoding: [0x8c,0xed,0x1c,0x8f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q4, [r4, #56]
# CHECK: vstrh.32 q0, [r5, #56] @ encoding: [0x8d,0xed,0x1c,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q0, [r5, #56]
# CHECK: vstrh.32 q5, [r4, #56]! @ encoding: [0xac,0xed,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r4, #56]!
# CHECK: vstrh.32 q5, [r4, #56]! @ encoding: [0xac,0xed,0x1c,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r4, #56]!
# CHECK: vstrh.32 q5, [r4], #-26 @ encoding: [0x2c,0xec,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r4], #-26
# CHECK: vstrh.32 q5, [r3], #-26 @ encoding: [0x2b,0xec,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r3], #-26
# CHECK: vstrh.32 q5, [r2, #-26] @ encoding: [0x0a,0xed,0x0d,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r2, #-26]
# CHECK: vstrh.32 q5, [r2, #-64] @ encoding: [0x0a,0xed,0x20,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r2, #-64]
# CHECK: vstrh.32 q5, [r2, #-254] @ encoding: [0x0a,0xed,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r2, #-254]
# CHECK: vstrh.32 q5, [r4, #254]! @ encoding: [0xac,0xed,0x7f,0xaf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q5, [r4, #254]!
# CHECK: vldrw.u32 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r0]
# CHECK: vldrw.u32 q1, [r0] @ encoding: [0x90,0xed,0x00,0x3f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q1, [r0]
# CHECK: vldrw.u32 q0, [r11] @ encoding: [0x9b,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r11]
# CHECK: vldrw.u32 q3, [r11] @ encoding: [0x9b,0xed,0x00,0x7f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q3, [r11]
# CHECK: vldrw.u32 q0, [r4, #56] @ encoding: [0x94,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r4, #56]
# CHECK: vldrw.u32 q4, [r4, #56] @ encoding: [0x94,0xed,0x0e,0x9f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q4, [r4, #56]
# CHECK: vldrw.u32 q0, [r8, #56] @ encoding: [0x98,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r8, #56]
# CHECK: vldrw.u32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [r4, #56]!
# CHECK: vldrw.u32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [r4, #56]!
# CHECK: vldrw.u32 q5, [r4], #-28 @ encoding: [0x34,0xec,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [r4], #-28
# CHECK: vldrw.u32 q5, [r10], #-28 @ encoding: [0x3a,0xec,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [r10], #-28
# CHECK: vldrw.u32 q5, [sp, #-28] @ encoding: [0x1d,0xed,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [sp, #-28]
# CHECK: vldrw.u32 q5, [sp, #-64] @ encoding: [0x1d,0xed,0x10,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [sp, #-64]
# CHECK: vldrw.u32 q5, [sp, #-508] @ encoding: [0x1d,0xed,0x7f,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [sp, #-508]
# CHECK: vldrw.u32 q5, [r4, #508]! @ encoding: [0xb4,0xed,0x7f,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q5, [r4, #508]!
# CHECK: vstrw.32 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r0]
# CHECK: vstrw.32 q1, [r0] @ encoding: [0x80,0xed,0x00,0x3f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q1, [r0]
# CHECK: vstrw.32 q0, [r11] @ encoding: [0x8b,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r11]
# CHECK: vstrw.32 q3, [r11] @ encoding: [0x8b,0xed,0x00,0x7f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q3, [r11]
# CHECK: vstrw.32 q0, [r4, #56] @ encoding: [0x84,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r4, #56]
# CHECK: vstrw.32 q4, [r4, #56] @ encoding: [0x84,0xed,0x0e,0x9f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q4, [r4, #56]
# CHECK: vstrw.32 q0, [r8, #56] @ encoding: [0x88,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r8, #56]
# CHECK: vstrw.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [r4, #56]!
# CHECK: vstrw.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [r4, #56]!
# CHECK: vstrw.32 q5, [r4], #-28 @ encoding: [0x24,0xec,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [r4], #-28
# CHECK: vstrw.32 q5, [r10], #-28 @ encoding: [0x2a,0xec,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [r10], #-28
# CHECK: vstrw.32 q5, [sp, #-28] @ encoding: [0x0d,0xed,0x07,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [sp, #-28]
# CHECK: vstrw.32 q5, [sp, #-64] @ encoding: [0x0d,0xed,0x10,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [sp, #-64]
# CHECK: vstrw.32 q5, [sp, #-508] @ encoding: [0x0d,0xed,0x7f,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [sp, #-508]
# CHECK: vstrw.32 q5, [r4, #508]! @ encoding: [0xa4,0xed,0x7f,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q5, [r4, #508]!
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: invalid operand for instruction
@@ -885,271 +885,271 @@ vstrw.32 q5, [sp, #-3]
vstrw.32 q5, [sp, #512]
# CHECK: vldrb.u8 q0, [r0, q1] @ encoding: [0x90,0xfc,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r0, q1]
# CHECK: vldrb.u8 q3, [r10, q1] @ encoding: [0x9a,0xfc,0x02,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q3, [r10, q1]
# CHECK: vldrb.u16 q0, [r0, q1] @ encoding: [0x90,0xfc,0x82,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r0, q1]
# CHECK: vldrb.u16 q3, [r9, q1] @ encoding: [0x99,0xfc,0x82,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q3, [r9, q1]
# CHECK: vldrb.s16 q0, [r0, q1] @ encoding: [0x90,0xec,0x82,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r0, q1]
# CHECK: vldrb.s16 q3, [sp, q1] @ encoding: [0x9d,0xec,0x82,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q3, [sp, q1]
# CHECK: vldrb.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x02,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r0, q1]
# CHECK: vldrb.u32 q3, [r0, q1] @ encoding: [0x90,0xfc,0x02,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q3, [r0, q1]
# CHECK: vldrb.s32 q0, [r0, q1] @ encoding: [0x90,0xec,0x02,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r0, q1]
# CHECK: vldrb.s32 q3, [r0, q1] @ encoding: [0x90,0xec,0x02,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q3, [r0, q1]
# CHECK: vldrh.u16 q0, [r0, q1] @ encoding: [0x90,0xfc,0x92,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r0, q1]
# CHECK: vldrh.u16 q3, [r0, q1] @ encoding: [0x90,0xfc,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q3, [r0, q1]
# CHECK: vldrh.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x12,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r0, q1]
# CHECK: vldrh.u32 q3, [r0, q1] @ encoding: [0x90,0xfc,0x12,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q3, [r0, q1]
# CHECK: vldrh.s32 q0, [r0, q1] @ encoding: [0x90,0xec,0x12,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r0, q1]
# CHECK: vldrh.s32 q3, [r0, q1] @ encoding: [0x90,0xec,0x12,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q3, [r0, q1]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u8 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u16 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s16 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.u32 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s32 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r0, q0, uxtw #1]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u32 q0, [r0, q0, uxtw #1]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s32 q0, [r0, q0, uxtw #1]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r0, q0, uxtw #2]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [r0, q0]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector offset register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [r0, q0, uxtw #3]
# CHECK: vldrh.u16 q0, [r0, q1, uxtw #1] @ encoding: [0x90,0xfc,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.u16 q0, [r0, q1, uxtw #1]
# CHECK: vldrw.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r0, q1]
# CHECK: vldrw.u32 q3, [r0, q1] @ encoding: [0x90,0xfc,0x42,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q3, [r0, q1]
# CHECK: vldrw.u32 q0, [r0, q1, uxtw #2] @ encoding: [0x90,0xfc,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [r0, q1, uxtw #2]
# CHECK: vldrw.u32 q0, [sp, q1, uxtw #2] @ encoding: [0x9d,0xfc,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [sp, q1, uxtw #2]
# CHECK: vldrd.u64 q0, [r0, q1] @ encoding: [0x90,0xfc,0xd2,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [r0, q1]
# CHECK: vldrd.u64 q3, [r0, q1] @ encoding: [0x90,0xfc,0xd2,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q3, [r0, q1]
# CHECK: vldrd.u64 q0, [r0, q1, uxtw #3] @ encoding: [0x90,0xfc,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [r0, q1, uxtw #3]
# CHECK: vldrd.u64 q0, [sp, q1, uxtw #3] @ encoding: [0x9d,0xfc,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [sp, q1, uxtw #3]
# CHECK: vstrb.8 q0, [r0, q1] @ encoding: [0x80,0xec,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q0, [r0, q1]
# CHECK: vstrb.8 q3, [r10, q1] @ encoding: [0x8a,0xec,0x02,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q3, [r10, q1]
# CHECK: vstrb.8 q3, [r0, q3] @ encoding: [0x80,0xec,0x06,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.8 q3, [r0, q3]
# CHECK: vstrb.16 q0, [r0, q1] @ encoding: [0x80,0xec,0x82,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q0, [r0, q1]
# CHECK: vstrb.16 q3, [sp, q1] @ encoding: [0x8d,0xec,0x82,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q3, [sp, q1]
# CHECK: vstrb.16 q3, [r0, q3] @ encoding: [0x80,0xec,0x86,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.16 q3, [r0, q3]
# CHECK: vstrb.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x02,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q0, [r0, q1]
# CHECK: vstrb.32 q3, [r0, q1] @ encoding: [0x80,0xec,0x02,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q3, [r0, q1]
# CHECK: vstrb.32 q3, [r0, q3] @ encoding: [0x80,0xec,0x06,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.32 q3, [r0, q3]
# CHECK: vstrh.16 q0, [r0, q1] @ encoding: [0x80,0xec,0x92,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r0, q1]
# CHECK: vstrh.16 q3, [r0, q1] @ encoding: [0x80,0xec,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q3, [r0, q1]
# CHECK: vstrh.16 q3, [r0, q3] @ encoding: [0x80,0xec,0x96,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q3, [r0, q3]
# CHECK: vstrh.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x12,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q0, [r0, q1]
# CHECK: vstrh.32 q3, [r0, q1] @ encoding: [0x80,0xec,0x12,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q3, [r0, q1]
# CHECK: vstrh.32 q3, [r0, q3] @ encoding: [0x80,0xec,0x16,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q3, [r0, q3]
# CHECK: vstrh.16 q0, [r0, q1, uxtw #1] @ encoding: [0x80,0xec,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.16 q0, [r0, q1, uxtw #1]
# CHECK: vstrh.32 q3, [r8, q3, uxtw #1] @ encoding: [0x88,0xec,0x17,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.32 q3, [r8, q3, uxtw #1]
# CHECK: vstrw.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r0, q1]
# CHECK: vstrw.32 q3, [r0, q1] @ encoding: [0x80,0xec,0x42,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q3, [r0, q1]
# CHECK: vstrw.32 q3, [r0, q3] @ encoding: [0x80,0xec,0x46,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q3, [r0, q3]
# CHECK: vstrw.32 q0, [r0, q1, uxtw #2] @ encoding: [0x80,0xec,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [r0, q1, uxtw #2]
# CHECK: vstrw.32 q0, [sp, q1, uxtw #2] @ encoding: [0x8d,0xec,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [sp, q1, uxtw #2]
# CHECK: vstrd.64 q0, [r0, q1] @ encoding: [0x80,0xec,0xd2,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q0, [r0, q1]
# CHECK: vstrd.64 q3, [r0, q1] @ encoding: [0x80,0xec,0xd2,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q3, [r0, q1]
# CHECK: vstrd.64 q3, [r0, q3] @ encoding: [0x80,0xec,0xd6,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q3, [r0, q3]
# CHECK: vstrd.64 q0, [r0, q1, uxtw #3] @ encoding: [0x80,0xec,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q0, [r0, q1, uxtw #3]
# CHECK: vstrd.64 q0, [sp, q1, uxtw #3] @ encoding: [0x8d,0xec,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q0, [sp, q1, uxtw #3]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: operand must be a register in range [q0, q7]
@@ -1189,79 +1189,79 @@ vstrh.16 q0, [r0, q1, uxtw #2]
vstrb.32 q0, [r11, q1, uxtw #1]
# CHECK: vldrw.u32 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q0, [q1]
# CHECK: vldrw.u32 q7, [q1] @ encoding: [0x92,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1]
# CHECK: vldrw.u32 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1]!
# CHECK: vldrw.u32 q7, [q1, #4] @ encoding: [0x92,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #4]
# CHECK: vldrw.u32 q7, [q1, #-4] @ encoding: [0x12,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #-4]
# CHECK: vldrw.u32 q7, [q1, #508] @ encoding: [0x92,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #508]
# CHECK: vldrw.u32 q7, [q1, #-508] @ encoding: [0x12,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #-508]
# CHECK: vldrw.u32 q7, [q1, #264] @ encoding: [0x92,0xfd,0x42,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #264]
# CHECK: vldrw.u32 q7, [q1, #4]! @ encoding: [0xb2,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #4]!
# CHECK: vstrw.32 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q0, [q1]
# CHECK: vstrw.32 q1, [q1] @ encoding: [0x82,0xfd,0x00,0x3e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q1, [q1]
# CHECK: vstrw.32 q7, [q1] @ encoding: [0x82,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1]
# CHECK: vstrw.32 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1]!
# CHECK: vstrw.32 q7, [q7] @ encoding: [0x8e,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q7]
# CHECK: vstrw.32 q7, [q1, #4] @ encoding: [0x82,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1, #4]
# CHECK: vstrw.32 q7, [q1, #-4] @ encoding: [0x02,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1, #-4]
# CHECK: vstrw.32 q7, [q1, #508] @ encoding: [0x82,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1, #508]
# CHECK: vstrw.32 q7, [q1, #-508] @ encoding: [0x02,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1, #-508]
# CHECK: vstrw.32 q7, [q1, #264]! @ encoding: [0xa2,0xfd,0x42,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.32 q7, [q1, #264]!
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: operand must be a register in range [q0, q7]
@@ -1277,103 +1277,103 @@ vstrw.32 q4, [q1, #3]!
vldrw.u32 q7, [q1, #512]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector pointer register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q1, [q1, #264]
# CHECK: vldrd.u64 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q0, [q1]
# CHECK: vldrd.u64 q7, [q1] @ encoding: [0x92,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1]
# CHECK: vldrd.u64 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1]!
# CHECK: vldrd.u64 q7, [q1, #8] @ encoding: [0x92,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #8]
# CHECK: vldrd.u64 q7, [q1, #-8] @ encoding: [0x12,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #-8]
# CHECK: vldrd.u64 q7, [q1, #1016] @ encoding: [0x92,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #1016]
# CHECK: vldrd.u64 q7, [q1, #-1016] @ encoding: [0x12,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #-1016]
# CHECK: vldrd.u64 q7, [q1, #264] @ encoding: [0x92,0xfd,0x21,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #264]
# CHECK: vldrd.u64 q7, [q1, #624] @ encoding: [0x92,0xfd,0x4e,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #624]
# CHECK: vldrd.u64 q7, [q1, #264] @ encoding: [0x92,0xfd,0x21,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #264]
# CHECK: vldrd.u64 q7, [q1, #-1016]! @ encoding: [0x32,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q7, [q1, #-1016]!
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: destination vector register and vector pointer register can't be identical
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.u64 q6, [q6]
# CHECK: vstrd.64 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q0, [q1]
# CHECK: vstrd.64 q1, [q1] @ encoding: [0x82,0xfd,0x00,0x3f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q1, [q1]
# CHECK: vstrd.64 q7, [q1] @ encoding: [0x82,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1]
# CHECK: vstrd.64 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1]!
# CHECK: vstrd.64 q7, [q7] @ encoding: [0x8e,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q7]
# CHECK: vstrd.64 q7, [q1, #8] @ encoding: [0x82,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #8]
# CHECK: vstrd.64 q7, [q1, #-8]! @ encoding: [0x22,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #-8]!
# CHECK: vstrd.64 q7, [q1, #1016] @ encoding: [0x82,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #1016]
# CHECK: vstrd.64 q7, [q1, #-1016] @ encoding: [0x02,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #-1016]
# CHECK: vstrd.64 q7, [q1, #264] @ encoding: [0x82,0xfd,0x21,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #264]
# CHECK: vstrd.64 q7, [q1, #624] @ encoding: [0x82,0xfd,0x4e,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #624]
# CHECK: vstrd.64 q7, [q1, #264] @ encoding: [0x82,0xfd,0x21,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.64 q7, [q1, #264]
# ERROR: [[@LINE+2]]:{{[0-9]+}}: {{error|note}}: operand must be a register in range [q0, q7]
@@ -1393,547 +1393,547 @@ vstrd.64 q4, [q1, #3]
vstrd.64 q4, [q1, #4]
# CHECK: vldrb.u8 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s8 q0, [r0]
# CHECK: vldrb.u8 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.8 q0, [r0]
# CHECK: vldrb.u8 q0, [r8, #56] @ encoding: [0x98,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s8 q0, [r8, #56]
# CHECK: vldrb.u8 q0, [r8, #56] @ encoding: [0x98,0xed,0x38,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.8 q0, [r8, #56]
# CHECK: vldrb.u8 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s8 q5, [r4, #56]!
# CHECK: vldrb.u8 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.8 q5, [r4, #56]!
# CHECK: vstrb.8 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.u8 q0, [r0]
# CHECK: vstrb.8 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.s8 q0, [r0]
# CHECK: vstrb.8 q4, [r4, #56] @ encoding: [0x84,0xed,0x38,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.u8 q4, [r4, #56]
# CHECK: vstrb.8 q4, [r4, #56] @ encoding: [0x84,0xed,0x38,0x9e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.s8 q4, [r4, #56]
# CHECK: vstrb.8 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.u8 q5, [r4, #56]!
# CHECK: vstrb.8 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x38,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.s8 q5, [r4, #56]!
# CHECK: vldrh.u16 q0, [r0] @ encoding: [0x90,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s16 q0, [r0]
# CHECK: vldrh.u16 q0, [r0] @ encoding: [0x90,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.f16 q0, [r0]
# CHECK: vldrh.u16 q0, [r0] @ encoding: [0x90,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.16 q0, [r0]
# CHECK: vldrh.u16 q0, [r4, #56] @ encoding: [0x94,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s16 q0, [r4, #56]
# CHECK: vldrh.u16 q0, [r4, #56] @ encoding: [0x94,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.f16 q0, [r4, #56]
# CHECK: vldrh.u16 q0, [r4, #56] @ encoding: [0x94,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.16 q0, [r4, #56]
# CHECK: vldrh.u16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s16 q5, [r4, #56]!
# CHECK: vldrh.u16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.f16 q5, [r4, #56]!
# CHECK: vldrh.u16 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.16 q5, [r4, #56]!
# CHECK: vstrh.16 q0, [r0] @ encoding: [0x80,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.u16 q0, [r0]
# CHECK: vstrh.16 q0, [r0] @ encoding: [0x80,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.s16 q0, [r0]
# CHECK: vstrh.16 q0, [r0] @ encoding: [0x80,0xed,0x80,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.f16 q0, [r0]
# CHECK: vstrh.16 q0, [r4, #56] @ encoding: [0x84,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.u16 q0, [r4, #56]
# CHECK: vstrh.16 q0, [r4, #56] @ encoding: [0x84,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.s16 q0, [r4, #56]
# CHECK: vstrh.16 q0, [r4, #56] @ encoding: [0x84,0xed,0x9c,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.f16 q0, [r4, #56]
# CHECK: vstrh.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.u16 q5, [r4, #56]!
# CHECK: vstrh.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.s16 q5, [r4, #56]!
# CHECK: vstrh.16 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x9c,0xbe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.f16 q5, [r4, #56]!
# CHECK: vldrw.u32 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q0, [r0]
# CHECK: vldrw.u32 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q0, [r0]
# CHECK: vldrw.u32 q0, [r0] @ encoding: [0x90,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q0, [r0]
# CHECK: vldrw.u32 q0, [r4, #56] @ encoding: [0x94,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q0, [r4, #56]
# CHECK: vldrw.u32 q0, [r4, #56] @ encoding: [0x94,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q0, [r4, #56]
# CHECK: vldrw.u32 q0, [r4, #56] @ encoding: [0x94,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q0, [r4, #56]
# CHECK: vldrw.u32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q5, [r4, #56]!
# CHECK: vldrw.u32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q5, [r4, #56]!
# CHECK: vldrw.u32 q5, [r4, #56]! @ encoding: [0xb4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q5, [r4, #56]!
# CHECK: vstrw.32 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q0, [r0]
# CHECK: vstrw.32 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q0, [r0]
# CHECK: vstrw.32 q0, [r0] @ encoding: [0x80,0xed,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q0, [r0]
# CHECK: vstrw.32 q0, [r4, #56] @ encoding: [0x84,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q0, [r4, #56]
# CHECK: vstrw.32 q0, [r4, #56] @ encoding: [0x84,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q0, [r4, #56]
# CHECK: vstrw.32 q0, [r4, #56] @ encoding: [0x84,0xed,0x0e,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q0, [r4, #56]
# CHECK: vstrw.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q5, [r4, #56]!
# CHECK: vstrw.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q5, [r4, #56]!
# CHECK: vstrw.32 q5, [r4, #56]! @ encoding: [0xa4,0xed,0x0e,0xbf]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q5, [r4, #56]!
# CHECK: vldrb.u8 q0, [r0, q1] @ encoding: [0x90,0xfc,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.s8 q0, [r0, q1]
# CHECK: vldrb.u8 q0, [r0, q1] @ encoding: [0x90,0xfc,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrb.8 q0, [r0, q1]
# CHECK: vldrh.u16 q3, [r0, q1] @ encoding: [0x90,0xfc,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s16 q3, [r0, q1]
# CHECK: vldrh.u16 q3, [r0, q1] @ encoding: [0x90,0xfc,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.f16 q3, [r0, q1]
# CHECK: vldrh.u16 q3, [r0, q1] @ encoding: [0x90,0xfc,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.16 q3, [r0, q1]
# CHECK: vldrh.u16 q0, [r0, q1, uxtw #1] @ encoding: [0x90,0xfc,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.s16 q0, [r0, q1, uxtw #1]
# CHECK: vldrh.u16 q0, [r0, q1, uxtw #1] @ encoding: [0x90,0xfc,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.f16 q0, [r0, q1, uxtw #1]
# CHECK: vldrh.u16 q0, [r0, q1, uxtw #1] @ encoding: [0x90,0xfc,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrh.16 q0, [r0, q1, uxtw #1]
# CHECK: vldrw.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q0, [r0, q1]
# CHECK: vldrw.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q0, [r0, q1]
# CHECK: vldrw.u32 q0, [r0, q1] @ encoding: [0x90,0xfc,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q0, [r0, q1]
# CHECK: vldrw.u32 q0, [r0, q1, uxtw #2] @ encoding: [0x90,0xfc,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q0, [r0, q1, uxtw #2]
# CHECK: vldrw.u32 q0, [r0, q1, uxtw #2] @ encoding: [0x90,0xfc,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q0, [r0, q1, uxtw #2]
# CHECK: vldrw.u32 q0, [r0, q1, uxtw #2] @ encoding: [0x90,0xfc,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q0, [r0, q1, uxtw #2]
# CHECK: vldrd.u64 q0, [r0, q1] @ encoding: [0x90,0xfc,0xd2,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q0, [r0, q1]
# CHECK: vldrd.u64 q0, [r0, q1] @ encoding: [0x90,0xfc,0xd2,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q0, [r0, q1]
# CHECK: vldrd.u64 q0, [r0, q1] @ encoding: [0x90,0xfc,0xd2,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q0, [r0, q1]
# CHECK: vldrd.u64 q0, [r0, q1, uxtw #3] @ encoding: [0x90,0xfc,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q0, [r0, q1, uxtw #3]
# CHECK: vldrd.u64 q0, [r0, q1, uxtw #3] @ encoding: [0x90,0xfc,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q0, [r0, q1, uxtw #3]
# CHECK: vldrd.u64 q0, [r0, q1, uxtw #3] @ encoding: [0x90,0xfc,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q0, [r0, q1, uxtw #3]
# CHECK: vstrb.8 q0, [r0, q1] @ encoding: [0x80,0xec,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.u8 q0, [r0, q1]
# CHECK: vstrb.8 q0, [r0, q1] @ encoding: [0x80,0xec,0x02,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrb.s8 q0, [r0, q1]
# CHECK: vstrh.16 q3, [r0, q1] @ encoding: [0x80,0xec,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.u16 q3, [r0, q1]
# CHECK: vstrh.16 q3, [r0, q1] @ encoding: [0x80,0xec,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.s16 q3, [r0, q1]
# CHECK: vstrh.16 q3, [r0, q1] @ encoding: [0x80,0xec,0x92,0x6e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.f16 q3, [r0, q1]
# CHECK: vstrh.16 q0, [r0, q1, uxtw #1] @ encoding: [0x80,0xec,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.u16 q0, [r0, q1, uxtw #1]
# CHECK: vstrh.16 q0, [r0, q1, uxtw #1] @ encoding: [0x80,0xec,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.s16 q0, [r0, q1, uxtw #1]
# CHECK: vstrh.16 q0, [r0, q1, uxtw #1] @ encoding: [0x80,0xec,0x93,0x0e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrh.f16 q0, [r0, q1, uxtw #1]
# CHECK: vstrw.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q0, [r0, q1]
# CHECK: vstrw.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q0, [r0, q1]
# CHECK: vstrw.32 q0, [r0, q1] @ encoding: [0x80,0xec,0x42,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q0, [r0, q1]
# CHECK: vstrw.32 q0, [r0, q1, uxtw #2] @ encoding: [0x80,0xec,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q0, [r0, q1, uxtw #2]
# CHECK: vstrw.32 q0, [r0, q1, uxtw #2] @ encoding: [0x80,0xec,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q0, [r0, q1, uxtw #2]
# CHECK: vstrw.32 q0, [r0, q1, uxtw #2] @ encoding: [0x80,0xec,0x43,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q0, [r0, q1, uxtw #2]
# CHECK: vstrd.64 q3, [r0, q1] @ encoding: [0x80,0xec,0xd2,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q3, [r0, q1]
# CHECK: vstrd.64 q3, [r0, q1] @ encoding: [0x80,0xec,0xd2,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q3, [r0, q1]
# CHECK: vstrd.64 q3, [r0, q1] @ encoding: [0x80,0xec,0xd2,0x6f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q3, [r0, q1]
# CHECK: vstrd.64 q0, [r0, q1, uxtw #3] @ encoding: [0x80,0xec,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q0, [r0, q1, uxtw #3]
# CHECK: vstrd.64 q0, [r0, q1, uxtw #3] @ encoding: [0x80,0xec,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q0, [r0, q1, uxtw #3]
# CHECK: vstrd.64 q0, [r0, q1, uxtw #3] @ encoding: [0x80,0xec,0xd3,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q0, [r0, q1, uxtw #3]
# CHECK: vldrw.u32 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q0, [q1]
# CHECK: vldrw.u32 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q0, [q1]
# CHECK: vldrw.u32 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q0, [q1]
# CHECK: vldrw.u32 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q7, [q1]!
# CHECK: vldrw.u32 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q7, [q1]!
# CHECK: vldrw.u32 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q7, [q1]!
# CHECK: vldrw.u32 q7, [q1, #4] @ encoding: [0x92,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q7, [q1, #4]
# CHECK: vldrw.u32 q7, [q1, #4] @ encoding: [0x92,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q7, [q1, #4]
# CHECK: vldrw.u32 q7, [q1, #4] @ encoding: [0x92,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.32 q7, [q1, #4]
# CHECK: vldrw.u32 q7, [q1, #4]! @ encoding: [0xb2,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.s32 q7, [q1, #4]!
# CHECK: vldrw.u32 q7, [q1, #4]! @ encoding: [0xb2,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.f32 q7, [q1, #4]!
# CHECK: vldrw.u32 q7, [q1, #4]! @ encoding: [0xb2,0xfd,0x01,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrw.u32 q7, [q1, #4]!
# CHECK: vstrw.32 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q0, [q1]
# CHECK: vstrw.32 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q0, [q1]
# CHECK: vstrw.32 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1e]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q0, [q1]
# CHECK: vstrw.32 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q7, [q1]!
# CHECK: vstrw.32 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q7, [q1]!
# CHECK: vstrw.32 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q7, [q1]!
# CHECK: vstrw.32 q7, [q1, #508] @ encoding: [0x82,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q7, [q1, #508]
# CHECK: vstrw.32 q7, [q1, #508] @ encoding: [0x82,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q7, [q1, #508]
# CHECK: vstrw.32 q7, [q1, #508] @ encoding: [0x82,0xfd,0x7f,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q7, [q1, #508]
# CHECK: vstrw.32 q7, [q1, #264]! @ encoding: [0xa2,0xfd,0x42,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.u32 q7, [q1, #264]!
# CHECK: vstrw.32 q7, [q1, #264]! @ encoding: [0xa2,0xfd,0x42,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.s32 q7, [q1, #264]!
# CHECK: vstrw.32 q7, [q1, #264]! @ encoding: [0xa2,0xfd,0x42,0xfe]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrw.f32 q7, [q1, #264]!
# CHECK: vldrd.u64 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q0, [q1]
# CHECK: vldrd.u64 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q0, [q1]
# CHECK: vldrd.u64 q0, [q1] @ encoding: [0x92,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q0, [q1]
# CHECK: vldrd.u64 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q7, [q1]!
# CHECK: vldrd.u64 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q7, [q1]!
# CHECK: vldrd.u64 q7, [q1]! @ encoding: [0xb2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q7, [q1]!
# CHECK: vldrd.u64 q7, [q1, #8] @ encoding: [0x92,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q7, [q1, #8]
# CHECK: vldrd.u64 q7, [q1, #8] @ encoding: [0x92,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q7, [q1, #8]
# CHECK: vldrd.u64 q7, [q1, #8] @ encoding: [0x92,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q7, [q1, #8]
# CHECK: vldrd.u64 q7, [q1, #-1016]! @ encoding: [0x32,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.s64 q7, [q1, #-1016]!
# CHECK: vldrd.u64 q7, [q1, #-1016]! @ encoding: [0x32,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.f64 q7, [q1, #-1016]!
# CHECK: vldrd.u64 q7, [q1, #-1016]! @ encoding: [0x32,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vldrd.64 q7, [q1, #-1016]!
# CHECK: vstrd.64 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q0, [q1]
# CHECK: vstrd.64 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q0, [q1]
# CHECK: vstrd.64 q0, [q1] @ encoding: [0x82,0xfd,0x00,0x1f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q0, [q1]
# CHECK: vstrd.64 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q7, [q1]!
# CHECK: vstrd.64 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q7, [q1]!
# CHECK: vstrd.64 q7, [q1]! @ encoding: [0xa2,0xfd,0x00,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q7, [q1]!
# CHECK: vstrd.64 q7, [q1, #1016] @ encoding: [0x82,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q7, [q1, #1016]
# CHECK: vstrd.64 q7, [q1, #1016] @ encoding: [0x82,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q7, [q1, #1016]
# CHECK: vstrd.64 q7, [q1, #1016] @ encoding: [0x82,0xfd,0x7f,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q7, [q1, #1016]
# CHECK: vstrd.64 q7, [q1, #-8]! @ encoding: [0x22,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.u64 q7, [q1, #-8]!
# CHECK: vstrd.64 q7, [q1, #-8]! @ encoding: [0x22,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.s64 q7, [q1, #-8]!
# CHECK: vstrd.64 q7, [q1, #-8]! @ encoding: [0x22,0xfd,0x01,0xff]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vstrd.f64 q7, [q1, #-8]!
vpste
diff --git a/llvm/test/MC/ARM/mve-misc.s b/llvm/test/MC/ARM/mve-misc.s
index 7f9a2c56c2d82b..251a77b4710dcd 100644
--- a/llvm/test/MC/ARM/mve-misc.s
+++ b/llvm/test/MC/ARM/mve-misc.s
@@ -7,11 +7,11 @@
# RUN: FileCheck --check-prefix=ERROR-NOMVE < %t %s
# CHECK: vpsel q0, q5, q2 @ encoding: [0x3b,0xfe,0x05,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vpsel q0, q5, q2
# CHECK: vpnot @ encoding: [0x31,0xfe,0x4d,0x0f]
-# ERROR-NOMVE: [[@LINE+1]]:1: error: invalid instruction
+# ERROR-NOMVE: [[@LINE+1]]:1: error: instruction requires: mve
vpnot
# CHECK: wlstp.8 lr, r0, #1668 @ encoding: [0x00,0xf0,0x43,0xc3]
diff --git a/llvm/test/MC/ARM/neon-complex.s b/llvm/test/MC/ARM/neon-complex.s
index 0d428b596c94c0..6054a08dc82e89 100644
--- a/llvm/test/MC/ARM/neon-complex.s
+++ b/llvm/test/MC/ARM/neon-complex.s
@@ -29,8 +29,10 @@
// FP16-ARM: vcmla.f16 q0, q1, q2, #0 @ encoding: [0x44,0x08,0x22,0xfc]
// FP16-THUMB: vcmla.f16 q0, q1, q2, #0 @ encoding: [0x22,0xfc,0x44,0x08]
// NO-FP16-STDERR: :[[@LINE-3]]:{{[0-9]*}}: note: instruction requires: full half-float
-// V82A: :[[@LINE-4]]:{{[0-9]*}}: error: instruction requires: armv8.3a
-// NO-NEON_STDERR: :[[@LINE-5]]:{{[0-9]*}}: error: instruction requires: NEON
+// V82A: :[[@LINE-4]]:{{[0-9]*}}: error: invalid instruction, any one of the following would fix this:
+// V82A: :[[@LINE-5]]:{{[0-9]*}}: note: instruction requires: mve.fp
+// V82A: :[[@LINE-6]]:{{[0-9]*}}: note: instruction requires: armv8.3a
+// NO-NEON_STDERR: :[[@LINE-7]]:{{[0-9]*}}: error: instruction requires: NEON
vcmla.f32 d0, d1, d2, #0
// ARM: vcmla.f32 d0, d1, d2, #0 @ encoding: [0x02,0x08,0x31,0xfc]
// THUMB: vcmla.f32 d0, d1, d2, #0 @ encoding: [0x31,0xfc,0x02,0x08]
@@ -39,8 +41,10 @@
vcmla.f32 q0, q1, q2, #0
// ARM: vcmla.f32 q0, q1, q2, #0 @ encoding: [0x44,0x08,0x32,0xfc]
// THUMB: vcmla.f32 q0, q1, q2, #0 @ encoding: [0x32,0xfc,0x44,0x08]
-// V82A: :[[@LINE-3]]:{{[0-9]*}}: error: instruction requires: armv8.3a
-// NO-NEON_STDERR: :[[@LINE-4]]:{{[0-9]*}}: error: instruction requires: NEON
+// V82A: :[[@LINE-3]]:{{[0-9]*}}: error: invalid instruction, any one of the following would fix this:
+// V82A: :[[@LINE-4]]:{{[0-9]*}}: note: instruction requires: mve.fp
+// V82A: :[[@LINE-5]]:{{[0-9]*}}: note: instruction requires: armv8.3a
+// NO-NEON_STDERR: :[[@LINE-6]]:{{[0-9]*}}: error: instruction requires: NEON
// Valid rotations
vcmla.f32 d0, d1, d2, #90
@@ -83,8 +87,10 @@
// FP16-ARM: vcadd.f16 q0, q1, q2, #90 @ encoding: [0x44,0x08,0x82,0xfc]
// FP16-THUMB: vcadd.f16 q0, q1, q2, #90 @ encoding: [0x82,0xfc,0x44,0x08]
// NO-FP16-STDERR: :[[@LINE-3]]:{{[0-9]*}}: note: instruction requires: full half-float
-// V82A: :[[@LINE-4]]:{{[0-9]*}}: error: instruction requires: armv8.3a
-// NO-NEON_STDERR: :[[@LINE-5]]:{{[0-9]*}}: error: instruction requires: NEON
+// V82A: :[[@LINE-4]]:{{[0-9]*}}: error: invalid instruction, any one of the following would fix this:
+// V82A: :[[@LINE-5]]:{{[0-9]*}}: note: instruction requires: mve.fp
+// V82A: :[[@LINE-6]]:{{[0-9]*}}: note: instruction requires: armv8.3a
+// NO-NEON_STDERR: :[[@LINE-7]]:{{[0-9]*}}: error: instruction requires: NEON
vcadd.f32 d0, d1, d2, #90
// ARM: vcadd.f32 d0, d1, d2, #90 @ encoding: [0x02,0x08,0x91,0xfc]
// THUMB: vcadd.f32 d0, d1, d2, #90 @ encoding: [0x91,0xfc,0x02,0x08]
@@ -93,8 +99,10 @@
vcadd.f32 q0, q1, q2, #90
// ARM: vcadd.f32 q0, q1, q2, #90 @ encoding: [0x44,0x08,0x92,0xfc]
// THUMB: vcadd.f32 q0, q1, q2, #90 @ encoding: [0x92,0xfc,0x44,0x08]
-// V82A: :[[@LINE-3]]:{{[0-9]*}}: error: instruction requires: armv8.3a
-// NO-NEON_STDERR: :[[@LINE-4]]:{{[0-9]*}}: error: instruction requires: NEON
+// V82A: :[[@LINE-3]]:{{[0-9]*}}: error: invalid instruction, any one of the following would fix this:
+// V82A: :[[@LINE-4]]:{{[0-9]*}}: note: instruction requires: mve.fp
+// V82A: :[[@LINE-5]]:{{[0-9]*}}: note: instruction requires: armv8.3a
+// NO-NEON_STDERR: :[[@LINE-6]]:{{[0-9]*}}: error: instruction requires: NEON
// Valid rotations
vcadd.f32 d0, d1, d2, #270
diff --git a/llvm/test/MC/ARM/no-mve.s b/llvm/test/MC/ARM/no-mve.s
index 668db402dc66dd..2435ced45a370e 100644
--- a/llvm/test/MC/ARM/no-mve.s
+++ b/llvm/test/MC/ARM/no-mve.s
@@ -4,13 +4,13 @@
# RUN: FileCheck --check-prefix=CHECK-MVE < %t %s
# CHECK-MVE: instruction requires: mve.fp
-# CHECK: invalid instruction
+# CHECK: instruction requires: mve.fp
vcadd.f32 q1, q2, q3, #270
# CHECK-MVE: instruction requires: mve.fp
-# CHECK: invalid instruction
+# CHECK: instruction requires: mve.fp
vadd.f32 q1, q2, q3
# CHECK-MVE: vadd.i16 q1, q2, q3 @ encoding: [0x14,0xef,0x46,0x28]
-# CHECK: invalid instruction
+# CHECK: instruction requires: mve
vadd.i16 q1, q2, q3
diff --git a/llvm/test/MC/ARM/vfp4.s b/llvm/test/MC/ARM/vfp4.s
index 37d03bb53de8e9..f3bc5750f43128 100644
--- a/llvm/test/MC/ARM/vfp4.s
+++ b/llvm/test/MC/ARM/vfp4.s
@@ -23,7 +23,7 @@ vfma.f32 d16, d18, d17
@ ARM: vfma.f32 q2, q4, q0 @ encoding: [0x50,0x4c,0x08,0xf2]
@ THUMB: vfma.f32 q2, q4, q0 @ encoding: [0x08,0xef,0x50,0x4c]
-@ THUMB_V7EM-ERRORS: error: invalid instruction
+@ THUMB_V7EM-ERRORS: error: instruction requires: mve.fp
@ THUMB_V7EM-ERRORS-NEXT: vfma.f32 q2, q4, q0
vfma.f32 q2, q4, q0
@@ -57,7 +57,7 @@ vfms.f32 d16, d18, d17
@ ARM: vfms.f32 q2, q4, q0 @ encoding: [0x50,0x4c,0x28,0xf2]
@ THUMB: vfms.f32 q2, q4, q0 @ encoding: [0x28,0xef,0x50,0x4c]
-@ THUMB_V7EM-ERRORS: error: invalid instruction
+@ THUMB_V7EM-ERRORS: error: instruction requires: mve.fp
@ THUMB_V7EM-ERRORS-NEXT: vfms.f32 q2, q4, q0
vfms.f32 q2, q4, q0
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index afadd25dcc52d3..c52898473f5ffc 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -217,19 +217,6 @@ struct ClassInfo {
/// Is this operand optional and not always required.
bool IsOptional;
- /// OptionalShouldOffsetCustomParsers - Only used if IsOptional is true.
- /// Specifies if this optional operand should be assumed to be
- /// present for the sake of determining if a custom parser should be
- /// used, which is determined by the mnemonic and operand index.
- /// If true, then the parser will always assume a value representing this
- /// operand will always be present when parsing and thus the custom parser
- /// will be applied to later tokens in the input stream.
- /// If false, then the parse will assume it will not be present in the operand
- /// vector and therefore will apply the custom parser earlier.
- /// For example of usage, see ARMAsmParser and the CondCode operands which are
- /// always present at parse time.
- bool OptionalShouldOffsetCustomParsers;
-
/// DefaultMethod - The name of the method that returns the default operand
/// for optional operand
std::string DefaultMethod;
@@ -1464,11 +1451,6 @@ void AsmMatcherInfo::buildOperandClasses() {
if (BitInit *BI = dyn_cast<BitInit>(IsOptional))
CI->IsOptional = BI->getValue();
- Init *OptionalShouldOffsetCustomParsers =
- Rec->getValueInit("OptionalShouldOffsetCustomParsers");
- if (BitInit *BI = dyn_cast<BitInit>(OptionalShouldOffsetCustomParsers))
- CI->OptionalShouldOffsetCustomParsers = BI->getValue();
-
// Get or construct the default method name.
Init *DMName = Rec->getValueInit("DefaultMethod");
if (StringInit *SI = dyn_cast<StringInit>(DMName)) {
@@ -1510,7 +1492,7 @@ void AsmMatcherInfo::buildOperandMatchInfo() {
OperandMask |= maskTrailingOnes<unsigned>(NumOptionalOps + 1)
<< (i - NumOptionalOps);
}
- if (Op.Class->IsOptional && Op.Class->OptionalShouldOffsetCustomParsers)
+ if (Op.Class->IsOptional)
++NumOptionalOps;
}
>From 61dbf82e08a15c2523d41f1b04b235fef7847366 Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Wed, 6 Mar 2024 13:40:02 +0000
Subject: [PATCH 5/6] Some smaller changes addressing comments. Additionally
updated some definitions to fix MCA tests.
---
llvm/lib/Target/ARM/ARMInstrFormats.td | 1 -
llvm/lib/Target/ARM/ARMInstrThumb.td | 4 ++--
llvm/lib/Target/ARM/ARMInstrThumb2.td | 8 ++++----
.../lib/Target/ARM/AsmParser/ARMAsmParser.cpp | 20 ++++++++-----------
.../ARM/cortex-a57-basic-instructions.s | 2 +-
5 files changed, 15 insertions(+), 20 deletions(-)
diff --git a/llvm/lib/Target/ARM/ARMInstrFormats.td b/llvm/lib/Target/ARM/ARMInstrFormats.td
index d34f4d8ba037b2..1edac95c71aac0 100644
--- a/llvm/lib/Target/ARM/ARMInstrFormats.td
+++ b/llvm/lib/Target/ARM/ARMInstrFormats.td
@@ -157,7 +157,6 @@ def iflags_op : Operand<i32> {
// register whose default is 0 (no register).
def CondCodeOperand : AsmOperandClass {
let Name = "CondCode";
- let PredicateMethod = "isCondCode";
let DefaultMethod = "defaultCondCodeOp";
let IsOptional = true;
}
diff --git a/llvm/lib/Target/ARM/ARMInstrThumb.td b/llvm/lib/Target/ARM/ARMInstrThumb.td
index be0ca964d3f912..e7f4059935138a 100644
--- a/llvm/lib/Target/ARM/ARMInstrThumb.td
+++ b/llvm/lib/Target/ARM/ARMInstrThumb.td
@@ -1210,7 +1210,7 @@ def tMOVi8 : T1sI<(outs tGPR:$Rd), (ins imm0_255_expr:$imm8), IIC_iMOVi,
// Because we have an explicit tMOVSr below, we need an alias to handle
// the immediate "movs" form here. Blech.
def : tInstAlias <"movs $Rdn, $imm8",
- (tMOVi8 tGPR:$Rdn, CPSR, imm0_255_expr:$imm8, 14, 0)>;
+ (tMOVi8 tGPR:$Rdn, CPSR, imm0_255_expr:$imm8, 14, zero_reg)>;
// A7-73: MOV(2) - mov setting flag.
@@ -1768,7 +1768,7 @@ let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
// In Thumb1, "nop" is encoded as a "mov r8, r8". Technically, the bf00
// encoding is available on ARMv6K, but we don't differentiate that finely.
-def : InstAlias<"nop", (tMOVr R8, R8, 14, 0), 0>, Requires<[IsThumb, IsThumb1Only]>;
+def : InstAlias<"nop", (tMOVr R8, R8, 14, zero_reg), 0>, Requires<[IsThumb, IsThumb1Only]>;
// "neg" is and alias for "rsb rd, rn, #0"
diff --git a/llvm/lib/Target/ARM/ARMInstrThumb2.td b/llvm/lib/Target/ARM/ARMInstrThumb2.td
index 70686bce2280d1..f227d68deeb8bc 100644
--- a/llvm/lib/Target/ARM/ARMInstrThumb2.td
+++ b/llvm/lib/Target/ARM/ARMInstrThumb2.td
@@ -5096,10 +5096,10 @@ def : InstAlias<"isb${p}.w\t$opt", (t2ISB instsyncb_opt:$opt, pred:$p), 0>, Requ
def : InstAlias<"isb${p}", (t2ISB 0xf, pred:$p), 0>, Requires<[HasDB]>;
def : InstAlias<"isb${p}.w", (t2ISB 0xf, pred:$p), 0>, Requires<[HasDB]>;
-// Non-predicable aliases of a predicable DSB: the predicate is (14, 0) where
-// 14 = AL (always execute) and 0 = "instruction doesn't read the CPSR".
-def : InstAlias<"ssbb", (t2DSB 0x0, 14, 0), 1>, Requires<[HasDB, IsThumb2]>;
-def : InstAlias<"pssbb", (t2DSB 0x4, 14, 0), 1>, Requires<[HasDB, IsThumb2]>;
+// Non-predicable aliases of a predicable DSB: the predicate is (14, zero_reg) where
+// 14 = AL (always execute) and zero_reg = "instruction doesn't read the CPSR".
+def : InstAlias<"ssbb", (t2DSB 0x0, 14, zero_reg), 1>, Requires<[HasDB, IsThumb2]>;
+def : InstAlias<"pssbb", (t2DSB 0x4, 14, zero_reg), 1>, Requires<[HasDB, IsThumb2]>;
// Armv8-R 'Data Full Barrier'
def : InstAlias<"dfb${p}", (t2DSB 0xc, pred:$p), 1>, Requires<[HasDFB]>;
diff --git a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
index 789a4d9de7bedb..35ec6f250f98e9 100644
--- a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
+++ b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
@@ -6173,11 +6173,7 @@ ParseStatus ARMAsmParser::parseFPImm(OperandVector &Operands) {
if (!(isVmovf || isFconst))
return ParseStatus::NoMatch;
- if (Parser.getTok().getKind() == llvm::AsmToken::Hash ||
- Parser.getTok().getKind() == llvm::AsmToken::Dollar)
- Parser.Lex(); // Eat '#' or '$'.
- else
- return ParseStatus::NoMatch;
+ Parser.Lex(); // Eat '#' or '$'.
// Handle negation, as that still comes through as a separate token.
bool isNegative = false;
@@ -7098,7 +7094,7 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
// Add the carry setting operand, if necessary.
- if (CanAcceptCarrySet && CarrySetting != 0) {
+ if (CanAcceptCarrySet && CarrySetting) {
SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
Loc));
@@ -7114,7 +7110,7 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
// Add the VPT predication code operand, if necessary.
// Dont add in certain cases of VCVT as this needs to be disambiguated
- // after operand parsing
+ // after operand parsing.
if (CanAcceptVPTPredicationCode && VPTPredicationCode != llvm::ARMVCC::None &&
!(Mnemonic.starts_with("vcvt") && Mnemonic != "vcvta" &&
Mnemonic != "vcvtn" && Mnemonic != "vcvtp" && Mnemonic != "vcvtm")) {
@@ -7161,7 +7157,7 @@ bool ARMAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
}
}
- // This marks the end of the LHS Mnemonic operators
+ // This marks the end of the LHS Mnemonic operators.
// This is used for indexing into the non-menmonic operators as some of the
// mnemonic operators are optional and therfore indexes can differ.
unsigned MnemonicOpsEndInd = Operands.size();
@@ -10990,7 +10986,7 @@ ARMAsmParser::checkEarlyTargetMatchPredicate(MCInst &Inst,
unsigned Opc = Inst.getOpcode();
switch (Opc) {
// Prevent the mov r8 r8 encoding for nop being selected when the v6/thumb 2
- // encoding is available
+ // encoding is available.
case ARM::tMOVr: {
if (Operands[0]->isToken() &&
static_cast<ARMOperand &>(*Operands[0]).getToken() == "nop" &&
@@ -11255,7 +11251,7 @@ bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
MatchResult = MatchInstruction(Operands, Inst, NearMisses, MatchingInlineAsm,
PendConditionalInstruction, Out);
- // Find the number of operators that are part of the Mnumonic (LHS)
+ // Find the number of operators that are part of the Mnumonic (LHS).
unsigned MnemonicOpsEndInd = getMnemonicOpsEndInd(Operands);
switch (MatchResult) {
@@ -12930,7 +12926,7 @@ unsigned ARMAsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
if (hasV8Ops() && Op.isReg() && Op.getReg() == ARM::SP)
return Match_Success;
return Match_rGPR;
- // If trying to match a VecListDPair with a Q register, convert Q to list
+ // If trying to match a VecListDPair with a Q register, convert Q to list.
case MCK_VecListDPair:
if (Op.isQReg() && !hasMVE()) {
auto DPair = getDRegFromQReg(Op.getReg());
@@ -12941,7 +12937,7 @@ unsigned ARMAsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
}
return Match_InvalidOperand;
// If trying to match a VecListDPair with a D register, convert D singleton
- // list
+ // list.
case MCK_VecListOneD:
if (Op.isDReg() && !hasMVE()) {
Op.setVecListOneD(Op.getReg());
diff --git a/llvm/test/tools/llvm-mca/ARM/cortex-a57-basic-instructions.s b/llvm/test/tools/llvm-mca/ARM/cortex-a57-basic-instructions.s
index 2257e453e0a812..d686293c9b4309 100644
--- a/llvm/test/tools/llvm-mca/ARM/cortex-a57-basic-instructions.s
+++ b/llvm/test/tools/llvm-mca/ARM/cortex-a57-basic-instructions.s
@@ -1023,7 +1023,7 @@
# CHECK-NEXT: 2 2 1.00 blxne r2
# CHECK-NEXT: 2 1 1.00 U blx #32424576
# CHECK-NEXT: 2 1 1.00 U blx #16212288
-# CHECK-NEXT: 1 1 1.00 U bx r2
+# CHECK-NEXT: 1 1 1.00 bx r2
# CHECK-NEXT: 1 1 1.00 U bxne r2
# CHECK-NEXT: 1 1 1.00 U bxj r2
# CHECK-NEXT: 1 1 1.00 U bxjne r2
>From b0b513369f5958968956e3a32187ea8b9a23faba Mon Sep 17 00:00:00 2001
From: Alfie Richards <alfie.richards at arm.com>
Date: Thu, 7 Mar 2024 10:48:20 +0000
Subject: [PATCH 6/6] Remove unecessary and outdated `tMUL` disgnosis.
---
.../lib/Target/ARM/AsmParser/ARMAsmParser.cpp | 19 -------------------
1 file changed, 19 deletions(-)
diff --git a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
index 35ec6f250f98e9..edf38c488b03aa 100644
--- a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
+++ b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
@@ -8034,25 +8034,6 @@ bool ARMAsmParser::validateInstruction(MCInst &Inst,
case ARM::sysSTMIB_UPD:
return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
"system STM cannot have writeback register");
- case ARM::tMUL:
- // The second source operand must be the same register as the destination
- // operand.
- //
- // In this case, we must directly check the parsed operands because the
- // cvtThumbMultiply() function is written in such a way that it guarantees
- // this first statement is always true for the new Inst. Essentially, the
- // destination is unconditionally copied into the second source operand
- // without checking to see if it matches what we actually parsed.
- if (Operands.size() == MnemonicOpsEndInd + 3 &&
- (((ARMOperand &)*Operands[MnemonicOpsEndInd]).getReg() !=
- ((ARMOperand &)*Operands[MnemonicOpsEndInd + 2]).getReg()) &&
- (((ARMOperand &)*Operands[MnemonicOpsEndInd]).getReg() !=
- ((ARMOperand &)*Operands[MnemonicOpsEndInd + 1]).getReg())) {
- return Error(Operands[MnemonicOpsEndInd]->getStartLoc(),
- "destination register must match source register");
- }
- break;
-
// Like for ldm/stm, push and pop have hi-reg handling version in Thumb2,
// so only issue a diagnostic for thumb1. The instructions will be
// switched to the t2 encodings in processInstruction() if necessary.
More information about the llvm-commits
mailing list