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/StringExtras.h"
  34 #include "llvm/ADT/StringSwitch.h"
  35 #include "llvm/ADT/Twine.h"
  36
  37 using namespace llvm;
  38
  39 namespace {
  40
  41 class ARMOperand;
  42
  43 class ARMAsmParser : public MCTargetAsmParser {
  44   MCSubtargetInfo &STI;
  45   MCAsmParser &Parser;
  46
  47   struct {
  48     ARMCC::CondCodes Cond;    // Condition for IT block.
  49     unsigned Mask:4;          // Condition mask for instructions.
  50                               // Starting at first 1 (from lsb).
  51                               //   '1'  condition as indicated in IT.
  52                               //   '0'  inverse of condition (else).
  53                               // Count of instructions in IT block is
  54                               // 4 - trailingzeroes(mask)
  55
  56     bool FirstCond;           // Explicit flag for when we're parsing the
  57                               // First instruction in the IT block. It's
  58                               // implied in the mask, so needs special
  59                               // handling.
  60
  61     unsigned CurPosition;     // Current position in parsing of IT
  62                               // block. In range [0,3]. Initialized
  63                               // according to count of instructions in block.
  64                               // ~0U if no active IT block.
  65   } ITState;
  66   bool inITBlock() { return ITState.CurPosition != ~0U;}
  67   void forwardITPosition() {
  68     if (!inITBlock()) return;
  69     // Move to the next instruction in the IT block, if there is one. If not,
  70     // mark the block as done.
  71     unsigned TZ = CountTrailingZeros_32(ITState.Mask);
  72     if (++ITState.CurPosition == 5 - TZ)
  73       ITState.CurPosition = ~0U; // Done with the IT block after this.
  74   }
  75
  76
  77   MCAsmParser &getParser() const { return Parser; }
  78   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  79
  80   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  81   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  82
  83   int tryParseRegister();
  84   bool tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
  85   int tryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
  86   bool parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
  87   bool parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &);
  88   bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
  89   bool parsePrefix(ARMMCExpr::VariantKind &RefKind);
  90   const MCExpr *applyPrefixToExpr(const MCExpr *E,
  91                                   MCSymbolRefExpr::VariantKind Variant);
  92
  93
  94   bool parseMemRegOffsetShift(ARM_AM::ShiftOpc &ShiftType,
  95                               unsigned &ShiftAmount);
  96   bool parseDirectiveWord(unsigned Size, SMLoc L);
  97   bool parseDirectiveThumb(SMLoc L);
  98   bool parseDirectiveThumbFunc(SMLoc L);
  99   bool parseDirectiveCode(SMLoc L);
 100   bool parseDirectiveSyntax(SMLoc L);
 101
 102   StringRef splitMnemonic(StringRef Mnemonic, unsigned &PredicationCode,
 103                           bool &CarrySetting, unsigned &ProcessorIMod,
 104                           StringRef &ITMask);
 105   void getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
 106                              bool &CanAcceptPredicationCode);
 107
 108   bool isThumb() const {
 109     // FIXME: Can tablegen auto-generate this?
 110     return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
 111   }
 112   bool isThumbOne() const {
 113     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
 114   }
 115   bool isThumbTwo() const {
 116     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2);
 117   }
 118   bool hasV6Ops() const {
 119     return STI.getFeatureBits() & ARM::HasV6Ops;
 120   }
 121   void SwitchMode() {
 122     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
 123     setAvailableFeatures(FB);
 124   }
 125
 126   /// @name Auto-generated Match Functions
 127   /// {
 128
 129 #define GET_ASSEMBLER_HEADER
 130 #include "ARMGenAsmMatcher.inc"
 131
 132   /// }
 133
 134   OperandMatchResultTy parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*>&);
 135   OperandMatchResultTy parseCoprocNumOperand(
 136     SmallVectorImpl<MCParsedAsmOperand*>&);
 137   OperandMatchResultTy parseCoprocRegOperand(
 138     SmallVectorImpl<MCParsedAsmOperand*>&);
 139   OperandMatchResultTy parseMemBarrierOptOperand(
 140     SmallVectorImpl<MCParsedAsmOperand*>&);
 141   OperandMatchResultTy parseProcIFlagsOperand(
 142     SmallVectorImpl<MCParsedAsmOperand*>&);
 143   OperandMatchResultTy parseMSRMaskOperand(
 144     SmallVectorImpl<MCParsedAsmOperand*>&);
 145   OperandMatchResultTy parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &O,
 146                                    StringRef Op, int Low, int High);
 147   OperandMatchResultTy parsePKHLSLImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 148     return parsePKHImm(O, "lsl", 0, 31);
 149   }
 150   OperandMatchResultTy parsePKHASRImm(SmallVectorImpl<MCParsedAsmOperand*> &O) {
 151     return parsePKHImm(O, "asr", 1, 32);
 152   }
 153   OperandMatchResultTy parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 154   OperandMatchResultTy parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 155   OperandMatchResultTy parseRotImm(SmallVectorImpl<MCParsedAsmOperand*>&);
 156   OperandMatchResultTy parseBitfield(SmallVectorImpl<MCParsedAsmOperand*>&);
 157   OperandMatchResultTy parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*>&);
 158   OperandMatchResultTy parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*>&);
 159
 160   // Asm Match Converter Methods
 161   bool cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 162                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 163   bool cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 164                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 165   bool cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
 166                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 167   bool cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 168                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 169   bool cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 170                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 171   bool cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 172                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 173   bool cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 174                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 175   bool cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
 176                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 177   bool cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
 178                              const SmallVectorImpl<MCParsedAsmOperand*> &);
 179   bool cvtLdrdPre(MCInst &Inst, unsigned Opcode,
 180                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 181   bool cvtStrdPre(MCInst &Inst, unsigned Opcode,
 182                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 183   bool cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 184                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 185   bool cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
 186                         const SmallVectorImpl<MCParsedAsmOperand*> &);
 187
 188   bool validateInstruction(MCInst &Inst,
 189                            const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 190   void processInstruction(MCInst &Inst,
 191                           const SmallVectorImpl<MCParsedAsmOperand*> &Ops);
 192   bool shouldOmitCCOutOperand(StringRef Mnemonic,
 193                               SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 194
 195 public:
 196   enum ARMMatchResultTy {
 197     Match_RequiresITBlock = FIRST_TARGET_MATCH_RESULT_TY,
 198     Match_RequiresNotITBlock,
 199     Match_RequiresV6,
 200     Match_RequiresThumb2
 201   };
 202
 203   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
 204     : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
 205     MCAsmParserExtension::Initialize(_Parser);
 206
 207     // Initialize the set of available features.
 208     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 209
 210     // Not in an ITBlock to start with.
 211     ITState.CurPosition = ~0U;
 212   }
 213
 214   // Implementation of the MCTargetAsmParser interface:
 215   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
 216   bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 217                         SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 218   bool ParseDirective(AsmToken DirectiveID);
 219
 220   unsigned checkTargetMatchPredicate(MCInst &Inst);
 221
 222   bool MatchAndEmitInstruction(SMLoc IDLoc,
 223                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 224                                MCStreamer &Out);
 225 };
 226 } // end anonymous namespace
 227
 228 namespace {
 229
 230 /// ARMOperand - Instances of this class represent a parsed ARM machine
 231 /// instruction.
 232 class ARMOperand : public MCParsedAsmOperand {
 233   enum KindTy {
 234     CondCode,
 235     CCOut,
 236     ITCondMask,
 237     CoprocNum,
 238     CoprocReg,
 239     Immediate,
 240     MemBarrierOpt,
 241     Memory,
 242     PostIndexRegister,
 243     MSRMask,
 244     ProcIFlags,
 245     Register,
 246     RegisterList,
 247     DPRRegisterList,
 248     SPRRegisterList,
 249     ShiftedRegister,
 250     ShiftedImmediate,
 251     ShifterImmediate,
 252     RotateImmediate,
 253     BitfieldDescriptor,
 254     Token
 255   } Kind;
 256
 257   SMLoc StartLoc, EndLoc;
 258   SmallVector<unsigned, 8> Registers;
 259
 260   union {
 261     struct {
 262       ARMCC::CondCodes Val;
 263     } CC;
 264
 265     struct {
 266       unsigned Val;
 267     } Cop;
 268
 269     struct {
 270       unsigned Mask:4;
 271     } ITMask;
 272
 273     struct {
 274       ARM_MB::MemBOpt Val;
 275     } MBOpt;
 276
 277     struct {
 278       ARM_PROC::IFlags Val;
 279     } IFlags;
 280
 281     struct {
 282       unsigned Val;
 283     } MMask;
 284
 285     struct {
 286       const char *Data;
 287       unsigned Length;
 288     } Tok;
 289
 290     struct {
 291       unsigned RegNum;
 292     } Reg;
 293
 294     struct {
 295       const MCExpr *Val;
 296     } Imm;
 297
 298     /// Combined record for all forms of ARM address expressions.
 299     struct {
 300       unsigned BaseRegNum;
 301       // Offset is in OffsetReg or OffsetImm. If both are zero, no offset
 302       // was specified.
 303       const MCConstantExpr *OffsetImm;  // Offset immediate value
 304       unsigned OffsetRegNum;    // Offset register num, when OffsetImm == NULL
 305       ARM_AM::ShiftOpc ShiftType; // Shift type for OffsetReg
 306       unsigned ShiftImm;      // shift for OffsetReg.
 307       unsigned isNegative : 1;  // Negated OffsetReg? (~'U' bit)
 308     } Mem;
 309
 310     struct {
 311       unsigned RegNum;
 312       bool isAdd;
 313       ARM_AM::ShiftOpc ShiftTy;
 314       unsigned ShiftImm;
 315     } PostIdxReg;
 316
 317     struct {
 318       bool isASR;
 319       unsigned Imm;
 320     } ShifterImm;
 321     struct {
 322       ARM_AM::ShiftOpc ShiftTy;
 323       unsigned SrcReg;
 324       unsigned ShiftReg;
 325       unsigned ShiftImm;
 326     } RegShiftedReg;
 327     struct {
 328       ARM_AM::ShiftOpc ShiftTy;
 329       unsigned SrcReg;
 330       unsigned ShiftImm;
 331     } RegShiftedImm;
 332     struct {
 333       unsigned Imm;
 334     } RotImm;
 335     struct {
 336       unsigned LSB;
 337       unsigned Width;
 338     } Bitfield;
 339   };
 340
 341   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 342 public:
 343   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 344     Kind = o.Kind;
 345     StartLoc = o.StartLoc;
 346     EndLoc = o.EndLoc;
 347     switch (Kind) {
 348     case CondCode:
 349       CC = o.CC;
 350       break;
 351     case ITCondMask:
 352       ITMask = o.ITMask;
 353       break;
 354     case Token:
 355       Tok = o.Tok;
 356       break;
 357     case CCOut:
 358     case Register:
 359       Reg = o.Reg;
 360       break;
 361     case RegisterList:
 362     case DPRRegisterList:
 363     case SPRRegisterList:
 364       Registers = o.Registers;
 365       break;
 366     case CoprocNum:
 367     case CoprocReg:
 368       Cop = o.Cop;
 369       break;
 370     case Immediate:
 371       Imm = o.Imm;
 372       break;
 373     case MemBarrierOpt:
 374       MBOpt = o.MBOpt;
 375       break;
 376     case Memory:
 377       Mem = o.Mem;
 378       break;
 379     case PostIndexRegister:
 380       PostIdxReg = o.PostIdxReg;
 381       break;
 382     case MSRMask:
 383       MMask = o.MMask;
 384       break;
 385     case ProcIFlags:
 386       IFlags = o.IFlags;
 387       break;
 388     case ShifterImmediate:
 389       ShifterImm = o.ShifterImm;
 390       break;
 391     case ShiftedRegister:
 392       RegShiftedReg = o.RegShiftedReg;
 393       break;
 394     case ShiftedImmediate:
 395       RegShiftedImm = o.RegShiftedImm;
 396       break;
 397     case RotateImmediate:
 398       RotImm = o.RotImm;
 399       break;
 400     case BitfieldDescriptor:
 401       Bitfield = o.Bitfield;
 402       break;
 403     }
 404   }
 405
 406   /// getStartLoc - Get the location of the first token of this operand.
 407   SMLoc getStartLoc() const { return StartLoc; }
 408   /// getEndLoc - Get the location of the last token of this operand.
 409   SMLoc getEndLoc() const { return EndLoc; }
 410
 411   ARMCC::CondCodes getCondCode() const {
 412     assert(Kind == CondCode && "Invalid access!");
 413     return CC.Val;
 414   }
 415
 416   unsigned getCoproc() const {
 417     assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!");
 418     return Cop.Val;
 419   }
 420
 421   StringRef getToken() const {
 422     assert(Kind == Token && "Invalid access!");
 423     return StringRef(Tok.Data, Tok.Length);
 424   }
 425
 426   unsigned getReg() const {
 427     assert((Kind == Register || Kind == CCOut) && "Invalid access!");
 428     return Reg.RegNum;
 429   }
 430
 431   const SmallVectorImpl<unsigned> &getRegList() const {
 432     assert((Kind == RegisterList || Kind == DPRRegisterList ||
 433             Kind == SPRRegisterList) && "Invalid access!");
 434     return Registers;
 435   }
 436
 437   const MCExpr *getImm() const {
 438     assert(Kind == Immediate && "Invalid access!");
 439     return Imm.Val;
 440   }
 441
 442   ARM_MB::MemBOpt getMemBarrierOpt() const {
 443     assert(Kind == MemBarrierOpt && "Invalid access!");
 444     return MBOpt.Val;
 445   }
 446
 447   ARM_PROC::IFlags getProcIFlags() const {
 448     assert(Kind == ProcIFlags && "Invalid access!");
 449     return IFlags.Val;
 450   }
 451
 452   unsigned getMSRMask() const {
 453     assert(Kind == MSRMask && "Invalid access!");
 454     return MMask.Val;
 455   }
 456
 457   bool isCoprocNum() const { return Kind == CoprocNum; }
 458   bool isCoprocReg() const { return Kind == CoprocReg; }
 459   bool isCondCode() const { return Kind == CondCode; }
 460   bool isCCOut() const { return Kind == CCOut; }
 461   bool isITMask() const { return Kind == ITCondMask; }
 462   bool isITCondCode() const { return Kind == CondCode; }
 463   bool isImm() const { return Kind == Immediate; }
 464   bool isImm0_1020s4() const {
 465     if (Kind != Immediate)
 466       return false;
 467     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 468     if (!CE) return false;
 469     int64_t Value = CE->getValue();
 470     return ((Value & 3) == 0) && Value >= 0 && Value <= 1020;
 471   }
 472   bool isImm0_508s4() const {
 473     if (Kind != Immediate)
 474       return false;
 475     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 476     if (!CE) return false;
 477     int64_t Value = CE->getValue();
 478     return ((Value & 3) == 0) && Value >= 0 && Value <= 508;
 479   }
 480   bool isImm0_255() const {
 481     if (Kind != Immediate)
 482       return false;
 483     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 484     if (!CE) return false;
 485     int64_t Value = CE->getValue();
 486     return Value >= 0 && Value < 256;
 487   }
 488   bool isImm0_7() const {
 489     if (Kind != Immediate)
 490       return false;
 491     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 492     if (!CE) return false;
 493     int64_t Value = CE->getValue();
 494     return Value >= 0 && Value < 8;
 495   }
 496   bool isImm0_15() const {
 497     if (Kind != Immediate)
 498       return false;
 499     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 500     if (!CE) return false;
 501     int64_t Value = CE->getValue();
 502     return Value >= 0 && Value < 16;
 503   }
 504   bool isImm0_31() const {
 505     if (Kind != Immediate)
 506       return false;
 507     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 508     if (!CE) return false;
 509     int64_t Value = CE->getValue();
 510     return Value >= 0 && Value < 32;
 511   }
 512   bool isImm1_16() const {
 513     if (Kind != Immediate)
 514       return false;
 515     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 516     if (!CE) return false;
 517     int64_t Value = CE->getValue();
 518     return Value > 0 && Value < 17;
 519   }
 520   bool isImm1_32() const {
 521     if (Kind != Immediate)
 522       return false;
 523     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 524     if (!CE) return false;
 525     int64_t Value = CE->getValue();
 526     return Value > 0 && Value < 33;
 527   }
 528   bool isImm0_65535() const {
 529     if (Kind != Immediate)
 530       return false;
 531     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 532     if (!CE) return false;
 533     int64_t Value = CE->getValue();
 534     return Value >= 0 && Value < 65536;
 535   }
 536   bool isImm0_65535Expr() const {
 537     if (Kind != Immediate)
 538       return false;
 539     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 540     // If it's not a constant expression, it'll generate a fixup and be
 541     // handled later.
 542     if (!CE) return true;
 543     int64_t Value = CE->getValue();
 544     return Value >= 0 && Value < 65536;
 545   }
 546   bool isImm24bit() const {
 547     if (Kind != Immediate)
 548       return false;
 549     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 550     if (!CE) return false;
 551     int64_t Value = CE->getValue();
 552     return Value >= 0 && Value <= 0xffffff;
 553   }
 554   bool isImmThumbSR() const {
 555     if (Kind != Immediate)
 556       return false;
 557     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 558     if (!CE) return false;
 559     int64_t Value = CE->getValue();
 560     return Value > 0 && Value < 33;
 561   }
 562   bool isPKHLSLImm() const {
 563     if (Kind != Immediate)
 564       return false;
 565     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 566     if (!CE) return false;
 567     int64_t Value = CE->getValue();
 568     return Value >= 0 && Value < 32;
 569   }
 570   bool isPKHASRImm() const {
 571     if (Kind != Immediate)
 572       return false;
 573     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 574     if (!CE) return false;
 575     int64_t Value = CE->getValue();
 576     return Value > 0 && Value <= 32;
 577   }
 578   bool isARMSOImm() const {
 579     if (Kind != Immediate)
 580       return false;
 581     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 582     if (!CE) return false;
 583     int64_t Value = CE->getValue();
 584     return ARM_AM::getSOImmVal(Value) != -1;
 585   }
 586   bool isT2SOImm() const {
 587     if (Kind != Immediate)
 588       return false;
 589     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 590     if (!CE) return false;
 591     int64_t Value = CE->getValue();
 592     return ARM_AM::getT2SOImmVal(Value) != -1;
 593   }
 594   bool isSetEndImm() const {
 595     if (Kind != Immediate)
 596       return false;
 597     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 598     if (!CE) return false;
 599     int64_t Value = CE->getValue();
 600     return Value == 1 || Value == 0;
 601   }
 602   bool isReg() const { return Kind == Register; }
 603   bool isRegList() const { return Kind == RegisterList; }
 604   bool isDPRRegList() const { return Kind == DPRRegisterList; }
 605   bool isSPRRegList() const { return Kind == SPRRegisterList; }
 606   bool isToken() const { return Kind == Token; }
 607   bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; }
 608   bool isMemory() const { return Kind == Memory; }
 609   bool isShifterImm() const { return Kind == ShifterImmediate; }
 610   bool isRegShiftedReg() const { return Kind == ShiftedRegister; }
 611   bool isRegShiftedImm() const { return Kind == ShiftedImmediate; }
 612   bool isRotImm() const { return Kind == RotateImmediate; }
 613   bool isBitfield() const { return Kind == BitfieldDescriptor; }
 614   bool isPostIdxRegShifted() const { return Kind == PostIndexRegister; }
 615   bool isPostIdxReg() const {
 616     return Kind == PostIndexRegister && PostIdxReg.ShiftTy == ARM_AM::no_shift;
 617   }
 618   bool isMemNoOffset() const {
 619     if (Kind != Memory)
 620       return false;
 621     // No offset of any kind.
 622     return Mem.OffsetRegNum == 0 && Mem.OffsetImm == 0;
 623   }
 624   bool isAddrMode2() const {
 625     if (Kind != Memory)
 626       return false;
 627     // Check for register offset.
 628     if (Mem.OffsetRegNum) return true;
 629     // Immediate offset in range [-4095, 4095].
 630     if (!Mem.OffsetImm) return true;
 631     int64_t Val = Mem.OffsetImm->getValue();
 632     return Val > -4096 && Val < 4096;
 633   }
 634   bool isAM2OffsetImm() const {
 635     if (Kind != Immediate)
 636       return false;
 637     // Immediate offset in range [-4095, 4095].
 638     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 639     if (!CE) return false;
 640     int64_t Val = CE->getValue();
 641     return Val > -4096 && Val < 4096;
 642   }
 643   bool isAddrMode3() const {
 644     if (Kind != Memory)
 645       return false;
 646     // No shifts are legal for AM3.
 647     if (Mem.ShiftType != ARM_AM::no_shift) return false;
 648     // Check for register offset.
 649     if (Mem.OffsetRegNum) return true;
 650     // Immediate offset in range [-255, 255].
 651     if (!Mem.OffsetImm) return true;
 652     int64_t Val = Mem.OffsetImm->getValue();
 653     return Val > -256 && Val < 256;
 654   }
 655   bool isAM3Offset() const {
 656     if (Kind != Immediate && Kind != PostIndexRegister)
 657       return false;
 658     if (Kind == PostIndexRegister)
 659       return PostIdxReg.ShiftTy == ARM_AM::no_shift;
 660     // Immediate offset in range [-255, 255].
 661     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 662     if (!CE) return false;
 663     int64_t Val = CE->getValue();
 664     // Special case, #-0 is INT32_MIN.
 665     return (Val > -256 && Val < 256) || Val == INT32_MIN;
 666   }
 667   bool isAddrMode5() const {
 668     if (Kind != Memory)
 669       return false;
 670     // Check for register offset.
 671     if (Mem.OffsetRegNum) return false;
 672     // Immediate offset in range [-1020, 1020] and a multiple of 4.
 673     if (!Mem.OffsetImm) return true;
 674     int64_t Val = Mem.OffsetImm->getValue();
 675     return (Val >= -1020 && Val <= 1020 && ((Val & 3) == 0)) ||
 676            Val == INT32_MIN;
 677   }
 678   bool isMemRegOffset() const {
 679     if (Kind != Memory || !Mem.OffsetRegNum)
 680       return false;
 681     return true;
 682   }
 683   bool isT2MemRegOffset() const {
 684     if (Kind != Memory || !Mem.OffsetRegNum || Mem.isNegative)
 685       return false;
 686     // Only lsl #{0, 1, 2, 3} allowed.
 687     if (Mem.ShiftType == ARM_AM::no_shift)
 688       return true;
 689     if (Mem.ShiftType != ARM_AM::lsl || Mem.ShiftImm > 3)
 690       return false;
 691     return true;
 692   }
 693   bool isMemThumbRR() const {
 694     // Thumb reg+reg addressing is simple. Just two registers, a base and
 695     // an offset. No shifts, negations or any other complicating factors.
 696     if (Kind != Memory || !Mem.OffsetRegNum || Mem.isNegative ||
 697         Mem.ShiftType != ARM_AM::no_shift)
 698       return false;
 699     return isARMLowRegister(Mem.BaseRegNum) &&
 700       (!Mem.OffsetRegNum || isARMLowRegister(Mem.OffsetRegNum));
 701   }
 702   bool isMemThumbRIs4() const {
 703     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 704         !isARMLowRegister(Mem.BaseRegNum))
 705       return false;
 706     // Immediate offset, multiple of 4 in range [0, 124].
 707     if (!Mem.OffsetImm) return true;
 708     int64_t Val = Mem.OffsetImm->getValue();
 709     return Val >= 0 && Val <= 124 && (Val % 4) == 0;
 710   }
 711   bool isMemThumbRIs2() const {
 712     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 713         !isARMLowRegister(Mem.BaseRegNum))
 714       return false;
 715     // Immediate offset, multiple of 4 in range [0, 62].
 716     if (!Mem.OffsetImm) return true;
 717     int64_t Val = Mem.OffsetImm->getValue();
 718     return Val >= 0 && Val <= 62 && (Val % 2) == 0;
 719   }
 720   bool isMemThumbRIs1() const {
 721     if (Kind != Memory || Mem.OffsetRegNum != 0 ||
 722         !isARMLowRegister(Mem.BaseRegNum))
 723       return false;
 724     // Immediate offset in range [0, 31].
 725     if (!Mem.OffsetImm) return true;
 726     int64_t Val = Mem.OffsetImm->getValue();
 727     return Val >= 0 && Val <= 31;
 728   }
 729   bool isMemThumbSPI() const {
 730     if (Kind != Memory || Mem.OffsetRegNum != 0 || Mem.BaseRegNum != ARM::SP)
 731       return false;
 732     // Immediate offset, multiple of 4 in range [0, 1020].
 733     if (!Mem.OffsetImm) return true;
 734     int64_t Val = Mem.OffsetImm->getValue();
 735     return Val >= 0 && Val <= 1020 && (Val % 4) == 0;
 736   }
 737   bool isMemImm8Offset() const {
 738     if (Kind != Memory || Mem.OffsetRegNum != 0)
 739       return false;
 740     // Immediate offset in range [-255, 255].
 741     if (!Mem.OffsetImm) return true;
 742     int64_t Val = Mem.OffsetImm->getValue();
 743     return Val > -256 && Val < 256;
 744   }
 745   bool isMemPosImm8Offset() const {
 746     if (Kind != Memory || Mem.OffsetRegNum != 0)
 747       return false;
 748     // Immediate offset in range [0, 255].
 749     if (!Mem.OffsetImm) return true;
 750     int64_t Val = Mem.OffsetImm->getValue();
 751     return Val >= 0 && Val < 256;
 752   }
 753   bool isMemNegImm8Offset() const {
 754     if (Kind != Memory || Mem.OffsetRegNum != 0)
 755       return false;
 756     // Immediate offset in range [-255, -1].
 757     if (!Mem.OffsetImm) return true;
 758     int64_t Val = Mem.OffsetImm->getValue();
 759     return Val > -256 && Val < 0;
 760   }
 761   bool isMemUImm12Offset() const {
 762     // If we have an immediate that's not a constant, treat it as a label
 763     // reference needing a fixup. If it is a constant, it's something else
 764     // and we reject it.
 765     if (Kind == Immediate && !isa<MCConstantExpr>(getImm()))
 766       return true;
 767
 768     if (Kind != Memory || Mem.OffsetRegNum != 0)
 769       return false;
 770     // Immediate offset in range [0, 4095].
 771     if (!Mem.OffsetImm) return true;
 772     int64_t Val = Mem.OffsetImm->getValue();
 773     return (Val >= 0 && Val < 4096);
 774   }
 775   bool isMemImm12Offset() const {
 776     // If we have an immediate that's not a constant, treat it as a label
 777     // reference needing a fixup. If it is a constant, it's something else
 778     // and we reject it.
 779     if (Kind == Immediate && !isa<MCConstantExpr>(getImm()))
 780       return true;
 781
 782     if (Kind != Memory || Mem.OffsetRegNum != 0)
 783       return false;
 784     // Immediate offset in range [-4095, 4095].
 785     if (!Mem.OffsetImm) return true;
 786     int64_t Val = Mem.OffsetImm->getValue();
 787     return (Val > -4096 && Val < 4096) || (Val == INT32_MIN);
 788   }
 789   bool isPostIdxImm8() const {
 790     if (Kind != Immediate)
 791       return false;
 792     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 793     if (!CE) return false;
 794     int64_t Val = CE->getValue();
 795     return (Val > -256 && Val < 256) || (Val == INT32_MIN);
 796   }
 797
 798   bool isMSRMask() const { return Kind == MSRMask; }
 799   bool isProcIFlags() const { return Kind == ProcIFlags; }
 800
 801   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 802     // Add as immediates when possible.  Null MCExpr = 0.
 803     if (Expr == 0)
 804       Inst.addOperand(MCOperand::CreateImm(0));
 805     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 806       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 807     else
 808       Inst.addOperand(MCOperand::CreateExpr(Expr));
 809   }
 810
 811   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 812     assert(N == 2 && "Invalid number of operands!");
 813     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 814     unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
 815     Inst.addOperand(MCOperand::CreateReg(RegNum));
 816   }
 817
 818   void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
 819     assert(N == 1 && "Invalid number of operands!");
 820     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 821   }
 822
 823   void addITMaskOperands(MCInst &Inst, unsigned N) const {
 824     assert(N == 1 && "Invalid number of operands!");
 825     Inst.addOperand(MCOperand::CreateImm(ITMask.Mask));
 826   }
 827
 828   void addITCondCodeOperands(MCInst &Inst, unsigned N) const {
 829     assert(N == 1 && "Invalid number of operands!");
 830     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 831   }
 832
 833   void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
 834     assert(N == 1 && "Invalid number of operands!");
 835     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 836   }
 837
 838   void addCCOutOperands(MCInst &Inst, unsigned N) const {
 839     assert(N == 1 && "Invalid number of operands!");
 840     Inst.addOperand(MCOperand::CreateReg(getReg()));
 841   }
 842
 843   void addRegOperands(MCInst &Inst, unsigned N) const {
 844     assert(N == 1 && "Invalid number of operands!");
 845     Inst.addOperand(MCOperand::CreateReg(getReg()));
 846   }
 847
 848   void addRegShiftedRegOperands(MCInst &Inst, unsigned N) const {
 849     assert(N == 3 && "Invalid number of operands!");
 850     assert(isRegShiftedReg() && "addRegShiftedRegOperands() on non RegShiftedReg!");
 851     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.SrcReg));
 852     Inst.addOperand(MCOperand::CreateReg(RegShiftedReg.ShiftReg));
 853     Inst.addOperand(MCOperand::CreateImm(
 854       ARM_AM::getSORegOpc(RegShiftedReg.ShiftTy, RegShiftedReg.ShiftImm)));
 855   }
 856
 857   void addRegShiftedImmOperands(MCInst &Inst, unsigned N) const {
 858     assert(N == 2 && "Invalid number of operands!");
 859     assert(isRegShiftedImm() && "addRegShiftedImmOperands() on non RegShiftedImm!");
 860     Inst.addOperand(MCOperand::CreateReg(RegShiftedImm.SrcReg));
 861     Inst.addOperand(MCOperand::CreateImm(
 862       ARM_AM::getSORegOpc(RegShiftedImm.ShiftTy, RegShiftedImm.ShiftImm)));
 863   }
 864
 865   void addShifterImmOperands(MCInst &Inst, unsigned N) const {
 866     assert(N == 1 && "Invalid number of operands!");
 867     Inst.addOperand(MCOperand::CreateImm((ShifterImm.isASR << 5) |
 868                                          ShifterImm.Imm));
 869   }
 870
 871   void addRegListOperands(MCInst &Inst, unsigned N) const {
 872     assert(N == 1 && "Invalid number of operands!");
 873     const SmallVectorImpl<unsigned> &RegList = getRegList();
 874     for (SmallVectorImpl<unsigned>::const_iterator
 875            I = RegList.begin(), E = RegList.end(); I != E; ++I)
 876       Inst.addOperand(MCOperand::CreateReg(*I));
 877   }
 878
 879   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
 880     addRegListOperands(Inst, N);
 881   }
 882
 883   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
 884     addRegListOperands(Inst, N);
 885   }
 886
 887   void addRotImmOperands(MCInst &Inst, unsigned N) const {
 888     assert(N == 1 && "Invalid number of operands!");
 889     // Encoded as val>>3. The printer handles display as 8, 16, 24.
 890     Inst.addOperand(MCOperand::CreateImm(RotImm.Imm >> 3));
 891   }
 892
 893   void addBitfieldOperands(MCInst &Inst, unsigned N) const {
 894     assert(N == 1 && "Invalid number of operands!");
 895     // Munge the lsb/width into a bitfield mask.
 896     unsigned lsb = Bitfield.LSB;
 897     unsigned width = Bitfield.Width;
 898     // Make a 32-bit mask w/ the referenced bits clear and all other bits set.
 899     uint32_t Mask = ~(((uint32_t)0xffffffff >> lsb) << (32 - width) >>
 900                       (32 - (lsb + width)));
 901     Inst.addOperand(MCOperand::CreateImm(Mask));
 902   }
 903
 904   void addImmOperands(MCInst &Inst, unsigned N) const {
 905     assert(N == 1 && "Invalid number of operands!");
 906     addExpr(Inst, getImm());
 907   }
 908
 909   void addImm0_1020s4Operands(MCInst &Inst, unsigned N) const {
 910     assert(N == 1 && "Invalid number of operands!");
 911     // The immediate is scaled by four in the encoding and is stored
 912     // in the MCInst as such. Lop off the low two bits here.
 913     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 914     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
 915   }
 916
 917   void addImm0_508s4Operands(MCInst &Inst, unsigned N) const {
 918     assert(N == 1 && "Invalid number of operands!");
 919     // The immediate is scaled by four in the encoding and is stored
 920     // in the MCInst as such. Lop off the low two bits here.
 921     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 922     Inst.addOperand(MCOperand::CreateImm(CE->getValue() / 4));
 923   }
 924
 925   void addImm0_255Operands(MCInst &Inst, unsigned N) const {
 926     assert(N == 1 && "Invalid number of operands!");
 927     addExpr(Inst, getImm());
 928   }
 929
 930   void addImm0_7Operands(MCInst &Inst, unsigned N) const {
 931     assert(N == 1 && "Invalid number of operands!");
 932     addExpr(Inst, getImm());
 933   }
 934
 935   void addImm0_15Operands(MCInst &Inst, unsigned N) const {
 936     assert(N == 1 && "Invalid number of operands!");
 937     addExpr(Inst, getImm());
 938   }
 939
 940   void addImm0_31Operands(MCInst &Inst, unsigned N) const {
 941     assert(N == 1 && "Invalid number of operands!");
 942     addExpr(Inst, getImm());
 943   }
 944
 945   void addImm1_16Operands(MCInst &Inst, unsigned N) const {
 946     assert(N == 1 && "Invalid number of operands!");
 947     // The constant encodes as the immediate-1, and we store in the instruction
 948     // the bits as encoded, so subtract off one here.
 949     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 950     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 951   }
 952
 953   void addImm1_32Operands(MCInst &Inst, unsigned N) const {
 954     assert(N == 1 && "Invalid number of operands!");
 955     // The constant encodes as the immediate-1, and we store in the instruction
 956     // the bits as encoded, so subtract off one here.
 957     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 958     Inst.addOperand(MCOperand::CreateImm(CE->getValue() - 1));
 959   }
 960
 961   void addImm0_65535Operands(MCInst &Inst, unsigned N) const {
 962     assert(N == 1 && "Invalid number of operands!");
 963     addExpr(Inst, getImm());
 964   }
 965
 966   void addImm0_65535ExprOperands(MCInst &Inst, unsigned N) const {
 967     assert(N == 1 && "Invalid number of operands!");
 968     addExpr(Inst, getImm());
 969   }
 970
 971   void addImm24bitOperands(MCInst &Inst, unsigned N) const {
 972     assert(N == 1 && "Invalid number of operands!");
 973     addExpr(Inst, getImm());
 974   }
 975
 976   void addImmThumbSROperands(MCInst &Inst, unsigned N) const {
 977     assert(N == 1 && "Invalid number of operands!");
 978     // The constant encodes as the immediate, except for 32, which encodes as
 979     // zero.
 980     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 981     unsigned Imm = CE->getValue();
 982     Inst.addOperand(MCOperand::CreateImm((Imm == 32 ? 0 : Imm)));
 983   }
 984
 985   void addPKHLSLImmOperands(MCInst &Inst, unsigned N) const {
 986     assert(N == 1 && "Invalid number of operands!");
 987     addExpr(Inst, getImm());
 988   }
 989
 990   void addPKHASRImmOperands(MCInst &Inst, unsigned N) const {
 991     assert(N == 1 && "Invalid number of operands!");
 992     // An ASR value of 32 encodes as 0, so that's how we want to add it to
 993     // the instruction as well.
 994     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 995     int Val = CE->getValue();
 996     Inst.addOperand(MCOperand::CreateImm(Val == 32 ? 0 : Val));
 997   }
 998
 999   void addARMSOImmOperands(MCInst &Inst, unsigned N) const {
1000     assert(N == 1 && "Invalid number of operands!");
1001     addExpr(Inst, getImm());
1002   }
1003
1004   void addT2SOImmOperands(MCInst &Inst, unsigned N) const {
1005     assert(N == 1 && "Invalid number of operands!");
1006     addExpr(Inst, getImm());
1007   }
1008
1009   void addSetEndImmOperands(MCInst &Inst, unsigned N) const {
1010     assert(N == 1 && "Invalid number of operands!");
1011     addExpr(Inst, getImm());
1012   }
1013
1014   void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
1015     assert(N == 1 && "Invalid number of operands!");
1016     Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
1017   }
1018
1019   void addMemNoOffsetOperands(MCInst &Inst, unsigned N) const {
1020     assert(N == 1 && "Invalid number of operands!");
1021     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1022   }
1023
1024   void addAddrMode2Operands(MCInst &Inst, unsigned N) const {
1025     assert(N == 3 && "Invalid number of operands!");
1026     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1027     if (!Mem.OffsetRegNum) {
1028       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1029       // Special case for #-0
1030       if (Val == INT32_MIN) Val = 0;
1031       if (Val < 0) Val = -Val;
1032       Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1033     } else {
1034       // For register offset, we encode the shift type and negation flag
1035       // here.
1036       Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
1037                               Mem.ShiftImm, Mem.ShiftType);
1038     }
1039     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1040     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1041     Inst.addOperand(MCOperand::CreateImm(Val));
1042   }
1043
1044   void addAM2OffsetImmOperands(MCInst &Inst, unsigned N) const {
1045     assert(N == 2 && "Invalid number of operands!");
1046     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1047     assert(CE && "non-constant AM2OffsetImm operand!");
1048     int32_t Val = CE->getValue();
1049     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1050     // Special case for #-0
1051     if (Val == INT32_MIN) Val = 0;
1052     if (Val < 0) Val = -Val;
1053     Val = ARM_AM::getAM2Opc(AddSub, Val, ARM_AM::no_shift);
1054     Inst.addOperand(MCOperand::CreateReg(0));
1055     Inst.addOperand(MCOperand::CreateImm(Val));
1056   }
1057
1058   void addAddrMode3Operands(MCInst &Inst, unsigned N) const {
1059     assert(N == 3 && "Invalid number of operands!");
1060     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1061     if (!Mem.OffsetRegNum) {
1062       ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1063       // Special case for #-0
1064       if (Val == INT32_MIN) Val = 0;
1065       if (Val < 0) Val = -Val;
1066       Val = ARM_AM::getAM3Opc(AddSub, Val);
1067     } else {
1068       // For register offset, we encode the shift type and negation flag
1069       // here.
1070       Val = ARM_AM::getAM3Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add, 0);
1071     }
1072     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1073     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1074     Inst.addOperand(MCOperand::CreateImm(Val));
1075   }
1076
1077   void addAM3OffsetOperands(MCInst &Inst, unsigned N) const {
1078     assert(N == 2 && "Invalid number of operands!");
1079     if (Kind == PostIndexRegister) {
1080       int32_t Val =
1081         ARM_AM::getAM3Opc(PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub, 0);
1082       Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1083       Inst.addOperand(MCOperand::CreateImm(Val));
1084       return;
1085     }
1086
1087     // Constant offset.
1088     const MCConstantExpr *CE = static_cast<const MCConstantExpr*>(getImm());
1089     int32_t Val = CE->getValue();
1090     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1091     // Special case for #-0
1092     if (Val == INT32_MIN) Val = 0;
1093     if (Val < 0) Val = -Val;
1094     Val = ARM_AM::getAM3Opc(AddSub, Val);
1095     Inst.addOperand(MCOperand::CreateReg(0));
1096     Inst.addOperand(MCOperand::CreateImm(Val));
1097   }
1098
1099   void addAddrMode5Operands(MCInst &Inst, unsigned N) const {
1100     assert(N == 2 && "Invalid number of operands!");
1101     // The lower two bits are always zero and as such are not encoded.
1102     int32_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() / 4 : 0;
1103     ARM_AM::AddrOpc AddSub = Val < 0 ? ARM_AM::sub : ARM_AM::add;
1104     // Special case for #-0
1105     if (Val == INT32_MIN) Val = 0;
1106     if (Val < 0) Val = -Val;
1107     Val = ARM_AM::getAM5Opc(AddSub, Val);
1108     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1109     Inst.addOperand(MCOperand::CreateImm(Val));
1110   }
1111
1112   void addMemImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1113     assert(N == 2 && "Invalid number of operands!");
1114     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1115     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1116     Inst.addOperand(MCOperand::CreateImm(Val));
1117   }
1118
1119   void addMemPosImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1120     addMemImm8OffsetOperands(Inst, N);
1121   }
1122
1123   void addMemNegImm8OffsetOperands(MCInst &Inst, unsigned N) const {
1124     addMemImm8OffsetOperands(Inst, N);
1125   }
1126
1127   void addMemUImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1128     assert(N == 2 && "Invalid number of operands!");
1129     // If this is an immediate, it's a label reference.
1130     if (Kind == Immediate) {
1131       addExpr(Inst, getImm());
1132       Inst.addOperand(MCOperand::CreateImm(0));
1133       return;
1134     }
1135
1136     // Otherwise, it's a normal memory reg+offset.
1137     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1138     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1139     Inst.addOperand(MCOperand::CreateImm(Val));
1140   }
1141
1142   void addMemImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1143     assert(N == 2 && "Invalid number of operands!");
1144     // If this is an immediate, it's a label reference.
1145     if (Kind == Immediate) {
1146       addExpr(Inst, getImm());
1147       Inst.addOperand(MCOperand::CreateImm(0));
1148       return;
1149     }
1150
1151     // Otherwise, it's a normal memory reg+offset.
1152     int64_t Val = Mem.OffsetImm ? Mem.OffsetImm->getValue() : 0;
1153     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1154     Inst.addOperand(MCOperand::CreateImm(Val));
1155   }
1156
1157   void addMemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1158     assert(N == 3 && "Invalid number of operands!");
1159     unsigned Val = ARM_AM::getAM2Opc(Mem.isNegative ? ARM_AM::sub : ARM_AM::add,
1160                                      Mem.ShiftImm, Mem.ShiftType);
1161     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1162     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1163     Inst.addOperand(MCOperand::CreateImm(Val));
1164   }
1165
1166   void addT2MemRegOffsetOperands(MCInst &Inst, unsigned N) const {
1167     assert(N == 3 && "Invalid number of operands!");
1168     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1169     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1170     Inst.addOperand(MCOperand::CreateImm(Mem.ShiftImm));
1171   }
1172
1173   void addMemThumbRROperands(MCInst &Inst, unsigned N) const {
1174     assert(N == 2 && "Invalid number of operands!");
1175     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1176     Inst.addOperand(MCOperand::CreateReg(Mem.OffsetRegNum));
1177   }
1178
1179   void addMemThumbRIs4Operands(MCInst &Inst, unsigned N) const {
1180     assert(N == 2 && "Invalid number of operands!");
1181     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 4) : 0;
1182     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1183     Inst.addOperand(MCOperand::CreateImm(Val));
1184   }
1185
1186   void addMemThumbRIs2Operands(MCInst &Inst, unsigned N) const {
1187     assert(N == 2 && "Invalid number of operands!");
1188     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 2) : 0;
1189     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1190     Inst.addOperand(MCOperand::CreateImm(Val));
1191   }
1192
1193   void addMemThumbRIs1Operands(MCInst &Inst, unsigned N) const {
1194     assert(N == 2 && "Invalid number of operands!");
1195     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue()) : 0;
1196     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1197     Inst.addOperand(MCOperand::CreateImm(Val));
1198   }
1199
1200   void addMemThumbSPIOperands(MCInst &Inst, unsigned N) const {
1201     assert(N == 2 && "Invalid number of operands!");
1202     int64_t Val = Mem.OffsetImm ? (Mem.OffsetImm->getValue() / 4) : 0;
1203     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
1204     Inst.addOperand(MCOperand::CreateImm(Val));
1205   }
1206
1207   void addPostIdxImm8Operands(MCInst &Inst, unsigned N) const {
1208     assert(N == 1 && "Invalid number of operands!");
1209     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
1210     assert(CE && "non-constant post-idx-imm8 operand!");
1211     int Imm = CE->getValue();
1212     bool isAdd = Imm >= 0;
1213     if (Imm == INT32_MIN) Imm = 0;
1214     Imm = (Imm < 0 ? -Imm : Imm) | (int)isAdd << 8;
1215     Inst.addOperand(MCOperand::CreateImm(Imm));
1216   }
1217
1218   void addPostIdxRegOperands(MCInst &Inst, unsigned N) const {
1219     assert(N == 2 && "Invalid number of operands!");
1220     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1221     Inst.addOperand(MCOperand::CreateImm(PostIdxReg.isAdd));
1222   }
1223
1224   void addPostIdxRegShiftedOperands(MCInst &Inst, unsigned N) const {
1225     assert(N == 2 && "Invalid number of operands!");
1226     Inst.addOperand(MCOperand::CreateReg(PostIdxReg.RegNum));
1227     // The sign, shift type, and shift amount are encoded in a single operand
1228     // using the AM2 encoding helpers.
1229     ARM_AM::AddrOpc opc = PostIdxReg.isAdd ? ARM_AM::add : ARM_AM::sub;
1230     unsigned Imm = ARM_AM::getAM2Opc(opc, PostIdxReg.ShiftImm,
1231                                      PostIdxReg.ShiftTy);
1232     Inst.addOperand(MCOperand::CreateImm(Imm));
1233   }
1234
1235   void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
1236     assert(N == 1 && "Invalid number of operands!");
1237     Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
1238   }
1239
1240   void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
1241     assert(N == 1 && "Invalid number of operands!");
1242     Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
1243   }
1244
1245   virtual void print(raw_ostream &OS) const;
1246
1247   static ARMOperand *CreateITMask(unsigned Mask, SMLoc S) {
1248     ARMOperand *Op = new ARMOperand(ITCondMask);
1249     Op->ITMask.Mask = Mask;
1250     Op->StartLoc = S;
1251     Op->EndLoc = S;
1252     return Op;
1253   }
1254
1255   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
1256     ARMOperand *Op = new ARMOperand(CondCode);
1257     Op->CC.Val = CC;
1258     Op->StartLoc = S;
1259     Op->EndLoc = S;
1260     return Op;
1261   }
1262
1263   static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
1264     ARMOperand *Op = new ARMOperand(CoprocNum);
1265     Op->Cop.Val = CopVal;
1266     Op->StartLoc = S;
1267     Op->EndLoc = S;
1268     return Op;
1269   }
1270
1271   static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
1272     ARMOperand *Op = new ARMOperand(CoprocReg);
1273     Op->Cop.Val = CopVal;
1274     Op->StartLoc = S;
1275     Op->EndLoc = S;
1276     return Op;
1277   }
1278
1279   static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
1280     ARMOperand *Op = new ARMOperand(CCOut);
1281     Op->Reg.RegNum = RegNum;
1282     Op->StartLoc = S;
1283     Op->EndLoc = S;
1284     return Op;
1285   }
1286
1287   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
1288     ARMOperand *Op = new ARMOperand(Token);
1289     Op->Tok.Data = Str.data();
1290     Op->Tok.Length = Str.size();
1291     Op->StartLoc = S;
1292     Op->EndLoc = S;
1293     return Op;
1294   }
1295
1296   static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
1297     ARMOperand *Op = new ARMOperand(Register);
1298     Op->Reg.RegNum = RegNum;
1299     Op->StartLoc = S;
1300     Op->EndLoc = E;
1301     return Op;
1302   }
1303
1304   static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
1305                                            unsigned SrcReg,
1306                                            unsigned ShiftReg,
1307                                            unsigned ShiftImm,
1308                                            SMLoc S, SMLoc E) {
1309     ARMOperand *Op = new ARMOperand(ShiftedRegister);
1310     Op->RegShiftedReg.ShiftTy = ShTy;
1311     Op->RegShiftedReg.SrcReg = SrcReg;
1312     Op->RegShiftedReg.ShiftReg = ShiftReg;
1313     Op->RegShiftedReg.ShiftImm = ShiftImm;
1314     Op->StartLoc = S;
1315     Op->EndLoc = E;
1316     return Op;
1317   }
1318
1319   static ARMOperand *CreateShiftedImmediate(ARM_AM::ShiftOpc ShTy,
1320                                             unsigned SrcReg,
1321                                             unsigned ShiftImm,
1322                                             SMLoc S, SMLoc E) {
1323     ARMOperand *Op = new ARMOperand(ShiftedImmediate);
1324     Op->RegShiftedImm.ShiftTy = ShTy;
1325     Op->RegShiftedImm.SrcReg = SrcReg;
1326     Op->RegShiftedImm.ShiftImm = ShiftImm;
1327     Op->StartLoc = S;
1328     Op->EndLoc = E;
1329     return Op;
1330   }
1331
1332   static ARMOperand *CreateShifterImm(bool isASR, unsigned Imm,
1333                                    SMLoc S, SMLoc E) {
1334     ARMOperand *Op = new ARMOperand(ShifterImmediate);
1335     Op->ShifterImm.isASR = isASR;
1336     Op->ShifterImm.Imm = Imm;
1337     Op->StartLoc = S;
1338     Op->EndLoc = E;
1339     return Op;
1340   }
1341
1342   static ARMOperand *CreateRotImm(unsigned Imm, SMLoc S, SMLoc E) {
1343     ARMOperand *Op = new ARMOperand(RotateImmediate);
1344     Op->RotImm.Imm = Imm;
1345     Op->StartLoc = S;
1346     Op->EndLoc = E;
1347     return Op;
1348   }
1349
1350   static ARMOperand *CreateBitfield(unsigned LSB, unsigned Width,
1351                                     SMLoc S, SMLoc E) {
1352     ARMOperand *Op = new ARMOperand(BitfieldDescriptor);
1353     Op->Bitfield.LSB = LSB;
1354     Op->Bitfield.Width = Width;
1355     Op->StartLoc = S;
1356     Op->EndLoc = E;
1357     return Op;
1358   }
1359
1360   static ARMOperand *
1361   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
1362                 SMLoc StartLoc, SMLoc EndLoc) {
1363     KindTy Kind = RegisterList;
1364
1365     if (llvm::ARMMCRegisterClasses[ARM::DPRRegClassID].
1366         contains(Regs.front().first))
1367       Kind = DPRRegisterList;
1368     else if (llvm::ARMMCRegisterClasses[ARM::SPRRegClassID].
1369              contains(Regs.front().first))
1370       Kind = SPRRegisterList;
1371
1372     ARMOperand *Op = new ARMOperand(Kind);
1373     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1374            I = Regs.begin(), E = Regs.end(); I != E; ++I)
1375       Op->Registers.push_back(I->first);
1376     array_pod_sort(Op->Registers.begin(), Op->Registers.end());
1377     Op->StartLoc = StartLoc;
1378     Op->EndLoc = EndLoc;
1379     return Op;
1380   }
1381
1382   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
1383     ARMOperand *Op = new ARMOperand(Immediate);
1384     Op->Imm.Val = Val;
1385     Op->StartLoc = S;
1386     Op->EndLoc = E;
1387     return Op;
1388   }
1389
1390   static ARMOperand *CreateMem(unsigned BaseRegNum,
1391                                const MCConstantExpr *OffsetImm,
1392                                unsigned OffsetRegNum,
1393                                ARM_AM::ShiftOpc ShiftType,
1394                                unsigned ShiftImm,
1395                                bool isNegative,
1396                                SMLoc S, SMLoc E) {
1397     ARMOperand *Op = new ARMOperand(Memory);
1398     Op->Mem.BaseRegNum = BaseRegNum;
1399     Op->Mem.OffsetImm = OffsetImm;
1400     Op->Mem.OffsetRegNum = OffsetRegNum;
1401     Op->Mem.ShiftType = ShiftType;
1402     Op->Mem.ShiftImm = ShiftImm;
1403     Op->Mem.isNegative = isNegative;
1404     Op->StartLoc = S;
1405     Op->EndLoc = E;
1406     return Op;
1407   }
1408
1409   static ARMOperand *CreatePostIdxReg(unsigned RegNum, bool isAdd,
1410                                       ARM_AM::ShiftOpc ShiftTy,
1411                                       unsigned ShiftImm,
1412                                       SMLoc S, SMLoc E) {
1413     ARMOperand *Op = new ARMOperand(PostIndexRegister);
1414     Op->PostIdxReg.RegNum = RegNum;
1415     Op->PostIdxReg.isAdd = isAdd;
1416     Op->PostIdxReg.ShiftTy = ShiftTy;
1417     Op->PostIdxReg.ShiftImm = ShiftImm;
1418     Op->StartLoc = S;
1419     Op->EndLoc = E;
1420     return Op;
1421   }
1422
1423   static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
1424     ARMOperand *Op = new ARMOperand(MemBarrierOpt);
1425     Op->MBOpt.Val = Opt;
1426     Op->StartLoc = S;
1427     Op->EndLoc = S;
1428     return Op;
1429   }
1430
1431   static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
1432     ARMOperand *Op = new ARMOperand(ProcIFlags);
1433     Op->IFlags.Val = IFlags;
1434     Op->StartLoc = S;
1435     Op->EndLoc = S;
1436     return Op;
1437   }
1438
1439   static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
1440     ARMOperand *Op = new ARMOperand(MSRMask);
1441     Op->MMask.Val = MMask;
1442     Op->StartLoc = S;
1443     Op->EndLoc = S;
1444     return Op;
1445   }
1446 };
1447
1448 } // end anonymous namespace.
1449
1450 void ARMOperand::print(raw_ostream &OS) const {
1451   switch (Kind) {
1452   case CondCode:
1453     OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
1454     break;
1455   case CCOut:
1456     OS << "<ccout " << getReg() << ">";
1457     break;
1458   case ITCondMask: {
1459     static char MaskStr[][6] = { "()", "(t)", "(e)", "(tt)", "(et)", "(te)",
1460       "(ee)", "(ttt)", "(ett)", "(tet)", "(eet)", "(tte)", "(ete)",
1461       "(tee)", "(eee)" };
1462     assert((ITMask.Mask & 0xf) == ITMask.Mask);
1463     OS << "<it-mask " << MaskStr[ITMask.Mask] << ">";
1464     break;
1465   }
1466   case CoprocNum:
1467     OS << "<coprocessor number: " << getCoproc() << ">";
1468     break;
1469   case CoprocReg:
1470     OS << "<coprocessor register: " << getCoproc() << ">";
1471     break;
1472   case MSRMask:
1473     OS << "<mask: " << getMSRMask() << ">";
1474     break;
1475   case Immediate:
1476     getImm()->print(OS);
1477     break;
1478   case MemBarrierOpt:
1479     OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
1480     break;
1481   case Memory:
1482     OS << "<memory "
1483        << " base:" << Mem.BaseRegNum;
1484     OS << ">";
1485     break;
1486   case PostIndexRegister:
1487     OS << "post-idx register " << (PostIdxReg.isAdd ? "" : "-")
1488        << PostIdxReg.RegNum;
1489     if (PostIdxReg.ShiftTy != ARM_AM::no_shift)
1490       OS << ARM_AM::getShiftOpcStr(PostIdxReg.ShiftTy) << " "
1491          << PostIdxReg.ShiftImm;
1492     OS << ">";
1493     break;
1494   case ProcIFlags: {
1495     OS << "<ARM_PROC::";
1496     unsigned IFlags = getProcIFlags();
1497     for (int i=2; i >= 0; --i)
1498       if (IFlags & (1 << i))
1499         OS << ARM_PROC::IFlagsToString(1 << i);
1500     OS << ">";
1501     break;
1502   }
1503   case Register:
1504     OS << "<register " << getReg() << ">";
1505     break;
1506   case ShifterImmediate:
1507     OS << "<shift " << (ShifterImm.isASR ? "asr" : "lsl")
1508        << " #" << ShifterImm.Imm << ">";
1509     break;
1510   case ShiftedRegister:
1511     OS << "<so_reg_reg "
1512        << RegShiftedReg.SrcReg
1513        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedReg.ShiftImm))
1514        << ", " << RegShiftedReg.ShiftReg << ", "
1515        << ARM_AM::getSORegOffset(RegShiftedReg.ShiftImm)
1516        << ">";
1517     break;
1518   case ShiftedImmediate:
1519     OS << "<so_reg_imm "
1520        << RegShiftedImm.SrcReg
1521        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(RegShiftedImm.ShiftImm))
1522        << ", " << ARM_AM::getSORegOffset(RegShiftedImm.ShiftImm)
1523        << ">";
1524     break;
1525   case RotateImmediate:
1526     OS << "<ror " << " #" << (RotImm.Imm * 8) << ">";
1527     break;
1528   case BitfieldDescriptor:
1529     OS << "<bitfield " << "lsb: " << Bitfield.LSB
1530        << ", width: " << Bitfield.Width << ">";
1531     break;
1532   case RegisterList:
1533   case DPRRegisterList:
1534   case SPRRegisterList: {
1535     OS << "<register_list ";
1536
1537     const SmallVectorImpl<unsigned> &RegList = getRegList();
1538     for (SmallVectorImpl<unsigned>::const_iterator
1539            I = RegList.begin(), E = RegList.end(); I != E; ) {
1540       OS << *I;
1541       if (++I < E) OS << ", ";
1542     }
1543
1544     OS << ">";
1545     break;
1546   }
1547   case Token:
1548     OS << "'" << getToken() << "'";
1549     break;
1550   }
1551 }
1552
1553 /// @name Auto-generated Match Functions
1554 /// {
1555
1556 static unsigned MatchRegisterName(StringRef Name);
1557
1558 /// }
1559
1560 bool ARMAsmParser::ParseRegister(unsigned &RegNo,
1561                                  SMLoc &StartLoc, SMLoc &EndLoc) {
1562   RegNo = tryParseRegister();
1563
1564   return (RegNo == (unsigned)-1);
1565 }
1566
1567 /// Try to parse a register name.  The token must be an Identifier when called,
1568 /// and if it is a register name the token is eaten and the register number is
1569 /// returned.  Otherwise return -1.
1570 ///
1571 int ARMAsmParser::tryParseRegister() {
1572   const AsmToken &Tok = Parser.getTok();
1573   if (Tok.isNot(AsmToken::Identifier)) return -1;
1574
1575   // FIXME: Validate register for the current architecture; we have to do
1576   // validation later, so maybe there is no need for this here.
1577   std::string upperCase = Tok.getString().str();
1578   std::string lowerCase = LowercaseString(upperCase);
1579   unsigned RegNum = MatchRegisterName(lowerCase);
1580   if (!RegNum) {
1581     RegNum = StringSwitch<unsigned>(lowerCase)
1582       .Case("r13", ARM::SP)
1583       .Case("r14", ARM::LR)
1584       .Case("r15", ARM::PC)
1585       .Case("ip", ARM::R12)
1586       .Default(0);
1587   }
1588   if (!RegNum) return -1;
1589
1590   Parser.Lex(); // Eat identifier token.
1591   return RegNum;
1592 }
1593
1594 // Try to parse a shifter  (e.g., "lsl <amt>"). On success, return 0.
1595 // If a recoverable error occurs, return 1. If an irrecoverable error
1596 // occurs, return -1. An irrecoverable error is one where tokens have been
1597 // consumed in the process of trying to parse the shifter (i.e., when it is
1598 // indeed a shifter operand, but malformed).
1599 int ARMAsmParser::tryParseShiftRegister(
1600                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1601   SMLoc S = Parser.getTok().getLoc();
1602   const AsmToken &Tok = Parser.getTok();
1603   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1604
1605   std::string upperCase = Tok.getString().str();
1606   std::string lowerCase = LowercaseString(upperCase);
1607   ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
1608       .Case("lsl", ARM_AM::lsl)
1609       .Case("lsr", ARM_AM::lsr)
1610       .Case("asr", ARM_AM::asr)
1611       .Case("ror", ARM_AM::ror)
1612       .Case("rrx", ARM_AM::rrx)
1613       .Default(ARM_AM::no_shift);
1614
1615   if (ShiftTy == ARM_AM::no_shift)
1616     return 1;
1617
1618   Parser.Lex(); // Eat the operator.
1619
1620   // The source register for the shift has already been added to the
1621   // operand list, so we need to pop it off and combine it into the shifted
1622   // register operand instead.
1623   OwningPtr<ARMOperand> PrevOp((ARMOperand*)Operands.pop_back_val());
1624   if (!PrevOp->isReg())
1625     return Error(PrevOp->getStartLoc(), "shift must be of a register");
1626   int SrcReg = PrevOp->getReg();
1627   int64_t Imm = 0;
1628   int ShiftReg = 0;
1629   if (ShiftTy == ARM_AM::rrx) {
1630     // RRX Doesn't have an explicit shift amount. The encoder expects
1631     // the shift register to be the same as the source register. Seems odd,
1632     // but OK.
1633     ShiftReg = SrcReg;
1634   } else {
1635     // Figure out if this is shifted by a constant or a register (for non-RRX).
1636     if (Parser.getTok().is(AsmToken::Hash)) {
1637       Parser.Lex(); // Eat hash.
1638       SMLoc ImmLoc = Parser.getTok().getLoc();
1639       const MCExpr *ShiftExpr = 0;
1640       if (getParser().ParseExpression(ShiftExpr)) {
1641         Error(ImmLoc, "invalid immediate shift value");
1642         return -1;
1643       }
1644       // The expression must be evaluatable as an immediate.
1645       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
1646       if (!CE) {
1647         Error(ImmLoc, "invalid immediate shift value");
1648         return -1;
1649       }
1650       // Range check the immediate.
1651       // lsl, ror: 0 <= imm <= 31
1652       // lsr, asr: 0 <= imm <= 32
1653       Imm = CE->getValue();
1654       if (Imm < 0 ||
1655           ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
1656           ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
1657         Error(ImmLoc, "immediate shift value out of range");
1658         return -1;
1659       }
1660     } else if (Parser.getTok().is(AsmToken::Identifier)) {
1661       ShiftReg = tryParseRegister();
1662       SMLoc L = Parser.getTok().getLoc();
1663       if (ShiftReg == -1) {
1664         Error (L, "expected immediate or register in shift operand");
1665         return -1;
1666       }
1667     } else {
1668       Error (Parser.getTok().getLoc(),
1669                     "expected immediate or register in shift operand");
1670       return -1;
1671     }
1672   }
1673
1674   if (ShiftReg && ShiftTy != ARM_AM::rrx)
1675     Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
1676                                                          ShiftReg, Imm,
1677                                                S, Parser.getTok().getLoc()));
1678   else
1679     Operands.push_back(ARMOperand::CreateShiftedImmediate(ShiftTy, SrcReg, Imm,
1680                                                S, Parser.getTok().getLoc()));
1681
1682   return 0;
1683 }
1684
1685
1686 /// Try to parse a register name.  The token must be an Identifier when called.
1687 /// If it's a register, an AsmOperand is created. Another AsmOperand is created
1688 /// if there is a "writeback". 'true' if it's not a register.
1689 ///
1690 /// TODO this is likely to change to allow different register types and or to
1691 /// parse for a specific register type.
1692 bool ARMAsmParser::
1693 tryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1694   SMLoc S = Parser.getTok().getLoc();
1695   int RegNo = tryParseRegister();
1696   if (RegNo == -1)
1697     return true;
1698
1699   Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
1700
1701   const AsmToken &ExclaimTok = Parser.getTok();
1702   if (ExclaimTok.is(AsmToken::Exclaim)) {
1703     Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
1704                                                ExclaimTok.getLoc()));
1705     Parser.Lex(); // Eat exclaim token
1706   }
1707
1708   return false;
1709 }
1710
1711 /// MatchCoprocessorOperandName - Try to parse an coprocessor related
1712 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
1713 /// "c5", ...
1714 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
1715   // Use the same layout as the tablegen'erated register name matcher. Ugly,
1716   // but efficient.
1717   switch (Name.size()) {
1718   default: break;
1719   case 2:
1720     if (Name[0] != CoprocOp)
1721       return -1;
1722     switch (Name[1]) {
1723     default:  return -1;
1724     case '0': return 0;
1725     case '1': return 1;
1726     case '2': return 2;
1727     case '3': return 3;
1728     case '4': return 4;
1729     case '5': return 5;
1730     case '6': return 6;
1731     case '7': return 7;
1732     case '8': return 8;
1733     case '9': return 9;
1734     }
1735     break;
1736   case 3:
1737     if (Name[0] != CoprocOp || Name[1] != '1')
1738       return -1;
1739     switch (Name[2]) {
1740     default:  return -1;
1741     case '0': return 10;
1742     case '1': return 11;
1743     case '2': return 12;
1744     case '3': return 13;
1745     case '4': return 14;
1746     case '5': return 15;
1747     }
1748     break;
1749   }
1750
1751   return -1;
1752 }
1753
1754 /// parseITCondCode - Try to parse a condition code for an IT instruction.
1755 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1756 parseITCondCode(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1757   SMLoc S = Parser.getTok().getLoc();
1758   const AsmToken &Tok = Parser.getTok();
1759   if (!Tok.is(AsmToken::Identifier))
1760     return MatchOperand_NoMatch;
1761   unsigned CC = StringSwitch<unsigned>(Tok.getString())
1762     .Case("eq", ARMCC::EQ)
1763     .Case("ne", ARMCC::NE)
1764     .Case("hs", ARMCC::HS)
1765     .Case("cs", ARMCC::HS)
1766     .Case("lo", ARMCC::LO)
1767     .Case("cc", ARMCC::LO)
1768     .Case("mi", ARMCC::MI)
1769     .Case("pl", ARMCC::PL)
1770     .Case("vs", ARMCC::VS)
1771     .Case("vc", ARMCC::VC)
1772     .Case("hi", ARMCC::HI)
1773     .Case("ls", ARMCC::LS)
1774     .Case("ge", ARMCC::GE)
1775     .Case("lt", ARMCC::LT)
1776     .Case("gt", ARMCC::GT)
1777     .Case("le", ARMCC::LE)
1778     .Case("al", ARMCC::AL)
1779     .Default(~0U);
1780   if (CC == ~0U)
1781     return MatchOperand_NoMatch;
1782   Parser.Lex(); // Eat the token.
1783
1784   Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), S));
1785
1786   return MatchOperand_Success;
1787 }
1788
1789 /// parseCoprocNumOperand - Try to parse an coprocessor number operand. The
1790 /// token must be an Identifier when called, and if it is a coprocessor
1791 /// number, the token is eaten and the operand is added to the operand list.
1792 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1793 parseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1794   SMLoc S = Parser.getTok().getLoc();
1795   const AsmToken &Tok = Parser.getTok();
1796   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1797
1798   int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
1799   if (Num == -1)
1800     return MatchOperand_NoMatch;
1801
1802   Parser.Lex(); // Eat identifier token.
1803   Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
1804   return MatchOperand_Success;
1805 }
1806
1807 /// parseCoprocRegOperand - Try to parse an coprocessor register operand. The
1808 /// token must be an Identifier when called, and if it is a coprocessor
1809 /// number, the token is eaten and the operand is added to the operand list.
1810 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1811 parseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1812   SMLoc S = Parser.getTok().getLoc();
1813   const AsmToken &Tok = Parser.getTok();
1814   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1815
1816   int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
1817   if (Reg == -1)
1818     return MatchOperand_NoMatch;
1819
1820   Parser.Lex(); // Eat identifier token.
1821   Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
1822   return MatchOperand_Success;
1823 }
1824
1825 /// Parse a register list, return it if successful else return null.  The first
1826 /// token must be a '{' when called.
1827 bool ARMAsmParser::
1828 parseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1829   assert(Parser.getTok().is(AsmToken::LCurly) &&
1830          "Token is not a Left Curly Brace");
1831   SMLoc S = Parser.getTok().getLoc();
1832
1833   // Read the rest of the registers in the list.
1834   unsigned PrevRegNum = 0;
1835   SmallVector<std::pair<unsigned, SMLoc>, 32> Registers;
1836
1837   do {
1838     bool IsRange = Parser.getTok().is(AsmToken::Minus);
1839     Parser.Lex(); // Eat non-identifier token.
1840
1841     const AsmToken &RegTok = Parser.getTok();
1842     SMLoc RegLoc = RegTok.getLoc();
1843     if (RegTok.isNot(AsmToken::Identifier)) {
1844       Error(RegLoc, "register expected");
1845       return true;
1846     }
1847
1848     int RegNum = tryParseRegister();
1849     if (RegNum == -1) {
1850       Error(RegLoc, "register expected");
1851       return true;
1852     }
1853
1854     if (IsRange) {
1855       int Reg = PrevRegNum;
1856       do {
1857         ++Reg;
1858         Registers.push_back(std::make_pair(Reg, RegLoc));
1859       } while (Reg != RegNum);
1860     } else {
1861       Registers.push_back(std::make_pair(RegNum, RegLoc));
1862     }
1863
1864     PrevRegNum = RegNum;
1865   } while (Parser.getTok().is(AsmToken::Comma) ||
1866            Parser.getTok().is(AsmToken::Minus));
1867
1868   // Process the right curly brace of the list.
1869   const AsmToken &RCurlyTok = Parser.getTok();
1870   if (RCurlyTok.isNot(AsmToken::RCurly)) {
1871     Error(RCurlyTok.getLoc(), "'}' expected");
1872     return true;
1873   }
1874
1875   SMLoc E = RCurlyTok.getLoc();
1876   Parser.Lex(); // Eat right curly brace token.
1877
1878   // Verify the register list.
1879   bool EmittedWarning = false;
1880   unsigned HighRegNum = 0;
1881   BitVector RegMap(32);
1882   for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
1883     const std::pair<unsigned, SMLoc> &RegInfo = Registers[i];
1884     unsigned Reg = getARMRegisterNumbering(RegInfo.first);
1885
1886     if (RegMap[Reg]) {
1887       Error(RegInfo.second, "register duplicated in register list");
1888       return true;
1889     }
1890
1891     if (!EmittedWarning && Reg < HighRegNum)
1892       Warning(RegInfo.second,
1893               "register not in ascending order in register list");
1894
1895     RegMap.set(Reg);
1896     HighRegNum = std::max(Reg, HighRegNum);
1897   }
1898
1899   Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
1900   return false;
1901 }
1902
1903 /// parseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
1904 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1905 parseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1906   SMLoc S = Parser.getTok().getLoc();
1907   const AsmToken &Tok = Parser.getTok();
1908   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1909   StringRef OptStr = Tok.getString();
1910
1911   unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
1912     .Case("sy",    ARM_MB::SY)
1913     .Case("st",    ARM_MB::ST)
1914     .Case("sh",    ARM_MB::ISH)
1915     .Case("ish",   ARM_MB::ISH)
1916     .Case("shst",  ARM_MB::ISHST)
1917     .Case("ishst", ARM_MB::ISHST)
1918     .Case("nsh",   ARM_MB::NSH)
1919     .Case("un",    ARM_MB::NSH)
1920     .Case("nshst", ARM_MB::NSHST)
1921     .Case("unst",  ARM_MB::NSHST)
1922     .Case("osh",   ARM_MB::OSH)
1923     .Case("oshst", ARM_MB::OSHST)
1924     .Default(~0U);
1925
1926   if (Opt == ~0U)
1927     return MatchOperand_NoMatch;
1928
1929   Parser.Lex(); // Eat identifier token.
1930   Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
1931   return MatchOperand_Success;
1932 }
1933
1934 /// parseProcIFlagsOperand - Try to parse iflags from CPS instruction.
1935 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1936 parseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1937   SMLoc S = Parser.getTok().getLoc();
1938   const AsmToken &Tok = Parser.getTok();
1939   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1940   StringRef IFlagsStr = Tok.getString();
1941
1942   unsigned IFlags = 0;
1943   for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
1944     unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
1945     .Case("a", ARM_PROC::A)
1946     .Case("i", ARM_PROC::I)
1947     .Case("f", ARM_PROC::F)
1948     .Default(~0U);
1949
1950     // If some specific iflag is already set, it means that some letter is
1951     // present more than once, this is not acceptable.
1952     if (Flag == ~0U || (IFlags & Flag))
1953       return MatchOperand_NoMatch;
1954
1955     IFlags |= Flag;
1956   }
1957
1958   Parser.Lex(); // Eat identifier token.
1959   Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
1960   return MatchOperand_Success;
1961 }
1962
1963 /// parseMSRMaskOperand - Try to parse mask flags from MSR instruction.
1964 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1965 parseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1966   SMLoc S = Parser.getTok().getLoc();
1967   const AsmToken &Tok = Parser.getTok();
1968   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1969   StringRef Mask = Tok.getString();
1970
1971   // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
1972   size_t Start = 0, Next = Mask.find('_');
1973   StringRef Flags = "";
1974   std::string SpecReg = LowercaseString(Mask.slice(Start, Next));
1975   if (Next != StringRef::npos)
1976     Flags = Mask.slice(Next+1, Mask.size());
1977
1978   // FlagsVal contains the complete mask:
1979   // 3-0: Mask
1980   // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
1981   unsigned FlagsVal = 0;
1982
1983   if (SpecReg == "apsr") {
1984     FlagsVal = StringSwitch<unsigned>(Flags)
1985     .Case("nzcvq",  0x8) // same as CPSR_f
1986     .Case("g",      0x4) // same as CPSR_s
1987     .Case("nzcvqg", 0xc) // same as CPSR_fs
1988     .Default(~0U);
1989
1990     if (FlagsVal == ~0U) {
1991       if (!Flags.empty())
1992         return MatchOperand_NoMatch;
1993       else
1994         FlagsVal = 0; // No flag
1995     }
1996   } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
1997     if (Flags == "all") // cpsr_all is an alias for cpsr_fc
1998       Flags = "fc";
1999     for (int i = 0, e = Flags.size(); i != e; ++i) {
2000       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
2001       .Case("c", 1)
2002       .Case("x", 2)
2003       .Case("s", 4)
2004       .Case("f", 8)
2005       .Default(~0U);
2006
2007       // If some specific flag is already set, it means that some letter is
2008       // present more than once, this is not acceptable.
2009       if (FlagsVal == ~0U || (FlagsVal & Flag))
2010         return MatchOperand_NoMatch;
2011       FlagsVal |= Flag;
2012     }
2013   } else // No match for special register.
2014     return MatchOperand_NoMatch;
2015
2016   // Special register without flags are equivalent to "fc" flags.
2017   if (!FlagsVal)
2018     FlagsVal = 0x9;
2019
2020   // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
2021   if (SpecReg == "spsr")
2022     FlagsVal |= 16;
2023
2024   Parser.Lex(); // Eat identifier token.
2025   Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
2026   return MatchOperand_Success;
2027 }
2028
2029 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2030 parsePKHImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands, StringRef Op,
2031             int Low, int High) {
2032   const AsmToken &Tok = Parser.getTok();
2033   if (Tok.isNot(AsmToken::Identifier)) {
2034     Error(Parser.getTok().getLoc(), Op + " operand expected.");
2035     return MatchOperand_ParseFail;
2036   }
2037   StringRef ShiftName = Tok.getString();
2038   std::string LowerOp = LowercaseString(Op);
2039   std::string UpperOp = UppercaseString(Op);
2040   if (ShiftName != LowerOp && ShiftName != UpperOp) {
2041     Error(Parser.getTok().getLoc(), Op + " operand expected.");
2042     return MatchOperand_ParseFail;
2043   }
2044   Parser.Lex(); // Eat shift type token.
2045
2046   // There must be a '#' and a shift amount.
2047   if (Parser.getTok().isNot(AsmToken::Hash)) {
2048     Error(Parser.getTok().getLoc(), "'#' expected");
2049     return MatchOperand_ParseFail;
2050   }
2051   Parser.Lex(); // Eat hash token.
2052
2053   const MCExpr *ShiftAmount;
2054   SMLoc Loc = Parser.getTok().getLoc();
2055   if (getParser().ParseExpression(ShiftAmount)) {
2056     Error(Loc, "illegal expression");
2057     return MatchOperand_ParseFail;
2058   }
2059   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2060   if (!CE) {
2061     Error(Loc, "constant expression expected");
2062     return MatchOperand_ParseFail;
2063   }
2064   int Val = CE->getValue();
2065   if (Val < Low || Val > High) {
2066     Error(Loc, "immediate value out of range");
2067     return MatchOperand_ParseFail;
2068   }
2069
2070   Operands.push_back(ARMOperand::CreateImm(CE, Loc, Parser.getTok().getLoc()));
2071
2072   return MatchOperand_Success;
2073 }
2074
2075 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2076 parseSetEndImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2077   const AsmToken &Tok = Parser.getTok();
2078   SMLoc S = Tok.getLoc();
2079   if (Tok.isNot(AsmToken::Identifier)) {
2080     Error(Tok.getLoc(), "'be' or 'le' operand expected");
2081     return MatchOperand_ParseFail;
2082   }
2083   int Val = StringSwitch<int>(Tok.getString())
2084     .Case("be", 1)
2085     .Case("le", 0)
2086     .Default(-1);
2087   Parser.Lex(); // Eat the token.
2088
2089   if (Val == -1) {
2090     Error(Tok.getLoc(), "'be' or 'le' operand expected");
2091     return MatchOperand_ParseFail;
2092   }
2093   Operands.push_back(ARMOperand::CreateImm(MCConstantExpr::Create(Val,
2094                                                                   getContext()),
2095                                            S, Parser.getTok().getLoc()));
2096   return MatchOperand_Success;
2097 }
2098
2099 /// parseShifterImm - Parse the shifter immediate operand for SSAT/USAT
2100 /// instructions. Legal values are:
2101 ///     lsl #n  'n' in [0,31]
2102 ///     asr #n  'n' in [1,32]
2103 ///             n == 32 encoded as n == 0.
2104 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2105 parseShifterImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2106   const AsmToken &Tok = Parser.getTok();
2107   SMLoc S = Tok.getLoc();
2108   if (Tok.isNot(AsmToken::Identifier)) {
2109     Error(S, "shift operator 'asr' or 'lsl' expected");
2110     return MatchOperand_ParseFail;
2111   }
2112   StringRef ShiftName = Tok.getString();
2113   bool isASR;
2114   if (ShiftName == "lsl" || ShiftName == "LSL")
2115     isASR = false;
2116   else if (ShiftName == "asr" || ShiftName == "ASR")
2117     isASR = true;
2118   else {
2119     Error(S, "shift operator 'asr' or 'lsl' expected");
2120     return MatchOperand_ParseFail;
2121   }
2122   Parser.Lex(); // Eat the operator.
2123
2124   // A '#' and a shift amount.
2125   if (Parser.getTok().isNot(AsmToken::Hash)) {
2126     Error(Parser.getTok().getLoc(), "'#' expected");
2127     return MatchOperand_ParseFail;
2128   }
2129   Parser.Lex(); // Eat hash token.
2130
2131   const MCExpr *ShiftAmount;
2132   SMLoc E = Parser.getTok().getLoc();
2133   if (getParser().ParseExpression(ShiftAmount)) {
2134     Error(E, "malformed shift expression");
2135     return MatchOperand_ParseFail;
2136   }
2137   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2138   if (!CE) {
2139     Error(E, "shift amount must be an immediate");
2140     return MatchOperand_ParseFail;
2141   }
2142
2143   int64_t Val = CE->getValue();
2144   if (isASR) {
2145     // Shift amount must be in [1,32]
2146     if (Val < 1 || Val > 32) {
2147       Error(E, "'asr' shift amount must be in range [1,32]");
2148       return MatchOperand_ParseFail;
2149     }
2150     // asr #32 encoded as asr #0.
2151     if (Val == 32) Val = 0;
2152   } else {
2153     // Shift amount must be in [1,32]
2154     if (Val < 0 || Val > 31) {
2155       Error(E, "'lsr' shift amount must be in range [0,31]");
2156       return MatchOperand_ParseFail;
2157     }
2158   }
2159
2160   E = Parser.getTok().getLoc();
2161   Operands.push_back(ARMOperand::CreateShifterImm(isASR, Val, S, E));
2162
2163   return MatchOperand_Success;
2164 }
2165
2166 /// parseRotImm - Parse the shifter immediate operand for SXTB/UXTB family
2167 /// of instructions. Legal values are:
2168 ///     ror #n  'n' in {0, 8, 16, 24}
2169 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2170 parseRotImm(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2171   const AsmToken &Tok = Parser.getTok();
2172   SMLoc S = Tok.getLoc();
2173   if (Tok.isNot(AsmToken::Identifier)) {
2174     Error(S, "rotate operator 'ror' expected");
2175     return MatchOperand_ParseFail;
2176   }
2177   StringRef ShiftName = Tok.getString();
2178   if (ShiftName != "ror" && ShiftName != "ROR") {
2179     Error(S, "rotate operator 'ror' expected");
2180     return MatchOperand_ParseFail;
2181   }
2182   Parser.Lex(); // Eat the operator.
2183
2184   // A '#' and a rotate amount.
2185   if (Parser.getTok().isNot(AsmToken::Hash)) {
2186     Error(Parser.getTok().getLoc(), "'#' expected");
2187     return MatchOperand_ParseFail;
2188   }
2189   Parser.Lex(); // Eat hash token.
2190
2191   const MCExpr *ShiftAmount;
2192   SMLoc E = Parser.getTok().getLoc();
2193   if (getParser().ParseExpression(ShiftAmount)) {
2194     Error(E, "malformed rotate expression");
2195     return MatchOperand_ParseFail;
2196   }
2197   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftAmount);
2198   if (!CE) {
2199     Error(E, "rotate amount must be an immediate");
2200     return MatchOperand_ParseFail;
2201   }
2202
2203   int64_t Val = CE->getValue();
2204   // Shift amount must be in {0, 8, 16, 24} (0 is undocumented extension)
2205   // normally, zero is represented in asm by omitting the rotate operand
2206   // entirely.
2207   if (Val != 8 && Val != 16 && Val != 24 && Val != 0) {
2208     Error(E, "'ror' rotate amount must be 8, 16, or 24");
2209     return MatchOperand_ParseFail;
2210   }
2211
2212   E = Parser.getTok().getLoc();
2213   Operands.push_back(ARMOperand::CreateRotImm(Val, S, E));
2214
2215   return MatchOperand_Success;
2216 }
2217
2218 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2219 parseBitfield(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2220   SMLoc S = Parser.getTok().getLoc();
2221   // The bitfield descriptor is really two operands, the LSB and the width.
2222   if (Parser.getTok().isNot(AsmToken::Hash)) {
2223     Error(Parser.getTok().getLoc(), "'#' expected");
2224     return MatchOperand_ParseFail;
2225   }
2226   Parser.Lex(); // Eat hash token.
2227
2228   const MCExpr *LSBExpr;
2229   SMLoc E = Parser.getTok().getLoc();
2230   if (getParser().ParseExpression(LSBExpr)) {
2231     Error(E, "malformed immediate expression");
2232     return MatchOperand_ParseFail;
2233   }
2234   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(LSBExpr);
2235   if (!CE) {
2236     Error(E, "'lsb' operand must be an immediate");
2237     return MatchOperand_ParseFail;
2238   }
2239
2240   int64_t LSB = CE->getValue();
2241   // The LSB must be in the range [0,31]
2242   if (LSB < 0 || LSB > 31) {
2243     Error(E, "'lsb' operand must be in the range [0,31]");
2244     return MatchOperand_ParseFail;
2245   }
2246   E = Parser.getTok().getLoc();
2247
2248   // Expect another immediate operand.
2249   if (Parser.getTok().isNot(AsmToken::Comma)) {
2250     Error(Parser.getTok().getLoc(), "too few operands");
2251     return MatchOperand_ParseFail;
2252   }
2253   Parser.Lex(); // Eat hash token.
2254   if (Parser.getTok().isNot(AsmToken::Hash)) {
2255     Error(Parser.getTok().getLoc(), "'#' expected");
2256     return MatchOperand_ParseFail;
2257   }
2258   Parser.Lex(); // Eat hash token.
2259
2260   const MCExpr *WidthExpr;
2261   if (getParser().ParseExpression(WidthExpr)) {
2262     Error(E, "malformed immediate expression");
2263     return MatchOperand_ParseFail;
2264   }
2265   CE = dyn_cast<MCConstantExpr>(WidthExpr);
2266   if (!CE) {
2267     Error(E, "'width' operand must be an immediate");
2268     return MatchOperand_ParseFail;
2269   }
2270
2271   int64_t Width = CE->getValue();
2272   // The LSB must be in the range [1,32-lsb]
2273   if (Width < 1 || Width > 32 - LSB) {
2274     Error(E, "'width' operand must be in the range [1,32-lsb]");
2275     return MatchOperand_ParseFail;
2276   }
2277   E = Parser.getTok().getLoc();
2278
2279   Operands.push_back(ARMOperand::CreateBitfield(LSB, Width, S, E));
2280
2281   return MatchOperand_Success;
2282 }
2283
2284 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2285 parsePostIdxReg(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2286   // Check for a post-index addressing register operand. Specifically:
2287   // postidx_reg := '+' register {, shift}
2288   //              | '-' register {, shift}
2289   //              | register {, shift}
2290
2291   // This method must return MatchOperand_NoMatch without consuming any tokens
2292   // in the case where there is no match, as other alternatives take other
2293   // parse methods.
2294   AsmToken Tok = Parser.getTok();
2295   SMLoc S = Tok.getLoc();
2296   bool haveEaten = false;
2297   bool isAdd = true;
2298   int Reg = -1;
2299   if (Tok.is(AsmToken::Plus)) {
2300     Parser.Lex(); // Eat the '+' token.
2301     haveEaten = true;
2302   } else if (Tok.is(AsmToken::Minus)) {
2303     Parser.Lex(); // Eat the '-' token.
2304     isAdd = false;
2305     haveEaten = true;
2306   }
2307   if (Parser.getTok().is(AsmToken::Identifier))
2308     Reg = tryParseRegister();
2309   if (Reg == -1) {
2310     if (!haveEaten)
2311       return MatchOperand_NoMatch;
2312     Error(Parser.getTok().getLoc(), "register expected");
2313     return MatchOperand_ParseFail;
2314   }
2315   SMLoc E = Parser.getTok().getLoc();
2316
2317   ARM_AM::ShiftOpc ShiftTy = ARM_AM::no_shift;
2318   unsigned ShiftImm = 0;
2319   if (Parser.getTok().is(AsmToken::Comma)) {
2320     Parser.Lex(); // Eat the ','.
2321     if (parseMemRegOffsetShift(ShiftTy, ShiftImm))
2322       return MatchOperand_ParseFail;
2323   }
2324
2325   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ShiftTy,
2326                                                   ShiftImm, S, E));
2327
2328   return MatchOperand_Success;
2329 }
2330
2331 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
2332 parseAM3Offset(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2333   // Check for a post-index addressing register operand. Specifically:
2334   // am3offset := '+' register
2335   //              | '-' register
2336   //              | register
2337   //              | # imm
2338   //              | # + imm
2339   //              | # - imm
2340
2341   // This method must return MatchOperand_NoMatch without consuming any tokens
2342   // in the case where there is no match, as other alternatives take other
2343   // parse methods.
2344   AsmToken Tok = Parser.getTok();
2345   SMLoc S = Tok.getLoc();
2346
2347   // Do immediates first, as we always parse those if we have a '#'.
2348   if (Parser.getTok().is(AsmToken::Hash)) {
2349     Parser.Lex(); // Eat the '#'.
2350     // Explicitly look for a '-', as we need to encode negative zero
2351     // differently.
2352     bool isNegative = Parser.getTok().is(AsmToken::Minus);
2353     const MCExpr *Offset;
2354     if (getParser().ParseExpression(Offset))
2355       return MatchOperand_ParseFail;
2356     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2357     if (!CE) {
2358       Error(S, "constant expression expected");
2359       return MatchOperand_ParseFail;
2360     }
2361     SMLoc E = Tok.getLoc();
2362     // Negative zero is encoded as the flag value INT32_MIN.
2363     int32_t Val = CE->getValue();
2364     if (isNegative && Val == 0)
2365       Val = INT32_MIN;
2366
2367     Operands.push_back(
2368       ARMOperand::CreateImm(MCConstantExpr::Create(Val, getContext()), S, E));
2369
2370     return MatchOperand_Success;
2371   }
2372
2373
2374   bool haveEaten = false;
2375   bool isAdd = true;
2376   int Reg = -1;
2377   if (Tok.is(AsmToken::Plus)) {
2378     Parser.Lex(); // Eat the '+' token.
2379     haveEaten = true;
2380   } else if (Tok.is(AsmToken::Minus)) {
2381     Parser.Lex(); // Eat the '-' token.
2382     isAdd = false;
2383     haveEaten = true;
2384   }
2385   if (Parser.getTok().is(AsmToken::Identifier))
2386     Reg = tryParseRegister();
2387   if (Reg == -1) {
2388     if (!haveEaten)
2389       return MatchOperand_NoMatch;
2390     Error(Parser.getTok().getLoc(), "register expected");
2391     return MatchOperand_ParseFail;
2392   }
2393   SMLoc E = Parser.getTok().getLoc();
2394
2395   Operands.push_back(ARMOperand::CreatePostIdxReg(Reg, isAdd, ARM_AM::no_shift,
2396                                                   0, S, E));
2397
2398   return MatchOperand_Success;
2399 }
2400
2401 /// cvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2402 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2403 /// when they refer multiple MIOperands inside a single one.
2404 bool ARMAsmParser::
2405 cvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2406                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2407   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2408
2409   // Create a writeback register dummy placeholder.
2410   Inst.addOperand(MCOperand::CreateImm(0));
2411
2412   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2413   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2414   return true;
2415 }
2416
2417 /// cvtLdWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
2418 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2419 /// when they refer multiple MIOperands inside a single one.
2420 bool ARMAsmParser::
2421 cvtLdWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
2422                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2423   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2424
2425   // Create a writeback register dummy placeholder.
2426   Inst.addOperand(MCOperand::CreateImm(0));
2427
2428   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
2429   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2430   return true;
2431 }
2432
2433
2434 /// cvtStWriteBackRegAddrModeImm12 - Convert parsed operands to MCInst.
2435 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2436 /// when they refer multiple MIOperands inside a single one.
2437 bool ARMAsmParser::
2438 cvtStWriteBackRegAddrModeImm12(MCInst &Inst, unsigned Opcode,
2439                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2440   // Create a writeback register dummy placeholder.
2441   Inst.addOperand(MCOperand::CreateImm(0));
2442   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2443   ((ARMOperand*)Operands[3])->addMemImm12OffsetOperands(Inst, 2);
2444   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2445   return true;
2446 }
2447
2448 /// cvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
2449 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2450 /// when they refer multiple MIOperands inside a single one.
2451 bool ARMAsmParser::
2452 cvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
2453                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2454   // Create a writeback register dummy placeholder.
2455   Inst.addOperand(MCOperand::CreateImm(0));
2456   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2457   ((ARMOperand*)Operands[3])->addAddrMode2Operands(Inst, 3);
2458   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2459   return true;
2460 }
2461
2462 /// cvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
2463 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2464 /// when they refer multiple MIOperands inside a single one.
2465 bool ARMAsmParser::
2466 cvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
2467                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2468   // Create a writeback register dummy placeholder.
2469   Inst.addOperand(MCOperand::CreateImm(0));
2470   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2471   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
2472   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2473   return true;
2474 }
2475
2476 /// cvtLdExtTWriteBackImm - Convert parsed operands to MCInst.
2477 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2478 /// when they refer multiple MIOperands inside a single one.
2479 bool ARMAsmParser::
2480 cvtLdExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2481                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2482   // Rt
2483   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2484   // Create a writeback register dummy placeholder.
2485   Inst.addOperand(MCOperand::CreateImm(0));
2486   // addr
2487   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2488   // offset
2489   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2490   // pred
2491   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2492   return true;
2493 }
2494
2495 /// cvtLdExtTWriteBackReg - Convert parsed operands to MCInst.
2496 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2497 /// when they refer multiple MIOperands inside a single one.
2498 bool ARMAsmParser::
2499 cvtLdExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2500                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2501   // Rt
2502   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2503   // Create a writeback register dummy placeholder.
2504   Inst.addOperand(MCOperand::CreateImm(0));
2505   // addr
2506   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2507   // offset
2508   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2509   // pred
2510   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2511   return true;
2512 }
2513
2514 /// cvtStExtTWriteBackImm - Convert parsed operands to MCInst.
2515 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2516 /// when they refer multiple MIOperands inside a single one.
2517 bool ARMAsmParser::
2518 cvtStExtTWriteBackImm(MCInst &Inst, unsigned Opcode,
2519                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2520   // Create a writeback register dummy placeholder.
2521   Inst.addOperand(MCOperand::CreateImm(0));
2522   // Rt
2523   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2524   // addr
2525   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2526   // offset
2527   ((ARMOperand*)Operands[4])->addPostIdxImm8Operands(Inst, 1);
2528   // pred
2529   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2530   return true;
2531 }
2532
2533 /// cvtStExtTWriteBackReg - Convert parsed operands to MCInst.
2534 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2535 /// when they refer multiple MIOperands inside a single one.
2536 bool ARMAsmParser::
2537 cvtStExtTWriteBackReg(MCInst &Inst, unsigned Opcode,
2538                       const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2539   // Create a writeback register dummy placeholder.
2540   Inst.addOperand(MCOperand::CreateImm(0));
2541   // Rt
2542   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2543   // addr
2544   ((ARMOperand*)Operands[3])->addMemNoOffsetOperands(Inst, 1);
2545   // offset
2546   ((ARMOperand*)Operands[4])->addPostIdxRegOperands(Inst, 2);
2547   // pred
2548   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2549   return true;
2550 }
2551
2552 /// cvtLdrdPre - Convert parsed operands to MCInst.
2553 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2554 /// when they refer multiple MIOperands inside a single one.
2555 bool ARMAsmParser::
2556 cvtLdrdPre(MCInst &Inst, unsigned Opcode,
2557            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2558   // Rt, Rt2
2559   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2560   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2561   // Create a writeback register dummy placeholder.
2562   Inst.addOperand(MCOperand::CreateImm(0));
2563   // addr
2564   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2565   // pred
2566   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2567   return true;
2568 }
2569
2570 /// cvtStrdPre - Convert parsed operands to MCInst.
2571 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2572 /// when they refer multiple MIOperands inside a single one.
2573 bool ARMAsmParser::
2574 cvtStrdPre(MCInst &Inst, unsigned Opcode,
2575            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2576   // Create a writeback register dummy placeholder.
2577   Inst.addOperand(MCOperand::CreateImm(0));
2578   // Rt, Rt2
2579   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2580   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2581   // addr
2582   ((ARMOperand*)Operands[4])->addAddrMode3Operands(Inst, 3);
2583   // pred
2584   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2585   return true;
2586 }
2587
2588 /// cvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
2589 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2590 /// when they refer multiple MIOperands inside a single one.
2591 bool ARMAsmParser::
2592 cvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
2593                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2594   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
2595   // Create a writeback register dummy placeholder.
2596   Inst.addOperand(MCOperand::CreateImm(0));
2597   ((ARMOperand*)Operands[3])->addAddrMode3Operands(Inst, 3);
2598   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
2599   return true;
2600 }
2601
2602 /// cvtThumbMultiple- Convert parsed operands to MCInst.
2603 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
2604 /// when they refer multiple MIOperands inside a single one.
2605 bool ARMAsmParser::
2606 cvtThumbMultiply(MCInst &Inst, unsigned Opcode,
2607            const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2608   // The second source operand must be the same register as the destination
2609   // operand.
2610   if (Operands.size() == 6 &&
2611       (((ARMOperand*)Operands[3])->getReg() !=
2612        ((ARMOperand*)Operands[5])->getReg()) &&
2613       (((ARMOperand*)Operands[3])->getReg() !=
2614        ((ARMOperand*)Operands[4])->getReg())) {
2615     Error(Operands[3]->getStartLoc(),
2616           "destination register must match source register");
2617     return false;
2618   }
2619   ((ARMOperand*)Operands[3])->addRegOperands(Inst, 1);
2620   ((ARMOperand*)Operands[1])->addCCOutOperands(Inst, 1);
2621   ((ARMOperand*)Operands[4])->addRegOperands(Inst, 1);
2622   // If we have a three-operand form, use that, else the second source operand
2623   // is just the destination operand again.
2624   if (Operands.size() == 6)
2625     ((ARMOperand*)Operands[5])->addRegOperands(Inst, 1);
2626   else
2627     Inst.addOperand(Inst.getOperand(0));
2628   ((ARMOperand*)Operands[2])->addCondCodeOperands(Inst, 2);
2629
2630   return true;
2631 }
2632
2633 /// Parse an ARM memory expression, return false if successful else return true
2634 /// or an error.  The first token must be a '[' when called.
2635 bool ARMAsmParser::
2636 parseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
2637   SMLoc S, E;
2638   assert(Parser.getTok().is(AsmToken::LBrac) &&
2639          "Token is not a Left Bracket");
2640   S = Parser.getTok().getLoc();
2641   Parser.Lex(); // Eat left bracket token.
2642
2643   const AsmToken &BaseRegTok = Parser.getTok();
2644   int BaseRegNum = tryParseRegister();
2645   if (BaseRegNum == -1)
2646     return Error(BaseRegTok.getLoc(), "register expected");
2647
2648   // The next token must either be a comma or a closing bracket.
2649   const AsmToken &Tok = Parser.getTok();
2650   if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
2651     return Error(Tok.getLoc(), "malformed memory operand");
2652
2653   if (Tok.is(AsmToken::RBrac)) {
2654     E = Tok.getLoc();
2655     Parser.Lex(); // Eat right bracket token.
2656
2657     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, 0, ARM_AM::no_shift,
2658                                              0, false, S, E));
2659
2660     return false;
2661   }
2662
2663   assert(Tok.is(AsmToken::Comma) && "Lost comma in memory operand?!");
2664   Parser.Lex(); // Eat the comma.
2665
2666   // If we have a '#' it's an immediate offset, else assume it's a register
2667   // offset.
2668   if (Parser.getTok().is(AsmToken::Hash)) {
2669     Parser.Lex(); // Eat the '#'.
2670     E = Parser.getTok().getLoc();
2671
2672     bool isNegative = getParser().getTok().is(AsmToken::Minus);
2673     const MCExpr *Offset;
2674     if (getParser().ParseExpression(Offset))
2675      return true;
2676
2677     // The expression has to be a constant. Memory references with relocations
2678     // don't come through here, as they use the <label> forms of the relevant
2679     // instructions.
2680     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Offset);
2681     if (!CE)
2682       return Error (E, "constant expression expected");
2683
2684     // If the constant was #-0, represent it as INT32_MIN.
2685     int32_t Val = CE->getValue();
2686     if (isNegative && Val == 0)
2687       CE = MCConstantExpr::Create(INT32_MIN, getContext());
2688
2689     // Now we should have the closing ']'
2690     E = Parser.getTok().getLoc();
2691     if (Parser.getTok().isNot(AsmToken::RBrac))
2692       return Error(E, "']' expected");
2693     Parser.Lex(); // Eat right bracket token.
2694
2695     // Don't worry about range checking the value here. That's handled by
2696     // the is*() predicates.
2697     Operands.push_back(ARMOperand::CreateMem(BaseRegNum, CE, 0,
2698                                              ARM_AM::no_shift, 0, false, S,E));
2699
2700     // If there's a pre-indexing writeback marker, '!', just add it as a token
2701     // operand.
2702     if (Parser.getTok().is(AsmToken::Exclaim)) {
2703       Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2704       Parser.Lex(); // Eat the '!'.
2705     }
2706
2707     return false;
2708   }
2709
2710   // The register offset is optionally preceded by a '+' or '-'
2711   bool isNegative = false;
2712   if (Parser.getTok().is(AsmToken::Minus)) {
2713     isNegative = true;
2714     Parser.Lex(); // Eat the '-'.
2715   } else if (Parser.getTok().is(AsmToken::Plus)) {
2716     // Nothing to do.
2717     Parser.Lex(); // Eat the '+'.
2718   }
2719
2720   E = Parser.getTok().getLoc();
2721   int OffsetRegNum = tryParseRegister();
2722   if (OffsetRegNum == -1)
2723     return Error(E, "register expected");
2724
2725   // If there's a shift operator, handle it.
2726   ARM_AM::ShiftOpc ShiftType = ARM_AM::no_shift;
2727   unsigned ShiftImm = 0;
2728   if (Parser.getTok().is(AsmToken::Comma)) {
2729     Parser.Lex(); // Eat the ','.
2730     if (parseMemRegOffsetShift(ShiftType, ShiftImm))
2731       return true;
2732   }
2733
2734   // Now we should have the closing ']'
2735   E = Parser.getTok().getLoc();
2736   if (Parser.getTok().isNot(AsmToken::RBrac))
2737     return Error(E, "']' expected");
2738   Parser.Lex(); // Eat right bracket token.
2739
2740   Operands.push_back(ARMOperand::CreateMem(BaseRegNum, 0, OffsetRegNum,
2741                                            ShiftType, ShiftImm, isNegative,
2742                                            S, E));
2743
2744   // If there's a pre-indexing writeback marker, '!', just add it as a token
2745   // operand.
2746   if (Parser.getTok().is(AsmToken::Exclaim)) {
2747     Operands.push_back(ARMOperand::CreateToken("!",Parser.getTok().getLoc()));
2748     Parser.Lex(); // Eat the '!'.
2749   }
2750
2751   return false;
2752 }
2753
2754 /// parseMemRegOffsetShift - one of these two:
2755 ///   ( lsl | lsr | asr | ror ) , # shift_amount
2756 ///   rrx
2757 /// return true if it parses a shift otherwise it returns false.
2758 bool ARMAsmParser::parseMemRegOffsetShift(ARM_AM::ShiftOpc &St,
2759                                           unsigned &Amount) {
2760   SMLoc Loc = Parser.getTok().getLoc();
2761   const AsmToken &Tok = Parser.getTok();
2762   if (Tok.isNot(AsmToken::Identifier))
2763     return true;
2764   StringRef ShiftName = Tok.getString();
2765   if (ShiftName == "lsl" || ShiftName == "LSL")
2766     St = ARM_AM::lsl;
2767   else if (ShiftName == "lsr" || ShiftName == "LSR")
2768     St = ARM_AM::lsr;
2769   else if (ShiftName == "asr" || ShiftName == "ASR")
2770     St = ARM_AM::asr;
2771   else if (ShiftName == "ror" || ShiftName == "ROR")
2772     St = ARM_AM::ror;
2773   else if (ShiftName == "rrx" || ShiftName == "RRX")
2774     St = ARM_AM::rrx;
2775   else
2776     return Error(Loc, "illegal shift operator");
2777   Parser.Lex(); // Eat shift type token.
2778
2779   // rrx stands alone.
2780   Amount = 0;
2781   if (St != ARM_AM::rrx) {
2782     Loc = Parser.getTok().getLoc();
2783     // A '#' and a shift amount.
2784     const AsmToken &HashTok = Parser.getTok();
2785     if (HashTok.isNot(AsmToken::Hash))
2786       return Error(HashTok.getLoc(), "'#' expected");
2787     Parser.Lex(); // Eat hash token.
2788
2789     const MCExpr *Expr;
2790     if (getParser().ParseExpression(Expr))
2791       return true;
2792     // Range check the immediate.
2793     // lsl, ror: 0 <= imm <= 31
2794     // lsr, asr: 0 <= imm <= 32
2795     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
2796     if (!CE)
2797       return Error(Loc, "shift amount must be an immediate");
2798     int64_t Imm = CE->getValue();
2799     if (Imm < 0 ||
2800         ((St == ARM_AM::lsl || St == ARM_AM::ror) && Imm > 31) ||
2801         ((St == ARM_AM::lsr || St == ARM_AM::asr) && Imm > 32))
2802       return Error(Loc, "immediate shift value out of range");
2803     Amount = Imm;
2804   }
2805
2806   return false;
2807 }
2808
2809 /// Parse a arm instruction operand.  For now this parses the operand regardless
2810 /// of the mnemonic.
2811 bool ARMAsmParser::parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2812                                 StringRef Mnemonic) {
2813   SMLoc S, E;
2814
2815   // Check if the current operand has a custom associated parser, if so, try to
2816   // custom parse the operand, or fallback to the general approach.
2817   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
2818   if (ResTy == MatchOperand_Success)
2819     return false;
2820   // If there wasn't a custom match, try the generic matcher below. Otherwise,
2821   // there was a match, but an error occurred, in which case, just return that
2822   // the operand parsing failed.
2823   if (ResTy == MatchOperand_ParseFail)
2824     return true;
2825
2826   switch (getLexer().getKind()) {
2827   default:
2828     Error(Parser.getTok().getLoc(), "unexpected token in operand");
2829     return true;
2830   case AsmToken::Identifier: {
2831     if (!tryParseRegisterWithWriteBack(Operands))
2832       return false;
2833     int Res = tryParseShiftRegister(Operands);
2834     if (Res == 0) // success
2835       return false;
2836     else if (Res == -1) // irrecoverable error
2837       return true;
2838
2839     // Fall though for the Identifier case that is not a register or a
2840     // special name.
2841   }
2842   case AsmToken::Integer: // things like 1f and 2b as a branch targets
2843   case AsmToken::Dot: {   // . as a branch target
2844     // This was not a register so parse other operands that start with an
2845     // identifier (like labels) as expressions and create them as immediates.
2846     const MCExpr *IdVal;
2847     S = Parser.getTok().getLoc();
2848     if (getParser().ParseExpression(IdVal))
2849       return true;
2850     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2851     Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
2852     return false;
2853   }
2854   case AsmToken::LBrac:
2855     return parseMemory(Operands);
2856   case AsmToken::LCurly:
2857     return parseRegisterList(Operands);
2858   case AsmToken::Hash: {
2859     // #42 -> immediate.
2860     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
2861     S = Parser.getTok().getLoc();
2862     Parser.Lex();
2863     bool isNegative = Parser.getTok().is(AsmToken::Minus);
2864     const MCExpr *ImmVal;
2865     if (getParser().ParseExpression(ImmVal))
2866       return true;
2867     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal);
2868     if (!CE) {
2869       Error(S, "constant expression expected");
2870       return MatchOperand_ParseFail;
2871     }
2872     int32_t Val = CE->getValue();
2873     if (isNegative && Val == 0)
2874       ImmVal = MCConstantExpr::Create(INT32_MIN, getContext());
2875     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2876     Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
2877     return false;
2878   }
2879   case AsmToken::Colon: {
2880     // ":lower16:" and ":upper16:" expression prefixes
2881     // FIXME: Check it's an expression prefix,
2882     // e.g. (FOO - :lower16:BAR) isn't legal.
2883     ARMMCExpr::VariantKind RefKind;
2884     if (parsePrefix(RefKind))
2885       return true;
2886
2887     const MCExpr *SubExprVal;
2888     if (getParser().ParseExpression(SubExprVal))
2889       return true;
2890
2891     const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
2892                                                    getContext());
2893     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2894     Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
2895     return false;
2896   }
2897   }
2898 }
2899
2900 // parsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
2901 //  :lower16: and :upper16:.
2902 bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
2903   RefKind = ARMMCExpr::VK_ARM_None;
2904
2905   // :lower16: and :upper16: modifiers
2906   assert(getLexer().is(AsmToken::Colon) && "expected a :");
2907   Parser.Lex(); // Eat ':'
2908
2909   if (getLexer().isNot(AsmToken::Identifier)) {
2910     Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
2911     return true;
2912   }
2913
2914   StringRef IDVal = Parser.getTok().getIdentifier();
2915   if (IDVal == "lower16") {
2916     RefKind = ARMMCExpr::VK_ARM_LO16;
2917   } else if (IDVal == "upper16") {
2918     RefKind = ARMMCExpr::VK_ARM_HI16;
2919   } else {
2920     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
2921     return true;
2922   }
2923   Parser.Lex();
2924
2925   if (getLexer().isNot(AsmToken::Colon)) {
2926     Error(Parser.getTok().getLoc(), "unexpected token after prefix");
2927     return true;
2928   }
2929   Parser.Lex(); // Eat the last ':'
2930   return false;
2931 }
2932
2933 const MCExpr *
2934 ARMAsmParser::applyPrefixToExpr(const MCExpr *E,
2935                                 MCSymbolRefExpr::VariantKind Variant) {
2936   // Recurse over the given expression, rebuilding it to apply the given variant
2937   // to the leftmost symbol.
2938   if (Variant == MCSymbolRefExpr::VK_None)
2939     return E;
2940
2941   switch (E->getKind()) {
2942   case MCExpr::Target:
2943     llvm_unreachable("Can't handle target expr yet");
2944   case MCExpr::Constant:
2945     llvm_unreachable("Can't handle lower16/upper16 of constant yet");
2946
2947   case MCExpr::SymbolRef: {
2948     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
2949
2950     if (SRE->getKind() != MCSymbolRefExpr::VK_None)
2951       return 0;
2952
2953     return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext());
2954   }
2955
2956   case MCExpr::Unary:
2957     llvm_unreachable("Can't handle unary expressions yet");
2958
2959   case MCExpr::Binary: {
2960     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
2961     const MCExpr *LHS = applyPrefixToExpr(BE->getLHS(), Variant);
2962     const MCExpr *RHS = BE->getRHS();
2963     if (!LHS)
2964       return 0;
2965
2966     return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext());
2967   }
2968   }
2969
2970   assert(0 && "Invalid expression kind!");
2971   return 0;
2972 }
2973
2974 /// \brief Given a mnemonic, split out possible predication code and carry
2975 /// setting letters to form a canonical mnemonic and flags.
2976 //
2977 // FIXME: Would be nice to autogen this.
2978 // FIXME: This is a bit of a maze of special cases.
2979 StringRef ARMAsmParser::splitMnemonic(StringRef Mnemonic,
2980                                       unsigned &PredicationCode,
2981                                       bool &CarrySetting,
2982                                       unsigned &ProcessorIMod,
2983                                       StringRef &ITMask) {
2984   PredicationCode = ARMCC::AL;
2985   CarrySetting = false;
2986   ProcessorIMod = 0;
2987
2988   // Ignore some mnemonics we know aren't predicated forms.
2989   //
2990   // FIXME: Would be nice to autogen this.
2991   if ((Mnemonic == "movs" && isThumb()) ||
2992       Mnemonic == "teq"   || Mnemonic == "vceq"   || Mnemonic == "svc"   ||
2993       Mnemonic == "mls"   || Mnemonic == "smmls"  || Mnemonic == "vcls"  ||
2994       Mnemonic == "vmls"  || Mnemonic == "vnmls"  || Mnemonic == "vacge" ||
2995       Mnemonic == "vcge"  || Mnemonic == "vclt"   || Mnemonic == "vacgt" ||
2996       Mnemonic == "vcgt"  || Mnemonic == "vcle"   || Mnemonic == "smlal" ||
2997       Mnemonic == "umaal" || Mnemonic == "umlal"  || Mnemonic == "vabal" ||
2998       Mnemonic == "vmlal" || Mnemonic == "vpadal" || Mnemonic == "vqdmlal")
2999     return Mnemonic;
3000
3001   // First, split out any predication code. Ignore mnemonics we know aren't
3002   // predicated but do have a carry-set and so weren't caught above.
3003   if (Mnemonic != "adcs" && Mnemonic != "bics" && Mnemonic != "movs" &&
3004       Mnemonic != "muls" && Mnemonic != "smlals" && Mnemonic != "smulls" &&
3005       Mnemonic != "umlals" && Mnemonic != "umulls" && Mnemonic != "lsls" &&
3006       Mnemonic != "sbcs" && Mnemonic != "rscs") {
3007     unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
3008       .Case("eq", ARMCC::EQ)
3009       .Case("ne", ARMCC::NE)
3010       .Case("hs", ARMCC::HS)
3011       .Case("cs", ARMCC::HS)
3012       .Case("lo", ARMCC::LO)
3013       .Case("cc", ARMCC::LO)
3014       .Case("mi", ARMCC::MI)
3015       .Case("pl", ARMCC::PL)
3016       .Case("vs", ARMCC::VS)
3017       .Case("vc", ARMCC::VC)
3018       .Case("hi", ARMCC::HI)
3019       .Case("ls", ARMCC::LS)
3020       .Case("ge", ARMCC::GE)
3021       .Case("lt", ARMCC::LT)
3022       .Case("gt", ARMCC::GT)
3023       .Case("le", ARMCC::LE)
3024       .Case("al", ARMCC::AL)
3025       .Default(~0U);
3026     if (CC != ~0U) {
3027       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
3028       PredicationCode = CC;
3029     }
3030   }
3031
3032   // Next, determine if we have a carry setting bit. We explicitly ignore all
3033   // the instructions we know end in 's'.
3034   if (Mnemonic.endswith("s") &&
3035       !(Mnemonic == "cps" || Mnemonic == "mls" ||
3036         Mnemonic == "mrs" || Mnemonic == "smmls" || Mnemonic == "vabs" ||
3037         Mnemonic == "vcls" || Mnemonic == "vmls" || Mnemonic == "vmrs" ||
3038         Mnemonic == "vnmls" || Mnemonic == "vqabs" || Mnemonic == "vrecps" ||
3039         Mnemonic == "vrsqrts" || Mnemonic == "srs" ||
3040         (Mnemonic == "movs" && isThumb()))) {
3041     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
3042     CarrySetting = true;
3043   }
3044
3045   // The "cps" instruction can have a interrupt mode operand which is glued into
3046   // the mnemonic. Check if this is the case, split it and parse the imod op
3047   if (Mnemonic.startswith("cps")) {
3048     // Split out any imod code.
3049     unsigned IMod =
3050       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
3051       .Case("ie", ARM_PROC::IE)
3052       .Case("id", ARM_PROC::ID)
3053       .Default(~0U);
3054     if (IMod != ~0U) {
3055       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
3056       ProcessorIMod = IMod;
3057     }
3058   }
3059
3060   // The "it" instruction has the condition mask on the end of the mnemonic.
3061   if (Mnemonic.startswith("it")) {
3062     ITMask = Mnemonic.slice(2, Mnemonic.size());
3063     Mnemonic = Mnemonic.slice(0, 2);
3064   }
3065
3066   return Mnemonic;
3067 }
3068
3069 /// \brief Given a canonical mnemonic, determine if the instruction ever allows
3070 /// inclusion of carry set or predication code operands.
3071 //
3072 // FIXME: It would be nice to autogen this.
3073 void ARMAsmParser::
3074 getMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
3075                       bool &CanAcceptPredicationCode) {
3076   if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
3077       Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
3078       Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" ||
3079       Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
3080       Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" ||
3081       Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
3082       Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" ||
3083       Mnemonic == "eor" || Mnemonic == "smlal" || Mnemonic == "neg" ||
3084       (Mnemonic == "mov" && !isThumb())) {
3085     CanAcceptCarrySet = true;
3086   } else {
3087     CanAcceptCarrySet = false;
3088   }
3089
3090   if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
3091       Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
3092       Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
3093       Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
3094       Mnemonic == "dsb" || Mnemonic == "isb" || Mnemonic == "setend" ||
3095       (Mnemonic == "clrex" && !isThumb()) ||
3096       (Mnemonic == "nop" && isThumbOne()) ||
3097       ((Mnemonic == "pld" || Mnemonic == "pli" || Mnemonic == "pldw") &&
3098        !isThumb()) ||
3099       ((Mnemonic.startswith("rfe") || Mnemonic.startswith("srs")) &&
3100        !isThumb()) ||
3101       Mnemonic.startswith("cps") || (Mnemonic == "movs" && isThumb())) {
3102     CanAcceptPredicationCode = false;
3103   } else {
3104     CanAcceptPredicationCode = true;
3105   }
3106
3107   if (isThumb())
3108     if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
3109         Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
3110       CanAcceptPredicationCode = false;
3111 }
3112
3113 bool ARMAsmParser::shouldOmitCCOutOperand(StringRef Mnemonic,
3114                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3115   // FIXME: This is all horribly hacky. We really need a better way to deal
3116   // with optional operands like this in the matcher table.
3117
3118   // The 'mov' mnemonic is special. One variant has a cc_out operand, while
3119   // another does not. Specifically, the MOVW instruction does not. So we
3120   // special case it here and remove the defaulted (non-setting) cc_out
3121   // operand if that's the instruction we're trying to match.
3122   //
3123   // We do this as post-processing of the explicit operands rather than just
3124   // conditionally adding the cc_out in the first place because we need
3125   // to check the type of the parsed immediate operand.
3126   if (Mnemonic == "mov" && Operands.size() > 4 &&
3127       !static_cast<ARMOperand*>(Operands[4])->isARMSOImm() &&
3128       static_cast<ARMOperand*>(Operands[4])->isImm0_65535Expr() &&
3129       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3130     return true;
3131
3132   // Register-register 'add' for thumb does not have a cc_out operand
3133   // when there are only two register operands.
3134   if (isThumb() && Mnemonic == "add" && Operands.size() == 5 &&
3135       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3136       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3137       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3138     return true;
3139   // Register-register 'add' for thumb does not have a cc_out operand
3140   // when it's an ADD Rdm, SP, {Rdm|#imm0_255} instruction. We do
3141   // have to check the immediate range here since Thumb2 has a variant
3142   // that can handle a different range and has a cc_out operand.
3143   if (isThumb() && Mnemonic == "add" && Operands.size() == 6 &&
3144       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3145       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3146       static_cast<ARMOperand*>(Operands[4])->getReg() == ARM::SP &&
3147       static_cast<ARMOperand*>(Operands[1])->getReg() == 0 &&
3148       (static_cast<ARMOperand*>(Operands[5])->isReg() ||
3149        static_cast<ARMOperand*>(Operands[5])->isImm0_1020s4()))
3150     return true;
3151   // For Thumb2, add immediate does not have a cc_out operand for the
3152   // imm0_4096 variant. That's the least-preferred variant when
3153   // selecting via the generic "add" mnemonic, so to know that we
3154   // should remove the cc_out operand, we have to explicitly check that
3155   // it's not one of the other variants. Ugh.
3156   if (isThumbTwo() && Mnemonic == "add" && Operands.size() == 6 &&
3157       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3158       static_cast<ARMOperand*>(Operands[4])->isReg() &&
3159       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3160     // Nest conditions rather than one big 'if' statement for readability.
3161     //
3162     // If either register is a high reg, it's either one of the SP
3163     // variants (handled above) or a 32-bit encoding, so we just
3164     // check against T3.
3165     if ((!isARMLowRegister(static_cast<ARMOperand*>(Operands[3])->getReg()) ||
3166          !isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg())) &&
3167         static_cast<ARMOperand*>(Operands[5])->isT2SOImm())
3168       return false;
3169     // If both registers are low, we're in an IT block, and the immediate is
3170     // in range, we should use encoding T1 instead, which has a cc_out.
3171     if (inITBlock() &&
3172         isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
3173         isARMLowRegister(static_cast<ARMOperand*>(Operands[4])->getReg()) &&
3174         static_cast<ARMOperand*>(Operands[5])->isImm0_7())
3175       return false;
3176
3177     // Otherwise, we use encoding T4, which does not have a cc_out
3178     // operand.
3179     return true;
3180   }
3181
3182
3183   // Register-register 'add/sub' for thumb does not have a cc_out operand
3184   // when it's an ADD/SUB SP, #imm. Be lenient on count since there's also
3185   // the "add/sub SP, SP, #imm" version. If the follow-up operands aren't
3186   // right, this will result in better diagnostics (which operand is off)
3187   // anyway.
3188   if (isThumb() && (Mnemonic == "add" || Mnemonic == "sub") &&
3189       (Operands.size() == 5 || Operands.size() == 6) &&
3190       static_cast<ARMOperand*>(Operands[3])->isReg() &&
3191       static_cast<ARMOperand*>(Operands[3])->getReg() == ARM::SP &&
3192       static_cast<ARMOperand*>(Operands[1])->getReg() == 0)
3193     return true;
3194
3195   return false;
3196 }
3197
3198 /// Parse an arm instruction mnemonic followed by its operands.
3199 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
3200                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3201   // Create the leading tokens for the mnemonic, split by '.' characters.
3202   size_t Start = 0, Next = Name.find('.');
3203   StringRef Mnemonic = Name.slice(Start, Next);
3204
3205   // Split out the predication code and carry setting flag from the mnemonic.
3206   unsigned PredicationCode;
3207   unsigned ProcessorIMod;
3208   bool CarrySetting;
3209   StringRef ITMask;
3210   Mnemonic = splitMnemonic(Mnemonic, PredicationCode, CarrySetting,
3211                            ProcessorIMod, ITMask);
3212
3213   // In Thumb1, only the branch (B) instruction can be predicated.
3214   if (isThumbOne() && PredicationCode != ARMCC::AL && Mnemonic != "b") {
3215     Parser.EatToEndOfStatement();
3216     return Error(NameLoc, "conditional execution not supported in Thumb1");
3217   }
3218
3219   Operands.push_back(ARMOperand::CreateToken(Mnemonic, NameLoc));
3220
3221   // Handle the IT instruction ITMask. Convert it to a bitmask. This
3222   // is the mask as it will be for the IT encoding if the conditional
3223   // encoding has a '1' as it's bit0 (i.e. 't' ==> '1'). In the case
3224   // where the conditional bit0 is zero, the instruction post-processing
3225   // will adjust the mask accordingly.
3226   if (Mnemonic == "it") {
3227     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + 2);
3228     if (ITMask.size() > 3) {
3229       Parser.EatToEndOfStatement();
3230       return Error(Loc, "too many conditions on IT instruction");
3231     }
3232     unsigned Mask = 8;
3233     for (unsigned i = ITMask.size(); i != 0; --i) {
3234       char pos = ITMask[i - 1];
3235       if (pos != 't' && pos != 'e') {
3236         Parser.EatToEndOfStatement();
3237         return Error(Loc, "illegal IT block condition mask '" + ITMask + "'");
3238       }
3239       Mask >>= 1;
3240       if (ITMask[i - 1] == 't')
3241         Mask |= 8;
3242     }
3243     Operands.push_back(ARMOperand::CreateITMask(Mask, Loc));
3244   }
3245
3246   // FIXME: This is all a pretty gross hack. We should automatically handle
3247   // optional operands like this via tblgen.
3248
3249   // Next, add the CCOut and ConditionCode operands, if needed.
3250   //
3251   // For mnemonics which can ever incorporate a carry setting bit or predication
3252   // code, our matching model involves us always generating CCOut and
3253   // ConditionCode operands to match the mnemonic "as written" and then we let
3254   // the matcher deal with finding the right instruction or generating an
3255   // appropriate error.
3256   bool CanAcceptCarrySet, CanAcceptPredicationCode;
3257   getMnemonicAcceptInfo(Mnemonic, CanAcceptCarrySet, CanAcceptPredicationCode);
3258
3259   // If we had a carry-set on an instruction that can't do that, issue an
3260   // error.
3261   if (!CanAcceptCarrySet && CarrySetting) {
3262     Parser.EatToEndOfStatement();
3263     return Error(NameLoc, "instruction '" + Mnemonic +
3264                  "' can not set flags, but 's' suffix specified");
3265   }
3266   // If we had a predication code on an instruction that can't do that, issue an
3267   // error.
3268   if (!CanAcceptPredicationCode && PredicationCode != ARMCC::AL) {
3269     Parser.EatToEndOfStatement();
3270     return Error(NameLoc, "instruction '" + Mnemonic +
3271                  "' is not predicable, but condition code specified");
3272   }
3273
3274   // Add the carry setting operand, if necessary.
3275   if (CanAcceptCarrySet) {
3276     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
3277     Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
3278                                                Loc));
3279   }
3280
3281   // Add the predication code operand, if necessary.
3282   if (CanAcceptPredicationCode) {
3283     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
3284                                       CarrySetting);
3285     Operands.push_back(ARMOperand::CreateCondCode(
3286                          ARMCC::CondCodes(PredicationCode), Loc));
3287   }
3288
3289   // Add the processor imod operand, if necessary.
3290   if (ProcessorIMod) {
3291     Operands.push_back(ARMOperand::CreateImm(
3292           MCConstantExpr::Create(ProcessorIMod, getContext()),
3293                                  NameLoc, NameLoc));
3294   }
3295
3296   // Add the remaining tokens in the mnemonic.
3297   while (Next != StringRef::npos) {
3298     Start = Next;
3299     Next = Name.find('.', Start + 1);
3300     StringRef ExtraToken = Name.slice(Start, Next);
3301
3302     // For now, we're only parsing Thumb1 (for the most part), so
3303     // just ignore ".n" qualifiers. We'll use them to restrict
3304     // matching when we do Thumb2.
3305     if (ExtraToken != ".n") {
3306       SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Start);
3307       Operands.push_back(ARMOperand::CreateToken(ExtraToken, Loc));
3308     }
3309   }
3310
3311   // Read the remaining operands.
3312   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3313     // Read the first operand.
3314     if (parseOperand(Operands, Mnemonic)) {
3315       Parser.EatToEndOfStatement();
3316       return true;
3317     }
3318
3319     while (getLexer().is(AsmToken::Comma)) {
3320       Parser.Lex();  // Eat the comma.
3321
3322       // Parse and remember the operand.
3323       if (parseOperand(Operands, Mnemonic)) {
3324         Parser.EatToEndOfStatement();
3325         return true;
3326       }
3327     }
3328   }
3329
3330   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3331     Parser.EatToEndOfStatement();
3332     return TokError("unexpected token in argument list");
3333   }
3334
3335   Parser.Lex(); // Consume the EndOfStatement
3336
3337   // Some instructions, mostly Thumb, have forms for the same mnemonic that
3338   // do and don't have a cc_out optional-def operand. With some spot-checks
3339   // of the operand list, we can figure out which variant we're trying to
3340   // parse and adjust accordingly before actually matching. We shouldn't ever
3341   // try to remove a cc_out operand that was explicitly set on the the
3342   // mnemonic, of course (CarrySetting == true). Reason number #317 the
3343   // table driven matcher doesn't fit well with the ARM instruction set.
3344   if (!CarrySetting && shouldOmitCCOutOperand(Mnemonic, Operands)) {
3345     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
3346     Operands.erase(Operands.begin() + 1);
3347     delete Op;
3348   }
3349
3350   // ARM mode 'blx' need special handling, as the register operand version
3351   // is predicable, but the label operand version is not. So, we can't rely
3352   // on the Mnemonic based checking to correctly figure out when to put
3353   // a CondCode operand in the list. If we're trying to match the label
3354   // version, remove the CondCode operand here.
3355   if (!isThumb() && Mnemonic == "blx" && Operands.size() == 3 &&
3356       static_cast<ARMOperand*>(Operands[2])->isImm()) {
3357     ARMOperand *Op = static_cast<ARMOperand*>(Operands[1]);
3358     Operands.erase(Operands.begin() + 1);
3359     delete Op;
3360   }
3361
3362   // The vector-compare-to-zero instructions have a literal token "#0" at
3363   // the end that comes to here as an immediate operand. Convert it to a
3364   // token to play nicely with the matcher.
3365   if ((Mnemonic == "vceq" || Mnemonic == "vcge" || Mnemonic == "vcgt" ||
3366       Mnemonic == "vcle" || Mnemonic == "vclt") && Operands.size() == 6 &&
3367       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3368     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
3369     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
3370     if (CE && CE->getValue() == 0) {
3371       Operands.erase(Operands.begin() + 5);
3372       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
3373       delete Op;
3374     }
3375   }
3376   // Similarly, the Thumb1 "RSB" instruction has a literal "#0" on the
3377   // end. Convert it to a token here.
3378   if (Mnemonic == "rsb" && isThumb() && Operands.size() == 6 &&
3379       static_cast<ARMOperand*>(Operands[5])->isImm()) {
3380     ARMOperand *Op = static_cast<ARMOperand*>(Operands[5]);
3381     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op->getImm());
3382     if (CE && CE->getValue() == 0) {
3383       Operands.erase(Operands.begin() + 5);
3384       Operands.push_back(ARMOperand::CreateToken("#0", Op->getStartLoc()));
3385       delete Op;
3386     }
3387   }
3388
3389   return false;
3390 }
3391
3392 // Validate context-sensitive operand constraints.
3393
3394 // return 'true' if register list contains non-low GPR registers,
3395 // 'false' otherwise. If Reg is in the register list or is HiReg, set
3396 // 'containsReg' to true.
3397 static bool checkLowRegisterList(MCInst Inst, unsigned OpNo, unsigned Reg,
3398                                  unsigned HiReg, bool &containsReg) {
3399   containsReg = false;
3400   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
3401     unsigned OpReg = Inst.getOperand(i).getReg();
3402     if (OpReg == Reg)
3403       containsReg = true;
3404     // Anything other than a low register isn't legal here.
3405     if (!isARMLowRegister(OpReg) && (!HiReg || OpReg != HiReg))
3406       return true;
3407   }
3408   return false;
3409 }
3410
3411 // Check if the specified regisgter is in the register list of the inst,
3412 // starting at the indicated operand number.
3413 static bool listContainsReg(MCInst &Inst, unsigned OpNo, unsigned Reg) {
3414   for (unsigned i = OpNo; i < Inst.getNumOperands(); ++i) {
3415     unsigned OpReg = Inst.getOperand(i).getReg();
3416     if (OpReg == Reg)
3417       return true;
3418   }
3419   return false;
3420 }
3421
3422 // FIXME: We would really prefer to have MCInstrInfo (the wrapper around
3423 // the ARMInsts array) instead. Getting that here requires awkward
3424 // API changes, though. Better way?
3425 namespace llvm {
3426 extern MCInstrDesc ARMInsts[];
3427 }
3428 static MCInstrDesc &getInstDesc(unsigned Opcode) {
3429   return ARMInsts[Opcode];
3430 }
3431
3432 // FIXME: We would really like to be able to tablegen'erate this.
3433 bool ARMAsmParser::
3434 validateInstruction(MCInst &Inst,
3435                     const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3436   MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
3437   SMLoc Loc = Operands[0]->getStartLoc();
3438   // Check the IT block state first.
3439   if (inITBlock()) {
3440     unsigned bit = 1;
3441     if (ITState.FirstCond)
3442       ITState.FirstCond = false;
3443     else
3444       bit = (ITState.Mask >> (5 - ITState.CurPosition)) & 1;
3445     // The instruction must be predicable.
3446     if (!MCID.isPredicable())
3447       return Error(Loc, "instructions in IT block must be predicable");
3448     unsigned Cond = Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm();
3449     unsigned ITCond = bit ? ITState.Cond :
3450       ARMCC::getOppositeCondition(ITState.Cond);
3451     if (Cond != ITCond) {
3452       // Find the condition code Operand to get its SMLoc information.
3453       SMLoc CondLoc;
3454       for (unsigned i = 1; i < Operands.size(); ++i)
3455         if (static_cast<ARMOperand*>(Operands[i])->isCondCode())
3456           CondLoc = Operands[i]->getStartLoc();
3457       return Error(CondLoc, "incorrect condition in IT block; got '" +
3458                    StringRef(ARMCondCodeToString(ARMCC::CondCodes(Cond))) +
3459                    "', but expected '" +
3460                    ARMCondCodeToString(ARMCC::CondCodes(ITCond)) + "'");
3461     }
3462   // Check for non-'al' condition codes outside of the IT block.
3463   } else if (isThumbTwo() && MCID.isPredicable() &&
3464              Inst.getOperand(MCID.findFirstPredOperandIdx()).getImm() !=
3465              ARMCC::AL && Inst.getOpcode() != ARM::tBcc &&
3466              Inst.getOpcode() != ARM::t2Bcc)
3467     return Error(Loc, "predicated instructions must be in IT block");
3468
3469   switch (Inst.getOpcode()) {
3470   case ARM::LDRD:
3471   case ARM::LDRD_PRE:
3472   case ARM::LDRD_POST:
3473   case ARM::LDREXD: {
3474     // Rt2 must be Rt + 1.
3475     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
3476     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3477     if (Rt2 != Rt + 1)
3478       return Error(Operands[3]->getStartLoc(),
3479                    "destination operands must be sequential");
3480     return false;
3481   }
3482   case ARM::STRD: {
3483     // Rt2 must be Rt + 1.
3484     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(0).getReg());
3485     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3486     if (Rt2 != Rt + 1)
3487       return Error(Operands[3]->getStartLoc(),
3488                    "source operands must be sequential");
3489     return false;
3490   }
3491   case ARM::STRD_PRE:
3492   case ARM::STRD_POST:
3493   case ARM::STREXD: {
3494     // Rt2 must be Rt + 1.
3495     unsigned Rt = getARMRegisterNumbering(Inst.getOperand(1).getReg());
3496     unsigned Rt2 = getARMRegisterNumbering(Inst.getOperand(2).getReg());
3497     if (Rt2 != Rt + 1)
3498       return Error(Operands[3]->getStartLoc(),
3499                    "source operands must be sequential");
3500     return false;
3501   }
3502   case ARM::SBFX:
3503   case ARM::UBFX: {
3504     // width must be in range [1, 32-lsb]
3505     unsigned lsb = Inst.getOperand(2).getImm();
3506     unsigned widthm1 = Inst.getOperand(3).getImm();
3507     if (widthm1 >= 32 - lsb)
3508       return Error(Operands[5]->getStartLoc(),
3509                    "bitfield width must be in range [1,32-lsb]");
3510     return false;
3511   }
3512   case ARM::tLDMIA: {
3513     // If we're parsing Thumb2, the .w variant is available and handles
3514     // most cases that are normally illegal for a Thumb1 LDM
3515     // instruction. We'll make the transformation in processInstruction()
3516     // if necessary.
3517     //
3518     // Thumb LDM instructions are writeback iff the base register is not
3519     // in the register list.
3520     unsigned Rn = Inst.getOperand(0).getReg();
3521     bool hasWritebackToken =
3522       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
3523        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
3524     bool listContainsBase;
3525     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) && !isThumbTwo())
3526       return Error(Operands[3 + hasWritebackToken]->getStartLoc(),
3527                    "registers must be in range r0-r7");
3528     // If we should have writeback, then there should be a '!' token.
3529     if (!listContainsBase && !hasWritebackToken && !isThumbTwo())
3530       return Error(Operands[2]->getStartLoc(),
3531                    "writeback operator '!' expected");
3532     // If we should not have writeback, there must not be a '!'. This is
3533     // true even for the 32-bit wide encodings.
3534     if (listContainsBase && hasWritebackToken)
3535       return Error(Operands[3]->getStartLoc(),
3536                    "writeback operator '!' not allowed when base register "
3537                    "in register list");
3538
3539     break;
3540   }
3541   case ARM::t2LDMIA_UPD: {
3542     if (listContainsReg(Inst, 3, Inst.getOperand(0).getReg()))
3543       return Error(Operands[4]->getStartLoc(),
3544                    "writeback operator '!' not allowed when base register "
3545                    "in register list");
3546     break;
3547   }
3548   case ARM::tPOP: {
3549     bool listContainsBase;
3550     if (checkLowRegisterList(Inst, 3, 0, ARM::PC, listContainsBase))
3551       return Error(Operands[2]->getStartLoc(),
3552                    "registers must be in range r0-r7 or pc");
3553     break;
3554   }
3555   case ARM::tPUSH: {
3556     bool listContainsBase;
3557     if (checkLowRegisterList(Inst, 3, 0, ARM::LR, listContainsBase))
3558       return Error(Operands[2]->getStartLoc(),
3559                    "registers must be in range r0-r7 or lr");
3560     break;
3561   }
3562   case ARM::tSTMIA_UPD: {
3563     bool listContainsBase;
3564     if (checkLowRegisterList(Inst, 4, 0, 0, listContainsBase))
3565       return Error(Operands[4]->getStartLoc(),
3566                    "registers must be in range r0-r7");
3567     break;
3568   }
3569   }
3570
3571   return false;
3572 }
3573
3574 void ARMAsmParser::
3575 processInstruction(MCInst &Inst,
3576                    const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
3577   switch (Inst.getOpcode()) {
3578   case ARM::LDMIA_UPD:
3579     // If this is a load of a single register via a 'pop', then we should use
3580     // a post-indexed LDR instruction instead, per the ARM ARM.
3581     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "pop" &&
3582         Inst.getNumOperands() == 5) {
3583       MCInst TmpInst;
3584       TmpInst.setOpcode(ARM::LDR_POST_IMM);
3585       TmpInst.addOperand(Inst.getOperand(4)); // Rt
3586       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
3587       TmpInst.addOperand(Inst.getOperand(1)); // Rn
3588       TmpInst.addOperand(MCOperand::CreateReg(0));  // am2offset
3589       TmpInst.addOperand(MCOperand::CreateImm(4));
3590       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
3591       TmpInst.addOperand(Inst.getOperand(3));
3592       Inst = TmpInst;
3593     }
3594     break;
3595   case ARM::STMDB_UPD:
3596     // If this is a store of a single register via a 'push', then we should use
3597     // a pre-indexed STR instruction instead, per the ARM ARM.
3598     if (static_cast<ARMOperand*>(Operands[0])->getToken() == "push" &&
3599         Inst.getNumOperands() == 5) {
3600       MCInst TmpInst;
3601       TmpInst.setOpcode(ARM::STR_PRE_IMM);
3602       TmpInst.addOperand(Inst.getOperand(0)); // Rn_wb
3603       TmpInst.addOperand(Inst.getOperand(4)); // Rt
3604       TmpInst.addOperand(Inst.getOperand(1)); // addrmode_imm12
3605       TmpInst.addOperand(MCOperand::CreateImm(-4));
3606       TmpInst.addOperand(Inst.getOperand(2)); // CondCode
3607       TmpInst.addOperand(Inst.getOperand(3));
3608       Inst = TmpInst;
3609     }
3610     break;
3611   case ARM::tADDi8:
3612     // If the immediate is in the range 0-7, we want tADDi3 iff Rd was
3613     // explicitly specified. From the ARM ARM: "Encoding T1 is preferred
3614     // to encoding T2 if <Rd> is specified and encoding T2 is preferred
3615     // to encoding T1 if <Rd> is omitted."
3616     if (Inst.getOperand(3).getImm() < 8 && Operands.size() == 6)
3617       Inst.setOpcode(ARM::tADDi3);
3618     break;
3619   case ARM::t2Bcc:
3620     // If the conditional is AL or we're in an IT block, we really want t2B.
3621     if (Inst.getOperand(1).getImm() == ARMCC::AL || inITBlock())
3622       Inst.setOpcode(ARM::t2B);
3623     break;
3624   case ARM::tBcc:
3625     // If the conditional is AL, we really want tB.
3626     if (Inst.getOperand(1).getImm() == ARMCC::AL)
3627       Inst.setOpcode(ARM::tB);
3628     break;
3629   case ARM::tLDMIA: {
3630     // If the register list contains any high registers, or if the writeback
3631     // doesn't match what tLDMIA can do, we need to use the 32-bit encoding
3632     // instead if we're in Thumb2. Otherwise, this should have generated
3633     // an error in validateInstruction().
3634     unsigned Rn = Inst.getOperand(0).getReg();
3635     bool hasWritebackToken =
3636       (static_cast<ARMOperand*>(Operands[3])->isToken() &&
3637        static_cast<ARMOperand*>(Operands[3])->getToken() == "!");
3638     bool listContainsBase;
3639     if (checkLowRegisterList(Inst, 3, Rn, 0, listContainsBase) ||
3640         (!listContainsBase && !hasWritebackToken) ||
3641         (listContainsBase && hasWritebackToken)) {
3642       // 16-bit encoding isn't sufficient. Switch to the 32-bit version.
3643       assert (isThumbTwo());
3644       Inst.setOpcode(hasWritebackToken ? ARM::t2LDMIA_UPD : ARM::t2LDMIA);
3645       // If we're switching to the updating version, we need to insert
3646       // the writeback tied operand.
3647       if (hasWritebackToken)
3648         Inst.insert(Inst.begin(),
3649                     MCOperand::CreateReg(Inst.getOperand(0).getReg()));
3650     }
3651     break;
3652   }
3653   case ARM::t2IT: {
3654     // The mask bits for all but the first condition are represented as
3655     // the low bit of the condition code value implies 't'. We currently
3656     // always have 1 implies 't', so XOR toggle the bits if the low bit
3657     // of the condition code is zero. The encoding also expects the low
3658     // bit of the condition to be encoded as bit 4 of the mask operand,
3659     // so mask that in if needed
3660     MCOperand &MO = Inst.getOperand(1);
3661     unsigned Mask = MO.getImm();
3662     unsigned OrigMask = Mask;
3663     unsigned TZ = CountTrailingZeros_32(Mask);
3664     if ((Inst.getOperand(0).getImm() & 1) == 0) {
3665       assert(Mask && TZ <= 3 && "illegal IT mask value!");
3666       for (unsigned i = 3; i != TZ; --i)
3667         Mask ^= 1 << i;
3668     } else
3669       Mask |= 0x10;
3670     MO.setImm(Mask);
3671
3672     // Set up the IT block state according to the IT instruction we just
3673     // matched.
3674     assert(!inITBlock() && "nested IT blocks?!");
3675     ITState.Cond = ARMCC::CondCodes(Inst.getOperand(0).getImm());
3676     ITState.Mask = OrigMask; // Use the original mask, not the updated one.
3677     ITState.CurPosition = 0;
3678     ITState.FirstCond = true;
3679     break;
3680   }
3681   }
3682 }
3683
3684 unsigned ARMAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
3685   // 16-bit thumb arithmetic instructions either require or preclude the 'S'
3686   // suffix depending on whether they're in an IT block or not.
3687   unsigned Opc = Inst.getOpcode();
3688   MCInstrDesc &MCID = getInstDesc(Opc);
3689   if (MCID.TSFlags & ARMII::ThumbArithFlagSetting) {
3690     assert(MCID.hasOptionalDef() &&
3691            "optionally flag setting instruction missing optional def operand");
3692     assert(MCID.NumOperands == Inst.getNumOperands() &&
3693            "operand count mismatch!");
3694     // Find the optional-def operand (cc_out).
3695     unsigned OpNo;
3696     for (OpNo = 0;
3697          !MCID.OpInfo[OpNo].isOptionalDef() && OpNo < MCID.NumOperands;
3698          ++OpNo)
3699       ;
3700     // If we're parsing Thumb1, reject it completely.
3701     if (isThumbOne() && Inst.getOperand(OpNo).getReg() != ARM::CPSR)
3702       return Match_MnemonicFail;
3703     // If we're parsing Thumb2, which form is legal depends on whether we're
3704     // in an IT block.
3705     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() != ARM::CPSR &&
3706         !inITBlock())
3707       return Match_RequiresITBlock;
3708     if (isThumbTwo() && Inst.getOperand(OpNo).getReg() == ARM::CPSR &&
3709         inITBlock())
3710       return Match_RequiresNotITBlock;
3711   }
3712   // Some high-register supporting Thumb1 encodings only allow both registers
3713   // to be from r0-r7 when in Thumb2.
3714   else if (Opc == ARM::tADDhirr && isThumbOne() &&
3715            isARMLowRegister(Inst.getOperand(1).getReg()) &&
3716            isARMLowRegister(Inst.getOperand(2).getReg()))
3717     return Match_RequiresThumb2;
3718   // Others only require ARMv6 or later.
3719   else if (Opc == ARM::tMOVr && isThumbOne() && !hasV6Ops() &&
3720            isARMLowRegister(Inst.getOperand(0).getReg()) &&
3721            isARMLowRegister(Inst.getOperand(1).getReg()))
3722     return Match_RequiresV6;
3723   return Match_Success;
3724 }
3725
3726 bool ARMAsmParser::
3727 MatchAndEmitInstruction(SMLoc IDLoc,
3728                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
3729                         MCStreamer &Out) {
3730   MCInst Inst;
3731   unsigned ErrorInfo;
3732   unsigned MatchResult;
3733   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
3734   switch (MatchResult) {
3735   default: break;
3736   case Match_Success:
3737     // Context sensitive operand constraints aren't handled by the matcher,
3738     // so check them here.
3739     if (validateInstruction(Inst, Operands)) {
3740       // Still progress the IT block, otherwise one wrong condition causes
3741       // nasty cascading errors.
3742       forwardITPosition();
3743       return true;
3744     }
3745
3746     // Some instructions need post-processing to, for example, tweak which
3747     // encoding is selected.
3748     processInstruction(Inst, Operands);
3749
3750     // Only move forward at the very end so that everything in validate
3751     // and process gets a consistent answer about whether we're in an IT
3752     // block.
3753     forwardITPosition();
3754
3755     Out.EmitInstruction(Inst);
3756     return false;
3757   case Match_MissingFeature:
3758     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
3759     return true;
3760   case Match_InvalidOperand: {
3761     SMLoc ErrorLoc = IDLoc;
3762     if (ErrorInfo != ~0U) {
3763       if (ErrorInfo >= Operands.size())
3764         return Error(IDLoc, "too few operands for instruction");
3765
3766       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
3767       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
3768     }
3769
3770     return Error(ErrorLoc, "invalid operand for instruction");
3771   }
3772   case Match_MnemonicFail:
3773     return Error(IDLoc, "invalid instruction");
3774   case Match_ConversionFail:
3775     // The converter function will have already emited a diagnostic.
3776     return true;
3777   case Match_RequiresNotITBlock:
3778     return Error(IDLoc, "flag setting instruction only valid outside IT block");
3779   case Match_RequiresITBlock:
3780     return Error(IDLoc, "instruction only valid inside IT block");
3781   case Match_RequiresV6:
3782     return Error(IDLoc, "instruction variant requires ARMv6 or later");
3783   case Match_RequiresThumb2:
3784     return Error(IDLoc, "instruction variant requires Thumb2");
3785   }
3786
3787   llvm_unreachable("Implement any new match types added!");
3788   return true;
3789 }
3790
3791 /// parseDirective parses the arm specific directives
3792 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
3793   StringRef IDVal = DirectiveID.getIdentifier();
3794   if (IDVal == ".word")
3795     return parseDirectiveWord(4, DirectiveID.getLoc());
3796   else if (IDVal == ".thumb")
3797     return parseDirectiveThumb(DirectiveID.getLoc());
3798   else if (IDVal == ".thumb_func")
3799     return parseDirectiveThumbFunc(DirectiveID.getLoc());
3800   else if (IDVal == ".code")
3801     return parseDirectiveCode(DirectiveID.getLoc());
3802   else if (IDVal == ".syntax")
3803     return parseDirectiveSyntax(DirectiveID.getLoc());
3804   return true;
3805 }
3806
3807 /// parseDirectiveWord
3808 ///  ::= .word [ expression (, expression)* ]
3809 bool ARMAsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
3810   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3811     for (;;) {
3812       const MCExpr *Value;
3813       if (getParser().ParseExpression(Value))
3814         return true;
3815
3816       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
3817
3818       if (getLexer().is(AsmToken::EndOfStatement))
3819         break;
3820
3821       // FIXME: Improve diagnostic.
3822       if (getLexer().isNot(AsmToken::Comma))
3823         return Error(L, "unexpected token in directive");
3824       Parser.Lex();
3825     }
3826   }
3827
3828   Parser.Lex();
3829   return false;
3830 }
3831
3832 /// parseDirectiveThumb
3833 ///  ::= .thumb
3834 bool ARMAsmParser::parseDirectiveThumb(SMLoc L) {
3835   if (getLexer().isNot(AsmToken::EndOfStatement))
3836     return Error(L, "unexpected token in directive");
3837   Parser.Lex();
3838
3839   // TODO: set thumb mode
3840   // TODO: tell the MC streamer the mode
3841   // getParser().getStreamer().Emit???();
3842   return false;
3843 }
3844
3845 /// parseDirectiveThumbFunc
3846 ///  ::= .thumbfunc symbol_name
3847 bool ARMAsmParser::parseDirectiveThumbFunc(SMLoc L) {
3848   const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
3849   bool isMachO = MAI.hasSubsectionsViaSymbols();
3850   StringRef Name;
3851
3852   // Darwin asm has function name after .thumb_func direction
3853   // ELF doesn't
3854   if (isMachO) {
3855     const AsmToken &Tok = Parser.getTok();
3856     if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
3857       return Error(L, "unexpected token in .thumb_func directive");
3858     Name = Tok.getString();
3859     Parser.Lex(); // Consume the identifier token.
3860   }
3861
3862   if (getLexer().isNot(AsmToken::EndOfStatement))
3863     return Error(L, "unexpected token in directive");
3864   Parser.Lex();
3865
3866   // FIXME: assuming function name will be the line following .thumb_func
3867   if (!isMachO) {
3868     Name = Parser.getTok().getString();
3869   }
3870
3871   // Mark symbol as a thumb symbol.
3872   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
3873   getParser().getStreamer().EmitThumbFunc(Func);
3874   return false;
3875 }
3876
3877 /// parseDirectiveSyntax
3878 ///  ::= .syntax unified | divided
3879 bool ARMAsmParser::parseDirectiveSyntax(SMLoc L) {
3880   const AsmToken &Tok = Parser.getTok();
3881   if (Tok.isNot(AsmToken::Identifier))
3882     return Error(L, "unexpected token in .syntax directive");
3883   StringRef Mode = Tok.getString();
3884   if (Mode == "unified" || Mode == "UNIFIED")
3885     Parser.Lex();
3886   else if (Mode == "divided" || Mode == "DIVIDED")
3887     return Error(L, "'.syntax divided' arm asssembly not supported");
3888   else
3889     return Error(L, "unrecognized syntax mode in .syntax directive");
3890
3891   if (getLexer().isNot(AsmToken::EndOfStatement))
3892     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
3893   Parser.Lex();
3894
3895   // TODO tell the MC streamer the mode
3896   // getParser().getStreamer().Emit???();
3897   return false;
3898 }
3899
3900 /// parseDirectiveCode
3901 ///  ::= .code 16 | 32
3902 bool ARMAsmParser::parseDirectiveCode(SMLoc L) {
3903   const AsmToken &Tok = Parser.getTok();
3904   if (Tok.isNot(AsmToken::Integer))
3905     return Error(L, "unexpected token in .code directive");
3906   int64_t Val = Parser.getTok().getIntVal();
3907   if (Val == 16)
3908     Parser.Lex();
3909   else if (Val == 32)
3910     Parser.Lex();
3911   else
3912     return Error(L, "invalid operand to .code directive");
3913
3914   if (getLexer().isNot(AsmToken::EndOfStatement))
3915     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
3916   Parser.Lex();
3917
3918   if (Val == 16) {
3919     if (!isThumb())
3920       SwitchMode();
3921     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
3922   } else {
3923     if (isThumb())
3924       SwitchMode();
3925     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
3926   }
3927
3928   return false;
3929 }
3930
3931 extern "C" void LLVMInitializeARMAsmLexer();
3932
3933 /// Force static initialization.
3934 extern "C" void LLVMInitializeARMAsmParser() {
3935   RegisterMCAsmParser<ARMAsmParser> X(TheARMTarget);
3936   RegisterMCAsmParser<ARMAsmParser> Y(TheThumbTarget);
3937   LLVMInitializeARMAsmLexer();
3938 }
3939
3940 #define GET_REGISTER_MATCHER
3941 #define GET_MATCHER_IMPLEMENTATION
3942 #include "ARMGenAsmMatcher.inc"