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