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