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