lib/Target/ARM/AsmParser/ARMAsmParser.cpp

   1 //===-- ARMAsmParser.cpp - Parse ARM assembly to MCInst instructions ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ARM.h"
  11 #include "ARMAddressingModes.h"
  12 #include "ARMSubtarget.h"
  13 #include "llvm/MC/MCParser/MCAsmLexer.h"
  14 #include "llvm/MC/MCParser/MCAsmParser.h"
  15 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCStreamer.h"
  18 #include "llvm/MC/MCExpr.h"
  19 #include "llvm/MC/MCInst.h"
  20 #include "llvm/Target/TargetRegistry.h"
  21 #include "llvm/Target/TargetAsmParser.h"
  22 #include "llvm/Support/SourceMgr.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/ADT/SmallVector.h"
  25 #include "llvm/ADT/StringSwitch.h"
  26 #include "llvm/ADT/Twine.h"
  27 using namespace llvm;
  28
  29 // The shift types for register controlled shifts in arm memory addressing
  30 enum ShiftType {
  31   Lsl,
  32   Lsr,
  33   Asr,
  34   Ror,
  35   Rrx
  36 };
  37
  38 namespace {
  39
  40 class ARMOperand;
  41
  42 class ARMAsmParser : public TargetAsmParser {
  43   MCAsmParser &Parser;
  44   TargetMachine &TM;
  45
  46   MCAsmParser &getParser() const { return Parser; }
  47   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  48
  49   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  50   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  51
  52   int TryParseRegister();
  53   ARMOperand *TryParseRegisterWithWriteBack();
  54   ARMOperand *ParseRegisterList();
  55   ARMOperand *ParseMemory();
  56   ARMOperand *ParseOperand();
  57
  58   bool ParseMemoryOffsetReg(bool &Negative,
  59                             bool &OffsetRegShifted,
  60                             enum ShiftType &ShiftType,
  61                             const MCExpr *&ShiftAmount,
  62                             const MCExpr *&Offset,
  63                             bool &OffsetIsReg,
  64                             int &OffsetRegNum,
  65                             SMLoc &E);
  66   bool ParseShift(enum ShiftType &St, const MCExpr *&ShiftAmount, SMLoc &E);
  67   bool ParseDirectiveWord(unsigned Size, SMLoc L);
  68   bool ParseDirectiveThumb(SMLoc L);
  69   bool ParseDirectiveThumbFunc(SMLoc L);
  70   bool ParseDirectiveCode(SMLoc L);
  71   bool ParseDirectiveSyntax(SMLoc L);
  72
  73   bool MatchAndEmitInstruction(SMLoc IDLoc,
  74                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
  75                                MCStreamer &Out);
  76
  77   /// @name Auto-generated Match Functions
  78   /// {
  79
  80 #define GET_ASSEMBLER_HEADER
  81 #include "ARMGenAsmMatcher.inc"
  82
  83   /// }
  84
  85 public:
  86   ARMAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &_TM)
  87     : TargetAsmParser(T), Parser(_Parser), TM(_TM) {
  88       // Initialize the set of available features.
  89       setAvailableFeatures(ComputeAvailableFeatures(
  90           &TM.getSubtarget<ARMSubtarget>()));
  91     }
  92
  93   virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
  94                                 SmallVectorImpl<MCParsedAsmOperand*> &Operands);
  95   virtual bool ParseDirective(AsmToken DirectiveID);
  96 };
  97 } // end anonymous namespace
  98
  99 namespace {
 100
 101 /// ARMOperand - Instances of this class represent a parsed ARM machine
 102 /// instruction.
 103 class ARMOperand : public MCParsedAsmOperand {
 104   enum KindTy {
 105     CondCode,
 106     Immediate,
 107     Memory,
 108     Register,
 109     RegisterList,
 110     DPRRegisterList,
 111     SPRRegisterList,
 112     Token
 113   } Kind;
 114
 115   SMLoc StartLoc, EndLoc;
 116
 117   union {
 118     struct {
 119       ARMCC::CondCodes Val;
 120     } CC;
 121
 122     struct {
 123       const char *Data;
 124       unsigned Length;
 125     } Tok;
 126
 127     struct {
 128       unsigned RegNum;
 129       bool Writeback;
 130     } Reg;
 131
 132     struct {
 133       SmallVector<unsigned, 32> *Registers;
 134     } RegList;
 135
 136     struct {
 137       const MCExpr *Val;
 138     } Imm;
 139
 140     // This is for all forms of ARM address expressions
 141     struct {
 142       unsigned BaseRegNum;
 143       unsigned OffsetRegNum;         // used when OffsetIsReg is true
 144       const MCExpr *Offset;          // used when OffsetIsReg is false
 145       const MCExpr *ShiftAmount;     // used when OffsetRegShifted is true
 146       enum ShiftType ShiftType;      // used when OffsetRegShifted is true
 147       unsigned OffsetRegShifted : 1; // only used when OffsetIsReg is true
 148       unsigned Preindexed : 1;
 149       unsigned Postindexed : 1;
 150       unsigned OffsetIsReg : 1;
 151       unsigned Negative : 1;         // only used when OffsetIsReg is true
 152       unsigned Writeback : 1;
 153     } Mem;
 154   };
 155
 156   ARMOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 157 public:
 158   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 159     Kind = o.Kind;
 160     StartLoc = o.StartLoc;
 161     EndLoc = o.EndLoc;
 162     switch (Kind) {
 163     case CondCode:
 164       CC = o.CC;
 165       break;
 166     case Token:
 167       Tok = o.Tok;
 168       break;
 169     case Register:
 170       Reg = o.Reg;
 171       break;
 172     case RegisterList:
 173     case DPRRegisterList:
 174     case SPRRegisterList:
 175       RegList = o.RegList;
 176       break;
 177     case Immediate:
 178       Imm = o.Imm;
 179       break;
 180     case Memory:
 181       Mem = o.Mem;
 182       break;
 183     }
 184   }
 185   ~ARMOperand() {
 186     if (isRegList())
 187       delete RegList.Registers;
 188   }
 189
 190   /// getStartLoc - Get the location of the first token of this operand.
 191   SMLoc getStartLoc() const { return StartLoc; }
 192   /// getEndLoc - Get the location of the last token of this operand.
 193   SMLoc getEndLoc() const { return EndLoc; }
 194
 195   ARMCC::CondCodes getCondCode() const {
 196     assert(Kind == CondCode && "Invalid access!");
 197     return CC.Val;
 198   }
 199
 200   StringRef getToken() const {
 201     assert(Kind == Token && "Invalid access!");
 202     return StringRef(Tok.Data, Tok.Length);
 203   }
 204
 205   unsigned getReg() const {
 206     assert(Kind == Register && "Invalid access!");
 207     return Reg.RegNum;
 208   }
 209
 210   const SmallVectorImpl<unsigned> &getRegList() const {
 211     assert((Kind == RegisterList || Kind == DPRRegisterList ||
 212             Kind == SPRRegisterList) && "Invalid access!");
 213     return *RegList.Registers;
 214   }
 215
 216   const MCExpr *getImm() const {
 217     assert(Kind == Immediate && "Invalid access!");
 218     return Imm.Val;
 219   }
 220
 221   bool isCondCode() const { return Kind == CondCode; }
 222   bool isImm() const { return Kind == Immediate; }
 223   bool isReg() const { return Kind == Register; }
 224   bool isRegList() const { return Kind == RegisterList; }
 225   bool isDPRRegList() const { return Kind == DPRRegisterList; }
 226   bool isSPRRegList() const { return Kind == SPRRegisterList; }
 227   bool isToken() const { return Kind == Token; }
 228   bool isMemory() const { return Kind == Memory; }
 229   bool isMemMode5() const {
 230     if (!isMemory() || Mem.OffsetIsReg || Mem.OffsetRegShifted ||
 231         Mem.Writeback || Mem.Negative)
 232       return false;
 233     // If there is an offset expression, make sure it's valid.
 234     if (!Mem.Offset)
 235       return true;
 236     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Mem.Offset);
 237     if (!CE)
 238       return false;
 239     // The offset must be a multiple of 4 in the range 0-1020.
 240     int64_t Value = CE->getValue();
 241     return ((Value & 0x3) == 0 && Value <= 1020 && Value >= -1020);
 242   }
 243
 244   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 245     // Add as immediates when possible.  Null MCExpr = 0.
 246     if (Expr == 0)
 247       Inst.addOperand(MCOperand::CreateImm(0));
 248     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 249       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 250     else
 251       Inst.addOperand(MCOperand::CreateExpr(Expr));
 252   }
 253
 254   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 255     assert(N == 2 && "Invalid number of operands!");
 256     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 257     // FIXME: What belongs here?
 258     Inst.addOperand(MCOperand::CreateReg(0));
 259   }
 260
 261   void addRegOperands(MCInst &Inst, unsigned N) const {
 262     assert(N == 1 && "Invalid number of operands!");
 263     Inst.addOperand(MCOperand::CreateReg(getReg()));
 264   }
 265
 266   void addRegListOperands(MCInst &Inst, unsigned N) const {
 267     assert(N == 1 && "Invalid number of operands!");
 268     const SmallVectorImpl<unsigned> &RegList = getRegList();
 269     for (SmallVectorImpl<unsigned>::const_iterator
 270            I = RegList.begin(), E = RegList.end(); I != E; ++I)
 271       Inst.addOperand(MCOperand::CreateReg(*I));
 272   }
 273
 274   void addDPRRegListOperands(MCInst &Inst, unsigned N) const {
 275     addRegListOperands(Inst, N);
 276   }
 277
 278   void addSPRRegListOperands(MCInst &Inst, unsigned N) const {
 279     addRegListOperands(Inst, N);
 280   }
 281
 282   void addImmOperands(MCInst &Inst, unsigned N) const {
 283     assert(N == 1 && "Invalid number of operands!");
 284     addExpr(Inst, getImm());
 285   }
 286
 287   void addMemMode5Operands(MCInst &Inst, unsigned N) const {
 288     assert(N == 2 && isMemMode5() && "Invalid number of operands!");
 289
 290     Inst.addOperand(MCOperand::CreateReg(Mem.BaseRegNum));
 291     assert(!Mem.OffsetIsReg && "Invalid mode 5 operand");
 292
 293     // FIXME: #-0 is encoded differently than #0. Does the parser preserve
 294     // the difference?
 295     if (Mem.Offset) {
 296       const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Mem.Offset);
 297       assert(CE && "Non-constant mode 5 offset operand!");
 298
 299       // The MCInst offset operand doesn't include the low two bits (like
 300       // the instruction encoding).
 301       int64_t Offset = CE->getValue() / 4;
 302       if (Offset >= 0)
 303         Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add,
 304                                                                Offset)));
 305       else
 306         Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub,
 307                                                                -Offset)));
 308     } else {
 309       Inst.addOperand(MCOperand::CreateImm(0));
 310     }
 311   }
 312
 313   virtual void dump(raw_ostream &OS) const;
 314
 315   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
 316     ARMOperand *Op = new ARMOperand(CondCode);
 317     Op->CC.Val = CC;
 318     Op->StartLoc = S;
 319     Op->EndLoc = S;
 320     return Op;
 321   }
 322
 323   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
 324     ARMOperand *Op = new ARMOperand(Token);
 325     Op->Tok.Data = Str.data();
 326     Op->Tok.Length = Str.size();
 327     Op->StartLoc = S;
 328     Op->EndLoc = S;
 329     return Op;
 330   }
 331
 332   static ARMOperand *CreateReg(unsigned RegNum, bool Writeback, SMLoc S,
 333                                SMLoc E) {
 334     ARMOperand *Op = new ARMOperand(Register);
 335     Op->Reg.RegNum = RegNum;
 336     Op->Reg.Writeback = Writeback;
 337     Op->StartLoc = S;
 338     Op->EndLoc = E;
 339     return Op;
 340   }
 341
 342   static ARMOperand *
 343   CreateRegList(const SmallVectorImpl<std::pair<unsigned, SMLoc> > &Regs,
 344                 SMLoc StartLoc, SMLoc EndLoc) {
 345     KindTy Kind = RegisterList;
 346
 347     if (ARM::DPRRegClass.contains(Regs.front().first))
 348       Kind = DPRRegisterList;
 349     else if (ARM::SPRRegClass.contains(Regs.front().first))
 350       Kind = SPRRegisterList;
 351
 352     ARMOperand *Op = new ARMOperand(Kind);
 353     Op->RegList.Registers = new SmallVector<unsigned, 32>();
 354     for (SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
 355            I = Regs.begin(), E = Regs.end(); I != E; ++I)
 356       Op->RegList.Registers->push_back(I->first);
 357     std::sort(Op->RegList.Registers->begin(), Op->RegList.Registers->end());
 358     Op->StartLoc = StartLoc;
 359     Op->EndLoc = EndLoc;
 360     return Op;
 361   }
 362
 363   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
 364     ARMOperand *Op = new ARMOperand(Immediate);
 365     Op->Imm.Val = Val;
 366     Op->StartLoc = S;
 367     Op->EndLoc = E;
 368     return Op;
 369   }
 370
 371   static ARMOperand *CreateMem(unsigned BaseRegNum, bool OffsetIsReg,
 372                                const MCExpr *Offset, unsigned OffsetRegNum,
 373                                bool OffsetRegShifted, enum ShiftType ShiftType,
 374                                const MCExpr *ShiftAmount, bool Preindexed,
 375                                bool Postindexed, bool Negative, bool Writeback,
 376                                SMLoc S, SMLoc E) {
 377     ARMOperand *Op = new ARMOperand(Memory);
 378     Op->Mem.BaseRegNum = BaseRegNum;
 379     Op->Mem.OffsetIsReg = OffsetIsReg;
 380     Op->Mem.Offset = Offset;
 381     Op->Mem.OffsetRegNum = OffsetRegNum;
 382     Op->Mem.OffsetRegShifted = OffsetRegShifted;
 383     Op->Mem.ShiftType = ShiftType;
 384     Op->Mem.ShiftAmount = ShiftAmount;
 385     Op->Mem.Preindexed = Preindexed;
 386     Op->Mem.Postindexed = Postindexed;
 387     Op->Mem.Negative = Negative;
 388     Op->Mem.Writeback = Writeback;
 389
 390     Op->StartLoc = S;
 391     Op->EndLoc = E;
 392     return Op;
 393   }
 394 };
 395
 396 } // end anonymous namespace.
 397
 398 void ARMOperand::dump(raw_ostream &OS) const {
 399   switch (Kind) {
 400   case CondCode:
 401     OS << ARMCondCodeToString(getCondCode());
 402     break;
 403   case Immediate:
 404     getImm()->print(OS);
 405     break;
 406   case Memory:
 407     OS << "<memory" << (!Mem.Writeback ? ">" : "!>");
 408     break;
 409   case Register:
 410     OS << "<register " << getReg() << (!Reg.Writeback ? ">" : "!>");
 411     break;
 412   case RegisterList:
 413   case DPRRegisterList:
 414   case SPRRegisterList: {
 415     OS << "<register_list ";
 416
 417     const SmallVectorImpl<unsigned> &RegList = getRegList();
 418     for (SmallVectorImpl<unsigned>::const_iterator
 419            I = RegList.begin(), E = RegList.end(); I != E; ) {
 420       OS << *I;
 421       if (++I < E) OS << ", ";
 422     }
 423
 424     OS << ">";
 425     break;
 426   }
 427   case Token:
 428     OS << "'" << getToken() << "'";
 429     break;
 430   }
 431 }
 432
 433 /// @name Auto-generated Match Functions
 434 /// {
 435
 436 static unsigned MatchRegisterName(StringRef Name);
 437
 438 /// }
 439
 440 /// Try to parse a register name.  The token must be an Identifier when called,
 441 /// and if it is a register name the token is eaten and the register number is
 442 /// returned.  Otherwise return -1.
 443 ///
 444 int ARMAsmParser::TryParseRegister() {
 445   const AsmToken &Tok = Parser.getTok();
 446   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
 447
 448   // FIXME: Validate register for the current architecture; we have to do
 449   // validation later, so maybe there is no need for this here.
 450   unsigned RegNum = MatchRegisterName(Tok.getString());
 451   if (RegNum == 0)
 452     return -1;
 453   Parser.Lex(); // Eat identifier token.
 454   return RegNum;
 455 }
 456
 457
 458 /// Try to parse a register name.  The token must be an Identifier when called,
 459 /// and if it is a register name the token is eaten and the register number is
 460 /// returned.  Otherwise return -1.
 461 ///
 462 /// TODO this is likely to change to allow different register types and or to
 463 /// parse for a specific register type.
 464 ARMOperand *ARMAsmParser::TryParseRegisterWithWriteBack() {
 465   SMLoc S = Parser.getTok().getLoc();
 466   int RegNo = TryParseRegister();
 467   if (RegNo == -1)
 468     return 0;
 469
 470   SMLoc E = Parser.getTok().getLoc();
 471
 472   bool Writeback = false;
 473   const AsmToken &ExclaimTok = Parser.getTok();
 474   if (ExclaimTok.is(AsmToken::Exclaim)) {
 475     E = ExclaimTok.getLoc();
 476     Writeback = true;
 477     Parser.Lex(); // Eat exclaim token
 478   }
 479
 480   return ARMOperand::CreateReg(RegNo, Writeback, S, E);
 481 }
 482
 483 /// Parse a register list, return it if successful else return null.  The first
 484 /// token must be a '{' when called.
 485 ARMOperand *ARMAsmParser::ParseRegisterList() {
 486   assert(Parser.getTok().is(AsmToken::LCurly) &&
 487          "Token is not a Left Curly Brace");
 488   SMLoc S = Parser.getTok().getLoc();
 489
 490   // Read the rest of the registers in the list.
 491   unsigned PrevRegNum = 0;
 492   SmallVector<std::pair<unsigned, SMLoc>, 32> Registers;
 493
 494   do {
 495     bool IsRange = Parser.getTok().is(AsmToken::Minus);
 496     Parser.Lex(); // Eat non-identifier token.
 497
 498     const AsmToken &RegTok = Parser.getTok();
 499     SMLoc RegLoc = RegTok.getLoc();
 500     if (RegTok.isNot(AsmToken::Identifier)) {
 501       Error(RegLoc, "register expected");
 502       return 0;
 503     }
 504
 505     int RegNum = TryParseRegister();
 506     if (RegNum == -1) {
 507       Error(RegLoc, "register expected");
 508       return 0;
 509     }
 510
 511     if (IsRange) {
 512       int Reg = PrevRegNum;
 513       do {
 514         ++Reg;
 515         Registers.push_back(std::make_pair(Reg, RegLoc));
 516       } while (Reg != RegNum);
 517     } else {
 518       Registers.push_back(std::make_pair(RegNum, RegLoc));
 519     }
 520
 521     PrevRegNum = RegNum;
 522   } while (Parser.getTok().is(AsmToken::Comma) ||
 523            Parser.getTok().is(AsmToken::Minus));
 524
 525   // Process the right curly brace of the list.
 526   const AsmToken &RCurlyTok = Parser.getTok();
 527   if (RCurlyTok.isNot(AsmToken::RCurly)) {
 528     Error(RCurlyTok.getLoc(), "'}' expected");
 529     return 0;
 530   }
 531
 532   SMLoc E = RCurlyTok.getLoc();
 533   Parser.Lex(); // Eat right curly brace token.
 534
 535   // Verify the register list.
 536   SmallVectorImpl<std::pair<unsigned, SMLoc> >::const_iterator
 537     RI = Registers.begin(), RE = Registers.end();
 538
 539   DenseMap<unsigned, bool> RegMap;
 540   RegMap[RI->first] = true;
 541
 542   unsigned HighRegNum = RI->first;
 543   bool EmittedWarning = false;
 544
 545   for (++RI; RI != RE; ++RI) {
 546     const std::pair<unsigned, SMLoc> &RegInfo = *RI;
 547     unsigned Reg = RegInfo.first;
 548
 549     if (RegMap[Reg]) {
 550       Error(RegInfo.second, "register duplicated in register list");
 551       return 0;
 552     }
 553
 554     if (!EmittedWarning && Reg < HighRegNum)
 555       Warning(RegInfo.second,
 556               "register not in ascending order in register list");
 557
 558     RegMap[Reg] = true;
 559     HighRegNum = std::max(Reg, HighRegNum);
 560   }
 561
 562   return ARMOperand::CreateRegList(Registers, S, E);
 563 }
 564
 565 /// Parse an ARM memory expression, return false if successful else return true
 566 /// or an error.  The first token must be a '[' when called.
 567 /// TODO Only preindexing and postindexing addressing are started, unindexed
 568 /// with option, etc are still to do.
 569 ARMOperand *ARMAsmParser::ParseMemory() {
 570   SMLoc S, E;
 571   assert(Parser.getTok().is(AsmToken::LBrac) &&
 572          "Token is not a Left Bracket");
 573   S = Parser.getTok().getLoc();
 574   Parser.Lex(); // Eat left bracket token.
 575
 576   const AsmToken &BaseRegTok = Parser.getTok();
 577   if (BaseRegTok.isNot(AsmToken::Identifier)) {
 578     Error(BaseRegTok.getLoc(), "register expected");
 579     return 0;
 580   }
 581   int BaseRegNum = TryParseRegister();
 582   if (BaseRegNum == -1) {
 583     Error(BaseRegTok.getLoc(), "register expected");
 584     return 0;
 585   }
 586
 587   bool Preindexed = false;
 588   bool Postindexed = false;
 589   bool OffsetIsReg = false;
 590   bool Negative = false;
 591   bool Writeback = false;
 592
 593   // First look for preindexed address forms, that is after the "[Rn" we now
 594   // have to see if the next token is a comma.
 595   const AsmToken &Tok = Parser.getTok();
 596   if (Tok.is(AsmToken::Comma)) {
 597     Preindexed = true;
 598     Parser.Lex(); // Eat comma token.
 599     int OffsetRegNum;
 600     bool OffsetRegShifted;
 601     enum ShiftType ShiftType;
 602     const MCExpr *ShiftAmount;
 603     const MCExpr *Offset;
 604     if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount,
 605                              Offset, OffsetIsReg, OffsetRegNum, E))
 606       return 0;
 607     const AsmToken &RBracTok = Parser.getTok();
 608     if (RBracTok.isNot(AsmToken::RBrac)) {
 609       Error(RBracTok.getLoc(), "']' expected");
 610       return 0;
 611     }
 612     E = RBracTok.getLoc();
 613     Parser.Lex(); // Eat right bracket token.
 614
 615     const AsmToken &ExclaimTok = Parser.getTok();
 616     if (ExclaimTok.is(AsmToken::Exclaim)) {
 617       E = ExclaimTok.getLoc();
 618       Writeback = true;
 619       Parser.Lex(); // Eat exclaim token
 620     }
 621     return ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum,
 622                                  OffsetRegShifted, ShiftType, ShiftAmount,
 623                                  Preindexed, Postindexed, Negative, Writeback,
 624                                  S, E);
 625   }
 626   // The "[Rn" we have so far was not followed by a comma.
 627   else if (Tok.is(AsmToken::RBrac)) {
 628     // If there's anything other than the right brace, this is a post indexing
 629     // addressing form.
 630     E = Tok.getLoc();
 631     Parser.Lex(); // Eat right bracket token.
 632
 633     int OffsetRegNum = 0;
 634     bool OffsetRegShifted = false;
 635     enum ShiftType ShiftType;
 636     const MCExpr *ShiftAmount;
 637     const MCExpr *Offset = 0;
 638
 639     const AsmToken &NextTok = Parser.getTok();
 640     if (NextTok.isNot(AsmToken::EndOfStatement)) {
 641       Postindexed = true;
 642       Writeback = true;
 643       if (NextTok.isNot(AsmToken::Comma)) {
 644         Error(NextTok.getLoc(), "',' expected");
 645         return 0;
 646       }
 647       Parser.Lex(); // Eat comma token.
 648       if (ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType,
 649                                ShiftAmount, Offset, OffsetIsReg, OffsetRegNum,
 650                                E))
 651         return 0;
 652     }
 653
 654     return ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum,
 655                                  OffsetRegShifted, ShiftType, ShiftAmount,
 656                                  Preindexed, Postindexed, Negative, Writeback,
 657                                  S, E);
 658   }
 659
 660   return 0;
 661 }
 662
 663 /// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn],"
 664 /// we will parse the following (were +/- means that a plus or minus is
 665 /// optional):
 666 ///   +/-Rm
 667 ///   +/-Rm, shift
 668 ///   #offset
 669 /// we return false on success or an error otherwise.
 670 bool ARMAsmParser::ParseMemoryOffsetReg(bool &Negative,
 671                                         bool &OffsetRegShifted,
 672                                         enum ShiftType &ShiftType,
 673                                         const MCExpr *&ShiftAmount,
 674                                         const MCExpr *&Offset,
 675                                         bool &OffsetIsReg,
 676                                         int &OffsetRegNum,
 677                                         SMLoc &E) {
 678   Negative = false;
 679   OffsetRegShifted = false;
 680   OffsetIsReg = false;
 681   OffsetRegNum = -1;
 682   const AsmToken &NextTok = Parser.getTok();
 683   E = NextTok.getLoc();
 684   if (NextTok.is(AsmToken::Plus))
 685     Parser.Lex(); // Eat plus token.
 686   else if (NextTok.is(AsmToken::Minus)) {
 687     Negative = true;
 688     Parser.Lex(); // Eat minus token
 689   }
 690   // See if there is a register following the "[Rn," or "[Rn]," we have so far.
 691   const AsmToken &OffsetRegTok = Parser.getTok();
 692   if (OffsetRegTok.is(AsmToken::Identifier)) {
 693     SMLoc CurLoc = OffsetRegTok.getLoc();
 694     OffsetRegNum = TryParseRegister();
 695     if (OffsetRegNum != -1) {
 696       OffsetIsReg = true;
 697       E = CurLoc;
 698     }
 699   }
 700
 701   // If we parsed a register as the offset then there can be a shift after that.
 702   if (OffsetRegNum != -1) {
 703     // Look for a comma then a shift
 704     const AsmToken &Tok = Parser.getTok();
 705     if (Tok.is(AsmToken::Comma)) {
 706       Parser.Lex(); // Eat comma token.
 707
 708       const AsmToken &Tok = Parser.getTok();
 709       if (ParseShift(ShiftType, ShiftAmount, E))
 710         return Error(Tok.getLoc(), "shift expected");
 711       OffsetRegShifted = true;
 712     }
 713   }
 714   else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm"
 715     // Look for #offset following the "[Rn," or "[Rn],"
 716     const AsmToken &HashTok = Parser.getTok();
 717     if (HashTok.isNot(AsmToken::Hash))
 718       return Error(HashTok.getLoc(), "'#' expected");
 719
 720     Parser.Lex(); // Eat hash token.
 721
 722     if (getParser().ParseExpression(Offset))
 723      return true;
 724     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 725   }
 726   return false;
 727 }
 728
 729 /// ParseShift as one of these two:
 730 ///   ( lsl | lsr | asr | ror ) , # shift_amount
 731 ///   rrx
 732 /// and returns true if it parses a shift otherwise it returns false.
 733 bool ARMAsmParser::ParseShift(ShiftType &St, const MCExpr *&ShiftAmount,
 734                               SMLoc &E) {
 735   const AsmToken &Tok = Parser.getTok();
 736   if (Tok.isNot(AsmToken::Identifier))
 737     return true;
 738   StringRef ShiftName = Tok.getString();
 739   if (ShiftName == "lsl" || ShiftName == "LSL")
 740     St = Lsl;
 741   else if (ShiftName == "lsr" || ShiftName == "LSR")
 742     St = Lsr;
 743   else if (ShiftName == "asr" || ShiftName == "ASR")
 744     St = Asr;
 745   else if (ShiftName == "ror" || ShiftName == "ROR")
 746     St = Ror;
 747   else if (ShiftName == "rrx" || ShiftName == "RRX")
 748     St = Rrx;
 749   else
 750     return true;
 751   Parser.Lex(); // Eat shift type token.
 752
 753   // Rrx stands alone.
 754   if (St == Rrx)
 755     return false;
 756
 757   // Otherwise, there must be a '#' and a shift amount.
 758   const AsmToken &HashTok = Parser.getTok();
 759   if (HashTok.isNot(AsmToken::Hash))
 760     return Error(HashTok.getLoc(), "'#' expected");
 761   Parser.Lex(); // Eat hash token.
 762
 763   if (getParser().ParseExpression(ShiftAmount))
 764     return true;
 765
 766   return false;
 767 }
 768
 769 /// Parse a arm instruction operand.  For now this parses the operand regardless
 770 /// of the mnemonic.
 771 ARMOperand *ARMAsmParser::ParseOperand() {
 772   SMLoc S, E;
 773   switch (getLexer().getKind()) {
 774   default:
 775     Error(Parser.getTok().getLoc(), "unexpected token in operand");
 776     return 0;
 777   case AsmToken::Identifier:
 778     if (ARMOperand *Op = TryParseRegisterWithWriteBack())
 779       return Op;
 780
 781     // This was not a register so parse other operands that start with an
 782     // identifier (like labels) as expressions and create them as immediates.
 783     const MCExpr *IdVal;
 784     S = Parser.getTok().getLoc();
 785     if (getParser().ParseExpression(IdVal))
 786       return 0;
 787     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 788     return ARMOperand::CreateImm(IdVal, S, E);
 789   case AsmToken::LBrac:
 790     return ParseMemory();
 791   case AsmToken::LCurly:
 792     return ParseRegisterList();
 793   case AsmToken::Hash:
 794     // #42 -> immediate.
 795     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
 796     S = Parser.getTok().getLoc();
 797     Parser.Lex();
 798     const MCExpr *ImmVal;
 799     if (getParser().ParseExpression(ImmVal))
 800       return 0;
 801     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 802     return ARMOperand::CreateImm(ImmVal, S, E);
 803   }
 804 }
 805
 806 /// Parse an arm instruction mnemonic followed by its operands.
 807 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
 808                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
 809   // Create the leading tokens for the mnemonic, split by '.' characters.
 810   size_t Start = 0, Next = Name.find('.');
 811   StringRef Head = Name.slice(Start, Next);
 812
 813   // Determine the predicate, if any.
 814   //
 815   // FIXME: We need a way to check whether a prefix supports predication,
 816   // otherwise we will end up with an ambiguity for instructions that happen to
 817   // end with a predicate name.
 818   // FIXME: Likewise, some arithmetic instructions have an 's' prefix which
 819   // indicates to update the condition codes. Those instructions have an
 820   // additional immediate operand which encodes the prefix as reg0 or CPSR.
 821   // Just checking for a suffix of 's' definitely creates ambiguities; e.g,
 822   // the SMMLS instruction.
 823   unsigned CC = StringSwitch<unsigned>(Head.substr(Head.size()-2))
 824     .Case("eq", ARMCC::EQ)
 825     .Case("ne", ARMCC::NE)
 826     .Case("hs", ARMCC::HS)
 827     .Case("lo", ARMCC::LO)
 828     .Case("mi", ARMCC::MI)
 829     .Case("pl", ARMCC::PL)
 830     .Case("vs", ARMCC::VS)
 831     .Case("vc", ARMCC::VC)
 832     .Case("hi", ARMCC::HI)
 833     .Case("ls", ARMCC::LS)
 834     .Case("ge", ARMCC::GE)
 835     .Case("lt", ARMCC::LT)
 836     .Case("gt", ARMCC::GT)
 837     .Case("le", ARMCC::LE)
 838     .Case("al", ARMCC::AL)
 839     .Default(~0U);
 840
 841   if (CC == ~0U ||
 842       (CC == ARMCC::LS && (Head == "vmls" || Head == "vnmls"))) {
 843     CC = ARMCC::AL;
 844   } else {
 845     Head = Head.slice(0, Head.size() - 2);
 846   }
 847
 848   Operands.push_back(ARMOperand::CreateToken(Head, NameLoc));
 849   // FIXME: Should only add this operand for predicated instructions
 850   Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), NameLoc));
 851
 852   // Add the remaining tokens in the mnemonic.
 853   while (Next != StringRef::npos) {
 854     Start = Next;
 855     Next = Name.find('.', Start + 1);
 856     Head = Name.slice(Start, Next);
 857
 858     Operands.push_back(ARMOperand::CreateToken(Head, NameLoc));
 859   }
 860
 861   // Read the remaining operands.
 862   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 863     // Read the first operand.
 864     if (ARMOperand *Op = ParseOperand())
 865       Operands.push_back(Op);
 866     else {
 867       Parser.EatToEndOfStatement();
 868       return true;
 869     }
 870
 871     while (getLexer().is(AsmToken::Comma)) {
 872       Parser.Lex();  // Eat the comma.
 873
 874       // Parse and remember the operand.
 875       if (ARMOperand *Op = ParseOperand())
 876         Operands.push_back(Op);
 877       else {
 878         Parser.EatToEndOfStatement();
 879         return true;
 880       }
 881     }
 882   }
 883
 884   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 885     Parser.EatToEndOfStatement();
 886     return TokError("unexpected token in argument list");
 887   }
 888
 889   Parser.Lex(); // Consume the EndOfStatement
 890   return false;
 891 }
 892
 893 bool ARMAsmParser::
 894 MatchAndEmitInstruction(SMLoc IDLoc,
 895                         SmallVectorImpl<MCParsedAsmOperand*> &Operands,
 896                         MCStreamer &Out) {
 897   MCInst Inst;
 898   unsigned ErrorInfo;
 899   switch (MatchInstructionImpl(Operands, Inst, ErrorInfo)) {
 900   case Match_Success:
 901     Out.EmitInstruction(Inst);
 902     return false;
 903   case Match_MissingFeature:
 904     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
 905     return true;
 906   case Match_InvalidOperand: {
 907     SMLoc ErrorLoc = IDLoc;
 908     if (ErrorInfo != ~0U) {
 909       if (ErrorInfo >= Operands.size())
 910         return Error(IDLoc, "too few operands for instruction");
 911
 912       ErrorLoc = ((ARMOperand*)Operands[ErrorInfo])->getStartLoc();
 913       if (ErrorLoc == SMLoc()) ErrorLoc = IDLoc;
 914     }
 915
 916     return Error(ErrorLoc, "invalid operand for instruction");
 917   }
 918   case Match_MnemonicFail:
 919     return Error(IDLoc, "unrecognized instruction mnemonic");
 920   }
 921
 922   llvm_unreachable("Implement any new match types added!");
 923   return true;
 924 }
 925
 926 /// ParseDirective parses the arm specific directives
 927 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
 928   StringRef IDVal = DirectiveID.getIdentifier();
 929   if (IDVal == ".word")
 930     return ParseDirectiveWord(4, DirectiveID.getLoc());
 931   else if (IDVal == ".thumb")
 932     return ParseDirectiveThumb(DirectiveID.getLoc());
 933   else if (IDVal == ".thumb_func")
 934     return ParseDirectiveThumbFunc(DirectiveID.getLoc());
 935   else if (IDVal == ".code")
 936     return ParseDirectiveCode(DirectiveID.getLoc());
 937   else if (IDVal == ".syntax")
 938     return ParseDirectiveSyntax(DirectiveID.getLoc());
 939   return true;
 940 }
 941
 942 /// ParseDirectiveWord
 943 ///  ::= .word [ expression (, expression)* ]
 944 bool ARMAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
 945   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 946     for (;;) {
 947       const MCExpr *Value;
 948       if (getParser().ParseExpression(Value))
 949         return true;
 950
 951       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
 952
 953       if (getLexer().is(AsmToken::EndOfStatement))
 954         break;
 955
 956       // FIXME: Improve diagnostic.
 957       if (getLexer().isNot(AsmToken::Comma))
 958         return Error(L, "unexpected token in directive");
 959       Parser.Lex();
 960     }
 961   }
 962
 963   Parser.Lex();
 964   return false;
 965 }
 966
 967 /// ParseDirectiveThumb
 968 ///  ::= .thumb
 969 bool ARMAsmParser::ParseDirectiveThumb(SMLoc L) {
 970   if (getLexer().isNot(AsmToken::EndOfStatement))
 971     return Error(L, "unexpected token in directive");
 972   Parser.Lex();
 973
 974   // TODO: set thumb mode
 975   // TODO: tell the MC streamer the mode
 976   // getParser().getStreamer().Emit???();
 977   return false;
 978 }
 979
 980 /// ParseDirectiveThumbFunc
 981 ///  ::= .thumbfunc symbol_name
 982 bool ARMAsmParser::ParseDirectiveThumbFunc(SMLoc L) {
 983   const AsmToken &Tok = Parser.getTok();
 984   if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
 985     return Error(L, "unexpected token in .thumb_func directive");
 986   StringRef Name = Tok.getString();
 987   Parser.Lex(); // Consume the identifier token.
 988   if (getLexer().isNot(AsmToken::EndOfStatement))
 989     return Error(L, "unexpected token in directive");
 990   Parser.Lex();
 991
 992   // Mark symbol as a thumb symbol.
 993   MCSymbol *Func = getParser().getContext().GetOrCreateSymbol(Name);
 994   getParser().getStreamer().EmitThumbFunc(Func);
 995   return false;
 996 }
 997
 998 /// ParseDirectiveSyntax
 999 ///  ::= .syntax unified | divided
1000 bool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) {
1001   const AsmToken &Tok = Parser.getTok();
1002   if (Tok.isNot(AsmToken::Identifier))
1003     return Error(L, "unexpected token in .syntax directive");
1004   StringRef Mode = Tok.getString();
1005   if (Mode == "unified" || Mode == "UNIFIED")
1006     Parser.Lex();
1007   else if (Mode == "divided" || Mode == "DIVIDED")
1008     Parser.Lex();
1009   else
1010     return Error(L, "unrecognized syntax mode in .syntax directive");
1011
1012   if (getLexer().isNot(AsmToken::EndOfStatement))
1013     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
1014   Parser.Lex();
1015
1016   // TODO tell the MC streamer the mode
1017   // getParser().getStreamer().Emit???();
1018   return false;
1019 }
1020
1021 /// ParseDirectiveCode
1022 ///  ::= .code 16 | 32
1023 bool ARMAsmParser::ParseDirectiveCode(SMLoc L) {
1024   const AsmToken &Tok = Parser.getTok();
1025   if (Tok.isNot(AsmToken::Integer))
1026     return Error(L, "unexpected token in .code directive");
1027   int64_t Val = Parser.getTok().getIntVal();
1028   if (Val == 16)
1029     Parser.Lex();
1030   else if (Val == 32)
1031     Parser.Lex();
1032   else
1033     return Error(L, "invalid operand to .code directive");
1034
1035   if (getLexer().isNot(AsmToken::EndOfStatement))
1036     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
1037   Parser.Lex();
1038
1039   if (Val == 16)
1040     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code16);
1041   else
1042     getParser().getStreamer().EmitAssemblerFlag(MCAF_Code32);
1043
1044   return false;
1045 }
1046
1047 extern "C" void LLVMInitializeARMAsmLexer();
1048
1049 /// Force static initialization.
1050 extern "C" void LLVMInitializeARMAsmParser() {
1051   RegisterAsmParser<ARMAsmParser> X(TheARMTarget);
1052   RegisterAsmParser<ARMAsmParser> Y(TheThumbTarget);
1053   LLVMInitializeARMAsmLexer();
1054 }
1055
1056 #define GET_REGISTER_MATCHER
1057 #define GET_MATCHER_IMPLEMENTATION
1058 #include "ARMGenAsmMatcher.inc"