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 "ARMSubtarget.h"
  12 #include "llvm/MC/MCParser/MCAsmLexer.h"
  13 #include "llvm/MC/MCParser/MCAsmParser.h"
  14 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  15 #include "llvm/MC/MCStreamer.h"
  16 #include "llvm/MC/MCExpr.h"
  17 #include "llvm/MC/MCInst.h"
  18 #include "llvm/Target/TargetRegistry.h"
  19 #include "llvm/Target/TargetAsmParser.h"
  20 #include "llvm/Support/SourceMgr.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include "llvm/ADT/OwningPtr.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/ADT/Twine.h"
  26 using namespace llvm;
  27
  28 // The shift types for register controlled shifts in arm memory addressing
  29 enum ShiftType {
  30   Lsl,
  31   Lsr,
  32   Asr,
  33   Ror,
  34   Rrx
  35 };
  36
  37 namespace {
  38   struct ARMOperand;
  39
  40 class ARMAsmParser : public TargetAsmParser {
  41   MCAsmParser &Parser;
  42   TargetMachine &TM;
  43
  44 private:
  45   MCAsmParser &getParser() const { return Parser; }
  46
  47   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
  48
  49   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
  50
  51   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
  52
  53   ARMOperand *MaybeParseRegister(bool ParseWriteBack);
  54
  55   bool ParseRegisterList(OwningPtr<ARMOperand> &Op);
  56
  57   bool ParseMemory(OwningPtr<ARMOperand> &Op);
  58
  59   bool ParseMemoryOffsetReg(bool &Negative,
  60                             bool &OffsetRegShifted,
  61                             enum ShiftType &ShiftType,
  62                             const MCExpr *&ShiftAmount,
  63                             const MCExpr *&Offset,
  64                             bool &OffsetIsReg,
  65                             int &OffsetRegNum,
  66                             SMLoc &E);
  67
  68   bool ParseShift(enum ShiftType &St, const MCExpr *&ShiftAmount, SMLoc &E);
  69
  70   bool ParseOperand(OwningPtr<ARMOperand> &Op);
  71
  72   bool ParseDirectiveWord(unsigned Size, SMLoc L);
  73
  74   bool ParseDirectiveThumb(SMLoc L);
  75
  76   bool ParseDirectiveThumbFunc(SMLoc L);
  77
  78   bool ParseDirectiveCode(SMLoc L);
  79
  80   bool ParseDirectiveSyntax(SMLoc L);
  81
  82   bool MatchAndEmitInstruction(SMLoc IDLoc,
  83                                SmallVectorImpl<MCParsedAsmOperand*> &Operands,
  84                                MCStreamer &Out) {
  85     MCInst Inst;
  86     unsigned ErrorInfo;
  87     if (MatchInstructionImpl(Operands, Inst, ErrorInfo) == Match_Success) {
  88       Out.EmitInstruction(Inst);
  89       return false;
  90     }
  91
  92     // FIXME: We should give nicer diagnostics about the exact failure.
  93     Error(IDLoc, "unrecognized instruction");
  94     return true;
  95   }
  96
  97   /// @name Auto-generated Match Functions
  98   /// {
  99
 100 #define GET_ASSEMBLER_HEADER
 101 #include "ARMGenAsmMatcher.inc"
 102
 103   /// }
 104
 105
 106 public:
 107   ARMAsmParser(const Target &T, MCAsmParser &_Parser, TargetMachine &_TM)
 108     : TargetAsmParser(T), Parser(_Parser), TM(_TM) {}
 109
 110   virtual bool ParseInstruction(StringRef Name, SMLoc NameLoc,
 111                                 SmallVectorImpl<MCParsedAsmOperand*> &Operands);
 112
 113   virtual bool ParseDirective(AsmToken DirectiveID);
 114 };
 115 } // end anonymous namespace
 116
 117 namespace {
 118
 119 /// ARMOperand - Instances of this class represent a parsed ARM machine
 120 /// instruction.
 121 struct ARMOperand : public MCParsedAsmOperand {
 122 public:
 123   enum KindTy {
 124     CondCode,
 125     Immediate,
 126     Memory,
 127     Register,
 128     Token
 129   } Kind;
 130
 131   SMLoc StartLoc, EndLoc;
 132
 133   union {
 134     struct {
 135       ARMCC::CondCodes Val;
 136     } CC;
 137
 138     struct {
 139       const char *Data;
 140       unsigned Length;
 141     } Tok;
 142
 143     struct {
 144       unsigned RegNum;
 145       bool Writeback;
 146     } Reg;
 147
 148     struct {
 149       const MCExpr *Val;
 150     } Imm;
 151
 152     // This is for all forms of ARM address expressions
 153     struct {
 154       unsigned BaseRegNum;
 155       unsigned OffsetRegNum; // used when OffsetIsReg is true
 156       const MCExpr *Offset; // used when OffsetIsReg is false
 157       const MCExpr *ShiftAmount; // used when OffsetRegShifted is true
 158       enum ShiftType ShiftType;  // used when OffsetRegShifted is true
 159       unsigned
 160         OffsetRegShifted : 1, // only used when OffsetIsReg is true
 161         Preindexed : 1,
 162         Postindexed : 1,
 163         OffsetIsReg : 1,
 164         Negative : 1, // only used when OffsetIsReg is true
 165         Writeback : 1;
 166     } Mem;
 167
 168   };
 169
 170   //ARMOperand(KindTy K, SMLoc S, SMLoc E)
 171   //  : Kind(K), StartLoc(S), EndLoc(E) {}
 172
 173   ARMOperand(const ARMOperand &o) : MCParsedAsmOperand() {
 174     Kind = o.Kind;
 175     StartLoc = o.StartLoc;
 176     EndLoc = o.EndLoc;
 177     switch (Kind) {
 178     case CondCode:
 179       CC = o.CC;
 180       break;
 181     case Token:
 182       Tok = o.Tok;
 183       break;
 184     case Register:
 185       Reg = o.Reg;
 186       break;
 187     case Immediate:
 188       Imm = o.Imm;
 189       break;
 190     case Memory:
 191       Mem = o.Mem;
 192       break;
 193     }
 194   }
 195
 196   /// getStartLoc - Get the location of the first token of this operand.
 197   SMLoc getStartLoc() const { return StartLoc; }
 198   /// getEndLoc - Get the location of the last token of this operand.
 199   SMLoc getEndLoc() const { return EndLoc; }
 200
 201   ARMCC::CondCodes getCondCode() const {
 202     assert(Kind == CondCode && "Invalid access!");
 203     return CC.Val;
 204   }
 205
 206   StringRef getToken() const {
 207     assert(Kind == Token && "Invalid access!");
 208     return StringRef(Tok.Data, Tok.Length);
 209   }
 210
 211   unsigned getReg() const {
 212     assert(Kind == Register && "Invalid access!");
 213     return Reg.RegNum;
 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
 223   bool isImm() const { return Kind == Immediate; }
 224
 225   bool isReg() const { return Kind == Register; }
 226
 227   bool isToken() const {return Kind == Token; }
 228
 229   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 230     // Add as immediates when possible.
 231     if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 232       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 233     else
 234       Inst.addOperand(MCOperand::CreateExpr(Expr));
 235   }
 236
 237   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
 238     assert(N == 2 && "Invalid number of operands!");
 239     Inst.addOperand(MCOperand::CreateImm(unsigned(getCondCode())));
 240     // FIXME: What belongs here?
 241     Inst.addOperand(MCOperand::CreateReg(0));
 242   }
 243
 244   void addRegOperands(MCInst &Inst, unsigned N) const {
 245     assert(N == 1 && "Invalid number of operands!");
 246     Inst.addOperand(MCOperand::CreateReg(getReg()));
 247   }
 248
 249   void addImmOperands(MCInst &Inst, unsigned N) const {
 250     assert(N == 1 && "Invalid number of operands!");
 251     addExpr(Inst, getImm());
 252   }
 253
 254   virtual void dump(raw_ostream &OS) const;
 255
 256   static ARMOperand *CreateCondCode(ARMCC::CondCodes CC, SMLoc S) {
 257     ARMOperand *Op = new ARMOperand(CondCode);
 258     Op->CC.Val = CC;
 259     Op->StartLoc = S;
 260     Op->EndLoc = S;
 261     return Op;
 262   }
 263
 264   static ARMOperand *CreateToken(StringRef Str, SMLoc S) {
 265     ARMOperand *Op = new ARMOperand(Token);
 266     Op->Tok.Data = Str.data();
 267     Op->Tok.Length = Str.size();
 268     Op->StartLoc = S;
 269     Op->EndLoc = S;
 270     return Op;
 271   }
 272
 273   static ARMOperand *CreateReg(unsigned RegNum, bool Writeback, SMLoc S,
 274                                SMLoc E) {
 275     ARMOperand *Op = new ARMOperand(Register);
 276     Op->Reg.RegNum = RegNum;
 277     Op->Reg.Writeback = Writeback;
 278     Op->StartLoc = S;
 279     Op->EndLoc = E;
 280     return Op;
 281   }
 282
 283   static ARMOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
 284     ARMOperand *Op = new ARMOperand(Immediate);
 285     Op->Imm.Val = Val;
 286     Op->StartLoc = S;
 287     Op->EndLoc = E;
 288     return Op;
 289   }
 290
 291   static ARMOperand *CreateMem(unsigned BaseRegNum, bool OffsetIsReg,
 292                                const MCExpr *Offset, unsigned OffsetRegNum,
 293                                bool OffsetRegShifted, enum ShiftType ShiftType,
 294                                const MCExpr *ShiftAmount, bool Preindexed,
 295                                bool Postindexed, bool Negative, bool Writeback,
 296                                SMLoc S, SMLoc E) {
 297     ARMOperand *Op = new ARMOperand(Memory);
 298     Op->Mem.BaseRegNum = BaseRegNum;
 299     Op->Mem.OffsetIsReg = OffsetIsReg;
 300     Op->Mem.Offset = Offset;
 301     Op->Mem.OffsetRegNum = OffsetRegNum;
 302     Op->Mem.OffsetRegShifted = OffsetRegShifted;
 303     Op->Mem.ShiftType = ShiftType;
 304     Op->Mem.ShiftAmount = ShiftAmount;
 305     Op->Mem.Preindexed = Preindexed;
 306     Op->Mem.Postindexed = Postindexed;
 307     Op->Mem.Negative = Negative;
 308     Op->Mem.Writeback = Writeback;
 309
 310     Op->StartLoc = S;
 311     Op->EndLoc = E;
 312     return Op;
 313   }
 314
 315 private:
 316   ARMOperand(KindTy K) : Kind(K) {}
 317 };
 318
 319 } // end anonymous namespace.
 320
 321 void ARMOperand::dump(raw_ostream &OS) const {
 322   switch (Kind) {
 323   case CondCode:
 324     OS << ARMCondCodeToString(getCondCode());
 325     break;
 326   case Immediate:
 327     getImm()->print(OS);
 328     break;
 329   case Memory:
 330     OS << "<memory>";
 331     break;
 332   case Register:
 333     OS << "<register " << getReg() << ">";
 334     break;
 335   case Token:
 336     OS << "'" << getToken() << "'";
 337     break;
 338   }
 339 }
 340
 341 /// @name Auto-generated Match Functions
 342 /// {
 343
 344 static unsigned MatchRegisterName(StringRef Name);
 345
 346 /// }
 347
 348 /// Try to parse a register name.  The token must be an Identifier when called,
 349 /// and if it is a register name the token is eaten and a Reg operand is created
 350 /// and returned.  Otherwise return null.
 351 ///
 352 /// TODO this is likely to change to allow different register types and or to
 353 /// parse for a specific register type.
 354 ARMOperand *ARMAsmParser::MaybeParseRegister(bool ParseWriteBack) {
 355   SMLoc S, E;
 356   const AsmToken &Tok = Parser.getTok();
 357   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
 358
 359   // FIXME: Validate register for the current architecture; we have to do
 360   // validation later, so maybe there is no need for this here.
 361   int RegNum;
 362
 363   RegNum = MatchRegisterName(Tok.getString());
 364   if (RegNum == -1)
 365     return 0;
 366
 367   S = Tok.getLoc();
 368
 369   Parser.Lex(); // Eat identifier token.
 370
 371   E = Parser.getTok().getLoc();
 372
 373   bool Writeback = false;
 374   if (ParseWriteBack) {
 375     const AsmToken &ExclaimTok = Parser.getTok();
 376     if (ExclaimTok.is(AsmToken::Exclaim)) {
 377       E = ExclaimTok.getLoc();
 378       Writeback = true;
 379       Parser.Lex(); // Eat exclaim token
 380     }
 381   }
 382
 383   return ARMOperand::CreateReg(RegNum, Writeback, S, E);
 384 }
 385
 386 /// Parse a register list, return false if successful else return true or an
 387 /// error.  The first token must be a '{' when called.
 388 bool ARMAsmParser::ParseRegisterList(OwningPtr<ARMOperand> &Op) {
 389   SMLoc S, E;
 390   assert(Parser.getTok().is(AsmToken::LCurly) &&
 391          "Token is not an Left Curly Brace");
 392   S = Parser.getTok().getLoc();
 393   Parser.Lex(); // Eat left curly brace token.
 394
 395   const AsmToken &RegTok = Parser.getTok();
 396   SMLoc RegLoc = RegTok.getLoc();
 397   if (RegTok.isNot(AsmToken::Identifier))
 398     return Error(RegLoc, "register expected");
 399   int RegNum = MatchRegisterName(RegTok.getString());
 400   if (RegNum == -1)
 401     return Error(RegLoc, "register expected");
 402   Parser.Lex(); // Eat identifier token.
 403   unsigned RegList = 1 << RegNum;
 404
 405   int HighRegNum = RegNum;
 406   // TODO ranges like "{Rn-Rm}"
 407   while (Parser.getTok().is(AsmToken::Comma)) {
 408     Parser.Lex(); // Eat comma token.
 409
 410     const AsmToken &RegTok = Parser.getTok();
 411     SMLoc RegLoc = RegTok.getLoc();
 412     if (RegTok.isNot(AsmToken::Identifier))
 413       return Error(RegLoc, "register expected");
 414     int RegNum = MatchRegisterName(RegTok.getString());
 415     if (RegNum == -1)
 416       return Error(RegLoc, "register expected");
 417
 418     if (RegList & (1 << RegNum))
 419       Warning(RegLoc, "register duplicated in register list");
 420     else if (RegNum <= HighRegNum)
 421       Warning(RegLoc, "register not in ascending order in register list");
 422     RegList |= 1 << RegNum;
 423     HighRegNum = RegNum;
 424
 425     Parser.Lex(); // Eat identifier token.
 426   }
 427   const AsmToken &RCurlyTok = Parser.getTok();
 428   if (RCurlyTok.isNot(AsmToken::RCurly))
 429     return Error(RCurlyTok.getLoc(), "'}' expected");
 430   E = RCurlyTok.getLoc();
 431   Parser.Lex(); // Eat left curly brace token.
 432
 433   return false;
 434 }
 435
 436 /// Parse an arm memory expression, return false if successful else return true
 437 /// or an error.  The first token must be a '[' when called.
 438 /// TODO Only preindexing and postindexing addressing are started, unindexed
 439 /// with option, etc are still to do.
 440 bool ARMAsmParser::ParseMemory(OwningPtr<ARMOperand> &Op) {
 441   SMLoc S, E;
 442   assert(Parser.getTok().is(AsmToken::LBrac) &&
 443          "Token is not an Left Bracket");
 444   S = Parser.getTok().getLoc();
 445   Parser.Lex(); // Eat left bracket token.
 446
 447   const AsmToken &BaseRegTok = Parser.getTok();
 448   if (BaseRegTok.isNot(AsmToken::Identifier))
 449     return Error(BaseRegTok.getLoc(), "register expected");
 450   Op.reset(MaybeParseRegister(false));
 451   if (Op.get() == 0)
 452     return Error(BaseRegTok.getLoc(), "register expected");
 453   int BaseRegNum = Op->getReg();
 454
 455   bool Preindexed = false;
 456   bool Postindexed = false;
 457   bool OffsetIsReg = false;
 458   bool Negative = false;
 459   bool Writeback = false;
 460
 461   // First look for preindexed address forms, that is after the "[Rn" we now
 462   // have to see if the next token is a comma.
 463   const AsmToken &Tok = Parser.getTok();
 464   if (Tok.is(AsmToken::Comma)) {
 465     Preindexed = true;
 466     Parser.Lex(); // Eat comma token.
 467     int OffsetRegNum;
 468     bool OffsetRegShifted;
 469     enum ShiftType ShiftType;
 470     const MCExpr *ShiftAmount;
 471     const MCExpr *Offset;
 472     if(ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType, ShiftAmount,
 473                             Offset, OffsetIsReg, OffsetRegNum, E))
 474       return true;
 475     const AsmToken &RBracTok = Parser.getTok();
 476     if (RBracTok.isNot(AsmToken::RBrac))
 477       return Error(RBracTok.getLoc(), "']' expected");
 478     E = RBracTok.getLoc();
 479     Parser.Lex(); // Eat right bracket token.
 480
 481     const AsmToken &ExclaimTok = Parser.getTok();
 482     if (ExclaimTok.is(AsmToken::Exclaim)) {
 483       E = ExclaimTok.getLoc();
 484       Writeback = true;
 485       Parser.Lex(); // Eat exclaim token
 486     }
 487     Op.reset(
 488       ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum,
 489                             OffsetRegShifted, ShiftType, ShiftAmount,
 490                             Preindexed, Postindexed, Negative, Writeback, S,E));
 491     return false;
 492   }
 493   // The "[Rn" we have so far was not followed by a comma.
 494   else if (Tok.is(AsmToken::RBrac)) {
 495     // This is a post indexing addressing forms, that is a ']' follows after
 496     // the "[Rn".
 497     Postindexed = true;
 498     Writeback = true;
 499     E = Tok.getLoc();
 500     Parser.Lex(); // Eat right bracket token.
 501
 502     int OffsetRegNum = 0;
 503     bool OffsetRegShifted = false;
 504     enum ShiftType ShiftType;
 505     const MCExpr *ShiftAmount;
 506     const MCExpr *Offset;
 507
 508     const AsmToken &NextTok = Parser.getTok();
 509     if (NextTok.isNot(AsmToken::EndOfStatement)) {
 510       if (NextTok.isNot(AsmToken::Comma))
 511         return Error(NextTok.getLoc(), "',' expected");
 512       Parser.Lex(); // Eat comma token.
 513       if(ParseMemoryOffsetReg(Negative, OffsetRegShifted, ShiftType,
 514                               ShiftAmount, Offset, OffsetIsReg, OffsetRegNum,
 515                               E))
 516         return true;
 517     }
 518
 519     Op.reset(
 520       ARMOperand::CreateMem(BaseRegNum, OffsetIsReg, Offset, OffsetRegNum,
 521                             OffsetRegShifted, ShiftType, ShiftAmount,
 522                             Preindexed, Postindexed, Negative, Writeback, S,E));
 523     return false;
 524   }
 525
 526   return true;
 527 }
 528
 529 /// Parse the offset of a memory operand after we have seen "[Rn," or "[Rn],"
 530 /// we will parse the following (were +/- means that a plus or minus is
 531 /// optional):
 532 ///   +/-Rm
 533 ///   +/-Rm, shift
 534 ///   #offset
 535 /// we return false on success or an error otherwise.
 536 bool ARMAsmParser::ParseMemoryOffsetReg(bool &Negative,
 537                                         bool &OffsetRegShifted,
 538                                         enum ShiftType &ShiftType,
 539                                         const MCExpr *&ShiftAmount,
 540                                         const MCExpr *&Offset,
 541                                         bool &OffsetIsReg,
 542                                         int &OffsetRegNum,
 543                                         SMLoc &E) {
 544   OwningPtr<ARMOperand> Op;
 545   Negative = false;
 546   OffsetRegShifted = false;
 547   OffsetIsReg = false;
 548   OffsetRegNum = -1;
 549   const AsmToken &NextTok = Parser.getTok();
 550   E = NextTok.getLoc();
 551   if (NextTok.is(AsmToken::Plus))
 552     Parser.Lex(); // Eat plus token.
 553   else if (NextTok.is(AsmToken::Minus)) {
 554     Negative = true;
 555     Parser.Lex(); // Eat minus token
 556   }
 557   // See if there is a register following the "[Rn," or "[Rn]," we have so far.
 558   const AsmToken &OffsetRegTok = Parser.getTok();
 559   if (OffsetRegTok.is(AsmToken::Identifier)) {
 560     Op.reset(MaybeParseRegister(false));
 561     OffsetIsReg = Op.get() != 0;
 562     if (OffsetIsReg) {
 563       E = Op->getEndLoc();
 564       OffsetRegNum = Op->getReg();
 565     }
 566   }
 567   // If we parsed a register as the offset then their can be a shift after that
 568   if (OffsetRegNum != -1) {
 569     // Look for a comma then a shift
 570     const AsmToken &Tok = Parser.getTok();
 571     if (Tok.is(AsmToken::Comma)) {
 572       Parser.Lex(); // Eat comma token.
 573
 574       const AsmToken &Tok = Parser.getTok();
 575       if (ParseShift(ShiftType, ShiftAmount, E))
 576         return Error(Tok.getLoc(), "shift expected");
 577       OffsetRegShifted = true;
 578     }
 579   }
 580   else { // the "[Rn," or "[Rn,]" we have so far was not followed by "Rm"
 581     // Look for #offset following the "[Rn," or "[Rn],"
 582     const AsmToken &HashTok = Parser.getTok();
 583     if (HashTok.isNot(AsmToken::Hash))
 584       return Error(HashTok.getLoc(), "'#' expected");
 585
 586     Parser.Lex(); // Eat hash token.
 587
 588     if (getParser().ParseExpression(Offset))
 589      return true;
 590     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 591   }
 592   return false;
 593 }
 594
 595 /// ParseShift as one of these two:
 596 ///   ( lsl | lsr | asr | ror ) , # shift_amount
 597 ///   rrx
 598 /// and returns true if it parses a shift otherwise it returns false.
 599 bool ARMAsmParser::ParseShift(ShiftType &St, const MCExpr *&ShiftAmount,
 600                               SMLoc &E) {
 601   const AsmToken &Tok = Parser.getTok();
 602   if (Tok.isNot(AsmToken::Identifier))
 603     return true;
 604   StringRef ShiftName = Tok.getString();
 605   if (ShiftName == "lsl" || ShiftName == "LSL")
 606     St = Lsl;
 607   else if (ShiftName == "lsr" || ShiftName == "LSR")
 608     St = Lsr;
 609   else if (ShiftName == "asr" || ShiftName == "ASR")
 610     St = Asr;
 611   else if (ShiftName == "ror" || ShiftName == "ROR")
 612     St = Ror;
 613   else if (ShiftName == "rrx" || ShiftName == "RRX")
 614     St = Rrx;
 615   else
 616     return true;
 617   Parser.Lex(); // Eat shift type token.
 618
 619   // Rrx stands alone.
 620   if (St == Rrx)
 621     return false;
 622
 623   // Otherwise, there must be a '#' and a shift amount.
 624   const AsmToken &HashTok = Parser.getTok();
 625   if (HashTok.isNot(AsmToken::Hash))
 626     return Error(HashTok.getLoc(), "'#' expected");
 627   Parser.Lex(); // Eat hash token.
 628
 629   if (getParser().ParseExpression(ShiftAmount))
 630     return true;
 631
 632   return false;
 633 }
 634
 635 /// Parse a arm instruction operand.  For now this parses the operand regardless
 636 /// of the mnemonic.
 637 bool ARMAsmParser::ParseOperand(OwningPtr<ARMOperand> &Op) {
 638   SMLoc S, E;
 639
 640   switch (getLexer().getKind()) {
 641   case AsmToken::Identifier:
 642     Op.reset(MaybeParseRegister(true));
 643     if (Op.get() != 0)
 644       return false;
 645     // This was not a register so parse other operands that start with an
 646     // identifier (like labels) as expressions and create them as immediates.
 647     const MCExpr *IdVal;
 648     S = Parser.getTok().getLoc();
 649     if (getParser().ParseExpression(IdVal))
 650       return true;
 651     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 652     Op.reset(ARMOperand::CreateImm(IdVal, S, E));
 653     return false;
 654   case AsmToken::LBrac:
 655     return ParseMemory(Op);
 656   case AsmToken::LCurly:
 657     return ParseRegisterList(Op);
 658   case AsmToken::Hash:
 659     // #42 -> immediate.
 660     // TODO: ":lower16:" and ":upper16:" modifiers after # before immediate
 661     S = Parser.getTok().getLoc();
 662     Parser.Lex();
 663     const MCExpr *ImmVal;
 664     if (getParser().ParseExpression(ImmVal))
 665       return true;
 666     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
 667     Op.reset(ARMOperand::CreateImm(ImmVal, S, E));
 668     return false;
 669   default:
 670     return Error(Parser.getTok().getLoc(), "unexpected token in operand");
 671   }
 672 }
 673
 674 /// Parse an arm instruction mnemonic followed by its operands.
 675 bool ARMAsmParser::ParseInstruction(StringRef Name, SMLoc NameLoc,
 676                                SmallVectorImpl<MCParsedAsmOperand*> &Operands) {
 677   // Create the leading tokens for the mnemonic, split by '.' characters.
 678   size_t Start = 0, Next = Name.find('.');
 679   StringRef Head = Name.slice(Start, Next);
 680
 681   // Determine the predicate, if any.
 682   //
 683   // FIXME: We need a way to check whether a prefix supports predication,
 684   // otherwise we will end up with an ambiguity for instructions that happen to
 685   // end with a predicate name.
 686   unsigned CC = StringSwitch<unsigned>(Head.substr(Head.size()-2))
 687     .Case("eq", ARMCC::EQ)
 688     .Case("ne", ARMCC::NE)
 689     .Case("hs", ARMCC::HS)
 690     .Case("lo", ARMCC::LO)
 691     .Case("mi", ARMCC::MI)
 692     .Case("pl", ARMCC::PL)
 693     .Case("vs", ARMCC::VS)
 694     .Case("vc", ARMCC::VC)
 695     .Case("hi", ARMCC::HI)
 696     .Case("ls", ARMCC::LS)
 697     .Case("ge", ARMCC::GE)
 698     .Case("lt", ARMCC::LT)
 699     .Case("gt", ARMCC::GT)
 700     .Case("le", ARMCC::LE)
 701     .Case("al", ARMCC::AL)
 702     .Default(~0U);
 703
 704   if (CC != ~0U)
 705     Head = Head.slice(0, Head.size() - 2);
 706   else
 707     CC = ARMCC::AL;
 708
 709   Operands.push_back(ARMOperand::CreateToken(Head, NameLoc));
 710   Operands.push_back(ARMOperand::CreateCondCode(ARMCC::CondCodes(CC), NameLoc));
 711
 712   // Add the remaining tokens in the mnemonic.
 713   while (Next != StringRef::npos) {
 714     Start = Next;
 715     Next = Name.find('.', Start + 1);
 716     Head = Name.slice(Start, Next);
 717
 718     Operands.push_back(ARMOperand::CreateToken(Head, NameLoc));
 719   }
 720
 721   // Read the remaining operands.
 722   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 723     // Read the first operand.
 724     OwningPtr<ARMOperand> Op;
 725     if (ParseOperand(Op)) {
 726       Parser.EatToEndOfStatement();
 727       return true;
 728     }
 729     Operands.push_back(Op.take());
 730
 731     while (getLexer().is(AsmToken::Comma)) {
 732       Parser.Lex();  // Eat the comma.
 733
 734       // Parse and remember the operand.
 735       if (ParseOperand(Op)) {
 736         Parser.EatToEndOfStatement();
 737         return true;
 738       }
 739       Operands.push_back(Op.take());
 740     }
 741   }
 742
 743   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 744     Parser.EatToEndOfStatement();
 745     return TokError("unexpected token in argument list");
 746   }
 747   Parser.Lex(); // Consume the EndOfStatement
 748   return false;
 749 }
 750
 751 /// ParseDirective parses the arm specific directives
 752 bool ARMAsmParser::ParseDirective(AsmToken DirectiveID) {
 753   StringRef IDVal = DirectiveID.getIdentifier();
 754   if (IDVal == ".word")
 755     return ParseDirectiveWord(4, DirectiveID.getLoc());
 756   else if (IDVal == ".thumb")
 757     return ParseDirectiveThumb(DirectiveID.getLoc());
 758   else if (IDVal == ".thumb_func")
 759     return ParseDirectiveThumbFunc(DirectiveID.getLoc());
 760   else if (IDVal == ".code")
 761     return ParseDirectiveCode(DirectiveID.getLoc());
 762   else if (IDVal == ".syntax")
 763     return ParseDirectiveSyntax(DirectiveID.getLoc());
 764   return true;
 765 }
 766
 767 /// ParseDirectiveWord
 768 ///  ::= .word [ expression (, expression)* ]
 769 bool ARMAsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
 770   if (getLexer().isNot(AsmToken::EndOfStatement)) {
 771     for (;;) {
 772       const MCExpr *Value;
 773       if (getParser().ParseExpression(Value))
 774         return true;
 775
 776       getParser().getStreamer().EmitValue(Value, Size, 0/*addrspace*/);
 777
 778       if (getLexer().is(AsmToken::EndOfStatement))
 779         break;
 780
 781       // FIXME: Improve diagnostic.
 782       if (getLexer().isNot(AsmToken::Comma))
 783         return Error(L, "unexpected token in directive");
 784       Parser.Lex();
 785     }
 786   }
 787
 788   Parser.Lex();
 789   return false;
 790 }
 791
 792 /// ParseDirectiveThumb
 793 ///  ::= .thumb
 794 bool ARMAsmParser::ParseDirectiveThumb(SMLoc L) {
 795   if (getLexer().isNot(AsmToken::EndOfStatement))
 796     return Error(L, "unexpected token in directive");
 797   Parser.Lex();
 798
 799   // TODO: set thumb mode
 800   // TODO: tell the MC streamer the mode
 801   // getParser().getStreamer().Emit???();
 802   return false;
 803 }
 804
 805 /// ParseDirectiveThumbFunc
 806 ///  ::= .thumbfunc symbol_name
 807 bool ARMAsmParser::ParseDirectiveThumbFunc(SMLoc L) {
 808   const AsmToken &Tok = Parser.getTok();
 809   if (Tok.isNot(AsmToken::Identifier) && Tok.isNot(AsmToken::String))
 810     return Error(L, "unexpected token in .syntax directive");
 811   Parser.Lex(); // Consume the identifier token.
 812
 813   if (getLexer().isNot(AsmToken::EndOfStatement))
 814     return Error(L, "unexpected token in directive");
 815   Parser.Lex();
 816
 817   // TODO: mark symbol as a thumb symbol
 818   // getParser().getStreamer().Emit???();
 819   return false;
 820 }
 821
 822 /// ParseDirectiveSyntax
 823 ///  ::= .syntax unified | divided
 824 bool ARMAsmParser::ParseDirectiveSyntax(SMLoc L) {
 825   const AsmToken &Tok = Parser.getTok();
 826   if (Tok.isNot(AsmToken::Identifier))
 827     return Error(L, "unexpected token in .syntax directive");
 828   StringRef Mode = Tok.getString();
 829   if (Mode == "unified" || Mode == "UNIFIED")
 830     Parser.Lex();
 831   else if (Mode == "divided" || Mode == "DIVIDED")
 832     Parser.Lex();
 833   else
 834     return Error(L, "unrecognized syntax mode in .syntax directive");
 835
 836   if (getLexer().isNot(AsmToken::EndOfStatement))
 837     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
 838   Parser.Lex();
 839
 840   // TODO tell the MC streamer the mode
 841   // getParser().getStreamer().Emit???();
 842   return false;
 843 }
 844
 845 /// ParseDirectiveCode
 846 ///  ::= .code 16 | 32
 847 bool ARMAsmParser::ParseDirectiveCode(SMLoc L) {
 848   const AsmToken &Tok = Parser.getTok();
 849   if (Tok.isNot(AsmToken::Integer))
 850     return Error(L, "unexpected token in .code directive");
 851   int64_t Val = Parser.getTok().getIntVal();
 852   if (Val == 16)
 853     Parser.Lex();
 854   else if (Val == 32)
 855     Parser.Lex();
 856   else
 857     return Error(L, "invalid operand to .code directive");
 858
 859   if (getLexer().isNot(AsmToken::EndOfStatement))
 860     return Error(Parser.getTok().getLoc(), "unexpected token in directive");
 861   Parser.Lex();
 862
 863   // TODO tell the MC streamer the mode
 864   // getParser().getStreamer().Emit???();
 865   return false;
 866 }
 867
 868 extern "C" void LLVMInitializeARMAsmLexer();
 869
 870 /// Force static initialization.
 871 extern "C" void LLVMInitializeARMAsmParser() {
 872   RegisterAsmParser<ARMAsmParser> X(TheARMTarget);
 873   RegisterAsmParser<ARMAsmParser> Y(TheThumbTarget);
 874   LLVMInitializeARMAsmLexer();
 875 }
 876
 877 #define GET_REGISTER_MATCHER
 878 #define GET_MATCHER_IMPLEMENTATION
 879 #include "ARMGenAsmMatcher.inc"