lib/Target/ARM/AsmParser/ARMAsmParser.cpp

   1 //===-- ARMAsmParser.cpp - Parse ARM assembly to MCInst instructions ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MCTargetDesc/ARMBaseInfo.h"
  11 #include "MCTargetDesc/ARMAddressingModes.h"
  12 #include "MCTargetDesc/ARMMCExpr.h"
  13 #include "llvm/MC/MCParser/MCAsmLexer.h"
  14 #include "llvm/MC/MCParser/MCAsmParser.h"
  15 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  16 #include "llvm/MC/MCAsmInfo.h"
  17 #include "llvm/MC/MCContext.h"
  18 #include "llvm/MC/MCStreamer.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCInstrDesc.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCTargetAsmParser.h"
  25 #include "llvm/Support/MathExtras.h"
  26 #include "llvm/Support/SourceMgr.h"
  27 #include "llvm/Support/TargetRegistry.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include "llvm/ADT/BitVector.h"
  30 #include "llvm/ADT/OwningPtr.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/ADT/SmallVector.h"
  33 #include "llvm/ADT/StringSwitch.h"
  34 #include "llvm/ADT/Twine.h"
  35
  36 using namespace llvm;
  37
  38 namespace {
  39
  40 class ARMOperand;
  41
  42 enum VectorLaneTy { NoLanes, AllLanes, IndexedLane };
  43
  44 class ARMAsmParser : public MCTargetAsmParser {
  45   MCSubtargetInfo &STI;
  46   MCAsmParser &Parser;
  47
  48   // Map of register aliases registers via the .req directive.
  49   StringMap<unsigned> RegisterReqs;
  50
  51   struct {
  52     ARMCC::CondCodes Cond;    // Condition for IT block.
  53     unsigned Mask:4;          // Condition mask for instructions.
  54                               // Starting at first 1 (from lsb).
  55                               //   '1'  condition as indicated in IT.
  56                               //   '0'  inverse of condition (else).
  57                               // Count of instructions in IT block is
  58                               // 4 - trailingzeroes(mask)
  59
  60     bool FirstCond;           // Explicit flag for when we're parsing the
  61                               // First instruction in the IT block. It's
  62                               // implied in the mask, so needs special
  63                               // handling.
  64
  65     unsigned CurPosition;     // Current position in parsing of IT
  66                               // block. In range [0,3]. Initialized
  67                               // according to count of instructions in block.
  68                               // ~0U if no active IT block.
  69   } ITState;
  70   bool inITBlock() { return ITState.CurPosition != ~0U;}
  71   void forwardITPosition() {
  72     if (!inITBlock()) return;
  73     // Move to the next instruction in the IT block, if there is one. If not,
  74     // mark the block as done.
  75     unsigned TZ = CountTrailingZeros_32(ITState.Mask);
  76     if (++ITState.CurPosition == 5 - TZ)
  77       ITState.CurPosition = ~0U; // Done with the IT block after this.
  78   }
  79
  80
  81   MCAsmParser &getParser() const { return Parser; }
  82   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  83
  84   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  85   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  86
  87   int tryParseRegister();
  88   bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
  89   int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
  90   bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
  91   bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &);
  92   bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
  93   bool parsePrefix(ARMMCExpr::VariantKind &RefKind);
  94   bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType,
  95                               unsigned &ShiftAmount);
  96   bool parseDirectiveWord(unsigned Size, SMLoc L);
  97   bool parseDirectiveThumb(SMLoc L);
  98   bool parseDirectiveARM(SMLoc L);
  99   bool parseDirectiveThumbFunc(SMLoc L);
 100   bool parseDirectiveCode(SMLoc L);
 101   bool parseDirectiveSyntax(SMLoc L);
 102   bool parseDirectiveReq(StringRef Name, SMLoc L);
 103   bool parseDirectiveUnreq(SMLoc L);
 104   bool parseDirectiveArch(SMLoc L);
 105   bool parseDirectiveEabiAttr(SMLoc L);
 106
 107   StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode,
 108                           bool &CarrySetting, unsigned &ProcessorIMod,
 109                           StringRef &ITMask);
 110   void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
 111                              bool &CanAcceptPredicationCode);
 112
 113   bool isThumb() const {
 114     // FIXME: Can tablegen auto-generate this?
 115     return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
 116   }
 117   bool isThumbOne() const {
 118     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
 119   }
 120   bool isThumbTwo() const {
 121     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2);
 122   }
 123   bool hasV6Ops() const {
 124     return STI.getFeatureBits() & ARM::HasV6Ops;
 125   }
 126   bool hasV7Ops() const {
 127     return STI.getFeatureBits() & ARM::HasV7Ops;
 128   }
 129   void SwitchMode() {
 130     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
 131     setAvailableFeatures(FB);
 132   }
 133   bool isMClass() const {
 134     return STI.getFeatureBits() & ARM::FeatureMClass;
 135   }
 136
 137   /// @name Auto-generated Match Functions
 138   /// {
 139
 140 #define GET_ASSEMBLER_HEADER
 141 #include "ARMGenAsmMatcher.inc"
 142
 143   /// }
 144
 145   OperandMatchResultTy parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*>&);
 146   OperandMatchResultTy parseCoprocNumOperand(
 147     SmallVectorImpl<MCParsedAsmOperand*>&);
 148   OperandMatchResultTy parseCoprocRegOperand(
 149     SmallVectorImpl<MCParsedAsmOperand*>&);
 150   OperandMatchResultTy parseCoprocOptionOperand(
 151     SmallVectorImpl<MCParsedAsmOperand*>&);
 152   OperandMatchResultTy parseMemBarrierOptOperand(
 153     SmallVectorImpl<MCParsedAsmOperand*>&);
 154   OperandMatchResultTy parseProcIFlagsOperand(
 155     SmallVectorImpl<MCParsedAsmOperand*>&);
 156   OperandMatchResultTy parseMSRMaskOperand(
 157     SmallVectorImpl<MCParsedAsmOperand*>&);
 158   OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O,
 159                                    StringRef Op, int Low, int High);
 160   OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 161     return parsePKHImm(O, "lsl", 0, 31);
 162   }
 163   OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 164     return parsePKHImm(O, "asr", 1, 32);
 165   }
 166   OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 167   OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 168   OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 169   OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&);
 170   OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&);
 171   OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&);
 172   OperandMatchResultTy parseFPImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 173   OperandMatchResultTy parseVectorList(SmallVectorImpl<MCParsedAsmOperand*>&);
 174   OperandMatchResultTy parseVectorLane(VectorLaneTy &LaneKind, unsigned &Index);
 175
 176   // Asm Match Converter Methods
 177   bool cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
 178                     const SmallVectorImpl<MCParsedAsmOperand*> &);
 179   bool cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
 180                     const SmallVectorImpl<MCParsedAsmOperand*> &);
 181   bool cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
 182                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 183   bool cvtStWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
 184                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 185   bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 186                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 187   bool cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 188                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 189   bool cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 190                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 191   bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 192                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 193   bool cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 194                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 195   bool cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 196                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 197   bool cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 198                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 199   bool cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 200                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 201   bool cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 202                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 203   bool cvtLdrdPre(MCInst &Inst, unsigned Opcode,
 204                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 205   bool cvtStrdPre(MCInst &Inst, unsigned Opcode,
 206                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 207   bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 208                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 209   bool cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
 210                         const SmallVectorImpl<MCParsedAsmOperand*> &);
 211   bool cvtVLDwbFixed(MCInst &Inst, unsigned Opcode,
 212                      const SmallVectorImpl<MCParsedAsmOperand*> &);
 213   bool cvtVLDwbRegister(MCInst &Inst, unsigned Opcode,
 214                         const SmallVectorImpl<MCParsedAsmOperand*> &);
 215   bool cvtVSTwbFixed(MCInst &Inst, unsigned Opcode,
 216                      const SmallVectorImpl<MCParsedAsmOperand*> &);
 217   bool cvtVSTwbRegister(MCInst &Inst, unsigned Opcode,
 218                         const SmallVectorImpl<MCParsedAsmOperand*> &);
 219
 220   bool validateInstruction(MCInst &Inst,
 221                            const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 222   bool processInstruction(MCInst &Inst,
 223                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 224   bool shouldOmitCCOutOperand(StringRef Mnemonic,
 225                               SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 226
 227 public:
 228   enum ARMMatchResultTy {
 229     Match_RequiresITBlock = FIRST_TARGET_MATCH_RESULT_TY,
 230     Match_RequiresNotITBlock,
 231     Match_RequiresV6,
 232     Match_RequiresThumb2
 233   };
 234
 235   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
 236     : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
 237     MCAsmParserExtension::Initialize(_Parser);
 238
 239     // Initialize the set of available features.
 240     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 241
 242     // Not in an ITBlock to start with.
 243     ITState.CurPosition = ~0U;
 244   }
 245
 246   // Implementation of the MCTargetAsmParser interface:
 247   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
 248   bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 249                         SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 250   bool ParseDirective(AsmToken DirectiveID);
 251
 252   unsigned checkTargetMatchPredicate(MCInst &Inst);
 253
 254   bool MatchAndEmitInstruction(SMLoc IDLoc,
 255                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 256                                MCStreamer &Out);
 257 };
 258 } // end anonymous namespace
 259
 260 namespace {
 261
 262 /// ARMOperand - Instances of this class represent a parsed ARM machine
 263 /// instruction.
 264 class ARMOperand : public MCParsedAsmOperand {
 265   enum KindTy {
 266     k_CondCode,
 267     k_CCOut,
 268     k_ITCondMask,
 269     k_CoprocNum,
 270     k_CoprocReg,
 271     k_CoprocOption,
 272     k_Immediate,
 273     k_MemBarrierOpt,
 274     k_Memory,
 275     k_PostIndexRegister,
 276     k_MSRMask,
 277     k_ProcIFlags,
 278     k_VectorIndex,
 279     k_Register,
 280     k_RegisterList,
 281     k_DPRRegisterList,
 282     k_SPRRegisterList,
 283     k_VectorList,
 284     k_VectorListAllLanes,
 285     k_VectorListIndexed,
 286     k_ShiftedRegister,
 287     k_ShiftedImmediate,
 288     k_ShifterImmediate,
 289     k_RotateImmediate,
 290     k_BitfieldDescriptor,
 291     k_Token
 292   } Kind;
 293
 294   SMLoc StartLoc, EndLoc;
 295   SmallVector<unsigned, 8> Registers;
 296
 297   union {
 298     struct {
 299       ARMCC::CondCodes Val;
 300     } CC;
 301
 302     struct {
 303       unsigned Val;
 304     } Cop;
 305
 306     struct {
 307       unsigned Val;
 308     } CoprocOption;
 309
 310     struct {
 311       unsigned Mask:4;
 312     } ITMask;
 313
 314     struct {
 315       ARM_MB::MemBOpt Val;
 316     } MBOpt;
 317
 318     struct {
 319       ARM_PROC::IFlags Val;
 320     } IFlags;
 321
 322     struct {
 323       unsigned Val;
 324     } MMask;
 325
 326     struct {
 327       const char *Data;
 328       unsigned Length;
 329     } Tok;
 330
 331     struct {
 332       unsigned RegNum;
 333     } Reg;
 334
 335     // A vector register list is a sequential list of 1 to 4 registers.
 336     struct {
 337       unsigned RegNum;
 338       unsigned Count;
 339       unsigned LaneIndex;
 340       bool isDoubleSpaced;
 341     } VectorList;
 342
 343     struct {
 344       unsigned Val;
 345     } VectorIndex;
 346
 347     struct {
 348       const MCExpr *Val;
 349     } Imm;
 350
 351     /// Combined record for all forms of ARM address expressions.
 352     struct {
 353       unsigned BaseRegNum;
 354       // Offset is in OffsetReg or OffsetImm. If both are zero, no offset
 355       // was specified.
 356       const MCConstantExpr *OffsetImm;  // Offset immediate value
 357       unsigned OffsetRegNum;    // Offset register num, when OffsetImm == NULL
 358       ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg
 359       unsigned ShiftImm;        // shift for OffsetReg.
 360       unsigned Alignment;       // 0 = no alignment specified
 361                                 // n = alignment in bytes (2, 4, 8, 16, or 32)
 362       unsigned isNegative : 1;  // Negated OffsetReg? (~'U' bit)
 363     } Memory;
 364
 365     struct {
 366       unsigned RegNum;
 367       bool isAdd;
 368       ARM_AM::ShiftOpc ShiftTy;
 369       unsigned ShiftImm;
 370     } PostIdxReg;
 371
 372     struct {
 373       bool isASR;
 374       unsigned Imm;
 375     } ShifterImm;
 376     struct {
 377       ARM_AM::ShiftOpc ShiftTy;
 378       unsigned SrcReg;
 379       unsigned ShiftReg;
 380       unsigned ShiftImm;
 381     } RegShiftedReg;
 382     struct {
 383       ARM_AM::ShiftOpc ShiftTy;
 384       unsigned SrcReg;
 385       unsigned ShiftImm;
 386     } RegShiftedImm;
 387     struct {
 388       unsigned Imm;
 389     } RotImm;
 390     struct {
 391       unsigned LSB;
 392       unsigned Width;
 393     } Bitfield;
 394   };
 395
 396   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 397 public:
 398   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 399     Kind = o.Kind;
 400     StartLoc = o.StartLoc;
 401     EndLoc = o.EndLoc;
 402     switch (Kind) {
 403     case k_CondCode:
 404       CC = o.CC;
 405       break;
 406     case k_ITCondMask:
 407       ITMask = o.ITMask;
 408       break;
 409     case k_Token:
 410       Tok = o.Tok;
 411       break;
 412     case k_CCOut:
 413     case k_Register:
 414       Reg = o.Reg;
 415       break;
 416     case k_RegisterList:
 417     case k_DPRRegisterList:
 418     case k_SPRRegisterList:
 419       Registers = o.Registers;
 420       break;
 421     case k_VectorList:
 422     case k_VectorListAllLanes:
 423     case k_VectorListIndexed:
 424       VectorList = o.VectorList;
 425       break;
 426     case k_CoprocNum:
 427     case k_CoprocReg:
 428       Cop = o.Cop;
 429       break;
 430     case k_CoprocOption:
 431       CoprocOption = o.CoprocOption;
 432       break;
 433     case k_Immediate:
 434       Imm = o.Imm;
 435       break;
 436     case k_MemBarrierOpt:
 437       MBOpt = o.MBOpt;
 438       break;
 439     case k_Memory:
 440       Memory = o.Memory;
 441       break;
 442     case k_PostIndexRegister:
 443       PostIdxReg = o.PostIdxReg;
 444       break;
 445     case k_MSRMask:
 446       MMask = o.MMask;
 447       break;
 448     case k_ProcIFlags:
 449       IFlags = o.IFlags;
 450       break;
 451     case k_ShifterImmediate:
 452       ShifterImm = o.ShifterImm;
 453       break;
 454     case k_ShiftedRegister:
 455       RegShiftedReg = o.RegShiftedReg;
 456       break;
 457     case k_ShiftedImmediate:
 458       RegShiftedImm = o.RegShiftedImm;
 459       break;
 460     case k_RotateImmediate:
 461       RotImm = o.RotImm;
 462       break;
 463     case k_BitfieldDescriptor:
 464       Bitfield = o.Bitfield;
 465       break;
 466     case k_VectorIndex:
 467       VectorIndex = o.VectorIndex;
 468       break;
 469     }
 470   }
 471
 472   /// getStartLoc - Get the location of the first token of this operand.
 473   SMLoc getStartLoc() const { return StartLoc; }
 474   /// getEndLoc - Get the location of the last token of this operand.
 475   SMLoc getEndLoc() const { return EndLoc; }
 476
 477   ARMCC::CondCodes getCondCode() const {
 478     assert(Kind == k_CondCode && "Invalid access!");
 479     return CC.Val;
 480   }
 481
 482   unsigned getCoproc() const {
 483     assert((Kind == k_CoprocNum || Kind == k_CoprocReg) && "Invalid access!");
 484     return Cop.Val;
 485   }
 486
 487   StringRef getToken() const {
 488     assert(Kind == k_Token && "Invalid access!");
 489     return StringRef(Tok.Data, Tok.Length);
 490   }
 491
 492   unsigned getReg() const {
 493     assert((Kind == k_Register || Kind == k_CCOut) && "Invalid access!");
 494     return Reg.RegNum;
 495   }
 496
 497   const SmallVectorImpl<unsigned> &getRegList() const {
 498     assert((Kind == k_RegisterList || Kind == k_DPRRegisterList ||
 499             Kind == k_SPRRegisterList) && "Invalid access!");
 500     return Registers;
 501   }
 502
 503   const MCExpr *getImm() const {
 504     assert(isImm() && "Invalid access!");
 505     return Imm.Val;
 506   }
 507
 508   unsigned getVectorIndex() const {
 509     assert(Kind == k_VectorIndex && "Invalid access!");
 510     return VectorIndex.Val;
 511   }
 512
 513   ARM_MB::MemBOpt getMemBarrierOpt() const {
 514     assert(Kind == k_MemBarrierOpt && "Invalid access!");
 515     return MBOpt.Val;
 516   }
 517
 518   ARM_PROC::IFlags getProcIFlags() const {
 519     assert(Kind == k_ProcIFlags && "Invalid access!");
 520     return IFlags.Val;
 521   }
 522
 523   unsigned getMSRMask() const {
 524     assert(Kind == k_MSRMask && "Invalid access!");
 525     return MMask.Val;
 526   }
 527
 528   bool isCoprocNum() const { return Kind == k_CoprocNum; }
 529   bool isCoprocReg() const { return Kind == k_CoprocReg; }
 530   bool isCoprocOption() const { return Kind == k_CoprocOption; }
 531   bool isCondCode() const { return Kind == k_CondCode; }
 532   bool isCCOut() const { return Kind == k_CCOut; }
 533   bool isITMask() const { return Kind == k_ITCondMask; }
 534   bool isITCondCode() const { return Kind == k_CondCode; }
 535   bool isImm() const { return Kind == k_Immediate; }
 536   bool isFPImm() const {
 537     if (!isImm()) return false;
 538     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 539     if (!CE) return false;
 540     int Val = ARM_AM::getFP32Imm(APInt(32, CE->getValue()));
 541     return Val != -1;
 542   }
 543   bool isFBits16() const {
 544     if (!isImm()) return false;
 545     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 546     if (!CE) return false;
 547     int64_t Value = CE->getValue();
 548     return Value >= 0 && Value <= 16;
 549   }
 550   bool isFBits32() const {
 551     if (!isImm()) return false;
 552     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 553     if (!CE) return false;
 554     int64_t Value = CE->getValue();
 555     return Value >= 1 && Value <= 32;
 556   }
 557   bool isImm8s4() const {
 558     if (!isImm()) return false;
 559     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 560     if (!CE) return false;
 561     int64_t Value = CE->getValue();
 562     return ((Value & 3) == 0) && Value >= -1020 && Value <= 1020;
 563   }
 564   bool isImm0_1020s4() const {
 565     if (!isImm()) return false;
 566     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 567     if (!CE) return false;
 568     int64_t Value = CE->getValue();
 569     return ((Value & 3) == 0) && Value >= 0 && Value <= 1020;
 570   }
 571   bool isImm0_508s4() const {
 572     if (!isImm()) return false;
 573     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 574     if (!CE) return false;
 575     int64_t Value = CE->getValue();
 576     return ((Value & 3) == 0) && Value >= 0 && Value <= 508;
 577   }
 578   bool isImm0_255() const {
 579     if (!isImm()) return false;
 580     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 581     if (!CE) return false;
 582     int64_t Value = CE->getValue();
 583     return Value >= 0 && Value < 256;
 584   }
 585   bool isImm0_1() const {
 586     if (!isImm()) return false;
 587     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 588     if (!CE) return false;
 589     int64_t Value = CE->getValue();
 590     return Value >= 0 && Value < 2;
 591   }
 592   bool isImm0_3() const {
 593     if (!isImm()) return false;
 594     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 595     if (!CE) return false;
 596     int64_t Value = CE->getValue();
 597     return Value >= 0 && Value < 4;
 598   }
 599   bool isImm0_7() const {
 600     if (!isImm()) return false;
 601     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 602     if (!CE) return false;
 603     int64_t Value = CE->getValue();
 604     return Value >= 0 && Value < 8;
 605   }
 606   bool isImm0_15() const {
 607     if (!isImm()) return false;
 608     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 609     if (!CE) return false;
 610     int64_t Value = CE->getValue();
 611     return Value >= 0 && Value < 16;
 612   }
 613   bool isImm0_31() const {
 614     if (!isImm()) return false;
 615     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 616     if (!CE) return false;
 617     int64_t Value = CE->getValue();
 618     return Value >= 0 && Value < 32;
 619   }
 620   bool isImm0_63() const {
 621     if (!isImm()) return false;
 622     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 623     if (!CE) return false;
 624     int64_t Value = CE->getValue();
 625     return Value >= 0 && Value < 64;
 626   }
 627   bool isImm8() const {
 628     if (!isImm()) return false;
 629     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 630     if (!CE) return false;
 631     int64_t Value = CE->getValue();
 632     return Value == 8;
 633   }
 634   bool isImm16() const {
 635     if (!isImm()) return false;
 636     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 637     if (!CE) return false;
 638     int64_t Value = CE->getValue();
 639     return Value == 16;
 640   }
 641   bool isImm32() const {
 642     if (!isImm()) return false;
 643     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 644     if (!CE) return false;
 645     int64_t Value = CE->getValue();
 646     return Value == 32;
 647   }
 648   bool isShrImm8() const {
 649     if (!isImm()) return false;
 650     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 651     if (!CE) return false;
 652     int64_t Value = CE->getValue();
 653     return Value > 0 && Value <= 8;
 654   }
 655   bool isShrImm16() const {
 656     if (!isImm()) return false;
 657     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 658     if (!CE) return false;
 659     int64_t Value = CE->getValue();
 660     return Value > 0 && Value <= 16;
 661   }
 662   bool isShrImm32() const {
 663     if (!isImm()) return false;
 664     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 665     if (!CE) return false;
 666     int64_t Value = CE->getValue();
 667     return Value > 0 && Value <= 32;
 668   }
 669   bool isShrImm64() const {
 670     if (!isImm()) return false;
 671     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 672     if (!CE) return false;
 673     int64_t Value = CE->getValue();
 674     return Value > 0 && Value <= 64;
 675   }
 676   bool isImm1_7() const {
 677     if (!isImm()) return false;
 678     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 679     if (!CE) return false;
 680     int64_t Value = CE->getValue();
 681     return Value > 0 && Value < 8;
 682   }
 683   bool isImm1_15() const {
 684     if (!isImm()) return false;
 685     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 686     if (!CE) return false;
 687     int64_t Value = CE->getValue();
 688     return Value > 0 && Value < 16;
 689   }
 690   bool isImm1_31() const {
 691     if (!isImm()) return false;
 692     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 693     if (!CE) return false;
 694     int64_t Value = CE->getValue();
 695     return Value > 0 && Value < 32;
 696   }
 697   bool isImm1_16() const {
 698     if (!isImm()) return false;
 699     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 700     if (!CE) return false;
 701     int64_t Value = CE->getValue();
 702     return Value > 0 && Value < 17;
 703   }
 704   bool isImm1_32() const {
 705     if (!isImm()) return false;
 706     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 707     if (!CE) return false;
 708     int64_t Value = CE->getValue();
 709     return Value > 0 && Value < 33;
 710   }
 711   bool isImm0_32() const {
 712     if (!isImm()) return false;
 713     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 714     if (!CE) return false;
 715     int64_t Value = CE->getValue();
 716     return Value >= 0 && Value < 33;
 717   }
 718   bool isImm0_65535() const {
 719     if (!isImm()) return false;
 720     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 721     if (!CE) return false;
 722     int64_t Value = CE->getValue();
 723     return Value >= 0 && Value < 65536;
 724   }
 725   bool isImm0_65535Expr() const {
 726     if (!isImm()) return false;
 727     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 728     // If it's not a constant expression, it'll generate a fixup and be
 729     // handled later.
 730     if (!CE) return true;
 731     int64_t Value = CE->getValue();
 732     return Value >= 0 && Value < 65536;
 733   }
 734   bool isImm24bit() const {
 735     if (!isImm()) return false;
 736     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 737     if (!CE) return false;
 738     int64_t Value = CE->getValue();
 739     return Value >= 0 && Value <= 0xffffff;
 740   }
 741   bool isImmThumbSR() const {
 742     if (!isImm()) return false;
 743     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 744     if (!CE) return false;
 745     int64_t Value = CE->getValue();
 746     return Value > 0 && Value < 33;
 747   }
 748   bool isPKHLSLImm() const {
 749     if (!isImm()) return false;
 750     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 751     if (!CE) return false;
 752     int64_t Value = CE->getValue();
 753     return Value >= 0 && Value < 32;
 754   }
 755   bool isPKHASRImm() const {
 756     if (!isImm()) return false;
 757     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 758     if (!CE) return false;
 759     int64_t Value = CE->getValue();
 760     return Value > 0 && Value <= 32;
 761   }
 762   bool isARMSOImm() const {
 763     if (!isImm()) return false;
 764     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 765     if (!CE) return false;
 766     int64_t Value = CE->getValue();
 767     return ARM_AM::getSOImmVal(Value) != -1;
 768   }
 769   bool isARMSOImmNot() const {
 770     if (!isImm()) return false;
 771     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 772     if (!CE) return false;
 773     int64_t Value = CE->getValue();
 774     return ARM_AM::getSOImmVal(~Value) != -1;
 775   }
 776   bool isARMSOImmNeg() const {
 777     if (!isImm()) return false;
 778     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 779     if (!CE) return false;
 780     int64_t Value = CE->getValue();
 781     return ARM_AM::getSOImmVal(-Value) != -1;
 782   }
 783   bool isT2SOImm() const {
 784     if (!isImm()) return false;
 785     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 786     if (!CE) return false;
 787     int64_t Value = CE->getValue();
 788     return ARM_AM::getT2SOImmVal(Value) != -1;
 789   }
 790   bool isT2SOImmNot() const {
 791     if (!isImm()) return false;
 792     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 793     if (!CE) return false;
 794     int64_t Value = CE->getValue();
 795     return ARM_AM::getT2SOImmVal(~Value) != -1;
 796   }
 797   bool isT2SOImmNeg() const {
 798     if (!isImm()) return false;
 799     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 800     if (!CE) return false;
 801     int64_t Value = CE->getValue();
 802     return ARM_AM::getT2SOImmVal(-Value) != -1;
 803   }
 804   bool isSetEndImm() const {
 805     if (!isImm()) return false;
 806     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 807     if (!CE) return false;
 808     int64_t Value = CE->getValue();
 809     return Value == 1 || Value == 0;
 810   }
 811   bool isReg() const { return Kind == k_Register; }
 812   bool isRegList() const { return Kind == k_RegisterList; }
 813   bool isDPRRegList() const { return Kind == k_DPRRegisterList; }
 814   bool isSPRRegList() const { return Kind == k_SPRRegisterList; }
 815   bool isToken() const { return Kind == k_Token; }
 816   bool isMemBarrierOpt() const { return Kind == k_MemBarrierOpt; }
 817   bool isMemory() const { return Kind == k_Memory; }
 818   bool isShifterImm() const { return Kind == k_ShifterImmediate; }
 819   bool isRegShiftedReg() const { return Kind == k_ShiftedRegister; }
 820   bool isRegShiftedImm() const { return Kind == k_ShiftedImmediate; }
 821   bool isRotImm() const { return Kind == k_RotateImmediate; }
 822   bool isBitfield() const { return Kind == k_BitfieldDescriptor; }
 823   bool isPostIdxRegShifted() const { return Kind == k_PostIndexRegister; }
 824   bool isPostIdxReg() const {
 825     return Kind == k_PostIndexRegister && PostIdxReg.ShiftTy ==ARM_AM::no_shift;
 826   }
 827   bool isMemNoOffset(bool alignOK = false) const {
 828     if (!isMemory())
 829       return false;
 830     // No offset of any kind.
 831     return Memory.OffsetRegNum == 0 && Memory.OffsetImm == 0 &&
 832      (alignOK || Memory.Alignment == 0);
 833   }
 834   bool isMemPCRelImm12() const {
 835     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
 836       return false;
 837     // Base register must be PC.
 838     if (Memory.BaseRegNum != ARM::PC)
 839       return false;
 840     // Immediate offset in range [-4095, 4095].
 841     if (!Memory.OffsetImm) return true;
 842     int64_t Val = Memory.OffsetImm->getValue();
 843     return (Val > -4096 && Val < 4096) || (Val == INT32_MIN);
 844   }
 845   bool isAlignedMemory() const {
 846     return isMemNoOffset(true);
 847   }
 848   bool isAddrMode2() const {
 849     if (!isMemory() || Memory.Alignment != 0) return false;
 850     // Check for register offset.
 851     if (Memory.OffsetRegNum) return true;
 852     // Immediate offset in range [-4095, 4095].
 853     if (!Memory.OffsetImm) return true;
 854     int64_t Val = Memory.OffsetImm->getValue();
 855     return Val > -4096 && Val < 4096;
 856   }
 857   bool isAM2OffsetImm() const {
 858     if (!isImm()) return false;
 859     // Immediate offset in range [-4095, 4095].
 860     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 861     if (!CE) return false;
 862     int64_t Val = CE->getValue();
 863     return Val > -4096 && Val < 4096;
 864   }
 865   bool isAddrMode3() const {
 866     // If we have an immediate that's not a constant, treat it as a label
 867     // reference needing a fixup. If it is a constant, it's something else
 868     // and we reject it.
 869     if (isImm() && !isa<MCConstantExpr>(getImm()))
 870       return true;
 871     if (!isMemory() || Memory.Alignment != 0) return false;
 872     // No shifts are legal for AM3.
 873     if (Memory.ShiftType != ARM_AM::no_shift) return false;
 874     // Check for register offset.
 875     if (Memory.OffsetRegNum) return true;
 876     // Immediate offset in range [-255, 255].
 877     if (!Memory.OffsetImm) return true;
 878     int64_t Val = Memory.OffsetImm->getValue();
 879     return Val > -256 && Val < 256;
 880   }
 881   bool isAM3Offset() const {
 882     if (Kind != k_Immediate && Kind != k_PostIndexRegister)
 883       return false;
 884     if (Kind == k_PostIndexRegister)
 885       return PostIdxReg.ShiftTy == ARM_AM::no_shift;
 886     // Immediate offset in range [-255, 255].
 887     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 888     if (!CE) return false;
 889     int64_t Val = CE->getValue();
 890     // Special case, #-0 is INT32_MIN.
 891     return (Val > -256 && Val < 256) || Val == INT32_MIN;
 892   }
 893   bool isAddrMode5() const {
 894     // If we have an immediate that's not a constant, treat it as a label
 895     // reference needing a fixup. If it is a constant, it's something else
 896     // and we reject it.
 897     if (isImm() && !isa<MCConstantExpr>(getImm()))
 898       return true;
 899     if (!isMemory() || Memory.Alignment != 0) return false;
 900     // Check for register offset.
 901     if (Memory.OffsetRegNum) return false;
 902     // Immediate offset in range [-1020, 1020] and a multiple of 4.
 903     if (!Memory.OffsetImm) return true;
 904     int64_t Val = Memory.OffsetImm->getValue();
 905     return (Val >= -1020 && Val <= 1020 && ((Val & 3) == 0)) ||
 906       Val == INT32_MIN;
 907   }
 908   bool isMemTBB() const {
 909     if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
 910         Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0)
 911       return false;
 912     return true;
 913   }
 914   bool isMemTBH() const {
 915     if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
 916         Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm != 1 ||
 917         Memory.Alignment != 0 )
 918       return false;
 919     return true;
 920   }
 921   bool isMemRegOffset() const {
 922     if (!isMemory() || !Memory.OffsetRegNum || Memory.Alignment != 0)
 923       return false;
 924     return true;
 925   }
 926   bool isT2MemRegOffset() const {
 927     if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
 928         Memory.Alignment != 0)
 929       return false;
 930     // Only lsl #{0, 1, 2, 3} allowed.
 931     if (Memory.ShiftType == ARM_AM::no_shift)
 932       return true;
 933     if (Memory.ShiftType != ARM_AM::lsl || Memory.ShiftImm > 3)
 934       return false;
 935     return true;
 936   }
 937   bool isMemThumbRR() const {
 938     // Thumb reg+reg addressing is simple. Just two registers, a base and
 939     // an offset. No shifts, negations or any other complicating factors.
 940     if (!isMemory() || !Memory.OffsetRegNum || Memory.isNegative ||
 941         Memory.ShiftType != ARM_AM::no_shift || Memory.Alignment != 0)
 942       return false;
 943     return isARMLowRegister(Memory.BaseRegNum) &&
 944       (!Memory.OffsetRegNum || isARMLowRegister(Memory.OffsetRegNum));
 945   }
 946   bool isMemThumbRIs4() const {
 947     if (!isMemory() || Memory.OffsetRegNum != 0 ||
 948         !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
 949       return false;
 950     // Immediate offset, multiple of 4 in range [0, 124].
 951     if (!Memory.OffsetImm) return true;
 952     int64_t Val = Memory.OffsetImm->getValue();
 953     return Val >= 0 && Val <= 124 && (Val % 4) == 0;
 954   }
 955   bool isMemThumbRIs2() const {
 956     if (!isMemory() || Memory.OffsetRegNum != 0 ||
 957         !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
 958       return false;
 959     // Immediate offset, multiple of 4 in range [0, 62].
 960     if (!Memory.OffsetImm) return true;
 961     int64_t Val = Memory.OffsetImm->getValue();
 962     return Val >= 0 && Val <= 62 && (Val % 2) == 0;
 963   }
 964   bool isMemThumbRIs1() const {
 965     if (!isMemory() || Memory.OffsetRegNum != 0 ||
 966         !isARMLowRegister(Memory.BaseRegNum) || Memory.Alignment != 0)
 967       return false;
 968     // Immediate offset in range [0, 31].
 969     if (!Memory.OffsetImm) return true;
 970     int64_t Val = Memory.OffsetImm->getValue();
 971     return Val >= 0 && Val <= 31;
 972   }
 973   bool isMemThumbSPI() const {
 974     if (!isMemory() || Memory.OffsetRegNum != 0 ||
 975         Memory.BaseRegNum != ARM::SP || Memory.Alignment != 0)
 976       return false;
 977     // Immediate offset, multiple of 4 in range [0, 1020].
 978     if (!Memory.OffsetImm) return true;
 979     int64_t Val = Memory.OffsetImm->getValue();
 980     return Val >= 0 && Val <= 1020 && (Val % 4) == 0;
 981   }
 982   bool isMemImm8s4Offset() const {
 983     // If we have an immediate that's not a constant, treat it as a label
 984     // reference needing a fixup. If it is a constant, it's something else
 985     // and we reject it.
 986     if (isImm() && !isa<MCConstantExpr>(getImm()))
 987       return true;
 988     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
 989       return false;
 990     // Immediate offset a multiple of 4 in range [-1020, 1020].
 991     if (!Memory.OffsetImm) return true;
 992     int64_t Val = Memory.OffsetImm->getValue();
 993     return Val >= -1020 && Val <= 1020 && (Val & 3) == 0;
 994   }
 995   bool isMemImm0_1020s4Offset() const {
 996     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
 997       return false;
 998     // Immediate offset a multiple of 4 in range [0, 1020].
 999     if (!Memory.OffsetImm) return true;
1000     int64_t Val = Memory.OffsetImm->getValue();
1001     return Val >= 0 && Val <= 1020 && (Val & 3) == 0;
1002   }
1003   bool isMemImm8Offset() const {
1004     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
1005       return false;
1006     // Base reg of PC isn't allowed for these encodings.
1007     if (Memory.BaseRegNum == ARM::PC) return false;
1008     // Immediate offset in range [-255, 255].
1009     if (!Memory.OffsetImm) return true;
1010     int64_t Val = Memory.OffsetImm->getValue();
1011     return (Val == INT32_MIN) || (Val > -256 && Val < 256);
1012   }
1013   bool isMemPosImm8Offset() const {
1014     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
1015       return false;
1016     // Immediate offset in range [0, 255].
1017     if (!Memory.OffsetImm) return true;
1018     int64_t Val = Memory.OffsetImm->getValue();
1019     return Val >= 0 && Val < 256;
1020   }
1021   bool isMemNegImm8Offset() const {
1022     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
1023       return false;
1024     // Base reg of PC isn't allowed for these encodings.
1025     if (Memory.BaseRegNum == ARM::PC) return false;
1026     // Immediate offset in range [-255, -1].
1027     if (!Memory.OffsetImm) return false;
1028     int64_t Val = Memory.OffsetImm->getValue();
1029     return (Val == INT32_MIN) || (Val > -256 && Val < 0);
1030   }
1031   bool isMemUImm12Offset() const {
1032     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
1033       return false;
1034     // Immediate offset in range [0, 4095].
1035     if (!Memory.OffsetImm) return true;
1036     int64_t Val = Memory.OffsetImm->getValue();
1037     return (Val >= 0 && Val < 4096);
1038   }
1039   bool isMemImm12Offset() const {
1040     // If we have an immediate that's not a constant, treat it as a label
1041     // reference needing a fixup. If it is a constant, it's something else
1042     // and we reject it.
1043     if (isImm() && !isa<MCConstantExpr>(getImm()))
1044       return true;
1045
1046     if (!isMemory() || Memory.OffsetRegNum != 0 || Memory.Alignment != 0)
1047       return false;
1048     // Immediate offset in range [-4095, 4095].
1049     if (!Memory.OffsetImm) return true;
1050     int64_t Val = Memory.OffsetImm->getValue();
1051     return (Val > -4096 && Val < 4096) || (Val == INT32_MIN);
1052   }
1053   bool isPostIdxImm8() const {
1054     if (!isImm()) return false;
1055     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1056     if (!CE) return false;
1057     int64_t Val = CE->getValue();
1058     return (Val > -256 && Val < 256) || (Val == INT32_MIN);
1059   }
1060   bool isPostIdxImm8s4() const {
1061     if (!isImm()) return false;
1062     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1063     if (!CE) return false;
1064     int64_t Val = CE->getValue();
1065     return ((Val & 3) == 0 && Val >= -1020 && Val <= 1020) ||
1066       (Val == INT32_MIN);
1067   }
1068
1069   bool isMSRMask() const { return Kind == k_MSRMask; }
1070   bool isProcIFlags() const { return Kind == k_ProcIFlags; }
1071
1072   // NEON operands.
1073   bool isSingleSpacedVectorList() const {
1074     return Kind == k_VectorList && !VectorList.isDoubleSpaced;
1075   }
1076   bool isDoubleSpacedVectorList() const {
1077     return Kind == k_VectorList && VectorList.isDoubleSpaced;
1078   }
1079   bool isVecListOneD() const {
1080     if (!isSingleSpacedVectorList()) return false;
1081     return VectorList.Count == 1;
1082   }
1083
1084   bool isVecListTwoD() const {
1085     if (!isSingleSpacedVectorList()) return false;
1086     return VectorList.Count == 2;
1087   }
1088
1089   bool isVecListThreeD() const {
1090     if (!isSingleSpacedVectorList()) return false;
1091     return VectorList.Count == 3;
1092   }
1093
1094   bool isVecListFourD() const {
1095     if (!isSingleSpacedVectorList()) return false;
1096     return VectorList.Count == 4;
1097   }
1098
1099   bool isVecListTwoQ() const {
1100     if (!isDoubleSpacedVectorList()) return false;
1101     return VectorList.Count == 2;
1102   }
1103
1104   bool isVecListThreeQ() const {
1105     if (!isDoubleSpacedVectorList()) return false;
1106     return VectorList.Count == 3;
1107   }
1108
1109   bool isVecListFourQ() const {
1110     if (!isDoubleSpacedVectorList()) return false;
1111     return VectorList.Count == 4;
1112   }
1113
1114   bool isSingleSpacedVectorAllLanes() const {
1115     return Kind == k_VectorListAllLanes && !VectorList.isDoubleSpaced;
1116   }
1117   bool isDoubleSpacedVectorAllLanes() const {
1118     return Kind == k_VectorListAllLanes && VectorList.isDoubleSpaced;
1119   }
1120   bool isVecListOneDAllLanes() const {
1121     if (!isSingleSpacedVectorAllLanes()) return false;
1122     return VectorList.Count == 1;
1123   }
1124
1125   bool isVecListTwoDAllLanes() const {
1126     if (!isSingleSpacedVectorAllLanes()) return false;
1127     return VectorList.Count == 2;
1128   }
1129
1130   bool isVecListTwoQAllLanes() const {
1131     if (!isDoubleSpacedVectorAllLanes()) return false;
1132     return VectorList.Count == 2;
1133   }
1134
1135   bool isSingleSpacedVectorIndexed() const {
1136     return Kind == k_VectorListIndexed && !VectorList.isDoubleSpaced;
1137   }
1138   bool isDoubleSpacedVectorIndexed() const {
1139     return Kind == k_VectorListIndexed && VectorList.isDoubleSpaced;
1140   }
1141   bool isVecListOneDByteIndexed() const {
1142     if (!isSingleSpacedVectorIndexed()) return false;
1143     return VectorList.Count == 1 && VectorList.LaneIndex <= 7;
1144   }
1145
1146   bool isVecListOneDHWordIndexed() const {
1147     if (!isSingleSpacedVectorIndexed()) return false;
1148     return VectorList.Count == 1 && VectorList.LaneIndex <= 3;
1149   }
1150
1151   bool isVecListOneDWordIndexed() const {
1152     if (!isSingleSpacedVectorIndexed()) return false;
1153     return VectorList.Count == 1 && VectorList.LaneIndex <= 1;
1154   }
1155
1156   bool isVecListTwoDByteIndexed() const {
1157     if (!isSingleSpacedVectorIndexed()) return false;
1158     return VectorList.Count == 2 && VectorList.LaneIndex <= 7;
1159   }
1160
1161   bool isVecListTwoDHWordIndexed() const {
1162     if (!isSingleSpacedVectorIndexed()) return false;
1163     return VectorList.Count == 2 && VectorList.LaneIndex <= 3;
1164   }
1165
1166   bool isVecListTwoQWordIndexed() const {
1167     if (!isDoubleSpacedVectorIndexed()) return false;
1168     return VectorList.Count == 2 && VectorList.LaneIndex <= 1;
1169   }
1170
1171   bool isVecListTwoQHWordIndexed() const {
1172     if (!isDoubleSpacedVectorIndexed()) return false;
1173     return VectorList.Count == 2 && VectorList.LaneIndex <= 3;
1174   }
1175
1176   bool isVecListTwoDWordIndexed() const {
1177     if (!isSingleSpacedVectorIndexed()) return false;
1178     return VectorList.Count == 2 && VectorList.LaneIndex <= 1;
1179   }
1180
1181   bool isVecListThreeDByteIndexed() const {
1182     if (!isSingleSpacedVectorIndexed()) return false;
1183     return VectorList.Count == 3 && VectorList.LaneIndex <= 7;
1184   }
1185
1186   bool isVecListThreeDHWordIndexed() const {
1187     if (!isSingleSpacedVectorIndexed()) return false;
1188     return VectorList.Count == 3 && VectorList.LaneIndex <= 3;
1189   }
1190
1191   bool isVecListThreeQWordIndexed() const {
1192     if (!isDoubleSpacedVectorIndexed()) return false;
1193     return VectorList.Count == 3 && VectorList.LaneIndex <= 1;
1194   }
1195
1196   bool isVecListThreeQHWordIndexed() const {
1197     if (!isDoubleSpacedVectorIndexed()) return false;
1198     return VectorList.Count == 3 && VectorList.LaneIndex <= 3;
1199   }
1200
1201   bool isVecListThreeDWordIndexed() const {
1202     if (!isSingleSpacedVectorIndexed()) return false;
1203     return VectorList.Count == 3 && VectorList.LaneIndex <= 1;
1204   }
1205
1206   bool isVectorIndex8() const {
1207     if (Kind != k_VectorIndex) return false;
1208     return VectorIndex.Val < 8;
1209   }
1210   bool isVectorIndex16() const {
1211     if (Kind != k_VectorIndex) return false;
1212     return VectorIndex.Val < 4;
1213   }
1214   bool isVectorIndex32() const {
1215     if (Kind != k_VectorIndex) return false;
1216     return VectorIndex.Val < 2;
1217   }
1218
1219   bool isNEONi8splat() const {
1220     if (!isImm()) return false;
1221     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1222     // Must be a constant.
1223     if (!CE) return false;
1224     int64_t Value = CE->getValue();
1225     // i8 value splatted across 8 bytes. The immediate is just the 8 byte
1226     // value.
1227     return Value >= 0 && Value < 256;
1228   }
1229
1230   bool isNEONi16splat() const {
1231     if (!isImm()) return false;
1232     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1233     // Must be a constant.
1234     if (!CE) return false;
1235     int64_t Value = CE->getValue();
1236     // i16 value in the range [0,255] or [0x0100, 0xff00]
1237     return (Value >= 0 && Value < 256) || (Value >= 0x0100 && Value <= 0xff00);
1238   }
1239
1240   bool isNEONi32splat() const {
1241     if (!isImm()) return false;
1242     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1243     // Must be a constant.
1244     if (!CE) return false;
1245     int64_t Value = CE->getValue();
1246     // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X.
1247     return (Value >= 0 && Value < 256) ||
1248       (Value >= 0x0100 && Value <= 0xff00) ||
1249       (Value >= 0x010000 && Value <= 0xff0000) ||
1250       (Value >= 0x01000000 && Value <= 0xff000000);
1251   }
1252
1253   bool isNEONi32vmov() const {
1254     if (!isImm()) return false;
1255     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1256     // Must be a constant.
1257     if (!CE) return false;
1258     int64_t Value = CE->getValue();
1259     // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X,
1260     // for VMOV/VMVN only, 00Xf or 0Xff are also accepted.
1261     return (Value >= 0 && Value < 256) ||
1262       (Value >= 0x0100 && Value <= 0xff00) ||
1263       (Value >= 0x010000 && Value <= 0xff0000) ||
1264       (Value >= 0x01000000 && Value <= 0xff000000) ||
1265       (Value >= 0x01ff && Value <= 0xffff && (Value & 0xff) == 0xff) ||
1266       (Value >= 0x01ffff && Value <= 0xffffff && (Value & 0xffff) == 0xffff);
1267   }
1268   bool isNEONi32vmovNeg() const {
1269     if (!isImm()) return false;
1270     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1271     // Must be a constant.
1272     if (!CE) return false;
1273     int64_t Value = ~CE->getValue();
1274     // i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X,
1275     // for VMOV/VMVN only, 00Xf or 0Xff are also accepted.
1276     return (Value >= 0 && Value < 256) ||
1277       (Value >= 0x0100 && Value <= 0xff00) ||
1278       (Value >= 0x010000 && Value <= 0xff0000) ||
1279       (Value >= 0x01000000 && Value <= 0xff000000) ||
1280       (Value >= 0x01ff && Value <= 0xffff && (Value & 0xff) == 0xff) ||
1281       (Value >= 0x01ffff && Value <= 0xffffff && (Value & 0xffff) == 0xffff);
1282   }
1283
1284   bool isNEONi64splat() const {
1285     if (!isImm()) return false;
1286     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1287     // Must be a constant.
1288     if (!CE) return false;
1289     uint64_t Value = CE->getValue();
1290     // i64 value with each byte being either 0 or 0xff.
1291     for (unsigned i = 0; i < 8; ++i)
1292       if ((Value & 0xff) != 0 && (Value & 0xff) != 0xff) return false;
1293     return true;
1294   }
1295
1296   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
1297     // Add as immediates when possible.  Null MCExpr = 0.
1298     if (Expr == 0)
1299       Inst.addOperand(MCOperand::CreateImm(0));
1300     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
1301       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
1302     else
1303       Inst.addOperand(MCOperand::CreateExpr(Expr));
1304   }
1305
1306   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
1307     assert(N == 2 && "Invalid number of operands!");
1308     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
1309     unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
1310     Inst.addOperand(MCOperand::CreateReg(RegNum));
1311   }
1312
1313   void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
1314     assert(N == 1 && "Invalid number of operands!");
1315     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
1316   }
1317
1318   void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
1319     assert(N == 1 && "Invalid number of operands!");
1320     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
1321   }
1322
1323   void addCoprocOptionOperands(MCInst &Inst, unsigned N) const {
1324     assert(N == 1 && "Invalid number of operands!");
1325     Inst.addOperand(MCOperand::CreateImm(CoprocOption.Val));
1326   }
1327
1328   void addITMaskOperands(MCInst &Inst, unsigned N) const {
1329     assert(N == 1 && "Invalid number of operands!");
1330     Inst.addOperand(MCOperand::CreateImm(ITMask.Mask));
1331   }
1332
1333   void addITCondCodeOperands(MCInst &Inst, unsigned N) const {
1334     assert(N == 1 && "Invalid number of operands!");
1335     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
1336   }
1337
1338   void addCCOutOperands(MCInst &Inst, unsigned N) const {
1339     assert(N == 1 && "Invalid number of operands!");
1340     Inst.addOperand(MCOperand::CreateReg(getReg()));
1341   }
1342
1343   void addRegOperands(MCInst &Inst, unsigned N) const {
1344     assert(N == 1 && "Invalid number of operands!");
1345     Inst.addOperand(MCOperand::CreateReg(getReg()));
1346   }
1347
1348   void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const {
1349     assert(N == 3 && "Invalid number of operands!");
1350     assert(isRegShiftedReg() &&
1351            "addRegShiftedRegOperands() on non RegShiftedReg!");
1352     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg));
1353     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg));
1354     Inst.addOperand(MCOperand::CreateImm(
1355       ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm)));
1356   }
1357
1358   void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const {
1359     assert(N == 2 && "Invalid number of operands!");
1360     assert(isRegShiftedImm() &&
1361            "addRegShiftedImmOperands() on non RegShiftedImm!");
1362     Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg));
1363     Inst.addOperand(MCOperand::CreateImm(
1364       ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm)));
1365   }
1366
1367   void addShifterImmOperands(MCInst &Inst, unsigned N) const {
1368     assert(N == 1 && "Invalid number of operands!");
1369     Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) |
1370                                          ShifterImm.Imm));
1371   }
1372
1373   void addRegListOperands(MCInst &Inst, unsigned N) const {
1374     assert(N == 1 && "Invalid number of operands!");
1375     const SmallVectorImpl<unsigned> &RegList = getRegList();
1376     for (SmallVectorImpl<unsigned>::const_iterator
1377            I = RegList.begin(), E = RegList.end(); I != E; ++I)
1378       Inst.addOperand(MCOperand::CreateReg(*I));
1379   }
1380
1381   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
1382     addRegListOperands(Inst, N);
1383   }
1384
1385   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
1386     addRegListOperands(Inst, N);
1387   }
1388
1389   void addRotImmOperands(MCInst &Inst, unsigned N) const {
1390     assert(N == 1 && "Invalid number of operands!");
1391     // Encoded as val>>3. The printer handles display as 8, 16, 24.
1392     Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3));
1393   }
1394
1395   void addBitfieldOperands(MCInst &Inst, unsigned N) const {
1396     assert(N == 1 && "Invalid number of operands!");
1397     // Munge the lsb/width into a bitfield mask.
1398     unsigned lsb = Bitfield.LSB;
1399     unsigned width = Bitfield.Width;
1400     // Make a 32-bit mask w/ the referenced bits clear and all other bits set.
1401     uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >>
1402                       (32 - (lsb + width)));
1403     Inst.addOperand(MCOperand::CreateImm(Mask));
1404   }
1405
1406   void addImmOperands(MCInst &Inst, unsigned N) const {
1407     assert(N == 1 && "Invalid number of operands!");
1408     addExpr(Inst, getImm());
1409   }
1410
1411   void addFBits16Operands(MCInst &Inst, unsigned N) const {
1412     assert(N == 1 && "Invalid number of operands!");
1413     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1414     Inst.addOperand(MCOperand::CreateImm(16 - CE->getValue()));
1415   }
1416
1417   void addFBits32Operands(MCInst &Inst, unsigned N) const {
1418     assert(N == 1 && "Invalid number of operands!");
1419     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1420     Inst.addOperand(MCOperand::CreateImm(32 - CE->getValue()));
1421   }
1422
1423   void addFPImmOperands(MCInst &Inst, unsigned N) const {
1424     assert(N == 1 && "Invalid number of operands!");
1425     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1426     int Val = ARM_AM::getFP32Imm(APInt(32, CE->getValue()));
1427     Inst.addOperand(MCOperand::CreateImm(Val));
1428   }
1429
1430   void addImm8s4Operands(MCInst &Inst, unsigned N) const {
1431     assert(N == 1 && "Invalid number of operands!");
1432     // FIXME: We really want to scale the value here, but the LDRD/STRD
1433     // instruction don't encode operands that way yet.
1434     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1435     Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
1436   }
1437
1438   void addImm0_1020s4Operands(MCInst &Inst, unsigned N) const {
1439     assert(N == 1 && "Invalid number of operands!");
1440     // The immediate is scaled by four in the encoding and is stored
1441     // in the MCInst as such. Lop off the low two bits here.
1442     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1443     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
1444   }
1445
1446   void addImm0_508s4Operands(MCInst &Inst, unsigned N) const {
1447     assert(N == 1 && "Invalid number of operands!");
1448     // The immediate is scaled by four in the encoding and is stored
1449     // in the MCInst as such. Lop off the low two bits here.
1450     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1451     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
1452   }
1453
1454   void addImm1_16Operands(MCInst &Inst, unsigned N) const {
1455     assert(N == 1 && "Invalid number of operands!");
1456     // The constant encodes as the immediate-1, and we store in the instruction
1457     // the bits as encoded, so subtract off one here.
1458     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1459     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
1460   }
1461
1462   void addImm1_32Operands(MCInst &Inst, unsigned N) const {
1463     assert(N == 1 && "Invalid number of operands!");
1464     // The constant encodes as the immediate-1, and we store in the instruction
1465     // the bits as encoded, so subtract off one here.
1466     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1467     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
1468   }
1469
1470   void addImmThumbSROperands(MCInst &Inst, unsigned N) const {
1471     assert(N == 1 && "Invalid number of operands!");
1472     // The constant encodes as the immediate, except for 32, which encodes as
1473     // zero.
1474     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1475     unsigned Imm = CE->getValue();
1476     Inst.addOperand(MCOperand::CreateImm((Imm == 32 ? 0 : Imm)));
1477   }
1478
1479   void addPKHASRImmOperands(MCInst &Inst, unsigned N) const {
1480     assert(N == 1 && "Invalid number of operands!");
1481     // An ASR value of 32 encodes as 0, so that's how we want to add it to
1482     // the instruction as well.
1483     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1484     int Val = CE->getValue();
1485     Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val));
1486   }
1487
1488   void addT2SOImmNotOperands(MCInst &Inst, unsigned N) const {
1489     assert(N == 1 && "Invalid number of operands!");
1490     // The operand is actually a t2_so_imm, but we have its bitwise
1491     // negation in the assembly source, so twiddle it here.
1492     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1493     Inst.addOperand(MCOperand::CreateImm(~CE->getValue()));
1494   }
1495
1496   void addT2SOImmNegOperands(MCInst &Inst, unsigned N) const {
1497     assert(N == 1 && "Invalid number of operands!");
1498     // The operand is actually a t2_so_imm, but we have its
1499     // negation in the assembly source, so twiddle it here.
1500     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1501     Inst.addOperand(MCOperand::CreateImm(-CE->getValue()));
1502   }
1503
1504   void addARMSOImmNotOperands(MCInst &Inst, unsigned N) const {
1505     assert(N == 1 && "Invalid number of operands!");
1506     // The operand is actually a so_imm, but we have its bitwise
1507     // negation in the assembly source, so twiddle it here.
1508     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1509     Inst.addOperand(MCOperand::CreateImm(~CE->getValue()));
1510   }
1511
1512   void addARMSOImmNegOperands(MCInst &Inst, unsigned N) const {
1513     assert(N == 1 && "Invalid number of operands!");
1514     // The operand is actually a so_imm, but we have its
1515     // negation in the assembly source, so twiddle it here.
1516     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1517     Inst.addOperand(MCOperand::CreateImm(-CE->getValue()));
1518   }
1519
1520   void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
1521     assert(N == 1 && "Invalid number of operands!");
1522     Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
1523   }
1524
1525   void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const {
1526     assert(N == 1 && "Invalid number of operands!");
1527     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1528   }
1529
1530   void addMemPCRelImm12Operands(MCInst &Inst, unsigned N) const {
1531     assert(N == 1 && "Invalid number of operands!");
1532     int32_t Imm = Memory.OffsetImm->getValue();
1533     // FIXME: Handle #-0
1534     if (Imm == INT32_MIN) Imm = 0;
1535     Inst.addOperand(MCOperand::CreateImm(Imm));
1536   }
1537
1538   void addAlignedMemoryOperands(MCInst &Inst, unsigned N) const {
1539     assert(N == 2 && "Invalid number of operands!");
1540     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1541     Inst.addOperand(MCOperand::CreateImm(Memory.Alignment));
1542   }
1543
1544   void addAddrMode2Operands(MCInst &Inst, unsigned N) const {
1545     assert(N == 3 && "Invalid number of operands!");
1546     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1547     if (!Memory.OffsetRegNum) {
1548       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1549       // Special case for #-0
1550       if (Val == INT32_MIN) Val = 0;
1551       if (Val < 0) Val = -Val;
1552       Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1553     } else {
1554       // For register offset, we encode the shift type and negation flag
1555       // here.
1556       Val = ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add,
1557                               Memory.ShiftImm, Memory.ShiftType);
1558     }
1559     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1560     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1561     Inst.addOperand(MCOperand::CreateImm(Val));
1562   }
1563
1564   void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const {
1565     assert(N == 2 && "Invalid number of operands!");
1566     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1567     assert(CE && "non-constant AM2OffsetImm operand!");
1568     int32_t Val = CE->getValue();
1569     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1570     // Special case for #-0
1571     if (Val == INT32_MIN) Val = 0;
1572     if (Val < 0) Val = -Val;
1573     Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1574     Inst.addOperand(MCOperand::CreateReg(0));
1575     Inst.addOperand(MCOperand::CreateImm(Val));
1576   }
1577
1578   void addAddrMode3Operands(MCInst &Inst, unsigned N) const {
1579     assert(N == 3 && "Invalid number of operands!");
1580     // If we have an immediate that's not a constant, treat it as a label
1581     // reference needing a fixup. If it is a constant, it's something else
1582     // and we reject it.
1583     if (isImm()) {
1584       Inst.addOperand(MCOperand::CreateExpr(getImm()));
1585       Inst.addOperand(MCOperand::CreateReg(0));
1586       Inst.addOperand(MCOperand::CreateImm(0));
1587       return;
1588     }
1589
1590     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1591     if (!Memory.OffsetRegNum) {
1592       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1593       // Special case for #-0
1594       if (Val == INT32_MIN) Val = 0;
1595       if (Val < 0) Val = -Val;
1596       Val = ARM_AM::getAM3Opc(AddSub, Val);
1597     } else {
1598       // For register offset, we encode the shift type and negation flag
1599       // here.
1600       Val = ARM_AM::getAM3Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add, 0);
1601     }
1602     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1603     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1604     Inst.addOperand(MCOperand::CreateImm(Val));
1605   }
1606
1607   void addAM3OffsetOperands(MCInst &Inst, unsigned N) const {
1608     assert(N == 2 && "Invalid number of operands!");
1609     if (Kind == k_PostIndexRegister) {
1610       int32_t Val =
1611         ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0);
1612       Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1613       Inst.addOperand(MCOperand::CreateImm(Val));
1614       return;
1615     }
1616
1617     // Constant offset.
1618     const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm());
1619     int32_t Val = CE->getValue();
1620     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1621     // Special case for #-0
1622     if (Val == INT32_MIN) Val = 0;
1623     if (Val < 0) Val = -Val;
1624     Val = ARM_AM::getAM3Opc(AddSub, Val);
1625     Inst.addOperand(MCOperand::CreateReg(0));
1626     Inst.addOperand(MCOperand::CreateImm(Val));
1627   }
1628
1629   void addAddrMode5Operands(MCInst &Inst, unsigned N) const {
1630     assert(N == 2 && "Invalid number of operands!");
1631     // If we have an immediate that's not a constant, treat it as a label
1632     // reference needing a fixup. If it is a constant, it's something else
1633     // and we reject it.
1634     if (isImm()) {
1635       Inst.addOperand(MCOperand::CreateExpr(getImm()));
1636       Inst.addOperand(MCOperand::CreateImm(0));
1637       return;
1638     }
1639
1640     // The lower two bits are always zero and as such are not encoded.
1641     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
1642     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1643     // Special case for #-0
1644     if (Val == INT32_MIN) Val = 0;
1645     if (Val < 0) Val = -Val;
1646     Val = ARM_AM::getAM5Opc(AddSub, Val);
1647     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1648     Inst.addOperand(MCOperand::CreateImm(Val));
1649   }
1650
1651   void addMemImm8s4OffsetOperands(MCInst &Inst, unsigned N) const {
1652     assert(N == 2 && "Invalid number of operands!");
1653     // If we have an immediate that's not a constant, treat it as a label
1654     // reference needing a fixup. If it is a constant, it's something else
1655     // and we reject it.
1656     if (isImm()) {
1657       Inst.addOperand(MCOperand::CreateExpr(getImm()));
1658       Inst.addOperand(MCOperand::CreateImm(0));
1659       return;
1660     }
1661
1662     int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1663     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1664     Inst.addOperand(MCOperand::CreateImm(Val));
1665   }
1666
1667   void addMemImm0_1020s4OffsetOperands(MCInst &Inst, unsigned N) const {
1668     assert(N == 2 && "Invalid number of operands!");
1669     // The lower two bits are always zero and as such are not encoded.
1670     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
1671     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1672     Inst.addOperand(MCOperand::CreateImm(Val));
1673   }
1674
1675   void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1676     assert(N == 2 && "Invalid number of operands!");
1677     int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1678     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1679     Inst.addOperand(MCOperand::CreateImm(Val));
1680   }
1681
1682   void addMemPosImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1683     addMemImm8OffsetOperands(Inst, N);
1684   }
1685
1686   void addMemNegImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1687     addMemImm8OffsetOperands(Inst, N);
1688   }
1689
1690   void addMemUImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1691     assert(N == 2 && "Invalid number of operands!");
1692     // If this is an immediate, it's a label reference.
1693     if (isImm()) {
1694       addExpr(Inst, getImm());
1695       Inst.addOperand(MCOperand::CreateImm(0));
1696       return;
1697     }
1698
1699     // Otherwise, it's a normal memory reg+offset.
1700     int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1701     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1702     Inst.addOperand(MCOperand::CreateImm(Val));
1703   }
1704
1705   void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1706     assert(N == 2 && "Invalid number of operands!");
1707     // If this is an immediate, it's a label reference.
1708     if (isImm()) {
1709       addExpr(Inst, getImm());
1710       Inst.addOperand(MCOperand::CreateImm(0));
1711       return;
1712     }
1713
1714     // Otherwise, it's a normal memory reg+offset.
1715     int64_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
1716     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1717     Inst.addOperand(MCOperand::CreateImm(Val));
1718   }
1719
1720   void addMemTBBOperands(MCInst &Inst, unsigned N) const {
1721     assert(N == 2 && "Invalid number of operands!");
1722     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1723     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1724   }
1725
1726   void addMemTBHOperands(MCInst &Inst, unsigned N) const {
1727     assert(N == 2 && "Invalid number of operands!");
1728     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1729     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1730   }
1731
1732   void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1733     assert(N == 3 && "Invalid number of operands!");
1734     unsigned Val =
1735       ARM_AM::getAM2Opc(Memory.isNegative ? ARM_AM::sub : ARM_AM::add,
1736                         Memory.ShiftImm, Memory.ShiftType);
1737     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1738     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1739     Inst.addOperand(MCOperand::CreateImm(Val));
1740   }
1741
1742   void addT2MemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1743     assert(N == 3 && "Invalid number of operands!");
1744     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1745     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1746     Inst.addOperand(MCOperand::CreateImm(Memory.ShiftImm));
1747   }
1748
1749   void addMemThumbRROperands(MCInst &Inst, unsigned N) const {
1750     assert(N == 2 && "Invalid number of operands!");
1751     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1752     Inst.addOperand(MCOperand::CreateReg(Memory.OffsetRegNum));
1753   }
1754
1755   void addMemThumbRIs4Operands(MCInst &Inst, unsigned N) const {
1756     assert(N == 2 && "Invalid number of operands!");
1757     int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0;
1758     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1759     Inst.addOperand(MCOperand::CreateImm(Val));
1760   }
1761
1762   void addMemThumbRIs2Operands(MCInst &Inst, unsigned N) const {
1763     assert(N == 2 && "Invalid number of operands!");
1764     int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 2) : 0;
1765     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1766     Inst.addOperand(MCOperand::CreateImm(Val));
1767   }
1768
1769   void addMemThumbRIs1Operands(MCInst &Inst, unsigned N) const {
1770     assert(N == 2 && "Invalid number of operands!");
1771     int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue()) : 0;
1772     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1773     Inst.addOperand(MCOperand::CreateImm(Val));
1774   }
1775
1776   void addMemThumbSPIOperands(MCInst &Inst, unsigned N) const {
1777     assert(N == 2 && "Invalid number of operands!");
1778     int64_t Val = Memory.OffsetImm ? (Memory.OffsetImm->getValue() / 4) : 0;
1779     Inst.addOperand(MCOperand::CreateReg(Memory.BaseRegNum));
1780     Inst.addOperand(MCOperand::CreateImm(Val));
1781   }
1782
1783   void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const {
1784     assert(N == 1 && "Invalid number of operands!");
1785     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1786     assert(CE && "non-constant post-idx-imm8 operand!");
1787     int Imm = CE->getValue();
1788     bool isAdd = Imm >= 0;
1789     if (Imm == INT32_MIN) Imm = 0;
1790     Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8;
1791     Inst.addOperand(MCOperand::CreateImm(Imm));
1792   }
1793
1794   void addPostIdxImm8s4Operands(MCInst &Inst, unsigned N) const {
1795     assert(N == 1 && "Invalid number of operands!");
1796     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1797     assert(CE && "non-constant post-idx-imm8s4 operand!");
1798     int Imm = CE->getValue();
1799     bool isAdd = Imm >= 0;
1800     if (Imm == INT32_MIN) Imm = 0;
1801     // Immediate is scaled by 4.
1802     Imm = ((Imm < 0 ? -Imm : Imm) / 4) | (int)isAdd << 8;
1803     Inst.addOperand(MCOperand::CreateImm(Imm));
1804   }
1805
1806   void addPostIdxRegOperands(MCInst &Inst, unsigned N) const {
1807     assert(N == 2 && "Invalid number of operands!");
1808     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1809     Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd));
1810   }
1811
1812   void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const {
1813     assert(N == 2 && "Invalid number of operands!");
1814     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1815     // The sign, shift type, and shift amount are encoded in a single operand
1816     // using the AM2 encoding helpers.
1817     ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub;
1818     unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm,
1819                                      PostIdxReg.ShiftTy);
1820     Inst.addOperand(MCOperand::CreateImm(Imm));
1821   }
1822
1823   void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
1824     assert(N == 1 && "Invalid number of operands!");
1825     Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
1826   }
1827
1828   void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
1829     assert(N == 1 && "Invalid number of operands!");
1830     Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
1831   }
1832
1833   void addVecListOperands(MCInst &Inst, unsigned N) const {
1834     assert(N == 1 && "Invalid number of operands!");
1835     Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1836   }
1837
1838   void addVecListIndexedOperands(MCInst &Inst, unsigned N) const {
1839     assert(N == 2 && "Invalid number of operands!");
1840     Inst.addOperand(MCOperand::CreateReg(VectorList.RegNum));
1841     Inst.addOperand(MCOperand::CreateImm(VectorList.LaneIndex));
1842   }
1843
1844   void addVectorIndex8Operands(MCInst &Inst, unsigned N) const {
1845     assert(N == 1 && "Invalid number of operands!");
1846     Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1847   }
1848
1849   void addVectorIndex16Operands(MCInst &Inst, unsigned N) const {
1850     assert(N == 1 && "Invalid number of operands!");
1851     Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1852   }
1853
1854   void addVectorIndex32Operands(MCInst &Inst, unsigned N) const {
1855     assert(N == 1 && "Invalid number of operands!");
1856     Inst.addOperand(MCOperand::CreateImm(getVectorIndex()));
1857   }
1858
1859   void addNEONi8splatOperands(MCInst &Inst, unsigned N) const {
1860     assert(N == 1 && "Invalid number of operands!");
1861     // The immediate encodes the type of constant as well as the value.
1862     // Mask in that this is an i8 splat.
1863     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1864     Inst.addOperand(MCOperand::CreateImm(CE->getValue() | 0xe00));
1865   }
1866
1867   void addNEONi16splatOperands(MCInst &Inst, unsigned N) const {
1868     assert(N == 1 && "Invalid number of operands!");
1869     // The immediate encodes the type of constant as well as the value.
1870     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1871     unsigned Value = CE->getValue();
1872     if (Value >= 256)
1873       Value = (Value >> 8) | 0xa00;
1874     else
1875       Value |= 0x800;
1876     Inst.addOperand(MCOperand::CreateImm(Value));
1877   }
1878
1879   void addNEONi32splatOperands(MCInst &Inst, unsigned N) const {
1880     assert(N == 1 && "Invalid number of operands!");
1881     // The immediate encodes the type of constant as well as the value.
1882     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1883     unsigned Value = CE->getValue();
1884     if (Value >= 256 && Value <= 0xff00)
1885       Value = (Value >> 8) | 0x200;
1886     else if (Value > 0xffff && Value <= 0xff0000)
1887       Value = (Value >> 16) | 0x400;
1888     else if (Value > 0xffffff)
1889       Value = (Value >> 24) | 0x600;
1890     Inst.addOperand(MCOperand::CreateImm(Value));
1891   }
1892
1893   void addNEONi32vmovOperands(MCInst &Inst, unsigned N) const {
1894     assert(N == 1 && "Invalid number of operands!");
1895     // The immediate encodes the type of constant as well as the value.
1896     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1897     unsigned Value = CE->getValue();
1898     if (Value >= 256 && Value <= 0xffff)
1899       Value = (Value >> 8) | ((Value & 0xff) ? 0xc00 : 0x200);
1900     else if (Value > 0xffff && Value <= 0xffffff)
1901       Value = (Value >> 16) | ((Value & 0xff) ? 0xd00 : 0x400);
1902     else if (Value > 0xffffff)
1903       Value = (Value >> 24) | 0x600;
1904     Inst.addOperand(MCOperand::CreateImm(Value));
1905   }
1906
1907   void addNEONi32vmovNegOperands(MCInst &Inst, unsigned N) const {
1908     assert(N == 1 && "Invalid number of operands!");
1909     // The immediate encodes the type of constant as well as the value.
1910     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1911     unsigned Value = ~CE->getValue();
1912     if (Value >= 256 && Value <= 0xffff)
1913       Value = (Value >> 8) | ((Value & 0xff) ? 0xc00 : 0x200);
1914     else if (Value > 0xffff && Value <= 0xffffff)
1915       Value = (Value >> 16) | ((Value & 0xff) ? 0xd00 : 0x400);
1916     else if (Value > 0xffffff)
1917       Value = (Value >> 24) | 0x600;
1918     Inst.addOperand(MCOperand::CreateImm(Value));
1919   }
1920
1921   void addNEONi64splatOperands(MCInst &Inst, unsigned N) const {
1922     assert(N == 1 && "Invalid number of operands!");
1923     // The immediate encodes the type of constant as well as the value.
1924     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1925     uint64_t Value = CE->getValue();
1926     unsigned Imm = 0;
1927     for (unsigned i = 0; i < 8; ++i, Value >>= 8) {
1928       Imm |= (Value & 1) << i;
1929     }
1930     Inst.addOperand(MCOperand::CreateImm(Imm | 0x1e00));
1931   }
1932
1933   virtual void print(raw_ostream &OS) const;
1934
1935   static ARMOperand *CreateITMask(unsigned Mask, SMLoc S) {
1936     ARMOperand *Op = new ARMOperand(k_ITCondMask);
1937     Op->ITMask.Mask = Mask;
1938     Op->StartLoc = S;
1939     Op->EndLoc = S;
1940     return Op;
1941   }
1942
1943   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
1944     ARMOperand *Op = new ARMOperand(k_CondCode);
1945     Op->CC.Val = CC;
1946     Op->StartLoc = S;
1947     Op->EndLoc = S;
1948     return Op;
1949   }
1950
1951   static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
1952     ARMOperand *Op = new ARMOperand(k_CoprocNum);
1953     Op->Cop.Val = CopVal;
1954     Op->StartLoc = S;
1955     Op->EndLoc = S;
1956     return Op;
1957   }
1958
1959   static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
1960     ARMOperand *Op = new ARMOperand(k_CoprocReg);
1961     Op->Cop.Val = CopVal;
1962     Op->StartLoc = S;
1963     Op->EndLoc = S;
1964     return Op;
1965   }
1966
1967   static ARMOperand *CreateCoprocOption(unsigned Val, SMLoc S, SMLoc E) {
1968     ARMOperand *Op = new ARMOperand(k_CoprocOption);
1969     Op->Cop.Val = Val;
1970     Op->StartLoc = S;
1971     Op->EndLoc = E;
1972     return Op;
1973   }
1974
1975   static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
1976     ARMOperand *Op = new ARMOperand(k_CCOut);
1977     Op->Reg.RegNum = RegNum;
1978     Op->StartLoc = S;
1979     Op->EndLoc = S;
1980     return Op;
1981   }
1982
1983   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
1984     ARMOperand *Op = new ARMOperand(k_Token);
1985     Op->Tok.Data = Str.data();
1986     Op->Tok.Length = Str.size();
1987     Op->StartLoc = S;
1988     Op->EndLoc = S;
1989     return Op;
1990   }
1991
1992   static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
1993     ARMOperand *Op = new ARMOperand(k_Register);
1994     Op->Reg.RegNum = RegNum;
1995     Op->StartLoc = S;
1996     Op->EndLoc = E;
1997     return Op;
1998   }
1999
2000   static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
2001                                            unsigned SrcReg,
2002                                            unsigned ShiftReg,
2003                                            unsigned ShiftImm,
2004                                            SMLoc S, SMLoc E) {
2005     ARMOperand *Op = new ARMOperand(k_ShiftedRegister);
2006     Op->RegShiftedReg.ShiftTy = ShTy;
2007     Op->RegShiftedReg.SrcReg = SrcReg;
2008     Op->RegShiftedReg.ShiftReg = ShiftReg;
2009     Op->RegShiftedReg.ShiftImm = ShiftImm;
2010     Op->StartLoc = S;
2011     Op->EndLoc = E;
2012     return Op;
2013   }
2014
2015   static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy,
2016                                             unsigned SrcReg,
2017                                             unsigned ShiftImm,
2018                                             SMLoc S, SMLoc E) {
2019     ARMOperand *Op = new ARMOperand(k_ShiftedImmediate);
2020     Op->RegShiftedImm.ShiftTy = ShTy;
2021     Op->RegShiftedImm.SrcReg = SrcReg;
2022     Op->RegShiftedImm.ShiftImm = ShiftImm;
2023     Op->StartLoc = S;
2024     Op->EndLoc = E;
2025     return Op;
2026   }
2027
2028   static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm,
2029                                    SMLoc S, SMLoc E) {
2030     ARMOperand *Op = new ARMOperand(k_ShifterImmediate);
2031     Op->ShifterImm.isASR = isASR;
2032     Op->ShifterImm.Imm = Imm;
2033     Op->StartLoc = S;
2034     Op->EndLoc = E;
2035     return Op;
2036   }
2037
2038   static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) {
2039     ARMOperand *Op = new ARMOperand(k_RotateImmediate);
2040     Op->RotImm.Imm = Imm;
2041     Op->StartLoc = S;
2042     Op->EndLoc = E;
2043     return Op;
2044   }
2045
2046   static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width,
2047                                     SMLoc S, SMLoc E) {
2048     ARMOperand *Op = new ARMOperand(k_BitfieldDescriptor);
2049     Op->Bitfield.LSB = LSB;
2050     Op->Bitfield.Width = Width;
2051     Op->StartLoc = S;
2052     Op->EndLoc = E;
2053     return Op;
2054   }
2055
2056   static ARMOperand *
2057   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
2058                 SMLoc StartLoc, SMLoc EndLoc) {
2059     KindTy Kind = k_RegisterList;
2060
2061     if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Regs.front().first))
2062       Kind = k_DPRRegisterList;
2063     else if (ARMMCRegisterClasses[ARM::SPRRegClassID].
2064              contains(Regs.front().first))
2065       Kind = k_SPRRegisterList;
2066
2067     ARMOperand *Op = new ARMOperand(Kind);
2068     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
2069            I = Regs.begin(), E = Regs.end(); I != E; ++I)
2070       Op->Registers.push_back(I->first);
2071     array_pod_sort(Op->Registers.begin(), Op->Registers.end());
2072     Op->StartLoc = StartLoc;
2073     Op->EndLoc = EndLoc;
2074     return Op;
2075   }
2076
2077   static ARMOperand *CreateVectorList(unsigned RegNum, unsigned Count,
2078                                       bool isDoubleSpaced, SMLoc S, SMLoc E) {
2079     ARMOperand *Op = new ARMOperand(k_VectorList);
2080     Op->VectorList.RegNum = RegNum;
2081     Op->VectorList.Count = Count;
2082     Op->VectorList.isDoubleSpaced = isDoubleSpaced;
2083     Op->StartLoc = S;
2084     Op->EndLoc = E;
2085     return Op;
2086   }
2087
2088   static ARMOperand *CreateVectorListAllLanes(unsigned RegNum, unsigned Count,
2089                                               bool isDoubleSpaced,
2090                                               SMLoc S, SMLoc E) {
2091     ARMOperand *Op = new ARMOperand(k_VectorListAllLanes);
2092     Op->VectorList.RegNum = RegNum;
2093     Op->VectorList.Count = Count;
2094     Op->VectorList.isDoubleSpaced = isDoubleSpaced;
2095     Op->StartLoc = S;
2096     Op->EndLoc = E;
2097     return Op;
2098   }
2099
2100   static ARMOperand *CreateVectorListIndexed(unsigned RegNum, unsigned Count,
2101                                              unsigned Index,
2102                                              bool isDoubleSpaced,
2103                                              SMLoc S, SMLoc E) {
2104     ARMOperand *Op = new ARMOperand(k_VectorListIndexed);
2105     Op->VectorList.RegNum = RegNum;
2106     Op->VectorList.Count = Count;
2107     Op->VectorList.LaneIndex = Index;
2108     Op->VectorList.isDoubleSpaced = isDoubleSpaced;
2109     Op->StartLoc = S;
2110     Op->EndLoc = E;
2111     return Op;
2112   }
2113
2114   static ARMOperand *CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E,
2115                                        MCContext &Ctx) {
2116     ARMOperand *Op = new ARMOperand(k_VectorIndex);
2117     Op->VectorIndex.Val = Idx;
2118     Op->StartLoc = S;
2119     Op->EndLoc = E;
2120     return Op;
2121   }
2122
2123   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
2124     ARMOperand *Op = new ARMOperand(k_Immediate);
2125     Op->Imm.Val = Val;
2126     Op->StartLoc = S;
2127     Op->EndLoc = E;
2128     return Op;
2129   }
2130
2131   static ARMOperand *CreateMem(unsigned BaseRegNum,
2132                                const MCConstantExpr *OffsetImm,
2133                                unsigned OffsetRegNum,
2134                                ARM_AM::ShiftOpc ShiftType,
2135                                unsigned ShiftImm,
2136                                unsigned Alignment,
2137                                bool isNegative,
2138                                SMLoc S, SMLoc E) {
2139     ARMOperand *Op = new ARMOperand(k_Memory);
2140     Op->Memory.BaseRegNum = BaseRegNum;
2141     Op->Memory.OffsetImm = OffsetImm;
2142     Op->Memory.OffsetRegNum = OffsetRegNum;
2143     Op->Memory.ShiftType = ShiftType;
2144     Op->Memory.ShiftImm = ShiftImm;
2145     Op->Memory.Alignment = Alignment;
2146     Op->Memory.isNegative = isNegative;
2147     Op->StartLoc = S;
2148     Op->EndLoc = E;
2149     return Op;
2150   }
2151
2152   static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd,
2153                                       ARM_AM::ShiftOpc ShiftTy,
2154                                       unsigned ShiftImm,
2155                                       SMLoc S, SMLoc E) {
2156     ARMOperand *Op = new ARMOperand(k_PostIndexRegister);
2157     Op->PostIdxReg.RegNum = RegNum;
2158     Op->PostIdxReg.isAdd = isAdd;
2159     Op->PostIdxReg.ShiftTy = ShiftTy;
2160     Op->PostIdxReg.ShiftImm = ShiftImm;
2161     Op->StartLoc = S;
2162     Op->EndLoc = E;
2163     return Op;
2164   }
2165
2166   static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
2167     ARMOperand *Op = new ARMOperand(k_MemBarrierOpt);
2168     Op->MBOpt.Val = Opt;
2169     Op->StartLoc = S;
2170     Op->EndLoc = S;
2171     return Op;
2172   }
2173
2174   static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
2175     ARMOperand *Op = new ARMOperand(k_ProcIFlags);
2176     Op->IFlags.Val = IFlags;
2177     Op->StartLoc = S;
2178     Op->EndLoc = S;
2179     return Op;
2180   }
2181
2182   static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
2183     ARMOperand *Op = new ARMOperand(k_MSRMask);
2184     Op->MMask.Val = MMask;
2185     Op->StartLoc = S;
2186     Op->EndLoc = S;
2187     return Op;
2188   }
2189 };
2190
2191 } // end anonymous namespace.
2192
2193 void ARMOperand::print(raw_ostream &OS) const {
2194   switch (Kind) {
2195   case k_CondCode:
2196     OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
2197     break;
2198   case k_CCOut:
2199     OS << "<ccout " << getReg() << ">";
2200     break;
2201   case k_ITCondMask: {
2202     static const char *MaskStr[] = {
2203       "()", "(t)", "(e)", "(tt)", "(et)", "(te)", "(ee)", "(ttt)", "(ett)",
2204       "(tet)", "(eet)", "(tte)", "(ete)", "(tee)", "(eee)"
2205     };
2206     assert((ITMask.Mask & 0xf) == ITMask.Mask);
2207     OS << "<it-mask " << MaskStr[ITMask.Mask] << ">";
2208     break;
2209   }
2210   case k_CoprocNum:
2211     OS << "<coprocessor number: " << getCoproc() << ">";
2212     break;
2213   case k_CoprocReg:
2214     OS << "<coprocessor register: " << getCoproc() << ">";
2215     break;
2216   case k_CoprocOption:
2217     OS << "<coprocessor option: " << CoprocOption.Val << ">";
2218     break;
2219   case k_MSRMask:
2220     OS << "<mask: " << getMSRMask() << ">";
2221     break;
2222   case k_Immediate:
2223     getImm()->print(OS);
2224     break;
2225   case k_MemBarrierOpt:
2226     OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
2227     break;
2228   case k_Memory:
2229     OS << "<memory "
2230        << " base:" << Memory.BaseRegNum;
2231     OS << ">";
2232     break;
2233   case k_PostIndexRegister:
2234     OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-")
2235        << PostIdxReg.RegNum;
2236     if (PostIdxReg.ShiftTy != ARM_AM::no_shift)
2237       OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " "
2238          << PostIdxReg.ShiftImm;
2239     OS << ">";
2240     break;
2241   case k_ProcIFlags: {
2242     OS << "<ARM_PROC::";
2243     unsigned IFlags = getProcIFlags();
2244     for (int i=2; i >= 0; --i)
2245       if (IFlags & (1 << i))
2246         OS << ARM_PROC::IFlagsToString(1 << i);
2247     OS << ">";
2248     break;
2249   }
2250   case k_Register:
2251     OS << "<register " << getReg() << ">";
2252     break;
2253   case k_ShifterImmediate:
2254     OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl")
2255        << " #" << ShifterImm.Imm << ">";
2256     break;
2257   case k_ShiftedRegister:
2258     OS << "<so_reg_reg "
2259        << RegShiftedReg.SrcReg << " "
2260        << ARM_AM::getShiftOpcStr(RegShiftedReg.ShiftTy)
2261        << " " << RegShiftedReg.ShiftReg << ">";
2262     break;
2263   case k_ShiftedImmediate:
2264     OS << "<so_reg_imm "
2265        << RegShiftedImm.SrcReg << " "
2266        << ARM_AM::getShiftOpcStr(RegShiftedImm.ShiftTy)
2267        << " #" << RegShiftedImm.ShiftImm << ">";
2268     break;
2269   case k_RotateImmediate:
2270     OS << "<ror " << " #" << (RotImm.Imm * 8) << ">";
2271     break;
2272   case k_BitfieldDescriptor:
2273     OS << "<bitfield " << "lsb: " << Bitfield.LSB
2274        << ", width: " << Bitfield.Width << ">";
2275     break;
2276   case k_RegisterList:
2277   case k_DPRRegisterList:
2278   case k_SPRRegisterList: {
2279     OS << "<register_list ";
2280
2281     const SmallVectorImpl<unsigned> &RegList = getRegList();
2282     for (SmallVectorImpl<unsigned>::const_iterator
2283            I = RegList.begin(), E = RegList.end(); I != E; ) {
2284       OS << *I;
2285       if (++I < E) OS << ", ";
2286     }
2287
2288     OS << ">";
2289     break;
2290   }
2291   case k_VectorList:
2292     OS << "<vector_list " << VectorList.Count << " * "
2293        << VectorList.RegNum << ">";
2294     break;
2295   case k_VectorListAllLanes:
2296     OS << "<vector_list(all lanes) " << VectorList.Count << " * "
2297        << VectorList.RegNum << ">";
2298     break;
2299   case k_VectorListIndexed:
2300     OS << "<vector_list(lane " << VectorList.LaneIndex << ") "
2301        << VectorList.Count << " * " << VectorList.RegNum << ">";
2302     break;
2303   case k_Token:
2304     OS << "'" << getToken() << "'";
2305     break;
2306   case k_VectorIndex:
2307     OS << "<vectorindex " << getVectorIndex() << ">";
2308     break;
2309   }
2310 }
2311
2312 /// @name Auto-generated Match Functions
2313 /// {
2314
2315 static unsigned MatchRegisterName(StringRef Name);
2316
2317 /// }
2318
2319 bool ARMAsmParser::ParseRegister(unsigned &RegNo,
2320                                  SMLoc &StartLoc, SMLoc &EndLoc) {
2321   StartLoc = Parser.getTok().getLoc();
2322   RegNo = tryParseRegister();
2323   EndLoc = Parser.getTok().getLoc();
2324
2325   return (RegNo == (unsigned)-1);
2326 }
2327
2328 /// Try to parse a register name.  The token must be an Identifier when called,
2329 /// and if it is a register name the token is eaten and the register number is
2330 /// returned.  Otherwise return -1.
2331 ///
2332 int ARMAsmParser::tryParseRegister() {
2333   const AsmToken &Tok = Parser.getTok();
2334   if (Tok.isNot(AsmToken::Identifier)) return -1;
2335
2336   std::string lowerCase = Tok.getString().lower();
2337   unsigned RegNum = MatchRegisterName(lowerCase);
2338   if (!RegNum) {
2339     RegNum = StringSwitch<unsigned>(lowerCase)
2340       .Case("r13", ARM::SP)
2341       .Case("r14", ARM::LR)
2342       .Case("r15", ARM::PC)
2343       .Case("ip", ARM::R12)
2344       // Additional register name aliases for 'gas' compatibility.
2345       .Case("a1", ARM::R0)
2346       .Case("a2", ARM::R1)
2347       .Case("a3", ARM::R2)
2348       .Case("a4", ARM::R3)
2349       .Case("v1", ARM::R4)
2350       .Case("v2", ARM::R5)
2351       .Case("v3", ARM::R6)
2352       .Case("v4", ARM::R7)
2353       .Case("v5", ARM::R8)
2354       .Case("v6", ARM::R9)
2355       .Case("v7", ARM::R10)
2356       .Case("v8", ARM::R11)
2357       .Case("sb", ARM::R9)
2358       .Case("sl", ARM::R10)
2359       .Case("fp", ARM::R11)
2360       .Default(0);
2361   }
2362   if (!RegNum) {
2363     // Check for aliases registered via .req. Canonicalize to lower case.
2364     // That's more consistent since register names are case insensitive, and
2365     // it's how the original entry was passed in from MC/MCParser/AsmParser.
2366     StringMap<unsigned>::const_iterator Entry = RegisterReqs.find(lowerCase);
2367     // If no match, return failure.
2368     if (Entry == RegisterReqs.end())
2369       return -1;
2370     Parser.Lex(); // Eat identifier token.
2371     return Entry->getValue();
2372   }
2373
2374   Parser.Lex(); // Eat identifier token.
2375
2376   return RegNum;
2377 }
2378
2379 // Try to parse a shifter  (e.g., "lsl <amt>"). On success, return 0.
2380 // If a recoverable error occurs, return 1. If an irrecoverable error
2381 // occurs, return -1. An irrecoverable error is one where tokens have been
2382 // consumed in the process of trying to parse the shifter (i.e., when it is
2383 // indeed a shifter operand, but malformed).
2384 int ARMAsmParser::tryParseShiftRegister(
2385                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2386   SMLoc S = Parser.getTok().getLoc();
2387   const AsmToken &Tok = Parser.getTok();
2388   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2389
2390   std::string lowerCase = Tok.getString().lower();
2391   ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
2392       .Case("asl", ARM_AM::lsl)
2393       .Case("lsl", ARM_AM::lsl)
2394       .Case("lsr", ARM_AM::lsr)
2395       .Case("asr", ARM_AM::asr)
2396       .Case("ror", ARM_AM::ror)
2397       .Case("rrx", ARM_AM::rrx)
2398       .Default(ARM_AM::no_shift);
2399
2400   if (ShiftTy == ARM_AM::no_shift)
2401     return 1;
2402
2403   Parser.Lex(); // Eat the operator.
2404
2405   // The source register for the shift has already been added to the
2406   // operand list, so we need to pop it off and combine it into the shifted
2407   // register operand instead.
2408   OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val());
2409   if (!PrevOp->isReg())
2410     return Error(PrevOp->getStartLoc(), "shift must be of a register");
2411   int SrcReg = PrevOp->getReg();
2412   int64_t Imm = 0;
2413   int ShiftReg = 0;
2414   if (ShiftTy == ARM_AM::rrx) {
2415     // RRX Doesn't have an explicit shift amount. The encoder expects
2416     // the shift register to be the same as the source register. Seems odd,
2417     // but OK.
2418     ShiftReg = SrcReg;
2419   } else {
2420     // Figure out if this is shifted by a constant or a register (for non-RRX).
2421     if (Parser.getTok().is(AsmToken::Hash) ||
2422         Parser.getTok().is(AsmToken::Dollar)) {
2423       Parser.Lex(); // Eat hash.
2424       SMLoc ImmLoc = Parser.getTok().getLoc();
2425       const MCExpr *ShiftExpr = 0;
2426       if (getParser().ParseExpression(ShiftExpr)) {
2427         Error(ImmLoc, "invalid immediate shift value");
2428         return -1;
2429       }
2430       // The expression must be evaluatable as an immediate.
2431       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
2432       if (!CE) {
2433         Error(ImmLoc, "invalid immediate shift value");
2434         return -1;
2435       }
2436       // Range check the immediate.
2437       // lsl, ror: 0 <= imm <= 31
2438       // lsr, asr: 0 <= imm <= 32
2439       Imm = CE->getValue();
2440       if (Imm < 0 ||
2441           ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
2442           ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
2443         Error(ImmLoc, "immediate shift value out of range");
2444         return -1;
2445       }
2446       // shift by zero is a nop. Always send it through as lsl.
2447       // ('as' compatibility)
2448       if (Imm == 0)
2449         ShiftTy = ARM_AM::lsl;
2450     } else if (Parser.getTok().is(AsmToken::Identifier)) {
2451       ShiftReg = tryParseRegister();
2452       SMLoc L = Parser.getTok().getLoc();
2453       if (ShiftReg == -1) {
2454         Error (L, "expected immediate or register in shift operand");
2455         return -1;
2456       }
2457     } else {
2458       Error (Parser.getTok().getLoc(),
2459                     "expected immediate or register in shift operand");
2460       return -1;
2461     }
2462   }
2463
2464   if (ShiftReg && ShiftTy != ARM_AM::rrx)
2465     Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
2466                                                          ShiftReg, Imm,
2467                                                S, Parser.getTok().getLoc()));
2468   else
2469     Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm,
2470                                                S, Parser.getTok().getLoc()));
2471
2472   return 0;
2473 }
2474
2475
2476 /// Try to parse a register name.  The token must be an Identifier when called.
2477 /// If it's a register, an AsmOperand is created. Another AsmOperand is created
2478 /// if there is a "writeback". 'true' if it's not a register.
2479 ///
2480 /// TODO this is likely to change to allow different register types and or to
2481 /// parse for a specific register type.
2482 bool ARMAsmParser::
2483 tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2484   SMLoc S = Parser.getTok().getLoc();
2485   int RegNo = tryParseRegister();
2486   if (RegNo == -1)
2487     return true;
2488
2489   Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
2490
2491   const AsmToken &ExclaimTok = Parser.getTok();
2492   if (ExclaimTok.is(AsmToken::Exclaim)) {
2493     Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
2494                                                ExclaimTok.getLoc()));
2495     Parser.Lex(); // Eat exclaim token
2496     return false;
2497   }
2498
2499   // Also check for an index operand. This is only legal for vector registers,
2500   // but that'll get caught OK in operand matching, so we don't need to
2501   // explicitly filter everything else out here.
2502   if (Parser.getTok().is(AsmToken::LBrac)) {
2503     SMLoc SIdx = Parser.getTok().getLoc();
2504     Parser.Lex(); // Eat left bracket token.
2505
2506     const MCExpr *ImmVal;
2507     if (getParser().ParseExpression(ImmVal))
2508       return MatchOperand_ParseFail;
2509     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2510     if (!MCE) {
2511       TokError("immediate value expected for vector index");
2512       return MatchOperand_ParseFail;
2513     }
2514
2515     SMLoc E = Parser.getTok().getLoc();
2516     if (Parser.getTok().isNot(AsmToken::RBrac)) {
2517       Error(E, "']' expected");
2518       return MatchOperand_ParseFail;
2519     }
2520
2521     Parser.Lex(); // Eat right bracket token.
2522
2523     Operands.push_back(ARMOperand::CreateVectorIndex(MCE->getValue(),
2524                                                      SIdx, E,
2525                                                      getContext()));
2526   }
2527
2528   return false;
2529 }
2530
2531 /// MatchCoprocessorOperandName - Try to parse an coprocessor related
2532 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
2533 /// "c5", ...
2534 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
2535   // Use the same layout as the tablegen'erated register name matcher. Ugly,
2536   // but efficient.
2537   switch (Name.size()) {
2538   default: return -1;
2539   case 2:
2540     if (Name[0] != CoprocOp)
2541       return -1;
2542     switch (Name[1]) {
2543     default:  return -1;
2544     case '0': return 0;
2545     case '1': return 1;
2546     case '2': return 2;
2547     case '3': return 3;
2548     case '4': return 4;
2549     case '5': return 5;
2550     case '6': return 6;
2551     case '7': return 7;
2552     case '8': return 8;
2553     case '9': return 9;
2554     }
2555   case 3:
2556     if (Name[0] != CoprocOp || Name[1] != '1')
2557       return -1;
2558     switch (Name[2]) {
2559     default:  return -1;
2560     case '0': return 10;
2561     case '1': return 11;
2562     case '2': return 12;
2563     case '3': return 13;
2564     case '4': return 14;
2565     case '5': return 15;
2566     }
2567   }
2568 }
2569
2570 /// parseITCondCode - Try to parse a condition code for an IT instruction.
2571 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2572 parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2573   SMLoc S = Parser.getTok().getLoc();
2574   const AsmToken &Tok = Parser.getTok();
2575   if (!Tok.is(AsmToken::Identifier))
2576     return MatchOperand_NoMatch;
2577   unsigned CC = StringSwitch<unsigned>(Tok.getString())
2578     .Case("eq", ARMCC::EQ)
2579     .Case("ne", ARMCC::NE)
2580     .Case("hs", ARMCC::HS)
2581     .Case("cs", ARMCC::HS)
2582     .Case("lo", ARMCC::LO)
2583     .Case("cc", ARMCC::LO)
2584     .Case("mi", ARMCC::MI)
2585     .Case("pl", ARMCC::PL)
2586     .Case("vs", ARMCC::VS)
2587     .Case("vc", ARMCC::VC)
2588     .Case("hi", ARMCC::HI)
2589     .Case("ls", ARMCC::LS)
2590     .Case("ge", ARMCC::GE)
2591     .Case("lt", ARMCC::LT)
2592     .Case("gt", ARMCC::GT)
2593     .Case("le", ARMCC::LE)
2594     .Case("al", ARMCC::AL)
2595     .Default(~0U);
2596   if (CC == ~0U)
2597     return MatchOperand_NoMatch;
2598   Parser.Lex(); // Eat the token.
2599
2600   Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), S));
2601
2602   return MatchOperand_Success;
2603 }
2604
2605 /// parseCoprocNumOperand - Try to parse an coprocessor number operand. The
2606 /// token must be an Identifier when called, and if it is a coprocessor
2607 /// number, the token is eaten and the operand is added to the operand list.
2608 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2609 parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2610   SMLoc S = Parser.getTok().getLoc();
2611   const AsmToken &Tok = Parser.getTok();
2612   if (Tok.isNot(AsmToken::Identifier))
2613     return MatchOperand_NoMatch;
2614
2615   int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
2616   if (Num == -1)
2617     return MatchOperand_NoMatch;
2618
2619   Parser.Lex(); // Eat identifier token.
2620   Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
2621   return MatchOperand_Success;
2622 }
2623
2624 /// parseCoprocRegOperand - Try to parse an coprocessor register operand. The
2625 /// token must be an Identifier when called, and if it is a coprocessor
2626 /// number, the token is eaten and the operand is added to the operand list.
2627 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2628 parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2629   SMLoc S = Parser.getTok().getLoc();
2630   const AsmToken &Tok = Parser.getTok();
2631   if (Tok.isNot(AsmToken::Identifier))
2632     return MatchOperand_NoMatch;
2633
2634   int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
2635   if (Reg == -1)
2636     return MatchOperand_NoMatch;
2637
2638   Parser.Lex(); // Eat identifier token.
2639   Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
2640   return MatchOperand_Success;
2641 }
2642
2643 /// parseCoprocOptionOperand - Try to parse an coprocessor option operand.
2644 /// coproc_option : '{' imm0_255 '}'
2645 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2646 parseCoprocOptionOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2647   SMLoc S = Parser.getTok().getLoc();
2648
2649   // If this isn't a '{', this isn't a coprocessor immediate operand.
2650   if (Parser.getTok().isNot(AsmToken::LCurly))
2651     return MatchOperand_NoMatch;
2652   Parser.Lex(); // Eat the '{'
2653
2654   const MCExpr *Expr;
2655   SMLoc Loc = Parser.getTok().getLoc();
2656   if (getParser().ParseExpression(Expr)) {
2657     Error(Loc, "illegal expression");
2658     return MatchOperand_ParseFail;
2659   }
2660   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
2661   if (!CE || CE->getValue() < 0 || CE->getValue() > 255) {
2662     Error(Loc, "coprocessor option must be an immediate in range [0, 255]");
2663     return MatchOperand_ParseFail;
2664   }
2665   int Val = CE->getValue();
2666
2667   // Check for and consume the closing '}'
2668   if (Parser.getTok().isNot(AsmToken::RCurly))
2669     return MatchOperand_ParseFail;
2670   SMLoc E = Parser.getTok().getLoc();
2671   Parser.Lex(); // Eat the '}'
2672
2673   Operands.push_back(ARMOperand::CreateCoprocOption(Val, S, E));
2674   return MatchOperand_Success;
2675 }
2676
2677 // For register list parsing, we need to map from raw GPR register numbering
2678 // to the enumeration values. The enumeration values aren't sorted by
2679 // register number due to our using "sp", "lr" and "pc" as canonical names.
2680 static unsigned getNextRegister(unsigned Reg) {
2681   // If this is a GPR, we need to do it manually, otherwise we can rely
2682   // on the sort ordering of the enumeration since the other reg-classes
2683   // are sane.
2684   if (!ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg))
2685     return Reg + 1;
2686   switch(Reg) {
2687   default: assert(0 && "Invalid GPR number!");
2688   case ARM::R0:  return ARM::R1;  case ARM::R1:  return ARM::R2;
2689   case ARM::R2:  return ARM::R3;  case ARM::R3:  return ARM::R4;
2690   case ARM::R4:  return ARM::R5;  case ARM::R5:  return ARM::R6;
2691   case ARM::R6:  return ARM::R7;  case ARM::R7:  return ARM::R8;
2692   case ARM::R8:  return ARM::R9;  case ARM::R9:  return ARM::R10;
2693   case ARM::R10: return ARM::R11; case ARM::R11: return ARM::R12;
2694   case ARM::R12: return ARM::SP;  case ARM::SP:  return ARM::LR;
2695   case ARM::LR:  return ARM::PC;  case ARM::PC:  return ARM::R0;
2696   }
2697 }
2698
2699 // Return the low-subreg of a given Q register.
2700 static unsigned getDRegFromQReg(unsigned QReg) {
2701   switch (QReg) {
2702   default: llvm_unreachable("expected a Q register!");
2703   case ARM::Q0:  return ARM::D0;
2704   case ARM::Q1:  return ARM::D2;
2705   case ARM::Q2:  return ARM::D4;
2706   case ARM::Q3:  return ARM::D6;
2707   case ARM::Q4:  return ARM::D8;
2708   case ARM::Q5:  return ARM::D10;
2709   case ARM::Q6:  return ARM::D12;
2710   case ARM::Q7:  return ARM::D14;
2711   case ARM::Q8:  return ARM::D16;
2712   case ARM::Q9:  return ARM::D18;
2713   case ARM::Q10: return ARM::D20;
2714   case ARM::Q11: return ARM::D22;
2715   case ARM::Q12: return ARM::D24;
2716   case ARM::Q13: return ARM::D26;
2717   case ARM::Q14: return ARM::D28;
2718   case ARM::Q15: return ARM::D30;
2719   }
2720 }
2721
2722 /// Parse a register list.
2723 bool ARMAsmParser::
2724 parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2725   assert(Parser.getTok().is(AsmToken::LCurly) &&
2726          "Token is not a Left Curly Brace");
2727   SMLoc S = Parser.getTok().getLoc();
2728   Parser.Lex(); // Eat '{' token.
2729   SMLoc RegLoc = Parser.getTok().getLoc();
2730
2731   // Check the first register in the list to see what register class
2732   // this is a list of.
2733   int Reg = tryParseRegister();
2734   if (Reg == -1)
2735     return Error(RegLoc, "register expected");
2736
2737   // The reglist instructions have at most 16 registers, so reserve
2738   // space for that many.
2739   SmallVector<std::pair<unsigned, SMLoc>, 16> Registers;
2740
2741   // Allow Q regs and just interpret them as the two D sub-registers.
2742   if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2743     Reg = getDRegFromQReg(Reg);
2744     Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2745     ++Reg;
2746   }
2747   const MCRegisterClass *RC;
2748   if (ARMMCRegisterClasses[ARM::GPRRegClassID].contains(Reg))
2749     RC = &ARMMCRegisterClasses[ARM::GPRRegClassID];
2750   else if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg))
2751     RC = &ARMMCRegisterClasses[ARM::DPRRegClassID];
2752   else if (ARMMCRegisterClasses[ARM::SPRRegClassID].contains(Reg))
2753     RC = &ARMMCRegisterClasses[ARM::SPRRegClassID];
2754   else
2755     return Error(RegLoc, "invalid register in register list");
2756
2757   // Store the register.
2758   Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2759
2760   // This starts immediately after the first register token in the list,
2761   // so we can see either a comma or a minus (range separator) as a legal
2762   // next token.
2763   while (Parser.getTok().is(AsmToken::Comma) ||
2764          Parser.getTok().is(AsmToken::Minus)) {
2765     if (Parser.getTok().is(AsmToken::Minus)) {
2766       Parser.Lex(); // Eat the minus.
2767       SMLoc EndLoc = Parser.getTok().getLoc();
2768       int EndReg = tryParseRegister();
2769       if (EndReg == -1)
2770         return Error(EndLoc, "register expected");
2771       // Allow Q regs and just interpret them as the two D sub-registers.
2772       if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(EndReg))
2773         EndReg = getDRegFromQReg(EndReg) + 1;
2774       // If the register is the same as the start reg, there's nothing
2775       // more to do.
2776       if (Reg == EndReg)
2777         continue;
2778       // The register must be in the same register class as the first.
2779       if (!RC->contains(EndReg))
2780         return Error(EndLoc, "invalid register in register list");
2781       // Ranges must go from low to high.
2782       if (getARMRegisterNumbering(Reg) > getARMRegisterNumbering(EndReg))
2783         return Error(EndLoc, "bad range in register list");
2784
2785       // Add all the registers in the range to the register list.
2786       while (Reg != EndReg) {
2787         Reg = getNextRegister(Reg);
2788         Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2789       }
2790       continue;
2791     }
2792     Parser.Lex(); // Eat the comma.
2793     RegLoc = Parser.getTok().getLoc();
2794     int OldReg = Reg;
2795     const AsmToken RegTok = Parser.getTok();
2796     Reg = tryParseRegister();
2797     if (Reg == -1)
2798       return Error(RegLoc, "register expected");
2799     // Allow Q regs and just interpret them as the two D sub-registers.
2800     bool isQReg = false;
2801     if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2802       Reg = getDRegFromQReg(Reg);
2803       isQReg = true;
2804     }
2805     // The register must be in the same register class as the first.
2806     if (!RC->contains(Reg))
2807       return Error(RegLoc, "invalid register in register list");
2808     // List must be monotonically increasing.
2809     if (getARMRegisterNumbering(Reg) < getARMRegisterNumbering(OldReg))
2810       return Error(RegLoc, "register list not in ascending order");
2811     if (getARMRegisterNumbering(Reg) == getARMRegisterNumbering(OldReg)) {
2812       Warning(RegLoc, "duplicated register (" + RegTok.getString() +
2813               ") in register list");
2814       continue;
2815     }
2816     // VFP register lists must also be contiguous.
2817     // It's OK to use the enumeration values directly here rather, as the
2818     // VFP register classes have the enum sorted properly.
2819     if (RC != &ARMMCRegisterClasses[ARM::GPRRegClassID] &&
2820         Reg != OldReg + 1)
2821       return Error(RegLoc, "non-contiguous register range");
2822     Registers.push_back(std::pair<unsigned, SMLoc>(Reg, RegLoc));
2823     if (isQReg)
2824       Registers.push_back(std::pair<unsigned, SMLoc>(++Reg, RegLoc));
2825   }
2826
2827   SMLoc E = Parser.getTok().getLoc();
2828   if (Parser.getTok().isNot(AsmToken::RCurly))
2829     return Error(E, "'}' expected");
2830   Parser.Lex(); // Eat '}' token.
2831
2832   // Push the register list operand.
2833   Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
2834
2835   // The ARM system instruction variants for LDM/STM have a '^' token here.
2836   if (Parser.getTok().is(AsmToken::Caret)) {
2837     Operands.push_back(ARMOperand::CreateToken("^",Parser.getTok().getLoc()));
2838     Parser.Lex(); // Eat '^' token.
2839   }
2840
2841   return false;
2842 }
2843
2844 // Helper function to parse the lane index for vector lists.
2845 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2846 parseVectorLane(VectorLaneTy &LaneKind, unsigned &Index) {
2847   Index = 0; // Always return a defined index value.
2848   if (Parser.getTok().is(AsmToken::LBrac)) {
2849     Parser.Lex(); // Eat the '['.
2850     if (Parser.getTok().is(AsmToken::RBrac)) {
2851       // "Dn[]" is the 'all lanes' syntax.
2852       LaneKind = AllLanes;
2853       Parser.Lex(); // Eat the ']'.
2854       return MatchOperand_Success;
2855     }
2856     const MCExpr *LaneIndex;
2857     SMLoc Loc = Parser.getTok().getLoc();
2858     if (getParser().ParseExpression(LaneIndex)) {
2859       Error(Loc, "illegal expression");
2860       return MatchOperand_ParseFail;
2861     }
2862     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LaneIndex);
2863     if (!CE) {
2864       Error(Loc, "lane index must be empty or an integer");
2865       return MatchOperand_ParseFail;
2866     }
2867     if (Parser.getTok().isNot(AsmToken::RBrac)) {
2868       Error(Parser.getTok().getLoc(), "']' expected");
2869       return MatchOperand_ParseFail;
2870     }
2871     Parser.Lex(); // Eat the ']'.
2872     int64_t Val = CE->getValue();
2873
2874     // FIXME: Make this range check context sensitive for .8, .16, .32.
2875     if (Val < 0 || Val > 7) {
2876       Error(Parser.getTok().getLoc(), "lane index out of range");
2877       return MatchOperand_ParseFail;
2878     }
2879     Index = Val;
2880     LaneKind = IndexedLane;
2881     return MatchOperand_Success;
2882   }
2883   LaneKind = NoLanes;
2884   return MatchOperand_Success;
2885 }
2886
2887 // parse a vector register list
2888 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2889 parseVectorList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2890   VectorLaneTy LaneKind;
2891   unsigned LaneIndex;
2892   SMLoc S = Parser.getTok().getLoc();
2893   // As an extension (to match gas), support a plain D register or Q register
2894   // (without encosing curly braces) as a single or double entry list,
2895   // respectively.
2896   if (Parser.getTok().is(AsmToken::Identifier)) {
2897     int Reg = tryParseRegister();
2898     if (Reg == -1)
2899       return MatchOperand_NoMatch;
2900     SMLoc E = Parser.getTok().getLoc();
2901     if (ARMMCRegisterClasses[ARM::DPRRegClassID].contains(Reg)) {
2902       OperandMatchResultTy Res = parseVectorLane(LaneKind, LaneIndex);
2903       if (Res != MatchOperand_Success)
2904         return Res;
2905       switch (LaneKind) {
2906       case NoLanes:
2907         E = Parser.getTok().getLoc();
2908         Operands.push_back(ARMOperand::CreateVectorList(Reg, 1, false, S, E));
2909         break;
2910       case AllLanes:
2911         E = Parser.getTok().getLoc();
2912         Operands.push_back(ARMOperand::CreateVectorListAllLanes(Reg, 1, false,
2913                                                                 S, E));
2914         break;
2915       case IndexedLane:
2916         Operands.push_back(ARMOperand::CreateVectorListIndexed(Reg, 1,
2917                                                                LaneIndex,
2918                                                                false, S, E));
2919         break;
2920       }
2921       return MatchOperand_Success;
2922     }
2923     if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2924       Reg = getDRegFromQReg(Reg);
2925       OperandMatchResultTy Res = parseVectorLane(LaneKind, LaneIndex);
2926       if (Res != MatchOperand_Success)
2927         return Res;
2928       switch (LaneKind) {
2929       case NoLanes:
2930         E = Parser.getTok().getLoc();
2931         Operands.push_back(ARMOperand::CreateVectorList(Reg, 2, false, S, E));
2932         break;
2933       case AllLanes:
2934         E = Parser.getTok().getLoc();
2935         Operands.push_back(ARMOperand::CreateVectorListAllLanes(Reg, 2, false,
2936                                                                 S, E));
2937         break;
2938       case IndexedLane:
2939         Operands.push_back(ARMOperand::CreateVectorListIndexed(Reg, 2,
2940                                                                LaneIndex,
2941                                                                false, S, E));
2942         break;
2943       }
2944       return MatchOperand_Success;
2945     }
2946     Error(S, "vector register expected");
2947     return MatchOperand_ParseFail;
2948   }
2949
2950   if (Parser.getTok().isNot(AsmToken::LCurly))
2951     return MatchOperand_NoMatch;
2952
2953   Parser.Lex(); // Eat '{' token.
2954   SMLoc RegLoc = Parser.getTok().getLoc();
2955
2956   int Reg = tryParseRegister();
2957   if (Reg == -1) {
2958     Error(RegLoc, "register expected");
2959     return MatchOperand_ParseFail;
2960   }
2961   unsigned Count = 1;
2962   int Spacing = 0;
2963   unsigned FirstReg = Reg;
2964   // The list is of D registers, but we also allow Q regs and just interpret
2965   // them as the two D sub-registers.
2966   if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
2967     FirstReg = Reg = getDRegFromQReg(Reg);
2968     Spacing = 1; // double-spacing requires explicit D registers, otherwise
2969                  // it's ambiguous with four-register single spaced.
2970     ++Reg;
2971     ++Count;
2972   }
2973   if (parseVectorLane(LaneKind, LaneIndex) != MatchOperand_Success)
2974     return MatchOperand_ParseFail;
2975
2976   while (Parser.getTok().is(AsmToken::Comma) ||
2977          Parser.getTok().is(AsmToken::Minus)) {
2978     if (Parser.getTok().is(AsmToken::Minus)) {
2979       if (!Spacing)
2980         Spacing = 1; // Register range implies a single spaced list.
2981       else if (Spacing == 2) {
2982         Error(Parser.getTok().getLoc(),
2983               "sequential registers in double spaced list");
2984         return MatchOperand_ParseFail;
2985       }
2986       Parser.Lex(); // Eat the minus.
2987       SMLoc EndLoc = Parser.getTok().getLoc();
2988       int EndReg = tryParseRegister();
2989       if (EndReg == -1) {
2990         Error(EndLoc, "register expected");
2991         return MatchOperand_ParseFail;
2992       }
2993       // Allow Q regs and just interpret them as the two D sub-registers.
2994       if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(EndReg))
2995         EndReg = getDRegFromQReg(EndReg) + 1;
2996       // If the register is the same as the start reg, there's nothing
2997       // more to do.
2998       if (Reg == EndReg)
2999         continue;
3000       // The register must be in the same register class as the first.
3001       if (!ARMMCRegisterClasses[ARM::DPRRegClassID].contains(EndReg)) {
3002         Error(EndLoc, "invalid register in register list");
3003         return MatchOperand_ParseFail;
3004       }
3005       // Ranges must go from low to high.
3006       if (Reg > EndReg) {
3007         Error(EndLoc, "bad range in register list");
3008         return MatchOperand_ParseFail;
3009       }
3010       // Parse the lane specifier if present.
3011       VectorLaneTy NextLaneKind;
3012       unsigned NextLaneIndex;
3013       if (parseVectorLane(NextLaneKind, NextLaneIndex) != MatchOperand_Success)
3014         return MatchOperand_ParseFail;
3015       if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) {
3016         Error(EndLoc, "mismatched lane index in register list");
3017         return MatchOperand_ParseFail;
3018       }
3019       EndLoc = Parser.getTok().getLoc();
3020
3021       // Add all the registers in the range to the register list.
3022       Count += EndReg - Reg;
3023       Reg = EndReg;
3024       continue;
3025     }
3026     Parser.Lex(); // Eat the comma.
3027     RegLoc = Parser.getTok().getLoc();
3028     int OldReg = Reg;
3029     Reg = tryParseRegister();
3030     if (Reg == -1) {
3031       Error(RegLoc, "register expected");
3032       return MatchOperand_ParseFail;
3033     }
3034     // vector register lists must be contiguous.
3035     // It's OK to use the enumeration values directly here rather, as the
3036     // VFP register classes have the enum sorted properly.
3037     //
3038     // The list is of D registers, but we also allow Q regs and just interpret
3039     // them as the two D sub-registers.
3040     if (ARMMCRegisterClasses[ARM::QPRRegClassID].contains(Reg)) {
3041       if (!Spacing)
3042         Spacing = 1; // Register range implies a single spaced list.
3043       else if (Spacing == 2) {
3044         Error(RegLoc,
3045               "invalid register in double-spaced list (must be 'D' register')");
3046         return MatchOperand_ParseFail;
3047       }
3048       Reg = getDRegFromQReg(Reg);
3049       if (Reg != OldReg + 1) {
3050         Error(RegLoc, "non-contiguous register range");
3051         return MatchOperand_ParseFail;
3052       }
3053       ++Reg;
3054       Count += 2;
3055       // Parse the lane specifier if present.
3056       VectorLaneTy NextLaneKind;
3057       unsigned NextLaneIndex;
3058       SMLoc EndLoc = Parser.getTok().getLoc();
3059       if (parseVectorLane(NextLaneKind, NextLaneIndex) != MatchOperand_Success)
3060         return MatchOperand_ParseFail;
3061       if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) {
3062         Error(EndLoc, "mismatched lane index in register list");
3063         return MatchOperand_ParseFail;
3064       }
3065       continue;
3066     }
3067     // Normal D register.
3068     // Figure out the register spacing (single or double) of the list if
3069     // we don't know it already.
3070     if (!Spacing)
3071       Spacing = 1 + (Reg == OldReg + 2);
3072
3073     // Just check that it's contiguous and keep going.
3074     if (Reg != OldReg + Spacing) {
3075       Error(RegLoc, "non-contiguous register range");
3076       return MatchOperand_ParseFail;
3077     }
3078     ++Count;
3079     // Parse the lane specifier if present.
3080     VectorLaneTy NextLaneKind;
3081     unsigned NextLaneIndex;
3082     SMLoc EndLoc = Parser.getTok().getLoc();
3083     if (parseVectorLane(NextLaneKind, NextLaneIndex) != MatchOperand_Success)
3084       return MatchOperand_ParseFail;
3085     if (NextLaneKind != LaneKind || LaneIndex != NextLaneIndex) {
3086       Error(EndLoc, "mismatched lane index in register list");
3087       return MatchOperand_ParseFail;
3088     }
3089   }
3090
3091   SMLoc E = Parser.getTok().getLoc();
3092   if (Parser.getTok().isNot(AsmToken::RCurly)) {
3093     Error(E, "'}' expected");
3094     return MatchOperand_ParseFail;
3095   }
3096   Parser.Lex(); // Eat '}' token.
3097
3098   switch (LaneKind) {
3099   case NoLanes:
3100     Operands.push_back(ARMOperand::CreateVectorList(FirstReg, Count,
3101                                                     (Spacing == 2), S, E));
3102     break;
3103   case AllLanes:
3104     Operands.push_back(ARMOperand::CreateVectorListAllLanes(FirstReg, Count,
3105                                                             (Spacing == 2),
3106                                                             S, E));
3107     break;
3108   case IndexedLane:
3109     Operands.push_back(ARMOperand::CreateVectorListIndexed(FirstReg, Count,
3110                                                            LaneIndex,
3111                                                            (Spacing == 2),
3112                                                            S, E));
3113     break;
3114   }
3115   return MatchOperand_Success;
3116 }
3117
3118 /// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
3119 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3120 parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3121   SMLoc S = Parser.getTok().getLoc();
3122   const AsmToken &Tok = Parser.getTok();
3123   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
3124   StringRef OptStr = Tok.getString();
3125
3126   unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
3127     .Case("sy",    ARM_MB::SY)
3128     .Case("st",    ARM_MB::ST)
3129     .Case("sh",    ARM_MB::ISH)
3130     .Case("ish",   ARM_MB::ISH)
3131     .Case("shst",  ARM_MB::ISHST)
3132     .Case("ishst", ARM_MB::ISHST)
3133     .Case("nsh",   ARM_MB::NSH)
3134     .Case("un",    ARM_MB::NSH)
3135     .Case("nshst", ARM_MB::NSHST)
3136     .Case("unst",  ARM_MB::NSHST)
3137     .Case("osh",   ARM_MB::OSH)
3138     .Case("oshst", ARM_MB::OSHST)
3139     .Default(~0U);
3140
3141   if (Opt == ~0U)
3142     return MatchOperand_NoMatch;
3143
3144   Parser.Lex(); // Eat identifier token.
3145   Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
3146   return MatchOperand_Success;
3147 }
3148
3149 /// parseProcIFlagsOperand - Try to parse iflags from CPS instruction.
3150 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3151 parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3152   SMLoc S = Parser.getTok().getLoc();
3153   const AsmToken &Tok = Parser.getTok();
3154   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
3155   StringRef IFlagsStr = Tok.getString();
3156
3157   // An iflags string of "none" is interpreted to mean that none of the AIF
3158   // bits are set.  Not a terribly useful instruction, but a valid encoding.
3159   unsigned IFlags = 0;
3160   if (IFlagsStr != "none") {
3161         for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
3162       unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
3163         .Case("a", ARM_PROC::A)
3164         .Case("i", ARM_PROC::I)
3165         .Case("f", ARM_PROC::F)
3166         .Default(~0U);
3167
3168       // If some specific iflag is already set, it means that some letter is
3169       // present more than once, this is not acceptable.
3170       if (Flag == ~0U || (IFlags & Flag))
3171         return MatchOperand_NoMatch;
3172
3173       IFlags |= Flag;
3174     }
3175   }
3176
3177   Parser.Lex(); // Eat identifier token.
3178   Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
3179   return MatchOperand_Success;
3180 }
3181
3182 /// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
3183 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3184 parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3185   SMLoc S = Parser.getTok().getLoc();
3186   const AsmToken &Tok = Parser.getTok();
3187   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
3188   StringRef Mask = Tok.getString();
3189
3190   if (isMClass()) {
3191     // See ARMv6-M 10.1.1
3192     unsigned FlagsVal = StringSwitch<unsigned>(Mask)
3193       .Case("apsr", 0)
3194       .Case("iapsr", 1)
3195       .Case("eapsr", 2)
3196       .Case("xpsr", 3)
3197       .Case("ipsr", 5)
3198       .Case("epsr", 6)
3199       .Case("iepsr", 7)
3200       .Case("msp", 8)
3201       .Case("psp", 9)
3202       .Case("primask", 16)
3203       .Case("basepri", 17)
3204       .Case("basepri_max", 18)
3205       .Case("faultmask", 19)
3206       .Case("control", 20)
3207       .Default(~0U);
3208
3209     if (FlagsVal == ~0U)
3210       return MatchOperand_NoMatch;
3211
3212     if (!hasV7Ops() && FlagsVal >= 17 && FlagsVal <= 19)
3213       // basepri, basepri_max and faultmask only valid for V7m.
3214       return MatchOperand_NoMatch;
3215
3216     Parser.Lex(); // Eat identifier token.
3217     Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
3218     return MatchOperand_Success;
3219   }
3220
3221   // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
3222   size_t Start = 0, Next = Mask.find('_');
3223   StringRef Flags = "";
3224   std::string SpecReg = Mask.slice(Start, Next).lower();
3225   if (Next != StringRef::npos)
3226     Flags = Mask.slice(Next+1, Mask.size());
3227
3228   // FlagsVal contains the complete mask:
3229   // 3-0: Mask
3230   // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
3231   unsigned FlagsVal = 0;
3232
3233   if (SpecReg == "apsr") {
3234     FlagsVal = StringSwitch<unsigned>(Flags)
3235     .Case("nzcvq",  0x8) // same as CPSR_f
3236     .Case("g",      0x4) // same as CPSR_s
3237     .Case("nzcvqg", 0xc) // same as CPSR_fs
3238     .Default(~0U);
3239
3240     if (FlagsVal == ~0U) {
3241       if (!Flags.empty())
3242         return MatchOperand_NoMatch;
3243       else
3244         FlagsVal = 8; // No flag
3245     }
3246   } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
3247     if (Flags == "all") // cpsr_all is an alias for cpsr_fc
3248       Flags = "fc";
3249     for (int i = 0, e = Flags.size(); i != e; ++i) {
3250       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
3251       .Case("c", 1)
3252       .Case("x", 2)
3253       .Case("s", 4)
3254       .Case("f", 8)
3255       .Default(~0U);
3256
3257       // If some specific flag is already set, it means that some letter is
3258       // present more than once, this is not acceptable.
3259       if (FlagsVal == ~0U || (FlagsVal & Flag))
3260         return MatchOperand_NoMatch;
3261       FlagsVal |= Flag;
3262     }
3263   } else // No match for special register.
3264     return MatchOperand_NoMatch;
3265
3266   // Special register without flags is NOT equivalent to "fc" flags.
3267   // NOTE: This is a divergence from gas' behavior.  Uncommenting the following
3268   // two lines would enable gas compatibility at the expense of breaking
3269   // round-tripping.
3270   //
3271   // if (!FlagsVal)
3272   //  FlagsVal = 0x9;
3273
3274   // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
3275   if (SpecReg == "spsr")
3276     FlagsVal |= 16;
3277
3278   Parser.Lex(); // Eat identifier token.
3279   Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
3280   return MatchOperand_Success;
3281 }
3282
3283 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3284 parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op,
3285             int Low, int High) {
3286   const AsmToken &Tok = Parser.getTok();
3287   if (Tok.isNot(AsmToken::Identifier)) {
3288     Error(Parser.getTok().getLoc(), Op + " operand expected.");
3289     return MatchOperand_ParseFail;
3290   }
3291   StringRef ShiftName = Tok.getString();
3292   std::string LowerOp = Op.lower();
3293   std::string UpperOp = Op.upper();
3294   if (ShiftName != LowerOp && ShiftName != UpperOp) {
3295     Error(Parser.getTok().getLoc(), Op + " operand expected.");
3296     return MatchOperand_ParseFail;
3297   }
3298   Parser.Lex(); // Eat shift type token.
3299
3300   // There must be a '#' and a shift amount.
3301   if (Parser.getTok().isNot(AsmToken::Hash) &&
3302       Parser.getTok().isNot(AsmToken::Dollar)) {
3303     Error(Parser.getTok().getLoc(), "'#' expected");
3304     return MatchOperand_ParseFail;
3305   }
3306   Parser.Lex(); // Eat hash token.
3307
3308   const MCExpr *ShiftAmount;
3309   SMLoc Loc = Parser.getTok().getLoc();
3310   if (getParser().ParseExpression(ShiftAmount)) {
3311     Error(Loc, "illegal expression");
3312     return MatchOperand_ParseFail;
3313   }
3314   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
3315   if (!CE) {
3316     Error(Loc, "constant expression expected");
3317     return MatchOperand_ParseFail;
3318   }
3319   int Val = CE->getValue();
3320   if (Val < Low || Val > High) {
3321     Error(Loc, "immediate value out of range");
3322     return MatchOperand_ParseFail;
3323   }
3324
3325   Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc()));
3326
3327   return MatchOperand_Success;
3328 }
3329
3330 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3331 parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3332   const AsmToken &Tok = Parser.getTok();
3333   SMLoc S = Tok.getLoc();
3334   if (Tok.isNot(AsmToken::Identifier)) {
3335     Error(Tok.getLoc(), "'be' or 'le' operand expected");
3336     return MatchOperand_ParseFail;
3337   }
3338   int Val = StringSwitch<int>(Tok.getString())
3339     .Case("be", 1)
3340     .Case("le", 0)
3341     .Default(-1);
3342   Parser.Lex(); // Eat the token.
3343
3344   if (Val == -1) {
3345     Error(Tok.getLoc(), "'be' or 'le' operand expected");
3346     return MatchOperand_ParseFail;
3347   }
3348   Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val,
3349                                                                   getContext()),
3350                                            S, Parser.getTok().getLoc()));
3351   return MatchOperand_Success;
3352 }
3353
3354 /// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT
3355 /// instructions. Legal values are:
3356 ///     lsl #n  'n' in [0,31]
3357 ///     asr #n  'n' in [1,32]
3358 ///             n == 32 encoded as n == 0.
3359 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3360 parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3361   const AsmToken &Tok = Parser.getTok();
3362   SMLoc S = Tok.getLoc();
3363   if (Tok.isNot(AsmToken::Identifier)) {
3364     Error(S, "shift operator 'asr' or 'lsl' expected");
3365     return MatchOperand_ParseFail;
3366   }
3367   StringRef ShiftName = Tok.getString();
3368   bool isASR;
3369   if (ShiftName == "lsl" || ShiftName == "LSL")
3370     isASR = false;
3371   else if (ShiftName == "asr" || ShiftName == "ASR")
3372     isASR = true;
3373   else {
3374     Error(S, "shift operator 'asr' or 'lsl' expected");
3375     return MatchOperand_ParseFail;
3376   }
3377   Parser.Lex(); // Eat the operator.
3378
3379   // A '#' and a shift amount.
3380   if (Parser.getTok().isNot(AsmToken::Hash) &&
3381       Parser.getTok().isNot(AsmToken::Dollar)) {
3382     Error(Parser.getTok().getLoc(), "'#' expected");
3383     return MatchOperand_ParseFail;
3384   }
3385   Parser.Lex(); // Eat hash token.
3386
3387   const MCExpr *ShiftAmount;
3388   SMLoc E = Parser.getTok().getLoc();
3389   if (getParser().ParseExpression(ShiftAmount)) {
3390     Error(E, "malformed shift expression");
3391     return MatchOperand_ParseFail;
3392   }
3393   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
3394   if (!CE) {
3395     Error(E, "shift amount must be an immediate");
3396     return MatchOperand_ParseFail;
3397   }
3398
3399   int64_t Val = CE->getValue();
3400   if (isASR) {
3401     // Shift amount must be in [1,32]
3402     if (Val < 1 || Val > 32) {
3403       Error(E, "'asr' shift amount must be in range [1,32]");
3404       return MatchOperand_ParseFail;
3405     }
3406     // asr #32 encoded as asr #0, but is not allowed in Thumb2 mode.
3407     if (isThumb() && Val == 32) {
3408       Error(E, "'asr #32' shift amount not allowed in Thumb mode");
3409       return MatchOperand_ParseFail;
3410     }
3411     if (Val == 32) Val = 0;
3412   } else {
3413     // Shift amount must be in [1,32]
3414     if (Val < 0 || Val > 31) {
3415       Error(E, "'lsr' shift amount must be in range [0,31]");
3416       return MatchOperand_ParseFail;
3417     }
3418   }
3419
3420   E = Parser.getTok().getLoc();
3421   Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E));
3422
3423   return MatchOperand_Success;
3424 }
3425
3426 /// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family
3427 /// of instructions. Legal values are:
3428 ///     ror #n  'n' in {0, 8, 16, 24}
3429 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3430 parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3431   const AsmToken &Tok = Parser.getTok();
3432   SMLoc S = Tok.getLoc();
3433   if (Tok.isNot(AsmToken::Identifier))
3434     return MatchOperand_NoMatch;
3435   StringRef ShiftName = Tok.getString();
3436   if (ShiftName != "ror" && ShiftName != "ROR")
3437     return MatchOperand_NoMatch;
3438   Parser.Lex(); // Eat the operator.
3439
3440   // A '#' and a rotate amount.
3441   if (Parser.getTok().isNot(AsmToken::Hash) &&
3442       Parser.getTok().isNot(AsmToken::Dollar)) {
3443     Error(Parser.getTok().getLoc(), "'#' expected");
3444     return MatchOperand_ParseFail;
3445   }
3446   Parser.Lex(); // Eat hash token.
3447
3448   const MCExpr *ShiftAmount;
3449   SMLoc E = Parser.getTok().getLoc();
3450   if (getParser().ParseExpression(ShiftAmount)) {
3451     Error(E, "malformed rotate expression");
3452     return MatchOperand_ParseFail;
3453   }
3454   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
3455   if (!CE) {
3456     Error(E, "rotate amount must be an immediate");
3457     return MatchOperand_ParseFail;
3458   }
3459
3460   int64_t Val = CE->getValue();
3461   // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension)
3462   // normally, zero is represented in asm by omitting the rotate operand
3463   // entirely.
3464   if (Val != 8 && Val != 16 && Val != 24 && Val != 0) {
3465     Error(E, "'ror' rotate amount must be 8, 16, or 24");
3466     return MatchOperand_ParseFail;
3467   }
3468
3469   E = Parser.getTok().getLoc();
3470   Operands.push_back(ARMOperand::CreateRotImm(Val, S, E));
3471
3472   return MatchOperand_Success;
3473 }
3474
3475 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3476 parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3477   SMLoc S = Parser.getTok().getLoc();
3478   // The bitfield descriptor is really two operands, the LSB and the width.
3479   if (Parser.getTok().isNot(AsmToken::Hash) &&
3480       Parser.getTok().isNot(AsmToken::Dollar)) {
3481     Error(Parser.getTok().getLoc(), "'#' expected");
3482     return MatchOperand_ParseFail;
3483   }
3484   Parser.Lex(); // Eat hash token.
3485
3486   const MCExpr *LSBExpr;
3487   SMLoc E = Parser.getTok().getLoc();
3488   if (getParser().ParseExpression(LSBExpr)) {
3489     Error(E, "malformed immediate expression");
3490     return MatchOperand_ParseFail;
3491   }
3492   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr);
3493   if (!CE) {
3494     Error(E, "'lsb' operand must be an immediate");
3495     return MatchOperand_ParseFail;
3496   }
3497
3498   int64_t LSB = CE->getValue();
3499   // The LSB must be in the range [0,31]
3500   if (LSB < 0 || LSB > 31) {
3501     Error(E, "'lsb' operand must be in the range [0,31]");
3502     return MatchOperand_ParseFail;
3503   }
3504   E = Parser.getTok().getLoc();
3505
3506   // Expect another immediate operand.
3507   if (Parser.getTok().isNot(AsmToken::Comma)) {
3508     Error(Parser.getTok().getLoc(), "too few operands");
3509     return MatchOperand_ParseFail;
3510   }
3511   Parser.Lex(); // Eat hash token.
3512   if (Parser.getTok().isNot(AsmToken::Hash) &&
3513       Parser.getTok().isNot(AsmToken::Dollar)) {
3514     Error(Parser.getTok().getLoc(), "'#' expected");
3515     return MatchOperand_ParseFail;
3516   }
3517   Parser.Lex(); // Eat hash token.
3518
3519   const MCExpr *WidthExpr;
3520   if (getParser().ParseExpression(WidthExpr)) {
3521     Error(E, "malformed immediate expression");
3522     return MatchOperand_ParseFail;
3523   }
3524   CE = dyn_cast<MCConstantExpr>(WidthExpr);
3525   if (!CE) {
3526     Error(E, "'width' operand must be an immediate");
3527     return MatchOperand_ParseFail;
3528   }
3529
3530   int64_t Width = CE->getValue();
3531   // The LSB must be in the range [1,32-lsb]
3532   if (Width < 1 || Width > 32 - LSB) {
3533     Error(E, "'width' operand must be in the range [1,32-lsb]");
3534     return MatchOperand_ParseFail;
3535   }
3536   E = Parser.getTok().getLoc();
3537
3538   Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, E));
3539
3540   return MatchOperand_Success;
3541 }
3542
3543 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3544 parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3545   // Check for a post-index addressing register operand. Specifically:
3546   // postidx_reg := '+' register {, shift}
3547   //              | '-' register {, shift}
3548   //              | register {, shift}
3549
3550   // This method must return MatchOperand_NoMatch without consuming any tokens
3551   // in the case where there is no match, as other alternatives take other
3552   // parse methods.
3553   AsmToken Tok = Parser.getTok();
3554   SMLoc S = Tok.getLoc();
3555   bool haveEaten = false;
3556   bool isAdd = true;
3557   int Reg = -1;
3558   if (Tok.is(AsmToken::Plus)) {
3559     Parser.Lex(); // Eat the '+' token.
3560     haveEaten = true;
3561   } else if (Tok.is(AsmToken::Minus)) {
3562     Parser.Lex(); // Eat the '-' token.
3563     isAdd = false;
3564     haveEaten = true;
3565   }
3566   if (Parser.getTok().is(AsmToken::Identifier))
3567     Reg = tryParseRegister();
3568   if (Reg == -1) {
3569     if (!haveEaten)
3570       return MatchOperand_NoMatch;
3571     Error(Parser.getTok().getLoc(), "register expected");
3572     return MatchOperand_ParseFail;
3573   }
3574   SMLoc E = Parser.getTok().getLoc();
3575
3576   ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift;
3577   unsigned ShiftImm = 0;
3578   if (Parser.getTok().is(AsmToken::Comma)) {
3579     Parser.Lex(); // Eat the ','.
3580     if (parseMemRegOffsetShift(ShiftTy, ShiftImm))
3581       return MatchOperand_ParseFail;
3582   }
3583
3584   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy,
3585                                                   ShiftImm, S, E));
3586
3587   return MatchOperand_Success;
3588 }
3589
3590 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
3591 parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3592   // Check for a post-index addressing register operand. Specifically:
3593   // am3offset := '+' register
3594   //              | '-' register
3595   //              | register
3596   //              | # imm
3597   //              | # + imm
3598   //              | # - imm
3599
3600   // This method must return MatchOperand_NoMatch without consuming any tokens
3601   // in the case where there is no match, as other alternatives take other
3602   // parse methods.
3603   AsmToken Tok = Parser.getTok();
3604   SMLoc S = Tok.getLoc();
3605
3606   // Do immediates first, as we always parse those if we have a '#'.
3607   if (Parser.getTok().is(AsmToken::Hash) ||
3608       Parser.getTok().is(AsmToken::Dollar)) {
3609     Parser.Lex(); // Eat the '#'.
3610     // Explicitly look for a '-', as we need to encode negative zero
3611     // differently.
3612     bool isNegative = Parser.getTok().is(AsmToken::Minus);
3613     const MCExpr *Offset;
3614     if (getParser().ParseExpression(Offset))
3615       return MatchOperand_ParseFail;
3616     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
3617     if (!CE) {
3618       Error(S, "constant expression expected");
3619       return MatchOperand_ParseFail;
3620     }
3621     SMLoc E = Tok.getLoc();
3622     // Negative zero is encoded as the flag value INT32_MIN.
3623     int32_t Val = CE->getValue();
3624     if (isNegative && Val == 0)
3625       Val = INT32_MIN;
3626
3627     Operands.push_back(
3628       ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E));
3629
3630     return MatchOperand_Success;
3631   }
3632
3633
3634   bool haveEaten = false;
3635   bool isAdd = true;
3636   int Reg = -1;
3637   if (Tok.is(AsmToken::Plus)) {
3638     Parser.Lex(); // Eat the '+' token.
3639     haveEaten = true;
3640   } else if (Tok.is(AsmToken::Minus)) {
3641     Parser.Lex(); // Eat the '-' token.
3642     isAdd = false;
3643     haveEaten = true;
3644   }
3645   if (Parser.getTok().is(AsmToken::Identifier))
3646     Reg = tryParseRegister();
3647   if (Reg == -1) {
3648     if (!haveEaten)
3649       return MatchOperand_NoMatch;
3650     Error(Parser.getTok().getLoc(), "register expected");
3651     return MatchOperand_ParseFail;
3652   }
3653   SMLoc E = Parser.getTok().getLoc();
3654
3655   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift,
3656                                                   0, S, E));
3657
3658   return MatchOperand_Success;
3659 }
3660
3661 /// cvtT2LdrdPre - Convert parsed operands to MCInst.
3662 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3663 /// when they refer multiple MIOperands inside a single one.
3664 bool ARMAsmParser::
3665 cvtT2LdrdPre(MCInst &Inst, unsigned Opcode,
3666              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3667   // Rt, Rt2
3668   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3669   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3670   // Create a writeback register dummy placeholder.
3671   Inst.addOperand(MCOperand::CreateReg(0));
3672   // addr
3673   ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
3674   // pred
3675   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3676   return true;
3677 }
3678
3679 /// cvtT2StrdPre - Convert parsed operands to MCInst.
3680 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3681 /// when they refer multiple MIOperands inside a single one.
3682 bool ARMAsmParser::
3683 cvtT2StrdPre(MCInst &Inst, unsigned Opcode,
3684              const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3685   // Create a writeback register dummy placeholder.
3686   Inst.addOperand(MCOperand::CreateReg(0));
3687   // Rt, Rt2
3688   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3689   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3690   // addr
3691   ((ARMOperand*)Operands[4])->addMemImm8s4OffsetOperands(Inst, 2);
3692   // pred
3693   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3694   return true;
3695 }
3696
3697 /// cvtLdWriteBackRegT2AddrModeImm8 - Convert parsed operands to MCInst.
3698 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3699 /// when they refer multiple MIOperands inside a single one.
3700 bool ARMAsmParser::
3701 cvtLdWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
3702                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3703   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3704
3705   // Create a writeback register dummy placeholder.
3706   Inst.addOperand(MCOperand::CreateImm(0));
3707
3708   ((ARMOperand*)Operands[3])->addMemImm8OffsetOperands(Inst, 2);
3709   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3710   return true;
3711 }
3712
3713 /// cvtStWriteBackRegT2AddrModeImm8 - Convert parsed operands to MCInst.
3714 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3715 /// when they refer multiple MIOperands inside a single one.
3716 bool ARMAsmParser::
3717 cvtStWriteBackRegT2AddrModeImm8(MCInst &Inst, unsigned Opcode,
3718                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3719   // Create a writeback register dummy placeholder.
3720   Inst.addOperand(MCOperand::CreateImm(0));
3721   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3722   ((ARMOperand*)Operands[3])->addMemImm8OffsetOperands(Inst, 2);
3723   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3724   return true;
3725 }
3726
3727 /// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
3728 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3729 /// when they refer multiple MIOperands inside a single one.
3730 bool ARMAsmParser::
3731 cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
3732                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3733   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3734
3735   // Create a writeback register dummy placeholder.
3736   Inst.addOperand(MCOperand::CreateImm(0));
3737
3738   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
3739   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3740   return true;
3741 }
3742
3743 /// cvtLdWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
3744 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3745 /// when they refer multiple MIOperands inside a single one.
3746 bool ARMAsmParser::
3747 cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
3748                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3749   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3750
3751   // Create a writeback register dummy placeholder.
3752   Inst.addOperand(MCOperand::CreateImm(0));
3753
3754   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
3755   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3756   return true;
3757 }
3758
3759
3760 /// cvtStWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
3761 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3762 /// when they refer multiple MIOperands inside a single one.
3763 bool ARMAsmParser::
3764 cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
3765                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3766   // Create a writeback register dummy placeholder.
3767   Inst.addOperand(MCOperand::CreateImm(0));
3768   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3769   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
3770   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3771   return true;
3772 }
3773
3774 /// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
3775 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3776 /// when they refer multiple MIOperands inside a single one.
3777 bool ARMAsmParser::
3778 cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
3779                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3780   // Create a writeback register dummy placeholder.
3781   Inst.addOperand(MCOperand::CreateImm(0));
3782   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3783   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
3784   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3785   return true;
3786 }
3787
3788 /// cvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
3789 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3790 /// when they refer multiple MIOperands inside a single one.
3791 bool ARMAsmParser::
3792 cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
3793                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3794   // Create a writeback register dummy placeholder.
3795   Inst.addOperand(MCOperand::CreateImm(0));
3796   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3797   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
3798   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3799   return true;
3800 }
3801
3802 /// cvtLdExtTWriteBackImm - Convert parsed operands to MCInst.
3803 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3804 /// when they refer multiple MIOperands inside a single one.
3805 bool ARMAsmParser::
3806 cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
3807                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3808   // Rt
3809   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3810   // Create a writeback register dummy placeholder.
3811   Inst.addOperand(MCOperand::CreateImm(0));
3812   // addr
3813   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3814   // offset
3815   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
3816   // pred
3817   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3818   return true;
3819 }
3820
3821 /// cvtLdExtTWriteBackReg - Convert parsed operands to MCInst.
3822 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3823 /// when they refer multiple MIOperands inside a single one.
3824 bool ARMAsmParser::
3825 cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
3826                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3827   // Rt
3828   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3829   // Create a writeback register dummy placeholder.
3830   Inst.addOperand(MCOperand::CreateImm(0));
3831   // addr
3832   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3833   // offset
3834   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
3835   // pred
3836   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3837   return true;
3838 }
3839
3840 /// cvtStExtTWriteBackImm - Convert parsed operands to MCInst.
3841 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3842 /// when they refer multiple MIOperands inside a single one.
3843 bool ARMAsmParser::
3844 cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
3845                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3846   // Create a writeback register dummy placeholder.
3847   Inst.addOperand(MCOperand::CreateImm(0));
3848   // Rt
3849   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3850   // addr
3851   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3852   // offset
3853   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
3854   // pred
3855   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3856   return true;
3857 }
3858
3859 /// cvtStExtTWriteBackReg - Convert parsed operands to MCInst.
3860 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3861 /// when they refer multiple MIOperands inside a single one.
3862 bool ARMAsmParser::
3863 cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
3864                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3865   // Create a writeback register dummy placeholder.
3866   Inst.addOperand(MCOperand::CreateImm(0));
3867   // Rt
3868   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3869   // addr
3870   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
3871   // offset
3872   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
3873   // pred
3874   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3875   return true;
3876 }
3877
3878 /// cvtLdrdPre - Convert parsed operands to MCInst.
3879 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3880 /// when they refer multiple MIOperands inside a single one.
3881 bool ARMAsmParser::
3882 cvtLdrdPre(MCInst &Inst, unsigned Opcode,
3883            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3884   // Rt, Rt2
3885   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3886   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3887   // Create a writeback register dummy placeholder.
3888   Inst.addOperand(MCOperand::CreateImm(0));
3889   // addr
3890   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
3891   // pred
3892   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3893   return true;
3894 }
3895
3896 /// cvtStrdPre - Convert parsed operands to MCInst.
3897 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3898 /// when they refer multiple MIOperands inside a single one.
3899 bool ARMAsmParser::
3900 cvtStrdPre(MCInst &Inst, unsigned Opcode,
3901            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3902   // Create a writeback register dummy placeholder.
3903   Inst.addOperand(MCOperand::CreateImm(0));
3904   // Rt, Rt2
3905   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3906   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3907   // addr
3908   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
3909   // pred
3910   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3911   return true;
3912 }
3913
3914 /// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
3915 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3916 /// when they refer multiple MIOperands inside a single one.
3917 bool ARMAsmParser::
3918 cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
3919                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3920   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
3921   // Create a writeback register dummy placeholder.
3922   Inst.addOperand(MCOperand::CreateImm(0));
3923   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
3924   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3925   return true;
3926 }
3927
3928 /// cvtThumbMultiple- Convert parsed operands to MCInst.
3929 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
3930 /// when they refer multiple MIOperands inside a single one.
3931 bool ARMAsmParser::
3932 cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
3933            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3934   // The second source operand must be the same register as the destination
3935   // operand.
3936   if (Operands.size() == 6 &&
3937       (((ARMOperand*)Operands[3])->getReg() !=
3938        ((ARMOperand*)Operands[5])->getReg()) &&
3939       (((ARMOperand*)Operands[3])->getReg() !=
3940        ((ARMOperand*)Operands[4])->getReg())) {
3941     Error(Operands[3]->getStartLoc(),
3942           "destination register must match source register");
3943     return false;
3944   }
3945   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
3946   ((ARMOperand*)Operands[1])->addCCOutOperands(Inst, 1);
3947   // If we have a three-operand form, make sure to set Rn to be the operand
3948   // that isn't the same as Rd.
3949   unsigned RegOp = 4;
3950   if (Operands.size() == 6 &&
3951       ((ARMOperand*)Operands[4])->getReg() ==
3952         ((ARMOperand*)Operands[3])->getReg())
3953     RegOp = 5;
3954   ((ARMOperand*)Operands[RegOp])->addRegOperands(Inst, 1);
3955   Inst.addOperand(Inst.getOperand(0));
3956   ((ARMOperand*)Operands[2])->addCondCodeOperands(Inst, 2);
3957
3958   return true;
3959 }
3960
3961 bool ARMAsmParser::
3962 cvtVLDwbFixed(MCInst &Inst, unsigned Opcode,
3963               const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3964   // Vd
3965   ((ARMOperand*)Operands[3])->addVecListOperands(Inst, 1);
3966   // Create a writeback register dummy placeholder.
3967   Inst.addOperand(MCOperand::CreateImm(0));
3968   // Vn
3969   ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3970   // pred
3971   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3972   return true;
3973 }
3974
3975 bool ARMAsmParser::
3976 cvtVLDwbRegister(MCInst &Inst, unsigned Opcode,
3977                  const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3978   // Vd
3979   ((ARMOperand*)Operands[3])->addVecListOperands(Inst, 1);
3980   // Create a writeback register dummy placeholder.
3981   Inst.addOperand(MCOperand::CreateImm(0));
3982   // Vn
3983   ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3984   // Vm
3985   ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
3986   // pred
3987   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
3988   return true;
3989 }
3990
3991 bool ARMAsmParser::
3992 cvtVSTwbFixed(MCInst &Inst, unsigned Opcode,
3993               const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3994   // Create a writeback register dummy placeholder.
3995   Inst.addOperand(MCOperand::CreateImm(0));
3996   // Vn
3997   ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
3998   // Vt
3999   ((ARMOperand*)Operands[3])->addVecListOperands(Inst, 1);
4000   // pred
4001   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
4002   return true;
4003 }
4004
4005 bool ARMAsmParser::
4006 cvtVSTwbRegister(MCInst &Inst, unsigned Opcode,
4007                  const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4008   // Create a writeback register dummy placeholder.
4009   Inst.addOperand(MCOperand::CreateImm(0));
4010   // Vn
4011   ((ARMOperand*)Operands[4])->addAlignedMemoryOperands(Inst, 2);
4012   // Vm
4013   ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
4014   // Vt
4015   ((ARMOperand*)Operands[3])->addVecListOperands(Inst, 1);
4016   // pred
4017   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
4018   return true;
4019 }
4020
4021 /// Parse an ARM memory expression, return false if successful else return true
4022 /// or an error.  The first token must be a '[' when called.
4023 bool ARMAsmParser::
4024 parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4025   SMLoc S, E;
4026   assert(Parser.getTok().is(AsmToken::LBrac) &&
4027          "Token is not a Left Bracket");
4028   S = Parser.getTok().getLoc();
4029   Parser.Lex(); // Eat left bracket token.
4030
4031   const AsmToken &BaseRegTok = Parser.getTok();
4032   int BaseRegNum = tryParseRegister();
4033   if (BaseRegNum == -1)
4034     return Error(BaseRegTok.getLoc(), "register expected");
4035
4036   // The next token must either be a comma or a closing bracket.
4037   const AsmToken &Tok = Parser.getTok();
4038   if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
4039     return Error(Tok.getLoc(), "malformed memory operand");
4040
4041   if (Tok.is(AsmToken::RBrac)) {
4042     E = Tok.getLoc();
4043     Parser.Lex(); // Eat right bracket token.
4044
4045     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift,
4046                                              0, 0, false, S, E));
4047
4048     // If there's a pre-indexing writeback marker, '!', just add it as a token
4049     // operand. It's rather odd, but syntactically valid.
4050     if (Parser.getTok().is(AsmToken::Exclaim)) {
4051       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
4052       Parser.Lex(); // Eat the '!'.
4053     }
4054
4055     return false;
4056   }
4057
4058   assert(Tok.is(AsmToken::Comma) && "Lost comma in memory operand?!");
4059   Parser.Lex(); // Eat the comma.
4060
4061   // If we have a ':', it's an alignment specifier.
4062   if (Parser.getTok().is(AsmToken::Colon)) {
4063     Parser.Lex(); // Eat the ':'.
4064     E = Parser.getTok().getLoc();
4065
4066     const MCExpr *Expr;
4067     if (getParser().ParseExpression(Expr))
4068      return true;
4069
4070     // The expression has to be a constant. Memory references with relocations
4071     // don't come through here, as they use the <label> forms of the relevant
4072     // instructions.
4073     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
4074     if (!CE)
4075       return Error (E, "constant expression expected");
4076
4077     unsigned Align = 0;
4078     switch (CE->getValue()) {
4079     default:
4080       return Error(E,
4081                    "alignment specifier must be 16, 32, 64, 128, or 256 bits");
4082     case 16:  Align = 2; break;
4083     case 32:  Align = 4; break;
4084     case 64:  Align = 8; break;
4085     case 128: Align = 16; break;
4086     case 256: Align = 32; break;
4087     }
4088
4089     // Now we should have the closing ']'
4090     E = Parser.getTok().getLoc();
4091     if (Parser.getTok().isNot(AsmToken::RBrac))
4092       return Error(E, "']' expected");
4093     Parser.Lex(); // Eat right bracket token.
4094
4095     // Don't worry about range checking the value here. That's handled by
4096     // the is*() predicates.
4097     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0,
4098                                              ARM_AM::no_shift, 0, Align,
4099                                              false, S, E));
4100
4101     // If there's a pre-indexing writeback marker, '!', just add it as a token
4102     // operand.
4103     if (Parser.getTok().is(AsmToken::Exclaim)) {
4104       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
4105       Parser.Lex(); // Eat the '!'.
4106     }
4107
4108     return false;
4109   }
4110
4111   // If we have a '#', it's an immediate offset, else assume it's a register
4112   // offset. Be friendly and also accept a plain integer (without a leading
4113   // hash) for gas compatibility.
4114   if (Parser.getTok().is(AsmToken::Hash) ||
4115       Parser.getTok().is(AsmToken::Dollar) ||
4116       Parser.getTok().is(AsmToken::Integer)) {
4117     if (Parser.getTok().isNot(AsmToken::Integer))
4118       Parser.Lex(); // Eat the '#'.
4119     E = Parser.getTok().getLoc();
4120
4121     bool isNegative = getParser().getTok().is(AsmToken::Minus);
4122     const MCExpr *Offset;
4123     if (getParser().ParseExpression(Offset))
4124      return true;
4125
4126     // The expression has to be a constant. Memory references with relocations
4127     // don't come through here, as they use the <label> forms of the relevant
4128     // instructions.
4129     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
4130     if (!CE)
4131       return Error (E, "constant expression expected");
4132
4133     // If the constant was #-0, represent it as INT32_MIN.
4134     int32_t Val = CE->getValue();
4135     if (isNegative && Val == 0)
4136       CE = MCConstantExpr::Create(INT32_MIN, getContext());
4137
4138     // Now we should have the closing ']'
4139     E = Parser.getTok().getLoc();
4140     if (Parser.getTok().isNot(AsmToken::RBrac))
4141       return Error(E, "']' expected");
4142     Parser.Lex(); // Eat right bracket token.
4143
4144     // Don't worry about range checking the value here. That's handled by
4145     // the is*() predicates.
4146     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0,
4147                                              ARM_AM::no_shift, 0, 0,
4148                                              false, S, E));
4149
4150     // If there's a pre-indexing writeback marker, '!', just add it as a token
4151     // operand.
4152     if (Parser.getTok().is(AsmToken::Exclaim)) {
4153       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
4154       Parser.Lex(); // Eat the '!'.
4155     }
4156
4157     return false;
4158   }
4159
4160   // The register offset is optionally preceded by a '+' or '-'
4161   bool isNegative = false;
4162   if (Parser.getTok().is(AsmToken::Minus)) {
4163     isNegative = true;
4164     Parser.Lex(); // Eat the '-'.
4165   } else if (Parser.getTok().is(AsmToken::Plus)) {
4166     // Nothing to do.
4167     Parser.Lex(); // Eat the '+'.
4168   }
4169
4170   E = Parser.getTok().getLoc();
4171   int OffsetRegNum = tryParseRegister();
4172   if (OffsetRegNum == -1)
4173     return Error(E, "register expected");
4174
4175   // If there's a shift operator, handle it.
4176   ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift;
4177   unsigned ShiftImm = 0;
4178   if (Parser.getTok().is(AsmToken::Comma)) {
4179     Parser.Lex(); // Eat the ','.
4180     if (parseMemRegOffsetShift(ShiftType, ShiftImm))
4181       return true;
4182   }
4183
4184   // Now we should have the closing ']'
4185   E = Parser.getTok().getLoc();
4186   if (Parser.getTok().isNot(AsmToken::RBrac))
4187     return Error(E, "']' expected");
4188   Parser.Lex(); // Eat right bracket token.
4189
4190   Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum,
4191                                            ShiftType, ShiftImm, 0, isNegative,
4192                                            S, E));
4193
4194   // If there's a pre-indexing writeback marker, '!', just add it as a token
4195   // operand.
4196   if (Parser.getTok().is(AsmToken::Exclaim)) {
4197     Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
4198     Parser.Lex(); // Eat the '!'.
4199   }
4200
4201   return false;
4202 }
4203
4204 /// parseMemRegOffsetShift - one of these two:
4205 ///   ( lsl | lsr | asr | ror ) , # shift_amount
4206 ///   rrx
4207 /// return true if it parses a shift otherwise it returns false.
4208 bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
4209                                           unsigned &Amount) {
4210   SMLoc Loc = Parser.getTok().getLoc();
4211   const AsmToken &Tok = Parser.getTok();
4212   if (Tok.isNot(AsmToken::Identifier))
4213     return true;
4214   StringRef ShiftName = Tok.getString();
4215   if (ShiftName == "lsl" || ShiftName == "LSL" ||
4216       ShiftName == "asl" || ShiftName == "ASL")
4217     St = ARM_AM::lsl;
4218   else if (ShiftName == "lsr" || ShiftName == "LSR")
4219     St = ARM_AM::lsr;
4220   else if (ShiftName == "asr" || ShiftName == "ASR")
4221     St = ARM_AM::asr;
4222   else if (ShiftName == "ror" || ShiftName == "ROR")
4223     St = ARM_AM::ror;
4224   else if (ShiftName == "rrx" || ShiftName == "RRX")
4225     St = ARM_AM::rrx;
4226   else
4227     return Error(Loc, "illegal shift operator");
4228   Parser.Lex(); // Eat shift type token.
4229
4230   // rrx stands alone.
4231   Amount = 0;
4232   if (St != ARM_AM::rrx) {
4233     Loc = Parser.getTok().getLoc();
4234     // A '#' and a shift amount.
4235     const AsmToken &HashTok = Parser.getTok();
4236     if (HashTok.isNot(AsmToken::Hash) &&
4237         HashTok.isNot(AsmToken::Dollar))
4238       return Error(HashTok.getLoc(), "'#' expected");
4239     Parser.Lex(); // Eat hash token.
4240
4241     const MCExpr *Expr;
4242     if (getParser().ParseExpression(Expr))
4243       return true;
4244     // Range check the immediate.
4245     // lsl, ror: 0 <= imm <= 31
4246     // lsr, asr: 0 <= imm <= 32
4247     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
4248     if (!CE)
4249       return Error(Loc, "shift amount must be an immediate");
4250     int64_t Imm = CE->getValue();
4251     if (Imm < 0 ||
4252         ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) ||
4253         ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32))
4254       return Error(Loc, "immediate shift value out of range");
4255     Amount = Imm;
4256   }
4257
4258   return false;
4259 }
4260
4261 /// parseFPImm - A floating point immediate expression operand.
4262 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
4263 parseFPImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4264   // Anything that can accept a floating point constant as an operand
4265   // needs to go through here, as the regular ParseExpression is
4266   // integer only.
4267   //
4268   // This routine still creates a generic Immediate operand, containing
4269   // a bitcast of the 64-bit floating point value. The various operands
4270   // that accept floats can check whether the value is valid for them
4271   // via the standard is*() predicates.
4272
4273   SMLoc S = Parser.getTok().getLoc();
4274
4275   if (Parser.getTok().isNot(AsmToken::Hash) &&
4276       Parser.getTok().isNot(AsmToken::Dollar))
4277     return MatchOperand_NoMatch;
4278
4279   // Disambiguate the VMOV forms that can accept an FP immediate.
4280   // vmov.f32 <sreg>, #imm
4281   // vmov.f64 <dreg>, #imm
4282   // vmov.f32 <dreg>, #imm  @ vector f32x2
4283   // vmov.f32 <qreg>, #imm  @ vector f32x4
4284   //
4285   // There are also the NEON VMOV instructions which expect an
4286   // integer constant. Make sure we don't try to parse an FPImm
4287   // for these:
4288   // vmov.i{8|16|32|64} <dreg|qreg>, #imm
4289   ARMOperand *TyOp = static_cast<ARMOperand*>(Operands[2]);
4290   if (!TyOp->isToken() || (TyOp->getToken() != ".f32" &&
4291                            TyOp->getToken() != ".f64"))
4292     return MatchOperand_NoMatch;
4293
4294   Parser.Lex(); // Eat the '#'.
4295
4296   // Handle negation, as that still comes through as a separate token.
4297   bool isNegative = false;
4298   if (Parser.getTok().is(AsmToken::Minus)) {
4299     isNegative = true;
4300     Parser.Lex();
4301   }
4302   const AsmToken &Tok = Parser.getTok();
4303   SMLoc Loc = Tok.getLoc();
4304   if (Tok.is(AsmToken::Real)) {
4305     APFloat RealVal(APFloat::IEEEsingle, Tok.getString());
4306     uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
4307     // If we had a '-' in front, toggle the sign bit.
4308     IntVal ^= (uint64_t)isNegative << 31;
4309     Parser.Lex(); // Eat the token.
4310     Operands.push_back(ARMOperand::CreateImm(
4311           MCConstantExpr::Create(IntVal, getContext()),
4312           S, Parser.getTok().getLoc()));
4313     return MatchOperand_Success;
4314   }
4315   // Also handle plain integers. Instructions which allow floating point
4316   // immediates also allow a raw encoded 8-bit value.
4317   if (Tok.is(AsmToken::Integer)) {
4318     int64_t Val = Tok.getIntVal();
4319     Parser.Lex(); // Eat the token.
4320     if (Val > 255 || Val < 0) {
4321       Error(Loc, "encoded floating point value out of range");
4322       return MatchOperand_ParseFail;
4323     }
4324     double RealVal = ARM_AM::getFPImmFloat(Val);
4325     Val = APFloat(APFloat::IEEEdouble, RealVal).bitcastToAPInt().getZExtValue();
4326     Operands.push_back(ARMOperand::CreateImm(
4327         MCConstantExpr::Create(Val, getContext()), S,
4328         Parser.getTok().getLoc()));
4329     return MatchOperand_Success;
4330   }
4331
4332   Error(Loc, "invalid floating point immediate");
4333   return MatchOperand_ParseFail;
4334 }
4335
4336 /// Parse a arm instruction operand.  For now this parses the operand regardless
4337 /// of the mnemonic.
4338 bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
4339                                 StringRef Mnemonic) {
4340   SMLoc S, E;
4341
4342   // Check if the current operand has a custom associated parser, if so, try to
4343   // custom parse the operand, or fallback to the general approach.
4344   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
4345   if (ResTy == MatchOperand_Success)
4346     return false;
4347   // If there wasn't a custom match, try the generic matcher below. Otherwise,
4348   // there was a match, but an error occurred, in which case, just return that
4349   // the operand parsing failed.
4350   if (ResTy == MatchOperand_ParseFail)
4351     return true;
4352
4353   switch (getLexer().getKind()) {
4354   default:
4355     Error(Parser.getTok().getLoc(), "unexpected token in operand");
4356     return true;
4357   case AsmToken::Identifier: {
4358     if (!tryParseRegisterWithWriteBack(Operands))
4359       return false;
4360     int Res = tryParseShiftRegister(Operands);
4361     if (Res == 0) // success
4362       return false;
4363     else if (Res == -1) // irrecoverable error
4364       return true;
4365     // If this is VMRS, check for the apsr_nzcv operand.
4366     if (Mnemonic == "vmrs" && Parser.getTok().getString() == "apsr_nzcv") {
4367       S = Parser.getTok().getLoc();
4368       Parser.Lex();
4369       Operands.push_back(ARMOperand::CreateToken("apsr_nzcv", S));
4370       return false;
4371     }
4372
4373     // Fall though for the Identifier case that is not a register or a
4374     // special name.
4375   }
4376   case AsmToken::LParen:  // parenthesized expressions like (_strcmp-4)
4377   case AsmToken::Integer: // things like 1f and 2b as a branch targets
4378   case AsmToken::String:  // quoted label names.
4379   case AsmToken::Dot: {   // . as a branch target
4380     // This was not a register so parse other operands that start with an
4381     // identifier (like labels) as expressions and create them as immediates.
4382     const MCExpr *IdVal;
4383     S = Parser.getTok().getLoc();
4384     if (getParser().ParseExpression(IdVal))
4385       return true;
4386     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
4387     Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
4388     return false;
4389   }
4390   case AsmToken::LBrac:
4391     return parseMemory(Operands);
4392   case AsmToken::LCurly:
4393     return parseRegisterList(Operands);
4394   case AsmToken::Dollar:
4395   case AsmToken::Hash: {
4396     // #42 -> immediate.
4397     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
4398     S = Parser.getTok().getLoc();
4399     Parser.Lex();
4400     bool isNegative = Parser.getTok().is(AsmToken::Minus);
4401     const MCExpr *ImmVal;
4402     if (getParser().ParseExpression(ImmVal))
4403       return true;
4404     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal);
4405     if (CE) {
4406       int32_t Val = CE->getValue();
4407       if (isNegative && Val == 0)
4408         ImmVal = MCConstantExpr::Create(INT32_MIN, getContext());
4409     }
4410     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
4411     Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
4412     return false;
4413   }
4414   case AsmToken::Colon: {
4415     // ":lower16:" and ":upper16:" expression prefixes
4416     // FIXME: Check it's an expression prefix,
4417     // e.g. (FOO - :lower16:BAR) isn't legal.
4418     ARMMCExpr::VariantKind RefKind;
4419     if (parsePrefix(RefKind))
4420       return true;
4421
4422     const MCExpr *SubExprVal;
4423     if (getParser().ParseExpression(SubExprVal))
4424       return true;
4425
4426     const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
4427                                                    getContext());
4428     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
4429     Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
4430     return false;
4431   }
4432   }
4433 }
4434
4435 // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
4436 //  :lower16: and :upper16:.
4437 bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
4438   RefKind = ARMMCExpr::VK_ARM_None;
4439
4440   // :lower16: and :upper16: modifiers
4441   assert(getLexer().is(AsmToken::Colon) && "expected a :");
4442   Parser.Lex(); // Eat ':'
4443
4444   if (getLexer().isNot(AsmToken::Identifier)) {
4445     Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
4446     return true;
4447   }
4448
4449   StringRef IDVal = Parser.getTok().getIdentifier();
4450   if (IDVal == "lower16") {
4451     RefKind = ARMMCExpr::VK_ARM_LO16;
4452   } else if (IDVal == "upper16") {
4453     RefKind = ARMMCExpr::VK_ARM_HI16;
4454   } else {
4455     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
4456     return true;
4457   }
4458   Parser.Lex();
4459
4460   if (getLexer().isNot(AsmToken::Colon)) {
4461     Error(Parser.getTok().getLoc(), "unexpected token after prefix");
4462     return true;
4463   }
4464   Parser.Lex(); // Eat the last ':'
4465   return false;
4466 }
4467
4468 /// \brief Given a mnemonic, split out possible predication code and carry
4469 /// setting letters to form a canonical mnemonic and flags.
4470 //
4471 // FIXME: Would be nice to autogen this.
4472 // FIXME: This is a bit of a maze of special cases.
4473 StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic,
4474                                       unsigned &PredicationCode,
4475                                       bool &CarrySetting,
4476                                       unsigned &ProcessorIMod,
4477                                       StringRef &ITMask) {
4478   PredicationCode = ARMCC::AL;
4479   CarrySetting = false;
4480   ProcessorIMod = 0;
4481
4482   // Ignore some mnemonics we know aren't predicated forms.
4483   //
4484   // FIXME: Would be nice to autogen this.
4485   if ((Mnemonic == "movs" && isThumb()) ||
4486       Mnemonic == "teq"   || Mnemonic == "vceq"   || Mnemonic == "svc"   ||
4487       Mnemonic == "mls"   || Mnemonic == "smmls"  || Mnemonic == "vcls"  ||
4488       Mnemonic == "vmls"  || Mnemonic == "vnmls"  || Mnemonic == "vacge" ||
4489       Mnemonic == "vcge"  || Mnemonic == "vclt"   || Mnemonic == "vacgt" ||
4490       Mnemonic == "vcgt"  || Mnemonic == "vcle"   || Mnemonic == "smlal" ||
4491       Mnemonic == "umaal" || Mnemonic == "umlal"  || Mnemonic == "vabal" ||
4492       Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal" ||
4493       Mnemonic == "fmuls")
4494     return Mnemonic;
4495
4496   // First, split out any predication code. Ignore mnemonics we know aren't
4497   // predicated but do have a carry-set and so weren't caught above.
4498   if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" &&
4499       Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" &&
4500       Mnemonic != "umlals" && Mnemonic != "umulls" && Mnemonic != "lsls" &&
4501       Mnemonic != "sbcs" && Mnemonic != "rscs") {
4502     unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
4503       .Case("eq", ARMCC::EQ)
4504       .Case("ne", ARMCC::NE)
4505       .Case("hs", ARMCC::HS)
4506       .Case("cs", ARMCC::HS)
4507       .Case("lo", ARMCC::LO)
4508       .Case("cc", ARMCC::LO)
4509       .Case("mi", ARMCC::MI)
4510       .Case("pl", ARMCC::PL)
4511       .Case("vs", ARMCC::VS)
4512       .Case("vc", ARMCC::VC)
4513       .Case("hi", ARMCC::HI)
4514       .Case("ls", ARMCC::LS)
4515       .Case("ge", ARMCC::GE)
4516       .Case("lt", ARMCC::LT)
4517       .Case("gt", ARMCC::GT)
4518       .Case("le", ARMCC::LE)
4519       .Case("al", ARMCC::AL)
4520       .Default(~0U);
4521     if (CC != ~0U) {
4522       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
4523       PredicationCode = CC;
4524     }
4525   }
4526
4527   // Next, determine if we have a carry setting bit. We explicitly ignore all
4528   // the instructions we know end in 's'.
4529   if (Mnemonic.endswith("s") &&
4530       !(Mnemonic == "cps" || Mnemonic == "mls" ||
4531         Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" ||
4532         Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" ||
4533         Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" ||
4534         Mnemonic == "vrsqrts" || Mnemonic == "srs" || Mnemonic == "flds" ||
4535         Mnemonic == "fmrs" || Mnemonic == "fsqrts" || Mnemonic == "fsubs" ||
4536         Mnemonic == "fsts" || Mnemonic == "fcpys" || Mnemonic == "fdivs" ||
4537         Mnemonic == "fmuls" || Mnemonic == "fcmps" ||
4538         (Mnemonic == "movs" && isThumb()))) {
4539     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
4540     CarrySetting = true;
4541   }
4542
4543   // The "cps" instruction can have a interrupt mode operand which is glued into
4544   // the mnemonic. Check if this is the case, split it and parse the imod op
4545   if (Mnemonic.startswith("cps")) {
4546     // Split out any imod code.
4547     unsigned IMod =
4548       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
4549       .Case("ie", ARM_PROC::IE)
4550       .Case("id", ARM_PROC::ID)
4551       .Default(~0U);
4552     if (IMod != ~0U) {
4553       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
4554       ProcessorIMod = IMod;
4555     }
4556   }
4557
4558   // The "it" instruction has the condition mask on the end of the mnemonic.
4559   if (Mnemonic.startswith("it")) {
4560     ITMask = Mnemonic.slice(2, Mnemonic.size());
4561     Mnemonic = Mnemonic.slice(0, 2);
4562   }
4563
4564   return Mnemonic;
4565 }
4566
4567 /// \brief Given a canonical mnemonic, determine if the instruction ever allows
4568 /// inclusion of carry set or predication code operands.
4569 //
4570 // FIXME: It would be nice to autogen this.
4571 void ARMAsmParser::
4572 getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
4573                       bool &CanAcceptPredicationCode) {
4574   if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
4575       Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
4576       Mnemonic == "add" || Mnemonic == "adc" ||
4577       Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
4578       Mnemonic == "orr" || Mnemonic == "mvn" ||
4579       Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
4580       Mnemonic == "sbc" || Mnemonic == "eor" || Mnemonic == "neg" ||
4581       (!isThumb() && (Mnemonic == "smull" || Mnemonic == "mov" ||
4582                       Mnemonic == "mla" || Mnemonic == "smlal" ||
4583                       Mnemonic == "umlal" || Mnemonic == "umull"))) {
4584     CanAcceptCarrySet = true;
4585   } else
4586     CanAcceptCarrySet = false;
4587
4588   if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
4589       Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
4590       Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
4591       Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
4592       Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "setend" ||
4593       (Mnemonic == "clrex" && !isThumb()) ||
4594       (Mnemonic == "nop" && isThumbOne()) ||
4595       ((Mnemonic == "pld" || Mnemonic == "pli" || Mnemonic == "pldw" ||
4596         Mnemonic == "ldc2" || Mnemonic == "ldc2l" ||
4597         Mnemonic == "stc2" || Mnemonic == "stc2l") && !isThumb()) ||
4598       ((Mnemonic.startswith("rfe") || Mnemonic.startswith("srs")) &&
4599        !isThumb()) ||
4600       Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumbOne())) {
4601     CanAcceptPredicationCode = false;
4602   } else
4603     CanAcceptPredicationCode = true;
4604
4605   if (isThumb()) {
4606     if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
4607         Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
4608       CanAcceptPredicationCode = false;
4609   }
4610 }
4611
4612 bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic,
4613                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4614   // FIXME: This is all horribly hacky. We really need a better way to deal
4615   // with optional operands like this in the matcher table.
4616
4617   // The 'mov' mnemonic is special. One variant has a cc_out operand, while
4618   // another does not. Specifically, the MOVW instruction does not. So we
4619   // special case it here and remove the defaulted (non-setting) cc_out
4620   // operand if that's the instruction we're trying to match.
4621   //
4622   // We do this as post-processing of the explicit operands rather than just
4623   // conditionally adding the cc_out in the first place because we need
4624   // to check the type of the parsed immediate operand.
4625   if (Mnemonic == "mov" && Operands.size() > 4 && !isThumb() &&
4626       !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() &&
4627       static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() &&
4628       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4629     return true;
4630
4631   // Register-register 'add' for thumb does not have a cc_out operand
4632   // when there are only two register operands.
4633   if (isThumb() && Mnemonic == "add" && Operands.size() == 5 &&
4634       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4635       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4636       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4637     return true;
4638   // Register-register 'add' for thumb does not have a cc_out operand
4639   // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do
4640   // have to check the immediate range here since Thumb2 has a variant
4641   // that can handle a different range and has a cc_out operand.
4642   if (((isThumb() && Mnemonic == "add") ||
4643        (isThumbTwo() && Mnemonic == "sub")) &&
4644       Operands.size() == 6 &&
4645       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4646       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4647       static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::SP &&
4648       static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
4649       (static_cast<ARMOperand*>(Operands[5])->isReg() ||
4650        static_cast<ARMOperand*>(Operands[5])->isImm0_1020s4()))
4651     return true;
4652   // For Thumb2, add/sub immediate does not have a cc_out operand for the
4653   // imm0_4095 variant. That's the least-preferred variant when
4654   // selecting via the generic "add" mnemonic, so to know that we
4655   // should remove the cc_out operand, we have to explicitly check that
4656   // it's not one of the other variants. Ugh.
4657   if (isThumbTwo() && (Mnemonic == "add" || Mnemonic == "sub") &&
4658       Operands.size() == 6 &&
4659       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4660       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4661       static_cast<ARMOperand*>(Operands[5])->isImm()) {
4662     // Nest conditions rather than one big 'if' statement for readability.
4663     //
4664     // If either register is a high reg, it's either one of the SP
4665     // variants (handled above) or a 32-bit encoding, so we just
4666     // check against T3. If the second register is the PC, this is an
4667     // alternate form of ADR, which uses encoding T4, so check for that too.
4668     if ((!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
4669          !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg())) &&
4670         static_cast<ARMOperand*>(Operands[4])->getReg() != ARM::PC &&
4671         static_cast<ARMOperand*>(Operands[5])->isT2SOImm())
4672       return false;
4673     // If both registers are low, we're in an IT block, and the immediate is
4674     // in range, we should use encoding T1 instead, which has a cc_out.
4675     if (inITBlock() &&
4676         isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) &&
4677         isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
4678         static_cast<ARMOperand*>(Operands[5])->isImm0_7())
4679       return false;
4680
4681     // Otherwise, we use encoding T4, which does not have a cc_out
4682     // operand.
4683     return true;
4684   }
4685
4686   // The thumb2 multiply instruction doesn't have a CCOut register, so
4687   // if we have a "mul" mnemonic in Thumb mode, check if we'll be able to
4688   // use the 16-bit encoding or not.
4689   if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 6 &&
4690       static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
4691       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4692       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4693       static_cast<ARMOperand*>(Operands[5])->isReg() &&
4694       // If the registers aren't low regs, the destination reg isn't the
4695       // same as one of the source regs, or the cc_out operand is zero
4696       // outside of an IT block, we have to use the 32-bit encoding, so
4697       // remove the cc_out operand.
4698       (!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
4699        !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) ||
4700        !isARMLowRegister(static_cast<ARMOperand*>(Operands[5])->getReg()) ||
4701        !inITBlock() ||
4702        (static_cast<ARMOperand*>(Operands[3])->getReg() !=
4703         static_cast<ARMOperand*>(Operands[5])->getReg() &&
4704         static_cast<ARMOperand*>(Operands[3])->getReg() !=
4705         static_cast<ARMOperand*>(Operands[4])->getReg())))
4706     return true;
4707
4708   // Also check the 'mul' syntax variant that doesn't specify an explicit
4709   // destination register.
4710   if (isThumbTwo() && Mnemonic == "mul" && Operands.size() == 5 &&
4711       static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
4712       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4713       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4714       // If the registers aren't low regs  or the cc_out operand is zero
4715       // outside of an IT block, we have to use the 32-bit encoding, so
4716       // remove the cc_out operand.
4717       (!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
4718        !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) ||
4719        !inITBlock()))
4720     return true;
4721
4722
4723
4724   // Register-register 'add/sub' for thumb does not have a cc_out operand
4725   // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also
4726   // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't
4727   // right, this will result in better diagnostics (which operand is off)
4728   // anyway.
4729   if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") &&
4730       (Operands.size() == 5 || Operands.size() == 6) &&
4731       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4732       static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::SP &&
4733       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
4734     return true;
4735
4736   return false;
4737 }
4738
4739 static bool isDataTypeToken(StringRef Tok) {
4740   return Tok == ".8" || Tok == ".16" || Tok == ".32" || Tok == ".64" ||
4741     Tok == ".i8" || Tok == ".i16" || Tok == ".i32" || Tok == ".i64" ||
4742     Tok == ".u8" || Tok == ".u16" || Tok == ".u32" || Tok == ".u64" ||
4743     Tok == ".s8" || Tok == ".s16" || Tok == ".s32" || Tok == ".s64" ||
4744     Tok == ".p8" || Tok == ".p16" || Tok == ".f32" || Tok == ".f64" ||
4745     Tok == ".f" || Tok == ".d";
4746 }
4747
4748 // FIXME: This bit should probably be handled via an explicit match class
4749 // in the .td files that matches the suffix instead of having it be
4750 // a literal string token the way it is now.
4751 static bool doesIgnoreDataTypeSuffix(StringRef Mnemonic, StringRef DT) {
4752   return Mnemonic.startswith("vldm") || Mnemonic.startswith("vstm");
4753 }
4754
4755 static void applyMnemonicAliases(StringRef &Mnemonic, unsigned Features);
4756 /// Parse an arm instruction mnemonic followed by its operands.
4757 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
4758                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
4759   // Apply mnemonic aliases before doing anything else, as the destination
4760   // mnemnonic may include suffices and we want to handle them normally.
4761   // The generic tblgen'erated code does this later, at the start of
4762   // MatchInstructionImpl(), but that's too late for aliases that include
4763   // any sort of suffix.
4764   unsigned AvailableFeatures = getAvailableFeatures();
4765   applyMnemonicAliases(Name, AvailableFeatures);
4766
4767   // First check for the ARM-specific .req directive.
4768   if (Parser.getTok().is(AsmToken::Identifier) &&
4769       Parser.getTok().getIdentifier() == ".req") {
4770     parseDirectiveReq(Name, NameLoc);
4771     // We always return 'error' for this, as we're done with this
4772     // statement and don't need to match the 'instruction."
4773     return true;
4774   }
4775
4776   // Create the leading tokens for the mnemonic, split by '.' characters.
4777   size_t Start = 0, Next = Name.find('.');
4778   StringRef Mnemonic = Name.slice(Start, Next);
4779
4780   // Split out the predication code and carry setting flag from the mnemonic.
4781   unsigned PredicationCode;
4782   unsigned ProcessorIMod;
4783   bool CarrySetting;
4784   StringRef ITMask;
4785   Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting,
4786                            ProcessorIMod, ITMask);
4787
4788   // In Thumb1, only the branch (B) instruction can be predicated.
4789   if (isThumbOne() && PredicationCode != ARMCC::AL && Mnemonic != "b") {
4790     Parser.EatToEndOfStatement();
4791     return Error(NameLoc, "conditional execution not supported in Thumb1");
4792   }
4793
4794   Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc));
4795
4796   // Handle the IT instruction ITMask. Convert it to a bitmask. This
4797   // is the mask as it will be for the IT encoding if the conditional
4798   // encoding has a '1' as it's bit0 (i.e. 't' ==> '1'). In the case
4799   // where the conditional bit0 is zero, the instruction post-processing
4800   // will adjust the mask accordingly.
4801   if (Mnemonic == "it") {
4802     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + 2);
4803     if (ITMask.size() > 3) {
4804       Parser.EatToEndOfStatement();
4805       return Error(Loc, "too many conditions on IT instruction");
4806     }
4807     unsigned Mask = 8;
4808     for (unsigned i = ITMask.size(); i != 0; --i) {
4809       char pos = ITMask[i - 1];
4810       if (pos != 't' && pos != 'e') {
4811         Parser.EatToEndOfStatement();
4812         return Error(Loc, "illegal IT block condition mask '" + ITMask + "'");
4813       }
4814       Mask >>= 1;
4815       if (ITMask[i - 1] == 't')
4816         Mask |= 8;
4817     }
4818     Operands.push_back(ARMOperand::CreateITMask(Mask, Loc));
4819   }
4820
4821   // FIXME: This is all a pretty gross hack. We should automatically handle
4822   // optional operands like this via tblgen.
4823
4824   // Next, add the CCOut and ConditionCode operands, if needed.
4825   //
4826   // For mnemonics which can ever incorporate a carry setting bit or predication
4827   // code, our matching model involves us always generating CCOut and
4828   // ConditionCode operands to match the mnemonic "as written" and then we let
4829   // the matcher deal with finding the right instruction or generating an
4830   // appropriate error.
4831   bool CanAcceptCarrySet, CanAcceptPredicationCode;
4832   getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode);
4833
4834   // If we had a carry-set on an instruction that can't do that, issue an
4835   // error.
4836   if (!CanAcceptCarrySet && CarrySetting) {
4837     Parser.EatToEndOfStatement();
4838     return Error(NameLoc, "instruction '" + Mnemonic +
4839                  "' can not set flags, but 's' suffix specified");
4840   }
4841   // If we had a predication code on an instruction that can't do that, issue an
4842   // error.
4843   if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) {
4844     Parser.EatToEndOfStatement();
4845     return Error(NameLoc, "instruction '" + Mnemonic +
4846                  "' is not predicable, but condition code specified");
4847   }
4848
4849   // Add the carry setting operand, if necessary.
4850   if (CanAcceptCarrySet) {
4851     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
4852     Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
4853                                                Loc));
4854   }
4855
4856   // Add the predication code operand, if necessary.
4857   if (CanAcceptPredicationCode) {
4858     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
4859                                       CarrySetting);
4860     Operands.push_back(ARMOperand::CreateCondCode(
4861                          ARMCC::CondCodes(PredicationCode), Loc));
4862   }
4863
4864   // Add the processor imod operand, if necessary.
4865   if (ProcessorIMod) {
4866     Operands.push_back(ARMOperand::CreateImm(
4867           MCConstantExpr::Create(ProcessorIMod, getContext()),
4868                                  NameLoc, NameLoc));
4869   }
4870
4871   // Add the remaining tokens in the mnemonic.
4872   while (Next != StringRef::npos) {
4873     Start = Next;
4874     Next = Name.find('.', Start + 1);
4875     StringRef ExtraToken = Name.slice(Start, Next);
4876
4877     // Some NEON instructions have an optional datatype suffix that is
4878     // completely ignored. Check for that.
4879     if (isDataTypeToken(ExtraToken) &&
4880         doesIgnoreDataTypeSuffix(Mnemonic, ExtraToken))
4881       continue;
4882
4883     if (ExtraToken != ".n") {
4884       SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
4885       Operands.push_back(ARMOperand::CreateToken(ExtraToken, Loc));
4886     }
4887   }
4888
4889   // Read the remaining operands.
4890   if (getLexer().isNot(AsmToken::EndOfStatement)) {
4891     // Read the first operand.
4892     if (parseOperand(Operands, Mnemonic)) {
4893       Parser.EatToEndOfStatement();
4894       return true;
4895     }
4896
4897     while (getLexer().is(AsmToken::Comma)) {
4898       Parser.Lex();  // Eat the comma.
4899
4900       // Parse and remember the operand.
4901       if (parseOperand(Operands, Mnemonic)) {
4902         Parser.EatToEndOfStatement();
4903         return true;
4904       }
4905     }
4906   }
4907
4908   if (getLexer().isNot(AsmToken::EndOfStatement)) {
4909     SMLoc Loc = getLexer().getLoc();
4910     Parser.EatToEndOfStatement();
4911     return Error(Loc, "unexpected token in argument list");
4912   }
4913
4914   Parser.Lex(); // Consume the EndOfStatement
4915
4916   // Some instructions, mostly Thumb, have forms for the same mnemonic that
4917   // do and don't have a cc_out optional-def operand. With some spot-checks
4918   // of the operand list, we can figure out which variant we're trying to
4919   // parse and adjust accordingly before actually matching. We shouldn't ever
4920   // try to remove a cc_out operand that was explicitly set on the the
4921   // mnemonic, of course (CarrySetting == true). Reason number #317 the
4922   // table driven matcher doesn't fit well with the ARM instruction set.
4923   if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands)) {
4924     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
4925     Operands.erase(Operands.begin() + 1);
4926     delete Op;
4927   }
4928
4929   // ARM mode 'blx' need special handling, as the register operand version
4930   // is predicable, but the label operand version is not. So, we can't rely
4931   // on the Mnemonic based checking to correctly figure out when to put
4932   // a k_CondCode operand in the list. If we're trying to match the label
4933   // version, remove the k_CondCode operand here.
4934   if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
4935       static_cast<ARMOperand*>(Operands[2])->isImm()) {
4936     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
4937     Operands.erase(Operands.begin() + 1);
4938     delete Op;
4939   }
4940
4941   // The vector-compare-to-zero instructions have a literal token "#0" at
4942   // the end that comes to here as an immediate operand. Convert it to a
4943   // token to play nicely with the matcher.
4944   if ((Mnemonic == "vceq" || Mnemonic == "vcge" || Mnemonic == "vcgt" ||
4945       Mnemonic == "vcle" || Mnemonic == "vclt") && Operands.size() == 6 &&
4946       static_cast<ARMOperand*>(Operands[5])->isImm()) {
4947     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
4948     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4949     if (CE && CE->getValue() == 0) {
4950       Operands.erase(Operands.begin() + 5);
4951       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4952       delete Op;
4953     }
4954   }
4955   // VCMP{E} does the same thing, but with a different operand count.
4956   if ((Mnemonic == "vcmp" || Mnemonic == "vcmpe") && Operands.size() == 5 &&
4957       static_cast<ARMOperand*>(Operands[4])->isImm()) {
4958     ARMOperand *Op = static_cast<ARMOperand*>(Operands[4]);
4959     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4960     if (CE && CE->getValue() == 0) {
4961       Operands.erase(Operands.begin() + 4);
4962       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4963       delete Op;
4964     }
4965   }
4966   // Similarly, the Thumb1 "RSB" instruction has a literal "#0" on the
4967   // end. Convert it to a token here. Take care not to convert those
4968   // that should hit the Thumb2 encoding.
4969   if (Mnemonic == "rsb" && isThumb() && Operands.size() == 6 &&
4970       static_cast<ARMOperand*>(Operands[3])->isReg() &&
4971       static_cast<ARMOperand*>(Operands[4])->isReg() &&
4972       static_cast<ARMOperand*>(Operands[5])->isImm()) {
4973     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
4974     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
4975     if (CE && CE->getValue() == 0 &&
4976         (isThumbOne() ||
4977          // The cc_out operand matches the IT block.
4978          ((inITBlock() != CarrySetting) &&
4979          // Neither register operand is a high register.
4980          (isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) &&
4981           isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()))))){
4982       Operands.erase(Operands.begin() + 5);
4983       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
4984       delete Op;
4985     }
4986   }
4987
4988   return false;
4989 }
4990
4991 // Validate context-sensitive operand constraints.
4992
4993 // return 'true' if register list contains non-low GPR registers,
4994 // 'false' otherwise. If Reg is in the register list or is HiReg, set
4995 // 'containsReg' to true.
4996 static bool checkLowRegisterList(MCInst Inst, unsigned OpNo, unsigned Reg,
4997                                  unsigned HiReg, bool &containsReg) {
4998   containsReg = false;
4999   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
5000     unsigned OpReg = Inst.getOperand(i).getReg();
5001     if (OpReg == Reg)
5002       containsReg = true;
5003     // Anything other than a low register isn't legal here.
5004     if (!isARMLowRegister(OpReg) && (!HiReg || OpReg != HiReg))
5005       return true;
5006   }
5007   return false;
5008 }
5009
5010 // Check if the specified regisgter is in the register list of the inst,
5011 // starting at the indicated operand number.
5012 static bool listContainsReg(MCInst &Inst, unsigned OpNo, unsigned Reg) {
5013   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
5014     unsigned OpReg = Inst.getOperand(i).getReg();
5015     if (OpReg == Reg)
5016       return true;
5017   }
5018   return false;
5019 }
5020
5021 // FIXME: We would really prefer to have MCInstrInfo (the wrapper around
5022 // the ARMInsts array) instead. Getting that here requires awkward
5023 // API changes, though. Better way?
5024 namespace llvm {
5025 extern const MCInstrDesc ARMInsts[];
5026 }
5027 static const MCInstrDesc &getInstDesc(unsigned Opcode) {
5028   return ARMInsts[Opcode];
5029 }
5030
5031 // FIXME: We would really like to be able to tablegen'erate this.
5032 bool ARMAsmParser::
5033 validateInstruction(MCInst &Inst,
5034                     const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
5035   const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
5036   SMLoc Loc = Operands[0]->getStartLoc();
5037   // Check the IT block state first.
5038   // NOTE: In Thumb mode, the BKPT instruction has the interesting property of
5039   // being allowed in IT blocks, but not being predicable.  It just always
5040   // executes.
5041   if (inITBlock() && Inst.getOpcode() != ARM::tBKPT) {
5042     unsigned bit = 1;
5043     if (ITState.FirstCond)
5044       ITState.FirstCond = false;
5045     else
5046       bit = (ITState.Mask >> (5 - ITState.CurPosition)) & 1;
5047     // The instruction must be predicable.
5048     if (!MCID.isPredicable())
5049       return Error(Loc, "instructions in IT block must be predicable");
5050     unsigned Cond = Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm();
5051     unsigned ITCond = bit ? ITState.Cond :
5052       ARMCC::getOppositeCondition(ITState.Cond);
5053     if (Cond != ITCond) {
5054       // Find the condition code Operand to get its SMLoc information.
5055       SMLoc CondLoc;
5056       for (unsigned i = 1; i < Operands.size(); ++i)
5057         if (static_cast<ARMOperand*>(Operands[i])->isCondCode())
5058           CondLoc = Operands[i]->getStartLoc();
5059       return Error(CondLoc, "incorrect condition in IT block; got '" +
5060                    StringRef(ARMCondCodeToString(ARMCC::CondCodes(Cond))) +
5061                    "', but expected '" +
5062                    ARMCondCodeToString(ARMCC::CondCodes(ITCond)) + "'");
5063     }
5064   // Check for non-'al' condition codes outside of the IT block.
5065   } else if (isThumbTwo() && MCID.isPredicable() &&
5066              Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm() !=
5067              ARMCC::AL && Inst.getOpcode() != ARM::tB &&
5068              Inst.getOpcode() != ARM::t2B)
5069     return Error(Loc, "predicated instructions must be in IT block");
5070
5071   switch (Inst.getOpcode()) {
5072   case ARM::LDRD:
5073   case ARM::LDRD_PRE:
5074   case ARM::LDRD_POST:
5075   case ARM::LDREXD: {
5076     // Rt2 must be Rt + 1.
5077     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
5078     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
5079     if (Rt2 != Rt + 1)
5080       return Error(Operands[3]->getStartLoc(),
5081                    "destination operands must be sequential");
5082     return false;
5083   }
5084   case ARM::STRD: {
5085     // Rt2 must be Rt + 1.
5086     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
5087     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
5088     if (Rt2 != Rt + 1)
5089       return Error(Operands[3]->getStartLoc(),
5090                    "source operands must be sequential");
5091     return false;
5092   }
5093   case ARM::STRD_PRE:
5094   case ARM::STRD_POST:
5095   case ARM::STREXD: {
5096     // Rt2 must be Rt + 1.
5097     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg());
5098     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg());
5099     if (Rt2 != Rt + 1)
5100       return Error(Operands[3]->getStartLoc(),
5101                    "source operands must be sequential");
5102     return false;
5103   }
5104   case ARM::SBFX:
5105   case ARM::UBFX: {
5106     // width must be in range [1, 32-lsb]
5107     unsigned lsb = Inst.getOperand(2).getImm();
5108     unsigned widthm1 = Inst.getOperand(3).getImm();
5109     if (widthm1 >= 32 - lsb)
5110       return Error(Operands[5]->getStartLoc(),
5111                    "bitfield width must be in range [1,32-lsb]");
5112     return false;
5113   }
5114   case ARM::tLDMIA: {
5115     // If we're parsing Thumb2, the .w variant is available and handles
5116     // most cases that are normally illegal for a Thumb1 LDM
5117     // instruction. We'll make the transformation in processInstruction()
5118     // if necessary.
5119     //
5120     // Thumb LDM instructions are writeback iff the base register is not
5121     // in the register list.
5122     unsigned Rn = Inst.getOperand(0).getReg();
5123     bool hasWritebackToken =
5124       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
5125        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
5126     bool listContainsBase;
5127     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) && !isThumbTwo())
5128       return Error(Operands[3 + hasWritebackToken]->getStartLoc(),
5129                    "registers must be in range r0-r7");
5130     // If we should have writeback, then there should be a '!' token.
5131     if (!listContainsBase && !hasWritebackToken && !isThumbTwo())
5132       return Error(Operands[2]->getStartLoc(),
5133                    "writeback operator '!' expected");
5134     // If we should not have writeback, there must not be a '!'. This is
5135     // true even for the 32-bit wide encodings.
5136     if (listContainsBase && hasWritebackToken)
5137       return Error(Operands[3]->getStartLoc(),
5138                    "writeback operator '!' not allowed when base register "
5139                    "in register list");
5140
5141     break;
5142   }
5143   case ARM::t2LDMIA_UPD: {
5144     if (listContainsReg(Inst, 3, Inst.getOperand(0).getReg()))
5145       return Error(Operands[4]->getStartLoc(),
5146                    "writeback operator '!' not allowed when base register "
5147                    "in register list");
5148     break;
5149   }
5150   // Like for ldm/stm, push and pop have hi-reg handling version in Thumb2,
5151   // so only issue a diagnostic for thumb1. The instructions will be
5152   // switched to the t2 encodings in processInstruction() if necessary.
5153   case ARM::tPOP: {
5154     bool listContainsBase;
5155     if (checkLowRegisterList(Inst, 2, 0, ARM::PC, listContainsBase) &&
5156         !isThumbTwo())
5157       return Error(Operands[2]->getStartLoc(),
5158                    "registers must be in range r0-r7 or pc");
5159     break;
5160   }
5161   case ARM::tPUSH: {
5162     bool listContainsBase;
5163     if (checkLowRegisterList(Inst, 2, 0, ARM::LR, listContainsBase) &&
5164         !isThumbTwo())
5165       return Error(Operands[2]->getStartLoc(),
5166                    "registers must be in range r0-r7 or lr");
5167     break;
5168   }
5169   case ARM::tSTMIA_UPD: {
5170     bool listContainsBase;
5171     if (checkLowRegisterList(Inst, 4, 0, 0, listContainsBase) && !isThumbTwo())
5172       return Error(Operands[4]->getStartLoc(),
5173                    "registers must be in range r0-r7");
5174     break;
5175   }
5176   }
5177
5178   return false;
5179 }
5180
5181 static unsigned getRealVSTOpcode(unsigned Opc, unsigned &Spacing) {
5182   switch(Opc) {
5183   default: assert(0 && "unexpected opcode!");
5184   // VST1LN
5185   case ARM::VST1LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VST1LNd8_UPD;
5186   case ARM::VST1LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST1LNd16_UPD;
5187   case ARM::VST1LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST1LNd32_UPD;
5188   case ARM::VST1LNdWB_register_Asm_8:  Spacing = 1; return ARM::VST1LNd8_UPD;
5189   case ARM::VST1LNdWB_register_Asm_16: Spacing = 1; return ARM::VST1LNd16_UPD;
5190   case ARM::VST1LNdWB_register_Asm_32: Spacing = 1; return ARM::VST1LNd32_UPD;
5191   case ARM::VST1LNdAsm_8:  Spacing = 1; return ARM::VST1LNd8;
5192   case ARM::VST1LNdAsm_16: Spacing = 1; return ARM::VST1LNd16;
5193   case ARM::VST1LNdAsm_32: Spacing = 1; return ARM::VST1LNd32;
5194
5195   // VST2LN
5196   case ARM::VST2LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VST2LNd8_UPD;
5197   case ARM::VST2LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST2LNd16_UPD;
5198   case ARM::VST2LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST2LNd32_UPD;
5199   case ARM::VST2LNqWB_fixed_Asm_16: Spacing = 2; return ARM::VST2LNq16_UPD;
5200   case ARM::VST2LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VST2LNq32_UPD;
5201
5202   case ARM::VST2LNdWB_register_Asm_8:  Spacing = 1; return ARM::VST2LNd8_UPD;
5203   case ARM::VST2LNdWB_register_Asm_16: Spacing = 1; return ARM::VST2LNd16_UPD;
5204   case ARM::VST2LNdWB_register_Asm_32: Spacing = 1; return ARM::VST2LNd32_UPD;
5205   case ARM::VST2LNqWB_register_Asm_16: Spacing = 2; return ARM::VST2LNq16_UPD;
5206   case ARM::VST2LNqWB_register_Asm_32: Spacing = 2; return ARM::VST2LNq32_UPD;
5207
5208   case ARM::VST2LNdAsm_8:  Spacing = 1; return ARM::VST2LNd8;
5209   case ARM::VST2LNdAsm_16: Spacing = 1; return ARM::VST2LNd16;
5210   case ARM::VST2LNdAsm_32: Spacing = 1; return ARM::VST2LNd32;
5211   case ARM::VST2LNqAsm_16: Spacing = 2; return ARM::VST2LNq16;
5212   case ARM::VST2LNqAsm_32: Spacing = 2; return ARM::VST2LNq32;
5213
5214   // VST3LN
5215   case ARM::VST3LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VST3LNd8_UPD;
5216   case ARM::VST3LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VST3LNd16_UPD;
5217   case ARM::VST3LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VST3LNd32_UPD;
5218   case ARM::VST3LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VST3LNq16_UPD;
5219   case ARM::VST3LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VST3LNq32_UPD;
5220   case ARM::VST3LNdWB_register_Asm_8:  Spacing = 1; return ARM::VST3LNd8_UPD;
5221   case ARM::VST3LNdWB_register_Asm_16: Spacing = 1; return ARM::VST3LNd16_UPD;
5222   case ARM::VST3LNdWB_register_Asm_32: Spacing = 1; return ARM::VST3LNd32_UPD;
5223   case ARM::VST3LNqWB_register_Asm_16: Spacing = 2; return ARM::VST3LNq16_UPD;
5224   case ARM::VST3LNqWB_register_Asm_32: Spacing = 2; return ARM::VST3LNq32_UPD;
5225   case ARM::VST3LNdAsm_8:  Spacing = 1; return ARM::VST3LNd8;
5226   case ARM::VST3LNdAsm_16: Spacing = 1; return ARM::VST3LNd16;
5227   case ARM::VST3LNdAsm_32: Spacing = 1; return ARM::VST3LNd32;
5228   case ARM::VST3LNqAsm_16: Spacing = 2; return ARM::VST3LNq16;
5229   case ARM::VST3LNqAsm_32: Spacing = 2; return ARM::VST3LNq32;
5230
5231   // VST3
5232   case ARM::VST3dWB_fixed_Asm_8:  Spacing = 1; return ARM::VST3d8_UPD;
5233   case ARM::VST3dWB_fixed_Asm_16: Spacing = 1; return ARM::VST3d16_UPD;
5234   case ARM::VST3dWB_fixed_Asm_32: Spacing = 1; return ARM::VST3d32_UPD;
5235   case ARM::VST3qWB_fixed_Asm_8:  Spacing = 2; return ARM::VST3q8_UPD;
5236   case ARM::VST3qWB_fixed_Asm_16: Spacing = 2; return ARM::VST3q16_UPD;
5237   case ARM::VST3qWB_fixed_Asm_32: Spacing = 2; return ARM::VST3q32_UPD;
5238   case ARM::VST3dWB_register_Asm_8:  Spacing = 1; return ARM::VST3d8_UPD;
5239   case ARM::VST3dWB_register_Asm_16: Spacing = 1; return ARM::VST3d16_UPD;
5240   case ARM::VST3dWB_register_Asm_32: Spacing = 1; return ARM::VST3d32_UPD;
5241   case ARM::VST3qWB_register_Asm_8:  Spacing = 2; return ARM::VST3q8_UPD;
5242   case ARM::VST3qWB_register_Asm_16: Spacing = 2; return ARM::VST3q16_UPD;
5243   case ARM::VST3qWB_register_Asm_32: Spacing = 2; return ARM::VST3q32_UPD;
5244   case ARM::VST3dAsm_8:  Spacing = 1; return ARM::VST3d8;
5245   case ARM::VST3dAsm_16: Spacing = 1; return ARM::VST3d16;
5246   case ARM::VST3dAsm_32: Spacing = 1; return ARM::VST3d32;
5247   case ARM::VST3qAsm_8:  Spacing = 2; return ARM::VST3q8;
5248   case ARM::VST3qAsm_16: Spacing = 2; return ARM::VST3q16;
5249   case ARM::VST3qAsm_32: Spacing = 2; return ARM::VST3q32;
5250   }
5251 }
5252
5253 static unsigned getRealVLDOpcode(unsigned Opc, unsigned &Spacing) {
5254   switch(Opc) {
5255   default: assert(0 && "unexpected opcode!");
5256   // VLD1LN
5257   case ARM::VLD1LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VLD1LNd8_UPD;
5258   case ARM::VLD1LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD1LNd16_UPD;
5259   case ARM::VLD1LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD1LNd32_UPD;
5260   case ARM::VLD1LNdWB_register_Asm_8:  Spacing = 1; return ARM::VLD1LNd8_UPD;
5261   case ARM::VLD1LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD1LNd16_UPD;
5262   case ARM::VLD1LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD1LNd32_UPD;
5263   case ARM::VLD1LNdAsm_8:  Spacing = 1; return ARM::VLD1LNd8;
5264   case ARM::VLD1LNdAsm_16: Spacing = 1; return ARM::VLD1LNd16;
5265   case ARM::VLD1LNdAsm_32: Spacing = 1; return ARM::VLD1LNd32;
5266
5267   // VLD2LN
5268   case ARM::VLD2LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VLD2LNd8_UPD;
5269   case ARM::VLD2LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD2LNd16_UPD;
5270   case ARM::VLD2LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD2LNd32_UPD;
5271   case ARM::VLD2LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD2LNq16_UPD;
5272   case ARM::VLD2LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD2LNq32_UPD;
5273   case ARM::VLD2LNdWB_register_Asm_8:  Spacing = 1; return ARM::VLD2LNd8_UPD;
5274   case ARM::VLD2LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD2LNd16_UPD;
5275   case ARM::VLD2LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD2LNd32_UPD;
5276   case ARM::VLD2LNqWB_register_Asm_16: Spacing = 2; return ARM::VLD2LNq16_UPD;
5277   case ARM::VLD2LNqWB_register_Asm_32: Spacing = 2; return ARM::VLD2LNq32_UPD;
5278   case ARM::VLD2LNdAsm_8:  Spacing = 1; return ARM::VLD2LNd8;
5279   case ARM::VLD2LNdAsm_16: Spacing = 1; return ARM::VLD2LNd16;
5280   case ARM::VLD2LNdAsm_32: Spacing = 1; return ARM::VLD2LNd32;
5281   case ARM::VLD2LNqAsm_16: Spacing = 2; return ARM::VLD2LNq16;
5282   case ARM::VLD2LNqAsm_32: Spacing = 2; return ARM::VLD2LNq32;
5283
5284   // VLD3LN
5285   case ARM::VLD3LNdWB_fixed_Asm_8:  Spacing = 1; return ARM::VLD3LNd8_UPD;
5286   case ARM::VLD3LNdWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3LNd16_UPD;
5287   case ARM::VLD3LNdWB_fixed_Asm_32: Spacing = 1; return ARM::VLD3LNd32_UPD;
5288   case ARM::VLD3LNqWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3LNq16_UPD;
5289   case ARM::VLD3LNqWB_fixed_Asm_32: Spacing = 2; return ARM::VLD3LNq32_UPD;
5290   case ARM::VLD3LNdWB_register_Asm_8:  Spacing = 1; return ARM::VLD3LNd8_UPD;
5291   case ARM::VLD3LNdWB_register_Asm_16: Spacing = 1; return ARM::VLD3LNd16_UPD;
5292   case ARM::VLD3LNdWB_register_Asm_32: Spacing = 1; return ARM::VLD3LNd32_UPD;
5293   case ARM::VLD3LNqWB_register_Asm_16: Spacing = 2; return ARM::VLD3LNq16_UPD;
5294   case ARM::VLD3LNqWB_register_Asm_32: Spacing = 2; return ARM::VLD3LNq32_UPD;
5295   case ARM::VLD3LNdAsm_8:  Spacing = 1; return ARM::VLD3LNd8;
5296   case ARM::VLD3LNdAsm_16: Spacing = 1; return ARM::VLD3LNd16;
5297   case ARM::VLD3LNdAsm_32: Spacing = 1; return ARM::VLD3LNd32;
5298   case ARM::VLD3LNqAsm_16: Spacing = 2; return ARM::VLD3LNq16;
5299   case ARM::VLD3LNqAsm_32: Spacing = 2; return ARM::VLD3LNq32;
5300
5301   // VLD3
5302   case ARM::VLD3dWB_fixed_Asm_8:  Spacing = 1; return ARM::VLD3d8_UPD;
5303   case ARM::VLD3dWB_fixed_Asm_16: Spacing = 1; return ARM::VLD3d16_UPD;
5304   case ARM::VLD3dWB_fixed_Asm_32: Spacing = 1; return ARM::VLD3d32_UPD;
5305   case ARM::VLD3qWB_fixed_Asm_8:  Spacing = 2; return ARM::VLD3q8_UPD;
5306   case ARM::VLD3qWB_fixed_Asm_16: Spacing = 2; return ARM::VLD3q16_UPD;
5307   case ARM::VLD3qWB_fixed_Asm_32: Spacing = 2; return ARM::VLD3q32_UPD;
5308   case ARM::VLD3dWB_register_Asm_8:  Spacing = 1; return ARM::VLD3d8_UPD;
5309   case ARM::VLD3dWB_register_Asm_16: Spacing = 1; return ARM::VLD3d16_UPD;
5310   case ARM::VLD3dWB_register_Asm_32: Spacing = 1; return ARM::VLD3d32_UPD;
5311   case ARM::VLD3qWB_register_Asm_8:  Spacing = 2; return ARM::VLD3q8_UPD;
5312   case ARM::VLD3qWB_register_Asm_16: Spacing = 2; return ARM::VLD3q16_UPD;
5313   case ARM::VLD3qWB_register_Asm_32: Spacing = 2; return ARM::VLD3q32_UPD;
5314   case ARM::VLD3dAsm_8:  Spacing = 1; return ARM::VLD3d8;
5315   case ARM::VLD3dAsm_16: Spacing = 1; return ARM::VLD3d16;
5316   case ARM::VLD3dAsm_32: Spacing = 1; return ARM::VLD3d32;
5317   case ARM::VLD3qAsm_8:  Spacing = 2; return ARM::VLD3q8;
5318   case ARM::VLD3qAsm_16: Spacing = 2; return ARM::VLD3q16;
5319   case ARM::VLD3qAsm_32: Spacing = 2; return ARM::VLD3q32;
5320   }
5321 }
5322
5323 bool ARMAsmParser::
5324 processInstruction(MCInst &Inst,
5325                    const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
5326   switch (Inst.getOpcode()) {
5327   // Aliases for alternate PC+imm syntax of LDR instructions.
5328   case ARM::t2LDRpcrel:
5329     Inst.setOpcode(ARM::t2LDRpci);
5330     return true;
5331   case ARM::t2LDRBpcrel:
5332     Inst.setOpcode(ARM::t2LDRBpci);
5333     return true;
5334   case ARM::t2LDRHpcrel:
5335     Inst.setOpcode(ARM::t2LDRHpci);
5336     return true;
5337   case ARM::t2LDRSBpcrel:
5338     Inst.setOpcode(ARM::t2LDRSBpci);
5339     return true;
5340   case ARM::t2LDRSHpcrel:
5341     Inst.setOpcode(ARM::t2LDRSHpci);
5342     return true;
5343   // Handle NEON VST complex aliases.
5344   case ARM::VST1LNdWB_register_Asm_8:
5345   case ARM::VST1LNdWB_register_Asm_16:
5346   case ARM::VST1LNdWB_register_Asm_32: {
5347     MCInst TmpInst;
5348     // Shuffle the operands around so the lane index operand is in the
5349     // right place.
5350     unsigned Spacing;
5351     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5352     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5353     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5354     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5355     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5356     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5357     TmpInst.addOperand(Inst.getOperand(1)); // lane
5358     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5359     TmpInst.addOperand(Inst.getOperand(6));
5360     Inst = TmpInst;
5361     return true;
5362   }
5363
5364   case ARM::VST2LNdWB_register_Asm_8:
5365   case ARM::VST2LNdWB_register_Asm_16:
5366   case ARM::VST2LNdWB_register_Asm_32:
5367   case ARM::VST2LNqWB_register_Asm_16:
5368   case ARM::VST2LNqWB_register_Asm_32: {
5369     MCInst TmpInst;
5370     // Shuffle the operands around so the lane index operand is in the
5371     // right place.
5372     unsigned Spacing;
5373     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5374     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5375     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5376     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5377     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5378     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5379     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5380                                             Spacing));
5381     TmpInst.addOperand(Inst.getOperand(1)); // lane
5382     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5383     TmpInst.addOperand(Inst.getOperand(6));
5384     Inst = TmpInst;
5385     return true;
5386   }
5387
5388   case ARM::VST3LNdWB_register_Asm_8:
5389   case ARM::VST3LNdWB_register_Asm_16:
5390   case ARM::VST3LNdWB_register_Asm_32:
5391   case ARM::VST3LNqWB_register_Asm_16:
5392   case ARM::VST3LNqWB_register_Asm_32: {
5393     MCInst TmpInst;
5394     // Shuffle the operands around so the lane index operand is in the
5395     // right place.
5396     unsigned Spacing;
5397     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5398     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5399     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5400     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5401     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5402     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5403     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5404                                             Spacing));
5405     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5406                                             Spacing * 2));
5407     TmpInst.addOperand(Inst.getOperand(1)); // lane
5408     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5409     TmpInst.addOperand(Inst.getOperand(6));
5410     Inst = TmpInst;
5411     return true;
5412   }
5413
5414   case ARM::VST1LNdWB_fixed_Asm_8:
5415   case ARM::VST1LNdWB_fixed_Asm_16:
5416   case ARM::VST1LNdWB_fixed_Asm_32: {
5417     MCInst TmpInst;
5418     // Shuffle the operands around so the lane index operand is in the
5419     // right place.
5420     unsigned Spacing;
5421     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5422     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5423     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5424     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5425     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5426     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5427     TmpInst.addOperand(Inst.getOperand(1)); // lane
5428     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5429     TmpInst.addOperand(Inst.getOperand(5));
5430     Inst = TmpInst;
5431     return true;
5432   }
5433
5434   case ARM::VST2LNdWB_fixed_Asm_8:
5435   case ARM::VST2LNdWB_fixed_Asm_16:
5436   case ARM::VST2LNdWB_fixed_Asm_32:
5437   case ARM::VST2LNqWB_fixed_Asm_16:
5438   case ARM::VST2LNqWB_fixed_Asm_32: {
5439     MCInst TmpInst;
5440     // Shuffle the operands around so the lane index operand is in the
5441     // right place.
5442     unsigned Spacing;
5443     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5444     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5445     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5446     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5447     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5448     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5449     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5450                                             Spacing));
5451     TmpInst.addOperand(Inst.getOperand(1)); // lane
5452     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5453     TmpInst.addOperand(Inst.getOperand(5));
5454     Inst = TmpInst;
5455     return true;
5456   }
5457
5458   case ARM::VST3LNdWB_fixed_Asm_8:
5459   case ARM::VST3LNdWB_fixed_Asm_16:
5460   case ARM::VST3LNdWB_fixed_Asm_32:
5461   case ARM::VST3LNqWB_fixed_Asm_16:
5462   case ARM::VST3LNqWB_fixed_Asm_32: {
5463     MCInst TmpInst;
5464     // Shuffle the operands around so the lane index operand is in the
5465     // right place.
5466     unsigned Spacing;
5467     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5468     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5469     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5470     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5471     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5472     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5473     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5474                                             Spacing));
5475     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5476                                             Spacing * 2));
5477     TmpInst.addOperand(Inst.getOperand(1)); // lane
5478     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5479     TmpInst.addOperand(Inst.getOperand(5));
5480     Inst = TmpInst;
5481     return true;
5482   }
5483
5484   case ARM::VST1LNdAsm_8:
5485   case ARM::VST1LNdAsm_16:
5486   case ARM::VST1LNdAsm_32: {
5487     MCInst TmpInst;
5488     // Shuffle the operands around so the lane index operand is in the
5489     // right place.
5490     unsigned Spacing;
5491     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5492     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5493     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5494     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5495     TmpInst.addOperand(Inst.getOperand(1)); // lane
5496     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5497     TmpInst.addOperand(Inst.getOperand(5));
5498     Inst = TmpInst;
5499     return true;
5500   }
5501
5502   case ARM::VST2LNdAsm_8:
5503   case ARM::VST2LNdAsm_16:
5504   case ARM::VST2LNdAsm_32:
5505   case ARM::VST2LNqAsm_16:
5506   case ARM::VST2LNqAsm_32: {
5507     MCInst TmpInst;
5508     // Shuffle the operands around so the lane index operand is in the
5509     // right place.
5510     unsigned Spacing;
5511     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5512     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5513     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5514     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5515     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5516                                             Spacing));
5517     TmpInst.addOperand(Inst.getOperand(1)); // lane
5518     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5519     TmpInst.addOperand(Inst.getOperand(5));
5520     Inst = TmpInst;
5521     return true;
5522   }
5523
5524   case ARM::VST3LNdAsm_8:
5525   case ARM::VST3LNdAsm_16:
5526   case ARM::VST3LNdAsm_32:
5527   case ARM::VST3LNqAsm_16:
5528   case ARM::VST3LNqAsm_32: {
5529     MCInst TmpInst;
5530     // Shuffle the operands around so the lane index operand is in the
5531     // right place.
5532     unsigned Spacing;
5533     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5534     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5535     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5536     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5537     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5538                                             Spacing));
5539     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5540                                             Spacing * 2));
5541     TmpInst.addOperand(Inst.getOperand(1)); // lane
5542     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5543     TmpInst.addOperand(Inst.getOperand(5));
5544     Inst = TmpInst;
5545     return true;
5546   }
5547
5548   // Handle NEON VLD complex aliases.
5549   case ARM::VLD1LNdWB_register_Asm_8:
5550   case ARM::VLD1LNdWB_register_Asm_16:
5551   case ARM::VLD1LNdWB_register_Asm_32: {
5552     MCInst TmpInst;
5553     // Shuffle the operands around so the lane index operand is in the
5554     // right place.
5555     unsigned Spacing;
5556     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5557     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5558     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5559     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5560     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5561     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5562     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5563     TmpInst.addOperand(Inst.getOperand(1)); // lane
5564     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5565     TmpInst.addOperand(Inst.getOperand(6));
5566     Inst = TmpInst;
5567     return true;
5568   }
5569
5570   case ARM::VLD2LNdWB_register_Asm_8:
5571   case ARM::VLD2LNdWB_register_Asm_16:
5572   case ARM::VLD2LNdWB_register_Asm_32:
5573   case ARM::VLD2LNqWB_register_Asm_16:
5574   case ARM::VLD2LNqWB_register_Asm_32: {
5575     MCInst TmpInst;
5576     // Shuffle the operands around so the lane index operand is in the
5577     // right place.
5578     unsigned Spacing;
5579     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5580     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5581     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5582                                             Spacing));
5583     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5584     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5585     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5586     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5587     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5588     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5589                                             Spacing));
5590     TmpInst.addOperand(Inst.getOperand(1)); // lane
5591     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5592     TmpInst.addOperand(Inst.getOperand(6));
5593     Inst = TmpInst;
5594     return true;
5595   }
5596
5597   case ARM::VLD3LNdWB_register_Asm_8:
5598   case ARM::VLD3LNdWB_register_Asm_16:
5599   case ARM::VLD3LNdWB_register_Asm_32:
5600   case ARM::VLD3LNqWB_register_Asm_16:
5601   case ARM::VLD3LNqWB_register_Asm_32: {
5602     MCInst TmpInst;
5603     // Shuffle the operands around so the lane index operand is in the
5604     // right place.
5605     unsigned Spacing;
5606     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5607     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5608     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5609                                             Spacing));
5610     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5611                                             Spacing * 2));
5612     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5613     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5614     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5615     TmpInst.addOperand(Inst.getOperand(4)); // Rm
5616     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5617     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5618                                             Spacing));
5619     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5620                                             Spacing * 2));
5621     TmpInst.addOperand(Inst.getOperand(1)); // lane
5622     TmpInst.addOperand(Inst.getOperand(5)); // CondCode
5623     TmpInst.addOperand(Inst.getOperand(6));
5624     Inst = TmpInst;
5625     return true;
5626   }
5627
5628   case ARM::VLD1LNdWB_fixed_Asm_8:
5629   case ARM::VLD1LNdWB_fixed_Asm_16:
5630   case ARM::VLD1LNdWB_fixed_Asm_32: {
5631     MCInst TmpInst;
5632     // Shuffle the operands around so the lane index operand is in the
5633     // right place.
5634     unsigned Spacing;
5635     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5636     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5637     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5638     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5639     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5640     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5641     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5642     TmpInst.addOperand(Inst.getOperand(1)); // lane
5643     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5644     TmpInst.addOperand(Inst.getOperand(5));
5645     Inst = TmpInst;
5646     return true;
5647   }
5648
5649   case ARM::VLD2LNdWB_fixed_Asm_8:
5650   case ARM::VLD2LNdWB_fixed_Asm_16:
5651   case ARM::VLD2LNdWB_fixed_Asm_32:
5652   case ARM::VLD2LNqWB_fixed_Asm_16:
5653   case ARM::VLD2LNqWB_fixed_Asm_32: {
5654     MCInst TmpInst;
5655     // Shuffle the operands around so the lane index operand is in the
5656     // right place.
5657     unsigned Spacing;
5658     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5659     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5660     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5661                                             Spacing));
5662     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5663     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5664     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5665     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5666     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5667     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5668                                             Spacing));
5669     TmpInst.addOperand(Inst.getOperand(1)); // lane
5670     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5671     TmpInst.addOperand(Inst.getOperand(5));
5672     Inst = TmpInst;
5673     return true;
5674   }
5675
5676   case ARM::VLD3LNdWB_fixed_Asm_8:
5677   case ARM::VLD3LNdWB_fixed_Asm_16:
5678   case ARM::VLD3LNdWB_fixed_Asm_32:
5679   case ARM::VLD3LNqWB_fixed_Asm_16:
5680   case ARM::VLD3LNqWB_fixed_Asm_32: {
5681     MCInst TmpInst;
5682     // Shuffle the operands around so the lane index operand is in the
5683     // right place.
5684     unsigned Spacing;
5685     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5686     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5687     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5688                                             Spacing));
5689     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5690                                             Spacing * 2));
5691     TmpInst.addOperand(Inst.getOperand(2)); // Rn_wb
5692     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5693     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5694     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5695     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5696     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5697                                             Spacing));
5698     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5699                                             Spacing * 2));
5700     TmpInst.addOperand(Inst.getOperand(1)); // lane
5701     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5702     TmpInst.addOperand(Inst.getOperand(5));
5703     Inst = TmpInst;
5704     return true;
5705   }
5706
5707   case ARM::VLD1LNdAsm_8:
5708   case ARM::VLD1LNdAsm_16:
5709   case ARM::VLD1LNdAsm_32: {
5710     MCInst TmpInst;
5711     // Shuffle the operands around so the lane index operand is in the
5712     // right place.
5713     unsigned Spacing;
5714     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5715     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5716     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5717     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5718     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5719     TmpInst.addOperand(Inst.getOperand(1)); // lane
5720     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5721     TmpInst.addOperand(Inst.getOperand(5));
5722     Inst = TmpInst;
5723     return true;
5724   }
5725
5726   case ARM::VLD2LNdAsm_8:
5727   case ARM::VLD2LNdAsm_16:
5728   case ARM::VLD2LNdAsm_32:
5729   case ARM::VLD2LNqAsm_16:
5730   case ARM::VLD2LNqAsm_32: {
5731     MCInst TmpInst;
5732     // Shuffle the operands around so the lane index operand is in the
5733     // right place.
5734     unsigned Spacing;
5735     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5736     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5737     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5738                                             Spacing));
5739     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5740     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5741     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5742     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5743                                             Spacing));
5744     TmpInst.addOperand(Inst.getOperand(1)); // lane
5745     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5746     TmpInst.addOperand(Inst.getOperand(5));
5747     Inst = TmpInst;
5748     return true;
5749   }
5750
5751   case ARM::VLD3LNdAsm_8:
5752   case ARM::VLD3LNdAsm_16:
5753   case ARM::VLD3LNdAsm_32:
5754   case ARM::VLD3LNqAsm_16:
5755   case ARM::VLD3LNqAsm_32: {
5756     MCInst TmpInst;
5757     // Shuffle the operands around so the lane index operand is in the
5758     // right place.
5759     unsigned Spacing;
5760     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5761     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5762     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5763                                             Spacing));
5764     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5765                                             Spacing * 2));
5766     TmpInst.addOperand(Inst.getOperand(2)); // Rn
5767     TmpInst.addOperand(Inst.getOperand(3)); // alignment
5768     TmpInst.addOperand(Inst.getOperand(0)); // Tied operand src (== Vd)
5769     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5770                                             Spacing));
5771     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5772                                             Spacing * 2));
5773     TmpInst.addOperand(Inst.getOperand(1)); // lane
5774     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5775     TmpInst.addOperand(Inst.getOperand(5));
5776     Inst = TmpInst;
5777     return true;
5778   }
5779
5780   // VLD3 multiple 3-element structure instructions.
5781   case ARM::VLD3dAsm_8:
5782   case ARM::VLD3dAsm_16:
5783   case ARM::VLD3dAsm_32:
5784   case ARM::VLD3qAsm_8:
5785   case ARM::VLD3qAsm_16:
5786   case ARM::VLD3qAsm_32: {
5787     MCInst TmpInst;
5788     unsigned Spacing;
5789     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5790     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5791     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5792                                             Spacing));
5793     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5794                                             Spacing * 2));
5795     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5796     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5797     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
5798     TmpInst.addOperand(Inst.getOperand(4));
5799     Inst = TmpInst;
5800     return true;
5801   }
5802
5803   case ARM::VLD3dWB_fixed_Asm_8:
5804   case ARM::VLD3dWB_fixed_Asm_16:
5805   case ARM::VLD3dWB_fixed_Asm_32:
5806   case ARM::VLD3qWB_fixed_Asm_8:
5807   case ARM::VLD3qWB_fixed_Asm_16:
5808   case ARM::VLD3qWB_fixed_Asm_32: {
5809     MCInst TmpInst;
5810     unsigned Spacing;
5811     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5812     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5813     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5814                                             Spacing));
5815     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5816                                             Spacing * 2));
5817     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5818     TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn
5819     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5820     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5821     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
5822     TmpInst.addOperand(Inst.getOperand(4));
5823     Inst = TmpInst;
5824     return true;
5825   }
5826
5827   case ARM::VLD3dWB_register_Asm_8:
5828   case ARM::VLD3dWB_register_Asm_16:
5829   case ARM::VLD3dWB_register_Asm_32:
5830   case ARM::VLD3qWB_register_Asm_8:
5831   case ARM::VLD3qWB_register_Asm_16:
5832   case ARM::VLD3qWB_register_Asm_32: {
5833     MCInst TmpInst;
5834     unsigned Spacing;
5835     TmpInst.setOpcode(getRealVLDOpcode(Inst.getOpcode(), Spacing));
5836     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5837     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5838                                             Spacing));
5839     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5840                                             Spacing * 2));
5841     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5842     TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn
5843     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5844     TmpInst.addOperand(Inst.getOperand(3)); // Rm
5845     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5846     TmpInst.addOperand(Inst.getOperand(5));
5847     Inst = TmpInst;
5848     return true;
5849   }
5850
5851   // VST3 multiple 3-element structure instructions.
5852   case ARM::VST3dAsm_8:
5853   case ARM::VST3dAsm_16:
5854   case ARM::VST3dAsm_32:
5855   case ARM::VST3qAsm_8:
5856   case ARM::VST3qAsm_16:
5857   case ARM::VST3qAsm_32: {
5858     MCInst TmpInst;
5859     unsigned Spacing;
5860     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5861     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5862     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5863     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5864     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5865                                             Spacing));
5866     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5867                                             Spacing * 2));
5868     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
5869     TmpInst.addOperand(Inst.getOperand(4));
5870     Inst = TmpInst;
5871     return true;
5872   }
5873
5874   case ARM::VST3dWB_fixed_Asm_8:
5875   case ARM::VST3dWB_fixed_Asm_16:
5876   case ARM::VST3dWB_fixed_Asm_32:
5877   case ARM::VST3qWB_fixed_Asm_8:
5878   case ARM::VST3qWB_fixed_Asm_16:
5879   case ARM::VST3qWB_fixed_Asm_32: {
5880     MCInst TmpInst;
5881     unsigned Spacing;
5882     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5883     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5884     TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn
5885     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5886     TmpInst.addOperand(MCOperand::CreateReg(0)); // Rm
5887     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5888     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5889                                             Spacing));
5890     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5891                                             Spacing * 2));
5892     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
5893     TmpInst.addOperand(Inst.getOperand(4));
5894     Inst = TmpInst;
5895     return true;
5896   }
5897
5898   case ARM::VST3dWB_register_Asm_8:
5899   case ARM::VST3dWB_register_Asm_16:
5900   case ARM::VST3dWB_register_Asm_32:
5901   case ARM::VST3qWB_register_Asm_8:
5902   case ARM::VST3qWB_register_Asm_16:
5903   case ARM::VST3qWB_register_Asm_32: {
5904     MCInst TmpInst;
5905     unsigned Spacing;
5906     TmpInst.setOpcode(getRealVSTOpcode(Inst.getOpcode(), Spacing));
5907     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5908     TmpInst.addOperand(Inst.getOperand(1)); // Rn_wb == tied Rn
5909     TmpInst.addOperand(Inst.getOperand(2)); // alignment
5910     TmpInst.addOperand(Inst.getOperand(3)); // Rm
5911     TmpInst.addOperand(Inst.getOperand(0)); // Vd
5912     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5913                                             Spacing));
5914     TmpInst.addOperand(MCOperand::CreateReg(Inst.getOperand(0).getReg() +
5915                                             Spacing * 2));
5916     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5917     TmpInst.addOperand(Inst.getOperand(5));
5918     Inst = TmpInst;
5919     return true;
5920   }
5921
5922   // Handle the Thumb2 mode MOV complex aliases.
5923   case ARM::t2MOVsr:
5924   case ARM::t2MOVSsr: {
5925     // Which instruction to expand to depends on the CCOut operand and
5926     // whether we're in an IT block if the register operands are low
5927     // registers.
5928     bool isNarrow = false;
5929     if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
5930         isARMLowRegister(Inst.getOperand(1).getReg()) &&
5931         isARMLowRegister(Inst.getOperand(2).getReg()) &&
5932         Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg() &&
5933         inITBlock() == (Inst.getOpcode() == ARM::t2MOVsr))
5934       isNarrow = true;
5935     MCInst TmpInst;
5936     unsigned newOpc;
5937     switch(ARM_AM::getSORegShOp(Inst.getOperand(3).getImm())) {
5938     default: llvm_unreachable("unexpected opcode!");
5939     case ARM_AM::asr: newOpc = isNarrow ? ARM::tASRrr : ARM::t2ASRrr; break;
5940     case ARM_AM::lsr: newOpc = isNarrow ? ARM::tLSRrr : ARM::t2LSRrr; break;
5941     case ARM_AM::lsl: newOpc = isNarrow ? ARM::tLSLrr : ARM::t2LSLrr; break;
5942     case ARM_AM::ror: newOpc = isNarrow ? ARM::tROR   : ARM::t2RORrr; break;
5943     }
5944     TmpInst.setOpcode(newOpc);
5945     TmpInst.addOperand(Inst.getOperand(0)); // Rd
5946     if (isNarrow)
5947       TmpInst.addOperand(MCOperand::CreateReg(
5948           Inst.getOpcode() == ARM::t2MOVSsr ? ARM::CPSR : 0));
5949     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5950     TmpInst.addOperand(Inst.getOperand(2)); // Rm
5951     TmpInst.addOperand(Inst.getOperand(4)); // CondCode
5952     TmpInst.addOperand(Inst.getOperand(5));
5953     if (!isNarrow)
5954       TmpInst.addOperand(MCOperand::CreateReg(
5955           Inst.getOpcode() == ARM::t2MOVSsr ? ARM::CPSR : 0));
5956     Inst = TmpInst;
5957     return true;
5958   }
5959   case ARM::t2MOVsi:
5960   case ARM::t2MOVSsi: {
5961     // Which instruction to expand to depends on the CCOut operand and
5962     // whether we're in an IT block if the register operands are low
5963     // registers.
5964     bool isNarrow = false;
5965     if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
5966         isARMLowRegister(Inst.getOperand(1).getReg()) &&
5967         inITBlock() == (Inst.getOpcode() == ARM::t2MOVsi))
5968       isNarrow = true;
5969     MCInst TmpInst;
5970     unsigned newOpc;
5971     switch(ARM_AM::getSORegShOp(Inst.getOperand(2).getImm())) {
5972     default: llvm_unreachable("unexpected opcode!");
5973     case ARM_AM::asr: newOpc = isNarrow ? ARM::tASRri : ARM::t2ASRri; break;
5974     case ARM_AM::lsr: newOpc = isNarrow ? ARM::tLSRri : ARM::t2LSRri; break;
5975     case ARM_AM::lsl: newOpc = isNarrow ? ARM::tLSLri : ARM::t2LSLri; break;
5976     case ARM_AM::ror: newOpc = ARM::t2RORri; isNarrow = false; break;
5977     case ARM_AM::rrx: isNarrow = false; newOpc = ARM::t2RRX; break;
5978     }
5979     unsigned Ammount = ARM_AM::getSORegOffset(Inst.getOperand(2).getImm());
5980     if (Ammount == 32) Ammount = 0;
5981     TmpInst.setOpcode(newOpc);
5982     TmpInst.addOperand(Inst.getOperand(0)); // Rd
5983     if (isNarrow)
5984       TmpInst.addOperand(MCOperand::CreateReg(
5985           Inst.getOpcode() == ARM::t2MOVSsi ? ARM::CPSR : 0));
5986     TmpInst.addOperand(Inst.getOperand(1)); // Rn
5987     if (newOpc != ARM::t2RRX)
5988       TmpInst.addOperand(MCOperand::CreateImm(Ammount));
5989     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
5990     TmpInst.addOperand(Inst.getOperand(4));
5991     if (!isNarrow)
5992       TmpInst.addOperand(MCOperand::CreateReg(
5993           Inst.getOpcode() == ARM::t2MOVSsi ? ARM::CPSR : 0));
5994     Inst = TmpInst;
5995     return true;
5996   }
5997   // Handle the ARM mode MOV complex aliases.
5998   case ARM::ASRr:
5999   case ARM::LSRr:
6000   case ARM::LSLr:
6001   case ARM::RORr: {
6002     ARM_AM::ShiftOpc ShiftTy;
6003     switch(Inst.getOpcode()) {
6004     default: llvm_unreachable("unexpected opcode!");
6005     case ARM::ASRr: ShiftTy = ARM_AM::asr; break;
6006     case ARM::LSRr: ShiftTy = ARM_AM::lsr; break;
6007     case ARM::LSLr: ShiftTy = ARM_AM::lsl; break;
6008     case ARM::RORr: ShiftTy = ARM_AM::ror; break;
6009     }
6010     unsigned Shifter = ARM_AM::getSORegOpc(ShiftTy, 0);
6011     MCInst TmpInst;
6012     TmpInst.setOpcode(ARM::MOVsr);
6013     TmpInst.addOperand(Inst.getOperand(0)); // Rd
6014     TmpInst.addOperand(Inst.getOperand(1)); // Rn
6015     TmpInst.addOperand(Inst.getOperand(2)); // Rm
6016     TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty
6017     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
6018     TmpInst.addOperand(Inst.getOperand(4));
6019     TmpInst.addOperand(Inst.getOperand(5)); // cc_out
6020     Inst = TmpInst;
6021     return true;
6022   }
6023   case ARM::ASRi:
6024   case ARM::LSRi:
6025   case ARM::LSLi:
6026   case ARM::RORi: {
6027     ARM_AM::ShiftOpc ShiftTy;
6028     switch(Inst.getOpcode()) {
6029     default: llvm_unreachable("unexpected opcode!");
6030     case ARM::ASRi: ShiftTy = ARM_AM::asr; break;
6031     case ARM::LSRi: ShiftTy = ARM_AM::lsr; break;
6032     case ARM::LSLi: ShiftTy = ARM_AM::lsl; break;
6033     case ARM::RORi: ShiftTy = ARM_AM::ror; break;
6034     }
6035     // A shift by zero is a plain MOVr, not a MOVsi.
6036     unsigned Amt = Inst.getOperand(2).getImm();
6037     unsigned Opc = Amt == 0 ? ARM::MOVr : ARM::MOVsi;
6038     unsigned Shifter = ARM_AM::getSORegOpc(ShiftTy, Amt);
6039     MCInst TmpInst;
6040     TmpInst.setOpcode(Opc);
6041     TmpInst.addOperand(Inst.getOperand(0)); // Rd
6042     TmpInst.addOperand(Inst.getOperand(1)); // Rn
6043     if (Opc == ARM::MOVsi)
6044       TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty
6045     TmpInst.addOperand(Inst.getOperand(3)); // CondCode
6046     TmpInst.addOperand(Inst.getOperand(4));
6047     TmpInst.addOperand(Inst.getOperand(5)); // cc_out
6048     Inst = TmpInst;
6049     return true;
6050   }
6051   case ARM::RRXi: {
6052     unsigned Shifter = ARM_AM::getSORegOpc(ARM_AM::rrx, 0);
6053     MCInst TmpInst;
6054     TmpInst.setOpcode(ARM::MOVsi);
6055     TmpInst.addOperand(Inst.getOperand(0)); // Rd
6056     TmpInst.addOperand(Inst.getOperand(1)); // Rn
6057     TmpInst.addOperand(MCOperand::CreateImm(Shifter)); // Shift value and ty
6058     TmpInst.addOperand(Inst.getOperand(2)); // CondCode
6059     TmpInst.addOperand(Inst.getOperand(3));
6060     TmpInst.addOperand(Inst.getOperand(4)); // cc_out
6061     Inst = TmpInst;
6062     return true;
6063   }
6064   case ARM::t2LDMIA_UPD: {
6065     // If this is a load of a single register, then we should use
6066     // a post-indexed LDR instruction instead, per the ARM ARM.
6067     if (Inst.getNumOperands() != 5)
6068       return false;
6069     MCInst TmpInst;
6070     TmpInst.setOpcode(ARM::t2LDR_POST);
6071     TmpInst.addOperand(Inst.getOperand(4)); // Rt
6072     TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
6073     TmpInst.addOperand(Inst.getOperand(1)); // Rn
6074     TmpInst.addOperand(MCOperand::CreateImm(4));
6075     TmpInst.addOperand(Inst.getOperand(2)); // CondCode
6076     TmpInst.addOperand(Inst.getOperand(3));
6077     Inst = TmpInst;
6078     return true;
6079   }
6080   case ARM::t2STMDB_UPD: {
6081     // If this is a store of a single register, then we should use
6082     // a pre-indexed STR instruction instead, per the ARM ARM.
6083     if (Inst.getNumOperands() != 5)
6084       return false;
6085     MCInst TmpInst;
6086     TmpInst.setOpcode(ARM::t2STR_PRE);
6087     TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
6088     TmpInst.addOperand(Inst.getOperand(4)); // Rt
6089     TmpInst.addOperand(Inst.getOperand(1)); // Rn
6090     TmpInst.addOperand(MCOperand::CreateImm(-4));
6091     TmpInst.addOperand(Inst.getOperand(2)); // CondCode
6092     TmpInst.addOperand(Inst.getOperand(3));
6093     Inst = TmpInst;
6094     return true;
6095   }
6096   case ARM::LDMIA_UPD:
6097     // If this is a load of a single register via a 'pop', then we should use
6098     // a post-indexed LDR instruction instead, per the ARM ARM.
6099     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" &&
6100         Inst.getNumOperands() == 5) {
6101       MCInst TmpInst;
6102       TmpInst.setOpcode(ARM::LDR_POST_IMM);
6103       TmpInst.addOperand(Inst.getOperand(4)); // Rt
6104       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
6105       TmpInst.addOperand(Inst.getOperand(1)); // Rn
6106       TmpInst.addOperand(MCOperand::CreateReg(0));  // am2offset
6107       TmpInst.addOperand(MCOperand::CreateImm(4));
6108       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
6109       TmpInst.addOperand(Inst.getOperand(3));
6110       Inst = TmpInst;
6111       return true;
6112     }
6113     break;
6114   case ARM::STMDB_UPD:
6115     // If this is a store of a single register via a 'push', then we should use
6116     // a pre-indexed STR instruction instead, per the ARM ARM.
6117     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" &&
6118         Inst.getNumOperands() == 5) {
6119       MCInst TmpInst;
6120       TmpInst.setOpcode(ARM::STR_PRE_IMM);
6121       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
6122       TmpInst.addOperand(Inst.getOperand(4)); // Rt
6123       TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12
6124       TmpInst.addOperand(MCOperand::CreateImm(-4));
6125       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
6126       TmpInst.addOperand(Inst.getOperand(3));
6127       Inst = TmpInst;
6128     }
6129     break;
6130   case ARM::t2ADDri12:
6131     // If the immediate fits for encoding T3 (t2ADDri) and the generic "add"
6132     // mnemonic was used (not "addw"), encoding T3 is preferred.
6133     if (static_cast<ARMOperand*>(Operands[0])->getToken() != "add" ||
6134         ARM_AM::getT2SOImmVal(Inst.getOperand(2).getImm()) == -1)
6135       break;
6136     Inst.setOpcode(ARM::t2ADDri);
6137     Inst.addOperand(MCOperand::CreateReg(0)); // cc_out
6138     break;
6139   case ARM::t2SUBri12:
6140     // If the immediate fits for encoding T3 (t2SUBri) and the generic "sub"
6141     // mnemonic was used (not "subw"), encoding T3 is preferred.
6142     if (static_cast<ARMOperand*>(Operands[0])->getToken() != "sub" ||
6143         ARM_AM::getT2SOImmVal(Inst.getOperand(2).getImm()) == -1)
6144       break;
6145     Inst.setOpcode(ARM::t2SUBri);
6146     Inst.addOperand(MCOperand::CreateReg(0)); // cc_out
6147     break;
6148   case ARM::tADDi8:
6149     // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
6150     // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
6151     // to encoding T2 if <Rd> is specified and encoding T2 is preferred
6152     // to encoding T1 if <Rd> is omitted."
6153     if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) {
6154       Inst.setOpcode(ARM::tADDi3);
6155       return true;
6156     }
6157     break;
6158   case ARM::tSUBi8:
6159     // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
6160     // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
6161     // to encoding T2 if <Rd> is specified and encoding T2 is preferred
6162     // to encoding T1 if <Rd> is omitted."
6163     if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6) {
6164       Inst.setOpcode(ARM::tSUBi3);
6165       return true;
6166     }
6167     break;
6168   case ARM::t2ADDrr: {
6169     // If the destination and first source operand are the same, and
6170     // there's no setting of the flags, use encoding T2 instead of T3.
6171     // Note that this is only for ADD, not SUB. This mirrors the system
6172     // 'as' behaviour. Make sure the wide encoding wasn't explicit.
6173     if (Inst.getOperand(0).getReg() != Inst.getOperand(1).getReg() ||
6174         Inst.getOperand(5).getReg() != 0 ||
6175         (static_cast<ARMOperand*>(Operands[3])->isToken() &&
6176          static_cast<ARMOperand*>(Operands[3])->getToken() == ".w"))
6177       break;
6178     MCInst TmpInst;
6179     TmpInst.setOpcode(ARM::tADDhirr);
6180     TmpInst.addOperand(Inst.getOperand(0));
6181     TmpInst.addOperand(Inst.getOperand(0));
6182     TmpInst.addOperand(Inst.getOperand(2));
6183     TmpInst.addOperand(Inst.getOperand(3));
6184     TmpInst.addOperand(Inst.getOperand(4));
6185     Inst = TmpInst;
6186     return true;
6187   }
6188   case ARM::tB:
6189     // A Thumb conditional branch outside of an IT block is a tBcc.
6190     if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock()) {
6191       Inst.setOpcode(ARM::tBcc);
6192       return true;
6193     }
6194     break;
6195   case ARM::t2B:
6196     // A Thumb2 conditional branch outside of an IT block is a t2Bcc.
6197     if (Inst.getOperand(1).getImm() != ARMCC::AL && !inITBlock()){
6198       Inst.setOpcode(ARM::t2Bcc);
6199       return true;
6200     }
6201     break;
6202   case ARM::t2Bcc:
6203     // If the conditional is AL or we're in an IT block, we really want t2B.
6204     if (Inst.getOperand(1).getImm() == ARMCC::AL || inITBlock()) {
6205       Inst.setOpcode(ARM::t2B);
6206       return true;
6207     }
6208     break;
6209   case ARM::tBcc:
6210     // If the conditional is AL, we really want tB.
6211     if (Inst.getOperand(1).getImm() == ARMCC::AL) {
6212       Inst.setOpcode(ARM::tB);
6213       return true;
6214     }
6215     break;
6216   case ARM::tLDMIA: {
6217     // If the register list contains any high registers, or if the writeback
6218     // doesn't match what tLDMIA can do, we need to use the 32-bit encoding
6219     // instead if we're in Thumb2. Otherwise, this should have generated
6220     // an error in validateInstruction().
6221     unsigned Rn = Inst.getOperand(0).getReg();
6222     bool hasWritebackToken =
6223       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
6224        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
6225     bool listContainsBase;
6226     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) ||
6227         (!listContainsBase && !hasWritebackToken) ||
6228         (listContainsBase && hasWritebackToken)) {
6229       // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
6230       assert (isThumbTwo());
6231       Inst.setOpcode(hasWritebackToken ? ARM::t2LDMIA_UPD : ARM::t2LDMIA);
6232       // If we're switching to the updating version, we need to insert
6233       // the writeback tied operand.
6234       if (hasWritebackToken)
6235         Inst.insert(Inst.begin(),
6236                     MCOperand::CreateReg(Inst.getOperand(0).getReg()));
6237       return true;
6238     }
6239     break;
6240   }
6241   case ARM::tSTMIA_UPD: {
6242     // If the register list contains any high registers, we need to use
6243     // the 32-bit encoding instead if we're in Thumb2. Otherwise, this
6244     // should have generated an error in validateInstruction().
6245     unsigned Rn = Inst.getOperand(0).getReg();
6246     bool listContainsBase;
6247     if (checkLowRegisterList(Inst, 4, Rn, 0, listContainsBase)) {
6248       // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
6249       assert (isThumbTwo());
6250       Inst.setOpcode(ARM::t2STMIA_UPD);
6251       return true;
6252     }
6253     break;
6254   }
6255   case ARM::tPOP: {
6256     bool listContainsBase;
6257     // If the register list contains any high registers, we need to use
6258     // the 32-bit encoding instead if we're in Thumb2. Otherwise, this
6259     // should have generated an error in validateInstruction().
6260     if (!checkLowRegisterList(Inst, 2, 0, ARM::PC, listContainsBase))
6261       return false;
6262     assert (isThumbTwo());
6263     Inst.setOpcode(ARM::t2LDMIA_UPD);
6264     // Add the base register and writeback operands.
6265     Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP));
6266     Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP));
6267     return true;
6268   }
6269   case ARM::tPUSH: {
6270     bool listContainsBase;
6271     if (!checkLowRegisterList(Inst, 2, 0, ARM::LR, listContainsBase))
6272       return false;
6273     assert (isThumbTwo());
6274     Inst.setOpcode(ARM::t2STMDB_UPD);
6275     // Add the base register and writeback operands.
6276     Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP));
6277     Inst.insert(Inst.begin(), MCOperand::CreateReg(ARM::SP));
6278     return true;
6279   }
6280   case ARM::t2MOVi: {
6281     // If we can use the 16-bit encoding and the user didn't explicitly
6282     // request the 32-bit variant, transform it here.
6283     if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
6284         Inst.getOperand(1).getImm() <= 255 &&
6285         ((!inITBlock() && Inst.getOperand(2).getImm() == ARMCC::AL &&
6286          Inst.getOperand(4).getReg() == ARM::CPSR) ||
6287         (inITBlock() && Inst.getOperand(4).getReg() == 0)) &&
6288         (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
6289          static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
6290       // The operands aren't in the same order for tMOVi8...
6291       MCInst TmpInst;
6292       TmpInst.setOpcode(ARM::tMOVi8);
6293       TmpInst.addOperand(Inst.getOperand(0));
6294       TmpInst.addOperand(Inst.getOperand(4));
6295       TmpInst.addOperand(Inst.getOperand(1));
6296       TmpInst.addOperand(Inst.getOperand(2));
6297       TmpInst.addOperand(Inst.getOperand(3));
6298       Inst = TmpInst;
6299       return true;
6300     }
6301     break;
6302   }
6303   case ARM::t2MOVr: {
6304     // If we can use the 16-bit encoding and the user didn't explicitly
6305     // request the 32-bit variant, transform it here.
6306     if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
6307         isARMLowRegister(Inst.getOperand(1).getReg()) &&
6308         Inst.getOperand(2).getImm() == ARMCC::AL &&
6309         Inst.getOperand(4).getReg() == ARM::CPSR &&
6310         (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
6311          static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
6312       // The operands aren't the same for tMOV[S]r... (no cc_out)
6313       MCInst TmpInst;
6314       TmpInst.setOpcode(Inst.getOperand(4).getReg() ? ARM::tMOVSr : ARM::tMOVr);
6315       TmpInst.addOperand(Inst.getOperand(0));
6316       TmpInst.addOperand(Inst.getOperand(1));
6317       TmpInst.addOperand(Inst.getOperand(2));
6318       TmpInst.addOperand(Inst.getOperand(3));
6319       Inst = TmpInst;
6320       return true;
6321     }
6322     break;
6323   }
6324   case ARM::t2SXTH:
6325   case ARM::t2SXTB:
6326   case ARM::t2UXTH:
6327   case ARM::t2UXTB: {
6328     // If we can use the 16-bit encoding and the user didn't explicitly
6329     // request the 32-bit variant, transform it here.
6330     if (isARMLowRegister(Inst.getOperand(0).getReg()) &&
6331         isARMLowRegister(Inst.getOperand(1).getReg()) &&
6332         Inst.getOperand(2).getImm() == 0 &&
6333         (!static_cast<ARMOperand*>(Operands[2])->isToken() ||
6334          static_cast<ARMOperand*>(Operands[2])->getToken() != ".w")) {
6335       unsigned NewOpc;
6336       switch (Inst.getOpcode()) {
6337       default: llvm_unreachable("Illegal opcode!");
6338       case ARM::t2SXTH: NewOpc = ARM::tSXTH; break;
6339       case ARM::t2SXTB: NewOpc = ARM::tSXTB; break;
6340       case ARM::t2UXTH: NewOpc = ARM::tUXTH; break;
6341       case ARM::t2UXTB: NewOpc = ARM::tUXTB; break;
6342       }
6343       // The operands aren't the same for thumb1 (no rotate operand).
6344       MCInst TmpInst;
6345       TmpInst.setOpcode(NewOpc);
6346       TmpInst.addOperand(Inst.getOperand(0));
6347       TmpInst.addOperand(Inst.getOperand(1));
6348       TmpInst.addOperand(Inst.getOperand(3));
6349       TmpInst.addOperand(Inst.getOperand(4));
6350       Inst = TmpInst;
6351       return true;
6352     }
6353     break;
6354   }
6355   case ARM::MOVsi: {
6356     ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(Inst.getOperand(2).getImm());
6357     if (SOpc == ARM_AM::rrx) return false;
6358     if (ARM_AM::getSORegOffset(Inst.getOperand(2).getImm()) == 0) {
6359       // Shifting by zero is accepted as a vanilla 'MOVr'
6360       MCInst TmpInst;
6361       TmpInst.setOpcode(ARM::MOVr);
6362       TmpInst.addOperand(Inst.getOperand(0));
6363       TmpInst.addOperand(Inst.getOperand(1));
6364       TmpInst.addOperand(Inst.getOperand(3));
6365       TmpInst.addOperand(Inst.getOperand(4));
6366       TmpInst.addOperand(Inst.getOperand(5));
6367       Inst = TmpInst;
6368       return true;
6369     }
6370     return false;
6371   }
6372   case ARM::ANDrsi:
6373   case ARM::ORRrsi:
6374   case ARM::EORrsi:
6375   case ARM::BICrsi:
6376   case ARM::SUBrsi:
6377   case ARM::ADDrsi: {
6378     unsigned newOpc;
6379     ARM_AM::ShiftOpc SOpc = ARM_AM::getSORegShOp(Inst.getOperand(3).getImm());
6380     if (SOpc == ARM_AM::rrx) return false;
6381     switch (Inst.getOpcode()) {
6382     default: assert(0 && "unexpected opcode!");
6383     case ARM::ANDrsi: newOpc = ARM::ANDrr; break;
6384     case ARM::ORRrsi: newOpc = ARM::ORRrr; break;
6385     case ARM::EORrsi: newOpc = ARM::EORrr; break;
6386     case ARM::BICrsi: newOpc = ARM::BICrr; break;
6387     case ARM::SUBrsi: newOpc = ARM::SUBrr; break;
6388     case ARM::ADDrsi: newOpc = ARM::ADDrr; break;
6389     }
6390     // If the shift is by zero, use the non-shifted instruction definition.
6391     if (ARM_AM::getSORegOffset(Inst.getOperand(3).getImm()) == 0) {
6392       MCInst TmpInst;
6393       TmpInst.setOpcode(newOpc);
6394       TmpInst.addOperand(Inst.getOperand(0));
6395       TmpInst.addOperand(Inst.getOperand(1));
6396       TmpInst.addOperand(Inst.getOperand(2));
6397       TmpInst.addOperand(Inst.getOperand(4));
6398       TmpInst.addOperand(Inst.getOperand(5));
6399       TmpInst.addOperand(Inst.getOperand(6));
6400       Inst = TmpInst;
6401       return true;
6402     }
6403     return false;
6404   }
6405   case ARM::t2IT: {
6406     // The mask bits for all but the first condition are represented as
6407     // the low bit of the condition code value implies 't'. We currently
6408     // always have 1 implies 't', so XOR toggle the bits if the low bit
6409     // of the condition code is zero. The encoding also expects the low
6410     // bit of the condition to be encoded as bit 4 of the mask operand,
6411     // so mask that in if needed
6412     MCOperand &MO = Inst.getOperand(1);
6413     unsigned Mask = MO.getImm();
6414     unsigned OrigMask = Mask;
6415     unsigned TZ = CountTrailingZeros_32(Mask);
6416     if ((Inst.getOperand(0).getImm() & 1) == 0) {
6417       assert(Mask && TZ <= 3 && "illegal IT mask value!");
6418       for (unsigned i = 3; i != TZ; --i)
6419         Mask ^= 1 << i;
6420     } else
6421       Mask |= 0x10;
6422     MO.setImm(Mask);
6423
6424     // Set up the IT block state according to the IT instruction we just
6425     // matched.
6426     assert(!inITBlock() && "nested IT blocks?!");
6427     ITState.Cond = ARMCC::CondCodes(Inst.getOperand(0).getImm());
6428     ITState.Mask = OrigMask; // Use the original mask, not the updated one.
6429     ITState.CurPosition = 0;
6430     ITState.FirstCond = true;
6431     break;
6432   }
6433   }
6434   return false;
6435 }
6436
6437 unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
6438   // 16-bit thumb arithmetic instructions either require or preclude the 'S'
6439   // suffix depending on whether they're in an IT block or not.
6440   unsigned Opc = Inst.getOpcode();
6441   const MCInstrDesc &MCID = getInstDesc(Opc);
6442   if (MCID.TSFlags & ARMII::ThumbArithFlagSetting) {
6443     assert(MCID.hasOptionalDef() &&
6444            "optionally flag setting instruction missing optional def operand");
6445     assert(MCID.NumOperands == Inst.getNumOperands() &&
6446            "operand count mismatch!");
6447     // Find the optional-def operand (cc_out).
6448     unsigned OpNo;
6449     for (OpNo = 0;
6450          !MCID.OpInfo[OpNo].isOptionalDef() && OpNo < MCID.NumOperands;
6451          ++OpNo)
6452       ;
6453     // If we're parsing Thumb1, reject it completely.
6454     if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR)
6455       return Match_MnemonicFail;
6456     // If we're parsing Thumb2, which form is legal depends on whether we're
6457     // in an IT block.
6458     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR &&
6459         !inITBlock())
6460       return Match_RequiresITBlock;
6461     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR &&
6462         inITBlock())
6463       return Match_RequiresNotITBlock;
6464   }
6465   // Some high-register supporting Thumb1 encodings only allow both registers
6466   // to be from r0-r7 when in Thumb2.
6467   else if (Opc == ARM::tADDhirr && isThumbOne() &&
6468            isARMLowRegister(Inst.getOperand(1).getReg()) &&
6469            isARMLowRegister(Inst.getOperand(2).getReg()))
6470     return Match_RequiresThumb2;
6471   // Others only require ARMv6 or later.
6472   else if (Opc == ARM::tMOVr && isThumbOne() && !hasV6Ops() &&
6473            isARMLowRegister(Inst.getOperand(0).getReg()) &&
6474            isARMLowRegister(Inst.getOperand(1).getReg()))
6475     return Match_RequiresV6;
6476   return Match_Success;
6477 }
6478
6479 bool ARMAsmParser::
6480 MatchAndEmitInstruction(SMLoc IDLoc,
6481                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
6482                         MCStreamer &Out) {
6483   MCInst Inst;
6484   unsigned ErrorInfo;
6485   unsigned MatchResult;
6486   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
6487   switch (MatchResult) {
6488   default: break;
6489   case Match_Success:
6490     // Context sensitive operand constraints aren't handled by the matcher,
6491     // so check them here.
6492     if (validateInstruction(Inst, Operands)) {
6493       // Still progress the IT block, otherwise one wrong condition causes
6494       // nasty cascading errors.
6495       forwardITPosition();
6496       return true;
6497     }
6498
6499     // Some instructions need post-processing to, for example, tweak which
6500     // encoding is selected. Loop on it while changes happen so the
6501     // individual transformations can chain off each other. E.g.,
6502     // tPOP(r8)->t2LDMIA_UPD(sp,r8)->t2STR_POST(sp,r8)
6503     while (processInstruction(Inst, Operands))
6504       ;
6505
6506     // Only move forward at the very end so that everything in validate
6507     // and process gets a consistent answer about whether we're in an IT
6508     // block.
6509     forwardITPosition();
6510
6511     Out.EmitInstruction(Inst);
6512     return false;
6513   case Match_MissingFeature:
6514     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
6515     return true;
6516   case Match_InvalidOperand: {
6517     SMLoc ErrorLoc = IDLoc;
6518     if (ErrorInfo != ~0U) {
6519       if (ErrorInfo >= Operands.size())
6520         return Error(IDLoc, "too few operands for instruction");
6521
6522       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
6523       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
6524     }
6525
6526     return Error(ErrorLoc, "invalid operand for instruction");
6527   }
6528   case Match_MnemonicFail:
6529     return Error(IDLoc, "invalid instruction");
6530   case Match_ConversionFail:
6531     // The converter function will have already emited a diagnostic.
6532     return true;
6533   case Match_RequiresNotITBlock:
6534     return Error(IDLoc, "flag setting instruction only valid outside IT block");
6535   case Match_RequiresITBlock:
6536     return Error(IDLoc, "instruction only valid inside IT block");
6537   case Match_RequiresV6:
6538     return Error(IDLoc, "instruction variant requires ARMv6 or later");
6539   case Match_RequiresThumb2:
6540     return Error(IDLoc, "instruction variant requires Thumb2");
6541   }
6542
6543   llvm_unreachable("Implement any new match types added!");
6544 }
6545
6546 /// parseDirective parses the arm specific directives
6547 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
6548   StringRef IDVal = DirectiveID.getIdentifier();
6549   if (IDVal == ".word")
6550     return parseDirectiveWord(4, DirectiveID.getLoc());
6551   else if (IDVal == ".thumb")
6552     return parseDirectiveThumb(DirectiveID.getLoc());
6553   else if (IDVal == ".arm")
6554     return parseDirectiveARM(DirectiveID.getLoc());
6555   else if (IDVal == ".thumb_func")
6556     return parseDirectiveThumbFunc(DirectiveID.getLoc());
6557   else if (IDVal == ".code")
6558     return parseDirectiveCode(DirectiveID.getLoc());
6559   else if (IDVal == ".syntax")
6560     return parseDirectiveSyntax(DirectiveID.getLoc());
6561   else if (IDVal == ".unreq")
6562     return parseDirectiveUnreq(DirectiveID.getLoc());
6563   else if (IDVal == ".arch")
6564     return parseDirectiveArch(DirectiveID.getLoc());
6565   else if (IDVal == ".eabi_attribute")
6566     return parseDirectiveEabiAttr(DirectiveID.getLoc());
6567   return true;
6568 }
6569
6570 /// parseDirectiveWord
6571 ///  ::= .word [ expression (, expression)* ]
6572 bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
6573   if (getLexer().isNot(AsmToken::EndOfStatement)) {
6574     for (;;) {
6575       const MCExpr *Value;
6576       if (getParser().ParseExpression(Value))
6577         return true;
6578
6579       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
6580
6581       if (getLexer().is(AsmToken::EndOfStatement))
6582         break;
6583
6584       // FIXME: Improve diagnostic.
6585       if (getLexer().isNot(AsmToken::Comma))
6586         return Error(L, "unexpected token in directive");
6587       Parser.Lex();
6588     }
6589   }
6590
6591   Parser.Lex();
6592   return false;
6593 }
6594
6595 /// parseDirectiveThumb
6596 ///  ::= .thumb
6597 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
6598   if (getLexer().isNot(AsmToken::EndOfStatement))
6599     return Error(L, "unexpected token in directive");
6600   Parser.Lex();
6601
6602   if (!isThumb())
6603     SwitchMode();
6604   getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
6605   return false;
6606 }
6607
6608 /// parseDirectiveARM
6609 ///  ::= .arm
6610 bool ARMAsmParser::parseDirectiveARM(SMLoc L) {
6611   if (getLexer().isNot(AsmToken::EndOfStatement))
6612     return Error(L, "unexpected token in directive");
6613   Parser.Lex();
6614
6615   if (isThumb())
6616     SwitchMode();
6617   getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
6618   return false;
6619 }
6620
6621 /// parseDirectiveThumbFunc
6622 ///  ::= .thumbfunc symbol_name
6623 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
6624   const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
6625   bool isMachO = MAI.hasSubsectionsViaSymbols();
6626   StringRef Name;
6627   bool needFuncName = true;
6628
6629   // Darwin asm has (optionally) function name after .thumb_func direction
6630   // ELF doesn't
6631   if (isMachO) {
6632     const AsmToken &Tok = Parser.getTok();
6633     if (Tok.isNot(AsmToken::EndOfStatement)) {
6634       if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
6635         return Error(L, "unexpected token in .thumb_func directive");
6636       Name = Tok.getIdentifier();
6637       Parser.Lex(); // Consume the identifier token.
6638       needFuncName = false;
6639     }
6640   }
6641
6642   if (getLexer().isNot(AsmToken::EndOfStatement))
6643     return Error(L, "unexpected token in directive");
6644
6645   // Eat the end of statement and any blank lines that follow.
6646   while (getLexer().is(AsmToken::EndOfStatement))
6647     Parser.Lex();
6648
6649   // FIXME: assuming function name will be the line following .thumb_func
6650   // We really should be checking the next symbol definition even if there's
6651   // stuff in between.
6652   if (needFuncName) {
6653     Name = Parser.getTok().getIdentifier();
6654   }
6655
6656   // Mark symbol as a thumb symbol.
6657   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
6658   getParser().getStreamer().EmitThumbFunc(Func);
6659   return false;
6660 }
6661
6662 /// parseDirectiveSyntax
6663 ///  ::= .syntax unified | divided
6664 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
6665   const AsmToken &Tok = Parser.getTok();
6666   if (Tok.isNot(AsmToken::Identifier))
6667     return Error(L, "unexpected token in .syntax directive");
6668   StringRef Mode = Tok.getString();
6669   if (Mode == "unified" || Mode == "UNIFIED")
6670     Parser.Lex();
6671   else if (Mode == "divided" || Mode == "DIVIDED")
6672     return Error(L, "'.syntax divided' arm asssembly not supported");
6673   else
6674     return Error(L, "unrecognized syntax mode in .syntax directive");
6675
6676   if (getLexer().isNot(AsmToken::EndOfStatement))
6677     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
6678   Parser.Lex();
6679
6680   // TODO tell the MC streamer the mode
6681   // getParser().getStreamer().Emit???();
6682   return false;
6683 }
6684
6685 /// parseDirectiveCode
6686 ///  ::= .code 16 | 32
6687 bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
6688   const AsmToken &Tok = Parser.getTok();
6689   if (Tok.isNot(AsmToken::Integer))
6690     return Error(L, "unexpected token in .code directive");
6691   int64_t Val = Parser.getTok().getIntVal();
6692   if (Val == 16)
6693     Parser.Lex();
6694   else if (Val == 32)
6695     Parser.Lex();
6696   else
6697     return Error(L, "invalid operand to .code directive");
6698
6699   if (getLexer().isNot(AsmToken::EndOfStatement))
6700     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
6701   Parser.Lex();
6702
6703   if (Val == 16) {
6704     if (!isThumb())
6705       SwitchMode();
6706     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
6707   } else {
6708     if (isThumb())
6709       SwitchMode();
6710     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
6711   }
6712
6713   return false;
6714 }
6715
6716 /// parseDirectiveReq
6717 ///  ::= name .req registername
6718 bool ARMAsmParser::parseDirectiveReq(StringRef Name, SMLoc L) {
6719   Parser.Lex(); // Eat the '.req' token.
6720   unsigned Reg;
6721   SMLoc SRegLoc, ERegLoc;
6722   if (ParseRegister(Reg, SRegLoc, ERegLoc)) {
6723     Parser.EatToEndOfStatement();
6724     return Error(SRegLoc, "register name expected");
6725   }
6726
6727   // Shouldn't be anything else.
6728   if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
6729     Parser.EatToEndOfStatement();
6730     return Error(Parser.getTok().getLoc(),
6731                  "unexpected input in .req directive.");
6732   }
6733
6734   Parser.Lex(); // Consume the EndOfStatement
6735
6736   if (RegisterReqs.GetOrCreateValue(Name, Reg).getValue() != Reg)
6737     return Error(SRegLoc, "redefinition of '" + Name +
6738                           "' does not match original.");
6739
6740   return false;
6741 }
6742
6743 /// parseDirectiveUneq
6744 ///  ::= .unreq registername
6745 bool ARMAsmParser::parseDirectiveUnreq(SMLoc L) {
6746   if (Parser.getTok().isNot(AsmToken::Identifier)) {
6747     Parser.EatToEndOfStatement();
6748     return Error(L, "unexpected input in .unreq directive.");
6749   }
6750   RegisterReqs.erase(Parser.getTok().getIdentifier());
6751   Parser.Lex(); // Eat the identifier.
6752   return false;
6753 }
6754
6755 /// parseDirectiveArch
6756 ///  ::= .arch token
6757 bool ARMAsmParser::parseDirectiveArch(SMLoc L) {
6758   return true;
6759 }
6760
6761 /// parseDirectiveEabiAttr
6762 ///  ::= .eabi_attribute int, int
6763 bool ARMAsmParser::parseDirectiveEabiAttr(SMLoc L) {
6764   return true;
6765 }
6766
6767 extern "C" void LLVMInitializeARMAsmLexer();
6768
6769 /// Force static initialization.
6770 extern "C" void LLVMInitializeARMAsmParser() {
6771   RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget);
6772   RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget);
6773   LLVMInitializeARMAsmLexer();
6774 }
6775
6776 #define GET_REGISTER_MATCHER
6777 #define GET_MATCHER_IMPLEMENTATION
6778 #include "ARMGenAsmMatcher.inc"