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