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