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 "ARM.h"
  11 #include "ARMAddressingModes.h"
  12 #include "ARMMCExpr.h"
  13 #include "ARMBaseRegisterInfo.h"
  14 #include "ARMSubtarget.h"
  15 #include "llvm/MC/MCParser/MCAsmLexer.h"
  16 #include "llvm/MC/MCParser/MCAsmParser.h"
  17 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  18 #include "llvm/MC/MCAsmInfo.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCStreamer.h"
  21 #include "llvm/MC/MCExpr.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/Target/TargetRegistry.h"
  25 #include "llvm/Target/TargetAsmParser.h"
  26 #include "llvm/Support/SourceMgr.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include "llvm/ADT/OwningPtr.h"
  29 #include "llvm/ADT/SmallVector.h"
  30 #include "llvm/ADT/StringExtras.h"
  31 #include "llvm/ADT/StringSwitch.h"
  32 #include "llvm/ADT/Twine.h"
  33
  34 #define GET_SUBTARGETINFO_ENUM
  35 #include "ARMGenSubtargetInfo.inc"
  36
  37 using namespace llvm;
  38
  39 namespace {
  40
  41 class ARMOperand;
  42
  43 class ARMAsmParser : public TargetAsmParser {
  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   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
  55   bool TryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &);
  56   bool TryParseShiftRegister(SmallVectorImpl<MCParsedAsmOperand*> &);
  57   bool ParseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &);
  58   bool ParseMemory(SmallVectorImpl<MCParsedAsmOperand*> &,
  59                    ARMII::AddrMode AddrMode);
  60   bool ParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &, StringRef Mnemonic);
  61   bool ParsePrefix(ARMMCExpr::VariantKind &RefKind);
  62   const MCExpr *ApplyPrefixToExpr(const MCExpr *E,
  63                                   MCSymbolRefExpr::VariantKind Variant);
  64
  65
  66   bool ParseMemoryOffsetReg(bool &Negative,
  67                             bool &OffsetRegShifted,
  68                             enum ARM_AM::ShiftOpc &ShiftType,
  69                             const MCExpr *&ShiftAmount,
  70                             const MCExpr *&Offset,
  71                             bool &OffsetIsReg,
  72                             int &OffsetRegNum,
  73                             SMLoc &E);
  74   bool ParseShift(enum ARM_AM::ShiftOpc &St,
  75                   const MCExpr *&ShiftAmount, SMLoc &E);
  76   bool ParseDirectiveWord(unsigned Size, SMLoc L);
  77   bool ParseDirectiveThumb(SMLoc L);
  78   bool ParseDirectiveThumbFunc(SMLoc L);
  79   bool ParseDirectiveCode(SMLoc L);
  80   bool ParseDirectiveSyntax(SMLoc L);
  81
  82   bool MatchAndEmitInstruction(SMLoc IDLoc,
  83                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
  84                                MCStreamer &Out);
  85   void GetMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
  86                              bool &CanAcceptPredicationCode);
  87
  88   bool isThumb() const {
  89     // FIXME: Can tablegen auto-generate this?
  90     return (STI.getFeatureBits() & ARM::ModeThumb) != 0;
  91   }
  92   bool isThumbOne() const {
  93     return isThumb() && (STI.getFeatureBits() & ARM::FeatureThumb2) == 0;
  94   }
  95   void SwitchMode() {
  96     unsigned FB = ComputeAvailableFeatures(STI.ToggleFeature(ARM::ModeThumb));
  97     setAvailableFeatures(FB);
  98   }
  99
 100   /// @name Auto-generated Match Functions
 101   /// {
 102
 103 #define GET_ASSEMBLER_HEADER
 104 #include "ARMGenAsmMatcher.inc"
 105
 106   /// }
 107
 108   OperandMatchResultTy tryParseCoprocNumOperand(
 109     SmallVectorImpl<MCParsedAsmOperand*>&);
 110   OperandMatchResultTy tryParseCoprocRegOperand(
 111     SmallVectorImpl<MCParsedAsmOperand*>&);
 112   OperandMatchResultTy tryParseMemBarrierOptOperand(
 113     SmallVectorImpl<MCParsedAsmOperand*>&);
 114   OperandMatchResultTy tryParseProcIFlagsOperand(
 115     SmallVectorImpl<MCParsedAsmOperand*>&);
 116   OperandMatchResultTy tryParseMSRMaskOperand(
 117     SmallVectorImpl<MCParsedAsmOperand*>&);
 118   OperandMatchResultTy tryParseMemMode2Operand(
 119     SmallVectorImpl<MCParsedAsmOperand*>&);
 120   OperandMatchResultTy tryParseMemMode3Operand(
 121     SmallVectorImpl<MCParsedAsmOperand*>&);
 122
 123   // Asm Match Converter Methods
 124   bool CvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 125                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 126   bool CvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
 127                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 128   bool CvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 129                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 130   bool CvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
 131                                   const SmallVectorImpl<MCParsedAsmOperand*> &);
 132
 133 public:
 134   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser)
 135     : TargetAsmParser(), STI(_STI), Parser(_Parser) {
 136     MCAsmParserExtension::Initialize(_Parser);
 137
 138     // Initialize the set of available features.
 139     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 140   }
 141
 142   virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 143                                 SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 144   virtual bool ParseDirective(AsmToken DirectiveID);
 145 };
 146 } // end anonymous namespace
 147
 148 namespace {
 149
 150 /// ARMOperand - Instances of this class represent a parsed ARM machine
 151 /// instruction.
 152 class ARMOperand : public MCParsedAsmOperand {
 153   enum KindTy {
 154     CondCode,
 155     CCOut,
 156     CoprocNum,
 157     CoprocReg,
 158     Immediate,
 159     MemBarrierOpt,
 160     Memory,
 161     MSRMask,
 162     ProcIFlags,
 163     Register,
 164     RegisterList,
 165     DPRRegisterList,
 166     SPRRegisterList,
 167     ShiftedRegister,
 168     Shifter,
 169     Token
 170   } Kind;
 171
 172   SMLoc StartLoc, EndLoc;
 173   SmallVector<unsigned, 8> Registers;
 174
 175   union {
 176     struct {
 177       ARMCC::CondCodes Val;
 178     } CC;
 179
 180     struct {
 181       ARM_MB::MemBOpt Val;
 182     } MBOpt;
 183
 184     struct {
 185       unsigned Val;
 186     } Cop;
 187
 188     struct {
 189       ARM_PROC::IFlags Val;
 190     } IFlags;
 191
 192     struct {
 193       unsigned Val;
 194     } MMask;
 195
 196     struct {
 197       const char *Data;
 198       unsigned Length;
 199     } Tok;
 200
 201     struct {
 202       unsigned RegNum;
 203     } Reg;
 204
 205     struct {
 206       const MCExpr *Val;
 207     } Imm;
 208
 209     /// Combined record for all forms of ARM address expressions.
 210     struct {
 211       ARMII::AddrMode AddrMode;
 212       unsigned BaseRegNum;
 213       union {
 214         unsigned RegNum;     ///< Offset register num, when OffsetIsReg.
 215         const MCExpr *Value; ///< Offset value, when !OffsetIsReg.
 216       } Offset;
 217       const MCExpr *ShiftAmount;     // used when OffsetRegShifted is true
 218       enum ARM_AM::ShiftOpc ShiftType; // used when OffsetRegShifted is true
 219       unsigned OffsetRegShifted : 1; // only used when OffsetIsReg is true
 220       unsigned Preindexed       : 1;
 221       unsigned Postindexed      : 1;
 222       unsigned OffsetIsReg      : 1;
 223       unsigned Negative         : 1; // only used when OffsetIsReg is true
 224       unsigned Writeback        : 1;
 225     } Mem;
 226
 227     struct {
 228       ARM_AM::ShiftOpc ShiftTy;
 229       unsigned Imm;
 230     } Shift;
 231     struct {
 232       ARM_AM::ShiftOpc ShiftTy;
 233       unsigned SrcReg;
 234       unsigned ShiftReg;
 235       unsigned ShiftImm;
 236     } ShiftedReg;
 237   };
 238
 239   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 240 public:
 241   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 242     Kind = o.Kind;
 243     StartLoc = o.StartLoc;
 244     EndLoc = o.EndLoc;
 245     switch (Kind) {
 246     case CondCode:
 247       CC = o.CC;
 248       break;
 249     case Token:
 250       Tok = o.Tok;
 251       break;
 252     case CCOut:
 253     case Register:
 254       Reg = o.Reg;
 255       break;
 256     case RegisterList:
 257     case DPRRegisterList:
 258     case SPRRegisterList:
 259       Registers = o.Registers;
 260       break;
 261     case CoprocNum:
 262     case CoprocReg:
 263       Cop = o.Cop;
 264       break;
 265     case Immediate:
 266       Imm = o.Imm;
 267       break;
 268     case MemBarrierOpt:
 269       MBOpt = o.MBOpt;
 270       break;
 271     case Memory:
 272       Mem = o.Mem;
 273       break;
 274     case MSRMask:
 275       MMask = o.MMask;
 276       break;
 277     case ProcIFlags:
 278       IFlags = o.IFlags;
 279       break;
 280     case Shifter:
 281       Shift = o.Shift;
 282       break;
 283     case ShiftedRegister:
 284       ShiftedReg = o.ShiftedReg;
 285       break;
 286     }
 287   }
 288
 289   /// getStartLoc - Get the location of the first token of this operand.
 290   SMLoc getStartLoc() const { return StartLoc; }
 291   /// getEndLoc - Get the location of the last token of this operand.
 292   SMLoc getEndLoc() const { return EndLoc; }
 293
 294   ARMCC::CondCodes getCondCode() const {
 295     assert(Kind == CondCode && "Invalid access!");
 296     return CC.Val;
 297   }
 298
 299   unsigned getCoproc() const {
 300     assert((Kind == CoprocNum || Kind == CoprocReg) && "Invalid access!");
 301     return Cop.Val;
 302   }
 303
 304   StringRef getToken() const {
 305     assert(Kind == Token && "Invalid access!");
 306     return StringRef(Tok.Data, Tok.Length);
 307   }
 308
 309   unsigned getReg() const {
 310     assert((Kind == Register || Kind == CCOut) && "Invalid access!");
 311     return Reg.RegNum;
 312   }
 313
 314   const SmallVectorImpl<unsigned> &getRegList() const {
 315     assert((Kind == RegisterList || Kind == DPRRegisterList ||
 316             Kind == SPRRegisterList) && "Invalid access!");
 317     return Registers;
 318   }
 319
 320   const MCExpr *getImm() const {
 321     assert(Kind == Immediate && "Invalid access!");
 322     return Imm.Val;
 323   }
 324
 325   ARM_MB::MemBOpt getMemBarrierOpt() const {
 326     assert(Kind == MemBarrierOpt && "Invalid access!");
 327     return MBOpt.Val;
 328   }
 329
 330   ARM_PROC::IFlags getProcIFlags() const {
 331     assert(Kind == ProcIFlags && "Invalid access!");
 332     return IFlags.Val;
 333   }
 334
 335   unsigned getMSRMask() const {
 336     assert(Kind == MSRMask && "Invalid access!");
 337     return MMask.Val;
 338   }
 339
 340   /// @name Memory Operand Accessors
 341   /// @{
 342   ARMII::AddrMode getMemAddrMode() const {
 343     return Mem.AddrMode;
 344   }
 345   unsigned getMemBaseRegNum() const {
 346     return Mem.BaseRegNum;
 347   }
 348   unsigned getMemOffsetRegNum() const {
 349     assert(Mem.OffsetIsReg && "Invalid access!");
 350     return Mem.Offset.RegNum;
 351   }
 352   const MCExpr *getMemOffset() const {
 353     assert(!Mem.OffsetIsReg && "Invalid access!");
 354     return Mem.Offset.Value;
 355   }
 356   unsigned getMemOffsetRegShifted() const {
 357     assert(Mem.OffsetIsReg && "Invalid access!");
 358     return Mem.OffsetRegShifted;
 359   }
 360   const MCExpr *getMemShiftAmount() const {
 361     assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!");
 362     return Mem.ShiftAmount;
 363   }
 364   enum ARM_AM::ShiftOpc getMemShiftType() const {
 365     assert(Mem.OffsetIsReg && Mem.OffsetRegShifted && "Invalid access!");
 366     return Mem.ShiftType;
 367   }
 368   bool getMemPreindexed() const { return Mem.Preindexed; }
 369   bool getMemPostindexed() const { return Mem.Postindexed; }
 370   bool getMemOffsetIsReg() const { return Mem.OffsetIsReg; }
 371   bool getMemNegative() const { return Mem.Negative; }
 372   bool getMemWriteback() const { return Mem.Writeback; }
 373
 374   /// @}
 375
 376   bool isCoprocNum() const { return Kind == CoprocNum; }
 377   bool isCoprocReg() const { return Kind == CoprocReg; }
 378   bool isCondCode() const { return Kind == CondCode; }
 379   bool isCCOut() const { return Kind == CCOut; }
 380   bool isImm() const { return Kind == Immediate; }
 381   bool isImm0_255() const {
 382     if (Kind != Immediate)
 383       return false;
 384     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 385     if (!CE) return false;
 386     int64_t Value = CE->getValue();
 387     return Value >= 0 && Value < 256;
 388   }
 389   bool isT2SOImm() const {
 390     if (Kind != Immediate)
 391       return false;
 392     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 393     if (!CE) return false;
 394     int64_t Value = CE->getValue();
 395     return ARM_AM::getT2SOImmVal(Value) != -1;
 396   }
 397   bool isReg() const { return Kind == Register; }
 398   bool isRegList() const { return Kind == RegisterList; }
 399   bool isDPRRegList() const { return Kind == DPRRegisterList; }
 400   bool isSPRRegList() const { return Kind == SPRRegisterList; }
 401   bool isToken() const { return Kind == Token; }
 402   bool isMemBarrierOpt() const { return Kind == MemBarrierOpt; }
 403   bool isMemory() const { return Kind == Memory; }
 404   bool isShifter() const { return Kind == Shifter; }
 405   bool isShiftedReg() const { return Kind == ShiftedRegister; }
 406   bool isMemMode2() const {
 407     if (getMemAddrMode() != ARMII::AddrMode2)
 408       return false;
 409
 410     if (getMemOffsetIsReg())
 411       return true;
 412
 413     if (getMemNegative() &&
 414         !(getMemPostindexed() || getMemPreindexed()))
 415       return false;
 416
 417     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 418     if (!CE) return false;
 419     int64_t Value = CE->getValue();
 420
 421     // The offset must be in the range 0-4095 (imm12).
 422     if (Value > 4095 || Value < -4095)
 423       return false;
 424
 425     return true;
 426   }
 427   bool isMemMode3() const {
 428     if (getMemAddrMode() != ARMII::AddrMode3)
 429       return false;
 430
 431     if (getMemOffsetIsReg()) {
 432       if (getMemOffsetRegShifted())
 433         return false; // No shift with offset reg allowed
 434       return true;
 435     }
 436
 437     if (getMemNegative() &&
 438         !(getMemPostindexed() || getMemPreindexed()))
 439       return false;
 440
 441     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 442     if (!CE) return false;
 443     int64_t Value = CE->getValue();
 444
 445     // The offset must be in the range 0-255 (imm8).
 446     if (Value > 255 || Value < -255)
 447       return false;
 448
 449     return true;
 450   }
 451   bool isMemMode5() const {
 452     if (!isMemory() || getMemOffsetIsReg() || getMemWriteback() ||
 453         getMemNegative())
 454       return false;
 455
 456     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 457     if (!CE) return false;
 458
 459     // The offset must be a multiple of 4 in the range 0-1020.
 460     int64_t Value = CE->getValue();
 461     return ((Value & 0x3) == 0 && Value <= 1020 && Value >= -1020);
 462   }
 463   bool isMemMode7() const {
 464     if (!isMemory() ||
 465         getMemPreindexed() ||
 466         getMemPostindexed() ||
 467         getMemOffsetIsReg() ||
 468         getMemNegative() ||
 469         getMemWriteback())
 470       return false;
 471
 472     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 473     if (!CE) return false;
 474
 475     if (CE->getValue())
 476       return false;
 477
 478     return true;
 479   }
 480   bool isMemModeRegThumb() const {
 481     if (!isMemory() || !getMemOffsetIsReg() || getMemWriteback())
 482       return false;
 483     return true;
 484   }
 485   bool isMemModeImmThumb() const {
 486     if (!isMemory() || getMemOffsetIsReg() || getMemWriteback())
 487       return false;
 488
 489     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 490     if (!CE) return false;
 491
 492     // The offset must be a multiple of 4 in the range 0-124.
 493     uint64_t Value = CE->getValue();
 494     return ((Value & 0x3) == 0 && Value <= 124);
 495   }
 496   bool isMSRMask() const { return Kind == MSRMask; }
 497   bool isProcIFlags() const { return Kind == ProcIFlags; }
 498
 499   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 500     // Add as immediates when possible.  Null MCExpr = 0.
 501     if (Expr == 0)
 502       Inst.addOperand(MCOperand::CreateImm(0));
 503     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 504       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 505     else
 506       Inst.addOperand(MCOperand::CreateExpr(Expr));
 507   }
 508
 509   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 510     assert(N == 2 && "Invalid number of operands!");
 511     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 512     unsigned RegNum = getCondCode() == ARMCC::AL ? 0: ARM::CPSR;
 513     Inst.addOperand(MCOperand::CreateReg(RegNum));
 514   }
 515
 516   void addCoprocNumOperands(MCInst &Inst, unsigned N) const {
 517     assert(N == 1 && "Invalid number of operands!");
 518     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 519   }
 520
 521   void addCoprocRegOperands(MCInst &Inst, unsigned N) const {
 522     assert(N == 1 && "Invalid number of operands!");
 523     Inst.addOperand(MCOperand::CreateImm(getCoproc()));
 524   }
 525
 526   void addCCOutOperands(MCInst &Inst, unsigned N) const {
 527     assert(N == 1 && "Invalid number of operands!");
 528     Inst.addOperand(MCOperand::CreateReg(getReg()));
 529   }
 530
 531   void addRegOperands(MCInst &Inst, unsigned N) const {
 532     assert(N == 1 && "Invalid number of operands!");
 533     Inst.addOperand(MCOperand::CreateReg(getReg()));
 534   }
 535
 536   void addShiftedRegOperands(MCInst &Inst, unsigned N) const {
 537     assert(N == 3 && "Invalid number of operands!");
 538     assert(isShiftedReg() && "addShiftedRegOperands() on non ShiftedReg!");
 539     assert((ShiftedReg.ShiftReg == 0 ||
 540             ARM_AM::getSORegOffset(ShiftedReg.ShiftImm) == 0) &&
 541            "Invalid shifted register operand!");
 542     Inst.addOperand(MCOperand::CreateReg(ShiftedReg.SrcReg));
 543     Inst.addOperand(MCOperand::CreateReg(ShiftedReg.ShiftReg));
 544     Inst.addOperand(MCOperand::CreateImm(
 545       ARM_AM::getSORegOpc(ShiftedReg.ShiftTy, ShiftedReg.ShiftImm)));
 546   }
 547
 548   void addShifterOperands(MCInst &Inst, unsigned N) const {
 549     assert(N == 1 && "Invalid number of operands!");
 550     Inst.addOperand(MCOperand::CreateImm(
 551       ARM_AM::getSORegOpc(Shift.ShiftTy, 0)));
 552   }
 553
 554   void addRegListOperands(MCInst &Inst, unsigned N) const {
 555     assert(N == 1 && "Invalid number of operands!");
 556     const SmallVectorImpl<unsigned> &RegList = getRegList();
 557     for (SmallVectorImpl<unsigned>::const_iterator
 558            I = RegList.begin(), E = RegList.end(); I != E; ++I)
 559       Inst.addOperand(MCOperand::CreateReg(*I));
 560   }
 561
 562   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
 563     addRegListOperands(Inst, N);
 564   }
 565
 566   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
 567     addRegListOperands(Inst, N);
 568   }
 569
 570   void addImmOperands(MCInst &Inst, unsigned N) const {
 571     assert(N == 1 && "Invalid number of operands!");
 572     addExpr(Inst, getImm());
 573   }
 574
 575   void addImm0_255Operands(MCInst &Inst, unsigned N) const {
 576     assert(N == 1 && "Invalid number of operands!");
 577     addExpr(Inst, getImm());
 578   }
 579
 580   void addT2SOImmOperands(MCInst &Inst, unsigned N) const {
 581     assert(N == 1 && "Invalid number of operands!");
 582     addExpr(Inst, getImm());
 583   }
 584
 585   void addMemBarrierOptOperands(MCInst &Inst, unsigned N) const {
 586     assert(N == 1 && "Invalid number of operands!");
 587     Inst.addOperand(MCOperand::CreateImm(unsigned(getMemBarrierOpt())));
 588   }
 589
 590   void addMemMode7Operands(MCInst &Inst, unsigned N) const {
 591     assert(N == 1 && isMemMode7() && "Invalid number of operands!");
 592     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 593
 594     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 595     (void)CE;
 596     assert((CE || CE->getValue() == 0) &&
 597            "No offset operand support in mode 7");
 598   }
 599
 600   void addMemMode2Operands(MCInst &Inst, unsigned N) const {
 601     assert(isMemMode2() && "Invalid mode or number of operands!");
 602     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 603     unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1);
 604
 605     if (getMemOffsetIsReg()) {
 606       Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum()));
 607
 608       ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add;
 609       ARM_AM::ShiftOpc ShOpc = ARM_AM::no_shift;
 610       int64_t ShiftAmount = 0;
 611
 612       if (getMemOffsetRegShifted()) {
 613         ShOpc = getMemShiftType();
 614         const MCConstantExpr *CE =
 615                    dyn_cast<MCConstantExpr>(getMemShiftAmount());
 616         ShiftAmount = CE->getValue();
 617       }
 618
 619       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(AMOpc, ShiftAmount,
 620                                            ShOpc, IdxMode)));
 621       return;
 622     }
 623
 624     // Create a operand placeholder to always yield the same number of operands.
 625     Inst.addOperand(MCOperand::CreateReg(0));
 626
 627     // FIXME: #-0 is encoded differently than #0. Does the parser preserve
 628     // the difference?
 629     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 630     assert(CE && "Non-constant mode 2 offset operand!");
 631     int64_t Offset = CE->getValue();
 632
 633     if (Offset >= 0)
 634       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::add,
 635                                            Offset, ARM_AM::no_shift, IdxMode)));
 636     else
 637       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM2Opc(ARM_AM::sub,
 638                                           -Offset, ARM_AM::no_shift, IdxMode)));
 639   }
 640
 641   void addMemMode3Operands(MCInst &Inst, unsigned N) const {
 642     assert(isMemMode3() && "Invalid mode or number of operands!");
 643     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 644     unsigned IdxMode = (getMemPreindexed() | getMemPostindexed() << 1);
 645
 646     if (getMemOffsetIsReg()) {
 647       Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum()));
 648
 649       ARM_AM::AddrOpc AMOpc = getMemNegative() ? ARM_AM::sub : ARM_AM::add;
 650       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(AMOpc, 0,
 651                                                              IdxMode)));
 652       return;
 653     }
 654
 655     // Create a operand placeholder to always yield the same number of operands.
 656     Inst.addOperand(MCOperand::CreateReg(0));
 657
 658     // FIXME: #-0 is encoded differently than #0. Does the parser preserve
 659     // the difference?
 660     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 661     assert(CE && "Non-constant mode 3 offset operand!");
 662     int64_t Offset = CE->getValue();
 663
 664     if (Offset >= 0)
 665       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::add,
 666                                            Offset, IdxMode)));
 667     else
 668       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM3Opc(ARM_AM::sub,
 669                                            -Offset, IdxMode)));
 670   }
 671
 672   void addMemMode5Operands(MCInst &Inst, unsigned N) const {
 673     assert(N == 2 && isMemMode5() && "Invalid number of operands!");
 674
 675     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 676     assert(!getMemOffsetIsReg() && "Invalid mode 5 operand");
 677
 678     // FIXME: #-0 is encoded differently than #0. Does the parser preserve
 679     // the difference?
 680     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 681     assert(CE && "Non-constant mode 5 offset operand!");
 682
 683     // The MCInst offset operand doesn't include the low two bits (like
 684     // the instruction encoding).
 685     int64_t Offset = CE->getValue() / 4;
 686     if (Offset >= 0)
 687       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add,
 688                                                              Offset)));
 689     else
 690       Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub,
 691                                                              -Offset)));
 692   }
 693
 694   void addMemModeRegThumbOperands(MCInst &Inst, unsigned N) const {
 695     assert(N == 2 && isMemModeRegThumb() && "Invalid number of operands!");
 696     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 697     Inst.addOperand(MCOperand::CreateReg(getMemOffsetRegNum()));
 698   }
 699
 700   void addMemModeImmThumbOperands(MCInst &Inst, unsigned N) const {
 701     assert(N == 2 && isMemModeImmThumb() && "Invalid number of operands!");
 702     Inst.addOperand(MCOperand::CreateReg(getMemBaseRegNum()));
 703     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getMemOffset());
 704     assert(CE && "Non-constant mode offset operand!");
 705     Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 706   }
 707
 708   void addMSRMaskOperands(MCInst &Inst, unsigned N) const {
 709     assert(N == 1 && "Invalid number of operands!");
 710     Inst.addOperand(MCOperand::CreateImm(unsigned(getMSRMask())));
 711   }
 712
 713   void addProcIFlagsOperands(MCInst &Inst, unsigned N) const {
 714     assert(N == 1 && "Invalid number of operands!");
 715     Inst.addOperand(MCOperand::CreateImm(unsigned(getProcIFlags())));
 716   }
 717
 718   virtual void print(raw_ostream &OS) const;
 719
 720   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
 721     ARMOperand *Op = new ARMOperand(CondCode);
 722     Op->CC.Val = CC;
 723     Op->StartLoc = S;
 724     Op->EndLoc = S;
 725     return Op;
 726   }
 727
 728   static ARMOperand *CreateCoprocNum(unsigned CopVal, SMLoc S) {
 729     ARMOperand *Op = new ARMOperand(CoprocNum);
 730     Op->Cop.Val = CopVal;
 731     Op->StartLoc = S;
 732     Op->EndLoc = S;
 733     return Op;
 734   }
 735
 736   static ARMOperand *CreateCoprocReg(unsigned CopVal, SMLoc S) {
 737     ARMOperand *Op = new ARMOperand(CoprocReg);
 738     Op->Cop.Val = CopVal;
 739     Op->StartLoc = S;
 740     Op->EndLoc = S;
 741     return Op;
 742   }
 743
 744   static ARMOperand *CreateCCOut(unsigned RegNum, SMLoc S) {
 745     ARMOperand *Op = new ARMOperand(CCOut);
 746     Op->Reg.RegNum = RegNum;
 747     Op->StartLoc = S;
 748     Op->EndLoc = S;
 749     return Op;
 750   }
 751
 752   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
 753     ARMOperand *Op = new ARMOperand(Token);
 754     Op->Tok.Data = Str.data();
 755     Op->Tok.Length = Str.size();
 756     Op->StartLoc = S;
 757     Op->EndLoc = S;
 758     return Op;
 759   }
 760
 761   static ARMOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
 762     ARMOperand *Op = new ARMOperand(Register);
 763     Op->Reg.RegNum = RegNum;
 764     Op->StartLoc = S;
 765     Op->EndLoc = E;
 766     return Op;
 767   }
 768
 769   static ARMOperand *CreateShiftedRegister(ARM_AM::ShiftOpc ShTy,
 770                                            unsigned SrcReg,
 771                                            unsigned ShiftReg,
 772                                            unsigned ShiftImm,
 773                                            SMLoc S, SMLoc E) {
 774     ARMOperand *Op = new ARMOperand(ShiftedRegister);
 775     Op->ShiftedReg.ShiftTy = ShTy;
 776     Op->ShiftedReg.SrcReg = SrcReg;
 777     Op->ShiftedReg.ShiftReg = ShiftReg;
 778     Op->ShiftedReg.ShiftImm = ShiftImm;
 779     Op->StartLoc = S;
 780     Op->EndLoc = E;
 781     return Op;
 782   }
 783
 784   static ARMOperand *CreateShifter(ARM_AM::ShiftOpc ShTy,
 785                                    SMLoc S, SMLoc E) {
 786     ARMOperand *Op = new ARMOperand(Shifter);
 787     Op->Shift.ShiftTy = ShTy;
 788     Op->StartLoc = S;
 789     Op->EndLoc = E;
 790     return Op;
 791   }
 792
 793   static ARMOperand *
 794   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
 795                 SMLoc StartLoc, SMLoc EndLoc) {
 796     KindTy Kind = RegisterList;
 797
 798     if (ARM::DPRRegClass.contains(Regs.front().first))
 799       Kind = DPRRegisterList;
 800     else if (ARM::SPRRegClass.contains(Regs.front().first))
 801       Kind = SPRRegisterList;
 802
 803     ARMOperand *Op = new ARMOperand(Kind);
 804     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
 805            I = Regs.begin(), E = Regs.end(); I != E; ++I)
 806       Op->Registers.push_back(I->first);
 807     array_pod_sort(Op->Registers.begin(), Op->Registers.end());
 808     Op->StartLoc = StartLoc;
 809     Op->EndLoc = EndLoc;
 810     return Op;
 811   }
 812
 813   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
 814     ARMOperand *Op = new ARMOperand(Immediate);
 815     Op->Imm.Val = Val;
 816     Op->StartLoc = S;
 817     Op->EndLoc = E;
 818     return Op;
 819   }
 820
 821   static ARMOperand *CreateMem(ARMII::AddrMode AddrMode, unsigned BaseRegNum,
 822                                bool OffsetIsReg, const MCExpr *Offset,
 823                                int OffsetRegNum, bool OffsetRegShifted,
 824                                enum ARM_AM::ShiftOpc ShiftType,
 825                                const MCExpr *ShiftAmount, bool Preindexed,
 826                                bool Postindexed, bool Negative, bool Writeback,
 827                                SMLoc S, SMLoc E) {
 828     assert((OffsetRegNum == -1 || OffsetIsReg) &&
 829            "OffsetRegNum must imply OffsetIsReg!");
 830     assert((!OffsetRegShifted || OffsetIsReg) &&
 831            "OffsetRegShifted must imply OffsetIsReg!");
 832     assert((Offset || OffsetIsReg) &&
 833            "Offset must exists unless register offset is used!");
 834     assert((!ShiftAmount || (OffsetIsReg && OffsetRegShifted)) &&
 835            "Cannot have shift amount without shifted register offset!");
 836     assert((!Offset || !OffsetIsReg) &&
 837            "Cannot have expression offset and register offset!");
 838
 839     ARMOperand *Op = new ARMOperand(Memory);
 840     Op->Mem.AddrMode = AddrMode;
 841     Op->Mem.BaseRegNum = BaseRegNum;
 842     Op->Mem.OffsetIsReg = OffsetIsReg;
 843     if (OffsetIsReg)
 844       Op->Mem.Offset.RegNum = OffsetRegNum;
 845     else
 846       Op->Mem.Offset.Value = Offset;
 847     Op->Mem.OffsetRegShifted = OffsetRegShifted;
 848     Op->Mem.ShiftType = ShiftType;
 849     Op->Mem.ShiftAmount = ShiftAmount;
 850     Op->Mem.Preindexed = Preindexed;
 851     Op->Mem.Postindexed = Postindexed;
 852     Op->Mem.Negative = Negative;
 853     Op->Mem.Writeback = Writeback;
 854
 855     Op->StartLoc = S;
 856     Op->EndLoc = E;
 857     return Op;
 858   }
 859
 860   static ARMOperand *CreateMemBarrierOpt(ARM_MB::MemBOpt Opt, SMLoc S) {
 861     ARMOperand *Op = new ARMOperand(MemBarrierOpt);
 862     Op->MBOpt.Val = Opt;
 863     Op->StartLoc = S;
 864     Op->EndLoc = S;
 865     return Op;
 866   }
 867
 868   static ARMOperand *CreateProcIFlags(ARM_PROC::IFlags IFlags, SMLoc S) {
 869     ARMOperand *Op = new ARMOperand(ProcIFlags);
 870     Op->IFlags.Val = IFlags;
 871     Op->StartLoc = S;
 872     Op->EndLoc = S;
 873     return Op;
 874   }
 875
 876   static ARMOperand *CreateMSRMask(unsigned MMask, SMLoc S) {
 877     ARMOperand *Op = new ARMOperand(MSRMask);
 878     Op->MMask.Val = MMask;
 879     Op->StartLoc = S;
 880     Op->EndLoc = S;
 881     return Op;
 882   }
 883 };
 884
 885 } // end anonymous namespace.
 886
 887 void ARMOperand::print(raw_ostream &OS) const {
 888   switch (Kind) {
 889   case CondCode:
 890     OS << "<ARMCC::" << ARMCondCodeToString(getCondCode()) << ">";
 891     break;
 892   case CCOut:
 893     OS << "<ccout " << getReg() << ">";
 894     break;
 895   case CoprocNum:
 896     OS << "<coprocessor number: " << getCoproc() << ">";
 897     break;
 898   case CoprocReg:
 899     OS << "<coprocessor register: " << getCoproc() << ">";
 900     break;
 901   case MSRMask:
 902     OS << "<mask: " << getMSRMask() << ">";
 903     break;
 904   case Immediate:
 905     getImm()->print(OS);
 906     break;
 907   case MemBarrierOpt:
 908     OS << "<ARM_MB::" << MemBOptToString(getMemBarrierOpt()) << ">";
 909     break;
 910   case Memory:
 911     OS << "<memory "
 912        << "am:" << ARMII::AddrModeToString(getMemAddrMode())
 913        << " base:" << getMemBaseRegNum();
 914     if (getMemOffsetIsReg()) {
 915       OS << " offset:<register " << getMemOffsetRegNum();
 916       if (getMemOffsetRegShifted()) {
 917         OS << " offset-shift-type:" << getMemShiftType();
 918         OS << " offset-shift-amount:" << *getMemShiftAmount();
 919       }
 920     } else {
 921       OS << " offset:" << *getMemOffset();
 922     }
 923     if (getMemOffsetIsReg())
 924       OS << " (offset-is-reg)";
 925     if (getMemPreindexed())
 926       OS << " (pre-indexed)";
 927     if (getMemPostindexed())
 928       OS << " (post-indexed)";
 929     if (getMemNegative())
 930       OS << " (negative)";
 931     if (getMemWriteback())
 932       OS << " (writeback)";
 933     OS << ">";
 934     break;
 935   case ProcIFlags: {
 936     OS << "<ARM_PROC::";
 937     unsigned IFlags = getProcIFlags();
 938     for (int i=2; i >= 0; --i)
 939       if (IFlags & (1 << i))
 940         OS << ARM_PROC::IFlagsToString(1 << i);
 941     OS << ">";
 942     break;
 943   }
 944   case Register:
 945     OS << "<register " << getReg() << ">";
 946     break;
 947   case Shifter:
 948     OS << "<shifter " << ARM_AM::getShiftOpcStr(Shift.ShiftTy) << ">";
 949     break;
 950   case ShiftedRegister:
 951     OS << "<so_reg"
 952        << ShiftedReg.SrcReg
 953        << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(ShiftedReg.ShiftImm))
 954        << ", " << ShiftedReg.ShiftReg << ", "
 955        << ARM_AM::getSORegOffset(ShiftedReg.ShiftImm)
 956        << ">";
 957     break;
 958   case RegisterList:
 959   case DPRRegisterList:
 960   case SPRRegisterList: {
 961     OS << "<register_list ";
 962
 963     const SmallVectorImpl<unsigned> &RegList = getRegList();
 964     for (SmallVectorImpl<unsigned>::const_iterator
 965            I = RegList.begin(), E = RegList.end(); I != E; ) {
 966       OS << *I;
 967       if (++I < E) OS << ", ";
 968     }
 969
 970     OS << ">";
 971     break;
 972   }
 973   case Token:
 974     OS << "'" << getToken() << "'";
 975     break;
 976   }
 977 }
 978
 979 /// @name Auto-generated Match Functions
 980 /// {
 981
 982 static unsigned MatchRegisterName(StringRef Name);
 983
 984 /// }
 985
 986 bool ARMAsmParser::ParseRegister(unsigned &RegNo,
 987                                  SMLoc &StartLoc, SMLoc &EndLoc) {
 988   RegNo = TryParseRegister();
 989
 990   return (RegNo == (unsigned)-1);
 991 }
 992
 993 /// Try to parse a register name.  The token must be an Identifier when called,
 994 /// and if it is a register name the token is eaten and the register number is
 995 /// returned.  Otherwise return -1.
 996 ///
 997 int ARMAsmParser::TryParseRegister() {
 998   const AsmToken &Tok = Parser.getTok();
 999   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1000
1001   // FIXME: Validate register for the current architecture; we have to do
1002   // validation later, so maybe there is no need for this here.
1003   std::string upperCase = Tok.getString().str();
1004   std::string lowerCase = LowercaseString(upperCase);
1005   unsigned RegNum = MatchRegisterName(lowerCase);
1006   if (!RegNum) {
1007     RegNum = StringSwitch<unsigned>(lowerCase)
1008       .Case("r13", ARM::SP)
1009       .Case("r14", ARM::LR)
1010       .Case("r15", ARM::PC)
1011       .Case("ip", ARM::R12)
1012       .Default(0);
1013   }
1014   if (!RegNum) return -1;
1015
1016   Parser.Lex(); // Eat identifier token.
1017   return RegNum;
1018 }
1019
1020 /// Try to parse a register name.  The token must be an Identifier when called,
1021 /// and if it is a register name the token is eaten and the register number is
1022 /// returned.  Otherwise return -1.
1023 ///
1024 bool ARMAsmParser::TryParseShiftRegister(
1025                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1026   SMLoc S = Parser.getTok().getLoc();
1027   const AsmToken &Tok = Parser.getTok();
1028   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1029
1030   std::string upperCase = Tok.getString().str();
1031   std::string lowerCase = LowercaseString(upperCase);
1032   ARM_AM::ShiftOpc ShiftTy = StringSwitch<ARM_AM::ShiftOpc>(lowerCase)
1033       .Case("lsl", ARM_AM::lsl)
1034       .Case("lsr", ARM_AM::lsr)
1035       .Case("asr", ARM_AM::asr)
1036       .Case("ror", ARM_AM::ror)
1037       .Case("rrx", ARM_AM::rrx)
1038       .Default(ARM_AM::no_shift);
1039
1040   if (ShiftTy == ARM_AM::no_shift)
1041     return true;
1042
1043   Parser.Lex(); // Eat the operator.
1044
1045   // The source register for the shift has already been added to the
1046   // operand list, so we need to pop it off and combine it into the shifted
1047   // register operand instead.
1048   ARMOperand *PrevOp = (ARMOperand*)Operands.pop_back_val();
1049   if (!PrevOp->isReg())
1050     return Error(PrevOp->getStartLoc(), "shift must be of a register");
1051   int SrcReg = PrevOp->getReg();
1052   int64_t Imm = 0;
1053   int ShiftReg = 0;
1054   if (ShiftTy == ARM_AM::rrx) {
1055     // RRX Doesn't have an explicit shift amount. The encoder expects
1056     // the shift register to be the same as the source register. Seems odd,
1057     // but OK.
1058     ShiftReg = SrcReg;
1059   } else {
1060     // Figure out if this is shifted by a constant or a register (for non-RRX).
1061     if (Parser.getTok().is(AsmToken::Hash)) {
1062       Parser.Lex(); // Eat hash.
1063       SMLoc ImmLoc = Parser.getTok().getLoc();
1064       const MCExpr *ShiftExpr = 0;
1065       if (getParser().ParseExpression(ShiftExpr))
1066         return Error(ImmLoc, "invalid immediate shift value");
1067       // The expression must be evaluatable as an immediate.
1068       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ShiftExpr);
1069       if (!CE)
1070         return Error(ImmLoc, "invalid immediate shift value");
1071       // Range check the immediate.
1072       // lsl, ror: 0 <= imm <= 31
1073       // lsr, asr: 0 <= imm <= 32
1074       Imm = CE->getValue();
1075       if (Imm < 0 ||
1076           ((ShiftTy == ARM_AM::lsl || ShiftTy == ARM_AM::ror) && Imm > 31) ||
1077           ((ShiftTy == ARM_AM::lsr || ShiftTy == ARM_AM::asr) && Imm > 32)) {
1078         return Error(ImmLoc, "immediate shift value out of range");
1079       }
1080     } else if (Parser.getTok().is(AsmToken::Identifier)) {
1081       ShiftReg = TryParseRegister();
1082       SMLoc L = Parser.getTok().getLoc();
1083       if (ShiftReg == -1)
1084         return Error (L, "expected immediate or register in shift operand");
1085     } else
1086       return Error (Parser.getTok().getLoc(),
1087                     "expected immediate or register in shift operand");
1088   }
1089
1090
1091   Operands.push_back(ARMOperand::CreateShiftedRegister(ShiftTy, SrcReg,
1092                                                        ShiftReg, Imm,
1093                                                S, Parser.getTok().getLoc()));
1094
1095   return false;
1096 }
1097
1098
1099 /// Try to parse a register name.  The token must be an Identifier when called.
1100 /// If it's a register, an AsmOperand is created. Another AsmOperand is created
1101 /// if there is a "writeback". 'true' if it's not a register.
1102 ///
1103 /// TODO this is likely to change to allow different register types and or to
1104 /// parse for a specific register type.
1105 bool ARMAsmParser::
1106 TryParseRegisterWithWriteBack(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1107   SMLoc S = Parser.getTok().getLoc();
1108   int RegNo = TryParseRegister();
1109   if (RegNo == -1)
1110     return true;
1111
1112   Operands.push_back(ARMOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
1113
1114   const AsmToken &ExclaimTok = Parser.getTok();
1115   if (ExclaimTok.is(AsmToken::Exclaim)) {
1116     Operands.push_back(ARMOperand::CreateToken(ExclaimTok.getString(),
1117                                                ExclaimTok.getLoc()));
1118     Parser.Lex(); // Eat exclaim token
1119   }
1120
1121   return false;
1122 }
1123
1124 /// MatchCoprocessorOperandName - Try to parse an coprocessor related
1125 /// instruction with a symbolic operand name. Example: "p1", "p7", "c3",
1126 /// "c5", ...
1127 static int MatchCoprocessorOperandName(StringRef Name, char CoprocOp) {
1128   // Use the same layout as the tablegen'erated register name matcher. Ugly,
1129   // but efficient.
1130   switch (Name.size()) {
1131   default: break;
1132   case 2:
1133     if (Name[0] != CoprocOp)
1134       return -1;
1135     switch (Name[1]) {
1136     default:  return -1;
1137     case '0': return 0;
1138     case '1': return 1;
1139     case '2': return 2;
1140     case '3': return 3;
1141     case '4': return 4;
1142     case '5': return 5;
1143     case '6': return 6;
1144     case '7': return 7;
1145     case '8': return 8;
1146     case '9': return 9;
1147     }
1148     break;
1149   case 3:
1150     if (Name[0] != CoprocOp || Name[1] != '1')
1151       return -1;
1152     switch (Name[2]) {
1153     default:  return -1;
1154     case '0': return 10;
1155     case '1': return 11;
1156     case '2': return 12;
1157     case '3': return 13;
1158     case '4': return 14;
1159     case '5': return 15;
1160     }
1161     break;
1162   }
1163
1164   return -1;
1165 }
1166
1167 /// tryParseCoprocNumOperand - Try to parse an coprocessor number operand. The
1168 /// token must be an Identifier when called, and if it is a coprocessor
1169 /// number, the token is eaten and the operand is added to the operand list.
1170 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1171 tryParseCoprocNumOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1172   SMLoc S = Parser.getTok().getLoc();
1173   const AsmToken &Tok = Parser.getTok();
1174   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1175
1176   int Num = MatchCoprocessorOperandName(Tok.getString(), 'p');
1177   if (Num == -1)
1178     return MatchOperand_NoMatch;
1179
1180   Parser.Lex(); // Eat identifier token.
1181   Operands.push_back(ARMOperand::CreateCoprocNum(Num, S));
1182   return MatchOperand_Success;
1183 }
1184
1185 /// tryParseCoprocRegOperand - Try to parse an coprocessor register operand. The
1186 /// token must be an Identifier when called, and if it is a coprocessor
1187 /// number, the token is eaten and the operand is added to the operand list.
1188 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1189 tryParseCoprocRegOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1190   SMLoc S = Parser.getTok().getLoc();
1191   const AsmToken &Tok = Parser.getTok();
1192   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1193
1194   int Reg = MatchCoprocessorOperandName(Tok.getString(), 'c');
1195   if (Reg == -1)
1196     return MatchOperand_NoMatch;
1197
1198   Parser.Lex(); // Eat identifier token.
1199   Operands.push_back(ARMOperand::CreateCoprocReg(Reg, S));
1200   return MatchOperand_Success;
1201 }
1202
1203 /// Parse a register list, return it if successful else return null.  The first
1204 /// token must be a '{' when called.
1205 bool ARMAsmParser::
1206 ParseRegisterList(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1207   assert(Parser.getTok().is(AsmToken::LCurly) &&
1208          "Token is not a Left Curly Brace");
1209   SMLoc S = Parser.getTok().getLoc();
1210
1211   // Read the rest of the registers in the list.
1212   unsigned PrevRegNum = 0;
1213   SmallVector<std::pair<unsigned, SMLoc>, 32> Registers;
1214
1215   do {
1216     bool IsRange = Parser.getTok().is(AsmToken::Minus);
1217     Parser.Lex(); // Eat non-identifier token.
1218
1219     const AsmToken &RegTok = Parser.getTok();
1220     SMLoc RegLoc = RegTok.getLoc();
1221     if (RegTok.isNot(AsmToken::Identifier)) {
1222       Error(RegLoc, "register expected");
1223       return true;
1224     }
1225
1226     int RegNum = TryParseRegister();
1227     if (RegNum == -1) {
1228       Error(RegLoc, "register expected");
1229       return true;
1230     }
1231
1232     if (IsRange) {
1233       int Reg = PrevRegNum;
1234       do {
1235         ++Reg;
1236         Registers.push_back(std::make_pair(Reg, RegLoc));
1237       } while (Reg != RegNum);
1238     } else {
1239       Registers.push_back(std::make_pair(RegNum, RegLoc));
1240     }
1241
1242     PrevRegNum = RegNum;
1243   } while (Parser.getTok().is(AsmToken::Comma) ||
1244            Parser.getTok().is(AsmToken::Minus));
1245
1246   // Process the right curly brace of the list.
1247   const AsmToken &RCurlyTok = Parser.getTok();
1248   if (RCurlyTok.isNot(AsmToken::RCurly)) {
1249     Error(RCurlyTok.getLoc(), "'}' expected");
1250     return true;
1251   }
1252
1253   SMLoc E = RCurlyTok.getLoc();
1254   Parser.Lex(); // Eat right curly brace token.
1255
1256   // Verify the register list.
1257   SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
1258     RI = Registers.begin(), RE = Registers.end();
1259
1260   unsigned HighRegNum = getARMRegisterNumbering(RI->first);
1261   bool EmittedWarning = false;
1262
1263   DenseMap<unsigned, bool> RegMap;
1264   RegMap[HighRegNum] = true;
1265
1266   for (++RI; RI != RE; ++RI) {
1267     const std::pair<unsigned, SMLoc> &RegInfo = *RI;
1268     unsigned Reg = getARMRegisterNumbering(RegInfo.first);
1269
1270     if (RegMap[Reg]) {
1271       Error(RegInfo.second, "register duplicated in register list");
1272       return true;
1273     }
1274
1275     if (!EmittedWarning && Reg < HighRegNum)
1276       Warning(RegInfo.second,
1277               "register not in ascending order in register list");
1278
1279     RegMap[Reg] = true;
1280     HighRegNum = std::max(Reg, HighRegNum);
1281   }
1282
1283   Operands.push_back(ARMOperand::CreateRegList(Registers, S, E));
1284   return false;
1285 }
1286
1287 /// tryParseMemBarrierOptOperand - Try to parse DSB/DMB data barrier options.
1288 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1289 tryParseMemBarrierOptOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1290   SMLoc S = Parser.getTok().getLoc();
1291   const AsmToken &Tok = Parser.getTok();
1292   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1293   StringRef OptStr = Tok.getString();
1294
1295   unsigned Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()))
1296     .Case("sy",    ARM_MB::SY)
1297     .Case("st",    ARM_MB::ST)
1298     .Case("ish",   ARM_MB::ISH)
1299     .Case("ishst", ARM_MB::ISHST)
1300     .Case("nsh",   ARM_MB::NSH)
1301     .Case("nshst", ARM_MB::NSHST)
1302     .Case("osh",   ARM_MB::OSH)
1303     .Case("oshst", ARM_MB::OSHST)
1304     .Default(~0U);
1305
1306   if (Opt == ~0U)
1307     return MatchOperand_NoMatch;
1308
1309   Parser.Lex(); // Eat identifier token.
1310   Operands.push_back(ARMOperand::CreateMemBarrierOpt((ARM_MB::MemBOpt)Opt, S));
1311   return MatchOperand_Success;
1312 }
1313
1314 /// tryParseProcIFlagsOperand - Try to parse iflags from CPS instruction.
1315 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1316 tryParseProcIFlagsOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1317   SMLoc S = Parser.getTok().getLoc();
1318   const AsmToken &Tok = Parser.getTok();
1319   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1320   StringRef IFlagsStr = Tok.getString();
1321
1322   unsigned IFlags = 0;
1323   for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
1324     unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1))
1325     .Case("a", ARM_PROC::A)
1326     .Case("i", ARM_PROC::I)
1327     .Case("f", ARM_PROC::F)
1328     .Default(~0U);
1329
1330     // If some specific iflag is already set, it means that some letter is
1331     // present more than once, this is not acceptable.
1332     if (Flag == ~0U || (IFlags & Flag))
1333       return MatchOperand_NoMatch;
1334
1335     IFlags |= Flag;
1336   }
1337
1338   Parser.Lex(); // Eat identifier token.
1339   Operands.push_back(ARMOperand::CreateProcIFlags((ARM_PROC::IFlags)IFlags, S));
1340   return MatchOperand_Success;
1341 }
1342
1343 /// tryParseMSRMaskOperand - Try to parse mask flags from MSR instruction.
1344 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1345 tryParseMSRMaskOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1346   SMLoc S = Parser.getTok().getLoc();
1347   const AsmToken &Tok = Parser.getTok();
1348   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
1349   StringRef Mask = Tok.getString();
1350
1351   // Split spec_reg from flag, example: CPSR_sxf => "CPSR" and "sxf"
1352   size_t Start = 0, Next = Mask.find('_');
1353   StringRef Flags = "";
1354   StringRef SpecReg = Mask.slice(Start, Next);
1355   if (Next != StringRef::npos)
1356     Flags = Mask.slice(Next+1, Mask.size());
1357
1358   // FlagsVal contains the complete mask:
1359   // 3-0: Mask
1360   // 4: Special Reg (cpsr, apsr => 0; spsr => 1)
1361   unsigned FlagsVal = 0;
1362
1363   if (SpecReg == "apsr") {
1364     FlagsVal = StringSwitch<unsigned>(Flags)
1365     .Case("nzcvq",  0x8) // same as CPSR_c
1366     .Case("g",      0x4) // same as CPSR_s
1367     .Case("nzcvqg", 0xc) // same as CPSR_fs
1368     .Default(~0U);
1369
1370     if (FlagsVal == ~0U) {
1371       if (!Flags.empty())
1372         return MatchOperand_NoMatch;
1373       else
1374         FlagsVal = 0; // No flag
1375     }
1376   } else if (SpecReg == "cpsr" || SpecReg == "spsr") {
1377     if (Flags == "all") // cpsr_all is an alias for cpsr_fc
1378       Flags = "fc";
1379     for (int i = 0, e = Flags.size(); i != e; ++i) {
1380       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
1381       .Case("c", 1)
1382       .Case("x", 2)
1383       .Case("s", 4)
1384       .Case("f", 8)
1385       .Default(~0U);
1386
1387       // If some specific flag is already set, it means that some letter is
1388       // present more than once, this is not acceptable.
1389       if (FlagsVal == ~0U || (FlagsVal & Flag))
1390         return MatchOperand_NoMatch;
1391       FlagsVal |= Flag;
1392     }
1393   } else // No match for special register.
1394     return MatchOperand_NoMatch;
1395
1396   // Special register without flags are equivalent to "fc" flags.
1397   if (!FlagsVal)
1398     FlagsVal = 0x9;
1399
1400   // Bit 4: Special Reg (cpsr, apsr => 0; spsr => 1)
1401   if (SpecReg == "spsr")
1402     FlagsVal |= 16;
1403
1404   Parser.Lex(); // Eat identifier token.
1405   Operands.push_back(ARMOperand::CreateMSRMask(FlagsVal, S));
1406   return MatchOperand_Success;
1407 }
1408
1409 /// tryParseMemMode2Operand - Try to parse memory addressing mode 2 operand.
1410 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1411 tryParseMemMode2Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1412   assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\"");
1413
1414   if (ParseMemory(Operands, ARMII::AddrMode2))
1415     return MatchOperand_NoMatch;
1416
1417   return MatchOperand_Success;
1418 }
1419
1420 /// tryParseMemMode3Operand - Try to parse memory addressing mode 3 operand.
1421 ARMAsmParser::OperandMatchResultTy ARMAsmParser::
1422 tryParseMemMode3Operand(SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1423   assert(Parser.getTok().is(AsmToken::LBrac) && "Token is not a \"[\"");
1424
1425   if (ParseMemory(Operands, ARMII::AddrMode3))
1426     return MatchOperand_NoMatch;
1427
1428   return MatchOperand_Success;
1429 }
1430
1431 /// CvtLdWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
1432 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
1433 /// when they refer multiple MIOperands inside a single one.
1434 bool ARMAsmParser::
1435 CvtLdWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
1436                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1437   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
1438
1439   // Create a writeback register dummy placeholder.
1440   Inst.addOperand(MCOperand::CreateImm(0));
1441
1442   ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3);
1443   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
1444   return true;
1445 }
1446
1447 /// CvtStWriteBackRegAddrMode2 - Convert parsed operands to MCInst.
1448 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
1449 /// when they refer multiple MIOperands inside a single one.
1450 bool ARMAsmParser::
1451 CvtStWriteBackRegAddrMode2(MCInst &Inst, unsigned Opcode,
1452                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1453   // Create a writeback register dummy placeholder.
1454   Inst.addOperand(MCOperand::CreateImm(0));
1455   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
1456   ((ARMOperand*)Operands[3])->addMemMode2Operands(Inst, 3);
1457   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
1458   return true;
1459 }
1460
1461 /// CvtLdWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
1462 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
1463 /// when they refer multiple MIOperands inside a single one.
1464 bool ARMAsmParser::
1465 CvtLdWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
1466                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1467   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
1468
1469   // Create a writeback register dummy placeholder.
1470   Inst.addOperand(MCOperand::CreateImm(0));
1471
1472   ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3);
1473   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
1474   return true;
1475 }
1476
1477 /// CvtStWriteBackRegAddrMode3 - Convert parsed operands to MCInst.
1478 /// Needed here because the Asm Gen Matcher can't handle properly tied operands
1479 /// when they refer multiple MIOperands inside a single one.
1480 bool ARMAsmParser::
1481 CvtStWriteBackRegAddrMode3(MCInst &Inst, unsigned Opcode,
1482                          const SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1483   // Create a writeback register dummy placeholder.
1484   Inst.addOperand(MCOperand::CreateImm(0));
1485   ((ARMOperand*)Operands[2])->addRegOperands(Inst, 1);
1486   ((ARMOperand*)Operands[3])->addMemMode3Operands(Inst, 3);
1487   ((ARMOperand*)Operands[1])->addCondCodeOperands(Inst, 2);
1488   return true;
1489 }
1490
1491 /// Parse an ARM memory expression, return false if successful else return true
1492 /// or an error.  The first token must be a '[' when called.
1493 ///
1494 /// TODO Only preindexing and postindexing addressing are started, unindexed
1495 /// with option, etc are still to do.
1496 bool ARMAsmParser::
1497 ParseMemory(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
1498             ARMII::AddrMode AddrMode = ARMII::AddrModeNone) {
1499   SMLoc S, E;
1500   assert(Parser.getTok().is(AsmToken::LBrac) &&
1501          "Token is not a Left Bracket");
1502   S = Parser.getTok().getLoc();
1503   Parser.Lex(); // Eat left bracket token.
1504
1505   const AsmToken &BaseRegTok = Parser.getTok();
1506   if (BaseRegTok.isNot(AsmToken::Identifier)) {
1507     Error(BaseRegTok.getLoc(), "register expected");
1508     return true;
1509   }
1510   int BaseRegNum = TryParseRegister();
1511   if (BaseRegNum == -1) {
1512     Error(BaseRegTok.getLoc(), "register expected");
1513     return true;
1514   }
1515
1516   // The next token must either be a comma or a closing bracket.
1517   const AsmToken &Tok = Parser.getTok();
1518   if (!Tok.is(AsmToken::Comma) && !Tok.is(AsmToken::RBrac))
1519     return true;
1520
1521   bool Preindexed = false;
1522   bool Postindexed = false;
1523   bool OffsetIsReg = false;
1524   bool Negative = false;
1525   bool Writeback = false;
1526   ARMOperand *WBOp = 0;
1527   int OffsetRegNum = -1;
1528   bool OffsetRegShifted = false;
1529   enum ARM_AM::ShiftOpc ShiftType = ARM_AM::lsl;
1530   const MCExpr *ShiftAmount = 0;
1531   const MCExpr *Offset = 0;
1532
1533   // First look for preindexed address forms, that is after the "[Rn" we now
1534   // have to see if the next token is a comma.
1535   if (Tok.is(AsmToken::Comma)) {
1536     Preindexed = true;
1537     Parser.Lex(); // Eat comma token.
1538
1539     if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount,
1540                              Offset, OffsetIsReg, OffsetRegNum, E))
1541       return true;
1542     const AsmToken &RBracTok = Parser.getTok();
1543     if (RBracTok.isNot(AsmToken::RBrac)) {
1544       Error(RBracTok.getLoc(), "']' expected");
1545       return true;
1546     }
1547     E = RBracTok.getLoc();
1548     Parser.Lex(); // Eat right bracket token.
1549
1550     const AsmToken &ExclaimTok = Parser.getTok();
1551     if (ExclaimTok.is(AsmToken::Exclaim)) {
1552       // None of addrmode3 instruction uses "!"
1553       if (AddrMode == ARMII::AddrMode3)
1554         return true;
1555
1556       WBOp = ARMOperand::CreateToken(ExclaimTok.getString(),
1557                                      ExclaimTok.getLoc());
1558       Writeback = true;
1559       Parser.Lex(); // Eat exclaim token
1560     } else { // In addressing mode 2, pre-indexed mode always end with "!"
1561       if (AddrMode == ARMII::AddrMode2)
1562         Preindexed = false;
1563     }
1564   } else {
1565     // The "[Rn" we have so far was not followed by a comma.
1566
1567     // If there's anything other than the right brace, this is a post indexing
1568     // addressing form.
1569     E = Tok.getLoc();
1570     Parser.Lex(); // Eat right bracket token.
1571
1572     const AsmToken &NextTok = Parser.getTok();
1573
1574     if (NextTok.isNot(AsmToken::EndOfStatement)) {
1575       Postindexed = true;
1576       Writeback = true;
1577
1578       if (NextTok.isNot(AsmToken::Comma)) {
1579         Error(NextTok.getLoc(), "',' expected");
1580         return true;
1581       }
1582
1583       Parser.Lex(); // Eat comma token.
1584
1585       if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType,
1586                                ShiftAmount, Offset, OffsetIsReg, OffsetRegNum,
1587                                E))
1588         return true;
1589     }
1590   }
1591
1592   // Force Offset to exist if used.
1593   if (!OffsetIsReg) {
1594     if (!Offset)
1595       Offset = MCConstantExpr::Create(0, getContext());
1596   } else {
1597     if (AddrMode == ARMII::AddrMode3 && OffsetRegShifted) {
1598       Error(E, "shift amount not supported");
1599       return true;
1600     }
1601   }
1602
1603   Operands.push_back(ARMOperand::CreateMem(AddrMode, BaseRegNum, OffsetIsReg,
1604                                      Offset, OffsetRegNum, OffsetRegShifted,
1605                                      ShiftType, ShiftAmount, Preindexed,
1606                                      Postindexed, Negative, Writeback, S, E));
1607   if (WBOp)
1608     Operands.push_back(WBOp);
1609
1610   return false;
1611 }
1612
1613 /// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn],"
1614 /// we will parse the following (were +/- means that a plus or minus is
1615 /// optional):
1616 ///   +/-Rm
1617 ///   +/-Rm, shift
1618 ///   #offset
1619 /// we return false on success or an error otherwise.
1620 bool ARMAsmParser::ParseMemoryOffsetReg(bool &Negative,
1621                                         bool &OffsetRegShifted,
1622                                         enum ARM_AM::ShiftOpc &ShiftType,
1623                                         const MCExpr *&ShiftAmount,
1624                                         const MCExpr *&Offset,
1625                                         bool &OffsetIsReg,
1626                                         int &OffsetRegNum,
1627                                         SMLoc &E) {
1628   Negative = false;
1629   OffsetRegShifted = false;
1630   OffsetIsReg = false;
1631   OffsetRegNum = -1;
1632   const AsmToken &NextTok = Parser.getTok();
1633   E = NextTok.getLoc();
1634   if (NextTok.is(AsmToken::Plus))
1635     Parser.Lex(); // Eat plus token.
1636   else if (NextTok.is(AsmToken::Minus)) {
1637     Negative = true;
1638     Parser.Lex(); // Eat minus token
1639   }
1640   // See if there is a register following the "[Rn," or "[Rn]," we have so far.
1641   const AsmToken &OffsetRegTok = Parser.getTok();
1642   if (OffsetRegTok.is(AsmToken::Identifier)) {
1643     SMLoc CurLoc = OffsetRegTok.getLoc();
1644     OffsetRegNum = TryParseRegister();
1645     if (OffsetRegNum != -1) {
1646       OffsetIsReg = true;
1647       E = CurLoc;
1648     }
1649   }
1650
1651   // If we parsed a register as the offset then there can be a shift after that.
1652   if (OffsetRegNum != -1) {
1653     // Look for a comma then a shift
1654     const AsmToken &Tok = Parser.getTok();
1655     if (Tok.is(AsmToken::Comma)) {
1656       Parser.Lex(); // Eat comma token.
1657
1658       const AsmToken &Tok = Parser.getTok();
1659       if (ParseShift(ShiftType, ShiftAmount, E))
1660         return Error(Tok.getLoc(), "shift expected");
1661       OffsetRegShifted = true;
1662     }
1663   }
1664   else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm"
1665     // Look for #offset following the "[Rn," or "[Rn],"
1666     const AsmToken &HashTok = Parser.getTok();
1667     if (HashTok.isNot(AsmToken::Hash))
1668       return Error(HashTok.getLoc(), "'#' expected");
1669
1670     Parser.Lex(); // Eat hash token.
1671
1672     if (getParser().ParseExpression(Offset))
1673      return true;
1674     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1675   }
1676   return false;
1677 }
1678
1679 /// ParseShift as one of these two:
1680 ///   ( lsl | lsr | asr | ror ) , # shift_amount
1681 ///   rrx
1682 /// and returns true if it parses a shift otherwise it returns false.
1683 bool ARMAsmParser::ParseShift(ARM_AM::ShiftOpc &St,
1684                               const MCExpr *&ShiftAmount, SMLoc &E) {
1685   const AsmToken &Tok = Parser.getTok();
1686   if (Tok.isNot(AsmToken::Identifier))
1687     return true;
1688   StringRef ShiftName = Tok.getString();
1689   if (ShiftName == "lsl" || ShiftName == "LSL")
1690     St = ARM_AM::lsl;
1691   else if (ShiftName == "lsr" || ShiftName == "LSR")
1692     St = ARM_AM::lsr;
1693   else if (ShiftName == "asr" || ShiftName == "ASR")
1694     St = ARM_AM::asr;
1695   else if (ShiftName == "ror" || ShiftName == "ROR")
1696     St = ARM_AM::ror;
1697   else if (ShiftName == "rrx" || ShiftName == "RRX")
1698     St = ARM_AM::rrx;
1699   else
1700     return true;
1701   Parser.Lex(); // Eat shift type token.
1702
1703   // Rrx stands alone.
1704   if (St == ARM_AM::rrx)
1705     return false;
1706
1707   // Otherwise, there must be a '#' and a shift amount.
1708   const AsmToken &HashTok = Parser.getTok();
1709   if (HashTok.isNot(AsmToken::Hash))
1710     return Error(HashTok.getLoc(), "'#' expected");
1711   Parser.Lex(); // Eat hash token.
1712
1713   if (getParser().ParseExpression(ShiftAmount))
1714     return true;
1715
1716   return false;
1717 }
1718
1719 /// Parse a arm instruction operand.  For now this parses the operand regardless
1720 /// of the mnemonic.
1721 bool ARMAsmParser::ParseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
1722                                 StringRef Mnemonic) {
1723   SMLoc S, E;
1724
1725   // Check if the current operand has a custom associated parser, if so, try to
1726   // custom parse the operand, or fallback to the general approach.
1727   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
1728   if (ResTy == MatchOperand_Success)
1729     return false;
1730   // If there wasn't a custom match, try the generic matcher below. Otherwise,
1731   // there was a match, but an error occurred, in which case, just return that
1732   // the operand parsing failed.
1733   if (ResTy == MatchOperand_ParseFail)
1734     return true;
1735
1736   switch (getLexer().getKind()) {
1737   default:
1738     Error(Parser.getTok().getLoc(), "unexpected token in operand");
1739     return true;
1740   case AsmToken::Identifier:
1741     if (!TryParseRegisterWithWriteBack(Operands))
1742       return false;
1743     if (!TryParseShiftRegister(Operands))
1744       return false;
1745
1746
1747     // Fall though for the Identifier case that is not a register or a
1748     // special name.
1749   case AsmToken::Integer: // things like 1f and 2b as a branch targets
1750   case AsmToken::Dot: {   // . as a branch target
1751     // This was not a register so parse other operands that start with an
1752     // identifier (like labels) as expressions and create them as immediates.
1753     const MCExpr *IdVal;
1754     S = Parser.getTok().getLoc();
1755     if (getParser().ParseExpression(IdVal))
1756       return true;
1757     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1758     Operands.push_back(ARMOperand::CreateImm(IdVal, S, E));
1759     return false;
1760   }
1761   case AsmToken::LBrac:
1762     return ParseMemory(Operands);
1763   case AsmToken::LCurly:
1764     return ParseRegisterList(Operands);
1765   case AsmToken::Hash:
1766     // #42 -> immediate.
1767     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
1768     S = Parser.getTok().getLoc();
1769     Parser.Lex();
1770     const MCExpr *ImmVal;
1771     if (getParser().ParseExpression(ImmVal))
1772       return true;
1773     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1774     Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E));
1775     return false;
1776   case AsmToken::Colon: {
1777     // ":lower16:" and ":upper16:" expression prefixes
1778     // FIXME: Check it's an expression prefix,
1779     // e.g. (FOO - :lower16:BAR) isn't legal.
1780     ARMMCExpr::VariantKind RefKind;
1781     if (ParsePrefix(RefKind))
1782       return true;
1783
1784     const MCExpr *SubExprVal;
1785     if (getParser().ParseExpression(SubExprVal))
1786       return true;
1787
1788     const MCExpr *ExprVal = ARMMCExpr::Create(RefKind, SubExprVal,
1789                                                    getContext());
1790     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1791     Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E));
1792     return false;
1793   }
1794   }
1795 }
1796
1797 // ParsePrefix - Parse ARM 16-bit relocations expression prefix, i.e.
1798 //  :lower16: and :upper16:.
1799 bool ARMAsmParser::ParsePrefix(ARMMCExpr::VariantKind &RefKind) {
1800   RefKind = ARMMCExpr::VK_ARM_None;
1801
1802   // :lower16: and :upper16: modifiers
1803   assert(getLexer().is(AsmToken::Colon) && "expected a :");
1804   Parser.Lex(); // Eat ':'
1805
1806   if (getLexer().isNot(AsmToken::Identifier)) {
1807     Error(Parser.getTok().getLoc(), "expected prefix identifier in operand");
1808     return true;
1809   }
1810
1811   StringRef IDVal = Parser.getTok().getIdentifier();
1812   if (IDVal == "lower16") {
1813     RefKind = ARMMCExpr::VK_ARM_LO16;
1814   } else if (IDVal == "upper16") {
1815     RefKind = ARMMCExpr::VK_ARM_HI16;
1816   } else {
1817     Error(Parser.getTok().getLoc(), "unexpected prefix in operand");
1818     return true;
1819   }
1820   Parser.Lex();
1821
1822   if (getLexer().isNot(AsmToken::Colon)) {
1823     Error(Parser.getTok().getLoc(), "unexpected token after prefix");
1824     return true;
1825   }
1826   Parser.Lex(); // Eat the last ':'
1827   return false;
1828 }
1829
1830 const MCExpr *
1831 ARMAsmParser::ApplyPrefixToExpr(const MCExpr *E,
1832                                 MCSymbolRefExpr::VariantKind Variant) {
1833   // Recurse over the given expression, rebuilding it to apply the given variant
1834   // to the leftmost symbol.
1835   if (Variant == MCSymbolRefExpr::VK_None)
1836     return E;
1837
1838   switch (E->getKind()) {
1839   case MCExpr::Target:
1840     llvm_unreachable("Can't handle target expr yet");
1841   case MCExpr::Constant:
1842     llvm_unreachable("Can't handle lower16/upper16 of constant yet");
1843
1844   case MCExpr::SymbolRef: {
1845     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
1846
1847     if (SRE->getKind() != MCSymbolRefExpr::VK_None)
1848       return 0;
1849
1850     return MCSymbolRefExpr::Create(&SRE->getSymbol(), Variant, getContext());
1851   }
1852
1853   case MCExpr::Unary:
1854     llvm_unreachable("Can't handle unary expressions yet");
1855
1856   case MCExpr::Binary: {
1857     const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
1858     const MCExpr *LHS = ApplyPrefixToExpr(BE->getLHS(), Variant);
1859     const MCExpr *RHS = BE->getRHS();
1860     if (!LHS)
1861       return 0;
1862
1863     return MCBinaryExpr::Create(BE->getOpcode(), LHS, RHS, getContext());
1864   }
1865   }
1866
1867   assert(0 && "Invalid expression kind!");
1868   return 0;
1869 }
1870
1871 /// \brief Given a mnemonic, split out possible predication code and carry
1872 /// setting letters to form a canonical mnemonic and flags.
1873 //
1874 // FIXME: Would be nice to autogen this.
1875 static StringRef SplitMnemonic(StringRef Mnemonic,
1876                                unsigned &PredicationCode,
1877                                bool &CarrySetting,
1878                                unsigned &ProcessorIMod) {
1879   PredicationCode = ARMCC::AL;
1880   CarrySetting = false;
1881   ProcessorIMod = 0;
1882
1883   // Ignore some mnemonics we know aren't predicated forms.
1884   //
1885   // FIXME: Would be nice to autogen this.
1886   if (Mnemonic == "teq" || Mnemonic == "vceq" ||
1887       Mnemonic == "movs" ||
1888       Mnemonic == "svc" ||
1889       (Mnemonic == "mls" || Mnemonic == "smmls" || Mnemonic == "vcls" ||
1890        Mnemonic == "vmls" || Mnemonic == "vnmls") ||
1891       Mnemonic == "vacge" || Mnemonic == "vcge" ||
1892       Mnemonic == "vclt" ||
1893       Mnemonic == "vacgt" || Mnemonic == "vcgt" ||
1894       Mnemonic == "vcle" ||
1895       (Mnemonic == "smlal" || Mnemonic == "umaal" || Mnemonic == "umlal" ||
1896        Mnemonic == "vabal" || Mnemonic == "vmlal" || Mnemonic == "vpadal" ||
1897        Mnemonic == "vqdmlal" || Mnemonic == "bics"))
1898     return Mnemonic;
1899
1900   // First, split out any predication code. Ignore mnemonics we know aren't
1901   // predicated but do have a carry-set and so weren't caught above.
1902   if (Mnemonic != "adcs") {
1903     unsigned CC = StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2))
1904       .Case("eq", ARMCC::EQ)
1905       .Case("ne", ARMCC::NE)
1906       .Case("hs", ARMCC::HS)
1907       .Case("cs", ARMCC::HS)
1908       .Case("lo", ARMCC::LO)
1909       .Case("cc", ARMCC::LO)
1910       .Case("mi", ARMCC::MI)
1911       .Case("pl", ARMCC::PL)
1912       .Case("vs", ARMCC::VS)
1913       .Case("vc", ARMCC::VC)
1914       .Case("hi", ARMCC::HI)
1915       .Case("ls", ARMCC::LS)
1916       .Case("ge", ARMCC::GE)
1917       .Case("lt", ARMCC::LT)
1918       .Case("gt", ARMCC::GT)
1919       .Case("le", ARMCC::LE)
1920       .Case("al", ARMCC::AL)
1921       .Default(~0U);
1922     if (CC != ~0U) {
1923       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
1924       PredicationCode = CC;
1925     }
1926   }
1927
1928   // Next, determine if we have a carry setting bit. We explicitly ignore all
1929   // the instructions we know end in 's'.
1930   if (Mnemonic.endswith("s") &&
1931       !(Mnemonic == "asrs" || Mnemonic == "cps" || Mnemonic == "mls" ||
1932         Mnemonic == "movs" || Mnemonic == "mrs" || Mnemonic == "smmls" ||
1933         Mnemonic == "vabs" || Mnemonic == "vcls" || Mnemonic == "vmls" ||
1934         Mnemonic == "vmrs" || Mnemonic == "vnmls" || Mnemonic == "vqabs" ||
1935         Mnemonic == "vrecps" || Mnemonic == "vrsqrts")) {
1936     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
1937     CarrySetting = true;
1938   }
1939
1940   // The "cps" instruction can have a interrupt mode operand which is glued into
1941   // the mnemonic. Check if this is the case, split it and parse the imod op
1942   if (Mnemonic.startswith("cps")) {
1943     // Split out any imod code.
1944     unsigned IMod =
1945       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
1946       .Case("ie", ARM_PROC::IE)
1947       .Case("id", ARM_PROC::ID)
1948       .Default(~0U);
1949     if (IMod != ~0U) {
1950       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
1951       ProcessorIMod = IMod;
1952     }
1953   }
1954
1955   return Mnemonic;
1956 }
1957
1958 /// \brief Given a canonical mnemonic, determine if the instruction ever allows
1959 /// inclusion of carry set or predication code operands.
1960 //
1961 // FIXME: It would be nice to autogen this.
1962 void ARMAsmParser::
1963 GetMnemonicAcceptInfo(StringRef Mnemonic, bool &CanAcceptCarrySet,
1964                       bool &CanAcceptPredicationCode) {
1965   if (Mnemonic == "and" || Mnemonic == "lsl" || Mnemonic == "lsr" ||
1966       Mnemonic == "rrx" || Mnemonic == "ror" || Mnemonic == "sub" ||
1967       Mnemonic == "smull" || Mnemonic == "add" || Mnemonic == "adc" ||
1968       Mnemonic == "mul" || Mnemonic == "bic" || Mnemonic == "asr" ||
1969       Mnemonic == "umlal" || Mnemonic == "orr" || Mnemonic == "mvn" ||
1970       Mnemonic == "rsb" || Mnemonic == "rsc" || Mnemonic == "orn" ||
1971       Mnemonic == "sbc" || Mnemonic == "mla" || Mnemonic == "umull" ||
1972       Mnemonic == "eor" || Mnemonic == "smlal" ||
1973       (Mnemonic == "mov" && !isThumbOne())) {
1974     CanAcceptCarrySet = true;
1975   } else {
1976     CanAcceptCarrySet = false;
1977   }
1978
1979   if (Mnemonic == "cbnz" || Mnemonic == "setend" || Mnemonic == "dmb" ||
1980       Mnemonic == "cps" || Mnemonic == "mcr2" || Mnemonic == "it" ||
1981       Mnemonic == "mcrr2" || Mnemonic == "cbz" || Mnemonic == "cdp2" ||
1982       Mnemonic == "trap" || Mnemonic == "mrc2" || Mnemonic == "mrrc2" ||
1983       Mnemonic == "dsb" || Mnemonic == "movs" || Mnemonic == "isb" ||
1984       Mnemonic == "clrex" || Mnemonic.startswith("cps")) {
1985     CanAcceptPredicationCode = false;
1986   } else {
1987     CanAcceptPredicationCode = true;
1988   }
1989
1990   if (isThumb())
1991     if (Mnemonic == "bkpt" || Mnemonic == "mcr" || Mnemonic == "mcrr" ||
1992         Mnemonic == "mrc" || Mnemonic == "mrrc" || Mnemonic == "cdp")
1993       CanAcceptPredicationCode = false;
1994 }
1995
1996 /// Parse an arm instruction mnemonic followed by its operands.
1997 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
1998                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
1999   // Create the leading tokens for the mnemonic, split by '.' characters.
2000   size_t Start = 0, Next = Name.find('.');
2001   StringRef Head = Name.slice(Start, Next);
2002
2003   // Split out the predication code and carry setting flag from the mnemonic.
2004   unsigned PredicationCode;
2005   unsigned ProcessorIMod;
2006   bool CarrySetting;
2007   Head = SplitMnemonic(Head, PredicationCode, CarrySetting,
2008                        ProcessorIMod);
2009
2010   Operands.push_back(ARMOperand::CreateToken(Head, NameLoc));
2011
2012   // Next, add the CCOut and ConditionCode operands, if needed.
2013   //
2014   // For mnemonics which can ever incorporate a carry setting bit or predication
2015   // code, our matching model involves us always generating CCOut and
2016   // ConditionCode operands to match the mnemonic "as written" and then we let
2017   // the matcher deal with finding the right instruction or generating an
2018   // appropriate error.
2019   bool CanAcceptCarrySet, CanAcceptPredicationCode;
2020   GetMnemonicAcceptInfo(Head, CanAcceptCarrySet, CanAcceptPredicationCode);
2021
2022   // Add the carry setting operand, if necessary.
2023   //
2024   // FIXME: It would be awesome if we could somehow invent a location such that
2025   // match errors on this operand would print a nice diagnostic about how the
2026   // 's' character in the mnemonic resulted in a CCOut operand.
2027   if (CanAcceptCarrySet) {
2028     Operands.push_back(ARMOperand::CreateCCOut(CarrySetting ? ARM::CPSR : 0,
2029                                                NameLoc));
2030   } else {
2031     // This mnemonic can't ever accept a carry set, but the user wrote one (or
2032     // misspelled another mnemonic).
2033
2034     // FIXME: Issue a nice error.
2035   }
2036
2037   // Add the predication code operand, if necessary.
2038   if (CanAcceptPredicationCode) {
2039     Operands.push_back(ARMOperand::CreateCondCode(
2040                          ARMCC::CondCodes(PredicationCode), NameLoc));
2041   } else {
2042     // This mnemonic can't ever accept a predication code, but the user wrote
2043     // one (or misspelled another mnemonic).
2044
2045     // FIXME: Issue a nice error.
2046   }
2047
2048   // Add the processor imod operand, if necessary.
2049   if (ProcessorIMod) {
2050     Operands.push_back(ARMOperand::CreateImm(
2051           MCConstantExpr::Create(ProcessorIMod, getContext()),
2052                                  NameLoc, NameLoc));
2053   } else {
2054     // This mnemonic can't ever accept a imod, but the user wrote
2055     // one (or misspelled another mnemonic).
2056
2057     // FIXME: Issue a nice error.
2058   }
2059
2060   // Add the remaining tokens in the mnemonic.
2061   while (Next != StringRef::npos) {
2062     Start = Next;
2063     Next = Name.find('.', Start + 1);
2064     StringRef ExtraToken = Name.slice(Start, Next);
2065
2066     Operands.push_back(ARMOperand::CreateToken(ExtraToken, NameLoc));
2067   }
2068
2069   // Read the remaining operands.
2070   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2071     // Read the first operand.
2072     if (ParseOperand(Operands, Head)) {
2073       Parser.EatToEndOfStatement();
2074       return true;
2075     }
2076
2077     while (getLexer().is(AsmToken::Comma)) {
2078       Parser.Lex();  // Eat the comma.
2079
2080       // Parse and remember the operand.
2081       if (ParseOperand(Operands, Head)) {
2082         Parser.EatToEndOfStatement();
2083         return true;
2084       }
2085     }
2086   }
2087
2088   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2089     Parser.EatToEndOfStatement();
2090     return TokError("unexpected token in argument list");
2091   }
2092
2093   Parser.Lex(); // Consume the EndOfStatement
2094   return false;
2095 }
2096
2097 bool ARMAsmParser::
2098 MatchAndEmitInstruction(SMLoc IDLoc,
2099                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
2100                         MCStreamer &Out) {
2101   MCInst Inst;
2102   unsigned ErrorInfo;
2103   MatchResultTy MatchResult, MatchResult2;
2104   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo);
2105   if (MatchResult != Match_Success) {
2106     // If we get a Match_InvalidOperand it might be some arithmetic instruction
2107     // that does not update the condition codes.  So try adding a CCOut operand
2108     // with a value of reg0.
2109     if (MatchResult == Match_InvalidOperand) {
2110       Operands.insert(Operands.begin() + 1,
2111                       ARMOperand::CreateCCOut(0,
2112                                   ((ARMOperand*)Operands[0])->getStartLoc()));
2113       MatchResult2 = MatchInstructionImpl(Operands, Inst, ErrorInfo);
2114       if (MatchResult2 == Match_Success)
2115         MatchResult = Match_Success;
2116       else {
2117         ARMOperand *CCOut = ((ARMOperand*)Operands[1]);
2118         Operands.erase(Operands.begin() + 1);
2119         delete CCOut;
2120       }
2121     }
2122     // If we get a Match_MnemonicFail it might be some arithmetic instruction
2123     // that updates the condition codes if it ends in 's'.  So see if the
2124     // mnemonic ends in 's' and if so try removing the 's' and adding a CCOut
2125     // operand with a value of CPSR.
2126     else if (MatchResult == Match_MnemonicFail) {
2127       // Get the instruction mnemonic, which is the first token.
2128       StringRef Mnemonic = ((ARMOperand*)Operands[0])->getToken();
2129       if (Mnemonic.substr(Mnemonic.size()-1) == "s") {
2130         // removed the 's' from the mnemonic for matching.
2131         StringRef MnemonicNoS = Mnemonic.slice(0, Mnemonic.size() - 1);
2132         SMLoc NameLoc = ((ARMOperand*)Operands[0])->getStartLoc();
2133         ARMOperand *OldMnemonic = ((ARMOperand*)Operands[0]);
2134         Operands.erase(Operands.begin());
2135         delete OldMnemonic;
2136         Operands.insert(Operands.begin(),
2137                         ARMOperand::CreateToken(MnemonicNoS, NameLoc));
2138         Operands.insert(Operands.begin() + 1,
2139                         ARMOperand::CreateCCOut(ARM::CPSR, NameLoc));
2140         MatchResult2 = MatchInstructionImpl(Operands, Inst, ErrorInfo);
2141         if (MatchResult2 == Match_Success)
2142           MatchResult = Match_Success;
2143         else {
2144           ARMOperand *OldMnemonic = ((ARMOperand*)Operands[0]);
2145           Operands.erase(Operands.begin());
2146           delete OldMnemonic;
2147           Operands.insert(Operands.begin(),
2148                           ARMOperand::CreateToken(Mnemonic, NameLoc));
2149           ARMOperand *CCOut = ((ARMOperand*)Operands[1]);
2150           Operands.erase(Operands.begin() + 1);
2151           delete CCOut;
2152         }
2153       }
2154     }
2155   }
2156   switch (MatchResult) {
2157   case Match_Success:
2158     Out.EmitInstruction(Inst);
2159     return false;
2160   case Match_MissingFeature:
2161     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
2162     return true;
2163   case Match_InvalidOperand: {
2164     SMLoc ErrorLoc = IDLoc;
2165     if (ErrorInfo != ~0U) {
2166       if (ErrorInfo >= Operands.size())
2167         return Error(IDLoc, "too few operands for instruction");
2168
2169       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
2170       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
2171     }
2172
2173     return Error(ErrorLoc, "invalid operand for instruction");
2174   }
2175   case Match_MnemonicFail:
2176     return Error(IDLoc, "unrecognized instruction mnemonic");
2177   case Match_ConversionFail:
2178     return Error(IDLoc, "unable to convert operands to instruction");
2179   }
2180
2181   llvm_unreachable("Implement any new match types added!");
2182   return true;
2183 }
2184
2185 /// ParseDirective parses the arm specific directives
2186 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
2187   StringRef IDVal = DirectiveID.getIdentifier();
2188   if (IDVal == ".word")
2189     return ParseDirectiveWord(4, DirectiveID.getLoc());
2190   else if (IDVal == ".thumb")
2191     return ParseDirectiveThumb(DirectiveID.getLoc());
2192   else if (IDVal == ".thumb_func")
2193     return ParseDirectiveThumbFunc(DirectiveID.getLoc());
2194   else if (IDVal == ".code")
2195     return ParseDirectiveCode(DirectiveID.getLoc());
2196   else if (IDVal == ".syntax")
2197     return ParseDirectiveSyntax(DirectiveID.getLoc());
2198   return true;
2199 }
2200
2201 /// ParseDirectiveWord
2202 ///  ::= .word [ expression (, expression)* ]
2203 bool ARMAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
2204   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2205     for (;;) {
2206       const MCExpr *Value;
2207       if (getParser().ParseExpression(Value))
2208         return true;
2209
2210       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
2211
2212       if (getLexer().is(AsmToken::EndOfStatement))
2213         break;
2214
2215       // FIXME: Improve diagnostic.
2216       if (getLexer().isNot(AsmToken::Comma))
2217         return Error(L, "unexpected token in directive");
2218       Parser.Lex();
2219     }
2220   }
2221
2222   Parser.Lex();
2223   return false;
2224 }
2225
2226 /// ParseDirectiveThumb
2227 ///  ::= .thumb
2228 bool ARMAsmParser::ParseDirectiveThumb(SMLoc L) {
2229   if (getLexer().isNot(AsmToken::EndOfStatement))
2230     return Error(L, "unexpected token in directive");
2231   Parser.Lex();
2232
2233   // TODO: set thumb mode
2234   // TODO: tell the MC streamer the mode
2235   // getParser().getStreamer().Emit???();
2236   return false;
2237 }
2238
2239 /// ParseDirectiveThumbFunc
2240 ///  ::= .thumbfunc symbol_name
2241 bool ARMAsmParser::ParseDirectiveThumbFunc(SMLoc L) {
2242   const MCAsmInfo &MAI = getParser().getStreamer().getContext().getAsmInfo();
2243   bool isMachO = MAI.hasSubsectionsViaSymbols();
2244   StringRef Name;
2245
2246   // Darwin asm has function name after .thumb_func direction
2247   // ELF doesn't
2248   if (isMachO) {
2249     const AsmToken &Tok = Parser.getTok();
2250     if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
2251       return Error(L, "unexpected token in .thumb_func directive");
2252     Name = Tok.getString();
2253     Parser.Lex(); // Consume the identifier token.
2254   }
2255
2256   if (getLexer().isNot(AsmToken::EndOfStatement))
2257     return Error(L, "unexpected token in directive");
2258   Parser.Lex();
2259
2260   // FIXME: assuming function name will be the line following .thumb_func
2261   if (!isMachO) {
2262     Name = Parser.getTok().getString();
2263   }
2264
2265   // Mark symbol as a thumb symbol.
2266   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
2267   getParser().getStreamer().EmitThumbFunc(Func);
2268   return false;
2269 }
2270
2271 /// ParseDirectiveSyntax
2272 ///  ::= .syntax unified | divided
2273 bool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) {
2274   const AsmToken &Tok = Parser.getTok();
2275   if (Tok.isNot(AsmToken::Identifier))
2276     return Error(L, "unexpected token in .syntax directive");
2277   StringRef Mode = Tok.getString();
2278   if (Mode == "unified" || Mode == "UNIFIED")
2279     Parser.Lex();
2280   else if (Mode == "divided" || Mode == "DIVIDED")
2281     return Error(L, "'.syntax divided' arm asssembly not supported");
2282   else
2283     return Error(L, "unrecognized syntax mode in .syntax directive");
2284
2285   if (getLexer().isNot(AsmToken::EndOfStatement))
2286     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
2287   Parser.Lex();
2288
2289   // TODO tell the MC streamer the mode
2290   // getParser().getStreamer().Emit???();
2291   return false;
2292 }
2293
2294 /// ParseDirectiveCode
2295 ///  ::= .code 16 | 32
2296 bool ARMAsmParser::ParseDirectiveCode(SMLoc L) {
2297   const AsmToken &Tok = Parser.getTok();
2298   if (Tok.isNot(AsmToken::Integer))
2299     return Error(L, "unexpected token in .code directive");
2300   int64_t Val = Parser.getTok().getIntVal();
2301   if (Val == 16)
2302     Parser.Lex();
2303   else if (Val == 32)
2304     Parser.Lex();
2305   else
2306     return Error(L, "invalid operand to .code directive");
2307
2308   if (getLexer().isNot(AsmToken::EndOfStatement))
2309     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
2310   Parser.Lex();
2311
2312   if (Val == 16) {
2313     if (!isThumb())
2314       SwitchMode();
2315     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
2316   } else {
2317     if (isThumb())
2318       SwitchMode();
2319     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
2320   }
2321
2322   return false;
2323 }
2324
2325 extern "C" void LLVMInitializeARMAsmLexer();
2326
2327 /// Force static initialization.
2328 extern "C" void LLVMInitializeARMAsmParser() {
2329   RegisterAsmParser<ARMAsmParser> X(TheARMTarget);
2330   RegisterAsmParser<ARMAsmParser> Y(TheThumbTarget);
2331   LLVMInitializeARMAsmLexer();
2332 }
2333
2334 #define GET_REGISTER_MATCHER
2335 #define GET_MATCHER_IMPLEMENTATION
2336 #include "ARMGenAsmMatcher.inc"