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