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