[ARM] Use new assembler diags for ARM

[olista01]

Summary

This converts the ARM AsmParser to use the new assembly matcher error
reporting mechanism, which allows errors to be reported for multiple
instruction encodings when it is ambiguous which one the user intended
to use.

By itself this doesn't improve many error messages, because we don't have diagnostic text for most operand types, but as we add that then this will allow more of those diagnostic strings to be used when they are relevant.

[rengolin]

Hi Oliver,

This is an interesting development and I agree with many of your comments in the code, especially the one that says this is not ARM specific at all.

I imagine a generic engine which calls a target specific for the messages.

Also, can you give an example of a more general error that should silence the more specific ones?

cheers,
--renato

[olista01]

I imagine a generic engine which calls a target specific for the messages.

Do you think it's ok to develop this as ARM-specific code first then refactor it once we have stabilised it, or would it be better to start with the target-independent core?

Also, can you give an example of a more general error that should silence the more specific ones?

There are plenty of examples of this in Thumb, where we have 16-bit and 32-bit versions of an instruction, where the 32-bit version accepts a wider range of immediates or registers. Note that this case won't be hit often at all with just this patch, because we have diagnostic messages for very few operand classes (just those listed in getOperandMatchFailDiag). Expanding that is on my TODO list.

[rengolin]

In D31530#715155, @olista01 wrote:

Do you think it's ok to develop this as ARM-specific code first then refactor it once we have stabilised it, or would it be better to start with the target-independent core?

I'm not sure. Right now, the implementation is very much ARM dependent, which could make matters worse when trying to other targets. Maybe splitting now, that the functionality is small and the relationships are obvious, would be a much easier way to evolve later. Or maybe it'll just complicate more things now and make it harder to predict.

I have no strong opinion in this particular case. I have gone with both approaches in the past, and have had mixed results with both. :)

There are plenty of examples of this in Thumb, where we have 16-bit and 32-bit versions of an instruction, where the 32-bit version accepts a wider range of immediates or registers. Note that this case won't be hit often at all with just this patch, because we have diagnostic messages for very few operand classes (just those listed in getOperandMatchFailDiag). Expanding that is on my TODO list.

Interesting, that's a very fine grained level of warnings. I assume this wouldn't be enabled for the normal lowering, just assembly files/snippets, right? Or is this a tool to help us predict better codegen?

Regardless, they're both interesting tools that we could control independently (but use the same machinery).

cheers,
--renato

[olista01]

I have no strong opinion in this particular case. I have gone with both approaches in the past, and have had mixed results with both. :)

Ok, I'll stick with the current approach for now, but keep in mind the fact that this will need to be refactored at some point in the future.

I assume this wouldn't be enabled for the normal lowering, just assembly files/snippets, right?

Correct, this is only used when parsing textual assembly (both files and inline asm), not during code-generation from C/C++. Most of my motivating examples come from hand-written Thumb code, where there are a lot of different immediate ranges, and the assembler often just gives a "requires arm-mode" error, which is useless on a Cortex-M target that doesn't have ARM mode.

[rengolin]

In D31530#715210, @olista01 wrote:

Most of my motivating examples come from hand-written Thumb code, where there are a lot of different immediate ranges, and the assembler often just gives a "requires arm-mode" error, which is useless on a Cortex-M target that doesn't have ARM mode.

Right, that indeed needs a better solution! :)

[olista01]

Updated tests, the regression suite is now fully passing.

A few of the tests appear to show less-detailed error messages than before, printing "invalid instruction" rather than "invalid operand for instruction". However, these are cases where changing the operand in question would not make the instruction valid, so I think this is OK. There may be value in emitting a message when multiple operands are invalid, but that can come later.

[olista01]

Rebase past rL299358/D31333.

[rengolin]

Hi Oliver,

I'm still getting my bearings. The inline comments are more as a way to understand than to criticise your patch.

I think this is, in the long run, a good way forward. But I don't want to muddle the field before we get there.

So, before I look at the patch per se, we should discuss the error messages, what do they mean and what we can do.

Then later we can agree on multiple steps to get there, even if not all problems are fixed on the first commit (I'm sure they won't).

cheers,
--renato

test/MC/ARM/arm-branch-errors.s

14

This is a bit hard to understand... I'm not sure what you mean by "for one encoding".

Of course, the best message here would be "address needs to be 4-byte aligned on ARM", I'm not sure how we could get that with the current mechanism.

But it's also not clear (to me at least), how is this better than what we had.

test/MC/ARM/diagnostics.s

178

Why did this one get worse?

test/MC/ARM/fullfp16-neg.s

5

requires what?

I know it was there already, but it's confusing. If we're trying to show off the new (better) error messages, we should display them in their full glory. :)

test/MC/ARM/invalid-fp-armv8.s

38

This is technically "better" because you have chosen -mattr=-neon, but still doesn't say why the instruction is invalid.

Some error messages have the "requires ARMv8", but others don't. This one should know that it requires NEON, maybe a way to get the right info?

test/MC/ARM/lsl-zero-errors.s

49

It says multiple near misses, but only shows one... Not very helpful.

[olista01]

test/MC/ARM/arm-branch-errors.s

14

To make it clearer, here is the full error message for this instruction, with all of the context lines:

<stdin>:1:3: error: invalid instruction, multiple near-miss encodings found
  b #2
  ^
<stdin>:1:3: note: for one encoding: instruction requires: thumb
  b #2
  ^
<stdin>:1:5: note: for one encoding: invalid operand for instruction
  b #2
    ^

The two "note: for one encoding:" lines correspond to rows in the table-generated matcher table (which roughly corresponds to encodings in the ARMARM) which nearly match this instruction.

Two of these rows are Thumb branch instructions, for which an immediate of #2 is valid. I'm squashing these down into the one "instruction requires: thumb" message, as the second one wouldn't add anything.

Another of the rows is the ARM branch instruction, which doesn't match because the immediate must be a multiple of 4 (or a label, with alignment checked later). We don't currently have a diagnostic string for this operand class, so we emit the generic "invalid operand for instruction" message. Once this has been committed we can add a diagnostic string like "address needs to be 4-byte aligned" for the operand class.

test/MC/ARM/diagnostics.s

178

This one was previously picking up the diagnostic for MCK_Imm0_255, which is only valid for Thumb targets (this test is using ARM mode). If the immediate was reduced, this would actually match the MCK_ModImm class. However, that doesn't have a diagnostic associated with it yet. Once it does, we'll get a more useful diagnostic than before.

test/MC/ARM/fullfp16-neg.s

5

The full message is "instruction requires: full half-float", I'll update the test.

Many of these instructions also get an "invalid operand for instruction" error pointing to the ".f16" token, because they would be valid if they had ".f32" instead. I haven't updated the test to show this as I expect it to change once I add diagnostics for token operands.

test/MC/ARM/invalid-fp-armv8.s

38

A lot of the instructions in this file (including this one) are invalid both because NEON is disabled, and because they have incorrect operands (so would not be correct even if NEON were enabled). We don't emit a more specific error here because neither change alone would make the instruction valid.

test/MC/ARM/lsl-zero-errors.s

49

A lot of the instructions in this test now get multiple near-misses (mostly different operands invalid, valid in other ISA), I'll update the test.

[rengolin]

I guess this will be a long road anyway, so we should cope with some vague messages now, and add better ones with time.

Thanks for doing the effort, this is an area that is really bad at error messages. :)

LGTM.

[olista01]

Thanks, could you also review D27620, which this depends on?

I guess this will be a long road anyway, so we should cope with some vague messages now, and add better ones with time.

Yep, my plan was to get this change in without regressing anything too badly, then add diagnostics for each operand and register class. I've got a few patches that build on this up in phab, but I'm currently hitting a problem caused by the shouldOmitCCOutOperand function in the ARMAsmParser causing many instructions to fail to match all of their operands, not just the visible one. Once I've found a good solution to that, adding diags will hopefully only require adding the diagnostic string in the tablegen description of the operand.

[olista01]

After discussing this with someone in our documentation team, I've changed the wording of the messages slightly. They now look like this (with some patches adding diagnostic text for more operands, which I'm almost ready to upstream):

<stdin>:2:3: error: invalid instruction, any one of the following would fix this:
  adds r0, r1, #8
  ^
<stdin>:2:3: note: instruction requires: thumb2
  adds r0, r1, #8
  ^
<stdin>:2:16: note: operand must be an immediate in the range [0,7]
  adds r0, r1, #8
               ^
<stdin>:2:16: note: operand must be a register in range [r0, r7]
  adds r0, r1, #8
               ^

I've changed the initial error test to be more explicit about the fact that the notes relate to the error, and that fixing any one of them will make the instruction valid, rather than having to fix all of them. I've removed the "for one encoding" text from the notes, as this is now redundant, and seemed to be causing confusion.

This is dependent on D27620, which is still in review.

[echristo]

In general a fan of this FWIW:

One question is it intended that ultimately this is going to be turned on by default? From looking at the error messages it seems like it'd be goodness?

[olista01]

Yes, I agree that it would be good to get this turned on for all targets. I'm developing it on ARM only at the moment so that I can make changes to the general mechanism without breaking lots of target's tests. Once it's stabilised, here's what I think needs doing to use it for other targets:

• Move the ReportNearMisses and FilterNearMisses from the ARM asm parser to somewhere target-independent. There is some ARM-specific code in there at the moment, so this will need some sort of callbacks into the target asm parser.
• Switch each asm parser to use the new mechanism. This should involve changing the signature of MatchInstruction, implementing any target-specific callbacks needed, and flipping the bit in the tablegen. I think the biggest part of this work will be updating the tests to match the new diagnostic format.

I plan on doing this for AArch64 once I'm done with ARM, but I'm not sure I know enough about the other targets assembly to be able to update the tests myself.

[echristo]

SGTM. Thanks!

lib/Target/ARM/ARM.td

 
 def ARMAsmWriter : AsmWriter {
   string AsmWriterClassName  = "InstPrinter";
   int PassSubtarget = 1;
   int Variant = 0;
   bit isMCAsmWriter = 1;
 }
 
+def ARMAsmParser : AsmParser {
+  bit ReportMultipleNearMisses = 1;
+}
+
 def ARMAsmParserVariant : AsmParserVariant {
   int Variant = 0;
   string Name = "ARM";
   string BreakCharacters = ".";
 }
 
 def ARM : Target {
   // Pull in Instruction Info:
   let InstructionSet = ARMInstrInfo;
   let AssemblyWriters = [ARMAsmWriter];
+  let AssemblyParsers = [ARMAsmParser];
   let AssemblyParserVariants = [ARMAsmParserVariant];
 }

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 //===-- ARMAsmParser.cpp - Parse ARM assembly to MCInst instructions ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ARMFeatures.h"
 #include "MCTargetDesc/ARMAddressingModes.h"
 #include "MCTargetDesc/ARMBaseInfo.h"
 #include "MCTargetDesc/ARMMCExpr.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
cl::values(clEnumValN(ImplicitItModeTy::Always, "always",
                           "Accept in both ISAs, emit implicit ITs in Thumb"),
                clEnumValN(ImplicitItModeTy::Never, "never",
                           "Warn in ARM, reject in Thumb"),
                clEnumValN(ImplicitItModeTy::ARMOnly, "arm",
                           "Accept in ARM, reject in Thumb"),
                clEnumValN(ImplicitItModeTy::ThumbOnly, "thumb",
                           "Warn in ARM, emit implicit ITs in Thumb")));
 
+cl::opt<bool>
+DevDiags("arm-asm-parser-dev-diags", cl::init(false),
+         cl::desc("Use extended diagnostics, which include implementation "
+                  "details useful for development"));
+
 class ARMOperand;
 
 enum VectorLaneTy { NoLanes, AllLanes, IndexedLane };
 
 class UnwindContext {
   MCAsmParser &Parser;
 
   typedef SmallVector<SMLoc, 4> Locs;
unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
                                       unsigned Kind) override;
   unsigned checkTargetMatchPredicate(MCInst &Inst) override;
 
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
   unsigned MatchInstruction(OperandVector &Operands, MCInst &Inst,
-                            uint64_t &ErrorInfo, bool MatchingInlineAsm,
-                            bool &EmitInITBlock, MCStreamer &Out);
+                            SmallVectorImpl<NearMissInfo> &NearMisses,
+                            bool MatchingInlineAsm, bool &EmitInITBlock,
+                            MCStreamer &Out);
+
+  struct NearMissMessage {
+    SMLoc Loc;
+    SmallString<128> Message;
+  };
+
+  const char *getOperandMatchFailDiag(ARMMatchResultTy Error);
+  void FilterNearMisses(SmallVectorImpl<NearMissInfo> &NearMissesIn,
+                        SmallVectorImpl<NearMissMessage> &NearMissesOut,
+                        SMLoc IDLoc, OperandVector &Operands);
+  void ReportNearMisses(SmallVectorImpl<NearMissInfo> &NearMisses, SMLoc IDLoc,
+                        OperandVector &Operands);
+
   void onLabelParsed(MCSymbol *Symbol) override;
 };
 } // end anonymous namespace
 
 namespace {
 
 /// ARMOperand - Instances of this class represent a parsed ARM machine
 /// operand.
if (listContainsReg(Inst, 2, ARM::PC))
       return true;
     break;
   }
 
   return false;
 }
 
 unsigned ARMAsmParser::MatchInstruction(OperandVector &Operands, MCInst &Inst,
-                                          uint64_t &ErrorInfo,
+                                          SmallVectorImpl<NearMissInfo> &NearMisses,
                                           bool MatchingInlineAsm,
                                           bool &EmitInITBlock,
                                           MCStreamer &Out) {
   // If we can't use an implicit IT block here, just match as normal.
   if (inExplicitITBlock() || !isThumbTwo() || !useImplicitITThumb())
-    return MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
+    return MatchInstructionImpl(Operands, Inst, &NearMisses, MatchingInlineAsm);
 
   // Try to match the instruction in an extension of the current IT block (if
   // there is one).
   if (inImplicitITBlock()) {
     extendImplicitITBlock(ITState.Cond);
-    if (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm) ==
+    if (MatchInstructionImpl(Operands, Inst, nullptr, MatchingInlineAsm) ==
             Match_Success) {
       // The match succeded, but we still have to check that the instruction is
       // valid in this implicit IT block.
       const MCInstrDesc &MCID = MII.get(Inst.getOpcode());
       if (MCID.isPredicable()) {
         ARMCC::CondCodes InstCond =
             (ARMCC::CondCodes)Inst.getOperand(MCID.findFirstPredOperandIdx())
                 .getImm();
if (MatchInstructionImpl(Operands, Inst, nullptr, MatchingInlineAsm) ==
       }
     }
     rewindImplicitITPosition();
   }
 
   // Finish the current IT block, and try to match outside any IT block.
   flushPendingInstructions(Out);
   unsigned PlainMatchResult =
-      MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
+      MatchInstructionImpl(Operands, Inst, &NearMisses, MatchingInlineAsm);
   if (PlainMatchResult == Match_Success) {
     const MCInstrDesc &MCID = MII.get(Inst.getOpcode());
     if (MCID.isPredicable()) {
       ARMCC::CondCodes InstCond =
           (ARMCC::CondCodes)Inst.getOperand(MCID.findFirstPredOperandIdx())
               .getImm();
       // Some forms of the branch instruction have their own condition code
       // fields, so can be conditionally executed without an IT block.
if (MCID.isPredicable()) {
       return Match_Success;
     }
   }
 
   // Try to match in a new IT block. The matcher doesn't check the actual
   // condition, so we create an IT block with a dummy condition, and fix it up
   // once we know the actual condition.
   startImplicitITBlock();
-  if (MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm) ==
+  if (MatchInstructionImpl(Operands, Inst, nullptr, MatchingInlineAsm) ==
       Match_Success) {
     const MCInstrDesc &MCID = MII.get(Inst.getOpcode());
     if (MCID.isPredicable()) {
       ITState.Cond =
           (ARMCC::CondCodes)Inst.getOperand(MCID.findFirstPredOperandIdx())
               .getImm();
       EmitInITBlock = true;
       return Match_Success;

 bool ARMAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                            OperandVector &Operands,
                                            MCStreamer &Out, uint64_t &ErrorInfo,
                                            bool MatchingInlineAsm) {
   MCInst Inst;
   unsigned MatchResult;
   bool PendConditionalInstruction = false;
 
-  MatchResult = MatchInstruction(Operands, Inst, ErrorInfo, MatchingInlineAsm,
+  SmallVector<NearMissInfo, 4> NearMisses;
+  MatchResult = MatchInstruction(Operands, Inst, NearMisses, MatchingInlineAsm,
                                  PendConditionalInstruction, Out);
 
   switch (MatchResult) {
   case Match_Success:
     // Context sensitive operand constraints aren't handled by the matcher,
     // so check them here.
     if (validateInstruction(Inst, Operands)) {
       // Still progress the IT block, otherwise one wrong condition causes
case Match_Success:
     if (PendConditionalInstruction) {
       PendingConditionalInsts.push_back(Inst);
       if (isITBlockFull() || isITBlockTerminator(Inst))
         flushPendingInstructions(Out);
     } else {
       Out.EmitInstruction(Inst, getSTI());
     }
     return false;
-  case Match_MissingFeature: {
-    assert(ErrorInfo && "Unknown missing feature!");
-    // Special case the error message for the very common case where only
-    // a single subtarget feature is missing (Thumb vs. ARM, e.g.).
-    std::string Msg = "instruction requires:";
-    uint64_t Mask = 1;
-    for (unsigned i = 0; i < (sizeof(ErrorInfo)*8-1); ++i) {
-      if (ErrorInfo & Mask) {
-        Msg += " ";
-        Msg += getSubtargetFeatureName(ErrorInfo & Mask);
-      }
-      Mask <<= 1;
-    }
-    return Error(IDLoc, Msg);
-  }
-  case Match_InvalidOperand: {
-    SMLoc ErrorLoc = IDLoc;
-    if (ErrorInfo != ~0ULL) {
-      if (ErrorInfo >= Operands.size())
-        return Error(IDLoc, "too few operands for instruction");
-
-      ErrorLoc = ((ARMOperand &)*Operands[ErrorInfo]).getStartLoc();
-      if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
-    }
-
-    return Error(ErrorLoc, "invalid operand for instruction");
-  }
+  case Match_NearMisses:
+    ReportNearMisses(NearMisses, IDLoc, Operands);
+    return true;
   case Match_MnemonicFail:
     return Error(IDLoc, "invalid instruction",
                  ((ARMOperand &)*Operands[0]).getLocRange());
-  case Match_RequiresNotITBlock:
-    return Error(IDLoc, "flag setting instruction only valid outside IT block");
-  case Match_RequiresITBlock:
-    return Error(IDLoc, "instruction only valid inside IT block");
-  case Match_RequiresV6:
-    return Error(IDLoc, "instruction variant requires ARMv6 or later");
-  case Match_RequiresThumb2:
-    return Error(IDLoc, "instruction variant requires Thumb2");
-  case Match_RequiresV8:
-    return Error(IDLoc, "instruction variant requires ARMv8 or later");
-  case Match_RequiresFlagSetting:
-    return Error(IDLoc, "no flag-preserving variant of this instruction available");
-  case Match_ImmRange0_15: {
-    SMLoc ErrorLoc = ((ARMOperand &)*Operands[ErrorInfo]).getStartLoc();
-    if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
-    return Error(ErrorLoc, "immediate operand must be in the range [0,15]");
-  }
-  case Match_ImmRange0_239: {
-    SMLoc ErrorLoc = ((ARMOperand &)*Operands[ErrorInfo]).getStartLoc();
-    if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
-    return Error(ErrorLoc, "immediate operand must be in the range [0,239]");
-  }
-  case Match_AlignedMemoryRequiresNone:
-  case Match_DupAlignedMemoryRequiresNone:
-  case Match_AlignedMemoryRequires16:
-  case Match_DupAlignedMemoryRequires16:
-  case Match_AlignedMemoryRequires32:
-  case Match_DupAlignedMemoryRequires32:
-  case Match_AlignedMemoryRequires64:
-  case Match_DupAlignedMemoryRequires64:
-  case Match_AlignedMemoryRequires64or128:
-  case Match_DupAlignedMemoryRequires64or128:
-  case Match_AlignedMemoryRequires64or128or256:
-  {
-    SMLoc ErrorLoc = ((ARMOperand &)*Operands[ErrorInfo]).getAlignmentLoc();
-    if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
-    switch (MatchResult) {
-      default:
-        llvm_unreachable("Missing Match_Aligned type");
-      case Match_AlignedMemoryRequiresNone:
-      case Match_DupAlignedMemoryRequiresNone:
-        return Error(ErrorLoc, "alignment must be omitted");
-      case Match_AlignedMemoryRequires16:
-      case Match_DupAlignedMemoryRequires16:
-        return Error(ErrorLoc, "alignment must be 16 or omitted");
-      case Match_AlignedMemoryRequires32:
-      case Match_DupAlignedMemoryRequires32:
-        return Error(ErrorLoc, "alignment must be 32 or omitted");
-      case Match_AlignedMemoryRequires64:
-      case Match_DupAlignedMemoryRequires64:
-        return Error(ErrorLoc, "alignment must be 64 or omitted");
-      case Match_AlignedMemoryRequires64or128:
-      case Match_DupAlignedMemoryRequires64or128:
-        return Error(ErrorLoc, "alignment must be 64, 128 or omitted");
-      case Match_AlignedMemoryRequires64or128or256:
-        return Error(ErrorLoc, "alignment must be 64, 128, 256 or omitted");
-    }
-  }
   }
 
   llvm_unreachable("Implement any new match types added!");
 }
 
 /// parseDirective parses the arm specific directives
 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
   const MCObjectFileInfo::Environment Format =
extern "C" void LLVMInitializeARMAsmParser() {
   RegisterMCAsmParser<ARMAsmParser> B(getTheThumbBETarget());
 }
 
 #define GET_REGISTER_MATCHER
 #define GET_SUBTARGET_FEATURE_NAME
 #define GET_MATCHER_IMPLEMENTATION
 #include "ARMGenAsmMatcher.inc"
 
+const char *ARMAsmParser::getOperandMatchFailDiag(ARMMatchResultTy Error) {
+  switch (Error) {
+  case Match_ImmRange0_15:
+    return "immediate operand must be in the range [0,15]";
+  case Match_ImmRange0_239:
+    return "immediate operand must be in the range [0,239]";
+  case Match_AlignedMemoryRequiresNone:
+  case Match_DupAlignedMemoryRequiresNone:
+    return "alignment must be omitted";
+  case Match_AlignedMemoryRequires16:
+  case Match_DupAlignedMemoryRequires16:
+    return "alignment must be 16 or omitted";
+  case Match_AlignedMemoryRequires32:
+  case Match_DupAlignedMemoryRequires32:
+    return "alignment must be 32 or omitted";
+  case Match_AlignedMemoryRequires64:
+  case Match_DupAlignedMemoryRequires64:
+    return "alignment must be 64 or omitted";
+  case Match_AlignedMemoryRequires64or128:
+  case Match_DupAlignedMemoryRequires64or128:
+    return "alignment must be 64, 128 or omitted";
+  case Match_AlignedMemoryRequires64or128or256:
+    return "alignment must be 64, 128, 256 or omitted";
+  default:
+    return nullptr;
+  }
+}
+
+// Process the list of near-misses, throwing away ones we don't want to report
+// to the user, and converting the rest to a source location and string that
+// should be reported.
+void
+ARMAsmParser::FilterNearMisses(SmallVectorImpl<NearMissInfo> &NearMissesIn,
+                               SmallVectorImpl<NearMissMessage> &NearMissesOut,
+                               SMLoc IDLoc, OperandVector &Operands) {
+  // TODO: If operand didn't match, sub in a dummy one and run target
+  // predicate, so that we can avoid reporting near-misses that are invalid?
+  // TODO: Many operand types dont have SuperClasses set, so we report
+  // redundant ones.
+  // TODO: Some operands are superclasses of registers (e.g.
+  // MCK_RegShiftedImm), we don't have any way to represent that currently.
+  // TODO: This is not all ARM-specific, can some of it be factored out?
+
+  // Record some information about near-misses that we have already seen, so
+  // that we can avoid reporting redundant ones. For example, if there are
+  // variants of an instruction that take 8- and 16-bit immediates, we want
+  // to only report the widest one.
+  std::multimap<unsigned, unsigned> OperandMissesSeen;
+  SmallSet<uint64_t, 4> FeatureMissesSeen;
+
+  // Process the near-misses in reverse order, so that we see more general ones
+  // first, and so can avoid emitting more specific ones.
+  for (NearMissInfo &I : reverse(NearMissesIn)) {
+    switch (I.getKind()) {
+    case NearMissInfo::NearMissOperand: {
+      SMLoc OperandLoc =
+          ((ARMOperand &)*Operands[I.getOperandIndex()]).getStartLoc();
+      const char *OperandDiag =
+          getOperandMatchFailDiag((ARMMatchResultTy)I.getOperandError());
+
+      // If we have already emitted a message for a superclass, don't also report
+      // the sub-class. We consider all operand classes that we don't have a
+      // specialised diagnostic for to be equal for the propose of this check,
+      // so that we don't report the generic error multiple times on the same
+      // operand.
+      unsigned DupCheckMatchClass = OperandDiag ? I.getOperandClass() : ~0U;
+      auto PrevReports = OperandMissesSeen.equal_range(I.getOperandIndex());
+      if (std::any_of(PrevReports.first, PrevReports.second,
+                      [DupCheckMatchClass](
+                          const std::pair<unsigned, unsigned> Pair) {
+            if (DupCheckMatchClass == ~0U)
+              return Pair.second == ~0U;
+            else
+              return isSubclass((MatchClassKind)DupCheckMatchClass,
+                                (MatchClassKind)Pair.second);
+          }))
+        break;
+      OperandMissesSeen.insert(
+          std::make_pair(I.getOperandIndex(), DupCheckMatchClass));
+
+      NearMissMessage Message;
+      Message.Loc = OperandLoc;
+      raw_svector_ostream OS(Message.Message);
+      if (OperandDiag) {
+        OS << OperandDiag;
+      } else if (I.getOperandClass() == InvalidMatchClass) {
+        OS << "too many operands for instruction";
+      } else {
+        OS << "invalid operand for instruction";
+        if (DevDiags) {
+          OS << " class" << I.getOperandClass() << ", error "
+             << I.getOperandError() << ", opcode "
+             << MII.getName(I.getOpcode());
+        }
+      }
+      NearMissesOut.emplace_back(Message);
+      break;
+    }
+    case NearMissInfo::NearMissFeature: {
+      uint64_t MissingFeatures = I.getFeatures();
+      // Don't report the same set of features twice.
+      if (FeatureMissesSeen.count(MissingFeatures))
+        break;
+      FeatureMissesSeen.insert(MissingFeatures);
+
+      // Special case: don't report a feature set which includes arm-mode for
+      // targets that don't have ARM mode.
+      if ((MissingFeatures & Feature_IsARM) && !hasARM())
+        break;
+      // Don't report any near-misses that both require switching instruction
+      // set, and adding other subtarget features.
+      if (isThumb() && (MissingFeatures & Feature_IsARM) &&
+          (MissingFeatures & ~Feature_IsARM))
+        break;
+      if (!isThumb() && (MissingFeatures & Feature_IsThumb) &&
+          (MissingFeatures & ~Feature_IsThumb))
+        break;
+      if (!isThumb() && (MissingFeatures & Feature_IsThumb2) &&
+          (MissingFeatures & ~(Feature_IsThumb2 | Feature_IsThumb)))
+        break;
+
+      NearMissMessage Message;
+      Message.Loc = IDLoc;
+      raw_svector_ostream OS(Message.Message);
+
+      OS << "instruction requires:";
+      uint64_t Mask = 1;
+      for (unsigned MaskPos = 0; MaskPos < (sizeof(MissingFeatures) * 8 - 1);
+           ++MaskPos) {
+        if (MissingFeatures & Mask) {
+          OS << " " << getSubtargetFeatureName(MissingFeatures & Mask);
+        }
+        Mask <<= 1;
+      }
+      NearMissesOut.emplace_back(Message);
+
+      break;
+    }
+    case NearMissInfo::NearMissPredicate: {
+      NearMissMessage Message;
+      Message.Loc = IDLoc;
+      switch (I.getPredicateError()) {
+      case Match_RequiresNotITBlock:
+        Message.Message = "flag setting instruction only valid outside IT block";
+        break;
+      case Match_RequiresITBlock:
+        Message.Message = "instruction only valid inside IT block";
+        break;
+      case Match_RequiresV6:
+        Message.Message = "instruction variant requires ARMv6 or later";
+        break;
+      case Match_RequiresThumb2:
+        Message.Message = "instruction variant requires Thumb2";
+        break;
+      case Match_RequiresV8:
+        Message.Message = "instruction variant requires ARMv8 or later";
+        break;
+      case Match_RequiresFlagSetting:
+        Message.Message = "no flag-preserving variant of this instruction available";
+        break;
+      case Match_InvalidOperand:
+        Message.Message = "invalid operand for instruction";
+        break;
+      default:
+        llvm_unreachable("Unhandled target predicate error");
+        break;
+      }
+      NearMissesOut.emplace_back(Message);
+      break;
+    }
+    case NearMissInfo::NearMissTooFewOperands: {
+      SMLoc EndLoc = ((ARMOperand &)*Operands.back()).getEndLoc();
+      NearMissesOut.emplace_back(
+          NearMissMessage{ EndLoc, StringRef("too few operands for instruction") });
+      break;
+    }
+    case NearMissInfo::NoNearMiss:
+      // This should never leave the matcher.
+      llvm_unreachable("not a near-miss");
+      break;
+    }
+  }
+}
+
+void ARMAsmParser::ReportNearMisses(SmallVectorImpl<NearMissInfo> &NearMisses,
+                                    SMLoc IDLoc, OperandVector &Operands) {
+  SmallVector<NearMissMessage, 4> Messages;
+  FilterNearMisses(NearMisses, Messages, IDLoc, Operands);
+
+  if (Messages.size() == 0) {
+    // No near-misses were found, so the best we can do is "invalid
+    // instruction".
+    Error(IDLoc, "invalid instruction");
+  } else if (Messages.size() == 1) {
+    // One near miss was found, report it as the sole error.
+    Error(Messages[0].Loc, Messages[0].Message);
+  } else {
+    // More than one near miss, so report a generic "invalid instruction"
+    // error, followed by notes for each of the near-misses.
+    Error(IDLoc, "invalid instruction, multiple near-miss encodings found");
+    for (auto &M : Messages) {
+      SmallString<128> NoteMessage("for one encoding: ");
+      NoteMessage.append(M.Message);
+      Note(M.Loc, NoteMessage);
+    }
+  }
+}
+
 // FIXME: This structure should be moved inside ARMTargetParser
 // when we start to table-generate them, and we can use the ARM
 // flags below, that were generated by table-gen.
 static const struct {
   const unsigned Kind;
   const uint64_t ArchCheck;
   const FeatureBitset Features;
 } Extensions[] = {

test/MC/ARM/arm-branch-errors.s

 @ RUN: not llvm-mc -triple=armv7-apple-darwin < %s 2>&1 | FileCheck %s
 
 @------------------------------------------------------------------------------
 @ Branch targets destined for ARM mode must == 0 (mod 4), otherwise (mod 2).
 @------------------------------------------------------------------------------
 
         b #2
         bl #2
         beq #2
 
-@ CHECK: error: instruction requires: thumb
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
 @ CHECK:        b #2
-@ CHECK: error: instruction requires: thumb
+@ CHECK: note: for one encoding: instruction requires: thumb
+@ CHECK: note: for one encoding: invalid operand for instruction
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
 @ CHECK:        bl #2
-@ CHECK: error: instruction requires: thumb
+@ CHECK: note: for one encoding: instruction requires: thumb
+@ CHECK: note: for one encoding: invalid operand for instruction
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
 @ CHECK:        beq #2
+@ CHECK: note: for one encoding: instruction requires: thumb
+@ CHECK: note: for one encoding: invalid operand for instruction

test/MC/ARM/basic-arm-instructions-v8.1a.s

 //CHECK-ERROR:   vqrdmlah.u16  d0, d1, d2
 //CHECK-ERROR:           ^
 //CHECK-ERROR: error: invalid operand for instruction
 //CHECK-ERROR:   vqrdmlsh.f32  q3, q4, q5
 //CHECK-ERROR:           ^
 //CHECK-ERROR: error: invalid operand for instruction
 //CHECK-ERROR:   vqrdmlsh.f64  d3, d5, d5
 //CHECK-ERROR:           ^
-//CHECK-V8: error: invalid operand for instruction
+//CHECK-V8: error: invalid instruction
 //CHECK-V8:   vqrdmlah.i8   q0, q1, q2
-//CHECK-V8:           ^
-//CHECK-V8: error: invalid operand for instruction
+//CHECK-V8:   ^
+//CHECK-V8: error: invalid instruction
 //CHECK-V8:   vqrdmlah.u16  d0, d1, d2
-//CHECK-V8:           ^
-//CHECK-V8: error: invalid operand for instruction
+//CHECK-V8:   ^
+//CHECK-V8: error: invalid instruction
 //CHECK-V8:   vqrdmlsh.f32  q3, q4, q5
-//CHECK-V8:           ^
-//CHECK-V8: error: invalid operand for instruction
+//CHECK-V8:   ^
+//CHECK-V8: error: invalid instruction
 //CHECK-V8:  vqrdmlsh.f64  d3, d5, d5
-//CHECK-V8:           ^
+//CHECK-V8:  ^
 
   vqrdmlah.s16    d0, d1, d2
 //CHECK-V81aARM:   vqrdmlah.s16  d0, d1, d2      @ encoding: [0x12,0x0b,0x11,0xf3]
 //CHECK-V81aTHUMB: vqrdmlah.s16  d0, d1, d2      @ encoding: [0x11,0xff,0x12,0x0b]
 //CHECK-V8: error: instruction requires: armv8.1a
 //CHECK-V8:  vqrdmlah.s16    d0, d1, d2
 //CHECK-V8:  ^
 
//CHECK-V8:  ^
   vqrdmlsh.s32    q3, q4, q5
 //CHECK-V81aARM:   vqrdmlsh.s32  q3, q4, q5      @ encoding: [0x5a,0x6c,0x28,0xf3]
 //CHECK-V81aTHUMB: vqrdmlsh.s32  q3, q4, q5      @ encoding: [0x28,0xff,0x5a,0x6c]
 //CHECK-V8: error: instruction requires: armv8.1a
 //CHECK-V8:  vqrdmlsh.s32  q3, q4, q5
 //CHECK-V8:  ^
 
 
-  vqrdmlah.i8   q0, q1, d9[7]
+  vqrdmlah.i8   q0, q1, d9[0]
+  vqrdmlah.s32  q0, q1, d9[7]
   vqrdmlah.u16  d0, d1, d2[3]
   vqrdmlsh.f32  q3, q4, d5[1]
   vqrdmlsh.f64  d3, d5, d5[0]
 
 //CHECK-ERROR: error: invalid operand for instruction
-//CHECK-ERROR:   vqrdmlah.i8   q0, q1, d9[7]
-//CHECK-ERROR:           ^
+//CHECK-ERROR:   vqrdmlah.i8   q0, q1, d9[0]
+//CHECK-ERROR:           ^
+//CHECK-ERROR: error: invalid operand for instruction
+//CHECK-ERROR:   vqrdmlah.s32  q0, q1, d9[7]
+//CHECK-ERROR:                            ^
 //CHECK-ERROR: error: invalid operand for instruction
 //CHECK-ERROR:   vqrdmlah.u16  d0, d1, d2[3]
 //CHECK-ERROR:           ^
 //CHECK-ERROR: error: invalid operand for instruction
 //CHECK-ERROR:   vqrdmlsh.f32  q3, q4, d5[1]
 //CHECK-ERROR:           ^
 //CHECK-ERROR: error: invalid operand for instruction
 //CHECK-ERROR:   vqrdmlsh.f64  d3, d5, d5[0]

 //CHECK-V81aTHUMB: vqrdmlsh.s32  q0, q1, d2[0]   @ encoding: [0xa2,0xff,0x42,0x0f]
 //CHECK-V8: error: instruction requires: armv8.1a
 //CHECK-V8:  vqrdmlsh.s32  q0, q1, d2[0]
 //CHECK-V8:  ^
 
   setpan  #0
 //CHECK-V81aTHUMB:  setpan  #0                @       encoding: [0x10,0xb6]
 //CHECK-V81aARM:    setpan  #0                @       encoding: [0x00,0x00,0x10,0xf1]
-//CHECK-V8: error: instruction requires: armv8.1a
+//CHECK-V8: instruction requires: armv8.1a
 //CHECK-V8:  setpan  #0
 //CHECK-V8:  ^
 
   setpan  #1
 //CHECK-V81aTHUMB:  setpan  #1                @       encoding: [0x18,0xb6]
 //CHECK-V81aARM:    setpan  #1                @       encoding: [0x00,0x02,0x10,0xf1]
-//CHECK-V8: error: instruction requires: armv8.1a
+//CHECK-V8: instruction requires: armv8.1a
 //CHECK-V8:  setpan  #1
 //CHECK-V8:  ^
   setpan
   setpan #-1
   setpan #2
 //CHECK-ERROR: error: too few operands for instruction
 //CHECK-ERROR:  setpan
 //CHECK-ERROR:  ^

test/MC/ARM/basic-arm-instructions-v8.s

 @ CHECK-V7: error: invalid operand for instruction
 
 @------------------------------------------------------------------------------
 @ SEVL
 @------------------------------------------------------------------------------
         sevl
 
 @ CHECK-V8: sevl @ encoding: [0x05,0xf0,0x20,0xe3]
-@ CHECK-V7: error: instruction requires: armv8
+@ CHECK-V7: instruction requires: armv8

test/MC/ARM/basic-thumb2-instructions-v8.s

 
 @ Can accept SP as rGPR (in ARMv8 only)
         sbc.w r6, r3, sp, asr #16
         and.w r6, r3, sp, asr #16
         and sp, r0, #0
 @ CHECK-V8: sbc.w r6, r3, sp, asr #16     @ encoding: [0x63,0xeb,0x2d,0x46]
 @ CHECK-V8: and.w r6, r3, sp, asr #16     @ encoding: [0x03,0xea,0x2d,0x46]
 @ CHECK-V8: and   sp, r0, #0              @ encoding: [0x00,0xf0,0x00,0x0d]
-@ CHECK-V7: error: instruction variant requires ARMv8 or later
-@ CHECK-V7: error: instruction variant requires ARMv8 or later
+@ CHECK-V7: error: invalid instruction, multiple near-miss encodings found
+@ CHECk-V7: note: for one encoding: instruction variant requires ARMv8 or later
+@ CHECk-V7: note: for one encoding: invalid operand for instruction
+@ CHECK-V7: error: invalid instruction, multiple near-miss encodings found
+@ CHECk-V7: note: for one encoding: instruction variant requires ARMv8 or later
+@ CHECk-V7: note: for one encoding: invalid operand for instruction
 @ CHECK-V7: error: invalid operand for instruction
 
 @ DCPS{1,2,3} (in ARMv8 only)
         dcps1
         dcps2
         dcps3
 @ CHECK-V8: dcps1                         @ encoding: [0x8f,0xf7,0x01,0x80]
 @ CHECK-V8: dcps2                         @ encoding: [0x8f,0xf7,0x02,0x80]

test/MC/ARM/cps.s

 @ RUN: llvm-mc -triple=thumbv6t2--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv7a--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv7r--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv8a--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: not llvm-mc -triple=thumbv7m--none-eabi -show-encoding < %s 2>&1 | FileCheck %s --check-prefix=UNDEF
 
   cpsie f
   cpsie i, #3
   cps #0
 
 @ CHECK: cpsie f                         @ encoding: [0x61,0xb6]
 @ CHECK: cpsie   i, #3                   @ encoding: [0xaf,0xf3,0x43,0x85]
 @ CHECK: cps     #0                      @ encoding: [0xaf,0xf3,0x00,0x81]
 
 @ UNDEF-DAG: cpsie f                         @ encoding: [0x61,0xb6]
-@ UNDEF-DAG: error: instruction requires:
+@ UNDEF-DAG: instruction requires:
 @ UNDEF-DAG: error: instruction 'cps' requires effect for M-class

test/MC/ARM/diagnostics.s

@ CHECK-ERRORS:         pld r4, [r5, r6, rrx #0]
         @ Out of range 16-bit immediate on BKPT
         bkpt #65536
 
 @ CHECK-ERRORS: error: invalid operand for instruction
 
         @ Out of range immediates for v8 HLT instruction.
         hlt #65536
         hlt #-1
-@CHECK-ERRORS: error: invalid operand for instruction
+@CHECK-ERRORS-V7: error: invalid instruction
+@CHECK-ERRORS-V8: error: invalid operand for instruction
 @CHECK-ERRORS:         hlt #65536
 @CHECK-ERRORS:              ^
-@CHECK-ERRORS: error: invalid operand for instruction
+@CHECK-ERRORS-V7: error: invalid instruction
+@CHECK-ERRORS-V8: error: invalid operand for instruction
 @CHECK-ERRORS:         hlt #-1
 @CHECK-ERRORS:              ^
 
         @ Illegal condition code for v8 HLT instruction.
         hlteq #2
         hltlt #23
 @CHECK-ERRORS: error: instruction 'hlt' is not predicable, but condition code specified
 @CHECK-ERRORS:        hlteq #2
 @CHECK-ERRORS:        ^
 @CHECK-ERRORS: error: instruction 'hlt' is not predicable, but condition code specified
 @CHECK-ERRORS:        hltlt #23
 @CHECK-ERRORS:        ^
 
         @ Out of range 4 and 3 bit immediates on CDP[2]
 
         @ Out of range immediates for CDP/CDP2
         cdp  p7, #2, c1, c1, c1, #8
         cdp  p7, #1, c1, c1, c1, #8
         cdp2  p7, #2, c1, c1, c1, #8
         cdp2  p7, #1, c1, c1, c1, #8
 
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
 
         @ Out of range immediates for DBG
         dbg #-1
         dbg #16
 
-@ CHECK-ERRORS: error: immediate operand must be in the range [0,15]
-@ CHECK-ERRORS: error: immediate operand must be in the range [0,15]
+@ CHECK-ERRORS-V7: error: immediate operand must be in the range [0,15]
+@ CHECK-ERRORS-V7: error: immediate operand must be in the range [0,15]
+@ CHECK-ERRORS-V8: error: immediate operand must be in the range [0,15]
+@ CHECK-ERRORS-V8: error: immediate operand must be in the range [0,15]
 @  Double-check that we're synced up with the right diagnostics.
 @ CHECK-ERRORS: dbg #16
 
         @ Out of range immediate for MCR/MCR2/MCRR/MCRR2
         mcr  p7, #8, r5, c1, c1, #4
         mcr  p7, #2, r5, c1, c1, #8
         mcr2  p7, #8, r5, c1, c1, #4
         mcr2  p7, #1, r5, c1, c1, #8
         mcrr  p7, #16, r5, r4, c1
         mcrr2  p7, #16, r5, r4, c1
 @ CHECK-ERRORS: error: invalid operand for instruction
 @ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: too many operands for instruction
 @ CHECK-ERRORS: error: immediate operand must be in the range [0,15]
 @ CHECK-ERRORS-V7: error: immediate operand must be in the range [0,15]
-@ CHECK-ERRORS-V8: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
 
         @ p10 and p11 are reserved for NEON
         mcr p10, #2, r5, c1, c1, #4
         mcrr p11, #8, r5, r4, c1
 @ CHECK-ERRORS: error: invalid operand for instruction
 @ CHECK-ERRORS: error: invalid operand for instruction
 
         @ Out of range immediate for MOV
         movw r9, 0x10000
 @ CHECK-ERRORS: error: invalid operand for instruction
 
         @ Invalid 's' bit usage for MOVW
         movs r6, #0xffff
         movwseq r9, #0xffff
 @ CHECK-ERRORS: error: invalid operand for instruction
 @ CHECK-ERRORS: error: instruction 'movw' can not set flags, but 's' suffix specified
 
         @ Out of range immediate for MOVT
         movt r9, 0x10000
 @ CHECK-ERRORS: error: invalid operand for instruction
 
         @ Out of range immediates for MRC/MRC2/MRRC/MRRC2
         mrc  p14, #8, r1, c1, c2, #4
         mrc  p14, #1, r1, c1, c2, #8
         mrc2  p14, #8, r1, c1, c2, #4
         mrc2  p14, #0, r1, c1, c2, #9
         mrrc  p7, #16, r5, r4, c1
         mrrc2  p7, #17, r5, r4, c1
 @ CHECK-ERRORS: error: invalid operand for instruction
 @ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: too many operands for instruction
 @ CHECK-ERRORS: error: immediate operand must be in the range [0,15]
 @ CHECK-ERRORS-V7: error: immediate operand must be in the range [0,15]
-@ CHECK-ERRORS-V8: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
 
         @ Shifter operand validation for PKH instructions.
         pkhbt r2, r2, r3, lsl #-1
         pkhbt r2, r2, r3, lsl #32
         pkhtb r2, r2, r3, asr #0
         pkhtb r2, r2, r3, asr #33
         pkhbt r2, r2, r3, asr #3
         pkhtb r2, r2, r3, lsl #3

test/MC/ARM/directive-arch_extension-fp.s

@ RUN:   | FileCheck %s -check-prefix CHECK-V8 -check-prefix CHECK
   .arch_extension fp
 @ CHECK-V7: error: architectural extension 'fp' is not allowed for the current base architecture
 @ CHECK-V7-NEXT:  .arch_extension fp
 @ CHECK-V7-NEXT:                     ^
 
   .type fp,%function
 fp:
   vmrs r0, mvfr2
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vselgt.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vselge.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vseleq.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vselvs.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vmaxnm.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vminnm.f32 s0, s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vselgt.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vselge.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vseleq.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vselvs.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vmaxnm.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vminnm.f64 d0, d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vcvtb.f64.f16 d0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtb.f16.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtt.f64.f16 d0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtt.f16.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vcvta.s32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvta.u32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvta.s32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvta.u32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtn.s32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtn.u32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtn.s32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtn.u32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtp.s32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtp.u32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtp.s32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtp.u32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtm.s32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtm.u32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtm.s32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vcvtm.u32.f64 s0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vrintz.f32 s0, s1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintz.f64 d0, d1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintz.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintz.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintr.f32 s0, s1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintr.f64 d0, d1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintr.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintr.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintx.f32 s0, s1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintx.f64 d0, d1
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintx.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintx.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   vrinta.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrinta.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrinta.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrinta.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintn.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintn.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintn.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintn.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintp.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintp.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintp.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintp.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintm.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintm.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintm.f32.f32 s0, s0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
   vrintm.f64.f64 d0, d0
-@ CHECK-V7: error: instruction requires: FPARMv8
+@ CHECK-V7: instruction requires: FPARMv8
 
   .arch_extension nofp
 @ CHECK-V7: error: architectural extension 'fp' is not allowed for the current base architecture
 @ CHECK-V7-NEXT:  .arch_extension nofp
 @ CHECK-V7-NEXT:                     ^
 
   .type nofp,%function
 nofp:
   vmrs r0, mvfr2
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vselgt.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vselge.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vseleq.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vselvs.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vmaxnm.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vminnm.f32 s0, s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vselgt.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vselge.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vseleq.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vselvs.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vmaxnm.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vminnm.f64 d0, d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vcvtb.f64.f16 d0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtb.f16.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtt.f64.f16 d0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtt.f16.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vcvta.s32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvta.u32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvta.s32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvta.u32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtn.s32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtn.u32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtn.s32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtn.u32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtp.s32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtp.u32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtp.s32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtp.u32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtm.s32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtm.u32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtm.s32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vcvtm.u32.f64 s0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vrintz.f32 s0, s1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintz.f64 d0, d1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintz.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintz.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintr.f32 s0, s1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintr.f64 d0, d1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintr.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintr.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintx.f32 s0, s1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintx.f64 d0, d1
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintx.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintx.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 
   vrinta.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrinta.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrinta.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrinta.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintn.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintn.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintn.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintn.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintp.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintp.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintp.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintp.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintm.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintm.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintm.f32.f32 s0, s0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
   vrintm.f64.f64 d0, d0
-@ CHECK: error: instruction requires: FPARMv8
+@ CHECK: instruction requires: FPARMv8
 

test/MC/ARM/directive-arch_extension-idiv.s

 @ CHECK-V7M: error: architectural extension 'idiv' is not allowed for the current base architecture
 @ CHECK-V7M-NEXT:   .arch_extension idiv
 @ CHECK-V7M-NEXT:                     ^
 
   .type idiv,%function
 idiv:
   udiv r0, r1, r2
 @ CHECK-ARMv6: error: instruction requires: divide in ARM
-@ CHECK-THUMBv6: error: instruction requires: divide in ARM arm-mode
+@ CHECK-THUMBv6: error: instruction requires: divide in THUMB armv8m.base
   sdiv r0, r1, r2
 @ CHECK-ARMv6: error: instruction requires: divide in ARM
-@ CHECK-THUMBv6: error: instruction requires: divide in ARM arm-mode
+@ CHECK-THUMBv6: error: instruction requires: divide in THUMB armv8m.base
 
   .arch_extension noidiv
 @ CHECK-V6: error: architectural extension 'idiv' is not allowed for the current base architecture
 @ CHECK-V6-NEXT:  .arch_extension noidiv
 @ CHECK-V6-NEXT:                     ^
 @ CHECK-V7M: error: architectural extension 'idiv' is not allowed for the current base architecture
 @ CHECK-V7M-NEXT:   .arch_extension noidiv
 @ CHECK-V7M-NEXT:                     ^
 
   .type noidiv,%function
 noidiv:
   udiv r0, r1, r2
 @ CHECK-ARMv6: error: instruction requires: divide in ARM
-@ CHECK-THUMBv6: error: instruction requires: divide in ARM arm-mode
+@ CHECK-THUMBv6: error: instruction requires: divide in THUMB armv8m.base
 @ CHECK-ARMv7: error: instruction requires: divide in ARM
 @ CHECK-THUMBv7: error: instruction requires: divide in THUMB
   sdiv r0, r1, r2
 @ CHECK-ARMv6: error: instruction requires: divide in ARM
-@ CHECK-THUMBv6: error: instruction requires: divide in ARM arm-mode
+@ CHECK-THUMBv6: error: instruction requires: divide in THUMB armv8m.base
 @ CHECK-ARMv7: error: instruction requires: divide in ARM
 @ CHECK-THUMBv7: error: instruction requires: divide in THUMB
 

test/MC/ARM/fp-const-errors.s

 @ RUN: not llvm-mc -mcpu=cortex-a8 -triple armv7-none-linux-gnueabi < %s 2>&1 | FileCheck %s
 
 @ Test for floating point constants that are out of the 8-bit encoded value range
 vmov.f32 s2, #32.0
-@ CHECK: error: invalid operand for instruction
+@ CHECK: invalid operand for instruction
 
 vmov.f64 d2, #32.0
-@ CHECK: error: invalid operand for instruction
+@ CHECK: invalid operand for instruction
 
 @ Test that vmov.f instructions do not accept an 8-bit encoded float as an operand
 vmov.f32 s1, #0x70
 @ CHECK: error: invalid floating point immediate
 
 vmov.f64 d2, #0x70
 @ CHECK: error: invalid floating point immediate
 
 @ Test that fconst instructions do not accept a float constant as an operand
 fconsts s1, #1.0
 @ CHECK: error: invalid floating point immediate
 
 fconstd d2, #1.0
 @ CHECK: error: invalid floating point immediate
 
 vmov.i64 d0, 0x8000000000000000
-@ CHECK: error: invalid operand for instruction
+@ CHECK: invalid operand for instruction

test/MC/ARM/fullfp16-neg.s

 @ RUN: not llvm-mc -triple armv8a-none-eabi -mattr=-fullfp16 -show-encoding < %s 2>&1 | FileCheck %s
 @ RUN: not llvm-mc -triple armv8a-none-eabi -mattr=-fullfp16,+thumb-mode -show-encoding < %s 2>&1 | FileCheck %s
 
          vadd.f16  s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vsub.f16  s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vdiv.f16  s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vmul.f16  s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vnmul.f16       s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vmla.f16        s1, s2, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vmls.f16        s1, s2, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vnmla.f16       s1, s2, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vnmls.f16       s1, s2, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vcmp.f16 s0, s1
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vcmp.f16 s2, #0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vcmpe.f16       s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vcmpe.f16       s0, #0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vabs.f16        s0, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vneg.f16        s0, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vsqrt.f16       s0, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
          vcvt.f16.s32    s0, s0
          vcvt.f16.u32    s0, s0
          vcvt.s32.f16    s0, s0
          vcvt.u32.f16    s0, s0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
          vcvtr.s32.f16  s0, s1
          vcvtr.u32.f16  s0, s1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
          vcvt.f16.u32 s0, s0, #20
          vcvt.f16.u16 s0, s0, #1
          vcvt.f16.s32 s1, s1, #20
          vcvt.f16.s16 s17, s17, #1
          vcvt.u32.f16 s12, s12, #20
          vcvt.u16.f16 s28, s28, #1
          vcvt.s32.f16 s1, s1, #20
          vcvt.s16.f16 s17, s17, #1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvta.s32.f16 s2, s3
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtn.s32.f16 s6, s23
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtp.s32.f16 s0, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtm.s32.f16 s17, s8
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvta.u32.f16 s2, s3
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtn.u32.f16 s6, s23
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtp.u32.f16 s0, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtm.u32.f16 s17, s8
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vselge.f16 s4, s1, s23
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vselgt.f16 s0, s1, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vseleq.f16 s30, s28, s23
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vselvs.f16 s21, s16, s14
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vmaxnm.f16 s5, s12, s0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vminnm.f16 s0, s0, s12
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintz.f16 s3, s24
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintr.f16 s0, s9
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintx.f16 s10, s14
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrinta.f16 s12, s1
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintn.f16 s12, s1
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintp.f16 s12, s1
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrintm.f16 s12, s1
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vfma.f16 s2, s7, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vfms.f16 s2, s7, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vfnma.f16 s2, s7, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vfnms.f16 s2, s7, s4
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vmovx.f16 s2, s5
   vins.f16 s2, s5
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
 
   vldr.16 s1, [pc, #6]
   vldr.16 s2, [pc, #510]
   vldr.16 s3, [pc, #-510]
   vldr.16 s4, [r4, #-18]
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
 
   vstr.16 s1, [pc, #6]
   vstr.16 s2, [pc, #510]
   vstr.16 s3, [pc, #-510]
   vstr.16 s4, [r4, #-18]
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmov.f16 s0, #1.0
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vmov.f16 s1, r2
   vmov.f16 r3, s4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:

test/MC/ARM/fullfp16-neon-neg.s

 @ RUN: not llvm-mc -triple armv8a-none-eabi -mattr=-fullfp16,+neon -show-encoding < %s 2>&1 | FileCheck %s
 @ RUN: not llvm-mc -triple armv8a-none-eabi -mattr=+fullfp16,-neon -show-encoding < %s 2>&1 | FileCheck %s
 @ RUN: not llvm-mc -triple thumbv8a-none-eabi -mattr=-fullfp16,+neon -show-encoding < %s 2>&1 | FileCheck %s
 @ RUN: not llvm-mc -triple thumbv8a-none-eabi -mattr=+fullfp16,-neon -show-encoding < %s 2>&1 | FileCheck %s
 
   vadd.f16 d0, d1, d2
   vadd.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vsub.f16 d0, d1, d2
   vsub.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmul.f16 d0, d1, d2
   vmul.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmul.f16 d1, d2, d3[2]
   vmul.f16 q4, q5, d6[3]
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmla.f16 d0, d1, d2
   vmla.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmla.f16 d5, d6, d7[2]
   vmla.f16 q5, q6, d7[3]
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmls.f16 d0, d1, d2
   vmls.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmls.f16 d5, d6, d7[2]
   vmls.f16 q5, q6, d7[3]
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vfma.f16 d0, d1, d2
   vfma.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vfms.f16 d0, d1, d2
   vfms.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vceq.f16 d2, d3, d4
   vceq.f16 q2, q3, q4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vceq.f16 d2, d3, #0
   vceq.f16 q2, q3, #0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcge.f16 d2, d3, d4
   vcge.f16 q2, q3, q4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcge.f16 d2, d3, #0
   vcge.f16 q2, q3, #0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcgt.f16 d2, d3, d4
   vcgt.f16 q2, q3, q4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcgt.f16 d2, d3, #0
   vcgt.f16 q2, q3, #0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcle.f16 d2, d3, d4
   vcle.f16 q2, q3, q4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcle.f16 d2, d3, #0
   vcle.f16 q2, q3, #0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vclt.f16 d2, d3, d4
   vclt.f16 q2, q3, q4
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vclt.f16 d2, d3, #0
   vclt.f16 q2, q3, #0
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vacge.f16 d0, d1, d2
   vacge.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vacgt.f16 d0, d1, d2
   vacgt.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vacle.f16 d0, d1, d2
   vacle.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vaclt.f16 d0, d1, d2
   vaclt.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vabd.f16 d0, d1, d2
   vabd.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vabs.f16 d0, d1
   vabs.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmax.f16 d0, d1, d2
   vmax.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmin.f16 d0, d1, d2
   vmin.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vmaxnm.f16 d0, d1, d2
   vmaxnm.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vminnm.f16 d0, d1, d2
   vminnm.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vpadd.f16 d0, d1, d2
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vpmax.f16 d0, d1, d2
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vpmin.f16 d0, d1, d2
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
 
   vrecpe.f16 d0, d1
   vrecpe.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrecps.f16 d0, d1, d2
   vrecps.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrsqrte.f16 d0, d1
   vrsqrte.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrsqrts.f16 d0, d1, d2
   vrsqrts.f16 q0, q1, q2
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vneg.f16 d0, d1
   vneg.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvt.s16.f16 d0, d1
   vcvt.u16.f16 d0, d1
   vcvt.f16.s16 d0, d1
   vcvt.f16.u16 d0, d1
   vcvt.s16.f16 q0, q1
   vcvt.u16.f16 q0, q1
   vcvt.f16.s16 q0, q1
   vcvt.f16.u16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvta.s16.f16 d0, d1
   vcvta.s16.f16 q0, q1
   vcvta.u16.f16 d0, d1
   vcvta.u16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtm.s16.f16 d0, d1
   vcvtm.s16.f16 q0, q1
   vcvtm.u16.f16 d0, d1
   vcvtm.u16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtn.s16.f16 d0, d1
   vcvtn.s16.f16 q0, q1
   vcvtn.u16.f16 d0, d1
   vcvtn.u16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vcvtp.s16.f16 d0, d1
   vcvtp.s16.f16 q0, q1
   vcvtp.u16.f16 d0, d1
   vcvtp.u16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
 
   vcvt.s16.f16 d0, d1, #1
   vcvt.u16.f16 d0, d1, #2
   vcvt.f16.s16 d0, d1, #3
   vcvt.f16.u16 d0, d1, #4
   vcvt.s16.f16 q0, q1, #5
   vcvt.u16.f16 q0, q1, #6
   vcvt.f16.s16 q0, q1, #7
   vcvt.f16.u16 q0, q1, #8
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrinta.f16.f16 d0, d1
   vrinta.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrintm.f16.f16 d0, d1
   vrintm.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrintn.f16.f16 d0, d1
   vrintn.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrintp.f16.f16 d0, d1
   vrintp.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrintx.f16.f16 d0, d1
   vrintx.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:
 
   vrintz.f16.f16 d0, d1
   vrintz.f16.f16 q0, q1
-@ CHECK: error: instruction requires:
-@ CHECK: error: instruction requires:
+@ CHECK: instruction requires:
+@ CHECK: instruction requires:

test/MC/ARM/invalid-fp-armv8.s

@ V8: error: invalid instruction
   vsells.f32 s3, s4, s6
 @ V8: error: invalid instruction
   vsellt.f32 s3, s4, s6
 @ V8: error: invalid instruction
   vselle.f32 s3, s4, s6
 @ V8: error: invalid instruction
 
 vseleq.f32 s0, d2, d1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vselgt.f64 s3, s2, s1
 @ V8: error: invalid operand for instruction
 vselgt.f32 s0, q3, q1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vselgt.f64 q0, s3, q1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 
 vmaxnm.f32 s0, d2, d1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vminnm.f64 s3, s2, s1
 @ V8: error: invalid operand for instruction
 vmaxnm.f32 s0, q3, q1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vmaxnm.f64 q0, s3, q1
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vmaxnmgt.f64 q0, s3, q1
 @ CHECK: error: instruction 'vmaxnm' is not predicable, but condition code specified
 
 vcvta.s32.f64 d3, s2
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vcvtp.s32.f32 d3, s2
 @ V8: error: invalid operand for instruction
 vcvtn.u32.f64 d3, s2
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vcvtm.u32.f32 d3, s2
 @ V8: error: invalid operand for instruction
 vcvtnge.u32.f64 d3, s2
 @ V8: error: instruction 'vcvtn' is not predicable, but condition code specified
 
 vcvtbgt.f64.f16 q0, d3
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vcvttlt.f64.f16 s0, s3
-@ V8: error: invalid operand for instruction
+@ V8: note: for one encoding: invalid operand for instruction
 vcvttvs.f16.f64 s0, s3
-@ V8: error: invalid operand for instruction
+@ V8: note: for one encoding: invalid operand for instruction
 vcvtthi.f16.f64 q0, d3
 @ V8: error: invalid operand for instruction
 
 vrintrlo.f32.f32 d3, q0
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vrintxcs.f32.f32 d3, d0
 @ V8: error: instruction requires: NEON
 
 vrinta.f64.f64 s3, q0
-@ V8: error: invalid operand for instruction
+@ V8: error: invalid instruction
 vrintn.f32.f32 d3, d0
 @ V8: error: instruction requires: NEON
 vrintp.f32 q3, q0
 @ V8: error: instruction requires: NEON
 vrintmlt.f32 q3, q0
 @ V8: error: instruction 'vrintm' is not predicable, but condition code specified

test/MC/ARM/invalid-hint-thumb.s

 @ RUN: not llvm-mc -triple=thumbv7-apple-darwin -mcpu=cortex-a8 < %s 2>&1 | FileCheck %s
 
 hint #240
 hint #1000
 
-@ CHECK: error: immediate operand must be in the range [0,239]
-@ CHECK: error: immediate operand must be in the range [0,239]
+@ CHECK: note: for one encoding: immediate operand must be in the range [0,239]
+@ CHECK: note: for one encoding: immediate operand must be in the range [0,239]
 

test/MC/ARM/invalid-idiv.s

 @ RUN: not llvm-mc -triple=armv7 -mcpu=cortex-a15 -mattr=-hwdiv-arm < %s 2> %t
 @ RUN: FileCheck --check-prefix=ARM-A15 < %t %s
 @ RUN: not llvm-mc -triple=thumbv7 -mcpu=cortex-a15 -mattr=-hwdiv < %s 2> %t
 @ RUN: FileCheck --check-prefix=THUMB-A15 < %t %s
 @ RUN: not llvm-mc -triple=armv7 < %s 2> %t
 @ RUN: FileCheck --check-prefix=ARM < %t %s
 @ RUN: not llvm-mc -triple=thumbv7 < %s 2> %t
 @ RUN: FileCheck --check-prefix=THUMB < %t %s
 
         sdiv  r1, r2, r3
         udiv  r3, r4, r5
-@ ARM-A15: error: instruction requires: divide in ARM
+@ ARM-A15: note: for one encoding: instruction requires: divide in ARM
+@ ARM-A15: note: for one encoding: instruction requires: thumb
 @ ARM-A15: sdiv r1, r2, r3
-@ ARM-A15: error: instruction requires: divide in ARM
+@ ARM-A15: note: for one encoding: instruction requires: divide in ARM
+@ ARM-A15: note: for one encoding: instruction requires: thumb
 @ ARM-A15: udiv r3, r4, r5
-@ THUMB-A15: error: instruction requires: arm-mode
+@ THUMB-A15: note: for one encoding: instruction requires: arm-mode 
+@ THUMB-A15: note: for one encoding: instruction requires: divide in THUMB
 @ THUMB-A15: sdiv r1, r2, r3
-@ THUMB-A15: error: instruction requires: arm-mode
+@ THUMB-A15: note: for one encoding: instruction requires: arm-mode 
+@ THUMB-A15: note: for one encoding: instruction requires: divide in THUMB
 @ THUMB-A15: udiv r3, r4, r5
 
 @ ARM: error: instruction requires: divide in ARM
 @ ARM: sdiv r1, r2, r3
 @ ARM: error: instruction requires: divide in ARM
 @ ARM: udiv r3, r4, r5
 @ THUMB: error: instruction requires: divide in THUMB
 @ THUMB: sdiv r1, r2, r3
 @ THUMB: error: instruction requires: divide in THUMB
 @ THUMB: udiv r3, r4, r5

test/MC/ARM/invalid-neon-v8.s

 @ RUN: not llvm-mc -triple armv8 -mattr=-fp-armv8 -show-encoding < %s 2>&1 | FileCheck %s
 
 vmaxnm.f32 s4, d5, q1
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 vmaxnm.f64.f64 s4, d5, q1
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 vmaxnmge.f64.f64 s4, d5, q1
 @ CHECK: error: instruction 'vmaxnm' is not predicable, but condition code specified
 
 vcvta.s32.f32 s1, s2
 @ CHECK: error: instruction requires: FPARMv8
 vcvtp.u32.f32 s1, d2
 @ CHECK: error: invalid operand for instruction
 vcvtp.f32.u32 d1, q2
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 vcvtplo.f32.u32 s1, s2
 @ CHECK: error: instruction 'vcvtp' is not predicable, but condition code specified
 
 vrinta.f64.f64 s3, d12
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 vrintn.f32 d3, q12
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
 vrintz.f32 d3, q12
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
 vrintmge.f32.f32 d3, d4
 @ CHECK: error: instruction 'vrintm' is not predicable, but condition code specified
 
 aesd.8  q0, s1
 @ CHECK: error: invalid operand for instruction
 aese.8  s0, q1
 @ CHECK: error: invalid operand for instruction
 aesimc.8  s0, q1
 @ CHECK: error: invalid operand for instruction
 aesmc.8  q0, d1
 @ CHECK: error: invalid operand for instruction
 aesdge.8 q0, q1
 @ CHECK: error: instruction 'aesd' is not predicable, but condition code specified
 
 sha1h.32  d0, q1
 @ CHECK: error: invalid operand for instruction
 sha1su1.32  q0, s1
 @ CHECK: error: invalid operand for instruction
 sha256su0.32  s0, q1
 @ CHECK: error: invalid operand for instruction
 sha1heq.32  q0, q1
 @ CHECK: error: instruction 'sha1h' is not predicable, but condition code specified
 
 sha1c.32  s0, d1, q2
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 sha1m.32  q0, s1, q2
 @ CHECK: error: invalid operand for instruction
 sha1p.32  s0, q1, q2
 @ CHECK: error: invalid operand for instruction
 sha1su0.32  d0, q1, q2
 @ CHECK: error: invalid operand for instruction
 sha256h.32  q0, s1, q2
 @ CHECK: error: invalid operand for instruction
 sha256h2.32  q0, q1, s2
 @ CHECK: error: invalid operand for instruction
 sha256su1.32  s0, d1, q2
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 sha256su1lt.32  q0, d1, q2
 @ CHECK: error: instruction 'sha256su1' is not predicable, but condition code specified
 
 vmull.p64 q0, s1, s3
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
 vmull.p64 s1, d2, d3
 @ CHECK: error: invalid operand for instruction
 vmullge.p64 q0, d16, d17
 @ CHECK: error: instruction 'vmull' is not predicable, but condition code specified

test/MC/ARM/invalid-special-reg.s

 @ RUN: not llvm-mc -triple armv7a--none-eabi < %s 2>&1 | FileCheck %s
 @ RUN: not llvm-mc -triple thumbv7a--none-eabi < %s 2>&1 | FileCheck %s
 
   msr apsr_c, r0
 @ CHECK: invalid operand for instruction
-  msr cpsr_w
+  msr cpsr_w, r0
 @ CHECK: invalid operand for instruction
-  msr cpsr_cc
+  msr cpsr_cc, r0
 @ CHECK: invalid operand for instruction
-  msr xpsr_c
+  msr xpsr_c, r0
 @ CHECK: invalid operand for instruction

test/MC/ARM/ldr-pseudo-unpredictable.s

 @RUN: llvm-mc -triple armv5-unknown-linux-gnueabi %s | FileCheck --check-prefix=CHECK-ARM %s
 @RUN: not llvm-mc -triple thumbv7-unknown-linux-gnueabi %s 2>&1 | FileCheck --check-prefix=CHECK-SP %s
 @RUN: not llvm-mc -triple thumbv5-unknown-linux-gnueabi %s 2>&1 | FileCheck --check-prefix=CHECK-NONE %s
 @RUN: llvm-mc -triple armv5-base-apple-darwin %s | FileCheck --check-prefix=CHECK-DARWIN-ARM %s
 @RUN: not llvm-mc -triple thumbv7-base-apple-darwin %s 2>&1 | FileCheck --check-prefix=CHECK-DARWIN-SP %s
 @RUN: not llvm-mc -triple thumbv5-base.apple.darwin %s 2>&1 | FileCheck --check-prefix=CHECK-NONE %s
 
 @ We dont't do the transformation for rt = sp or pc
 @ as it is unpredictable for many of the MOV encondings
   ldr pc, = 0x4
 @ CHECK-ARM: ldr pc, .Ltmp[[TMP0:[0-9]+]]
 @ CHECK-DARWIN-ARM: ldr pc, Ltmp0
-@ CHECK-SP: error: instruction requires: arm-mode
-@ CHECK-DARWIN-SP: error: instruction requires: arm-mode
-@ CHECK-NONE: error: instruction requires: arm-mode
+@ CHECK-SP: instruction requires: arm-mode
+@ CHECK-DARWIN-SP: instruction requires: arm-mode
+@ CHECK-NONE: instruction requires: arm-mode
   ldr sp, = 0x8
 @ CHECK-ARM: ldr sp, .Ltmp[[TMP1:[0-9]+]]
 @ CHECK-DARWIN-ARM: ldr sp, Ltmp1
 @ CHECK-SP: ldr.w sp, .Ltmp[[TMP0:[0-9]+]]
 @ CHECK-DARWIN-SP: ldr.w sp, Ltmp0
-@ CHECK-NONE: error: instruction requires: arm-mode
+@ CHECK-NONE: instruction requires: arm-mode

test/MC/ARM/ldrd-strd-gnu-arm-bad-imm.s

 @ RUN: not llvm-mc -triple=armv7-linux-gnueabi %s 2>&1 | FileCheck %s
 .text
-@ CHECK: error: instruction requires: thumb2
+@ CHECK: note: for one encoding: invalid operand for instruction
+@ CHECK: note: for one encoding: instruction requires: thumb2
 @ CHECK:         ldrd    r0, [r0, #512]
         ldrd    r0, [r0, #512]
 
-@ CHECK: error: instruction requires: thumb2
+@ CHECK: note: for one encoding: invalid operand for instruction
+@ CHECK: note: for one encoding: instruction requires: thumb2
 @ CHECK:         strd    r0, [r0, #512]
         strd    r0, [r0, #512]

test/MC/ARM/lsl-zero-errors.s

 // RUN: not llvm-mc -triple=thumbv7 -show-encoding < %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NONARM --check-prefix=CHECK-THUMBV7 %s
 // RUN: not llvm-mc -triple=thumbv8 -show-encoding < %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NONARM --check-prefix=CHECK-THUMBV8 %s
 // RUN: llvm-mc -triple=armv7 -show-encoding < %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-ARM %s
 
         // lsl #0 is actually mov, so here we check that it behaves the same as
         // mov with regards to the permitted registers
 
         // Using PC is invalid in thumb
         lsl pc, r0, #0
         lsl r0, pc, #0
         lsl pc, pc, #0
         lsls pc, r0, #0
         lsls r0, pc, #0
         lsls pc, pc, #0
 
-// CHECK-NONARM: error: instruction requires: arm-mode
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsl pc, r0, #0
-// CHECK-NONARM: error: instruction requires: arm-mode
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsl r0, pc, #0
 // CHECK-NONARM: error: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsl pc, pc, #0
-// CHECK-NONARM: error: instruction requires: arm-mode
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsls pc, r0, #0
-// CHECK-NONARM: error: instruction requires: arm-mode
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsls r0, pc, #0
 // CHECK-NONARM: error: instruction requires: arm-mode
 // CHECK-NONARM-NEXT: lsls pc, pc, #0
 
 // CHECK-ARM: mov pc, r0                @ encoding: [0x00,0xf0,0xa0,0xe1]
 // CHECK-ARM: mov r0, pc                @ encoding: [0x0f,0x00,0xa0,0xe1]
 // CHECK-ARM: mov pc, pc                @ encoding: [0x0f,0xf0,0xa0,0xe1]
 // CHECK-ARM: movs pc, r0               @ encoding: [0x00,0xf0,0xb0,0xe1]
 // CHECK-ARM: movs r0, pc               @ encoding: [0x0f,0x00,0xb0,0xe1]
 // CHECK-ARM: movs pc, pc               @ encoding: [0x0f,0xf0,0xb0,0xe1]
 
         mov pc, r0, lsl #0
         mov r0, pc, lsl #0
         mov pc, pc, lsl #0
         movs pc, r0, lsl #0
         movs r0, pc, lsl #0
         movs pc, pc, lsl #0
 
 // FIXME: Really the error we should be giving is "requires: arm-mode"
-// CHECK-NONARM: error: invalid operand for instruction
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: invalid operand for instruction
 // CHECK-NONARM-NEXT: mov pc, r0, lsl #0
-// CHECK-NONARM: error: invalid operand for instruction
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: invalid operand for instruction
 // CHECK-NONARM-NEXT: mov r0, pc, lsl #0
-// CHECK-NONARM: error: invalid operand for instruction
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: invalid operand for instruction
 // CHECK-NONARM-NEXT: mov pc, pc, lsl #0
 // CHECK-NONARM: error: invalid operand for instruction
 // CHECK-NONARM-NEXT: movs pc, r0, lsl #0
-// CHECK-NONARM: error: invalid operand for instruction
+// CHECK-NONARM: error: invalid instruction, multiple near-miss encodings found
+// CHECK-NONARM: invalid operand for instruction
 // CHECK-NONARM-NEXT: movs r0, pc, lsl #0
 // CHECK-NONARM: error: invalid operand for instruction
 // CHECK-NONARM-NEXT: movs pc, pc, lsl #0
 
 // CHECK-ARM: mov pc, r0                @ encoding: [0x00,0xf0,0xa0,0xe1]
 // CHECK-ARM: mov r0, pc                @ encoding: [0x0f,0x00,0xa0,0xe1]
 // CHECK-ARM: mov pc, pc                @ encoding: [0x0f,0xf0,0xa0,0xe1]
 // CHECK-ARM: movs pc, r0               @ encoding: [0x00,0xf0,0xb0,0xe1]
 // CHECK-ARM: movs r0, pc               @ encoding: [0x0f,0x00,0xb0,0xe1]
 // CHECK-ARM: movs pc, pc               @ encoding: [0x0f,0xf0,0xb0,0xe1]
 
         // Using SP is invalid before ARMv8 in thumb unless non-flags-setting
         // and one of the source and destination is not SP
         lsl sp, sp, #0
         lsls sp, sp, #0
         lsls r0, sp, #0
         lsls sp, r0, #0
 
-// CHECK-THUMBV7: error: instruction variant requires ARMv8 or later
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: instruction variant requires ARMv8 or later
 // CHECK-THUMBV7-NEXT: lsl sp, sp, #0
-// CHECK-THUMBV7: error: instruction variant requires ARMv8 or later
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: instruction variant requires ARMv8 or later
 // CHECK-THUMBV7-NEXT: lsls sp, sp, #0
-// CHECK-THUMBV7: error: instruction variant requires ARMv8 or later
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: instruction variant requires ARMv8 or later
 // CHECK-THUMBV7-NEXT: lsls r0, sp, #0
-// CHECK-THUMBV7: error: instruction variant requires ARMv8 or later
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: instruction variant requires ARMv8 or later
 // CHECK-THUMBV7-NEXT: lsls sp, r0, #0
 
 // CHECK-ARM: mov sp, sp                @ encoding: [0x0d,0xd0,0xa0,0xe1]
 // CHECK-ARM: movs sp, sp               @ encoding: [0x0d,0xd0,0xb0,0xe1]
 // CHECK-ARM: movs r0, sp               @ encoding: [0x0d,0x00,0xb0,0xe1]
 // CHECK-ARM: movs sp, r0               @ encoding: [0x00,0xd0,0xb0,0xe1]
 
         mov sp, sp, lsl #0
         movs sp, sp, lsl #0
         movs r0, sp, lsl #0
         movs sp, r0, lsl #0
 
 // FIXME: We should consistently have the "requires ARMv8" error here
-// CHECK-THUMBV7: error: invalid operand for instruction
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: invalid operand for instruction
 // CHECK-THUMBV7-NEXT: mov sp, sp, lsl #0
-// CHECK-THUMBV7: error: invalid operand for instruction
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: invalid operand for instruction
 // CHECK-THUMBV7-NEXT: movs sp, sp, lsl #0
-// CHECK-THUMBV7: error: instruction variant requires ARMv8 or later
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: instruction variant requires ARMv8 or later
 // CHECK-THUMBV7-NEXT: movs r0, sp, lsl #0
-// CHECK-THUMBV7: error: invalid operand for instruction
+// CHECK-THUMBV7: error: invalid instruction, multiple near-miss encodings found
+// CHECK-THUMBV7: invalid operand for instruction
 // CHECK-THUMBV7-NEXT: movs sp, r0, lsl #0
 
 // CHECK-ARM: mov sp, sp                @ encoding: [0x0d,0xd0,0xa0,0xe1]
 // CHECK-ARM: movs sp, sp               @ encoding: [0x0d,0xd0,0xb0,0xe1]
 // CHECK-ARM: movs r0, sp               @ encoding: [0x0d,0x00,0xb0,0xe1]
 // CHECK-ARM: movs sp, r0               @ encoding: [0x00,0xd0,0xb0,0xe1]

test/MC/ARM/negative-immediates-thumb1-fail.s

 # RUN: not llvm-mc -triple thumbv7 -mcpu=cortex-m0 %s 2>&1 | FileCheck %s
 
 .thumb
 
 ADDs r1, r0, #0xFFFFFFF5
-# CHECK: error: instruction requires: arm-mode
+# CHECK: note: for one encoding: instruction requires: thumb2
+# CHECK: note: for one encoding: invalid operand for instruction
 
 ADDs r0, #0xFFFFFEFF
 # CHECK: error: invalid operand for instruction
 
 SUBs r1, r0, #0xFFFFFFF5
-# CHECK: error: instruction requires: arm-mode
+# CHECK: error: invalid operand for instruction
 
 SUBs r0, #0xFFFFFEFF
 # CHECK: error: invalid operand for instruction

test/MC/ARM/negative-immediates-thumb1.s

 # RUN: llvm-mc -triple thumbv7 -mcpu=cortex-m0 %s -show-encoding | FileCheck %s
 # RUN: not llvm-mc -triple thumbv7 -mcpu=cortex-m0 %s -show-encoding -mattr=+no-neg-immediates 2>&1 | FileCheck %s -check-prefix=CHECK-DISABLED
 
 .thumb
 
   ADDs r1, r0, #0xFFFFFFF9
 # CHECK: subs r1, r0, #7
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
   ADDs r0, #0xFFFFFF01
 # CHECK: subs r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 
   SUBs r0, #0xFFFFFF01
 # CHECK: adds r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 
   SUBs r1, r0, #0xFFFFFFF9
 # CHECK: adds r1, r0, #7
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates

test/MC/ARM/negative-immediates.s

 # RUN: llvm-mc -triple armv7 %s -show-encoding | FileCheck %s
 # RUN: not llvm-mc -triple armv7 %s -show-encoding -mattr=+no-neg-immediates 2>&1 | FileCheck %s -check-prefix=CHECK-DISABLED
 
 .arm
 
   ADC r0, r1, #0xFFFFFF00
 # CHECK: sbc r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADC r0, r1, #0xFFFFFE03
 # CHECK: sbc r0, r1, #508
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADD r0, r1, #0xFFFFFF01
 # CHECK: sub r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADD
   AND r0, r1, #0xFFFFFF00
 # CHECK: bic r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: AND
   BIC r0, r1, #0xFFFFFF00
 # CHECK: and r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: BIC
   CMP r0, #0xFFFFFF01
 # CHECK: cmn r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: CMP
   CMN r0, #0xFFFFFF01
 # CHECK: cmp r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: CMN
   MOV r0, #0xFFFFFF00
 # CHECK: mvn r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: MOV
   MVN r0, #0xFFFFFF00
 # CHECK: mov r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: MVN
   SBC r0, r1, #0xFFFFFF00
 # CHECK: adc r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: SBC
   SUB r0, r1, #0xFFFFFF01
 # CHECK: add r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: SUB
 
 .thumb
 
   ADC r0, r1, #0xFFFFFF00
 # CHECK: sbc r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADC r0, r1, #0xFFFF00FF
 # CHECK: sbc r0, r1, #65280
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADC r0, r1, #0xFFFEFFFE
 # CHECK: sbc r0, r1, #65537 @ encoding: [0x61,0xf1,0x01,0x10]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADC r0, r1, #0xFEFFFEFF
 # CHECK: sbc r0, r1, #16777472 @ encoding: [0x61,0xf1,0x01,0x20]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADC
   ADD.W r0, r0, #0xFFFFFF01
 # CHECK: sub.w r0, r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADD.W
   ADD.W r0, r0, #0xFF01FF02
 # CHECK: sub.w r0, r0, #16646398 @ encoding: [0xa0,0xf1,0xfe,0x10]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADD.W
   ADDW r0, r1, #0xFFFFFF01
 # CHECK: subw r0, r1, #255 @ encoding: [0xa1,0xf2,0xff,0x00]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADDW
   ADD.W r0, r1, #0xFFFFFF01
 # CHECK: sub.w r0, r1, #255 @ encoding: [0xa1,0xf1,0xff,0x00]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: ADD.W
   AND r0, r1, #0xFFFFFF00
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: AND
 # CHECK: bic r0, r1, #255
   AND r0, r1, #0xFEFFFEFF
 # CHECK: bic r0, r1, #16777472 @ encoding: [0x21,0xf0,0x01,0x20]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: AND
   BIC r0, r1, #0xFFFFFF00
 # CHECK: and r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: BIC
   BIC r0, r1, #0xFEFFFEFF
 # CHECK: and r0, r1, #16777472 @ encoding: [0x01,0xf0,0x01,0x20]
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: BIC
   CMP r0, #0xFFFFFF01
 # CHECK: cmn.w r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: CMP
   CMN r0, #0xFFFFFF01
 # CHECK: cmp.w r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: CMN
   MOV r0, #0xFFFFFF00
 # CHECK: mvn r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: MOV
   MVN r0, #0xFFFFFF00
 # CHECK: mov.w r0, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: MVN
   SBC r0, r1, #0xFFFFFF00
 # CHECK: adc r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: SBC
   SUBW r0, r1, #0xFFFFFF01
 # CHECK: addw r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: SUBW
   SUB.W r0, r1, #0xFFFFFF01
 # CHECK: add.w r0, r1, #255
-# CHECK-DISABLED: error: instruction requires: NegativeImmediates
+# CHECK-DISABLED: note: for one encoding: instruction requires: NegativeImmediates
 # CHECK-DISABLED: SUB.W

test/MC/ARM/neon-vld-vst-align.s

 @ RUN: not llvm-mc -triple=thumbv7-apple-darwin -show-encoding < %s > %t 2> %t.err
 @ RUN: FileCheck < %t %s
 @ RUN: FileCheck --check-prefix=CHECK-ERRORS < %t.err %s
 
   vld1.8  {d0}, [r4]
   vld1.8  {d0}, [r4:16]
   vld1.8  {d0}, [r4:32]
   vld1.8  {d0}, [r4:64]
   vld1.8  {d0}, [r4:128]
   vld1.8  {d0}, [r4:256]
 
 @ CHECK: vld1.8 {d0}, [r4]              @ encoding: [0x24,0xf9,0x0f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.8 {d0}, [r4:64]           @ encoding: [0x24,0xf9,0x1f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vld1.8  {d0}, [r4]!
   vld1.8  {d0}, [r4:16]!
   vld1.8  {d0}, [r4:32]!
   vld1.8  {d0}, [r4:64]!
   vld1.8  {d0}, [r4:128]!
   vld1.8  {d0}, [r4:256]!
 
 @ CHECK: vld1.8 {d0}, [r4]!             @ encoding: [0x24,0xf9,0x0d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.8 {d0}, [r4:64]!          @ encoding: [0x24,0xf9,0x1d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vld1.8  {d0}, [r4], r6
   vld1.8  {d0}, [r4:16], r6
   vld1.8  {d0}, [r4:32], r6
   vld1.8  {d0}, [r4:64], r6
   vld1.8  {d0}, [r4:128], r6
   vld1.8  {d0}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0}, [r4], r6          @ encoding: [0x24,0xf9,0x06,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.8 {d0}, [r4:64], r6       @ encoding: [0x24,0xf9,0x16,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vld1.8  {d0, d1}, [r4]
   vld1.8  {d0, d1}, [r4:16]
   vld1.8  {d0, d1}, [r4:32]
   vld1.8  {d0, d1}, [r4:64]
   vld1.8  {d0, d1}, [r4:128]
   vld1.8  {d0, d1}, [r4:256]
 
 @ CHECK: vld1.8 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x0f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.8 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x1f,0x0a]
 @ CHECK: vld1.8 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0x2f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld1.8  {d0, d1}, [r4]!
   vld1.8  {d0, d1}, [r4:16]!
   vld1.8  {d0, d1}, [r4:32]!
   vld1.8  {d0, d1}, [r4:64]!
   vld1.8  {d0, d1}, [r4:128]!
   vld1.8  {d0, d1}, [r4:256]!
 
 @ CHECK: vld1.8 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x0d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.8 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x1d,0x0a]
 @ CHECK: vld1.8 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0x2d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld1.8  {d0, d1}, [r4], r6
   vld1.8  {d0, d1}, [r4:16], r6
   vld1.8  {d0, d1}, [r4:32], r6
   vld1.8  {d0, d1}, [r4:64], r6
   vld1.8  {d0, d1}, [r4:128], r6
   vld1.8  {d0, d1}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x06,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.8 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x16,0x0a]
 @ CHECK: vld1.8 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0x26,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld1.8  {d0, d1, d2}, [r4]
   vld1.8  {d0, d1, d2}, [r4:16]
   vld1.8  {d0, d1, d2}, [r4:32]
   vld1.8  {d0, d1, d2}, [r4:64]
   vld1.8  {d0, d1, d2}, [r4:128]
   vld1.8  {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld1.8 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x0f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.8 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x1f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.8  {d0, d1, d2}, [r4]!
   vld1.8  {d0, d1, d2}, [r4:16]!
   vld1.8  {d0, d1, d2}, [r4:32]!
   vld1.8  {d0, d1, d2}, [r4:64]!
   vld1.8  {d0, d1, d2}, [r4:128]!
   vld1.8  {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld1.8 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x0d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.8 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x1d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.8  {d0, d1, d2}, [r4], r6
   vld1.8  {d0, d1, d2}, [r4:16], r6
   vld1.8  {d0, d1, d2}, [r4:32], r6
   vld1.8  {d0, d1, d2}, [r4:64], r6
   vld1.8  {d0, d1, d2}, [r4:128], r6
   vld1.8  {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x06,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.8 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.8  {d0, d1, d2, d3}, [r4]
   vld1.8  {d0, d1, d2, d3}, [r4:16]
   vld1.8  {d0, d1, d2, d3}, [r4:32]
   vld1.8  {d0, d1, d2, d3}, [r4:64]
   vld1.8  {d0, d1, d2, d3}, [r4:128]
   vld1.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x0f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x1f,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x2f,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x3f,0x02]
 
   vld1.8  {d0, d1, d2, d3}, [r4]!
   vld1.8  {d0, d1, d2, d3}, [r4:16]!
   vld1.8  {d0, d1, d2, d3}, [r4:32]!
   vld1.8  {d0, d1, d2, d3}, [r4:64]!
   vld1.8  {d0, d1, d2, d3}, [r4:128]!
   vld1.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x0d,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x1d,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x2d,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x3d,0x02]
 
   vld1.8  {d0, d1, d2, d3}, [r4], r6
   vld1.8  {d0, d1, d2, d3}, [r4:16], r6
   vld1.8  {d0, d1, d2, d3}, [r4:32], r6
   vld1.8  {d0, d1, d2, d3}, [r4:64], r6
   vld1.8  {d0, d1, d2, d3}, [r4:128], r6
   vld1.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x06,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x26,0x02]
 @ CHECK: vld1.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x36,0x02]
 
   vld1.8  {d0[2]}, [r4]
   vld1.8  {d0[2]}, [r4:16]
   vld1.8  {d0[2]}, [r4:32]
   vld1.8  {d0[2]}, [r4:64]
   vld1.8  {d0[2]}, [r4:128]
   vld1.8  {d0[2]}, [r4:256]
 
 @ CHECK: vld1.8 {d0[2]}, [r4]           @ encoding: [0xa4,0xf9,0x4f,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:16]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:32]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vld1.8  {d0[2]}, [r4]!
   vld1.8  {d0[2]}, [r4:16]!
   vld1.8  {d0[2]}, [r4:32]!
   vld1.8  {d0[2]}, [r4:64]!
   vld1.8  {d0[2]}, [r4:128]!
   vld1.8  {d0[2]}, [r4:256]!
 
 @ CHECK: vld1.8 {d0[2]}, [r4]!          @ encoding: [0xa4,0xf9,0x4d,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:16]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:32]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vld1.8  {d0[2]}, [r4], r6
   vld1.8  {d0[2]}, [r4:16], r6
   vld1.8  {d0[2]}, [r4:32], r6
   vld1.8  {d0[2]}, [r4:64], r6
   vld1.8  {d0[2]}, [r4:128], r6
   vld1.8  {d0[2]}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0[2]}, [r4], r6       @ encoding: [0xa4,0xf9,0x46,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:16], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:32], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[2]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vld1.8  {d0[]}, [r4]
   vld1.8  {d0[]}, [r4:16]
   vld1.8  {d0[]}, [r4:32]
   vld1.8  {d0[]}, [r4:64]
   vld1.8  {d0[]}, [r4:128]
   vld1.8  {d0[]}, [r4:256]
 
 @ CHECK: vld1.8 {d0[]}, [r4]            @ encoding: [0xa4,0xf9,0x0f,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:16]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:32]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:64]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:128]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:256]
 @ CHECK-ERRORS:                             ^
 
   vld1.8  {d0[]}, [r4]!
   vld1.8  {d0[]}, [r4:16]!
   vld1.8  {d0[]}, [r4:32]!
   vld1.8  {d0[]}, [r4:64]!
   vld1.8  {d0[]}, [r4:128]!
   vld1.8  {d0[]}, [r4:256]!
 
 @ CHECK: vld1.8 {d0[]}, [r4]!           @ encoding: [0xa4,0xf9,0x0d,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:16]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:32]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:64]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:128]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:256]!
 @ CHECK-ERRORS:                             ^
 
   vld1.8  {d0[]}, [r4], r6
   vld1.8  {d0[]}, [r4:16], r6
   vld1.8  {d0[]}, [r4:32], r6
   vld1.8  {d0[]}, [r4:64], r6
   vld1.8  {d0[]}, [r4:128], r6
   vld1.8  {d0[]}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0[]}, [r4], r6        @ encoding: [0xa4,0xf9,0x06,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:16], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:32], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:64], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:128], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[]}, [r4:256], r6
 @ CHECK-ERRORS:                             ^
 
   vld1.8  {d0[], d1[]}, [r4]
   vld1.8  {d0[], d1[]}, [r4:16]
   vld1.8  {d0[], d1[]}, [r4:32]
   vld1.8  {d0[], d1[]}, [r4:64]
   vld1.8  {d0[], d1[]}, [r4:128]
   vld1.8  {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld1.8 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0x2f,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.8  {d0[], d1[]}, [r4]!
   vld1.8  {d0[], d1[]}, [r4:16]!
   vld1.8  {d0[], d1[]}, [r4:32]!
   vld1.8  {d0[], d1[]}, [r4:64]!
   vld1.8  {d0[], d1[]}, [r4:128]!
   vld1.8  {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld1.8 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0x2d,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.8  {d0[], d1[]}, [r4], r6
   vld1.8  {d0[], d1[]}, [r4:16], r6
   vld1.8  {d0[], d1[]}, [r4:32], r6
   vld1.8  {d0[], d1[]}, [r4:64], r6
   vld1.8  {d0[], d1[]}, [r4:128], r6
   vld1.8  {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld1.8 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x26,0x0c]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld1.8  {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0}, [r4]
   vld1.16 {d0}, [r4:16]
   vld1.16 {d0}, [r4:32]
   vld1.16 {d0}, [r4:64]
   vld1.16 {d0}, [r4:128]
   vld1.16 {d0}, [r4:256]
 
 @ CHECK: vld1.16 {d0}, [r4]              @ encoding: [0x24,0xf9,0x4f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.16 {d0}, [r4:64]           @ encoding: [0x24,0xf9,0x5f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vld1.16 {d0}, [r4]!
   vld1.16 {d0}, [r4:16]!
   vld1.16 {d0}, [r4:32]!
   vld1.16 {d0}, [r4:64]!
   vld1.16 {d0}, [r4:128]!
   vld1.16 {d0}, [r4:256]!
 
 @ CHECK: vld1.16 {d0}, [r4]!             @ encoding: [0x24,0xf9,0x4d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.16 {d0}, [r4:64]!          @ encoding: [0x24,0xf9,0x5d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vld1.16 {d0}, [r4], r6
   vld1.16 {d0}, [r4:16], r6
   vld1.16 {d0}, [r4:32], r6
   vld1.16 {d0}, [r4:64], r6
   vld1.16 {d0}, [r4:128], r6
   vld1.16 {d0}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0}, [r4], r6          @ encoding: [0x24,0xf9,0x46,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.16 {d0}, [r4:64], r6       @ encoding: [0x24,0xf9,0x56,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vld1.16 {d0, d1}, [r4]
   vld1.16 {d0, d1}, [r4:16]
   vld1.16 {d0, d1}, [r4:32]
   vld1.16 {d0, d1}, [r4:64]
   vld1.16 {d0, d1}, [r4:128]
   vld1.16 {d0, d1}, [r4:256]
 
 @ CHECK: vld1.16 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x4f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.16 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x5f,0x0a]
 @ CHECK: vld1.16 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0x6f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld1.16 {d0, d1}, [r4]!
   vld1.16 {d0, d1}, [r4:16]!
   vld1.16 {d0, d1}, [r4:32]!
   vld1.16 {d0, d1}, [r4:64]!
   vld1.16 {d0, d1}, [r4:128]!
   vld1.16 {d0, d1}, [r4:256]!
 
 @ CHECK: vld1.16 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x4d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.16 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x5d,0x0a]
 @ CHECK: vld1.16 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0x6d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld1.16 {d0, d1}, [r4], r6
   vld1.16 {d0, d1}, [r4:16], r6
   vld1.16 {d0, d1}, [r4:32], r6
   vld1.16 {d0, d1}, [r4:64], r6
   vld1.16 {d0, d1}, [r4:128], r6
   vld1.16 {d0, d1}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x46,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.16 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x56,0x0a]
 @ CHECK: vld1.16 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0x66,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld1.16 {d0, d1, d2}, [r4]
   vld1.16 {d0, d1, d2}, [r4:16]
   vld1.16 {d0, d1, d2}, [r4:32]
   vld1.16 {d0, d1, d2}, [r4:64]
   vld1.16 {d0, d1, d2}, [r4:128]
   vld1.16 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld1.16 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x4f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.16 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x5f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0, d1, d2}, [r4]!
   vld1.16 {d0, d1, d2}, [r4:16]!
   vld1.16 {d0, d1, d2}, [r4:32]!
   vld1.16 {d0, d1, d2}, [r4:64]!
   vld1.16 {d0, d1, d2}, [r4:128]!
   vld1.16 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld1.16 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x4d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.16 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x5d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0, d1, d2}, [r4], r6
   vld1.16 {d0, d1, d2}, [r4:16], r6
   vld1.16 {d0, d1, d2}, [r4:32], r6
   vld1.16 {d0, d1, d2}, [r4:64], r6
   vld1.16 {d0, d1, d2}, [r4:128], r6
   vld1.16 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x46,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.16 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0, d1, d2, d3}, [r4]
   vld1.16 {d0, d1, d2, d3}, [r4:16]
   vld1.16 {d0, d1, d2, d3}, [r4:32]
   vld1.16 {d0, d1, d2, d3}, [r4:64]
   vld1.16 {d0, d1, d2, d3}, [r4:128]
   vld1.16 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x4f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x5f,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x6f,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x7f,0x02]
 
   vld1.16 {d0, d1, d2, d3}, [r4]!
   vld1.16 {d0, d1, d2, d3}, [r4:16]!
   vld1.16 {d0, d1, d2, d3}, [r4:32]!
   vld1.16 {d0, d1, d2, d3}, [r4:64]!
   vld1.16 {d0, d1, d2, d3}, [r4:128]!
   vld1.16 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x4d,0x02]
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x5d,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x6d,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x7d,0x02]
 
   vld1.16 {d0, d1, d2, d3}, [r4], r6
   vld1.16 {d0, d1, d2, d3}, [r4:16], r6
   vld1.16 {d0, d1, d2, d3}, [r4:32], r6
   vld1.16 {d0, d1, d2, d3}, [r4:64], r6
   vld1.16 {d0, d1, d2, d3}, [r4:128], r6
   vld1.16 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x46,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x66,0x02]
 @ CHECK: vld1.16 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x76,0x02]
 
   vld1.16 {d0[2]}, [r4]
   vld1.16 {d0[2]}, [r4:16]
   vld1.16 {d0[2]}, [r4:32]
   vld1.16 {d0[2]}, [r4:64]
   vld1.16 {d0[2]}, [r4:128]
   vld1.16 {d0[2]}, [r4:256]
 
 @ CHECK: vld1.16 {d0[2]}, [r4]           @ encoding: [0xa4,0xf9,0x8f,0x04]
 @ CHECK: vld1.16 {d0[2]}, [r4:16]        @ encoding: [0xa4,0xf9,0x9f,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:32]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vld1.16 {d0[2]}, [r4]!
   vld1.16 {d0[2]}, [r4:16]!
   vld1.16 {d0[2]}, [r4:32]!
   vld1.16 {d0[2]}, [r4:64]!
   vld1.16 {d0[2]}, [r4:128]!
   vld1.16 {d0[2]}, [r4:256]!
 
 @ CHECK: vld1.16 {d0[2]}, [r4]!          @ encoding: [0xa4,0xf9,0x8d,0x04]
 @ CHECK: vld1.16 {d0[2]}, [r4:16]!       @ encoding: [0xa4,0xf9,0x9d,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:32]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vld1.16 {d0[2]}, [r4], r6
   vld1.16 {d0[2]}, [r4:16], r6
   vld1.16 {d0[2]}, [r4:32], r6
   vld1.16 {d0[2]}, [r4:64], r6
   vld1.16 {d0[2]}, [r4:128], r6
   vld1.16 {d0[2]}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0[2]}, [r4], r6       @ encoding: [0xa4,0xf9,0x86,0x04]
 @ CHECK: vld1.16 {d0[2]}, [r4:16], r6    @ encoding: [0xa4,0xf9,0x96,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:32], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[2]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vld1.16 {d0[]}, [r4]
   vld1.16 {d0[]}, [r4:16]
   vld1.16 {d0[]}, [r4:32]
   vld1.16 {d0[]}, [r4:64]
   vld1.16 {d0[]}, [r4:128]
   vld1.16 {d0[]}, [r4:256]
 
 @ CHECK: vld1.16 {d0[]}, [r4]            @ encoding: [0xa4,0xf9,0x4f,0x0c]
 @ CHECK: vld1.16 {d0[]}, [r4:16]         @ encoding: [0xa4,0xf9,0x5f,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:32]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:64]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:128]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:256]
 @ CHECK-ERRORS:                             ^
 
   vld1.16 {d0[]}, [r4]!
   vld1.16 {d0[]}, [r4:16]!
   vld1.16 {d0[]}, [r4:32]!
   vld1.16 {d0[]}, [r4:64]!
   vld1.16 {d0[]}, [r4:128]!
   vld1.16 {d0[]}, [r4:256]!
 
 @ CHECK: vld1.16 {d0[]}, [r4]!           @ encoding: [0xa4,0xf9,0x4d,0x0c]
 @ CHECK: vld1.16 {d0[]}, [r4:16]!        @ encoding: [0xa4,0xf9,0x5d,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:32]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:64]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:128]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:256]!
 @ CHECK-ERRORS:                             ^
 
   vld1.16 {d0[]}, [r4], r6
   vld1.16 {d0[]}, [r4:16], r6
   vld1.16 {d0[]}, [r4:32], r6
   vld1.16 {d0[]}, [r4:64], r6
   vld1.16 {d0[]}, [r4:128], r6
   vld1.16 {d0[]}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0[]}, [r4], r6        @ encoding: [0xa4,0xf9,0x46,0x0c]
 @ CHECK: vld1.16 {d0[]}, [r4:16], r6     @ encoding: [0xa4,0xf9,0x56,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:32], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:64], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:128], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[]}, [r4:256], r6
 @ CHECK-ERRORS:                             ^
 
   vld1.16 {d0[], d1[]}, [r4]
   vld1.16 {d0[], d1[]}, [r4:16]
   vld1.16 {d0[], d1[]}, [r4:32]
   vld1.16 {d0[], d1[]}, [r4:64]
   vld1.16 {d0[], d1[]}, [r4:128]
   vld1.16 {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld1.16 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0x6f,0x0c]
 @ CHECK: vld1.16 {d0[], d1[]}, [r4:16]   @ encoding: [0xa4,0xf9,0x7f,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0[], d1[]}, [r4]!
   vld1.16 {d0[], d1[]}, [r4:16]!
   vld1.16 {d0[], d1[]}, [r4:32]!
   vld1.16 {d0[], d1[]}, [r4:64]!
   vld1.16 {d0[], d1[]}, [r4:128]!
   vld1.16 {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld1.16 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0x6d,0x0c]
 @ CHECK: vld1.16 {d0[], d1[]}, [r4:16]!  @ encoding: [0xa4,0xf9,0x7d,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.16 {d0[], d1[]}, [r4], r6
   vld1.16 {d0[], d1[]}, [r4:16], r6
   vld1.16 {d0[], d1[]}, [r4:32], r6
   vld1.16 {d0[], d1[]}, [r4:64], r6
   vld1.16 {d0[], d1[]}, [r4:128], r6
   vld1.16 {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld1.16 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x66,0x0c]
 @ CHECK: vld1.16 {d0[], d1[]}, [r4:16], r6 @ encoding: [0xa4,0xf9,0x76,0x0c]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld1.16 {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0}, [r4]
   vld1.32 {d0}, [r4:16]
   vld1.32 {d0}, [r4:32]
   vld1.32 {d0}, [r4:64]
   vld1.32 {d0}, [r4:128]
   vld1.32 {d0}, [r4:256]
 
 @ CHECK: vld1.32 {d0}, [r4]              @ encoding: [0x24,0xf9,0x8f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.32 {d0}, [r4:64]           @ encoding: [0x24,0xf9,0x9f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vld1.32 {d0}, [r4]!
   vld1.32 {d0}, [r4:16]!
   vld1.32 {d0}, [r4:32]!
   vld1.32 {d0}, [r4:64]!
   vld1.32 {d0}, [r4:128]!
   vld1.32 {d0}, [r4:256]!
 
 @ CHECK: vld1.32 {d0}, [r4]!             @ encoding: [0x24,0xf9,0x8d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.32 {d0}, [r4:64]!          @ encoding: [0x24,0xf9,0x9d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vld1.32 {d0}, [r4], r6
   vld1.32 {d0}, [r4:16], r6
   vld1.32 {d0}, [r4:32], r6
   vld1.32 {d0}, [r4:64], r6
   vld1.32 {d0}, [r4:128], r6
   vld1.32 {d0}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0}, [r4], r6          @ encoding: [0x24,0xf9,0x86,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.32 {d0}, [r4:64], r6       @ encoding: [0x24,0xf9,0x96,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vld1.32 {d0, d1}, [r4]
   vld1.32 {d0, d1}, [r4:16]
   vld1.32 {d0, d1}, [r4:32]
   vld1.32 {d0, d1}, [r4:64]
   vld1.32 {d0, d1}, [r4:128]
   vld1.32 {d0, d1}, [r4:256]
 
 @ CHECK: vld1.32 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x8f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.32 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x9f,0x0a]
 @ CHECK: vld1.32 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0xaf,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld1.32 {d0, d1}, [r4]!
   vld1.32 {d0, d1}, [r4:16]!
   vld1.32 {d0, d1}, [r4:32]!
   vld1.32 {d0, d1}, [r4:64]!
   vld1.32 {d0, d1}, [r4:128]!
   vld1.32 {d0, d1}, [r4:256]!
 
 @ CHECK: vld1.32 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x8d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.32 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x9d,0x0a]
 @ CHECK: vld1.32 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0xad,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld1.32 {d0, d1}, [r4], r6
   vld1.32 {d0, d1}, [r4:16], r6
   vld1.32 {d0, d1}, [r4:32], r6
   vld1.32 {d0, d1}, [r4:64], r6
   vld1.32 {d0, d1}, [r4:128], r6
   vld1.32 {d0, d1}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x86,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.32 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x96,0x0a]
 @ CHECK: vld1.32 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0xa6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld1.32 {d0, d1, d2}, [r4]
   vld1.32 {d0, d1, d2}, [r4:16]
   vld1.32 {d0, d1, d2}, [r4:32]
   vld1.32 {d0, d1, d2}, [r4:64]
   vld1.32 {d0, d1, d2}, [r4:128]
   vld1.32 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld1.32 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x8f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x9f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0, d1, d2}, [r4]!
   vld1.32 {d0, d1, d2}, [r4:16]!
   vld1.32 {d0, d1, d2}, [r4:32]!
   vld1.32 {d0, d1, d2}, [r4:64]!
   vld1.32 {d0, d1, d2}, [r4:128]!
   vld1.32 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld1.32 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x8d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x9d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0, d1, d2}, [r4], r6
   vld1.32 {d0, d1, d2}, [r4:16], r6
   vld1.32 {d0, d1, d2}, [r4:32], r6
   vld1.32 {d0, d1, d2}, [r4:64], r6
   vld1.32 {d0, d1, d2}, [r4:128], r6
   vld1.32 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x86,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0, d1, d2, d3}, [r4]
   vld1.32 {d0, d1, d2, d3}, [r4:16]
   vld1.32 {d0, d1, d2, d3}, [r4:32]
   vld1.32 {d0, d1, d2, d3}, [r4:64]
   vld1.32 {d0, d1, d2, d3}, [r4:128]
   vld1.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x8f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x9f,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0xaf,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0xbf,0x02]
 
   vld1.32 {d0, d1, d2, d3}, [r4]!
   vld1.32 {d0, d1, d2, d3}, [r4:16]!
   vld1.32 {d0, d1, d2, d3}, [r4:32]!
   vld1.32 {d0, d1, d2, d3}, [r4:64]!
   vld1.32 {d0, d1, d2, d3}, [r4:128]!
   vld1.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x8d,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x9d,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0xad,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0xbd,0x02]
 
   vld1.32 {d0, d1, d2, d3}, [r4], r6
   vld1.32 {d0, d1, d2, d3}, [r4:16], r6
   vld1.32 {d0, d1, d2, d3}, [r4:32], r6
   vld1.32 {d0, d1, d2, d3}, [r4:64], r6
   vld1.32 {d0, d1, d2, d3}, [r4:128], r6
   vld1.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x86,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0xa6,0x02]
 @ CHECK: vld1.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0xb6,0x02]
 
   vld1.32 {d0[1]}, [r4]
   vld1.32 {d0[1]}, [r4:16]
   vld1.32 {d0[1]}, [r4:32]
   vld1.32 {d0[1]}, [r4:64]
   vld1.32 {d0[1]}, [r4:128]
   vld1.32 {d0[1]}, [r4:256]
 
 @ CHECK: vld1.32 {d0[1]}, [r4]           @ encoding: [0xa4,0xf9,0x8f,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16]
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32]        @ encoding: [0xa4,0xf9,0xbf,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vld1.32 {d0[1]}, [r4]!
   vld1.32 {d0[1]}, [r4:16]!
   vld1.32 {d0[1]}, [r4:32]!
   vld1.32 {d0[1]}, [r4:64]!
   vld1.32 {d0[1]}, [r4:128]!
   vld1.32 {d0[1]}, [r4:256]!
 
 @ CHECK: vld1.32 {d0[1]}, [r4]!          @ encoding: [0xa4,0xf9,0x8d,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16]!
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32]!       @ encoding: [0xa4,0xf9,0xbd,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vld1.32 {d0[1]}, [r4], r6
   vld1.32 {d0[1]}, [r4:16], r6
   vld1.32 {d0[1]}, [r4:32], r6
   vld1.32 {d0[1]}, [r4:64], r6
   vld1.32 {d0[1]}, [r4:128], r6
   vld1.32 {d0[1]}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0[1]}, [r4], r6       @ encoding: [0xa4,0xf9,0x86,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16], r6
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32], r6    @ encoding: [0xa4,0xf9,0xb6,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vld1.32 {d0[]}, [r4]
   vld1.32 {d0[]}, [r4:16]
   vld1.32 {d0[]}, [r4:32]
   vld1.32 {d0[]}, [r4:64]
   vld1.32 {d0[]}, [r4:128]
   vld1.32 {d0[]}, [r4:256]
 
 @ CHECK: vld1.32 {d0[]}, [r4]            @ encoding: [0xa4,0xf9,0x8f,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:16]
 @ CHECK-ERRORS:                             ^
 @ CHECK: vld1.32 {d0[]}, [r4:32]         @ encoding: [0xa4,0xf9,0x9f,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:64]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:128]
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:256]
 @ CHECK-ERRORS:                             ^
 
   vld1.32 {d0[]}, [r4]!
   vld1.32 {d0[]}, [r4:16]!
   vld1.32 {d0[]}, [r4:32]!
   vld1.32 {d0[]}, [r4:64]!
   vld1.32 {d0[]}, [r4:128]!
   vld1.32 {d0[]}, [r4:256]!
 
 @ CHECK: vld1.32 {d0[]}, [r4]!           @ encoding: [0xa4,0xf9,0x8d,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:16]!
 @ CHECK-ERRORS:                             ^
 @ CHECK: vld1.32 {d0[]}, [r4:32]!        @ encoding: [0xa4,0xf9,0x9d,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:64]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:128]!
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:256]!
 @ CHECK-ERRORS:                             ^
 
   vld1.32 {d0[]}, [r4], r6
   vld1.32 {d0[]}, [r4:16], r6
   vld1.32 {d0[]}, [r4:32], r6
   vld1.32 {d0[]}, [r4:64], r6
   vld1.32 {d0[]}, [r4:128], r6
   vld1.32 {d0[]}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0[]}, [r4], r6        @ encoding: [0xa4,0xf9,0x86,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:16], r6
 @ CHECK-ERRORS:                             ^
 @ CHECK: vld1.32 {d0[]}, [r4:32], r6     @ encoding: [0xa4,0xf9,0x96,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:64], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:128], r6
 @ CHECK-ERRORS:                             ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[]}, [r4:256], r6
 @ CHECK-ERRORS:                             ^
 
   vld1.32 {d0[], d1[]}, [r4]
   vld1.32 {d0[], d1[]}, [r4:16]
   vld1.32 {d0[], d1[]}, [r4:32]
   vld1.32 {d0[], d1[]}, [r4:64]
   vld1.32 {d0[], d1[]}, [r4:128]
   vld1.32 {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld1.32 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0xaf,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0[], d1[]}, [r4:32]   @ encoding: [0xa4,0xf9,0xbf,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0[], d1[]}, [r4]!
   vld1.32 {d0[], d1[]}, [r4:16]!
   vld1.32 {d0[], d1[]}, [r4:32]!
   vld1.32 {d0[], d1[]}, [r4:64]!
   vld1.32 {d0[], d1[]}, [r4:128]!
   vld1.32 {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld1.32 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0xad,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0[], d1[]}, [r4:32]!  @ encoding: [0xa4,0xf9,0xbd,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0[], d1[]}, [r4], r6
   vld1.32 {d0[], d1[]}, [r4:16], r6
   vld1.32 {d0[], d1[]}, [r4:32], r6
   vld1.32 {d0[], d1[]}, [r4:64], r6
   vld1.32 {d0[], d1[]}, [r4:128], r6
   vld1.32 {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0xa6,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.32 {d0[], d1[]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0xb6,0x0c]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.32 {d0[1]}, [r4]
   vld1.32 {d0[1]}, [r4:16]
   vld1.32 {d0[1]}, [r4:32]
   vld1.32 {d0[1]}, [r4:64]
   vld1.32 {d0[1]}, [r4:128]
   vld1.32 {d0[1]}, [r4:256]
 
 @ CHECK: vld1.32 {d0[1]}, [r4]           @ encoding: [0xa4,0xf9,0x8f,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16]
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32]        @ encoding: [0xa4,0xf9,0xbf,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vld1.32 {d0[1]}, [r4]!
   vld1.32 {d0[1]}, [r4:16]!
   vld1.32 {d0[1]}, [r4:32]!
   vld1.32 {d0[1]}, [r4:64]!
   vld1.32 {d0[1]}, [r4:128]!
   vld1.32 {d0[1]}, [r4:256]!
 
 @ CHECK: vld1.32 {d0[1]}, [r4]!          @ encoding: [0xa4,0xf9,0x8d,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16]!
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32]!       @ encoding: [0xa4,0xf9,0xbd,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vld1.32 {d0[1]}, [r4], r6
   vld1.32 {d0[1]}, [r4:16], r6
   vld1.32 {d0[1]}, [r4:32], r6
   vld1.32 {d0[1]}, [r4:64], r6
   vld1.32 {d0[1]}, [r4:128], r6
   vld1.32 {d0[1]}, [r4:256], r6
 
 @ CHECK: vld1.32 {d0[1]}, [r4], r6       @ encoding: [0xa4,0xf9,0x86,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:16], r6
 @ CHECK-ERRORS:                              ^
 @ CHECK: vld1.32 {d0[1]}, [r4:32], r6    @ encoding: [0xa4,0xf9,0xb6,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld1.32 {d0[1]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vld1.64 {d0}, [r4]
   vld1.64 {d0}, [r4:16]
   vld1.64 {d0}, [r4:32]
   vld1.64 {d0}, [r4:64]
   vld1.64 {d0}, [r4:128]
   vld1.64 {d0}, [r4:256]
 
 @ CHECK: vld1.64 {d0}, [r4]              @ encoding: [0x24,0xf9,0xcf,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.64 {d0}, [r4:64]           @ encoding: [0x24,0xf9,0xdf,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vld1.64 {d0}, [r4]!
   vld1.64 {d0}, [r4:16]!
   vld1.64 {d0}, [r4:32]!
   vld1.64 {d0}, [r4:64]!
   vld1.64 {d0}, [r4:128]!
   vld1.64 {d0}, [r4:256]!
 
 @ CHECK: vld1.64 {d0}, [r4]!             @ encoding: [0x24,0xf9,0xcd,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.64 {d0}, [r4:64]!          @ encoding: [0x24,0xf9,0xdd,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vld1.64 {d0}, [r4], r6
   vld1.64 {d0}, [r4:16], r6
   vld1.64 {d0}, [r4:32], r6
   vld1.64 {d0}, [r4:64], r6
   vld1.64 {d0}, [r4:128], r6
   vld1.64 {d0}, [r4:256], r6
 
 @ CHECK: vld1.64 {d0}, [r4], r6          @ encoding: [0x24,0xf9,0xc6,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vld1.64 {d0}, [r4:64], r6       @ encoding: [0x24,0xf9,0xd6,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vld1.64 {d0, d1}, [r4]
   vld1.64 {d0, d1}, [r4:16]
   vld1.64 {d0, d1}, [r4:32]
   vld1.64 {d0, d1}, [r4:64]
   vld1.64 {d0, d1}, [r4:128]
   vld1.64 {d0, d1}, [r4:256]
 
 @ CHECK: vld1.64 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0xcf,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.64 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0xdf,0x0a]
 @ CHECK: vld1.64 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0xef,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld1.64 {d0, d1}, [r4]!
   vld1.64 {d0, d1}, [r4:16]!
   vld1.64 {d0, d1}, [r4:32]!
   vld1.64 {d0, d1}, [r4:64]!
   vld1.64 {d0, d1}, [r4:128]!
   vld1.64 {d0, d1}, [r4:256]!
 
 @ CHECK: vld1.64 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0xcd,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.64 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0xdd,0x0a]
 @ CHECK: vld1.64 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0xed,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld1.64 {d0, d1}, [r4], r6
   vld1.64 {d0, d1}, [r4:16], r6
   vld1.64 {d0, d1}, [r4:32], r6
   vld1.64 {d0, d1}, [r4:64], r6
   vld1.64 {d0, d1}, [r4:128], r6
   vld1.64 {d0, d1}, [r4:256], r6
 
 @ CHECK: vld1.64 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0xc6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld1.64 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0xd6,0x0a]
 @ CHECK: vld1.64 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0xe6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld1.64 {d0, d1, d2}, [r4]
   vld1.64 {d0, d1, d2}, [r4:16]
   vld1.64 {d0, d1, d2}, [r4:32]
   vld1.64 {d0, d1, d2}, [r4:64]
   vld1.64 {d0, d1, d2}, [r4:128]
   vld1.64 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld1.64 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0xcf,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.64 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0xdf,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld1.64 {d0, d1, d2}, [r4]!
   vld1.64 {d0, d1, d2}, [r4:16]!
   vld1.64 {d0, d1, d2}, [r4:32]!
   vld1.64 {d0, d1, d2}, [r4:64]!
   vld1.64 {d0, d1, d2}, [r4:128]!
   vld1.64 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld1.64 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0xcd,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.64 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0xdd,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld1.64 {d0, d1, d2}, [r4], r6
   vld1.64 {d0, d1, d2}, [r4:16], r6
   vld1.64 {d0, d1, d2}, [r4:32], r6
   vld1.64 {d0, d1, d2}, [r4:64], r6
   vld1.64 {d0, d1, d2}, [r4:128], r6
   vld1.64 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld1.64 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0xc6,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld1.64 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0xd6,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld1.64 {d0, d1, d2, d3}, [r4]
   vld1.64 {d0, d1, d2, d3}, [r4:16]
   vld1.64 {d0, d1, d2, d3}, [r4:32]
   vld1.64 {d0, d1, d2, d3}, [r4:64]
   vld1.64 {d0, d1, d2, d3}, [r4:128]
   vld1.64 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0xcf,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0xdf,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0xef,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0xff,0x02]
 
   vld1.64 {d0, d1, d2, d3}, [r4]!
   vld1.64 {d0, d1, d2, d3}, [r4:16]!
   vld1.64 {d0, d1, d2, d3}, [r4:32]!
   vld1.64 {d0, d1, d2, d3}, [r4:64]!
   vld1.64 {d0, d1, d2, d3}, [r4:128]!
   vld1.64 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0xcd,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0xdd,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0xed,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0xfd,0x02]
 
   vld1.64 {d0, d1, d2, d3}, [r4], r6
   vld1.64 {d0, d1, d2, d3}, [r4:16], r6
   vld1.64 {d0, d1, d2, d3}, [r4:32], r6
   vld1.64 {d0, d1, d2, d3}, [r4:64], r6
   vld1.64 {d0, d1, d2, d3}, [r4:128], r6
   vld1.64 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0xc6,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld1.64 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0xd6,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0xe6,0x02]
 @ CHECK: vld1.64 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0xf6,0x02]
 
   vld2.8  {d0, d1}, [r4]
   vld2.8  {d0, d1}, [r4:16]
   vld2.8  {d0, d1}, [r4:32]
   vld2.8  {d0, d1}, [r4:64]
   vld2.8  {d0, d1}, [r4:128]
   vld2.8  {d0, d1}, [r4:256]
 
 @ CHECK: vld2.8 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x0f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x1f,0x08]
 @ CHECK: vld2.8 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0x2f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d1}, [r4]!
   vld2.8  {d0, d1}, [r4:16]!
   vld2.8  {d0, d1}, [r4:32]!
   vld2.8  {d0, d1}, [r4:64]!
   vld2.8  {d0, d1}, [r4:128]!
   vld2.8  {d0, d1}, [r4:256]!
 
 @ CHECK: vld2.8 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x0d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x1d,0x08]
 @ CHECK: vld2.8 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0x2d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d1}, [r4], r6
   vld2.8  {d0, d1}, [r4:16], r6
   vld2.8  {d0, d1}, [r4:32], r6
   vld2.8  {d0, d1}, [r4:64], r6
   vld2.8  {d0, d1}, [r4:128], r6
   vld2.8  {d0, d1}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x06,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x16,0x08]
 @ CHECK: vld2.8 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0x26,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d2}, [r4]
   vld2.8  {d0, d2}, [r4:16]
   vld2.8  {d0, d2}, [r4:32]
   vld2.8  {d0, d2}, [r4:64]
   vld2.8  {d0, d2}, [r4:128]
   vld2.8  {d0, d2}, [r4:256]
 
 @ CHECK: vld2.8 {d0, d2}, [r4]          @ encoding: [0x24,0xf9,0x0f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d2}, [r4:64]       @ encoding: [0x24,0xf9,0x1f,0x09]
 @ CHECK: vld2.8 {d0, d2}, [r4:128]      @ encoding: [0x24,0xf9,0x2f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d2}, [r4]!
   vld2.8  {d0, d2}, [r4:16]!
   vld2.8  {d0, d2}, [r4:32]!
   vld2.8  {d0, d2}, [r4:64]!
   vld2.8  {d0, d2}, [r4:128]!
   vld2.8  {d0, d2}, [r4:256]!
 
 @ CHECK: vld2.8 {d0, d2}, [r4]!         @ encoding: [0x24,0xf9,0x0d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d2}, [r4:64]!      @ encoding: [0x24,0xf9,0x1d,0x09]
 @ CHECK: vld2.8 {d0, d2}, [r4:128]!     @ encoding: [0x24,0xf9,0x2d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d2}, [r4], r6
   vld2.8  {d0, d2}, [r4:16], r6
   vld2.8  {d0, d2}, [r4:32], r6
   vld2.8  {d0, d2}, [r4:64], r6
   vld2.8  {d0, d2}, [r4:128], r6
   vld2.8  {d0, d2}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0, d2}, [r4], r6      @ encoding: [0x24,0xf9,0x06,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.8 {d0, d2}, [r4:64], r6   @ encoding: [0x24,0xf9,0x16,0x09]
 @ CHECK: vld2.8 {d0, d2}, [r4:128], r6  @ encoding: [0x24,0xf9,0x26,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d2}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.8  {d0, d1, d2, d3}, [r4]
   vld2.8  {d0, d1, d2, d3}, [r4:16]
   vld2.8  {d0, d1, d2, d3}, [r4:32]
   vld2.8  {d0, d1, d2, d3}, [r4:64]
   vld2.8  {d0, d1, d2, d3}, [r4:128]
   vld2.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x0f,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x1f,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x2f,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x3f,0x03]
 
   vld2.8  {d0, d1, d2, d3}, [r4]!
   vld2.8  {d0, d1, d2, d3}, [r4:16]!
   vld2.8  {d0, d1, d2, d3}, [r4:32]!
   vld2.8  {d0, d1, d2, d3}, [r4:64]!
   vld2.8  {d0, d1, d2, d3}, [r4:128]!
   vld2.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x0d,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x1d,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x2d,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x3d,0x03]
 
   vld2.8  {d0, d1, d2, d3}, [r4], r6
   vld2.8  {d0, d1, d2, d3}, [r4:16], r6
   vld2.8  {d0, d1, d2, d3}, [r4:32], r6
   vld2.8  {d0, d1, d2, d3}, [r4:64], r6
   vld2.8  {d0, d1, d2, d3}, [r4:128], r6
   vld2.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x06,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x26,0x03]
 @ CHECK: vld2.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x36,0x03]
 
   vld2.8  {d0[2], d1[2]}, [r4]
   vld2.8  {d0[2], d1[2]}, [r4:16]
   vld2.8  {d0[2], d1[2]}, [r4:32]
   vld2.8  {d0[2], d1[2]}, [r4:64]
   vld2.8  {d0[2], d1[2]}, [r4:128]
   vld2.8  {d0[2], d1[2]}, [r4:256]
 
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4]    @ encoding: [0xa4,0xf9,0x4f,0x01]
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4:16] @ encoding: [0xa4,0xf9,0x5f,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:64]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vld2.8  {d0[2], d1[2]}, [r4]!
   vld2.8  {d0[2], d1[2]}, [r4:16]!
   vld2.8  {d0[2], d1[2]}, [r4:32]!
   vld2.8  {d0[2], d1[2]}, [r4:64]!
   vld2.8  {d0[2], d1[2]}, [r4:128]!
   vld2.8  {d0[2], d1[2]}, [r4:256]!
 
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4]!   @ encoding: [0xa4,0xf9,0x4d,0x01]
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4:16]! @ encoding: [0xa4,0xf9,0x5d,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:64]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vld2.8  {d0[2], d1[2]}, [r4], r6
   vld2.8  {d0[2], d1[2]}, [r4:16], r6
   vld2.8  {d0[2], d1[2]}, [r4:32], r6
   vld2.8  {d0[2], d1[2]}, [r4:64], r6
   vld2.8  {d0[2], d1[2]}, [r4:128], r6
   vld2.8  {d0[2], d1[2]}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4], r6 @ encoding: [0xa4,0xf9,0x46,0x01]
 @ CHECK: vld2.8 {d0[2], d1[2]}, [r4:16], r6 @ encoding: [0xa4,0xf9,0x56,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:64], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[2], d1[2]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vld2.8  {d0[], d1[]}, [r4]
   vld2.8  {d0[], d1[]}, [r4:16]
   vld2.8  {d0[], d1[]}, [r4:32]
   vld2.8  {d0[], d1[]}, [r4:64]
   vld2.8  {d0[], d1[]}, [r4:128]
   vld2.8  {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld2.8 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0x0f,0x0d]
 @ CHECK: vld2.8 {d0[], d1[]}, [r4:16]   @ encoding: [0xa4,0xf9,0x1f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.8  {d0[], d1[]}, [r4]!
   vld2.8  {d0[], d1[]}, [r4:16]!
   vld2.8  {d0[], d1[]}, [r4:32]!
   vld2.8  {d0[], d1[]}, [r4:64]!
   vld2.8  {d0[], d1[]}, [r4:128]!
   vld2.8  {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld2.8 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0x0d,0x0d]
 @ CHECK: vld2.8 {d0[], d1[]}, [r4:16]!  @ encoding: [0xa4,0xf9,0x1d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld2.8  {d0[], d1[]}, [r4], r6
   vld2.8  {d0[], d1[]}, [r4:16], r6
   vld2.8  {d0[], d1[]}, [r4:32], r6
   vld2.8  {d0[], d1[]}, [r4:64], r6
   vld2.8  {d0[], d1[]}, [r4:128], r6
   vld2.8  {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x06,0x0d]
 @ CHECK: vld2.8 {d0[], d1[]}, [r4:16], r6 @ encoding: [0xa4,0xf9,0x16,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld2.8  {d0[], d2[]}, [r4]
   vld2.8  {d0[], d2[]}, [r4:16]
   vld2.8  {d0[], d2[]}, [r4:32]
   vld2.8  {d0[], d2[]}, [r4:64]
   vld2.8  {d0[], d2[]}, [r4:128]
   vld2.8  {d0[], d2[]}, [r4:256]
 
 @ CHECK: vld2.8 {d0[], d2[]}, [r4]      @ encoding: [0xa4,0xf9,0x2f,0x0d]
 @ CHECK: vld2.8 {d0[], d2[]}, [r4:16]   @ encoding: [0xa4,0xf9,0x3f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.8  {d0[], d2[]}, [r4]!
   vld2.8  {d0[], d2[]}, [r4:16]!
   vld2.8  {d0[], d2[]}, [r4:32]!
   vld2.8  {d0[], d2[]}, [r4:64]!
   vld2.8  {d0[], d2[]}, [r4:128]!
   vld2.8  {d0[], d2[]}, [r4:256]!
 
 @ CHECK: vld2.8 {d0[], d2[]}, [r4]!     @ encoding: [0xa4,0xf9,0x2d,0x0d]
 @ CHECK: vld2.8 {d0[], d2[]}, [r4:16]!  @ encoding: [0xa4,0xf9,0x3d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld2.8  {d0[], d2[]}, [r4], r6
   vld2.8  {d0[], d2[]}, [r4:16], r6
   vld2.8  {d0[], d2[]}, [r4:32], r6
   vld2.8  {d0[], d2[]}, [r4:64], r6
   vld2.8  {d0[], d2[]}, [r4:128], r6
   vld2.8  {d0[], d2[]}, [r4:256], r6
 
 @ CHECK: vld2.8 {d0[], d2[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x26,0x0d]
 @ CHECK: vld2.8 {d0[], d2[]}, [r4:16], r6 @ encoding: [0xa4,0xf9,0x36,0x0d]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vld2.8  {d0[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld2.16 {d0, d1}, [r4]
   vld2.16 {d0, d1}, [r4:16]
   vld2.16 {d0, d1}, [r4:32]
   vld2.16 {d0, d1}, [r4:64]
   vld2.16 {d0, d1}, [r4:128]
   vld2.16 {d0, d1}, [r4:256]
 
 @ CHECK: vld2.16 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x4f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x5f,0x08]
 @ CHECK: vld2.16 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0x6f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d1}, [r4]!
   vld2.16 {d0, d1}, [r4:16]!
   vld2.16 {d0, d1}, [r4:32]!
   vld2.16 {d0, d1}, [r4:64]!
   vld2.16 {d0, d1}, [r4:128]!
   vld2.16 {d0, d1}, [r4:256]!
 
 @ CHECK: vld2.16 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x4d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x5d,0x08]
 @ CHECK: vld2.16 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0x6d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d1}, [r4], r6
   vld2.16 {d0, d1}, [r4:16], r6
   vld2.16 {d0, d1}, [r4:32], r6
   vld2.16 {d0, d1}, [r4:64], r6
   vld2.16 {d0, d1}, [r4:128], r6
   vld2.16 {d0, d1}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x46,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x56,0x08]
 @ CHECK: vld2.16 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0x66,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d2}, [r4]
   vld2.16 {d0, d2}, [r4:16]
   vld2.16 {d0, d2}, [r4:32]
   vld2.16 {d0, d2}, [r4:64]
   vld2.16 {d0, d2}, [r4:128]
   vld2.16 {d0, d2}, [r4:256]
 
 @ CHECK: vld2.16 {d0, d2}, [r4]          @ encoding: [0x24,0xf9,0x4f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d2}, [r4:64]       @ encoding: [0x24,0xf9,0x5f,0x09]
 @ CHECK: vld2.16 {d0, d2}, [r4:128]      @ encoding: [0x24,0xf9,0x6f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d2}, [r4]!
   vld2.16 {d0, d2}, [r4:16]!
   vld2.16 {d0, d2}, [r4:32]!
   vld2.16 {d0, d2}, [r4:64]!
   vld2.16 {d0, d2}, [r4:128]!
   vld2.16 {d0, d2}, [r4:256]!
 
 @ CHECK: vld2.16 {d0, d2}, [r4]!         @ encoding: [0x24,0xf9,0x4d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d2}, [r4:64]!      @ encoding: [0x24,0xf9,0x5d,0x09]
 @ CHECK: vld2.16 {d0, d2}, [r4:128]!     @ encoding: [0x24,0xf9,0x6d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d2}, [r4], r6
   vld2.16 {d0, d2}, [r4:16], r6
   vld2.16 {d0, d2}, [r4:32], r6
   vld2.16 {d0, d2}, [r4:64], r6
   vld2.16 {d0, d2}, [r4:128], r6
   vld2.16 {d0, d2}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0, d2}, [r4], r6      @ encoding: [0x24,0xf9,0x46,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.16 {d0, d2}, [r4:64], r6   @ encoding: [0x24,0xf9,0x56,0x09]
 @ CHECK: vld2.16 {d0, d2}, [r4:128], r6  @ encoding: [0x24,0xf9,0x66,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d2}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.16 {d0, d1, d2, d3}, [r4]
   vld2.16 {d0, d1, d2, d3}, [r4:16]
   vld2.16 {d0, d1, d2, d3}, [r4:32]
   vld2.16 {d0, d1, d2, d3}, [r4:64]
   vld2.16 {d0, d1, d2, d3}, [r4:128]
   vld2.16 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x4f,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x5f,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x6f,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x7f,0x03]
 
   vld2.16 {d0, d1, d2, d3}, [r4]!
   vld2.16 {d0, d1, d2, d3}, [r4:16]!
   vld2.16 {d0, d1, d2, d3}, [r4:32]!
   vld2.16 {d0, d1, d2, d3}, [r4:64]!
   vld2.16 {d0, d1, d2, d3}, [r4:128]!
   vld2.16 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x4d,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x5d,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x6d,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x7d,0x03]
 
   vld2.16 {d0, d1, d2, d3}, [r4], r6
   vld2.16 {d0, d1, d2, d3}, [r4:16], r6
   vld2.16 {d0, d1, d2, d3}, [r4:32], r6
   vld2.16 {d0, d1, d2, d3}, [r4:64], r6
   vld2.16 {d0, d1, d2, d3}, [r4:128], r6
   vld2.16 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x46,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x66,0x03]
 @ CHECK: vld2.16 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x76,0x03]
 
   vld2.16 {d0[2], d1[2]}, [r4]
   vld2.16 {d0[2], d1[2]}, [r4:16]
   vld2.16 {d0[2], d1[2]}, [r4:32]
   vld2.16 {d0[2], d1[2]}, [r4:64]
   vld2.16 {d0[2], d1[2]}, [r4:128]
   vld2.16 {d0[2], d1[2]}, [r4:256]
 
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4]    @ encoding: [0xa4,0xf9,0x8f,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4:32] @ encoding: [0xa4,0xf9,0x9f,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:64]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[2], d1[2]}, [r4]!
   vld2.16 {d0[2], d1[2]}, [r4:16]!
   vld2.16 {d0[2], d1[2]}, [r4:32]!
   vld2.16 {d0[2], d1[2]}, [r4:64]!
   vld2.16 {d0[2], d1[2]}, [r4:128]!
   vld2.16 {d0[2], d1[2]}, [r4:256]!
 
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4]!   @ encoding: [0xa4,0xf9,0x8d,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4:32]! @ encoding: [0xa4,0xf9,0x9d,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:64]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[2], d1[2]}, [r4], r6
   vld2.16 {d0[2], d1[2]}, [r4:16], r6
   vld2.16 {d0[2], d1[2]}, [r4:32], r6
   vld2.16 {d0[2], d1[2]}, [r4:64], r6
   vld2.16 {d0[2], d1[2]}, [r4:128], r6
   vld2.16 {d0[2], d1[2]}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x96,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:64], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d1[2]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[2], d2[2]}, [r4]
   vld2.16 {d0[2], d2[2]}, [r4:16]
   vld2.16 {d0[2], d2[2]}, [r4:32]
   vld2.16 {d0[2], d2[2]}, [r4:64]
   vld2.16 {d0[2], d2[2]}, [r4:128]
   vld2.16 {d0[2], d2[2]}, [r4:256]
 
 @ CHECK: vld2.16 {d0[2], d2[2]}, [r4]    @ encoding: [0xa4,0xf9,0xaf,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d2[2]}, [r4:32] @ encoding: [0xa4,0xf9,0xbf,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:64]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[2], d2[2]}, [r4]!
   vld2.16 {d0[2], d2[2]}, [r4:16]!
   vld2.16 {d0[2], d2[2]}, [r4:32]!
   vld2.16 {d0[2], d2[2]}, [r4:64]!
   vld2.16 {d0[2], d2[2]}, [r4:128]!
   vld2.16 {d0[2], d2[2]}, [r4:256]!
 
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4]!   @ encoding: [0xa4,0xf9,0xad,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d1[2]}, [r4:32]! @ encoding: [0xa4,0xf9,0xbd,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:64]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[2], d2[2]}, [r4], r6
   vld2.16 {d0[2], d2[2]}, [r4:16], r6
   vld2.16 {d0[2], d2[2]}, [r4:32], r6
   vld2.16 {d0[2], d2[2]}, [r4:64], r6
   vld2.16 {d0[2], d2[2]}, [r4:128], r6
   vld2.16 {d0[2], d2[2]}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0[2], d2[2]}, [r4], r6 @ encoding: [0xa4,0xf9,0xa6,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.16 {d0[2], d2[2]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0xb6,0x05]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:64], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[2], d2[2]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vld2.16 {d0[], d1[]}, [r4]
   vld2.16 {d0[], d1[]}, [r4:16]
   vld2.16 {d0[], d1[]}, [r4:32]
   vld2.16 {d0[], d1[]}, [r4:64]
   vld2.16 {d0[], d1[]}, [r4:128]
   vld2.16 {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld2.16 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0x4f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d1[]}, [r4:32]   @ encoding: [0xa4,0xf9,0x5f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.16 {d0[], d1[]}, [r4]!
   vld2.16 {d0[], d1[]}, [r4:16]!
   vld2.16 {d0[], d1[]}, [r4:32]!
   vld2.16 {d0[], d1[]}, [r4:64]!
   vld2.16 {d0[], d1[]}, [r4:128]!
   vld2.16 {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld2.16 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0x4d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d1[]}, [r4:32]!  @ encoding: [0xa4,0xf9,0x5d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld2.16 {d0[], d1[]}, [r4], r6
   vld2.16 {d0[], d1[]}, [r4:16], r6
   vld2.16 {d0[], d1[]}, [r4:32], r6
   vld2.16 {d0[], d1[]}, [r4:64], r6
   vld2.16 {d0[], d1[]}, [r4:128], r6
   vld2.16 {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x46,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d1[]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x56,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld2.16 {d0[], d2[]}, [r4]
   vld2.16 {d0[], d2[]}, [r4:16]
   vld2.16 {d0[], d2[]}, [r4:32]
   vld2.16 {d0[], d2[]}, [r4:64]
   vld2.16 {d0[], d2[]}, [r4:128]
   vld2.16 {d0[], d2[]}, [r4:256]
 
 @ CHECK: vld2.16 {d0[], d2[]}, [r4]      @ encoding: [0xa4,0xf9,0x6f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d2[]}, [r4:32]   @ encoding: [0xa4,0xf9,0x7f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:64]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.16 {d0[], d2[]}, [r4]!
   vld2.16 {d0[], d2[]}, [r4:16]!
   vld2.16 {d0[], d2[]}, [r4:32]!
   vld2.16 {d0[], d2[]}, [r4:64]!
   vld2.16 {d0[], d2[]}, [r4:128]!
   vld2.16 {d0[], d2[]}, [r4:256]!
 
 @ CHECK: vld2.16 {d0[], d2[]}, [r4]!     @ encoding: [0xa4,0xf9,0x6d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d2[]}, [r4:32]!  @ encoding: [0xa4,0xf9,0x7d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:64]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:256]!
 
   vld2.16 {d0[], d2[]}, [r4], r6
   vld2.16 {d0[], d2[]}, [r4:16], r6
   vld2.16 {d0[], d2[]}, [r4:32], r6
   vld2.16 {d0[], d2[]}, [r4:64], r6
   vld2.16 {d0[], d2[]}, [r4:128], r6
   vld2.16 {d0[], d2[]}, [r4:256], r6
 
 @ CHECK: vld2.16 {d0[], d2[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x66,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.16 {d0[], d2[]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x76,0x0d]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:64], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld2.16 {d0[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0, d1}, [r4]
   vld2.32 {d0, d1}, [r4:16]
   vld2.32 {d0, d1}, [r4:32]
   vld2.32 {d0, d1}, [r4:64]
   vld2.32 {d0, d1}, [r4:128]
   vld2.32 {d0, d1}, [r4:256]
 
 @ CHECK: vld2.32 {d0, d1}, [r4]          @ encoding: [0x24,0xf9,0x8f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d1}, [r4:64]       @ encoding: [0x24,0xf9,0x9f,0x08]
 @ CHECK: vld2.32 {d0, d1}, [r4:128]      @ encoding: [0x24,0xf9,0xaf,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d1}, [r4]!
   vld2.32 {d0, d1}, [r4:16]!
   vld2.32 {d0, d1}, [r4:32]!
   vld2.32 {d0, d1}, [r4:64]!
   vld2.32 {d0, d1}, [r4:128]!
   vld2.32 {d0, d1}, [r4:256]!
 
 @ CHECK: vld2.32 {d0, d1}, [r4]!         @ encoding: [0x24,0xf9,0x8d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d1}, [r4:64]!      @ encoding: [0x24,0xf9,0x9d,0x08]
 @ CHECK: vld2.32 {d0, d1}, [r4:128]!     @ encoding: [0x24,0xf9,0xad,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d1}, [r4], r6
   vld2.32 {d0, d1}, [r4:16], r6
   vld2.32 {d0, d1}, [r4:32], r6
   vld2.32 {d0, d1}, [r4:64], r6
   vld2.32 {d0, d1}, [r4:128], r6
   vld2.32 {d0, d1}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0, d1}, [r4], r6      @ encoding: [0x24,0xf9,0x86,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d1}, [r4:64], r6   @ encoding: [0x24,0xf9,0x96,0x08]
 @ CHECK: vld2.32 {d0, d1}, [r4:128], r6  @ encoding: [0x24,0xf9,0xa6,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d2}, [r4]
   vld2.32 {d0, d2}, [r4:16]
   vld2.32 {d0, d2}, [r4:32]
   vld2.32 {d0, d2}, [r4:64]
   vld2.32 {d0, d2}, [r4:128]
   vld2.32 {d0, d2}, [r4:256]
 
 @ CHECK: vld2.32 {d0, d2}, [r4]          @ encoding: [0x24,0xf9,0x8f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d2}, [r4:64]       @ encoding: [0x24,0xf9,0x9f,0x09]
 @ CHECK: vld2.32 {d0, d2}, [r4:128]      @ encoding: [0x24,0xf9,0xaf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d2}, [r4]!
   vld2.32 {d0, d2}, [r4:16]!
   vld2.32 {d0, d2}, [r4:32]!
   vld2.32 {d0, d2}, [r4:64]!
   vld2.32 {d0, d2}, [r4:128]!
   vld2.32 {d0, d2}, [r4:256]!
 
 @ CHECK: vld2.32 {d0, d2}, [r4]!         @ encoding: [0x24,0xf9,0x8d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d2}, [r4:64]!      @ encoding: [0x24,0xf9,0x9d,0x09]
 @ CHECK: vld2.32 {d0, d2}, [r4:128]!     @ encoding: [0x24,0xf9,0xad,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d2}, [r4], r6
   vld2.32 {d0, d2}, [r4:16], r6
   vld2.32 {d0, d2}, [r4:32], r6
   vld2.32 {d0, d2}, [r4:64], r6
   vld2.32 {d0, d2}, [r4:128], r6
   vld2.32 {d0, d2}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0, d2}, [r4], r6      @ encoding: [0x24,0xf9,0x86,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vld2.32 {d0, d2}, [r4:64], r6   @ encoding: [0x24,0xf9,0x96,0x09]
 @ CHECK: vld2.32 {d0, d2}, [r4:128], r6  @ encoding: [0x24,0xf9,0xa6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d2}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vld2.32 {d0, d1, d2, d3}, [r4]
   vld2.32 {d0, d1, d2, d3}, [r4:16]
   vld2.32 {d0, d1, d2, d3}, [r4:32]
   vld2.32 {d0, d1, d2, d3}, [r4:64]
   vld2.32 {d0, d1, d2, d3}, [r4:128]
   vld2.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x8f,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x9f,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0xaf,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0xbf,0x03]
 
   vld2.32 {d0, d1, d2, d3}, [r4]!
   vld2.32 {d0, d1, d2, d3}, [r4:16]!
   vld2.32 {d0, d1, d2, d3}, [r4:32]!
   vld2.32 {d0, d1, d2, d3}, [r4:64]!
   vld2.32 {d0, d1, d2, d3}, [r4:128]!
   vld2.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x8d,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x9d,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0xad,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0xbd,0x03]
 
   vld2.32 {d0, d1, d2, d3}, [r4], r6
   vld2.32 {d0, d1, d2, d3}, [r4:16], r6
   vld2.32 {d0, d1, d2, d3}, [r4:32], r6
   vld2.32 {d0, d1, d2, d3}, [r4:64], r6
   vld2.32 {d0, d1, d2, d3}, [r4:128], r6
   vld2.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x86,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0xa6,0x03]
 @ CHECK: vld2.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0xb6,0x03]
 
   vld2.32 {d0[1], d1[1]}, [r4]
   vld2.32 {d0[1], d1[1]}, [r4:16]
   vld2.32 {d0[1], d1[1]}, [r4:32]
   vld2.32 {d0[1], d1[1]}, [r4:64]
   vld2.32 {d0[1], d1[1]}, [r4:128]
   vld2.32 {d0[1], d1[1]}, [r4:256]
 
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4]    @ encoding: [0xa4,0xf9,0x8f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4:64] @ encoding: [0xa4,0xf9,0x9f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[1], d1[1]}, [r4]!
   vld2.32 {d0[1], d1[1]}, [r4:16]!
   vld2.32 {d0[1], d1[1]}, [r4:32]!
   vld2.32 {d0[1], d1[1]}, [r4:64]!
   vld2.32 {d0[1], d1[1]}, [r4:128]!
   vld2.32 {d0[1], d1[1]}, [r4:256]!
 
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4]!   @ encoding: [0xa4,0xf9,0x8d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0x9d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[1], d1[1]}, [r4], r6
   vld2.32 {d0[1], d1[1]}, [r4:16], r6
   vld2.32 {d0[1], d1[1]}, [r4:32], r6
   vld2.32 {d0[1], d1[1]}, [r4:64], r6
   vld2.32 {d0[1], d1[1]}, [r4:128], r6
   vld2.32 {d0[1], d1[1]}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d1[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x96,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d1[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[1], d2[1]}, [r4]
   vld2.32 {d0[1], d2[1]}, [r4:16]
   vld2.32 {d0[1], d2[1]}, [r4:32]
   vld2.32 {d0[1], d2[1]}, [r4:64]
   vld2.32 {d0[1], d2[1]}, [r4:128]
   vld2.32 {d0[1], d2[1]}, [r4:256]
 
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4]    @ encoding: [0xa4,0xf9,0xcf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4:64] @ encoding: [0xa4,0xf9,0xdf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[1], d2[1]}, [r4]!
   vld2.32 {d0[1], d2[1]}, [r4:16]!
   vld2.32 {d0[1], d2[1]}, [r4:32]!
   vld2.32 {d0[1], d2[1]}, [r4:64]!
   vld2.32 {d0[1], d2[1]}, [r4:128]!
   vld2.32 {d0[1], d2[1]}, [r4:256]!
 
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4]!   @ encoding: [0xa4,0xf9,0xcd,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0xdd,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[1], d2[1]}, [r4], r6
   vld2.32 {d0[1], d2[1]}, [r4:16], r6
   vld2.32 {d0[1], d2[1]}, [r4:32], r6
   vld2.32 {d0[1], d2[1]}, [r4:64], r6
   vld2.32 {d0[1], d2[1]}, [r4:128], r6
   vld2.32 {d0[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0xc6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vld2.32 {d0[1], d2[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0xd6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vld2.32 {d0[], d1[]}, [r4]
   vld2.32 {d0[], d1[]}, [r4:16]
   vld2.32 {d0[], d1[]}, [r4:32]
   vld2.32 {d0[], d1[]}, [r4:64]
   vld2.32 {d0[], d1[]}, [r4:128]
   vld2.32 {d0[], d1[]}, [r4:256]
 
 @ CHECK: vld2.32 {d0[], d1[]}, [r4]      @ encoding: [0xa4,0xf9,0x8f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d1[]}, [r4:64]   @ encoding: [0xa4,0xf9,0x9f,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0[], d1[]}, [r4]!
   vld2.32 {d0[], d1[]}, [r4:16]!
   vld2.32 {d0[], d1[]}, [r4:32]!
   vld2.32 {d0[], d1[]}, [r4:64]!
   vld2.32 {d0[], d1[]}, [r4:128]!
   vld2.32 {d0[], d1[]}, [r4:256]!
 
 @ CHECK: vld2.32 {d0[], d1[]}, [r4]!     @ encoding: [0xa4,0xf9,0x8d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d1[]}, [r4:64]!  @ encoding: [0xa4,0xf9,0x9d,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0[], d1[]}, [r4], r6
   vld2.32 {d0[], d1[]}, [r4:16], r6
   vld2.32 {d0[], d1[]}, [r4:32], r6
   vld2.32 {d0[], d1[]}, [r4:64], r6
   vld2.32 {d0[], d1[]}, [r4:128], r6
   vld2.32 {d0[], d1[]}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0[], d1[]}, [r4], r6  @ encoding: [0xa4,0xf9,0x86,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d1[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x96,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d1[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0[], d2[]}, [r4]
   vld2.32 {d0[], d2[]}, [r4:16]
   vld2.32 {d0[], d2[]}, [r4:32]
   vld2.32 {d0[], d2[]}, [r4:64]
   vld2.32 {d0[], d2[]}, [r4:128]
   vld2.32 {d0[], d2[]}, [r4:256]
 
 @ CHECK: vld2.32 {d0[], d2[]}, [r4]      @ encoding: [0xa4,0xf9,0xaf,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d2[]}, [r4:64]   @ encoding: [0xa4,0xf9,0xbf,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0[], d2[]}, [r4]!
   vld2.32 {d0[], d2[]}, [r4:16]!
   vld2.32 {d0[], d2[]}, [r4:32]!
   vld2.32 {d0[], d2[]}, [r4:64]!
   vld2.32 {d0[], d2[]}, [r4:128]!
   vld2.32 {d0[], d2[]}, [r4:256]!
 
 @ CHECK: vld2.32 {d0[], d2[]}, [r4]!     @ encoding: [0xa4,0xf9,0xad,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d2[]}, [r4:64]!  @ encoding: [0xa4,0xf9,0xbd,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld2.32 {d0[], d2[]}, [r4], r6
   vld2.32 {d0[], d2[]}, [r4:16], r6
   vld2.32 {d0[], d2[]}, [r4:32], r6
   vld2.32 {d0[], d2[]}, [r4:64], r6
   vld2.32 {d0[], d2[]}, [r4:128], r6
   vld2.32 {d0[], d2[]}, [r4:256], r6
 
 @ CHECK: vld2.32 {d0[], d2[]}, [r4], r6  @ encoding: [0xa4,0xf9,0xa6,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld2.32 {d0[], d2[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0xb6,0x0d]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld2.32 {d0[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d1, d2}, [r4]
   vld3.8  {d0, d1, d2}, [r4:16]
   vld3.8  {d0, d1, d2}, [r4:32]
   vld3.8  {d0, d1, d2}, [r4:64]
   vld3.8  {d0, d1, d2}, [r4:128]
   vld3.8  {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld3.8 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x0f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x1f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d1, d2}, [r4]!
   vld3.8  {d0, d1, d2}, [r4:16]!
   vld3.8  {d0, d1, d2}, [r4:32]!
   vld3.8  {d0, d1, d2}, [r4:64]!
   vld3.8  {d0, d1, d2}, [r4:128]!
   vld3.8  {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld3.8 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x0d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x1d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d1, d2}, [r4], r6
   vld3.8  {d0, d1, d2}, [r4:16], r6
   vld3.8  {d0, d1, d2}, [r4:32], r6
   vld3.8  {d0, d1, d2}, [r4:64], r6
   vld3.8  {d0, d1, d2}, [r4:128], r6
   vld3.8  {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld3.8 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x06,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d2, d4}, [r4]
   vld3.8  {d0, d2, d4}, [r4:16]
   vld3.8  {d0, d2, d4}, [r4:32]
   vld3.8  {d0, d2, d4}, [r4:64]
   vld3.8  {d0, d2, d4}, [r4:128]
   vld3.8  {d0, d2, d4}, [r4:256]
 
 @ CHECK: vld3.8 {d0, d2, d4}, [r4]      @ encoding: [0x24,0xf9,0x0f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d2, d4}, [r4:64]   @ encoding: [0x24,0xf9,0x1f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d2, d4}, [r4]!
   vld3.8  {d0, d2, d4}, [r4:16]!
   vld3.8  {d0, d2, d4}, [r4:32]!
   vld3.8  {d0, d2, d4}, [r4:64]!
   vld3.8  {d0, d2, d4}, [r4:128]!
   vld3.8  {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vld3.8 {d0, d2, d4}, [r4]!     @ encoding: [0x24,0xf9,0x0d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d2, d4}, [r4:64]!  @ encoding: [0x24,0xf9,0x1d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0, d2, d4}, [r4], r6
   vld3.8  {d0, d2, d4}, [r4:16], r6
   vld3.8  {d0, d2, d4}, [r4:32], r6
   vld3.8  {d0, d2, d4}, [r4:64], r6
   vld3.8  {d0, d2, d4}, [r4:128], r6
   vld3.8  {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vld3.8 {d0, d2, d4}, [r4], r6  @ encoding: [0x24,0xf9,0x06,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.8 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.8  {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.8  {d0[1], d1[1], d2[1]}, [r4]
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:16]
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:32]
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:64]
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:128]
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vld3.8 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0xa4,0xf9,0x2f,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vld3.8  {d0[1], d1[1], d2[1]}, [r4]!
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:16]!
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:32]!
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:64]!
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:128]!
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vld3.8 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0xa4,0xf9,0x2d,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vld3.8  {d0[1], d1[1], d2[1]}, [r4], r6
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:16], r6
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:32], r6
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:64], r6
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:128], r6
   vld3.8  {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vld3.8 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x26,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vld3.8  {d0[], d1[], d2[]}, [r4]
   vld3.8  {d0[], d1[], d2[]}, [r4:16]
   vld3.8  {d0[], d1[], d2[]}, [r4:32]
   vld3.8  {d0[], d1[], d2[]}, [r4:64]
   vld3.8  {d0[], d1[], d2[]}, [r4:128]
   vld3.8  {d0[], d1[], d2[]}, [r4:256]
 
 @ CHECK: vld3.8 {d0[], d1[], d2[]}, [r4] @ encoding: [0xa4,0xf9,0x0f,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.8  {d0[], d1[], d2[]}, [r4]!
   vld3.8  {d0[], d1[], d2[]}, [r4:16]!
   vld3.8  {d0[], d1[], d2[]}, [r4:32]!
   vld3.8  {d0[], d1[], d2[]}, [r4:64]!
   vld3.8  {d0[], d1[], d2[]}, [r4:128]!
   vld3.8  {d0[], d1[], d2[]}, [r4:256]!
 
 @ CHECK: vld3.8 {d0[], d1[], d2[]}, [r4]! @ encoding: [0xa4,0xf9,0x0d,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.8  {d0[], d1[], d2[]}, [r4], r6
   vld3.8  {d0[], d1[], d2[]}, [r4:16], r6
   vld3.8  {d0[], d1[], d2[]}, [r4:32], r6
   vld3.8  {d0[], d1[], d2[]}, [r4:64], r6
   vld3.8  {d0[], d1[], d2[]}, [r4:128], r6
   vld3.8  {d0[], d1[], d2[]}, [r4:256], r6
 
 @ CHECK: vld3.8 {d0[], d1[], d2[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x06,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d1[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                         ^
 
   vld3.8  {d0[], d2[], d4[]}, [r4]
   vld3.8  {d0[], d2[], d4[]}, [r4:16]
   vld3.8  {d0[], d2[], d4[]}, [r4:32]
   vld3.8  {d0[], d2[], d4[]}, [r4:64]
   vld3.8  {d0[], d2[], d4[]}, [r4:128]
   vld3.8  {d0[], d2[], d4[]}, [r4:256]
 
 @ CHECK: vld3.8 {d0[], d2[], d4[]}, [r4] @ encoding: [0xa4,0xf9,0x2f,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.8  {d0[], d2[], d4[]}, [r4]!
   vld3.8  {d0[], d2[], d4[]}, [r4:16]!
   vld3.8  {d0[], d2[], d4[]}, [r4:32]!
   vld3.8  {d0[], d2[], d4[]}, [r4:64]!
   vld3.8  {d0[], d2[], d4[]}, [r4:128]!
   vld3.8  {d0[], d2[], d4[]}, [r4:256]!
 
 @ CHECK: vld3.8 {d0[], d1[], d2[]}, [r4]! @ encoding: [0xa4,0xf9,0x2d,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.8  {d0[], d2[], d4[]}, [r4], r6
   vld3.8  {d0[], d2[], d4[]}, [r4:16], r6
   vld3.8  {d0[], d2[], d4[]}, [r4:32], r6
   vld3.8  {d0[], d2[], d4[]}, [r4:64], r6
   vld3.8  {d0[], d2[], d4[]}, [r4:128], r6
   vld3.8  {d0[], d2[], d4[]}, [r4:256], r6
 
 @ CHECK: vld3.8 {d0[], d2[], d4[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x26,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.8  {d0[], d2[], d4[]}, [r4:256], r6
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0, d1, d2}, [r4]
   vld3.16 {d0, d1, d2}, [r4:16]
   vld3.16 {d0, d1, d2}, [r4:32]
   vld3.16 {d0, d1, d2}, [r4:64]
   vld3.16 {d0, d1, d2}, [r4:128]
   vld3.16 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld3.16 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x4f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x5f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0, d1, d2}, [r4]!
   vld3.16 {d0, d1, d2}, [r4:16]!
   vld3.16 {d0, d1, d2}, [r4:32]!
   vld3.16 {d0, d1, d2}, [r4:64]!
   vld3.16 {d0, d1, d2}, [r4:128]!
   vld3.16 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld3.16 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x4d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x5d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0, d1, d2}, [r4], r6
   vld3.16 {d0, d1, d2}, [r4:16], r6
   vld3.16 {d0, d1, d2}, [r4:32], r6
   vld3.16 {d0, d1, d2}, [r4:64], r6
   vld3.16 {d0, d1, d2}, [r4:128], r6
   vld3.16 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x46,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0, d2, d4}, [r4]
   vld3.16 {d0, d2, d4}, [r4:16]
   vld3.16 {d0, d2, d4}, [r4:32]
   vld3.16 {d0, d2, d4}, [r4:64]
   vld3.16 {d0, d2, d4}, [r4:128]
   vld3.16 {d0, d2, d4}, [r4:256]
 
 @ CHECK: vld3.16 {d0, d2, d4}, [r4]      @ encoding: [0x24,0xf9,0x4f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d2, d4}, [r4:64]   @ encoding: [0x24,0xf9,0x5f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0, d2, d4}, [r4]!
   vld3.16 {d0, d2, d4}, [r4:16]!
   vld3.16 {d0, d2, d4}, [r4:32]!
   vld3.16 {d0, d2, d4}, [r4:64]!
   vld3.16 {d0, d2, d4}, [r4:128]!
   vld3.16 {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vld3.16 {d0, d2, d4}, [r4]!     @ encoding: [0x24,0xf9,0x4d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d2, d4}, [r4:64]!  @ encoding: [0x24,0xf9,0x5d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0, d2, d4}, [r4], r6
   vld3.16 {d0, d2, d4}, [r4:16], r6
   vld3.16 {d0, d2, d4}, [r4:32], r6
   vld3.16 {d0, d2, d4}, [r4:64], r6
   vld3.16 {d0, d2, d4}, [r4:128], r6
   vld3.16 {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0, d2, d4}, [r4], r6  @ encoding: [0x24,0xf9,0x46,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.16 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.16 {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.16 {d0[1], d1[1], d2[1]}, [r4]
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:16]
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:32]
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:64]
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:128]
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vld3.16 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0xa4,0xf9,0x4f,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[1], d1[1], d2[1]}, [r4]!
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:16]!
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:32]!
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:64]!
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:128]!
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vld3.16 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0xa4,0xf9,0x4d,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[1], d1[1], d2[1]}, [r4], r6
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:16], r6
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:32], r6
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:64], r6
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:128], r6
   vld3.16 {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x46,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[1], d2[1], d4[1]}, [r4]
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:16]
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:32]
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:64]
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:128]
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:256]
 
 @ CHECK: vld3.16 {d0[1], d2[1], d4[1]}, [r4] @ encoding: [0xa4,0xf9,0x6f,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[1], d2[1], d4[1]}, [r4]!
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:16]!
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:32]!
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:64]!
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:128]!
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:256]!
 
 @ CHECK: vld3.16 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0xa4,0xf9,0x6d,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[1], d2[1], d4[1]}, [r4], r6
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:16], r6
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:32], r6
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:64], r6
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:128], r6
   vld3.16 {d0[1], d2[1], d4[1]}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0[1], d2[1], d4[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x66,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[1], d2[1], d4[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vld3.16 {d0[], d1[], d2[]}, [r4]
   vld3.16 {d0[], d1[], d2[]}, [r4:16]
   vld3.16 {d0[], d1[], d2[]}, [r4:32]
   vld3.16 {d0[], d1[], d2[]}, [r4:64]
   vld3.16 {d0[], d1[], d2[]}, [r4:128]
   vld3.16 {d0[], d1[], d2[]}, [r4:256]
 
 @ CHECK: vld3.16 {d0[], d1[], d2[]}, [r4] @ encoding: [0xa4,0xf9,0x4f,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0[], d1[], d2[]}, [r4]!
   vld3.16 {d0[], d1[], d2[]}, [r4:16]!
   vld3.16 {d0[], d1[], d2[]}, [r4:32]!
   vld3.16 {d0[], d1[], d2[]}, [r4:64]!
   vld3.16 {d0[], d1[], d2[]}, [r4:128]!
   vld3.16 {d0[], d1[], d2[]}, [r4:256]!
 
 @ CHECK: vld3.16 {d0[], d1[], d2[]}, [r4]! @ encoding: [0xa4,0xf9,0x4d,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0[], d1[], d2[]}, [r4], r6
   vld3.16 {d0[], d1[], d2[]}, [r4:16], r6
   vld3.16 {d0[], d1[], d2[]}, [r4:32], r6
   vld3.16 {d0[], d1[], d2[]}, [r4:64], r6
   vld3.16 {d0[], d1[], d2[]}, [r4:128], r6
   vld3.16 {d0[], d1[], d2[]}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0[], d1[], d2[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x46,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d1[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0[], d2[], d4[]}, [r4]
   vld3.16 {d0[], d2[], d4[]}, [r4:16]
   vld3.16 {d0[], d2[], d4[]}, [r4:32]
   vld3.16 {d0[], d2[], d4[]}, [r4:64]
   vld3.16 {d0[], d2[], d4[]}, [r4:128]
   vld3.16 {d0[], d2[], d4[]}, [r4:256]
 
 @ CHECK: vld3.16 {d0[], d2[], d4[]}, [r4] @ encoding: [0xa4,0xf9,0x6f,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0[], d2[], d4[]}, [r4]!
   vld3.16 {d0[], d2[], d4[]}, [r4:16]!
   vld3.16 {d0[], d2[], d4[]}, [r4:32]!
   vld3.16 {d0[], d2[], d4[]}, [r4:64]!
   vld3.16 {d0[], d2[], d4[]}, [r4:128]!
   vld3.16 {d0[], d2[], d4[]}, [r4:256]!
 
 @ CHECK: vld3.16 {d0[], d2[], d4[]}, [r4]! @ encoding: [0xa4,0xf9,0x6d,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.16 {d0[], d2[], d4[]}, [r4], r6
   vld3.16 {d0[], d2[], d4[]}, [r4:16], r6
   vld3.16 {d0[], d2[], d4[]}, [r4:32], r6
   vld3.16 {d0[], d2[], d4[]}, [r4:64], r6
   vld3.16 {d0[], d2[], d4[]}, [r4:128], r6
   vld3.16 {d0[], d2[], d4[]}, [r4:256], r6
 
 @ CHECK: vld3.16 {d0[], d2[], d4[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x66,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.16 {d0[], d2[], d4[]}, [r4:256], r6
 
   vld3.32 {d0, d1, d2}, [r4]
   vld3.32 {d0, d1, d2}, [r4:16]
   vld3.32 {d0, d1, d2}, [r4:32]
   vld3.32 {d0, d1, d2}, [r4:64]
   vld3.32 {d0, d1, d2}, [r4:128]
   vld3.32 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vld3.32 {d0, d1, d2}, [r4]      @ encoding: [0x24,0xf9,0x8f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d1, d2}, [r4:64]   @ encoding: [0x24,0xf9,0x9f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0, d1, d2}, [r4]!
   vld3.32 {d0, d1, d2}, [r4:16]!
   vld3.32 {d0, d1, d2}, [r4:32]!
   vld3.32 {d0, d1, d2}, [r4:64]!
   vld3.32 {d0, d1, d2}, [r4:128]!
   vld3.32 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vld3.32 {d0, d1, d2}, [r4]!     @ encoding: [0x24,0xf9,0x8d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d1, d2}, [r4:64]!  @ encoding: [0x24,0xf9,0x9d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0, d1, d2}, [r4], r6
   vld3.32 {d0, d1, d2}, [r4:16], r6
   vld3.32 {d0, d1, d2}, [r4:32], r6
   vld3.32 {d0, d1, d2}, [r4:64], r6
   vld3.32 {d0, d1, d2}, [r4:128], r6
   vld3.32 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0, d1, d2}, [r4], r6  @ encoding: [0x24,0xf9,0x86,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0, d2, d4}, [r4]
   vld3.32 {d0, d2, d4}, [r4:16]
   vld3.32 {d0, d2, d4}, [r4:32]
   vld3.32 {d0, d2, d4}, [r4:64]
   vld3.32 {d0, d2, d4}, [r4:128]
   vld3.32 {d0, d2, d4}, [r4:256]
 
 @ CHECK: vld3.32 {d0, d2, d4}, [r4]      @ encoding: [0x24,0xf9,0x8f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d2, d4}, [r4:64]   @ encoding: [0x24,0xf9,0x9f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0, d2, d4}, [r4]!
   vld3.32 {d0, d2, d4}, [r4:16]!
   vld3.32 {d0, d2, d4}, [r4:32]!
   vld3.32 {d0, d2, d4}, [r4:64]!
   vld3.32 {d0, d2, d4}, [r4:128]!
   vld3.32 {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vld3.32 {d0, d2, d4}, [r4]!     @ encoding: [0x24,0xf9,0x8d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d2, d4}, [r4:64]!  @ encoding: [0x24,0xf9,0x9d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0, d2, d4}, [r4], r6
   vld3.32 {d0, d2, d4}, [r4:16], r6
   vld3.32 {d0, d2, d4}, [r4:32], r6
   vld3.32 {d0, d2, d4}, [r4:64], r6
   vld3.32 {d0, d2, d4}, [r4:128], r6
   vld3.32 {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0, d2, d4}, [r4], r6  @ encoding: [0x24,0xf9,0x86,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vld3.32 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld3.32 {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vld3.32 {d0[1], d1[1], d2[1]}, [r4]
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:16]
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:32]
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:64]
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:128]
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vld3.32 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0xa4,0xf9,0x8f,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[1], d1[1], d2[1]}, [r4]!
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:16]!
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:32]!
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:64]!
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:128]!
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vld3.32 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0xa4,0xf9,0x8d,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[1], d1[1], d2[1]}, [r4], r6
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:16], r6
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:32], r6
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:64], r6
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:128], r6
   vld3.32 {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[1], d2[1], d4[1]}, [r4]
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:16]
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:32]
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:64]
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:128]
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:256]
 
 @ CHECK: vld3.32 {d0[1], d2[1], d4[1]}, [r4] @ encoding: [0xa4,0xf9,0xcf,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[1], d2[1], d4[1]}, [r4]!
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:16]!
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:32]!
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:64]!
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:128]!
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:256]!
 
 @ CHECK: vld3.32 {d0[1], d2[1], d4[1]}, [r4]! @ encoding: [0xa4,0xf9,0xcd,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[1], d2[1], d4[1]}, [r4], r6
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:16], r6
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:32], r6
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:64], r6
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:128], r6
   vld3.32 {d0[1], d2[1], d4[1]}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0[1], d2[1], d4[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0xc6,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[1], d2[1], d4[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vld3.32 {d0[], d1[], d2[]}, [r4]
   vld3.32 {d0[], d1[], d2[]}, [r4:16]
   vld3.32 {d0[], d1[], d2[]}, [r4:32]
   vld3.32 {d0[], d1[], d2[]}, [r4:64]
   vld3.32 {d0[], d1[], d2[]}, [r4:128]
   vld3.32 {d0[], d1[], d2[]}, [r4:256]
 
 @ CHECK: vld3.32 {d0[], d1[], d2[]}, [r4] @ encoding: [0xa4,0xf9,0x8f,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.32 {d0[], d1[], d2[]}, [r4]!
   vld3.32 {d0[], d1[], d2[]}, [r4:16]!
   vld3.32 {d0[], d1[], d2[]}, [r4:32]!
   vld3.32 {d0[], d1[], d2[]}, [r4:64]!
   vld3.32 {d0[], d1[], d2[]}, [r4:128]!
   vld3.32 {d0[], d1[], d2[]}, [r4:256]!
 
 @ CHECK: vld3.32 {d0[], d1[], d2[]}, [r4]! @ encoding: [0xa4,0xf9,0x8d,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.32 {d0[], d1[], d2[]}, [r4], r6
   vld3.32 {d0[], d1[], d2[]}, [r4:16], r6
   vld3.32 {d0[], d1[], d2[]}, [r4:32], r6
   vld3.32 {d0[], d1[], d2[]}, [r4:64], r6
   vld3.32 {d0[], d1[], d2[]}, [r4:128], r6
   vld3.32 {d0[], d1[], d2[]}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0[], d1[], d2[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d1[], d2[]}, [r4:256], r6
 @ CHECK-ERRORS:                                         ^
 
   vld3.32 {d0[], d2[], d4[]}, [r4]
   vld3.32 {d0[], d2[], d4[]}, [r4:16]
   vld3.32 {d0[], d2[], d4[]}, [r4:32]
   vld3.32 {d0[], d2[], d4[]}, [r4:64]
   vld3.32 {d0[], d2[], d4[]}, [r4:128]
   vld3.32 {d0[], d2[], d4[]}, [r4:256]
 
 @ CHECK: vld3.32 {d0[], d2[], d4[]}, [r4] @ encoding: [0xa4,0xf9,0xaf,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:16]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:32]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:64]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:128]
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:256]
 @ CHECK-ERRORS:                                         ^
 
   vld3.32 {d0[], d2[], d4[]}, [r4]!
   vld3.32 {d0[], d2[], d4[]}, [r4:16]!
   vld3.32 {d0[], d2[], d4[]}, [r4:32]!
   vld3.32 {d0[], d2[], d4[]}, [r4:64]!
   vld3.32 {d0[], d2[], d4[]}, [r4:128]!
   vld3.32 {d0[], d2[], d4[]}, [r4:256]!
 
 @ CHECK: vld3.32 {d0[], d2[], d4[]}, [r4]! @ encoding: [0xa4,0xf9,0xad,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:16]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:32]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:64]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:128]!
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:256]!
 @ CHECK-ERRORS:                                         ^
 
   vld3.32 {d0[], d2[], d4[]}, [r4], r6
   vld3.32 {d0[], d2[], d4[]}, [r4:16], r6
   vld3.32 {d0[], d2[], d4[]}, [r4:32], r6
   vld3.32 {d0[], d2[], d4[]}, [r4:64], r6
   vld3.32 {d0[], d2[], d4[]}, [r4:128], r6
   vld3.32 {d0[], d2[], d4[]}, [r4:256], r6
 
 @ CHECK: vld3.32 {d0[], d2[], d4[]}, [r4], r6 @ encoding: [0xa4,0xf9,0xa6,0x0e]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:16], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:32], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:64], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:128], r6
 @ CHECK-ERRORS:                                         ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vld3.32 {d0[], d2[], d4[]}, [r4:256], r6
 @ CHECK-ERRORS:                                         ^
 
   vld4.8  {d0, d1, d2, d3}, [r4]
   vld4.8  {d0, d1, d2, d3}, [r4:16]
   vld4.8  {d0, d1, d2, d3}, [r4:32]
   vld4.8  {d0, d1, d2, d3}, [r4:64]
   vld4.8  {d0, d1, d2, d3}, [r4:128]
   vld4.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x0f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x1f,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x2f,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x3f,0x00]
 
   vld4.8  {d0, d1, d2, d3}, [r4]!
   vld4.8  {d0, d1, d2, d3}, [r4:16]!
   vld4.8  {d0, d1, d2, d3}, [r4:32]!
   vld4.8  {d0, d1, d2, d3}, [r4:64]!
   vld4.8  {d0, d1, d2, d3}, [r4:128]!
   vld4.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x0d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x1d,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x2d,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x3d,0x00]
 
   vld4.8  {d0, d1, d2, d3}, [r4], r6
   vld4.8  {d0, d1, d2, d3}, [r4:16], r6
   vld4.8  {d0, d1, d2, d3}, [r4:32], r6
   vld4.8  {d0, d1, d2, d3}, [r4:64], r6
   vld4.8  {d0, d1, d2, d3}, [r4:128], r6
   vld4.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x06,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x26,0x00]
 @ CHECK: vld4.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x36,0x00]
 
   vld4.8  {d0, d2, d4, d6}, [r4]
   vld4.8  {d0, d2, d4, d6}, [r4:16]
   vld4.8  {d0, d2, d4, d6}, [r4:32]
   vld4.8  {d0, d2, d4, d6}, [r4:64]
   vld4.8  {d0, d2, d4, d6}, [r4:128]
   vld4.8  {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4]  @ encoding: [0x24,0xf9,0x0f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x24,0xf9,0x1f,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x24,0xf9,0x2f,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x24,0xf9,0x3f,0x01]
 
   vld4.8  {d0, d2, d4, d6}, [r4]!
   vld4.8  {d0, d2, d4, d6}, [r4:16]!
   vld4.8  {d0, d2, d4, d6}, [r4:32]!
   vld4.8  {d0, d2, d4, d6}, [r4:64]!
   vld4.8  {d0, d2, d4, d6}, [r4:128]!
   vld4.8  {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4]! @ encoding: [0x24,0xf9,0x0d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x24,0xf9,0x1d,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x24,0xf9,0x2d,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x24,0xf9,0x3d,0x01]
 
   vld4.8  {d0, d2, d4, d6}, [r4], r6
   vld4.8  {d0, d2, d4, d6}, [r4:16], r6
   vld4.8  {d0, d2, d4, d6}, [r4:32], r6
   vld4.8  {d0, d2, d4, d6}, [r4:64], r6
   vld4.8  {d0, d2, d4, d6}, [r4:128], r6
   vld4.8  {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x24,0xf9,0x06,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x24,0xf9,0x16,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x24,0xf9,0x26,0x01]
 @ CHECK: vld4.8 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x24,0xf9,0x36,0x01]
 
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0xa4,0xf9,0x2f,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32] @ encoding: [0xa4,0xf9,0x3f,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0xa4,0xf9,0x2d,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]! @ encoding: [0xa4,0xf9,0x3d,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x26,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x36,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4]
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16]
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:32]
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64]
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128]
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256]
 
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4] @ encoding: [0xa4,0xf9,0x0f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4:32] @ encoding: [0xa4,0xf9,0x1f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4]!
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16]!
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:32]!
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64]!
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128]!
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256]!
 
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4]! @ encoding: [0xa4,0xf9,0x0d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4:32]! @ encoding: [0xa4,0xf9,0x1d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4], r6
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16], r6
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:32], r6
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64], r6
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128], r6
   vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256], r6
 
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x06,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x16,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:64], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:128], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d1[], d2[], d3[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4]
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16]
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:32]
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64]
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128]
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256]
 
 @ CHECK: vld4.8 {d0[], d2[], d4[], d6[]}, [r4] @ encoding: [0xa4,0xf9,0x2f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d2[], d4[], d6[]}, [r4:32] @ encoding: [0xa4,0xf9,0x3f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4]!
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16]!
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:32]!
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64]!
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128]!
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256]!
 
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4]! @ encoding: [0xa4,0xf9,0x2d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d1[], d2[], d3[]}, [r4:32]! @ encoding: [0xa4,0xf9,0x3d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4], r6
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16], r6
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:32], r6
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64], r6
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128], r6
   vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256], r6
 
 @ CHECK: vld4.8 {d0[], d2[], d4[], d6[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x26,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.8 {d0[], d2[], d4[], d6[]}, [r4:32], r6 @ encoding: [0xa4,0xf9,0x36,0x0f]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:64], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:128], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vld4.8  {d0[], d2[], d4[], d6[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0, d1, d2, d3}, [r4]
   vld4.16 {d0, d1, d2, d3}, [r4:16]
   vld4.16 {d0, d1, d2, d3}, [r4:32]
   vld4.16 {d0, d1, d2, d3}, [r4:64]
   vld4.16 {d0, d1, d2, d3}, [r4:128]
   vld4.16 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x4f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x5f,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0x6f,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0x7f,0x00]
 
   vld4.16 {d0, d1, d2, d3}, [r4]!
   vld4.16 {d0, d1, d2, d3}, [r4:16]!
   vld4.16 {d0, d1, d2, d3}, [r4:32]!
   vld4.16 {d0, d1, d2, d3}, [r4:64]!
   vld4.16 {d0, d1, d2, d3}, [r4:128]!
   vld4.16 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x4d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x5d,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0x6d,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0x7d,0x00]
 
   vld4.16 {d0, d1, d2, d3}, [r4], r6
   vld4.16 {d0, d1, d2, d3}, [r4:16], r6
   vld4.16 {d0, d1, d2, d3}, [r4:32], r6
   vld4.16 {d0, d1, d2, d3}, [r4:64], r6
   vld4.16 {d0, d1, d2, d3}, [r4:128], r6
   vld4.16 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x46,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0x66,0x00]
 @ CHECK: vld4.16 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0x76,0x00]
 
   vld4.16 {d0, d2, d4, d6}, [r4]
   vld4.16 {d0, d2, d4, d6}, [r4:16]
   vld4.16 {d0, d2, d4, d6}, [r4:32]
   vld4.16 {d0, d2, d4, d6}, [r4:64]
   vld4.16 {d0, d2, d4, d6}, [r4:128]
   vld4.16 {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4]  @ encoding: [0x24,0xf9,0x4f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x24,0xf9,0x5f,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x24,0xf9,0x6f,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x24,0xf9,0x7f,0x01]
 
   vld4.16 {d0, d2, d4, d6}, [r4]!
   vld4.16 {d0, d2, d4, d6}, [r4:16]!
   vld4.16 {d0, d2, d4, d6}, [r4:32]!
   vld4.16 {d0, d2, d4, d6}, [r4:64]!
   vld4.16 {d0, d2, d4, d6}, [r4:128]!
   vld4.16 {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4]! @ encoding: [0x24,0xf9,0x4d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x24,0xf9,0x5d,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x24,0xf9,0x6d,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x24,0xf9,0x7d,0x01]
 
   vld4.16 {d0, d2, d4, d6}, [r4], r6
   vld4.16 {d0, d2, d4, d6}, [r4:16], r6
   vld4.16 {d0, d2, d4, d6}, [r4:32], r6
   vld4.16 {d0, d2, d4, d6}, [r4:64], r6
   vld4.16 {d0, d2, d4, d6}, [r4:128], r6
   vld4.16 {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x24,0xf9,0x46,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x24,0xf9,0x56,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x24,0xf9,0x66,0x01]
 @ CHECK: vld4.16 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x24,0xf9,0x76,0x01]
 
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0xa4,0xf9,0x4f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64] @ encoding: [0xa4,0xf9,0x5f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0xa4,0xf9,0x4d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0x5d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x46,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x56,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4]
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4] @ encoding: [0xa4,0xf9,0x6f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64] @ encoding: [0xa4,0xf9,0x7f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4]!
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]!
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4]! @ encoding: [0xa4,0xf9,0x6d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0x7d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
   vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x66,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x76,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4]
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16]
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32]
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64]
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128]
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256]
 
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4] @ encoding: [0xa4,0xf9,0x4f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64] @ encoding: [0xa4,0xf9,0x5f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4]!
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16]!
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32]!
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64]!
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128]!
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256]!
 
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4]! @ encoding: [0xa4,0xf9,0x4d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64]! @ encoding: [0xa4,0xf9,0x5d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4], r6
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16], r6
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32], r6
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64], r6
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128], r6
   vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x46,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:32], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x56,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:128], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d1[], d2[], d3[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4]
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16]
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32]
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:64]
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128]
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256]
 
 @ CHECK: vld4.16 {d0[], d2[], d4[], d6[]}, [r4] @ encoding: [0xa4,0xf9,0x6f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d2[], d4[], d6[]}, [r4:64] @ encoding: [0xa4,0xf9,0x7f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4]!
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16]!
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32]!
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:64]!
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128]!
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256]!
 
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4]! @ encoding: [0xa4,0xf9,0x6d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d1[], d2[], d3[]}, [r4:64]! @ encoding: [0xa4,0xf9,0x7d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4], r6
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16], r6
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32], r6
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:64], r6
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128], r6
   vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256], r6
 
 @ CHECK: vld4.16 {d0[], d2[], d4[], d6[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x66,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:32], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.16 {d0[], d2[], d4[], d6[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x76,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:128], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vld4.16 {d0[], d2[], d4[], d6[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0, d1, d2, d3}, [r4]
   vld4.32 {d0, d1, d2, d3}, [r4:16]
   vld4.32 {d0, d1, d2, d3}, [r4:32]
   vld4.32 {d0, d1, d2, d3}, [r4:64]
   vld4.32 {d0, d1, d2, d3}, [r4:128]
   vld4.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x24,0xf9,0x8f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x24,0xf9,0x9f,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x24,0xf9,0xaf,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x24,0xf9,0xbf,0x00]
 
   vld4.32 {d0, d1, d2, d3}, [r4]!
   vld4.32 {d0, d1, d2, d3}, [r4:16]!
   vld4.32 {d0, d1, d2, d3}, [r4:32]!
   vld4.32 {d0, d1, d2, d3}, [r4:64]!
   vld4.32 {d0, d1, d2, d3}, [r4:128]!
   vld4.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x24,0xf9,0x8d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x24,0xf9,0x9d,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x24,0xf9,0xad,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x24,0xf9,0xbd,0x00]
 
   vld4.32 {d0, d1, d2, d3}, [r4], r6
   vld4.32 {d0, d1, d2, d3}, [r4:16], r6
   vld4.32 {d0, d1, d2, d3}, [r4:32], r6
   vld4.32 {d0, d1, d2, d3}, [r4:64], r6
   vld4.32 {d0, d1, d2, d3}, [r4:128], r6
   vld4.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x24,0xf9,0x86,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x24,0xf9,0xa6,0x00]
 @ CHECK: vld4.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x24,0xf9,0xb6,0x00]
 
   vld4.32 {d0, d2, d4, d6}, [r4]
   vld4.32 {d0, d2, d4, d6}, [r4:16]
   vld4.32 {d0, d2, d4, d6}, [r4:32]
   vld4.32 {d0, d2, d4, d6}, [r4:64]
   vld4.32 {d0, d2, d4, d6}, [r4:128]
   vld4.32 {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4]  @ encoding: [0x24,0xf9,0x8f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x24,0xf9,0x9f,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x24,0xf9,0xaf,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x24,0xf9,0xbf,0x01]
 
   vld4.32 {d0, d2, d4, d6}, [r4]!
   vld4.32 {d0, d2, d4, d6}, [r4:16]!
   vld4.32 {d0, d2, d4, d6}, [r4:32]!
   vld4.32 {d0, d2, d4, d6}, [r4:64]!
   vld4.32 {d0, d2, d4, d6}, [r4:128]!
   vld4.32 {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4]! @ encoding: [0x24,0xf9,0x8d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x24,0xf9,0x9d,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x24,0xf9,0xad,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x24,0xf9,0xbd,0x01]
 
   vld4.32 {d0, d2, d4, d6}, [r4], r6
   vld4.32 {d0, d2, d4, d6}, [r4:16], r6
   vld4.32 {d0, d2, d4, d6}, [r4:32], r6
   vld4.32 {d0, d2, d4, d6}, [r4:64], r6
   vld4.32 {d0, d2, d4, d6}, [r4:128], r6
   vld4.32 {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x24,0xf9,0x86,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x24,0xf9,0x96,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x24,0xf9,0xa6,0x01]
 @ CHECK: vld4.32 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x24,0xf9,0xb6,0x01]
 
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0xa4,0xf9,0x8f,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64] @ encoding: [0xa4,0xf9,0x9f,0x0b]
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128] @ encoding: [0xa4,0xf9,0xaf,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0xa4,0xf9,0x8d,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0x9d,0x0b]
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]! @ encoding: [0xa4,0xf9,0xad,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x96,0x0b]
 @ CHECK: vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6 @ encoding: [0xa4,0xf9,0xa6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4] @ encoding: [0xa4,0xf9,0xcf,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64] @ encoding: [0xa4,0xf9,0xdf,0x0b]
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128] @ encoding: [0xa4,0xf9,0xef,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]!
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]!
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]! @ encoding: [0xa4,0xf9,0xcd,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]! @ encoding: [0xa4,0xf9,0xdd,0x0b]
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]! @ encoding: [0xa4,0xf9,0xed,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
   vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6 @ encoding: [0xa4,0xf9,0xc6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0xd6,0x0b]
 @ CHECK: vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6 @ encoding: [0xa4,0xf9,0xe6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4]
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16]
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32]
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64]
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128]
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256]
 
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4] @ encoding: [0xa4,0xf9,0x8f,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64] @ encoding: [0xa4,0xf9,0x9f,0x0f]
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128] @ encoding: [0xa4,0xf9,0xdf,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4]!
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16]!
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32]!
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64]!
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128]!
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256]!
 
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4]! @ encoding: [0xa4,0xf9,0x8d,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64]! @ encoding: [0xa4,0xf9,0x9d,0x0f]
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128]! @ encoding: [0xa4,0xf9,0xdd,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4], r6
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16], r6
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32], r6
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64], r6
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128], r6
   vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4], r6 @ encoding: [0xa4,0xf9,0x86,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:32], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0x96,0x0f]
 @ CHECK: vld4.32 {d0[], d1[], d2[], d3[]}, [r4:128], r6 @ encoding: [0xa4,0xf9,0xd6,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d1[], d2[], d3[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4]
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16]
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32]
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64]
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128]
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256]
 
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4] @ encoding: [0xa4,0xf9,0xaf,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16]
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32]
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64] @ encoding: [0xa4,0xf9,0xbf,0x0f]
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128] @ encoding: [0xa4,0xf9,0xff,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256]
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4]!
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16]!
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32]!
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64]!
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128]!
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256]!
 
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4]! @ encoding: [0xa4,0xf9,0xad,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16]!
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32]!
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64]! @ encoding: [0xa4,0xf9,0xbd,0x0f]
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128]! @ encoding: [0xa4,0xf9,0xfd,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256]!
 @ CHECK-ERRORS:                                               ^
 
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4], r6
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16], r6
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32], r6
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64], r6
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128], r6
   vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256], r6
 
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4], r6 @ encoding: [0xa4,0xf9,0xa6,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:16], r6
 @ CHECK-ERRORS:                                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:32], r6
 @ CHECK-ERRORS:                                               ^
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:64], r6 @ encoding: [0xa4,0xf9,0xb6,0x0f]
 @ CHECK: vld4.32 {d0[], d2[], d4[], d6[]}, [r4:128], r6 @ encoding: [0xa4,0xf9,0xf6,0x0f]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vld4.32 {d0[], d2[], d4[], d6[]}, [r4:256], r6
 @ CHECK-ERRORS:                                               ^
 
   vst1.8  {d0}, [r4]
   vst1.8  {d0}, [r4:16]
   vst1.8  {d0}, [r4:32]
   vst1.8  {d0}, [r4:64]
   vst1.8  {d0}, [r4:128]
   vst1.8  {d0}, [r4:256]
 
 @ CHECK: vst1.8 {d0}, [r4]              @ encoding: [0x04,0xf9,0x0f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.8 {d0}, [r4:64]           @ encoding: [0x04,0xf9,0x1f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vst1.8  {d0}, [r4]!
   vst1.8  {d0}, [r4:16]!
   vst1.8  {d0}, [r4:32]!
   vst1.8  {d0}, [r4:64]!
   vst1.8  {d0}, [r4:128]!
   vst1.8  {d0}, [r4:256]!
 
 @ CHECK: vst1.8 {d0}, [r4]!             @ encoding: [0x04,0xf9,0x0d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.8 {d0}, [r4:64]!          @ encoding: [0x04,0xf9,0x1d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vst1.8  {d0}, [r4], r6
   vst1.8  {d0}, [r4:16], r6
   vst1.8  {d0}, [r4:32], r6
   vst1.8  {d0}, [r4:64], r6
   vst1.8  {d0}, [r4:128], r6
   vst1.8  {d0}, [r4:256], r6
 
 @ CHECK: vst1.8 {d0}, [r4], r6          @ encoding: [0x04,0xf9,0x06,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.8 {d0}, [r4:64], r6       @ encoding: [0x04,0xf9,0x16,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vst1.8  {d0, d1}, [r4]
   vst1.8  {d0, d1}, [r4:16]
   vst1.8  {d0, d1}, [r4:32]
   vst1.8  {d0, d1}, [r4:64]
   vst1.8  {d0, d1}, [r4:128]
   vst1.8  {d0, d1}, [r4:256]
 
 @ CHECK: vst1.8 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0x0f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.8 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0x1f,0x0a]
 @ CHECK: vst1.8 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0x2f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst1.8  {d0, d1}, [r4]!
   vst1.8  {d0, d1}, [r4:16]!
   vst1.8  {d0, d1}, [r4:32]!
   vst1.8  {d0, d1}, [r4:64]!
   vst1.8  {d0, d1}, [r4:128]!
   vst1.8  {d0, d1}, [r4:256]!
 
 @ CHECK: vst1.8 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0x0d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.8 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0x1d,0x0a]
 @ CHECK: vst1.8 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0x2d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst1.8  {d0, d1}, [r4], r6
   vst1.8  {d0, d1}, [r4:16], r6
   vst1.8  {d0, d1}, [r4:32], r6
   vst1.8  {d0, d1}, [r4:64], r6
   vst1.8  {d0, d1}, [r4:128], r6
   vst1.8  {d0, d1}, [r4:256], r6
 
 @ CHECK: vst1.8 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0x06,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.8 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0x16,0x0a]
 @ CHECK: vst1.8 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0x26,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst1.8  {d0, d1, d2}, [r4]
   vst1.8  {d0, d1, d2}, [r4:16]
   vst1.8  {d0, d1, d2}, [r4:32]
   vst1.8  {d0, d1, d2}, [r4:64]
   vst1.8  {d0, d1, d2}, [r4:128]
   vst1.8  {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst1.8 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x0f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.8 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x1f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst1.8  {d0, d1, d2}, [r4]!
   vst1.8  {d0, d1, d2}, [r4:16]!
   vst1.8  {d0, d1, d2}, [r4:32]!
   vst1.8  {d0, d1, d2}, [r4:64]!
   vst1.8  {d0, d1, d2}, [r4:128]!
   vst1.8  {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst1.8 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x0d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.8 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x1d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst1.8  {d0, d1, d2}, [r4], r6
   vst1.8  {d0, d1, d2}, [r4:16], r6
   vst1.8  {d0, d1, d2}, [r4:32], r6
   vst1.8  {d0, d1, d2}, [r4:64], r6
   vst1.8  {d0, d1, d2}, [r4:128], r6
   vst1.8  {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst1.8 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x06,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.8 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst1.8  {d0, d1, d2, d3}, [r4]
   vst1.8  {d0, d1, d2, d3}, [r4:16]
   vst1.8  {d0, d1, d2, d3}, [r4:32]
   vst1.8  {d0, d1, d2, d3}, [r4:64]
   vst1.8  {d0, d1, d2, d3}, [r4:128]
   vst1.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x0f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x1f,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0x2f,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0x3f,0x02]
 
   vst1.8  {d0, d1, d2, d3}, [r4]!
   vst1.8  {d0, d1, d2, d3}, [r4:16]!
   vst1.8  {d0, d1, d2, d3}, [r4:32]!
   vst1.8  {d0, d1, d2, d3}, [r4:64]!
   vst1.8  {d0, d1, d2, d3}, [r4:128]!
   vst1.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x0d,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x1d,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0x2d,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0x3d,0x02]
 
   vst1.8  {d0, d1, d2, d3}, [r4], r6
   vst1.8  {d0, d1, d2, d3}, [r4:16], r6
   vst1.8  {d0, d1, d2, d3}, [r4:32], r6
   vst1.8  {d0, d1, d2, d3}, [r4:64], r6
   vst1.8  {d0, d1, d2, d3}, [r4:128], r6
   vst1.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x06,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0x26,0x02]
 @ CHECK: vst1.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0x36,0x02]
 
   vst1.8  {d0[2]}, [r4]
   vst1.8  {d0[2]}, [r4:16]
   vst1.8  {d0[2]}, [r4:32]
   vst1.8  {d0[2]}, [r4:64]
   vst1.8  {d0[2]}, [r4:128]
   vst1.8  {d0[2]}, [r4:256]
 
 @ CHECK: vst1.8 {d0[2]}, [r4]           @ encoding: [0x84,0xf9,0x4f,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:16]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:32]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vst1.8  {d0[2]}, [r4]!
   vst1.8  {d0[2]}, [r4:16]!
   vst1.8  {d0[2]}, [r4:32]!
   vst1.8  {d0[2]}, [r4:64]!
   vst1.8  {d0[2]}, [r4:128]!
   vst1.8  {d0[2]}, [r4:256]!
 
 @ CHECK: vst1.8 {d0[2]}, [r4]!          @ encoding: [0x84,0xf9,0x4d,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:16]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:32]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vst1.8  {d0[2]}, [r4], r6
   vst1.8  {d0[2]}, [r4:16], r6
   vst1.8  {d0[2]}, [r4:32], r6
   vst1.8  {d0[2]}, [r4:64], r6
   vst1.8  {d0[2]}, [r4:128], r6
   vst1.8  {d0[2]}, [r4:256], r6
 
 @ CHECK: vst1.8 {d0[2]}, [r4], r6       @ encoding: [0x84,0xf9,0x46,0x00]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:16], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:32], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst1.8  {d0[2]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vst1.16 {d0}, [r4]
   vst1.16 {d0}, [r4:16]
   vst1.16 {d0}, [r4:32]
   vst1.16 {d0}, [r4:64]
   vst1.16 {d0}, [r4:128]
   vst1.16 {d0}, [r4:256]
 
 @ CHECK: vst1.16 {d0}, [r4]              @ encoding: [0x04,0xf9,0x4f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.16 {d0}, [r4:64]           @ encoding: [0x04,0xf9,0x5f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vst1.16 {d0}, [r4]!
   vst1.16 {d0}, [r4:16]!
   vst1.16 {d0}, [r4:32]!
   vst1.16 {d0}, [r4:64]!
   vst1.16 {d0}, [r4:128]!
   vst1.16 {d0}, [r4:256]!
 
 @ CHECK: vst1.16 {d0}, [r4]!             @ encoding: [0x04,0xf9,0x4d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.16 {d0}, [r4:64]!          @ encoding: [0x04,0xf9,0x5d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vst1.16 {d0}, [r4], r6
   vst1.16 {d0}, [r4:16], r6
   vst1.16 {d0}, [r4:32], r6
   vst1.16 {d0}, [r4:64], r6
   vst1.16 {d0}, [r4:128], r6
   vst1.16 {d0}, [r4:256], r6
 
 @ CHECK: vst1.16 {d0}, [r4], r6          @ encoding: [0x04,0xf9,0x46,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.16 {d0}, [r4:64], r6       @ encoding: [0x04,0xf9,0x56,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vst1.16 {d0, d1}, [r4]
   vst1.16 {d0, d1}, [r4:16]
   vst1.16 {d0, d1}, [r4:32]
   vst1.16 {d0, d1}, [r4:64]
   vst1.16 {d0, d1}, [r4:128]
   vst1.16 {d0, d1}, [r4:256]
 
 @ CHECK: vst1.16 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0x4f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.16 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0x5f,0x0a]
 @ CHECK: vst1.16 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0x6f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst1.16 {d0, d1}, [r4]!
   vst1.16 {d0, d1}, [r4:16]!
   vst1.16 {d0, d1}, [r4:32]!
   vst1.16 {d0, d1}, [r4:64]!
   vst1.16 {d0, d1}, [r4:128]!
   vst1.16 {d0, d1}, [r4:256]!
 
 @ CHECK: vst1.16 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0x4d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.16 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0x5d,0x0a]
 @ CHECK: vst1.16 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0x6d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst1.16 {d0, d1}, [r4], r6
   vst1.16 {d0, d1}, [r4:16], r6
   vst1.16 {d0, d1}, [r4:32], r6
   vst1.16 {d0, d1}, [r4:64], r6
   vst1.16 {d0, d1}, [r4:128], r6
   vst1.16 {d0, d1}, [r4:256], r6
 
 @ CHECK: vst1.16 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0x46,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.16 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0x56,0x0a]
 @ CHECK: vst1.16 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0x66,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst1.16 {d0, d1, d2}, [r4]
   vst1.16 {d0, d1, d2}, [r4:16]
   vst1.16 {d0, d1, d2}, [r4:32]
   vst1.16 {d0, d1, d2}, [r4:64]
   vst1.16 {d0, d1, d2}, [r4:128]
   vst1.16 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst1.16 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x4f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.16 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x5f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst1.16 {d0, d1, d2}, [r4]!
   vst1.16 {d0, d1, d2}, [r4:16]!
   vst1.16 {d0, d1, d2}, [r4:32]!
   vst1.16 {d0, d1, d2}, [r4:64]!
   vst1.16 {d0, d1, d2}, [r4:128]!
   vst1.16 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst1.16 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x4d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.16 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x5d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst1.16 {d0, d1, d2}, [r4], r6
   vst1.16 {d0, d1, d2}, [r4:16], r6
   vst1.16 {d0, d1, d2}, [r4:32], r6
   vst1.16 {d0, d1, d2}, [r4:64], r6
   vst1.16 {d0, d1, d2}, [r4:128], r6
   vst1.16 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst1.16 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x46,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.16 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst1.16 {d0, d1, d2, d3}, [r4]
   vst1.16 {d0, d1, d2, d3}, [r4:16]
   vst1.16 {d0, d1, d2, d3}, [r4:32]
   vst1.16 {d0, d1, d2, d3}, [r4:64]
   vst1.16 {d0, d1, d2, d3}, [r4:128]
   vst1.16 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x4f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x5f,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0x6f,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0x7f,0x02]
 
   vst1.16 {d0, d1, d2, d3}, [r4]!
   vst1.16 {d0, d1, d2, d3}, [r4:16]!
   vst1.16 {d0, d1, d2, d3}, [r4:32]!
   vst1.16 {d0, d1, d2, d3}, [r4:64]!
   vst1.16 {d0, d1, d2, d3}, [r4:128]!
   vst1.16 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x4d,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x5d,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0x6d,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0x7d,0x02]
 
   vst1.16 {d0, d1, d2, d3}, [r4], r6
   vst1.16 {d0, d1, d2, d3}, [r4:16], r6
   vst1.16 {d0, d1, d2, d3}, [r4:32], r6
   vst1.16 {d0, d1, d2, d3}, [r4:64], r6
   vst1.16 {d0, d1, d2, d3}, [r4:128], r6
   vst1.16 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x46,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0x66,0x02]
 @ CHECK: vst1.16 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0x76,0x02]
 
   vst1.16 {d0[2]}, [r4]
   vst1.16 {d0[2]}, [r4:16]
   vst1.16 {d0[2]}, [r4:32]
   vst1.16 {d0[2]}, [r4:64]
   vst1.16 {d0[2]}, [r4:128]
   vst1.16 {d0[2]}, [r4:256]
 
 @ CHECK: vst1.16 {d0[2]}, [r4]           @ encoding: [0x84,0xf9,0x8f,0x04]
 @ CHECK: vst1.16 {d0[2]}, [r4:16]        @ encoding: [0x84,0xf9,0x9f,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:32]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vst1.16 {d0[2]}, [r4]!
   vst1.16 {d0[2]}, [r4:16]!
   vst1.16 {d0[2]}, [r4:32]!
   vst1.16 {d0[2]}, [r4:64]!
   vst1.16 {d0[2]}, [r4:128]!
   vst1.16 {d0[2]}, [r4:256]!
 
 @ CHECK: vst1.16 {d0[2]}, [r4]!          @ encoding: [0x84,0xf9,0x8d,0x04]
 @ CHECK: vst1.16 {d0[2]}, [r4:16]!       @ encoding: [0x84,0xf9,0x9d,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:32]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vst1.16 {d0[2]}, [r4], r6
   vst1.16 {d0[2]}, [r4:16], r6
   vst1.16 {d0[2]}, [r4:32], r6
   vst1.16 {d0[2]}, [r4:64], r6
   vst1.16 {d0[2]}, [r4:128], r6
   vst1.16 {d0[2]}, [r4:256], r6
 
 @ CHECK: vst1.16 {d0[2]}, [r4], r6       @ encoding: [0x84,0xf9,0x86,0x04]
 @ CHECK: vst1.16 {d0[2]}, [r4:16], r6    @ encoding: [0x84,0xf9,0x96,0x04]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:32], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst1.16 {d0[2]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vst1.32 {d0}, [r4]
   vst1.32 {d0}, [r4:16]
   vst1.32 {d0}, [r4:32]
   vst1.32 {d0}, [r4:64]
   vst1.32 {d0}, [r4:128]
   vst1.32 {d0}, [r4:256]
 
 @ CHECK: vst1.32 {d0}, [r4]              @ encoding: [0x04,0xf9,0x8f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.32 {d0}, [r4:64]           @ encoding: [0x04,0xf9,0x9f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vst1.32 {d0}, [r4]!
   vst1.32 {d0}, [r4:16]!
   vst1.32 {d0}, [r4:32]!
   vst1.32 {d0}, [r4:64]!
   vst1.32 {d0}, [r4:128]!
   vst1.32 {d0}, [r4:256]!
 
 @ CHECK: vst1.32 {d0}, [r4]!             @ encoding: [0x04,0xf9,0x8d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.32 {d0}, [r4:64]!          @ encoding: [0x04,0xf9,0x9d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vst1.32 {d0}, [r4], r6
   vst1.32 {d0}, [r4:16], r6
   vst1.32 {d0}, [r4:32], r6
   vst1.32 {d0}, [r4:64], r6
   vst1.32 {d0}, [r4:128], r6
   vst1.32 {d0}, [r4:256], r6
 
 @ CHECK: vst1.32 {d0}, [r4], r6          @ encoding: [0x04,0xf9,0x86,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.32 {d0}, [r4:64], r6       @ encoding: [0x04,0xf9,0x96,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vst1.32 {d0, d1}, [r4]
   vst1.32 {d0, d1}, [r4:16]
   vst1.32 {d0, d1}, [r4:32]
   vst1.32 {d0, d1}, [r4:64]
   vst1.32 {d0, d1}, [r4:128]
   vst1.32 {d0, d1}, [r4:256]
 
 @ CHECK: vst1.32 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0x8f,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.32 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0x9f,0x0a]
 @ CHECK: vst1.32 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0xaf,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst1.32 {d0, d1}, [r4]!
   vst1.32 {d0, d1}, [r4:16]!
   vst1.32 {d0, d1}, [r4:32]!
   vst1.32 {d0, d1}, [r4:64]!
   vst1.32 {d0, d1}, [r4:128]!
   vst1.32 {d0, d1}, [r4:256]!
 
 @ CHECK: vst1.32 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0x8d,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.32 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0x9d,0x0a]
 @ CHECK: vst1.32 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0xad,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst1.32 {d0, d1}, [r4], r6
   vst1.32 {d0, d1}, [r4:16], r6
   vst1.32 {d0, d1}, [r4:32], r6
   vst1.32 {d0, d1}, [r4:64], r6
   vst1.32 {d0, d1}, [r4:128], r6
   vst1.32 {d0, d1}, [r4:256], r6
 
 @ CHECK: vst1.32 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0x86,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.32 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0x96,0x0a]
 @ CHECK: vst1.32 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0xa6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst1.32 {d0, d1, d2}, [r4]
   vst1.32 {d0, d1, d2}, [r4:16]
   vst1.32 {d0, d1, d2}, [r4:32]
   vst1.32 {d0, d1, d2}, [r4:64]
   vst1.32 {d0, d1, d2}, [r4:128]
   vst1.32 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst1.32 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x8f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.32 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x9f,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst1.32 {d0, d1, d2}, [r4]!
   vst1.32 {d0, d1, d2}, [r4:16]!
   vst1.32 {d0, d1, d2}, [r4:32]!
   vst1.32 {d0, d1, d2}, [r4:64]!
   vst1.32 {d0, d1, d2}, [r4:128]!
   vst1.32 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst1.32 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x8d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.32 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x9d,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst1.32 {d0, d1, d2}, [r4], r6
   vst1.32 {d0, d1, d2}, [r4:16], r6
   vst1.32 {d0, d1, d2}, [r4:32], r6
   vst1.32 {d0, d1, d2}, [r4:64], r6
   vst1.32 {d0, d1, d2}, [r4:128], r6
   vst1.32 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst1.32 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x86,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.32 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst1.32 {d0, d1, d2, d3}, [r4]
   vst1.32 {d0, d1, d2, d3}, [r4:16]
   vst1.32 {d0, d1, d2, d3}, [r4:32]
   vst1.32 {d0, d1, d2, d3}, [r4:64]
   vst1.32 {d0, d1, d2, d3}, [r4:128]
   vst1.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x8f,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x9f,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0xaf,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0xbf,0x02]
 
   vst1.32 {d0, d1, d2, d3}, [r4]!
   vst1.32 {d0, d1, d2, d3}, [r4:16]!
   vst1.32 {d0, d1, d2, d3}, [r4:32]!
   vst1.32 {d0, d1, d2, d3}, [r4:64]!
   vst1.32 {d0, d1, d2, d3}, [r4:128]!
   vst1.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x8d,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x9d,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0xad,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0xbd,0x02]
 
   vst1.32 {d0, d1, d2, d3}, [r4], r6
   vst1.32 {d0, d1, d2, d3}, [r4:16], r6
   vst1.32 {d0, d1, d2, d3}, [r4:32], r6
   vst1.32 {d0, d1, d2, d3}, [r4:64], r6
   vst1.32 {d0, d1, d2, d3}, [r4:128], r6
   vst1.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x86,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0xa6,0x02]
 @ CHECK: vst1.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0xb6,0x02]
 
   vst1.32 {d0[1]}, [r4]
   vst1.32 {d0[1]}, [r4:16]
   vst1.32 {d0[1]}, [r4:32]
   vst1.32 {d0[1]}, [r4:64]
   vst1.32 {d0[1]}, [r4:128]
   vst1.32 {d0[1]}, [r4:256]
 
 @ CHECK: vst1.32 {d0[1]}, [r4]           @ encoding: [0x84,0xf9,0x8f,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:16]
 @ CHECK-ERRORS:                              ^
 @ CHECK: vst1.32 {d0[1]}, [r4:32]        @ encoding: [0x84,0xf9,0xbf,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:64]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:128]
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:256]
 @ CHECK-ERRORS:                              ^
 
   vst1.32 {d0[1]}, [r4]!
   vst1.32 {d0[1]}, [r4:16]!
   vst1.32 {d0[1]}, [r4:32]!
   vst1.32 {d0[1]}, [r4:64]!
   vst1.32 {d0[1]}, [r4:128]!
   vst1.32 {d0[1]}, [r4:256]!
 
 @ CHECK: vst1.32 {d0[1]}, [r4]!          @ encoding: [0x84,0xf9,0x8d,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:16]!
 @ CHECK-ERRORS:                              ^
 @ CHECK: vst1.32 {d0[1]}, [r4:32]!       @ encoding: [0x84,0xf9,0xbd,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:64]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:128]!
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:256]!
 @ CHECK-ERRORS:                              ^
 
   vst1.32 {d0[1]}, [r4], r6
   vst1.32 {d0[1]}, [r4:16], r6
   vst1.32 {d0[1]}, [r4:32], r6
   vst1.32 {d0[1]}, [r4:64], r6
   vst1.32 {d0[1]}, [r4:128], r6
   vst1.32 {d0[1]}, [r4:256], r6
 
 @ CHECK: vst1.32 {d0[1]}, [r4], r6       @ encoding: [0x84,0xf9,0x86,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:16], r6
 @ CHECK-ERRORS:                              ^
 @ CHECK: vst1.32 {d0[1]}, [r4:32], r6    @ encoding: [0x84,0xf9,0xb6,0x08]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:64], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:128], r6
 @ CHECK-ERRORS:                              ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst1.32 {d0[1]}, [r4:256], r6
 @ CHECK-ERRORS:                              ^
 
   vst1.64 {d0}, [r4]
   vst1.64 {d0}, [r4:16]
   vst1.64 {d0}, [r4:32]
   vst1.64 {d0}, [r4:64]
   vst1.64 {d0}, [r4:128]
   vst1.64 {d0}, [r4:256]
 
 @ CHECK: vst1.64 {d0}, [r4]              @ encoding: [0x04,0xf9,0xcf,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:16]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:32]
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.64 {d0}, [r4:64]           @ encoding: [0x04,0xf9,0xdf,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:128]
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:256]
 @ CHECK-ERRORS:                           ^
 
   vst1.64 {d0}, [r4]!
   vst1.64 {d0}, [r4:16]!
   vst1.64 {d0}, [r4:32]!
   vst1.64 {d0}, [r4:64]!
   vst1.64 {d0}, [r4:128]!
   vst1.64 {d0}, [r4:256]!
 
 @ CHECK: vst1.64 {d0}, [r4]!             @ encoding: [0x04,0xf9,0xcd,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:16]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:32]!
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.64 {d0}, [r4:64]!          @ encoding: [0x04,0xf9,0xdd,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:128]!
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:256]!
 @ CHECK-ERRORS:                           ^
 
   vst1.64 {d0}, [r4], r6
   vst1.64 {d0}, [r4:16], r6
   vst1.64 {d0}, [r4:32], r6
   vst1.64 {d0}, [r4:64], r6
   vst1.64 {d0}, [r4:128], r6
   vst1.64 {d0}, [r4:256], r6
 
 @ CHECK: vst1.64 {d0}, [r4], r6          @ encoding: [0x04,0xf9,0xc6,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:16], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:32], r6
 @ CHECK-ERRORS:                           ^
 @ CHECK: vst1.64 {d0}, [r4:64], r6       @ encoding: [0x04,0xf9,0xd6,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:128], r6
 @ CHECK-ERRORS:                           ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0}, [r4:256], r6
 @ CHECK-ERRORS:                           ^
 
   vst1.64 {d0, d1}, [r4]
   vst1.64 {d0, d1}, [r4:16]
   vst1.64 {d0, d1}, [r4:32]
   vst1.64 {d0, d1}, [r4:64]
   vst1.64 {d0, d1}, [r4:128]
   vst1.64 {d0, d1}, [r4:256]
 
 @ CHECK: vst1.64 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0xcf,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.64 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0xdf,0x0a]
 @ CHECK: vst1.64 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0xef,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst1.64 {d0, d1}, [r4]!
   vst1.64 {d0, d1}, [r4:16]!
   vst1.64 {d0, d1}, [r4:32]!
   vst1.64 {d0, d1}, [r4:64]!
   vst1.64 {d0, d1}, [r4:128]!
   vst1.64 {d0, d1}, [r4:256]!
 
 @ CHECK: vst1.64 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0xcd,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.64 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0xdd,0x0a]
 @ CHECK: vst1.64 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0xed,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst1.64 {d0, d1}, [r4], r6
   vst1.64 {d0, d1}, [r4:16], r6
   vst1.64 {d0, d1}, [r4:32], r6
   vst1.64 {d0, d1}, [r4:64], r6
   vst1.64 {d0, d1}, [r4:128], r6
   vst1.64 {d0, d1}, [r4:256], r6
 
 @ CHECK: vst1.64 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0xc6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst1.64 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0xd6,0x0a]
 @ CHECK: vst1.64 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0xe6,0x0a]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst1.64 {d0, d1, d2}, [r4]
   vst1.64 {d0, d1, d2}, [r4:16]
   vst1.64 {d0, d1, d2}, [r4:32]
   vst1.64 {d0, d1, d2}, [r4:64]
   vst1.64 {d0, d1, d2}, [r4:128]
   vst1.64 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst1.64 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0xcf,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.64 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0xdf,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst1.64 {d0, d1, d2}, [r4]!
   vst1.64 {d0, d1, d2}, [r4:16]!
   vst1.64 {d0, d1, d2}, [r4:32]!
   vst1.64 {d0, d1, d2}, [r4:64]!
   vst1.64 {d0, d1, d2}, [r4:128]!
   vst1.64 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst1.64 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0xcd,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.64 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0xdd,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst1.64 {d0, d1, d2}, [r4], r6
   vst1.64 {d0, d1, d2}, [r4:16], r6
   vst1.64 {d0, d1, d2}, [r4:32], r6
   vst1.64 {d0, d1, d2}, [r4:64], r6
   vst1.64 {d0, d1, d2}, [r4:128], r6
   vst1.64 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst1.64 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0xc6,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst1.64 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0xd6,0x06]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst1.64 {d0, d1, d2, d3}, [r4]
   vst1.64 {d0, d1, d2, d3}, [r4:16]
   vst1.64 {d0, d1, d2, d3}, [r4:32]
   vst1.64 {d0, d1, d2, d3}, [r4:64]
   vst1.64 {d0, d1, d2, d3}, [r4:128]
   vst1.64 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0xcf,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0xdf,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0xef,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0xff,0x02]
 
   vst1.64 {d0, d1, d2, d3}, [r4]!
   vst1.64 {d0, d1, d2, d3}, [r4:16]!
   vst1.64 {d0, d1, d2, d3}, [r4:32]!
   vst1.64 {d0, d1, d2, d3}, [r4:64]!
   vst1.64 {d0, d1, d2, d3}, [r4:128]!
   vst1.64 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0xcd,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0xdd,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0xed,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0xfd,0x02]
 
   vst1.64 {d0, d1, d2, d3}, [r4], r6
   vst1.64 {d0, d1, d2, d3}, [r4:16], r6
   vst1.64 {d0, d1, d2, d3}, [r4:32], r6
   vst1.64 {d0, d1, d2, d3}, [r4:64], r6
   vst1.64 {d0, d1, d2, d3}, [r4:128], r6
   vst1.64 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0xc6,0x02]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst1.64 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0xd6,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0xe6,0x02]
 @ CHECK: vst1.64 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0xf6,0x02]
 
   vst2.8  {d0, d1}, [r4]
   vst2.8  {d0, d1}, [r4:16]
   vst2.8  {d0, d1}, [r4:32]
   vst2.8  {d0, d1}, [r4:64]
   vst2.8  {d0, d1}, [r4:128]
   vst2.8  {d0, d1}, [r4:256]
 
 @ CHECK: vst2.8 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0x0f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0x1f,0x08]
 @ CHECK: vst2.8 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0x2f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d1}, [r4]!
   vst2.8  {d0, d1}, [r4:16]!
   vst2.8  {d0, d1}, [r4:32]!
   vst2.8  {d0, d1}, [r4:64]!
   vst2.8  {d0, d1}, [r4:128]!
   vst2.8  {d0, d1}, [r4:256]!
 
 @ CHECK: vst2.8 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0x0d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0x1d,0x08]
 @ CHECK: vst2.8 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0x2d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d1}, [r4], r6
   vst2.8  {d0, d1}, [r4:16], r6
   vst2.8  {d0, d1}, [r4:32], r6
   vst2.8  {d0, d1}, [r4:64], r6
   vst2.8  {d0, d1}, [r4:128], r6
   vst2.8  {d0, d1}, [r4:256], r6
 
 @ CHECK: vst2.8 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0x06,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0x16,0x08]
 @ CHECK: vst2.8 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0x26,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d2}, [r4]
   vst2.8  {d0, d2}, [r4:16]
   vst2.8  {d0, d2}, [r4:32]
   vst2.8  {d0, d2}, [r4:64]
   vst2.8  {d0, d2}, [r4:128]
   vst2.8  {d0, d2}, [r4:256]
 
 @ CHECK: vst2.8 {d0, d2}, [r4]          @ encoding: [0x04,0xf9,0x0f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d2}, [r4:64]       @ encoding: [0x04,0xf9,0x1f,0x09]
 @ CHECK: vst2.8 {d0, d2}, [r4:128]      @ encoding: [0x04,0xf9,0x2f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d2}, [r4]!
   vst2.8  {d0, d2}, [r4:16]!
   vst2.8  {d0, d2}, [r4:32]!
   vst2.8  {d0, d2}, [r4:64]!
   vst2.8  {d0, d2}, [r4:128]!
   vst2.8  {d0, d2}, [r4:256]!
 
 @ CHECK: vst2.8 {d0, d2}, [r4]!         @ encoding: [0x04,0xf9,0x0d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d2}, [r4:64]!      @ encoding: [0x04,0xf9,0x1d,0x09]
 @ CHECK: vst2.8 {d0, d2}, [r4:128]!     @ encoding: [0x04,0xf9,0x2d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d2}, [r4], r6
   vst2.8  {d0, d2}, [r4:16], r6
   vst2.8  {d0, d2}, [r4:32], r6
   vst2.8  {d0, d2}, [r4:64], r6
   vst2.8  {d0, d2}, [r4:128], r6
   vst2.8  {d0, d2}, [r4:256], r6
 
 @ CHECK: vst2.8 {d0, d2}, [r4], r6      @ encoding: [0x04,0xf9,0x06,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.8 {d0, d2}, [r4:64], r6   @ encoding: [0x04,0xf9,0x16,0x09]
 @ CHECK: vst2.8 {d0, d2}, [r4:128], r6  @ encoding: [0x04,0xf9,0x26,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d2}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst2.8  {d0, d1, d2, d3}, [r4]
   vst2.8  {d0, d1, d2, d3}, [r4:16]
   vst2.8  {d0, d1, d2, d3}, [r4:32]
   vst2.8  {d0, d1, d2, d3}, [r4:64]
   vst2.8  {d0, d1, d2, d3}, [r4:128]
   vst2.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x0f,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x1f,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0x2f,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0x3f,0x03]
 
   vst2.8  {d0, d1, d2, d3}, [r4]!
   vst2.8  {d0, d1, d2, d3}, [r4:16]!
   vst2.8  {d0, d1, d2, d3}, [r4:32]!
   vst2.8  {d0, d1, d2, d3}, [r4:64]!
   vst2.8  {d0, d1, d2, d3}, [r4:128]!
   vst2.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x0d,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x1d,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0x2d,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0x3d,0x03]
 
   vst2.8  {d0, d1, d2, d3}, [r4], r6
   vst2.8  {d0, d1, d2, d3}, [r4:16], r6
   vst2.8  {d0, d1, d2, d3}, [r4:32], r6
   vst2.8  {d0, d1, d2, d3}, [r4:64], r6
   vst2.8  {d0, d1, d2, d3}, [r4:128], r6
   vst2.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x06,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0x26,0x03]
 @ CHECK: vst2.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0x36,0x03]
 
   vst2.8  {d0[2], d1[2]}, [r4]
   vst2.8  {d0[2], d1[2]}, [r4:16]
   vst2.8  {d0[2], d1[2]}, [r4:32]
   vst2.8  {d0[2], d1[2]}, [r4:64]
   vst2.8  {d0[2], d1[2]}, [r4:128]
   vst2.8  {d0[2], d1[2]}, [r4:256]
 
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4]    @ encoding: [0x84,0xf9,0x4f,0x01]
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4:16] @ encoding: [0x84,0xf9,0x5f,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:64]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vst2.8  {d0[2], d1[2]}, [r4]!
   vst2.8  {d0[2], d1[2]}, [r4:16]!
   vst2.8  {d0[2], d1[2]}, [r4:32]!
   vst2.8  {d0[2], d1[2]}, [r4:64]!
   vst2.8  {d0[2], d1[2]}, [r4:128]!
   vst2.8  {d0[2], d1[2]}, [r4:256]!
 
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4]!   @ encoding: [0x84,0xf9,0x4d,0x01]
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4:16]! @ encoding: [0x84,0xf9,0x5d,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:64]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vst2.8  {d0[2], d1[2]}, [r4], r6
   vst2.8  {d0[2], d1[2]}, [r4:16], r6
   vst2.8  {d0[2], d1[2]}, [r4:32], r6
   vst2.8  {d0[2], d1[2]}, [r4:64], r6
   vst2.8  {d0[2], d1[2]}, [r4:128], r6
   vst2.8  {d0[2], d1[2]}, [r4:256], r6
 
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4], r6 @ encoding: [0x84,0xf9,0x46,0x01]
 @ CHECK: vst2.8 {d0[2], d1[2]}, [r4:16], r6 @ encoding: [0x84,0xf9,0x56,0x01]
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:64], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 16 or omitted
+@ CHECK-ERRORS: alignment must be 16 or omitted
 @ CHECK-ERRORS:         vst2.8  {d0[2], d1[2]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0, d1}, [r4]
   vst2.32 {d0, d1}, [r4:16]
   vst2.32 {d0, d1}, [r4:32]
   vst2.32 {d0, d1}, [r4:64]
   vst2.32 {d0, d1}, [r4:128]
   vst2.32 {d0, d1}, [r4:256]
 
 @ CHECK: vst2.32 {d0, d1}, [r4]          @ encoding: [0x04,0xf9,0x8f,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d1}, [r4:64]       @ encoding: [0x04,0xf9,0x9f,0x08]
 @ CHECK: vst2.32 {d0, d1}, [r4:128]      @ encoding: [0x04,0xf9,0xaf,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d1}, [r4]!
   vst2.32 {d0, d1}, [r4:16]!
   vst2.32 {d0, d1}, [r4:32]!
   vst2.32 {d0, d1}, [r4:64]!
   vst2.32 {d0, d1}, [r4:128]!
   vst2.32 {d0, d1}, [r4:256]!
 
 @ CHECK: vst2.32 {d0, d1}, [r4]!         @ encoding: [0x04,0xf9,0x8d,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d1}, [r4:64]!      @ encoding: [0x04,0xf9,0x9d,0x08]
 @ CHECK: vst2.32 {d0, d1}, [r4:128]!     @ encoding: [0x04,0xf9,0xad,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d1}, [r4], r6
   vst2.32 {d0, d1}, [r4:16], r6
   vst2.32 {d0, d1}, [r4:32], r6
   vst2.32 {d0, d1}, [r4:64], r6
   vst2.32 {d0, d1}, [r4:128], r6
   vst2.32 {d0, d1}, [r4:256], r6
 
 @ CHECK: vst2.32 {d0, d1}, [r4], r6      @ encoding: [0x04,0xf9,0x86,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d1}, [r4:64], r6   @ encoding: [0x04,0xf9,0x96,0x08]
 @ CHECK: vst2.32 {d0, d1}, [r4:128], r6  @ encoding: [0x04,0xf9,0xa6,0x08]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d2}, [r4]
   vst2.32 {d0, d2}, [r4:16]
   vst2.32 {d0, d2}, [r4:32]
   vst2.32 {d0, d2}, [r4:64]
   vst2.32 {d0, d2}, [r4:128]
   vst2.32 {d0, d2}, [r4:256]
 
 @ CHECK: vst2.32 {d0, d2}, [r4]          @ encoding: [0x04,0xf9,0x8f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:16]
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:32]
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d2}, [r4:64]       @ encoding: [0x04,0xf9,0x9f,0x09]
 @ CHECK: vst2.32 {d0, d2}, [r4:128]      @ encoding: [0x04,0xf9,0xaf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:256]
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d2}, [r4]!
   vst2.32 {d0, d2}, [r4:16]!
   vst2.32 {d0, d2}, [r4:32]!
   vst2.32 {d0, d2}, [r4:64]!
   vst2.32 {d0, d2}, [r4:128]!
   vst2.32 {d0, d2}, [r4:256]!
 
 @ CHECK: vst2.32 {d0, d2}, [r4]!         @ encoding: [0x04,0xf9,0x8d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:16]!
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:32]!
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d2}, [r4:64]!      @ encoding: [0x04,0xf9,0x9d,0x09]
 @ CHECK: vst2.32 {d0, d2}, [r4:128]!     @ encoding: [0x04,0xf9,0xad,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:256]!
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d2}, [r4], r6
   vst2.32 {d0, d2}, [r4:16], r6
   vst2.32 {d0, d2}, [r4:32], r6
   vst2.32 {d0, d2}, [r4:64], r6
   vst2.32 {d0, d2}, [r4:128], r6
   vst2.32 {d0, d2}, [r4:256], r6
 
 @ CHECK: vst2.32 {d0, d2}, [r4], r6      @ encoding: [0x04,0xf9,0x86,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:16], r6
 @ CHECK-ERRORS:                               ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:32], r6
 @ CHECK-ERRORS:                               ^
 @ CHECK: vst2.32 {d0, d2}, [r4:64], r6   @ encoding: [0x04,0xf9,0x96,0x09]
 @ CHECK: vst2.32 {d0, d2}, [r4:128], r6  @ encoding: [0x04,0xf9,0xa6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d2}, [r4:256], r6
 @ CHECK-ERRORS:                               ^
 
   vst2.32 {d0, d1, d2, d3}, [r4]
   vst2.32 {d0, d1, d2, d3}, [r4:16]
   vst2.32 {d0, d1, d2, d3}, [r4:32]
   vst2.32 {d0, d1, d2, d3}, [r4:64]
   vst2.32 {d0, d1, d2, d3}, [r4:128]
   vst2.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x8f,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x9f,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0xaf,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0xbf,0x03]
 
   vst2.32 {d0, d1, d2, d3}, [r4]!
   vst2.32 {d0, d1, d2, d3}, [r4:16]!
   vst2.32 {d0, d1, d2, d3}, [r4:32]!
   vst2.32 {d0, d1, d2, d3}, [r4:64]!
   vst2.32 {d0, d1, d2, d3}, [r4:128]!
   vst2.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x8d,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x9d,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0xad,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0xbd,0x03]
 
   vst2.32 {d0, d1, d2, d3}, [r4], r6
   vst2.32 {d0, d1, d2, d3}, [r4:16], r6
   vst2.32 {d0, d1, d2, d3}, [r4:32], r6
   vst2.32 {d0, d1, d2, d3}, [r4:64], r6
   vst2.32 {d0, d1, d2, d3}, [r4:128], r6
   vst2.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x86,0x03]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0xa6,0x03]
 @ CHECK: vst2.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0xb6,0x03]
 
   vst2.32 {d0[1], d1[1]}, [r4]
   vst2.32 {d0[1], d1[1]}, [r4:16]
   vst2.32 {d0[1], d1[1]}, [r4:32]
   vst2.32 {d0[1], d1[1]}, [r4:64]
   vst2.32 {d0[1], d1[1]}, [r4:128]
   vst2.32 {d0[1], d1[1]}, [r4:256]
 
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4]    @ encoding: [0x84,0xf9,0x8f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4:64] @ encoding: [0x84,0xf9,0x9f,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0[1], d1[1]}, [r4]!
   vst2.32 {d0[1], d1[1]}, [r4:16]!
   vst2.32 {d0[1], d1[1]}, [r4:32]!
   vst2.32 {d0[1], d1[1]}, [r4:64]!
   vst2.32 {d0[1], d1[1]}, [r4:128]!
   vst2.32 {d0[1], d1[1]}, [r4:256]!
 
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4]!   @ encoding: [0x84,0xf9,0x8d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4:64]! @ encoding: [0x84,0xf9,0x9d,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0[1], d1[1]}, [r4], r6
   vst2.32 {d0[1], d1[1]}, [r4:16], r6
   vst2.32 {d0[1], d1[1]}, [r4:32], r6
   vst2.32 {d0[1], d1[1]}, [r4:64], r6
   vst2.32 {d0[1], d1[1]}, [r4:128], r6
   vst2.32 {d0[1], d1[1]}, [r4:256], r6
 
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x86,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d1[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0x96,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d1[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0[1], d2[1]}, [r4]
   vst2.32 {d0[1], d2[1]}, [r4:16]
   vst2.32 {d0[1], d2[1]}, [r4:32]
   vst2.32 {d0[1], d2[1]}, [r4:64]
   vst2.32 {d0[1], d2[1]}, [r4:128]
   vst2.32 {d0[1], d2[1]}, [r4:256]
 
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4]    @ encoding: [0x84,0xf9,0xcf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4:64] @ encoding: [0x84,0xf9,0xdf,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0[1], d2[1]}, [r4]!
   vst2.32 {d0[1], d2[1]}, [r4:16]!
   vst2.32 {d0[1], d2[1]}, [r4:32]!
   vst2.32 {d0[1], d2[1]}, [r4:64]!
   vst2.32 {d0[1], d2[1]}, [r4:128]!
   vst2.32 {d0[1], d2[1]}, [r4:256]!
 
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4]!   @ encoding: [0x84,0xf9,0xcd,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4:64]! @ encoding: [0x84,0xf9,0xdd,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                     ^
 
   vst2.32 {d0[1], d2[1]}, [r4], r6
   vst2.32 {d0[1], d2[1]}, [r4:16], r6
   vst2.32 {d0[1], d2[1]}, [r4:32], r6
   vst2.32 {d0[1], d2[1]}, [r4:64], r6
   vst2.32 {d0[1], d2[1]}, [r4:128], r6
   vst2.32 {d0[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4], r6 @ encoding: [0x84,0xf9,0xc6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                     ^
 @ CHECK: vst2.32 {d0[1], d2[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0xd6,0x09]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                     ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst2.32 {d0[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                     ^
 
   vst3.8  {d0, d1, d2}, [r4]
   vst3.8  {d0, d1, d2}, [r4:16]
   vst3.8  {d0, d1, d2}, [r4:32]
   vst3.8  {d0, d1, d2}, [r4:64]
   vst3.8  {d0, d1, d2}, [r4:128]
   vst3.8  {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst3.8 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x0f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x1f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0, d1, d2}, [r4]!
   vst3.8  {d0, d1, d2}, [r4:16]!
   vst3.8  {d0, d1, d2}, [r4:32]!
   vst3.8  {d0, d1, d2}, [r4:64]!
   vst3.8  {d0, d1, d2}, [r4:128]!
   vst3.8  {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst3.8 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x0d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x1d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0, d1, d2}, [r4], r6
   vst3.8  {d0, d1, d2}, [r4:16], r6
   vst3.8  {d0, d1, d2}, [r4:32], r6
   vst3.8  {d0, d1, d2}, [r4:64], r6
   vst3.8  {d0, d1, d2}, [r4:128], r6
   vst3.8  {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst3.8 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x06,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0, d2, d4}, [r4]
   vst3.8  {d0, d2, d4}, [r4:16]
   vst3.8  {d0, d2, d4}, [r4:32]
   vst3.8  {d0, d2, d4}, [r4:64]
   vst3.8  {d0, d2, d4}, [r4:128]
   vst3.8  {d0, d2, d4}, [r4:256]
 
 @ CHECK: vst3.8 {d0, d2, d4}, [r4]      @ encoding: [0x04,0xf9,0x0f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d2, d4}, [r4:64]   @ encoding: [0x04,0xf9,0x1f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0, d2, d4}, [r4]!
   vst3.8  {d0, d2, d4}, [r4:16]!
   vst3.8  {d0, d2, d4}, [r4:32]!
   vst3.8  {d0, d2, d4}, [r4:64]!
   vst3.8  {d0, d2, d4}, [r4:128]!
   vst3.8  {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vst3.8 {d0, d2, d4}, [r4]!     @ encoding: [0x04,0xf9,0x0d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d2, d4}, [r4:64]!  @ encoding: [0x04,0xf9,0x1d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0, d2, d4}, [r4], r6
   vst3.8  {d0, d2, d4}, [r4:16], r6
   vst3.8  {d0, d2, d4}, [r4:32], r6
   vst3.8  {d0, d2, d4}, [r4:64], r6
   vst3.8  {d0, d2, d4}, [r4:128], r6
   vst3.8  {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vst3.8 {d0, d2, d4}, [r4], r6  @ encoding: [0x04,0xf9,0x06,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.8 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.8  {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.8  {d0[1], d1[1], d2[1]}, [r4]
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:16]
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:32]
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:64]
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:128]
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vst3.8 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0x84,0xf9,0x2f,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vst3.8  {d0[1], d1[1], d2[1]}, [r4]!
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:16]!
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:32]!
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:64]!
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:128]!
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vst3.8 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0x84,0xf9,0x2d,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vst3.8  {d0[1], d1[1], d2[1]}, [r4], r6
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:16], r6
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:32], r6
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:64], r6
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:128], r6
   vst3.8  {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vst3.8 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x26,0x02]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.8  {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0, d1, d2}, [r4]
   vst3.16 {d0, d1, d2}, [r4:16]
   vst3.16 {d0, d1, d2}, [r4:32]
   vst3.16 {d0, d1, d2}, [r4:64]
   vst3.16 {d0, d1, d2}, [r4:128]
   vst3.16 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst3.16 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x4f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x5f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0, d1, d2}, [r4]!
   vst3.16 {d0, d1, d2}, [r4:16]!
   vst3.16 {d0, d1, d2}, [r4:32]!
   vst3.16 {d0, d1, d2}, [r4:64]!
   vst3.16 {d0, d1, d2}, [r4:128]!
   vst3.16 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst3.16 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x4d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x5d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0, d1, d2}, [r4], r6
   vst3.16 {d0, d1, d2}, [r4:16], r6
   vst3.16 {d0, d1, d2}, [r4:32], r6
   vst3.16 {d0, d1, d2}, [r4:64], r6
   vst3.16 {d0, d1, d2}, [r4:128], r6
   vst3.16 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst3.16 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x46,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0, d2, d4}, [r4]
   vst3.16 {d0, d2, d4}, [r4:16]
   vst3.16 {d0, d2, d4}, [r4:32]
   vst3.16 {d0, d2, d4}, [r4:64]
   vst3.16 {d0, d2, d4}, [r4:128]
   vst3.16 {d0, d2, d4}, [r4:256]
 
 @ CHECK: vst3.16 {d0, d2, d4}, [r4]      @ encoding: [0x04,0xf9,0x4f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d2, d4}, [r4:64]   @ encoding: [0x04,0xf9,0x5f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0, d2, d4}, [r4]!
   vst3.16 {d0, d2, d4}, [r4:16]!
   vst3.16 {d0, d2, d4}, [r4:32]!
   vst3.16 {d0, d2, d4}, [r4:64]!
   vst3.16 {d0, d2, d4}, [r4:128]!
   vst3.16 {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vst3.16 {d0, d2, d4}, [r4]!     @ encoding: [0x04,0xf9,0x4d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d2, d4}, [r4:64]!  @ encoding: [0x04,0xf9,0x5d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0, d2, d4}, [r4], r6
   vst3.16 {d0, d2, d4}, [r4:16], r6
   vst3.16 {d0, d2, d4}, [r4:32], r6
   vst3.16 {d0, d2, d4}, [r4:64], r6
   vst3.16 {d0, d2, d4}, [r4:128], r6
   vst3.16 {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vst3.16 {d0, d2, d4}, [r4], r6  @ encoding: [0x04,0xf9,0x46,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.16 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.16 {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.16 {d0[1], d1[1], d2[1]}, [r4]
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:16]
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:32]
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:64]
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:128]
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vst3.16 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0x84,0xf9,0x4f,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0[1], d1[1], d2[1]}, [r4]!
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:16]!
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:32]!
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:64]!
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:128]!
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vst3.16 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0x84,0xf9,0x4d,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0[1], d1[1], d2[1]}, [r4], r6
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:16], r6
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:32], r6
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:64], r6
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:128], r6
   vst3.16 {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vst3.16 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x46,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0[1], d2[1], d4[1]}, [r4]
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:16]
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:32]
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:64]
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:128]
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:256]
 
 @ CHECK: vst3.16 {d0[1], d2[1], d4[1]}, [r4] @ encoding: [0x84,0xf9,0x6f,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0[1], d2[1], d4[1]}, [r4]!
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:16]!
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:32]!
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:64]!
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:128]!
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:256]!
 
 @ CHECK: vst3.16 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0x84,0xf9,0x6d,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vst3.16 {d0[1], d2[1], d4[1]}, [r4], r6
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:16], r6
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:32], r6
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:64], r6
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:128], r6
   vst3.16 {d0[1], d2[1], d4[1]}, [r4:256], r6
 
 @ CHECK: vst3.16 {d0[1], d2[1], d4[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x66,0x06]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.16 {d0[1], d2[1], d4[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0, d1, d2}, [r4]
   vst3.32 {d0, d1, d2}, [r4:16]
   vst3.32 {d0, d1, d2}, [r4:32]
   vst3.32 {d0, d1, d2}, [r4:64]
   vst3.32 {d0, d1, d2}, [r4:128]
   vst3.32 {d0, d1, d2}, [r4:256]
 
 @ CHECK: vst3.32 {d0, d1, d2}, [r4]      @ encoding: [0x04,0xf9,0x8f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d1, d2}, [r4:64]   @ encoding: [0x04,0xf9,0x9f,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0, d1, d2}, [r4]!
   vst3.32 {d0, d1, d2}, [r4:16]!
   vst3.32 {d0, d1, d2}, [r4:32]!
   vst3.32 {d0, d1, d2}, [r4:64]!
   vst3.32 {d0, d1, d2}, [r4:128]!
   vst3.32 {d0, d1, d2}, [r4:256]!
 
 @ CHECK: vst3.32 {d0, d1, d2}, [r4]!     @ encoding: [0x04,0xf9,0x8d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d1, d2}, [r4:64]!  @ encoding: [0x04,0xf9,0x9d,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0, d1, d2}, [r4], r6
   vst3.32 {d0, d1, d2}, [r4:16], r6
   vst3.32 {d0, d1, d2}, [r4:32], r6
   vst3.32 {d0, d1, d2}, [r4:64], r6
   vst3.32 {d0, d1, d2}, [r4:128], r6
   vst3.32 {d0, d1, d2}, [r4:256], r6
 
 @ CHECK: vst3.32 {d0, d1, d2}, [r4], r6  @ encoding: [0x04,0xf9,0x86,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d1, d2}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x04]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d1, d2}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0, d2, d4}, [r4]
   vst3.32 {d0, d2, d4}, [r4:16]
   vst3.32 {d0, d2, d4}, [r4:32]
   vst3.32 {d0, d2, d4}, [r4:64]
   vst3.32 {d0, d2, d4}, [r4:128]
   vst3.32 {d0, d2, d4}, [r4:256]
 
 @ CHECK: vst3.32 {d0, d2, d4}, [r4]      @ encoding: [0x04,0xf9,0x8f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:16]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:32]
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d2, d4}, [r4:64]   @ encoding: [0x04,0xf9,0x9f,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:128]
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:256]
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0, d2, d4}, [r4]!
   vst3.32 {d0, d2, d4}, [r4:16]!
   vst3.32 {d0, d2, d4}, [r4:32]!
   vst3.32 {d0, d2, d4}, [r4:64]!
   vst3.32 {d0, d2, d4}, [r4:128]!
   vst3.32 {d0, d2, d4}, [r4:256]!
 
 @ CHECK: vst3.32 {d0, d2, d4}, [r4]!     @ encoding: [0x04,0xf9,0x8d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:16]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:32]!
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d2, d4}, [r4:64]!  @ encoding: [0x04,0xf9,0x9d,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:128]!
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:256]!
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0, d2, d4}, [r4], r6
   vst3.32 {d0, d2, d4}, [r4:16], r6
   vst3.32 {d0, d2, d4}, [r4:32], r6
   vst3.32 {d0, d2, d4}, [r4:64], r6
   vst3.32 {d0, d2, d4}, [r4:128], r6
   vst3.32 {d0, d2, d4}, [r4:256], r6
 
 @ CHECK: vst3.32 {d0, d2, d4}, [r4], r6  @ encoding: [0x04,0xf9,0x86,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:16], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:32], r6
 @ CHECK-ERRORS:                                   ^
 @ CHECK: vst3.32 {d0, d2, d4}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x05]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:128], r6
 @ CHECK-ERRORS:                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst3.32 {d0, d2, d4}, [r4:256], r6
 @ CHECK-ERRORS:                                   ^
 
   vst3.32 {d0[1], d1[1], d2[1]}, [r4]
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:16]
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:32]
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:64]
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:128]
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:256]
 
 @ CHECK: vst3.32 {d0[1], d1[1], d2[1]}, [r4] @ encoding: [0x84,0xf9,0x8f,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0[1], d1[1], d2[1]}, [r4]!
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:16]!
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:32]!
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:64]!
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:128]!
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:256]!
 
 @ CHECK: vst3.32 {d0[1], d1[1], d2[1]}, [r4]! @ encoding: [0x84,0xf9,0x8d,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0[1], d1[1], d2[1]}, [r4], r6
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:16], r6
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:32], r6
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:64], r6
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:128], r6
   vst3.32 {d0[1], d1[1], d2[1]}, [r4:256], r6
 
 @ CHECK: vst3.32 {d0[1], d1[1], d2[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x86,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d1[1], d2[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0[1], d2[1], d4[1]}, [r4]
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:16]
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:32]
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:64]
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:128]
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:256]
 
 @ CHECK: vst3.32 {d0[1], d2[1], d4[1]}, [r4] @ encoding: [0x84,0xf9,0xcf,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:16]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:32]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:64]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:128]
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:256]
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0[1], d2[1], d4[1]}, [r4]!
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:16]!
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:32]!
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:64]!
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:128]!
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:256]!
 
 @ CHECK: vst3.32 {d0[1], d2[1], d4[1]}, [r4]! @ encoding: [0x84,0xf9,0xcd,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:16]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:32]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:64]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:128]!
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:256]!
 @ CHECK-ERRORS:                                            ^
 
   vst3.32 {d0[1], d2[1], d4[1]}, [r4], r6
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:16], r6
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:32], r6
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:64], r6
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:128], r6
   vst3.32 {d0[1], d2[1], d4[1]}, [r4:256], r6
 
 @ CHECK: vst3.32 {d0[1], d2[1], d4[1]}, [r4], r6 @ encoding: [0x84,0xf9,0xc6,0x0a]
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                            ^
-@ CHECK-ERRORS: error: alignment must be omitted
+@ CHECK-ERRORS: alignment must be omitted
 @ CHECK-ERRORS:         vst3.32 {d0[1], d2[1], d4[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                            ^
 
   vst4.8  {d0, d1, d2, d3}, [r4]
   vst4.8  {d0, d1, d2, d3}, [r4:16]
   vst4.8  {d0, d1, d2, d3}, [r4:32]
   vst4.8  {d0, d1, d2, d3}, [r4:64]
   vst4.8  {d0, d1, d2, d3}, [r4:128]
   vst4.8  {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x0f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x1f,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0x2f,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0x3f,0x00]
 
   vst4.8  {d0, d1, d2, d3}, [r4]!
   vst4.8  {d0, d1, d2, d3}, [r4:16]!
   vst4.8  {d0, d1, d2, d3}, [r4:32]!
   vst4.8  {d0, d1, d2, d3}, [r4:64]!
   vst4.8  {d0, d1, d2, d3}, [r4:128]!
   vst4.8  {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x0d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x1d,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0x2d,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0x3d,0x00]
 
   vst4.8  {d0, d1, d2, d3}, [r4], r6
   vst4.8  {d0, d1, d2, d3}, [r4:16], r6
   vst4.8  {d0, d1, d2, d3}, [r4:32], r6
   vst4.8  {d0, d1, d2, d3}, [r4:64], r6
   vst4.8  {d0, d1, d2, d3}, [r4:128], r6
   vst4.8  {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x06,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0x26,0x00]
 @ CHECK: vst4.8 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0x36,0x00]
 
   vst4.8  {d0, d2, d4, d6}, [r4]
   vst4.8  {d0, d2, d4, d6}, [r4:16]
   vst4.8  {d0, d2, d4, d6}, [r4:32]
   vst4.8  {d0, d2, d4, d6}, [r4:64]
   vst4.8  {d0, d2, d4, d6}, [r4:128]
   vst4.8  {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4]  @ encoding: [0x04,0xf9,0x0f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x04,0xf9,0x1f,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x04,0xf9,0x2f,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x04,0xf9,0x3f,0x01]
 
   vst4.8  {d0, d2, d4, d6}, [r4]!
   vst4.8  {d0, d2, d4, d6}, [r4:16]!
   vst4.8  {d0, d2, d4, d6}, [r4:32]!
   vst4.8  {d0, d2, d4, d6}, [r4:64]!
   vst4.8  {d0, d2, d4, d6}, [r4:128]!
   vst4.8  {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4]! @ encoding: [0x04,0xf9,0x0d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x04,0xf9,0x1d,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x04,0xf9,0x2d,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x04,0xf9,0x3d,0x01]
 
   vst4.8  {d0, d2, d4, d6}, [r4], r6
   vst4.8  {d0, d2, d4, d6}, [r4:16], r6
   vst4.8  {d0, d2, d4, d6}, [r4:32], r6
   vst4.8  {d0, d2, d4, d6}, [r4:64], r6
   vst4.8  {d0, d2, d4, d6}, [r4:128], r6
   vst4.8  {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x04,0xf9,0x06,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x04,0xf9,0x16,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x04,0xf9,0x26,0x01]
 @ CHECK: vst4.8 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x04,0xf9,0x36,0x01]
 
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0x84,0xf9,0x2f,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32] @ encoding: [0x84,0xf9,0x3f,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0x84,0xf9,0x2d,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]! @ encoding: [0x84,0xf9,0x3d,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x26,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.8 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6 @ encoding: [0x84,0xf9,0x36,0x03]
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 32 or omitted
+@ CHECK-ERRORS: alignment must be 32 or omitted
 @ CHECK-ERRORS:         vst4.8  {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0, d1, d2, d3}, [r4]
   vst4.16 {d0, d1, d2, d3}, [r4:16]
   vst4.16 {d0, d1, d2, d3}, [r4:32]
   vst4.16 {d0, d1, d2, d3}, [r4:64]
   vst4.16 {d0, d1, d2, d3}, [r4:128]
   vst4.16 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x4f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x5f,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0x6f,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0x7f,0x00]
 
   vst4.16 {d0, d1, d2, d3}, [r4]!
   vst4.16 {d0, d1, d2, d3}, [r4:16]!
   vst4.16 {d0, d1, d2, d3}, [r4:32]!
   vst4.16 {d0, d1, d2, d3}, [r4:64]!
   vst4.16 {d0, d1, d2, d3}, [r4:128]!
   vst4.16 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x4d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x5d,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0x6d,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0x7d,0x00]
 
   vst4.16 {d0, d1, d2, d3}, [r4], r6
   vst4.16 {d0, d1, d2, d3}, [r4:16], r6
   vst4.16 {d0, d1, d2, d3}, [r4:32], r6
   vst4.16 {d0, d1, d2, d3}, [r4:64], r6
   vst4.16 {d0, d1, d2, d3}, [r4:128], r6
   vst4.16 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x46,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0x66,0x00]
 @ CHECK: vst4.16 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0x76,0x00]
 
   vst4.16 {d0, d2, d4, d6}, [r4]
   vst4.16 {d0, d2, d4, d6}, [r4:16]
   vst4.16 {d0, d2, d4, d6}, [r4:32]
   vst4.16 {d0, d2, d4, d6}, [r4:64]
   vst4.16 {d0, d2, d4, d6}, [r4:128]
   vst4.16 {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4]  @ encoding: [0x04,0xf9,0x4f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x04,0xf9,0x5f,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x04,0xf9,0x6f,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x04,0xf9,0x7f,0x01]
 
   vst4.16 {d0, d2, d4, d6}, [r4]!
   vst4.16 {d0, d2, d4, d6}, [r4:16]!
   vst4.16 {d0, d2, d4, d6}, [r4:32]!
   vst4.16 {d0, d2, d4, d6}, [r4:64]!
   vst4.16 {d0, d2, d4, d6}, [r4:128]!
   vst4.16 {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4]! @ encoding: [0x04,0xf9,0x4d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x04,0xf9,0x5d,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x04,0xf9,0x6d,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x04,0xf9,0x7d,0x01]
 
   vst4.16 {d0, d2, d4, d6}, [r4], r6
   vst4.16 {d0, d2, d4, d6}, [r4:16], r6
   vst4.16 {d0, d2, d4, d6}, [r4:32], r6
   vst4.16 {d0, d2, d4, d6}, [r4:64], r6
   vst4.16 {d0, d2, d4, d6}, [r4:128], r6
   vst4.16 {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x04,0xf9,0x46,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x04,0xf9,0x56,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x04,0xf9,0x66,0x01]
 @ CHECK: vst4.16 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x04,0xf9,0x76,0x01]
 
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0x84,0xf9,0x4f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64] @ encoding: [0x84,0xf9,0x5f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0x84,0xf9,0x4d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0x84,0xf9,0x5d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x46,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0x56,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4]
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 
 @ CHECK: vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4] @ encoding: [0x84,0xf9,0x6f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64] @ encoding: [0x84,0xf9,0x7f,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4]!
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]!
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0x84,0xf9,0x6d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0x84,0xf9,0x7d,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
   vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 
 @ CHECK: vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x66,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0x76,0x07]
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64 or omitted
+@ CHECK-ERRORS: alignment must be 64 or omitted
 @ CHECK-ERRORS:         vst4.16 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0, d1, d2, d3}, [r4]
   vst4.32 {d0, d1, d2, d3}, [r4:16]
   vst4.32 {d0, d1, d2, d3}, [r4:32]
   vst4.32 {d0, d1, d2, d3}, [r4:64]
   vst4.32 {d0, d1, d2, d3}, [r4:128]
   vst4.32 {d0, d1, d2, d3}, [r4:256]
 
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4]  @ encoding: [0x04,0xf9,0x8f,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:64] @ encoding: [0x04,0xf9,0x9f,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:128] @ encoding: [0x04,0xf9,0xaf,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:256] @ encoding: [0x04,0xf9,0xbf,0x00]
 
   vst4.32 {d0, d1, d2, d3}, [r4]!
   vst4.32 {d0, d1, d2, d3}, [r4:16]!
   vst4.32 {d0, d1, d2, d3}, [r4:32]!
   vst4.32 {d0, d1, d2, d3}, [r4:64]!
   vst4.32 {d0, d1, d2, d3}, [r4:128]!
   vst4.32 {d0, d1, d2, d3}, [r4:256]!
 
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4]! @ encoding: [0x04,0xf9,0x8d,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:64]! @ encoding: [0x04,0xf9,0x9d,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:128]! @ encoding: [0x04,0xf9,0xad,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:256]! @ encoding: [0x04,0xf9,0xbd,0x00]
 
   vst4.32 {d0, d1, d2, d3}, [r4], r6
   vst4.32 {d0, d1, d2, d3}, [r4:16], r6
   vst4.32 {d0, d1, d2, d3}, [r4:32], r6
   vst4.32 {d0, d1, d2, d3}, [r4:64], r6
   vst4.32 {d0, d1, d2, d3}, [r4:128], r6
   vst4.32 {d0, d1, d2, d3}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4], r6 @ encoding: [0x04,0xf9,0x86,0x00]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d1, d2, d3}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:128], r6 @ encoding: [0x04,0xf9,0xa6,0x00]
 @ CHECK: vst4.32 {d0, d1, d2, d3}, [r4:256], r6 @ encoding: [0x04,0xf9,0xb6,0x00]
 
   vst4.32 {d0, d2, d4, d6}, [r4]
   vst4.32 {d0, d2, d4, d6}, [r4:16]
   vst4.32 {d0, d2, d4, d6}, [r4:32]
   vst4.32 {d0, d2, d4, d6}, [r4:64]
   vst4.32 {d0, d2, d4, d6}, [r4:128]
   vst4.32 {d0, d2, d4, d6}, [r4:256]
 
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4]  @ encoding: [0x04,0xf9,0x8f,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:16]
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:32]
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:64] @ encoding: [0x04,0xf9,0x9f,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:128] @ encoding: [0x04,0xf9,0xaf,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:256] @ encoding: [0x04,0xf9,0xbf,0x01]
 
   vst4.32 {d0, d2, d4, d6}, [r4]!
   vst4.32 {d0, d2, d4, d6}, [r4:16]!
   vst4.32 {d0, d2, d4, d6}, [r4:32]!
   vst4.32 {d0, d2, d4, d6}, [r4:64]!
   vst4.32 {d0, d2, d4, d6}, [r4:128]!
   vst4.32 {d0, d2, d4, d6}, [r4:256]!
 
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4]! @ encoding: [0x04,0xf9,0x8d,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:16]!
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:32]!
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:64]! @ encoding: [0x04,0xf9,0x9d,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:128]! @ encoding: [0x04,0xf9,0xad,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:256]! @ encoding: [0x04,0xf9,0xbd,0x01]
 
   vst4.32 {d0, d2, d4, d6}, [r4], r6
   vst4.32 {d0, d2, d4, d6}, [r4:16], r6
   vst4.32 {d0, d2, d4, d6}, [r4:32], r6
   vst4.32 {d0, d2, d4, d6}, [r4:64], r6
   vst4.32 {d0, d2, d4, d6}, [r4:128], r6
   vst4.32 {d0, d2, d4, d6}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4], r6 @ encoding: [0x04,0xf9,0x86,0x01]
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:16], r6
 @ CHECK-ERRORS:                                       ^
-@ CHECK-ERRORS: error: alignment must be 64, 128, 256 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128, 256 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0, d2, d4, d6}, [r4:32], r6
 @ CHECK-ERRORS:                                       ^
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:64], r6 @ encoding: [0x04,0xf9,0x96,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:128], r6 @ encoding: [0x04,0xf9,0xa6,0x01]
 @ CHECK: vst4.32 {d0, d2, d4, d6}, [r4:256], r6 @ encoding: [0x04,0xf9,0xb6,0x01]
 
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4] @ encoding: [0x84,0xf9,0x8f,0x0b]
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64] @ encoding: [0x84,0xf9,0x9f,0x0b]
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128] @ encoding: [0x84,0xf9,0xaf,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0x84,0xf9,0x8d,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0x84,0xf9,0x9d,0x0b]
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]! @ encoding: [0x84,0xf9,0xad,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x86,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0x96,0x0b]
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6 @ encoding: [0x84,0xf9,0xa6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4] @ encoding: [0x84,0xf9,0xcf,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64] @ encoding: [0x84,0xf9,0xdf,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128] @ encoding: [0x84,0xf9,0xef,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]! @ encoding: [0x84,0xf9,0xcd,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]! @ encoding: [0x84,0xf9,0xdd,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]! @ encoding: [0x84,0xf9,0xed,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6 @ encoding: [0x84,0xf9,0xc6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0xd6,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6 @ encoding: [0x84,0xf9,0xe6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]!
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4]! @ encoding: [0x84,0xf9,0x8d,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64]! @ encoding: [0x84,0xf9,0x9d,0x0b]
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128]! @ encoding: [0x84,0xf9,0xad,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6
   vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4], r6 @ encoding: [0x84,0xf9,0x86,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0x96,0x0b]
 @ CHECK: vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:128], r6 @ encoding: [0x84,0xf9,0xa6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d1[1], d2[1], d3[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4] @ encoding: [0x84,0xf9,0xcf,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64] @ encoding: [0x84,0xf9,0xdf,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128] @ encoding: [0x84,0xf9,0xef,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]!
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4]! @ encoding: [0x84,0xf9,0xcd,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16]!
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32]!
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64]! @ encoding: [0x84,0xf9,0xdd,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128]! @ encoding: [0x84,0xf9,0xed,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256]!
 @ CHECK-ERRORS:                                                   ^
 
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6
   vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4], r6 @ encoding: [0x84,0xf9,0xc6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:16], r6
 @ CHECK-ERRORS:                                                   ^
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:32], r6
 @ CHECK-ERRORS:                                                   ^
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:64], r6 @ encoding: [0x84,0xf9,0xd6,0x0b]
 @ CHECK: vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:128], r6 @ encoding: [0x84,0xf9,0xe6,0x0b]
-@ CHECK-ERRORS: error: alignment must be 64, 128 or omitted
+@ CHECK-ERRORS: alignment must be 64, 128 or omitted
 @ CHECK-ERRORS:         vst4.32 {d0[1], d2[1], d4[1], d6[1]}, [r4:256], r6
 @ CHECK-ERRORS:                                                   ^

test/MC/ARM/not-armv4.s

 @ RUN: not llvm-mc < %s -triple armv4-unknown-unknown -show-encoding 2>&1 | FileCheck %s
 
 @ PR18524
-@ CHECK: error: instruction requires: armv5t
+@ CHECK: instruction requires: armv5t
 clz r4,r9
 
-@ CHECK: error: instruction requires: armv6t2
+@ CHECK: instruction requires: armv6t2
 rbit r4,r9
 
 @ CHECK: error: instruction requires: armv6t2
 movw r4,#0x1234
 @ CHECK: error: instruction requires: armv6t2
 mov  r4,#0x1234

test/MC/ARM/single-precision-fp.s

 @ CHECK-ERRORS: error: instruction requires: double precision VFP
 @ CHECK-ERRORS-NEXT: vcmpe.f64 d5, #0
 @ CHECK-ERRORS: error: instruction requires: double precision VFP
 @ CHECK-ERRORS-NEXT: vcmp.f64 d6, #0
 
         @ FIXME: overlapping aliases and a probable TableGen indeterminacy mean
         @ that the actual reason can vary by platform.
         vmov.f64 d11, d10
-@ CHECK-ERRORS: error: instruction requires:
+@ CHECK-ERRORS: instruction requires: NEON
 @ CHECK-ERRORS-NEXT: vmov.f64 d11, d10
 
         vcvt.f64.s32 d9, s8
         vcvt.f64.u32 d7, s6
         vcvt.s32.f64 s5, d4
         vcvt.u32.f64 s3, d2
         vcvtr.s32.f64 s1, d0
         vcvtr.u32.f64 s1, d2

test/MC/ARM/thumb-diagnostics.s

 @ RUN: not llvm-mc -triple=thumbv6-apple-darwin -o /dev/null < %s 2>&1 \
 @ RUN:     | FileCheck --check-prefix=CHECK-ERRORS %s
 @ RUN: not llvm-mc -triple=thumbv5-apple-darwin -o /dev/null < %s 2>&1 \
 @ RUN:     | FileCheck --check-prefix=CHECK-ERRORS-V5 %s
 @ RUN: not llvm-mc -triple=thumbv7m -o /dev/null < %s 2>&1 \
 @ RUN:     | FileCheck --check-prefix=CHECK-ERRORS-V7M %s
 @ RUN: not llvm-mc -triple=thumbv8 -o /dev/null < %s 2>&1 \
 @ RUN:     | FileCheck --check-prefix=CHECK-ERRORS-V8 %s
 
 @ Check for various assembly diagnostic messages on invalid input.
 
 @ ADD instruction w/o 'S' suffix.
         add r1, r2, r3
-@ CHECK-ERRORS: error: no flag-preserving variant of this instruction available
+@ CHECK-ERRORS: no flag-preserving variant of this instruction available
 @ CHECK-ERRORS:         add r1, r2, r3
 @ CHECK-ERRORS:         ^
 
 @ Instructions which require v6+ for both registers to be low regs.
         add r2, r3
         mov r2, r3
-@ CHECK-ERRORS: error: instruction variant requires Thumb2
+@ CHECK-ERRORS: instruction variant requires Thumb2
 @ CHECK-ERRORS:         add r2, r3
 @ CHECK-ERRORS:         ^
-@ CHECK-ERRORS-V5: error: instruction variant requires ARMv6 or later
+@ CHECK-ERRORS-V5: instruction variant requires ARMv6 or later
 @ CHECK-ERRORS-V5:         mov r2, r3
 @ CHECK-ERRORS-V5:         ^
 
 
 @ Out of range immediates for ASR instruction.
         asrs r2, r3, #33
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: invalid operand for instruction
 @ CHECK-ERRORS:         asrs r2, r3, #33
 @ CHECK-ERRORS:                      ^
 
 @ Out of range immediates for BKPT instruction.
         bkpt #256
         bkpt #-1
 error: invalid operand for instruction
         bkpt #256
              ^
 error: invalid operand for instruction
         bkpt #-1
              ^
 
 @ Out of range immediates for v8 HLT instruction.
         hlt #64
         hlt #-1
-@CHECK-ERRORS: error: instruction requires: armv8 arm-mode
+@CHECK-ERRORS: invalid instruction
 @CHECK-ERRORS:        hlt #64
 @CHECK-ERRORS:        ^
-@CHECK-ERRORS-V8: error: instruction requires: arm-mode
+@CHECK-ERRORS-V8: invalid instruction
 @CHECK-ERRORS-V8:         hlt #64
 @CHECK-ERRORS-V8:              ^
-@CHECK-ERRORS: error: invalid operand for instruction
+@CHECK-ERRORS: invalid instruction
 @CHECK-ERRORS:         hlt #-1
 @CHECK-ERRORS:              ^
 
 @ Invalid writeback and register lists for LDM
         ldm r2!, {r5, r8}
         ldm r2, {r5, r7}
         ldm r2!, {r2, r3, r4}
         ldm r2!, {r2, r3, r4, r10}
         ldmdb r2!, {r2, r3, r4}
         ldm r0, {r2, sp}
         ldmia r0, {r2-r3, sp}
         ldmia r0!, {r2-r3, sp}
         ldmfd r2, {r1, r3-r6, sp}
         ldmfd r2!, {r1, r3-r6, sp}
         ldmdb r1, {r2, r3, sp}
         ldmdb r1!, {r2, r3, sp} 
-@ CHECK-ERRORS: error: registers must be in range r0-r7
+@ CHECK-ERRORS: registers must be in range r0-r7
 @ CHECK-ERRORS:         ldm r2!, {r5, r8}
 @ CHECK-ERRORS:                  ^
-@ CHECK-ERRORS: error: writeback operator '!' expected
+@ CHECK-ERRORS: writeback operator '!' expected
 @ CHECK-ERRORS:         ldm r2, {r5, r7}
 @ CHECK-ERRORS:             ^
-@ CHECK-ERRORS: error: writeback operator '!' not allowed when base register in register list
+@ CHECK-ERRORS: writeback operator '!' not allowed when base register in register list
 @ CHECK-ERRORS:         ldm r2!, {r2, r3, r4}
 @ CHECK-ERRORS:               ^
-@ CHECK-ERRORS-V8: error: writeback operator '!' not allowed when base register in register list
+@ CHECK-ERRORS-V8: writeback operator '!' not allowed when base register in register list
 @ CHECK-ERRORS-V8:         ldm r2!, {r2, r3, r4, r10}
 @ CHECK-ERRORS-V8:               ^
-@ CHECK-ERRORS-V8: error: writeback register not allowed in register list
+@ CHECK-ERRORS-V8: writeback register not allowed in register list
 @ CHECK-ERRORS-V8:         ldmdb r2!, {r2, r3, r4}
 @ CHECK-ERRORS-V8:                 ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldm r0, {r2, sp}
 @ CHECK-ERRORS-V7M:                 ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmia r0, {r2-r3, sp}
 @ CHECK-ERRORS-V7M:                   ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmia r0!, {r2-r3, sp}
 @ CHECK-ERRORS-V7M:                    ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmfd r2, {r1, r3-r6, sp}
 @ CHECK-ERRORS-V7M:                   ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmfd r2!, {r1, r3-r6, sp}
 @ CHECK-ERRORS-V7M:                    ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmdb r1, {r2, r3, sp}
 @ CHECK-ERRORS-V7M:                   ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         ldmdb r1!, {r2, r3, sp}
 @ CHECK-ERRORS-V7M:                    ^
 
 @ Invalid writeback and register lists for PUSH/POP
         pop {r1, r2, r10}
         push {r8, r9}
-@ CHECK-ERRORS: error: registers must be in range r0-r7 or pc
+@ CHECK-ERRORS: registers must be in range r0-r7 or pc
 @ CHECK-ERRORS:         pop {r1, r2, r10}
 @ CHECK-ERRORS:             ^
-@ CHECK-ERRORS: error: registers must be in range r0-r7 or lr
+@ CHECK-ERRORS: registers must be in range r0-r7 or lr
 @ CHECK-ERRORS:         push {r8, r9}
 @ CHECK-ERRORS:              ^
 
 
 @ Invalid writeback and register lists for STM
         stm r1, {r2, r6}
         stm r1!, {r2, r9}
         stm r2!, {r2, r9}
         stmdb r2!, {r0, r2}
         stm r1!, {r2, sp}
         stmia r4!, {r0-r3, sp}
         stmdb r1, {r2, r3, sp}
         stmdb r1!, {r2, r3, sp}
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         stm r1, {r2, r6}
 @ CHECK-ERRORS:         ^
-@ CHECK-ERRORS: error: registers must be in range r0-r7
+@ CHECK-ERRORS: registers must be in range r0-r7
 @ CHECK-ERRORS:         stm r1!, {r2, r9}
 @ CHECK-ERRORS:                  ^
-@ CHECK-ERRORS-V8: error: writeback operator '!' not allowed when base register in register list
+@ CHECK-ERRORS-V8: writeback operator '!' not allowed when base register in register list
 @ CHECK-ERRORS-V8:         stm r2!, {r2, r9}
 @ CHECK-ERRORS-V8:                  ^
-@ CHECK-ERRORS-V8: error: writeback register not allowed in register list
+@ CHECK-ERRORS-V8: writeback register not allowed in register list
 @ CHECK-ERRORS-V8:         stmdb r2!, {r0, r2}
 @ CHECK-ERRORS-V8:                  ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         stm r1!, {r2, sp}
 @ CHECK-ERRORS-V7M:                  ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         stmia r4!, {r0-r3, sp}
 @ CHECK-ERRORS-V7M:                    ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         stmdb r1, {r2, r3, sp}
 @ CHECK-ERRORS-V7M:                   ^
-@ CHECK-ERRORS-V7M: error: SP may not be in the register list
+@ CHECK-ERRORS-V7M: SP may not be in the register list
 @ CHECK-ERRORS-V7M:         stmdb r1!, {r2, r3, sp}
 @ CHECK-ERRORS-V7M:                    ^
 
 @ Out of range immediates for LSL instruction.
         lsls r4, r5, #-1
         lsls r4, r5, #32
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: invalid operand for instruction
 @ CHECK-ERRORS:         lsls r4, r5, #-1
 @ CHECK-ERRORS:                      ^
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: invalid operand for instruction
 @ CHECK-ERRORS:         lsls r4, r5, #32
 @ CHECK-ERRORS:                      ^
 
 @ Mismatched source/destination operands for MUL instruction.
         muls r1, r2, r3
-@ CHECK-ERRORS: error: destination register must match source register
+@ CHECK-ERRORS: destination register must match source register
 @ CHECK-ERRORS:         muls r1, r2, r3
 @ CHECK-ERRORS:              ^
 
 
 @ Out of range immediates for STR instruction.
         str r2, [r7, #-1]
         str r5, [r1, #3]
         str r3, [r7, #128]
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         str r2, [r7, #-1]
 @ CHECK-ERRORS:         ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         str r5, [r1, #3]
 @ CHECK-ERRORS:         ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         str r3, [r7, #128]
 @ CHECK-ERRORS:         ^
 
 @ Out of range immediate for SVC instruction.
         svc #-1
         svc #256
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: invalid operand for instruction
 @ CHECK-ERRORS:         svc #-1
 @ CHECK-ERRORS:             ^
-@ CHECK-ERRORS: error: instruction requires: arm-mode
+@ CHECK-ERRORS: instruction requires: arm-mode
 @ CHECK-ERRORS:         svc #256
 @ CHECK-ERRORS:         ^
 
 
 @ Out of range immediate for ADD SP instructions
         add sp, #-1
         add sp, #3
         add sp, sp, #512
         add r2, sp, #1024
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         add sp, #-1
 @ CHECK-ERRORS:                 ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         add sp, #3
 @ CHECK-ERRORS:                 ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         add sp, sp, #512
 @ CHECK-ERRORS:                     ^
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 @ CHECK-ERRORS:         add r2, sp, #1024
 @ CHECK-ERRORS:         ^
 
         add r2, sp, ip
-@ CHECK-ERRORS: error: source register must be the same as destination
+@ CHECK-ERRORS: source register must be the same as destination
 @ CHECK-ERRORS:         add r2, sp, ip
 @ CHECK-ERRORS:                     ^
 
 
 @------------------------------------------------------------------------------
 @ B/Bcc - out of range immediates for Thumb1 branches
 @------------------------------------------------------------------------------
 
         beq    #-258
         bne    #256
         bgt    #13
         b      #-1048578
         b      #1048576
         b      #10323
 
-@ CHECK-ERRORS: error: branch target out of range
-@ CHECK-ERRORS: error: branch target out of range
-@ CHECK-ERRORS: error: branch target out of range
-@ CHECK-ERRORS: error: branch target out of range
-@ CHECK-ERRORS: error: branch target out of range
-@ CHECK-ERRORS: error: branch target out of range
+@ CHECK-ERRORS: branch target out of range
+@ CHECK-ERRORS: branch target out of range
+@ CHECK-ERRORS: branch target out of range
+@ CHECK-ERRORS: branch target out of range
+@ CHECK-ERRORS: branch target out of range
+@ CHECK-ERRORS: branch target out of range
 
 @------------------------------------------------------------------------------
 @ CBZ/CBNZ - out of range immediates for branches
 @------------------------------------------------------------------------------
 
         cbz    r0, #-2
         cbz    r0, #0
         cbz    r0, #17
         cbnz   r0, #126
         cbnz   r0, #128
 
-@ CHECK-ERRORS-V7M: error: branch target out of range
-@ CHECK-ERRORS-V7M: error: invalid operand for instruction
-@ CHECK-ERRORS-V7M: error: branch target out of range
-@ CHECK-ERRORS-V8: error: branch target out of range
-@ CHECK-ERRORS-V8: error: invalid operand for instruction
-@ CHECK-ERRORS-V8: error: branch target out of range
+@ CHECK-ERRORS-V7M: branch target out of range
+@ CHECK-ERRORS-V7M: invalid operand for instruction
+@ CHECK-ERRORS-V7M: branch target out of range
+@ CHECK-ERRORS-V8: branch target out of range
+@ CHECK-ERRORS-V8: invalid operand for instruction
+@ CHECK-ERRORS-V8: branch target out of range
 
 @------------------------------------------------------------------------------
 @ SEV/WFE/WFI/YIELD - are not supported pre v6M or v6T2
 @------------------------------------------------------------------------------
         sev
         wfe
         wfi
         yield
 
-@ CHECK-ERRORS: error: instruction requires: armv6m or armv6t2
+@ CHECK-ERRORS: instruction requires: armv6m or armv6t2
 @ CHECK-ERRORS: sev
 @ CHECK-ERRORS: ^
-@ CHECK-ERRORS: error: instruction requires: armv6m or armv6t2
+@ CHECK-ERRORS: instruction requires: armv6m or armv6t2
 @ CHECK-ERRORS: wfe
 @ CHECK-ERRORS: ^
-@ CHECK-ERRORS: error: instruction requires: armv6m or armv6t2
+@ CHECK-ERRORS: instruction requires: armv6m or armv6t2
 @ CHECK-ERRORS: wfi
 @ CHECK-ERRORS: ^
-@ CHECK-ERRORS: error: instruction requires: armv6m or armv6t2
+@ CHECK-ERRORS: instruction requires: armv6m or armv6t2
 @ CHECK-ERRORS: yield
 @ CHECK-ERRORS: ^
 
 @------------------------------------------------------------------------------
 @ PLDW required mp-extensions
 @------------------------------------------------------------------------------
         pldw [r0, #4]
-@ CHECK-ERRORS: error: instruction requires: mp-extensions
+@ CHECK-ERRORS: instruction requires: mp-extensions
 
 @------------------------------------------------------------------------------
 @ LDR(lit) - invalid offsets
 @------------------------------------------------------------------------------
 
         ldr r4, [pc, #-12]
-@ CHECK-ERRORS: error: instruction requires: thumb2
+@ CHECK-ERRORS: instruction requires: thumb2
 
 @------------------------------------------------------------------------------
 @ STC2{L}/LDC2{L} - requires thumb2
 @------------------------------------------------------------------------------
         stc2 p0, c8, [r1, #4]
         stc2l p6, c2, [r7, #4]
         ldc2 p0, c8, [r1, #4]
         ldc2l p6, c2, [r7, #4]
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: invalid instruction
+@ CHECK-ERRORS: invalid instruction
+@ CHECK-ERRORS: invalid instruction
+@ CHECK-ERRORS: invalid instruction

test/MC/ARM/thumb-mov.s

// RUN: not llvm-mc -triple=thumbv8 -show-encoding < %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-V8 %s
         // t2MOVr selected because no thumb1 movs that can access high regs
         movs pc, r0
         movs r0, pc
         movs pc, pc
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: movs pc, r0
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: movs r0, pc
-// CHECK: error: invalid operand for instruction
+// CHECK: error: invalid instruction
 // CHECK-NEXT: movs pc, pc
 
         // mov.w selects t2MOVr
         mov.w pc, r0
         mov.w r0, pc
         mov.w pc, pc
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: mov.w pc, r0
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: mov.w r0, pc
-// CHECK: error: invalid operand for instruction
+// CHECK: error: invalid instruction
 // CHECK-NEXT: mov.w pc, pc
 
         // movs.w selects t2MOVr
         movs.w pc, r0
         movs.w r0, pc
         movs.w pc, pc
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: movs.w pc, r0
 // CHECK: error: invalid operand for instruction
 // CHECK-NEXT: movs.w r0, pc
-// CHECK: error: invalid operand for instruction
+// CHECK: error: invalid instruction
 // CHECK-NEXT: movs.w pc, pc
 
 
         // Now check instructions that are invalid before ARMv8 due to SP usage
 
         movs sp, r0
         movs r0, sp
         movs sp, sp
 // CHECK-V7: error: instruction variant requires ARMv8 or later
 // CHECK-V7-NEXT: movs sp, r0
-// CHECK-V7: error: instruction variant requires ARMv8 or later
+// CHECK-V7: instruction variant requires ARMv8 or later
 // CHECK-V7-NEXT: movs r0, sp
 // 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]
 // CHECK-V8: movs.w r0, sp            @ encoding: [0x5f,0xea,0x0d,0x00]
 // 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-NEXT: mov.w sp, sp
 // CHECK-V8: mov.w sp, sp             @ encoding: [0x4f,0xea,0x0d,0x0d]
 
         movs.w sp, r0
         movs.w r0, sp
         movs.w sp, sp
 // CHECK-V7: error: instruction variant requires ARMv8 or later
 // CHECK-V7-NEXT: movs.w sp, r0
-// CHECK-V7: error: instruction variant requires ARMv8 or later
+// CHECK-V7: instruction variant requires ARMv8 or later
 // CHECK-V7-NEXT: movs.w r0, sp
 // 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]
 // CHECK-V8: movs.w r0, sp            @ encoding: [0x5f,0xea,0x0d,0x00]
 // CHECK-V8: movs.w sp, sp            @ encoding: [0x5f,0xea,0x0d,0x0d]
 
 

test/MC/ARM/thumb-not-mclass.s

 @ RUN: not llvm-mc -triple=thumbv7m-apple-darwin -show-encoding < %s 2> %t
 @ RUN: FileCheck < %t %s
 @ RUN: not llvm-mc -triple=thumbv6m -show-encoding < %s 2> %t
 @ RUN: FileCheck < %t %s
   .syntax unified
   .globl _func
 
 @ Check that the assembler rejects thumb instructions that are not valid
 @ on mclass.
 
 @------------------------------------------------------------------------------
 @ BLX (immediate)
 @------------------------------------------------------------------------------
         blx _baz
 
-@ CHECK: error: instruction requires: !armv*m
+@ CHECK: instruction requires: !armv*m
 
 @------------------------------------------------------------------------------
 @ SETEND
 @------------------------------------------------------------------------------
 
         setend be
         setend le
 
-@ CHECK: error: invalid operand for instruction
-@ CHECK: error: invalid operand for instruction
+@ CHECK: error: invalid instruction
+@ CHECK: error: invalid instruction

test/MC/ARM/thumb2-bxj-v8.s

 @ RUN: not llvm-mc -triple=thumbv6t2--none-eabi -show-encoding < %s 2>&1 | FileCheck %s --check-prefix=UNDEF
 @ RUN: not llvm-mc -triple=thumbv7a--none-eabi -show-encoding < %s 2>&1  | FileCheck %s --check-prefix=UNDEF
 @ RUN: not llvm-mc -triple=thumbv7r--none-eabi -show-encoding < %s 2>&1  | FileCheck %s --check-prefix=UNDEF
 @ RUN: not llvm-mc -triple=thumbv7m--none-eabi -show-encoding < %s 2>&1  | FileCheck %s --check-prefix=ARM_MODE
 @ RUN: llvm-mc -triple=thumbv8a--none-eabi -show-encoding < %s 2>&1  | FileCheck %s
 
 bxj r13
 
 @ CHECK: bxj  sp                      @ encoding: [0xcd,0xf3,0x00,0x8f]
 @ UNDEF:  error: r13 (SP) is an unpredictable operand to BXJ
-@ ARM_MODE: error: instruction requires: arm-mode
+@ ARM_MODE: error: instruction requires: !armv*m

test/MC/ARM/thumb2-bxj.s

 @ RUN: llvm-mc -triple=thumbv6t2--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv7a--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv7r--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: llvm-mc -triple=thumbv8a--none-eabi -show-encoding < %s | FileCheck %s
 @ RUN: not llvm-mc -triple=thumbv7m--none-eabi -show-encoding < %s 2>&1 | FileCheck %s --check-prefix=UNDEF
 
         bxj r2
 
 @ CHECK: bxj r2                      @ encoding: [0xc2,0xf3,0x00,0x8f]
-@ UNDEF: error: instruction requires: arm-mode
+@ UNDEF: error: instruction requires: !armv*m

test/MC/ARM/thumb2-diagnostics.s

@ CHECK-ERRORS:         ^
         mrc  p14, #8, r1, c1, c2, #4
         mrc  p14, #1, r1, c1, c2, #8
         mrc2  p14, #8, r1, c1, c2, #4
         mrc2  p14, #0, r1, c1, c2, #9
         mrrc  p7, #16, r5, r4, c1
         mrrc2  p7, #17, r5, r4, c1
 @ CHECK-ERRORS: error: invalid operand for instruction
 @ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V8: error: too many operands for instruction
 @ CHECK-ERRORS: error: immediate operand must be in the range [0,15]
 @ CHECK-ERRORS-V7: error: immediate operand must be in the range [0,15]
-@ CHECK-ERRORS-V8: error: invalid operand for instruction
+@ CHECK-ERRORS-V8: error: invalid instruction
 
         isb  #-1
         isb  #16
 @ CHECK-ERRORS: error: immediate value out of range
 @ CHECK-ERRORS: error: immediate value out of range
 
         itt eq
         bkpteq #1

 @ CHECK-ERRORS:                 ^
 @ CHECK-ERRORS: error: immediate expression for mov requires :lower16: or :upper16
 @ CHECK-ERRORS:                  ^
 @ CHECK-ERRORS: error: immediate expression for mov requires :lower16: or :upper16
 @ CHECK-ERRORS:                  ^
 
         and sp, r1, #80008000
         and pc, r1, #80008000
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS-V7: error: invalid instruction
+@ CHECK-ERRORS-V8: error: invalid operand for instruction
+@ CHECK-ERRORS: error: invalid instruction
 
         ssat r0, #1, r0, asr #32
         usat r0, #1, r0, asr #32
 @ CHECK-ERRORS: error: 'asr #32' shift amount not allowed in Thumb mode
 @ CHECK-ERRORS: error: 'asr #32' shift amount not allowed in Thumb mode
 
         @ PC is not valid as shifted-rGPR
         sbc.w r2, r7, pc, lsr #16
         and.w r2, r7, pc, lsr #16
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
 
 
         @ PC is not valid as base of load
         ldr r0, [pc, r0]
         ldrb r1, [pc, r2]
         ldrh r3, [pc, r3]
         pld r4, [pc, r5]
         str r6, [pc, r7]
         strb r7 [pc, r8]
         strh r9, [pc, r10]
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: invalid operand for instruction
-@ CHECK-ERRORS: error: instruction requires: arm-mode
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
+@ CHECK-ERRORS: error: invalid instruction
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
 @ CHECK-ERRORS: error: immediate value expected for vector index
-@ CHECK-ERRORS: error: instruction requires: arm-mode
+@ CHECK-ERRORS: error: invalid instruction, multiple near-miss encodings found
 
         @ SWP(B) is an ARM-only instruction
         swp  r0, r1, [r2]
         swpb r3, r4, [r5]
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
+@ CHECK-ERRORS-V7: error: instruction requires: arm-mode
+@ CHECK-ERRORS-V7: error: instruction requires: arm-mode
+@ CHECK-ERRORS-V8: error: invalid instruction
+@ CHECK-ERRORS-V8: error: invalid instruction

test/MC/ARM/thumb2-dsp-diag.s

 @ RUN: not llvm-mc -triple=thumbv7m 2>&1 < %s | FileCheck --check-prefix=CHECK-ERRORS %s
 @ RUN: llvm-mc -triple=thumbv7em -show-encoding < %s | FileCheck --check-prefix=CHECK-7EM %s
 
 sxtab r0, r0, r0
 sxtah r0, r0, r0
 sxtab16 r0, r0, r0
 sxtb16 r0, r0
 sxtb16 r0, r0, ror #8
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: invalid instruction
 @ CHECK-7EM: sxtab  r0, r0, r0              @ encoding: [0x40,0xfa,0x80,0xf0]
 @ CHECK-7EM: sxtah  r0, r0, r0              @ encoding: [0x00,0xfa,0x80,0xf0]
 @ CHECK-7EM: sxtab16  r0, r0, r0              @ encoding: [0x20,0xfa,0x80,0xf0]
 @ CHECK-7EM: sxtb16  r0, r0                  @ encoding: [0x2f,0xfa,0x80,0xf0]
 @ CHECK-7EM: sxtb16  r0, r0, ror #8          @ encoding: [0x2f,0xfa,0x90,0xf0]
 
 uxtab r0, r0, r0
 uxtah r0, r0, r0
 uxtab16 r0, r0, r0
 uxtb16 r0, r0
 uxtb16 r0, r0, ror #8
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: instruction requires: arm-mode
-@ CHECK-ERRORS: error: invalid operand for instruction
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: instruction requires: dsp
+@ CHECK-ERRORS: error: invalid instruction
 @ CHECK-7EM: uxtab  r0, r0, r0              @ encoding: [0x50,0xfa,0x80,0xf0]
 @ CHECK-7EM: uxtah  r0, r0, r0              @ encoding: [0x10,0xfa,0x80,0xf0]
 @ CHECK-7EM: uxtab16  r0, r0, r0              @ encoding: [0x30,0xfa,0x80,0xf0]
 @ CHECK-7EM: uxtb16  r0, r0                  @ encoding: [0x3f,0xfa,0x80,0xf0]
 @ CHECK-7EM: uxtb16  r0, r0, ror #8          @ encoding: [0x3f,0xfa,0x90,0xf0]

test/MC/ARM/thumbv7m.s

@------------------------------------------------------------------------------
         msr  basepri, r0
         msr  basepri_max, r0
         msr  faultmask, r0
 
 @ CHECK: msr  basepri, r0             @ encoding: [0x80,0xf3,0x11,0x88]
 @ CHECK: msr  basepri_max, r0         @ encoding: [0x80,0xf3,0x12,0x88]
 @ CHECK: msr  faultmask, r0           @ encoding: [0x80,0xf3,0x13,0x88]
 
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: mrs r0, basepri
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: mrs r0, basepri_max
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: mrs r0, faultmask
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: msr basepri, r0
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: msr basepri_max, r0
-@ CHECK-V6M: error: invalid operand for instruction
+@ CHECK-V6M: error: invalid instruction
 @ CHECK-V6M-NEXT: msr faultmask, r0
 

test/MC/ARM/thumbv8m.s

 // UNDEF-MAINLINE_DSP-NOT: error: instruction requires:
 mov.w r0, r0
 
 // Check that .arm is invalid
 // UNDEF: target does not support ARM mode
 .arm
 
 // And only +dsp has DSP and instructions
-// UNDEF-BASELINE: error: instruction requires: arm-mode
-// UNDEF-MAINLINE: error: instruction requires: arm-mode
+// UNDEF-BASELINE: error: instruction requires: dsp thumb2
+// UNDEF-MAINLINE: error: instruction requires: dsp
 // UNDEF-MAINLINE_DSP-NOT: error: instruction requires:
 qadd16 r0, r0, r0
-// UNDEF-BASELINE: error: instruction requires: arm-mode
-// UNDEF-MAINLINE: error: instruction requires: arm-mode
+// UNDEF-BASELINE: error: instruction requires: dsp thumb2
+// UNDEF-MAINLINE: error: instruction requires: dsp
 // UNDEF-MAINLINE_DSP-NOT: error: instruction requires:
 uxtab16 r0, r1, r2
 
 // Instruction availibility checks
 
 // 'Barrier instructions'
 
 // CHECK: isb sy              @ encoding: [0xbf,0xf3,0x6f,0x8f]

 // ARMv8-M Security Extensions
 
 // CHECK: sg                         @ encoding: [0x7f,0xe9,0x7f,0xe9]
 sg
 
 // CHECK: bxns r0                    @ encoding: [0x04,0x47]
 bxns r0
 
-// UNDEF-BASELINE: error: invalid operand for instruction
+// UNDEF-BASELINE: error: invalid instruction
 // UNDEF-BASELINE: error: conditional execution not supported in Thumb1
 // CHECK-MAINLINE: it eq                      @ encoding: [0x08,0xbf]
 // CHECK-MAINLINE: bxnseq r1                  @ encoding: [0x0c,0x47]
 it eq
 bxnseq r1
 
 // CHECK: bxns lr                    @ encoding: [0x74,0x47]
 bxns lr
 
 // CHECK: blxns r0                   @ encoding: [0x84,0x47]
 blxns r0
 
-// UNDEF-BASELINE: error: invalid operand for instruction
+// UNDEF-BASELINE: error: invalid instruction
 // UNDEF-BASELINE: error: conditional execution not supported in Thumb1
 // CHECK-MAINLINE: it eq                      @ encoding: [0x08,0xbf]
 // CHECK-MAINLINE: blxnseq r1                 @ encoding: [0x8c,0x47]
 it eq
 blxnseq r1
 
 // CHECK: tt r0, r1                  @ encoding: [0x41,0xe8,0x00,0xf0]
 tt r0, r1

 MRS r12, BASEPRI_MAX_NS
 // CHECK-MAINLINE: mrs r12, basepri_max_ns @ encoding: [0xef,0xf3,0x92,0x8c]
 // UNDEF-BASELINE: error: invalid operand for instruction
 MSR FAULTMASK_NS, r14
 // CHECK-MAINLINE: msr faultmask_ns, lr  @ encoding: [0x8e,0xf3,0x93,0x88]
 // UNDEF-BASELINE: error: invalid operand for instruction
 
 // Invalid operand tests
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     sg #0
 sg #0
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     sg r0
 sg r0
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     bxns r0, r1
 bxns r0, r1
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     blxns r0, #0
 blxns r0, #0
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     blxns label
 blxns label
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     tt r0, r1, r2
 tt r0, r1, r2
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     tt r0, [r1]
 tt r0, [r1]
-// UNDEF: error: invalid operand for instruction
+// UNDEF: error: too many operands for instruction
 // UNDEF:     tt r0, r1, #4
 tt r0, r1, #4
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     tt r0, #4
 tt r0, #4
 
 // Unpredictable operands
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     blxns pc
 blxns pc
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     tt sp, r0
 tt sp, r0
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     tt pc, r0
 tt pc, r0
 // UNDEF: error: invalid operand for instruction
 // UNDEF:     tt r0, pc
 tt r0, pc
 
-// UNDEF: error: invalid operand for instruction
+// UNDEF-BASELINE: error: invalid instruction
+// UNDEF-MAINLINE: error: invalid operand for instruction
 // UNDEF:     vlldm pc
 vlldm pc
 
-// UNDEF: error: invalid operand for instruction
+// UNDEF-BASELINE: error: invalid instruction
+// UNDEF-MAINLINE: error: invalid operand for instruction
 // UNDEF:     vlstm pc
 vlstm pc

test/MC/ARM/udf-thumb-2-diagnostics.s

 @ RUN: not llvm-mc -triple thumbv7-eabi -mattr +thumb2 %s 2>&1 | FileCheck %s
 
   .syntax unified
   .text
   .thumb
 
 undefined:
   udfpl
 
 @ CHECK: error: instruction 'udf' is not predicable, but condition code specified
 @ CHECK:  udfpl
 @ CHECK:  ^
 
   udf #256
 
-@ CHECK: error: instruction requires: arm-mode
+@ CHECK: error: invalid instruction, multiple near-miss encodings found
+@ CHECK: note: for one encoding: instruction requires: arm-mode
+@ CHECK: note: for one encoding: invalid operand for instruction
 @ CHECK:  udf #256
 @ CHECK:  ^
 
   udf.w #65536
 
 @ CHECK: error: invalid operand for instruction
 @ CHECK:  udf.w #65536
 @ CHECK:        ^
 

test/MC/ARM/udf-thumb-diagnostics.s

 @ RUN: not llvm-mc -triple thumbv6m-eabi %s 2>&1 | FileCheck %s
 
   .syntax unified
   .text
   .thumb
 
 undefined:
   udfpl
 
 @ CHECK: error: conditional execution not supported in Thumb1
 @ CHECK:  udfpl
 @ CHECK:  ^
 
   udf #256
 
-@ CHECK: error: instruction requires: arm-mode
+@ CHECK: error: invalid operand for instruction
 @ CHECK:  udf #256
-@ CHECK:  ^
+@ CHECK:      ^
 

test/MC/ARM/vfp4.s

 @ RUN: llvm-mc < %s -triple armv7-unknown-unknown -show-encoding -mattr=+neon,+vfp4   | FileCheck %s --check-prefix=ARM
 @ RUN: llvm-mc < %s -triple thumbv7-unknown-unknown -show-encoding -mattr=+neon,+vfp4 | FileCheck %s --check-prefix=THUMB
 @ RUN: not llvm-mc < %s -triple thumbv7-unknown-unknown -show-encoding -mcpu=cortex-m4 > %t 2> %t2
 @ RUN:     FileCheck %s < %t --check-prefix=THUMB_V7EM
 @ RUN:     FileCheck %s < %t2 --check-prefix=THUMB_V7EM-ERRORS
 
 @ ARM: vfma.f64 d16, d18, d17 @ encoding: [0xa1,0x0b,0xe2,0xee]
 @ THUMB: vfma.f64 d16, d18, d17 @ encoding: [0xe2,0xee,0xa1,0x0b]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfma.f64 d16, d18, d17
 vfma.f64 d16, d18, d17
 
 @ ARM: vfma.f32 s2, s4, s0 @ encoding: [0x00,0x1a,0xa2,0xee]
 @ THUMB: vfma.f32 s2, s4, s0 @ encoding: [0xa2,0xee,0x00,0x1a]
 @ THUMB_V7EM: vfma.f32 s2, s4, s0 @ encoding: [0xa2,0xee,0x00,0x1a]
 vfma.f32 s2, s4, s0
 
 @ ARM: vfma.f32 d16, d18, d17 @ encoding: [0xb1,0x0c,0x42,0xf2]
 @ THUMB: vfma.f32 d16, d18, d17 @ encoding: [0x42,0xef,0xb1,0x0c]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfma.f32 d16, d18, d17
 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: instruction requires: NEON
 @ THUMB_V7EM-ERRORS-NEXT: vfma.f32 q2, q4, q0
 vfma.f32 q2, q4, q0
 
 @ ARM: vfnma.f64 d16, d18, d17 @ encoding: [0xe1,0x0b,0xd2,0xee]
 @ THUMB: vfnma.f64 d16, d18, d17 @ encoding: [0xd2,0xee,0xe1,0x0b]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfnma.f64 d16, d18, d17
 vfnma.f64 d16, d18, d17
 
 @ ARM: vfnma.f32 s2, s4, s0 @ encoding: [0x40,0x1a,0x92,0xee]
 @ THUMB: vfnma.f32 s2, s4, s0 @ encoding: [0x92,0xee,0x40,0x1a]
 @ THUMB_V7EM: vfnma.f32 s2, s4, s0 @ encoding: [0x92,0xee,0x40,0x1a]
 vfnma.f32 s2, s4, s0
 
 @ ARM: vfms.f64 d16, d18, d17 @ encoding: [0xe1,0x0b,0xe2,0xee]
 @ THUMB: vfms.f64 d16, d18, d17 @ encoding: [0xe2,0xee,0xe1,0x0b]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfms.f64 d16, d18, d17
 vfms.f64 d16, d18, d17
 
 @ ARM: vfms.f32 s2, s4, s0 @ encoding: [0x40,0x1a,0xa2,0xee]
 @ THUMB: vfms.f32 s2, s4, s0 @ encoding: [0xa2,0xee,0x40,0x1a]
 @ THUMB_V7EM: vfms.f32 s2, s4, s0 @ encoding: [0xa2,0xee,0x40,0x1a]
 vfms.f32 s2, s4, s0
 
 @ ARM: vfms.f32 d16, d18, d17 @ encoding: [0xb1,0x0c,0x62,0xf2]
 @ THUMB: vfms.f32 d16, d18, d17 @ encoding: [0x62,0xef,0xb1,0x0c]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfms.f32 d16, d18, d17
 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: instruction requires: NEON
 @ THUMB_V7EM-ERRORS-NEXT: vfms.f32 q2, q4, q0
 vfms.f32 q2, q4, q0
 
 @ ARM: vfnms.f64 d16, d18, d17 @ encoding: [0xa1,0x0b,0xd2,0xee]
 @ THUMB: vfnms.f64 d16, d18, d17 @ encoding: [0xd2,0xee,0xa1,0x0b]
-@ THUMB_V7EM-ERRORS: error: invalid operand for instruction
+@ THUMB_V7EM-ERRORS: error: invalid instruction
 @ THUMB_V7EM-ERRORS-NEXT: vfnms.f64 d16, d18, d17
 vfnms.f64 d16, d18, d17
 
 @ ARM: vfnms.f32 s2, s4, s0 @ encoding: [0x00,0x1a,0x92,0xee]
 @ THUMB: vfnms.f32 s2, s4, s0 @ encoding: [0x92,0xee,0x00,0x1a]
 @ THUMB_V7EM: vfnms.f32 s2, s4, s0 @ encoding: [0x92,0xee,0x00,0x1a]
 vfnms.f32 s2, s4, s0