lib/MC/MCParser/AsmParser.cpp

   1 //===- AsmParser.cpp - Parser for Assembly Files --------------------------===//
   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 // This class implements the parser for assembly files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/MC/MCParser/AsmParser.h"
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/ADT/Twine.h"
  17 #include "llvm/MC/MCContext.h"
  18 #include "llvm/MC/MCExpr.h"
  19 #include "llvm/MC/MCInst.h"
  20 #include "llvm/MC/MCSectionMachO.h"
  21 #include "llvm/MC/MCStreamer.h"
  22 #include "llvm/MC/MCSymbol.h"
  23 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  24 #include "llvm/Support/Compiler.h"
  25 #include "llvm/Support/SourceMgr.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include "llvm/Target/TargetAsmParser.h"
  28 using namespace llvm;
  29
  30
  31 enum { DEFAULT_ADDRSPACE = 0 };
  32
  33 // Mach-O section uniquing.
  34 //
  35 // FIXME: Figure out where this should live, it should be shared by
  36 // TargetLoweringObjectFile.
  37 typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
  38
  39 AsmParser::AsmParser(SourceMgr &_SM, MCContext &_Ctx, MCStreamer &_Out,
  40                      const MCAsmInfo &_MAI)
  41   : Lexer(_MAI), Ctx(_Ctx), Out(_Out), SrcMgr(_SM), TargetParser(0),
  42     CurBuffer(0), SectionUniquingMap(0) {
  43   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer));
  44
  45   // Debugging directives.
  46   AddDirectiveHandler(".file", &AsmParser::ParseDirectiveFile);
  47   AddDirectiveHandler(".line", &AsmParser::ParseDirectiveLine);
  48   AddDirectiveHandler(".loc", &AsmParser::ParseDirectiveLoc);
  49 }
  50
  51
  52
  53 AsmParser::~AsmParser() {
  54   // If we have the MachO uniquing map, free it.
  55   delete (MachOUniqueMapTy*)SectionUniquingMap;
  56 }
  57
  58 const MCSection *AsmParser::getMachOSection(const StringRef &Segment,
  59                                             const StringRef &Section,
  60                                             unsigned TypeAndAttributes,
  61                                             unsigned Reserved2,
  62                                             SectionKind Kind) const {
  63   // We unique sections by their segment/section pair.  The returned section
  64   // may not have the same flags as the requested section, if so this should be
  65   // diagnosed by the client as an error.
  66
  67   // Create the map if it doesn't already exist.
  68   if (SectionUniquingMap == 0)
  69     SectionUniquingMap = new MachOUniqueMapTy();
  70   MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)SectionUniquingMap;
  71
  72   // Form the name to look up.
  73   SmallString<64> Name;
  74   Name += Segment;
  75   Name.push_back(',');
  76   Name += Section;
  77
  78   // Do the lookup, if we have a hit, return it.
  79   const MCSectionMachO *&Entry = Map[Name.str()];
  80
  81   // FIXME: This should validate the type and attributes.
  82   if (Entry) return Entry;
  83
  84   // Otherwise, return a new section.
  85   return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
  86                                         Reserved2, Kind, Ctx);
  87 }
  88
  89 void AsmParser::Warning(SMLoc L, const Twine &Msg) {
  90   PrintMessage(L, Msg.str(), "warning");
  91 }
  92
  93 bool AsmParser::Error(SMLoc L, const Twine &Msg) {
  94   PrintMessage(L, Msg.str(), "error");
  95   return true;
  96 }
  97
  98 bool AsmParser::TokError(const char *Msg) {
  99   PrintMessage(Lexer.getLoc(), Msg, "error");
 100   return true;
 101 }
 102
 103 void AsmParser::PrintMessage(SMLoc Loc, const std::string &Msg,
 104                              const char *Type) const {
 105   SrcMgr.PrintMessage(Loc, Msg, Type);
 106 }
 107
 108 bool AsmParser::EnterIncludeFile(const std::string &Filename) {
 109   int NewBuf = SrcMgr.AddIncludeFile(Filename, Lexer.getLoc());
 110   if (NewBuf == -1)
 111     return true;
 112
 113   CurBuffer = NewBuf;
 114
 115   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer));
 116
 117   return false;
 118 }
 119
 120 const AsmToken &AsmParser::Lex() {
 121   const AsmToken *tok = &Lexer.Lex();
 122
 123   if (tok->is(AsmToken::Eof)) {
 124     // If this is the end of an included file, pop the parent file off the
 125     // include stack.
 126     SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
 127     if (ParentIncludeLoc != SMLoc()) {
 128       CurBuffer = SrcMgr.FindBufferContainingLoc(ParentIncludeLoc);
 129       Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer),
 130                       ParentIncludeLoc.getPointer());
 131       tok = &Lexer.Lex();
 132     }
 133   }
 134
 135   if (tok->is(AsmToken::Error))
 136     PrintMessage(Lexer.getErrLoc(), Lexer.getErr(), "error");
 137
 138   return *tok;
 139 }
 140
 141 bool AsmParser::Run() {
 142   // Create the initial section.
 143   //
 144   // FIXME: Support -n.
 145   // FIXME: Target hook & command line option for initial section.
 146   Out.SwitchSection(getMachOSection("__TEXT", "__text",
 147                                     MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 148                                     0, SectionKind::getText()));
 149
 150
 151   // Prime the lexer.
 152   Lex();
 153
 154   bool HadError = false;
 155
 156   AsmCond StartingCondState = TheCondState;
 157
 158   // While we have input, parse each statement.
 159   while (Lexer.isNot(AsmToken::Eof)) {
 160     // Handle conditional assembly here before calling ParseStatement()
 161     if (Lexer.getKind() == AsmToken::Identifier) {
 162       // If we have an identifier, handle it as the key symbol.
 163       AsmToken ID = getTok();
 164       SMLoc IDLoc = ID.getLoc();
 165       StringRef IDVal = ID.getString();
 166
 167       if (IDVal == ".if" ||
 168           IDVal == ".elseif" ||
 169           IDVal == ".else" ||
 170           IDVal == ".endif") {
 171         if (!ParseConditionalAssemblyDirectives(IDVal, IDLoc))
 172           continue;
 173         HadError = true;
 174         EatToEndOfStatement();
 175         continue;
 176       }
 177     }
 178     if (TheCondState.Ignore) {
 179       EatToEndOfStatement();
 180       continue;
 181     }
 182
 183     if (!ParseStatement()) continue;
 184
 185     // We had an error, remember it and recover by skipping to the next line.
 186     HadError = true;
 187     EatToEndOfStatement();
 188   }
 189
 190   if (TheCondState.TheCond != StartingCondState.TheCond ||
 191       TheCondState.Ignore != StartingCondState.Ignore)
 192     return TokError("unmatched .ifs or .elses");
 193
 194   if (!HadError)
 195     Out.Finish();
 196
 197   return HadError;
 198 }
 199
 200 /// ParseConditionalAssemblyDirectives - parse the conditional assembly
 201 /// directives
 202 bool AsmParser::ParseConditionalAssemblyDirectives(StringRef Directive,
 203                                                    SMLoc DirectiveLoc) {
 204   if (Directive == ".if")
 205     return ParseDirectiveIf(DirectiveLoc);
 206   if (Directive == ".elseif")
 207     return ParseDirectiveElseIf(DirectiveLoc);
 208   if (Directive == ".else")
 209     return ParseDirectiveElse(DirectiveLoc);
 210   if (Directive == ".endif")
 211     return ParseDirectiveEndIf(DirectiveLoc);
 212   return true;
 213 }
 214
 215 /// EatToEndOfStatement - Throw away the rest of the line for testing purposes.
 216 void AsmParser::EatToEndOfStatement() {
 217   while (Lexer.isNot(AsmToken::EndOfStatement) &&
 218          Lexer.isNot(AsmToken::Eof))
 219     Lex();
 220
 221   // Eat EOL.
 222   if (Lexer.is(AsmToken::EndOfStatement))
 223     Lex();
 224 }
 225
 226
 227 /// ParseParenExpr - Parse a paren expression and return it.
 228 /// NOTE: This assumes the leading '(' has already been consumed.
 229 ///
 230 /// parenexpr ::= expr)
 231 ///
 232 bool AsmParser::ParseParenExpr(const MCExpr *&Res, SMLoc &EndLoc) {
 233   if (ParseExpression(Res)) return true;
 234   if (Lexer.isNot(AsmToken::RParen))
 235     return TokError("expected ')' in parentheses expression");
 236   EndLoc = Lexer.getLoc();
 237   Lex();
 238   return false;
 239 }
 240
 241 MCSymbol *AsmParser::CreateSymbol(StringRef Name) {
 242   // If the label starts with L it is an assembler temporary label.
 243   if (Name.startswith("L"))
 244     return Ctx.GetOrCreateTemporarySymbol(Name);
 245   return Ctx.GetOrCreateSymbol(Name);
 246 }
 247
 248 /// ParsePrimaryExpr - Parse a primary expression and return it.
 249 ///  primaryexpr ::= (parenexpr
 250 ///  primaryexpr ::= symbol
 251 ///  primaryexpr ::= number
 252 ///  primaryexpr ::= ~,+,- primaryexpr
 253 bool AsmParser::ParsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
 254   switch (Lexer.getKind()) {
 255   default:
 256     return TokError("unknown token in expression");
 257   case AsmToken::Exclaim:
 258     Lex(); // Eat the operator.
 259     if (ParsePrimaryExpr(Res, EndLoc))
 260       return true;
 261     Res = MCUnaryExpr::CreateLNot(Res, getContext());
 262     return false;
 263   case AsmToken::String:
 264   case AsmToken::Identifier: {
 265     // This is a symbol reference.
 266     MCSymbol *Sym = CreateSymbol(getTok().getIdentifier());
 267     EndLoc = Lexer.getLoc();
 268     Lex(); // Eat identifier.
 269
 270     // If this is an absolute variable reference, substitute it now to preserve
 271     // semantics in the face of reassignment.
 272     if (Sym->getValue() && isa<MCConstantExpr>(Sym->getValue())) {
 273       Res = Sym->getValue();
 274       return false;
 275     }
 276
 277     // Otherwise create a symbol ref.
 278     Res = MCSymbolRefExpr::Create(Sym, getContext());
 279     return false;
 280   }
 281   case AsmToken::Integer:
 282     Res = MCConstantExpr::Create(getTok().getIntVal(), getContext());
 283     EndLoc = Lexer.getLoc();
 284     Lex(); // Eat token.
 285     return false;
 286   case AsmToken::LParen:
 287     Lex(); // Eat the '('.
 288     return ParseParenExpr(Res, EndLoc);
 289   case AsmToken::Minus:
 290     Lex(); // Eat the operator.
 291     if (ParsePrimaryExpr(Res, EndLoc))
 292       return true;
 293     Res = MCUnaryExpr::CreateMinus(Res, getContext());
 294     return false;
 295   case AsmToken::Plus:
 296     Lex(); // Eat the operator.
 297     if (ParsePrimaryExpr(Res, EndLoc))
 298       return true;
 299     Res = MCUnaryExpr::CreatePlus(Res, getContext());
 300     return false;
 301   case AsmToken::Tilde:
 302     Lex(); // Eat the operator.
 303     if (ParsePrimaryExpr(Res, EndLoc))
 304       return true;
 305     Res = MCUnaryExpr::CreateNot(Res, getContext());
 306     return false;
 307   }
 308 }
 309
 310 bool AsmParser::ParseExpression(const MCExpr *&Res) {
 311   SMLoc EndLoc;
 312   return ParseExpression(Res, EndLoc);
 313 }
 314
 315 /// ParseExpression - Parse an expression and return it.
 316 ///
 317 ///  expr ::= expr +,- expr          -> lowest.
 318 ///  expr ::= expr |,^,&,! expr      -> middle.
 319 ///  expr ::= expr *,/,%,<<,>> expr  -> highest.
 320 ///  expr ::= primaryexpr
 321 ///
 322 bool AsmParser::ParseExpression(const MCExpr *&Res, SMLoc &EndLoc) {
 323   // Parse the expression.
 324   Res = 0;
 325   if (ParsePrimaryExpr(Res, EndLoc) || ParseBinOpRHS(1, Res, EndLoc))
 326     return true;
 327
 328   // Try to constant fold it up front, if possible.
 329   int64_t Value;
 330   if (Res->EvaluateAsAbsolute(Value))
 331     Res = MCConstantExpr::Create(Value, getContext());
 332
 333   return false;
 334 }
 335
 336 bool AsmParser::ParseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) {
 337   Res = 0;
 338   return ParseParenExpr(Res, EndLoc) ||
 339          ParseBinOpRHS(1, Res, EndLoc);
 340 }
 341
 342 bool AsmParser::ParseAbsoluteExpression(int64_t &Res) {
 343   const MCExpr *Expr;
 344
 345   SMLoc StartLoc = Lexer.getLoc();
 346   if (ParseExpression(Expr))
 347     return true;
 348
 349   if (!Expr->EvaluateAsAbsolute(Res))
 350     return Error(StartLoc, "expected absolute expression");
 351
 352   return false;
 353 }
 354
 355 static unsigned getBinOpPrecedence(AsmToken::TokenKind K,
 356                                    MCBinaryExpr::Opcode &Kind) {
 357   switch (K) {
 358   default:
 359     return 0;    // not a binop.
 360
 361     // Lowest Precedence: &&, ||
 362   case AsmToken::AmpAmp:
 363     Kind = MCBinaryExpr::LAnd;
 364     return 1;
 365   case AsmToken::PipePipe:
 366     Kind = MCBinaryExpr::LOr;
 367     return 1;
 368
 369     // Low Precedence: +, -, ==, !=, <>, <, <=, >, >=
 370   case AsmToken::Plus:
 371     Kind = MCBinaryExpr::Add;
 372     return 2;
 373   case AsmToken::Minus:
 374     Kind = MCBinaryExpr::Sub;
 375     return 2;
 376   case AsmToken::EqualEqual:
 377     Kind = MCBinaryExpr::EQ;
 378     return 2;
 379   case AsmToken::ExclaimEqual:
 380   case AsmToken::LessGreater:
 381     Kind = MCBinaryExpr::NE;
 382     return 2;
 383   case AsmToken::Less:
 384     Kind = MCBinaryExpr::LT;
 385     return 2;
 386   case AsmToken::LessEqual:
 387     Kind = MCBinaryExpr::LTE;
 388     return 2;
 389   case AsmToken::Greater:
 390     Kind = MCBinaryExpr::GT;
 391     return 2;
 392   case AsmToken::GreaterEqual:
 393     Kind = MCBinaryExpr::GTE;
 394     return 2;
 395
 396     // Intermediate Precedence: |, &, ^
 397     //
 398     // FIXME: gas seems to support '!' as an infix operator?
 399   case AsmToken::Pipe:
 400     Kind = MCBinaryExpr::Or;
 401     return 3;
 402   case AsmToken::Caret:
 403     Kind = MCBinaryExpr::Xor;
 404     return 3;
 405   case AsmToken::Amp:
 406     Kind = MCBinaryExpr::And;
 407     return 3;
 408
 409     // Highest Precedence: *, /, %, <<, >>
 410   case AsmToken::Star:
 411     Kind = MCBinaryExpr::Mul;
 412     return 4;
 413   case AsmToken::Slash:
 414     Kind = MCBinaryExpr::Div;
 415     return 4;
 416   case AsmToken::Percent:
 417     Kind = MCBinaryExpr::Mod;
 418     return 4;
 419   case AsmToken::LessLess:
 420     Kind = MCBinaryExpr::Shl;
 421     return 4;
 422   case AsmToken::GreaterGreater:
 423     Kind = MCBinaryExpr::Shr;
 424     return 4;
 425   }
 426 }
 427
 428
 429 /// ParseBinOpRHS - Parse all binary operators with precedence >= 'Precedence'.
 430 /// Res contains the LHS of the expression on input.
 431 bool AsmParser::ParseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
 432                               SMLoc &EndLoc) {
 433   while (1) {
 434     MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
 435     unsigned TokPrec = getBinOpPrecedence(Lexer.getKind(), Kind);
 436
 437     // If the next token is lower precedence than we are allowed to eat, return
 438     // successfully with what we ate already.
 439     if (TokPrec < Precedence)
 440       return false;
 441
 442     Lex();
 443
 444     // Eat the next primary expression.
 445     const MCExpr *RHS;
 446     if (ParsePrimaryExpr(RHS, EndLoc)) return true;
 447
 448     // If BinOp binds less tightly with RHS than the operator after RHS, let
 449     // the pending operator take RHS as its LHS.
 450     MCBinaryExpr::Opcode Dummy;
 451     unsigned NextTokPrec = getBinOpPrecedence(Lexer.getKind(), Dummy);
 452     if (TokPrec < NextTokPrec) {
 453       if (ParseBinOpRHS(Precedence+1, RHS, EndLoc)) return true;
 454     }
 455
 456     // Merge LHS and RHS according to operator.
 457     Res = MCBinaryExpr::Create(Kind, Res, RHS, getContext());
 458   }
 459 }
 460
 461
 462
 463
 464 /// ParseStatement:
 465 ///   ::= EndOfStatement
 466 ///   ::= Label* Directive ...Operands... EndOfStatement
 467 ///   ::= Label* Identifier OperandList* EndOfStatement
 468 bool AsmParser::ParseStatement() {
 469   if (Lexer.is(AsmToken::EndOfStatement)) {
 470     Lex();
 471     return false;
 472   }
 473
 474   // Statements always start with an identifier.
 475   AsmToken ID = getTok();
 476   SMLoc IDLoc = ID.getLoc();
 477   StringRef IDVal;
 478   if (ParseIdentifier(IDVal))
 479     return TokError("unexpected token at start of statement");
 480
 481   // FIXME: Recurse on local labels?
 482
 483   // See what kind of statement we have.
 484   switch (Lexer.getKind()) {
 485   case AsmToken::Colon: {
 486     // identifier ':'   -> Label.
 487     Lex();
 488
 489     // Diagnose attempt to use a variable as a label.
 490     //
 491     // FIXME: Diagnostics. Note the location of the definition as a label.
 492     // FIXME: This doesn't diagnose assignment to a symbol which has been
 493     // implicitly marked as external.
 494     MCSymbol *Sym = CreateSymbol(IDVal);
 495     if (!Sym->isUndefined())
 496       return Error(IDLoc, "invalid symbol redefinition");
 497
 498     // Emit the label.
 499     Out.EmitLabel(Sym);
 500
 501     return ParseStatement();
 502   }
 503
 504   case AsmToken::Equal:
 505     // identifier '=' ... -> assignment statement
 506     Lex();
 507
 508     return ParseAssignment(IDVal);
 509
 510   default: // Normal instruction or directive.
 511     break;
 512   }
 513
 514   // Otherwise, we have a normal instruction or directive.
 515   if (IDVal[0] == '.') {
 516     // FIXME: This should be driven based on a hash lookup and callback.
 517     if (IDVal == ".section")
 518       return ParseDirectiveDarwinSection();
 519     if (IDVal == ".text")
 520       // FIXME: This changes behavior based on the -static flag to the
 521       // assembler.
 522       return ParseDirectiveSectionSwitch("__TEXT", "__text",
 523                                      MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS);
 524     if (IDVal == ".const")
 525       return ParseDirectiveSectionSwitch("__TEXT", "__const");
 526     if (IDVal == ".static_const")
 527       return ParseDirectiveSectionSwitch("__TEXT", "__static_const");
 528     if (IDVal == ".cstring")
 529       return ParseDirectiveSectionSwitch("__TEXT","__cstring",
 530                                          MCSectionMachO::S_CSTRING_LITERALS);
 531     if (IDVal == ".literal4")
 532       return ParseDirectiveSectionSwitch("__TEXT", "__literal4",
 533                                          MCSectionMachO::S_4BYTE_LITERALS,
 534                                          4);
 535     if (IDVal == ".literal8")
 536       return ParseDirectiveSectionSwitch("__TEXT", "__literal8",
 537                                          MCSectionMachO::S_8BYTE_LITERALS,
 538                                          8);
 539     if (IDVal == ".literal16")
 540       return ParseDirectiveSectionSwitch("__TEXT","__literal16",
 541                                          MCSectionMachO::S_16BYTE_LITERALS,
 542                                          16);
 543     if (IDVal == ".constructor")
 544       return ParseDirectiveSectionSwitch("__TEXT","__constructor");
 545     if (IDVal == ".destructor")
 546       return ParseDirectiveSectionSwitch("__TEXT","__destructor");
 547     if (IDVal == ".fvmlib_init0")
 548       return ParseDirectiveSectionSwitch("__TEXT","__fvmlib_init0");
 549     if (IDVal == ".fvmlib_init1")
 550       return ParseDirectiveSectionSwitch("__TEXT","__fvmlib_init1");
 551
 552     // FIXME: The assembler manual claims that this has the self modify code
 553     // flag, at least on x86-32, but that does not appear to be correct.
 554     if (IDVal == ".symbol_stub")
 555       return ParseDirectiveSectionSwitch("__TEXT","__symbol_stub",
 556                                          MCSectionMachO::S_SYMBOL_STUBS |
 557                                        MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 558                                           // FIXME: Different on PPC and ARM.
 559                                          0, 16);
 560     // FIXME: PowerPC only?
 561     if (IDVal == ".picsymbol_stub")
 562       return ParseDirectiveSectionSwitch("__TEXT","__picsymbol_stub",
 563                                          MCSectionMachO::S_SYMBOL_STUBS |
 564                                        MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 565                                          0, 26);
 566     if (IDVal == ".data")
 567       return ParseDirectiveSectionSwitch("__DATA", "__data");
 568     if (IDVal == ".static_data")
 569       return ParseDirectiveSectionSwitch("__DATA", "__static_data");
 570
 571     // FIXME: The section names of these two are misspelled in the assembler
 572     // manual.
 573     if (IDVal == ".non_lazy_symbol_pointer")
 574       return ParseDirectiveSectionSwitch("__DATA", "__nl_symbol_ptr",
 575                                      MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
 576                                          4);
 577     if (IDVal == ".lazy_symbol_pointer")
 578       return ParseDirectiveSectionSwitch("__DATA", "__la_symbol_ptr",
 579                                          MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
 580                                          4);
 581
 582     if (IDVal == ".dyld")
 583       return ParseDirectiveSectionSwitch("__DATA", "__dyld");
 584     if (IDVal == ".mod_init_func")
 585       return ParseDirectiveSectionSwitch("__DATA", "__mod_init_func",
 586                                        MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
 587                                          4);
 588     if (IDVal == ".mod_term_func")
 589       return ParseDirectiveSectionSwitch("__DATA", "__mod_term_func",
 590                                        MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
 591                                          4);
 592     if (IDVal == ".const_data")
 593       return ParseDirectiveSectionSwitch("__DATA", "__const");
 594
 595
 596     if (IDVal == ".objc_class")
 597       return ParseDirectiveSectionSwitch("__OBJC", "__class",
 598                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 599     if (IDVal == ".objc_meta_class")
 600       return ParseDirectiveSectionSwitch("__OBJC", "__meta_class",
 601                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 602     if (IDVal == ".objc_cat_cls_meth")
 603       return ParseDirectiveSectionSwitch("__OBJC", "__cat_cls_meth",
 604                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 605     if (IDVal == ".objc_cat_inst_meth")
 606       return ParseDirectiveSectionSwitch("__OBJC", "__cat_inst_meth",
 607                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 608     if (IDVal == ".objc_protocol")
 609       return ParseDirectiveSectionSwitch("__OBJC", "__protocol",
 610                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 611     if (IDVal == ".objc_string_object")
 612       return ParseDirectiveSectionSwitch("__OBJC", "__string_object",
 613                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 614     if (IDVal == ".objc_cls_meth")
 615       return ParseDirectiveSectionSwitch("__OBJC", "__cls_meth",
 616                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 617     if (IDVal == ".objc_inst_meth")
 618       return ParseDirectiveSectionSwitch("__OBJC", "__inst_meth",
 619                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 620     if (IDVal == ".objc_cls_refs")
 621       return ParseDirectiveSectionSwitch("__OBJC", "__cls_refs",
 622                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP |
 623                                          MCSectionMachO::S_LITERAL_POINTERS,
 624                                          4);
 625     if (IDVal == ".objc_message_refs")
 626       return ParseDirectiveSectionSwitch("__OBJC", "__message_refs",
 627                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP |
 628                                          MCSectionMachO::S_LITERAL_POINTERS,
 629                                          4);
 630     if (IDVal == ".objc_symbols")
 631       return ParseDirectiveSectionSwitch("__OBJC", "__symbols",
 632                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 633     if (IDVal == ".objc_category")
 634       return ParseDirectiveSectionSwitch("__OBJC", "__category",
 635                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 636     if (IDVal == ".objc_class_vars")
 637       return ParseDirectiveSectionSwitch("__OBJC", "__class_vars",
 638                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 639     if (IDVal == ".objc_instance_vars")
 640       return ParseDirectiveSectionSwitch("__OBJC", "__instance_vars",
 641                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 642     if (IDVal == ".objc_module_info")
 643       return ParseDirectiveSectionSwitch("__OBJC", "__module_info",
 644                                          MCSectionMachO::S_ATTR_NO_DEAD_STRIP);
 645     if (IDVal == ".objc_class_names")
 646       return ParseDirectiveSectionSwitch("__TEXT", "__cstring",
 647                                          MCSectionMachO::S_CSTRING_LITERALS);
 648     if (IDVal == ".objc_meth_var_types")
 649       return ParseDirectiveSectionSwitch("__TEXT", "__cstring",
 650                                          MCSectionMachO::S_CSTRING_LITERALS);
 651     if (IDVal == ".objc_meth_var_names")
 652       return ParseDirectiveSectionSwitch("__TEXT", "__cstring",
 653                                          MCSectionMachO::S_CSTRING_LITERALS);
 654     if (IDVal == ".objc_selector_strs")
 655       return ParseDirectiveSectionSwitch("__OBJC", "__selector_strs",
 656                                          MCSectionMachO::S_CSTRING_LITERALS);
 657
 658     // Assembler features
 659     if (IDVal == ".set")
 660       return ParseDirectiveSet();
 661
 662     // Data directives
 663
 664     if (IDVal == ".ascii")
 665       return ParseDirectiveAscii(false);
 666     if (IDVal == ".asciz")
 667       return ParseDirectiveAscii(true);
 668
 669     if (IDVal == ".byte")
 670       return ParseDirectiveValue(1);
 671     if (IDVal == ".short")
 672       return ParseDirectiveValue(2);
 673     if (IDVal == ".long")
 674       return ParseDirectiveValue(4);
 675     if (IDVal == ".quad")
 676       return ParseDirectiveValue(8);
 677
 678     // FIXME: Target hooks for IsPow2.
 679     if (IDVal == ".align")
 680       return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/1);
 681     if (IDVal == ".align32")
 682       return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/4);
 683     if (IDVal == ".balign")
 684       return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/1);
 685     if (IDVal == ".balignw")
 686       return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/2);
 687     if (IDVal == ".balignl")
 688       return ParseDirectiveAlign(/*IsPow2=*/false, /*ExprSize=*/4);
 689     if (IDVal == ".p2align")
 690       return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/1);
 691     if (IDVal == ".p2alignw")
 692       return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/2);
 693     if (IDVal == ".p2alignl")
 694       return ParseDirectiveAlign(/*IsPow2=*/true, /*ExprSize=*/4);
 695
 696     if (IDVal == ".org")
 697       return ParseDirectiveOrg();
 698
 699     if (IDVal == ".fill")
 700       return ParseDirectiveFill();
 701     if (IDVal == ".space")
 702       return ParseDirectiveSpace();
 703
 704     // Symbol attribute directives
 705
 706     if (IDVal == ".globl" || IDVal == ".global")
 707       return ParseDirectiveSymbolAttribute(MCSA_Global);
 708     if (IDVal == ".hidden")
 709       return ParseDirectiveSymbolAttribute(MCSA_Hidden);
 710     if (IDVal == ".indirect_symbol")
 711       return ParseDirectiveSymbolAttribute(MCSA_IndirectSymbol);
 712     if (IDVal == ".internal")
 713       return ParseDirectiveSymbolAttribute(MCSA_Internal);
 714     if (IDVal == ".lazy_reference")
 715       return ParseDirectiveSymbolAttribute(MCSA_LazyReference);
 716     if (IDVal == ".no_dead_strip")
 717       return ParseDirectiveSymbolAttribute(MCSA_NoDeadStrip);
 718     if (IDVal == ".private_extern")
 719       return ParseDirectiveSymbolAttribute(MCSA_PrivateExtern);
 720     if (IDVal == ".protected")
 721       return ParseDirectiveSymbolAttribute(MCSA_Protected);
 722     if (IDVal == ".reference")
 723       return ParseDirectiveSymbolAttribute(MCSA_Reference);
 724     if (IDVal == ".weak")
 725       return ParseDirectiveSymbolAttribute(MCSA_Weak);
 726     if (IDVal == ".weak_definition")
 727       return ParseDirectiveSymbolAttribute(MCSA_WeakDefinition);
 728     if (IDVal == ".weak_reference")
 729       return ParseDirectiveSymbolAttribute(MCSA_WeakReference);
 730
 731     if (IDVal == ".comm")
 732       return ParseDirectiveComm(/*IsLocal=*/false);
 733     if (IDVal == ".lcomm")
 734       return ParseDirectiveComm(/*IsLocal=*/true);
 735     if (IDVal == ".zerofill")
 736       return ParseDirectiveDarwinZerofill();
 737     if (IDVal == ".desc")
 738       return ParseDirectiveDarwinSymbolDesc();
 739     if (IDVal == ".lsym")
 740       return ParseDirectiveDarwinLsym();
 741
 742     if (IDVal == ".subsections_via_symbols")
 743       return ParseDirectiveDarwinSubsectionsViaSymbols();
 744     if (IDVal == ".abort")
 745       return ParseDirectiveAbort();
 746     if (IDVal == ".include")
 747       return ParseDirectiveInclude();
 748     if (IDVal == ".dump")
 749       return ParseDirectiveDarwinDumpOrLoad(IDLoc, /*IsDump=*/true);
 750     if (IDVal == ".load")
 751       return ParseDirectiveDarwinDumpOrLoad(IDLoc, /*IsLoad=*/false);
 752
 753     // Look up the handler in the handler table,
 754     bool(AsmParser::*Handler)(StringRef, SMLoc) = DirectiveMap[IDVal];
 755     if (Handler)
 756       return (this->*Handler)(IDVal, IDLoc);
 757
 758     // Target hook for parsing target specific directives.
 759     if (!getTargetParser().ParseDirective(ID))
 760       return false;
 761
 762     Warning(IDLoc, "ignoring directive for now");
 763     EatToEndOfStatement();
 764     return false;
 765   }
 766
 767
 768   SmallVector<MCParsedAsmOperand*, 8> ParsedOperands;
 769   if (getTargetParser().ParseInstruction(IDVal, IDLoc, ParsedOperands))
 770     // FIXME: Leaking ParsedOperands on failure.
 771     return true;
 772
 773   if (Lexer.isNot(AsmToken::EndOfStatement))
 774     // FIXME: Leaking ParsedOperands on failure.
 775     return TokError("unexpected token in argument list");
 776
 777   // Eat the end of statement marker.
 778   Lex();
 779
 780
 781   MCInst Inst;
 782
 783   bool MatchFail = getTargetParser().MatchInstruction(ParsedOperands, Inst);
 784
 785   // Free any parsed operands.
 786   for (unsigned i = 0, e = ParsedOperands.size(); i != e; ++i)
 787     delete ParsedOperands[i];
 788
 789   if (MatchFail) {
 790     // FIXME: We should give nicer diagnostics about the exact failure.
 791     Error(IDLoc, "unrecognized instruction");
 792     return true;
 793   }
 794
 795   // Instruction is good, process it.
 796   Out.EmitInstruction(Inst);
 797
 798   // Skip to end of line for now.
 799   return false;
 800 }
 801
 802 bool AsmParser::ParseAssignment(const StringRef &Name) {
 803   // FIXME: Use better location, we should use proper tokens.
 804   SMLoc EqualLoc = Lexer.getLoc();
 805
 806   const MCExpr *Value;
 807   SMLoc StartLoc = Lexer.getLoc();
 808   if (ParseExpression(Value))
 809     return true;
 810
 811   if (Lexer.isNot(AsmToken::EndOfStatement))
 812     return TokError("unexpected token in assignment");
 813
 814   // Eat the end of statement marker.
 815   Lex();
 816
 817   // Validate that the LHS is allowed to be a variable (either it has not been
 818   // used as a symbol, or it is an absolute symbol).
 819   MCSymbol *Sym = getContext().LookupSymbol(Name);
 820   if (Sym) {
 821     // Diagnose assignment to a label.
 822     //
 823     // FIXME: Diagnostics. Note the location of the definition as a label.
 824     // FIXME: Diagnose assignment to protected identifier (e.g., register name).
 825     if (!Sym->isUndefined() && !Sym->isAbsolute())
 826       return Error(EqualLoc, "redefinition of '" + Name + "'");
 827     else if (!Sym->isVariable())
 828       return Error(EqualLoc, "invalid assignment to '" + Name + "'");
 829     else if (!isa<MCConstantExpr>(Sym->getValue()))
 830       return Error(EqualLoc, "invalid reassignment of non-absolute variable '" +
 831                    Name + "'");
 832   } else
 833     Sym = CreateSymbol(Name);
 834
 835   // FIXME: Handle '.'.
 836
 837   // Do the assignment.
 838   Out.EmitAssignment(Sym, Value);
 839
 840   return false;
 841 }
 842
 843 /// ParseIdentifier:
 844 ///   ::= identifier
 845 ///   ::= string
 846 bool AsmParser::ParseIdentifier(StringRef &Res) {
 847   if (Lexer.isNot(AsmToken::Identifier) &&
 848       Lexer.isNot(AsmToken::String))
 849     return true;
 850
 851   Res = getTok().getIdentifier();
 852
 853   Lex(); // Consume the identifier token.
 854
 855   return false;
 856 }
 857
 858 /// ParseDirectiveSet:
 859 ///   ::= .set identifier ',' expression
 860 bool AsmParser::ParseDirectiveSet() {
 861   StringRef Name;
 862
 863   if (ParseIdentifier(Name))
 864     return TokError("expected identifier after '.set' directive");
 865
 866   if (Lexer.isNot(AsmToken::Comma))
 867     return TokError("unexpected token in '.set'");
 868   Lex();
 869
 870   return ParseAssignment(Name);
 871 }
 872
 873 /// ParseDirectiveSection:
 874 ///   ::= .section identifier (',' identifier)*
 875 /// FIXME: This should actually parse out the segment, section, attributes and
 876 /// sizeof_stub fields.
 877 bool AsmParser::ParseDirectiveDarwinSection() {
 878   SMLoc Loc = Lexer.getLoc();
 879
 880   StringRef SectionName;
 881   if (ParseIdentifier(SectionName))
 882     return Error(Loc, "expected identifier after '.section' directive");
 883
 884   // Verify there is a following comma.
 885   if (!Lexer.is(AsmToken::Comma))
 886     return TokError("unexpected token in '.section' directive");
 887
 888   std::string SectionSpec = SectionName;
 889   SectionSpec += ",";
 890
 891   // Add all the tokens until the end of the line, ParseSectionSpecifier will
 892   // handle this.
 893   StringRef EOL = Lexer.LexUntilEndOfStatement();
 894   SectionSpec.append(EOL.begin(), EOL.end());
 895
 896   Lex();
 897   if (Lexer.isNot(AsmToken::EndOfStatement))
 898     return TokError("unexpected token in '.section' directive");
 899   Lex();
 900
 901
 902   StringRef Segment, Section;
 903   unsigned TAA, StubSize;
 904   std::string ErrorStr =
 905     MCSectionMachO::ParseSectionSpecifier(SectionSpec, Segment, Section,
 906                                           TAA, StubSize);
 907
 908   if (!ErrorStr.empty())
 909     return Error(Loc, ErrorStr.c_str());
 910
 911   // FIXME: Arch specific.
 912   bool isText = Segment == "__TEXT";  // FIXME: Hack.
 913   Out.SwitchSection(getMachOSection(Segment, Section, TAA, StubSize,
 914                                     isText ? SectionKind::getText()
 915                                            : SectionKind::getDataRel()));
 916   return false;
 917 }
 918
 919 /// ParseDirectiveSectionSwitch -
 920 bool AsmParser::ParseDirectiveSectionSwitch(const char *Segment,
 921                                             const char *Section,
 922                                             unsigned TAA, unsigned Align,
 923                                             unsigned StubSize) {
 924   if (Lexer.isNot(AsmToken::EndOfStatement))
 925     return TokError("unexpected token in section switching directive");
 926   Lex();
 927
 928   // FIXME: Arch specific.
 929   bool isText = StringRef(Segment) == "__TEXT";  // FIXME: Hack.
 930   Out.SwitchSection(getMachOSection(Segment, Section, TAA, StubSize,
 931                                     isText ? SectionKind::getText()
 932                                     : SectionKind::getDataRel()));
 933
 934   // Set the implicit alignment, if any.
 935   //
 936   // FIXME: This isn't really what 'as' does; I think it just uses the implicit
 937   // alignment on the section (e.g., if one manually inserts bytes into the
 938   // section, then just issueing the section switch directive will not realign
 939   // the section. However, this is arguably more reasonable behavior, and there
 940   // is no good reason for someone to intentionally emit incorrectly sized
 941   // values into the implicitly aligned sections.
 942   if (Align)
 943     Out.EmitValueToAlignment(Align, 0, 1, 0);
 944
 945   return false;
 946 }
 947
 948 bool AsmParser::ParseEscapedString(std::string &Data) {
 949   assert(Lexer.is(AsmToken::String) && "Unexpected current token!");
 950
 951   Data = "";
 952   StringRef Str = getTok().getStringContents();
 953   for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 954     if (Str[i] != '\\') {
 955       Data += Str[i];
 956       continue;
 957     }
 958
 959     // Recognize escaped characters. Note that this escape semantics currently
 960     // loosely follows Darwin 'as'. Notably, it doesn't support hex escapes.
 961     ++i;
 962     if (i == e)
 963       return TokError("unexpected backslash at end of string");
 964
 965     // Recognize octal sequences.
 966     if ((unsigned) (Str[i] - '0') <= 7) {
 967       // Consume up to three octal characters.
 968       unsigned Value = Str[i] - '0';
 969
 970       if (i + 1 != e && ((unsigned) (Str[i + 1] - '0')) <= 7) {
 971         ++i;
 972         Value = Value * 8 + (Str[i] - '0');
 973
 974         if (i + 1 != e && ((unsigned) (Str[i + 1] - '0')) <= 7) {
 975           ++i;
 976           Value = Value * 8 + (Str[i] - '0');
 977         }
 978       }
 979
 980       if (Value > 255)
 981         return TokError("invalid octal escape sequence (out of range)");
 982
 983       Data += (unsigned char) Value;
 984       continue;
 985     }
 986
 987     // Otherwise recognize individual escapes.
 988     switch (Str[i]) {
 989     default:
 990       // Just reject invalid escape sequences for now.
 991       return TokError("invalid escape sequence (unrecognized character)");
 992
 993     case 'b': Data += '\b'; break;
 994     case 'f': Data += '\f'; break;
 995     case 'n': Data += '\n'; break;
 996     case 'r': Data += '\r'; break;
 997     case 't': Data += '\t'; break;
 998     case '"': Data += '"'; break;
 999     case '\\': Data += '\\'; break;
1000     }
1001   }
1002
1003   return false;
1004 }
1005
1006 /// ParseDirectiveAscii:
1007 ///   ::= ( .ascii | .asciz ) [ "string" ( , "string" )* ]
1008 bool AsmParser::ParseDirectiveAscii(bool ZeroTerminated) {
1009   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1010     for (;;) {
1011       if (Lexer.isNot(AsmToken::String))
1012         return TokError("expected string in '.ascii' or '.asciz' directive");
1013
1014       std::string Data;
1015       if (ParseEscapedString(Data))
1016         return true;
1017
1018       Out.EmitBytes(Data, DEFAULT_ADDRSPACE);
1019       if (ZeroTerminated)
1020         Out.EmitBytes(StringRef("\0", 1), DEFAULT_ADDRSPACE);
1021
1022       Lex();
1023
1024       if (Lexer.is(AsmToken::EndOfStatement))
1025         break;
1026
1027       if (Lexer.isNot(AsmToken::Comma))
1028         return TokError("unexpected token in '.ascii' or '.asciz' directive");
1029       Lex();
1030     }
1031   }
1032
1033   Lex();
1034   return false;
1035 }
1036
1037 /// ParseDirectiveValue
1038 ///  ::= (.byte | .short | ... ) [ expression (, expression)* ]
1039 bool AsmParser::ParseDirectiveValue(unsigned Size) {
1040   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1041     for (;;) {
1042       const MCExpr *Value;
1043       SMLoc ATTRIBUTE_UNUSED StartLoc = Lexer.getLoc();
1044       if (ParseExpression(Value))
1045         return true;
1046
1047       Out.EmitValue(Value, Size, DEFAULT_ADDRSPACE);
1048
1049       if (Lexer.is(AsmToken::EndOfStatement))
1050         break;
1051
1052       // FIXME: Improve diagnostic.
1053       if (Lexer.isNot(AsmToken::Comma))
1054         return TokError("unexpected token in directive");
1055       Lex();
1056     }
1057   }
1058
1059   Lex();
1060   return false;
1061 }
1062
1063 /// ParseDirectiveSpace
1064 ///  ::= .space expression [ , expression ]
1065 bool AsmParser::ParseDirectiveSpace() {
1066   int64_t NumBytes;
1067   if (ParseAbsoluteExpression(NumBytes))
1068     return true;
1069
1070   int64_t FillExpr = 0;
1071   bool HasFillExpr = false;
1072   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1073     if (Lexer.isNot(AsmToken::Comma))
1074       return TokError("unexpected token in '.space' directive");
1075     Lex();
1076
1077     if (ParseAbsoluteExpression(FillExpr))
1078       return true;
1079
1080     HasFillExpr = true;
1081
1082     if (Lexer.isNot(AsmToken::EndOfStatement))
1083       return TokError("unexpected token in '.space' directive");
1084   }
1085
1086   Lex();
1087
1088   if (NumBytes <= 0)
1089     return TokError("invalid number of bytes in '.space' directive");
1090
1091   // FIXME: Sometimes the fill expr is 'nop' if it isn't supplied, instead of 0.
1092   Out.EmitFill(NumBytes, FillExpr, DEFAULT_ADDRSPACE);
1093
1094   return false;
1095 }
1096
1097 /// ParseDirectiveFill
1098 ///  ::= .fill expression , expression , expression
1099 bool AsmParser::ParseDirectiveFill() {
1100   int64_t NumValues;
1101   if (ParseAbsoluteExpression(NumValues))
1102     return true;
1103
1104   if (Lexer.isNot(AsmToken::Comma))
1105     return TokError("unexpected token in '.fill' directive");
1106   Lex();
1107
1108   int64_t FillSize;
1109   if (ParseAbsoluteExpression(FillSize))
1110     return true;
1111
1112   if (Lexer.isNot(AsmToken::Comma))
1113     return TokError("unexpected token in '.fill' directive");
1114   Lex();
1115
1116   int64_t FillExpr;
1117   if (ParseAbsoluteExpression(FillExpr))
1118     return true;
1119
1120   if (Lexer.isNot(AsmToken::EndOfStatement))
1121     return TokError("unexpected token in '.fill' directive");
1122
1123   Lex();
1124
1125   if (FillSize != 1 && FillSize != 2 && FillSize != 4 && FillSize != 8)
1126     return TokError("invalid '.fill' size, expected 1, 2, 4, or 8");
1127
1128   for (uint64_t i = 0, e = NumValues; i != e; ++i)
1129     Out.EmitValue(MCConstantExpr::Create(FillExpr, getContext()), FillSize,
1130                   DEFAULT_ADDRSPACE);
1131
1132   return false;
1133 }
1134
1135 /// ParseDirectiveOrg
1136 ///  ::= .org expression [ , expression ]
1137 bool AsmParser::ParseDirectiveOrg() {
1138   const MCExpr *Offset;
1139   SMLoc StartLoc = Lexer.getLoc();
1140   if (ParseExpression(Offset))
1141     return true;
1142
1143   // Parse optional fill expression.
1144   int64_t FillExpr = 0;
1145   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1146     if (Lexer.isNot(AsmToken::Comma))
1147       return TokError("unexpected token in '.org' directive");
1148     Lex();
1149
1150     if (ParseAbsoluteExpression(FillExpr))
1151       return true;
1152
1153     if (Lexer.isNot(AsmToken::EndOfStatement))
1154       return TokError("unexpected token in '.org' directive");
1155   }
1156
1157   Lex();
1158
1159   // FIXME: Only limited forms of relocatable expressions are accepted here, it
1160   // has to be relative to the current section.
1161   Out.EmitValueToOffset(Offset, FillExpr);
1162
1163   return false;
1164 }
1165
1166 /// ParseDirectiveAlign
1167 ///  ::= {.align, ...} expression [ , expression [ , expression ]]
1168 bool AsmParser::ParseDirectiveAlign(bool IsPow2, unsigned ValueSize) {
1169   SMLoc AlignmentLoc = Lexer.getLoc();
1170   int64_t Alignment;
1171   if (ParseAbsoluteExpression(Alignment))
1172     return true;
1173
1174   SMLoc MaxBytesLoc;
1175   bool HasFillExpr = false;
1176   int64_t FillExpr = 0;
1177   int64_t MaxBytesToFill = 0;
1178   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1179     if (Lexer.isNot(AsmToken::Comma))
1180       return TokError("unexpected token in directive");
1181     Lex();
1182
1183     // The fill expression can be omitted while specifying a maximum number of
1184     // alignment bytes, e.g:
1185     //  .align 3,,4
1186     if (Lexer.isNot(AsmToken::Comma)) {
1187       HasFillExpr = true;
1188       if (ParseAbsoluteExpression(FillExpr))
1189         return true;
1190     }
1191
1192     if (Lexer.isNot(AsmToken::EndOfStatement)) {
1193       if (Lexer.isNot(AsmToken::Comma))
1194         return TokError("unexpected token in directive");
1195       Lex();
1196
1197       MaxBytesLoc = Lexer.getLoc();
1198       if (ParseAbsoluteExpression(MaxBytesToFill))
1199         return true;
1200
1201       if (Lexer.isNot(AsmToken::EndOfStatement))
1202         return TokError("unexpected token in directive");
1203     }
1204   }
1205
1206   Lex();
1207
1208   if (!HasFillExpr) {
1209     // FIXME: Sometimes fill with nop.
1210     FillExpr = 0;
1211   }
1212
1213   // Compute alignment in bytes.
1214   if (IsPow2) {
1215     // FIXME: Diagnose overflow.
1216     if (Alignment >= 32) {
1217       Error(AlignmentLoc, "invalid alignment value");
1218       Alignment = 31;
1219     }
1220
1221     Alignment = 1ULL << Alignment;
1222   }
1223
1224   // Diagnose non-sensical max bytes to align.
1225   if (MaxBytesLoc.isValid()) {
1226     if (MaxBytesToFill < 1) {
1227       Error(MaxBytesLoc, "alignment directive can never be satisfied in this "
1228             "many bytes, ignoring maximum bytes expression");
1229       MaxBytesToFill = 0;
1230     }
1231
1232     if (MaxBytesToFill >= Alignment) {
1233       Warning(MaxBytesLoc, "maximum bytes expression exceeds alignment and "
1234               "has no effect");
1235       MaxBytesToFill = 0;
1236     }
1237   }
1238
1239   // FIXME: hard code the parser to use EmitCodeAlignment for text when using
1240   // the TextAlignFillValue.
1241   if(Out.getCurrentSection()->getKind().isText() &&
1242      Lexer.getMAI().getTextAlignFillValue() == FillExpr)
1243     Out.EmitCodeAlignment(Alignment, MaxBytesToFill);
1244   else
1245     // FIXME: Target specific behavior about how the "extra" bytes are filled.
1246     Out.EmitValueToAlignment(Alignment, FillExpr, ValueSize, MaxBytesToFill);
1247
1248   return false;
1249 }
1250
1251 /// ParseDirectiveSymbolAttribute
1252 ///  ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
1253 bool AsmParser::ParseDirectiveSymbolAttribute(MCSymbolAttr Attr) {
1254   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1255     for (;;) {
1256       StringRef Name;
1257
1258       if (ParseIdentifier(Name))
1259         return TokError("expected identifier in directive");
1260
1261       MCSymbol *Sym = CreateSymbol(Name);
1262
1263       Out.EmitSymbolAttribute(Sym, Attr);
1264
1265       if (Lexer.is(AsmToken::EndOfStatement))
1266         break;
1267
1268       if (Lexer.isNot(AsmToken::Comma))
1269         return TokError("unexpected token in directive");
1270       Lex();
1271     }
1272   }
1273
1274   Lex();
1275   return false;
1276 }
1277
1278 /// ParseDirectiveDarwinSymbolDesc
1279 ///  ::= .desc identifier , expression
1280 bool AsmParser::ParseDirectiveDarwinSymbolDesc() {
1281   StringRef Name;
1282   if (ParseIdentifier(Name))
1283     return TokError("expected identifier in directive");
1284
1285   // Handle the identifier as the key symbol.
1286   MCSymbol *Sym = CreateSymbol(Name);
1287
1288   if (Lexer.isNot(AsmToken::Comma))
1289     return TokError("unexpected token in '.desc' directive");
1290   Lex();
1291
1292   SMLoc DescLoc = Lexer.getLoc();
1293   int64_t DescValue;
1294   if (ParseAbsoluteExpression(DescValue))
1295     return true;
1296
1297   if (Lexer.isNot(AsmToken::EndOfStatement))
1298     return TokError("unexpected token in '.desc' directive");
1299
1300   Lex();
1301
1302   // Set the n_desc field of this Symbol to this DescValue
1303   Out.EmitSymbolDesc(Sym, DescValue);
1304
1305   return false;
1306 }
1307
1308 /// ParseDirectiveComm
1309 ///  ::= ( .comm | .lcomm ) identifier , size_expression [ , align_expression ]
1310 bool AsmParser::ParseDirectiveComm(bool IsLocal) {
1311   SMLoc IDLoc = Lexer.getLoc();
1312   StringRef Name;
1313   if (ParseIdentifier(Name))
1314     return TokError("expected identifier in directive");
1315
1316   // Handle the identifier as the key symbol.
1317   MCSymbol *Sym = CreateSymbol(Name);
1318
1319   if (Lexer.isNot(AsmToken::Comma))
1320     return TokError("unexpected token in directive");
1321   Lex();
1322
1323   int64_t Size;
1324   SMLoc SizeLoc = Lexer.getLoc();
1325   if (ParseAbsoluteExpression(Size))
1326     return true;
1327
1328   int64_t Pow2Alignment = 0;
1329   SMLoc Pow2AlignmentLoc;
1330   if (Lexer.is(AsmToken::Comma)) {
1331     Lex();
1332     Pow2AlignmentLoc = Lexer.getLoc();
1333     if (ParseAbsoluteExpression(Pow2Alignment))
1334       return true;
1335
1336     // If this target takes alignments in bytes (not log) validate and convert.
1337     if (Lexer.getMAI().getAlignmentIsInBytes()) {
1338       if (!isPowerOf2_64(Pow2Alignment))
1339         return Error(Pow2AlignmentLoc, "alignment must be a power of 2");
1340       Pow2Alignment = Log2_64(Pow2Alignment);
1341     }
1342   }
1343
1344   if (Lexer.isNot(AsmToken::EndOfStatement))
1345     return TokError("unexpected token in '.comm' or '.lcomm' directive");
1346
1347   Lex();
1348
1349   // NOTE: a size of zero for a .comm should create a undefined symbol
1350   // but a size of .lcomm creates a bss symbol of size zero.
1351   if (Size < 0)
1352     return Error(SizeLoc, "invalid '.comm' or '.lcomm' directive size, can't "
1353                  "be less than zero");
1354
1355   // NOTE: The alignment in the directive is a power of 2 value, the assember
1356   // may internally end up wanting an alignment in bytes.
1357   // FIXME: Diagnose overflow.
1358   if (Pow2Alignment < 0)
1359     return Error(Pow2AlignmentLoc, "invalid '.comm' or '.lcomm' directive "
1360                  "alignment, can't be less than zero");
1361
1362   if (!Sym->isUndefined())
1363     return Error(IDLoc, "invalid symbol redefinition");
1364
1365   // '.lcomm' is equivalent to '.zerofill'.
1366   // Create the Symbol as a common or local common with Size and Pow2Alignment
1367   if (IsLocal) {
1368     Out.EmitZerofill(getMachOSection("__DATA", "__bss",
1369                                      MCSectionMachO::S_ZEROFILL, 0,
1370                                      SectionKind::getBSS()),
1371                      Sym, Size, 1 << Pow2Alignment);
1372     return false;
1373   }
1374
1375   Out.EmitCommonSymbol(Sym, Size, 1 << Pow2Alignment);
1376   return false;
1377 }
1378
1379 /// ParseDirectiveDarwinZerofill
1380 ///  ::= .zerofill segname , sectname [, identifier , size_expression [
1381 ///      , align_expression ]]
1382 bool AsmParser::ParseDirectiveDarwinZerofill() {
1383   // FIXME: Handle quoted names here.
1384
1385   if (Lexer.isNot(AsmToken::Identifier))
1386     return TokError("expected segment name after '.zerofill' directive");
1387   StringRef Segment = getTok().getString();
1388   Lex();
1389
1390   if (Lexer.isNot(AsmToken::Comma))
1391     return TokError("unexpected token in directive");
1392   Lex();
1393
1394   if (Lexer.isNot(AsmToken::Identifier))
1395     return TokError("expected section name after comma in '.zerofill' "
1396                     "directive");
1397   StringRef Section = getTok().getString();
1398   Lex();
1399
1400   // If this is the end of the line all that was wanted was to create the
1401   // the section but with no symbol.
1402   if (Lexer.is(AsmToken::EndOfStatement)) {
1403     // Create the zerofill section but no symbol
1404     Out.EmitZerofill(getMachOSection(Segment, Section,
1405                                      MCSectionMachO::S_ZEROFILL, 0,
1406                                      SectionKind::getBSS()));
1407     return false;
1408   }
1409
1410   if (Lexer.isNot(AsmToken::Comma))
1411     return TokError("unexpected token in directive");
1412   Lex();
1413
1414   if (Lexer.isNot(AsmToken::Identifier))
1415     return TokError("expected identifier in directive");
1416
1417   // handle the identifier as the key symbol.
1418   SMLoc IDLoc = Lexer.getLoc();
1419   MCSymbol *Sym = CreateSymbol(getTok().getString());
1420   Lex();
1421
1422   if (Lexer.isNot(AsmToken::Comma))
1423     return TokError("unexpected token in directive");
1424   Lex();
1425
1426   int64_t Size;
1427   SMLoc SizeLoc = Lexer.getLoc();
1428   if (ParseAbsoluteExpression(Size))
1429     return true;
1430
1431   int64_t Pow2Alignment = 0;
1432   SMLoc Pow2AlignmentLoc;
1433   if (Lexer.is(AsmToken::Comma)) {
1434     Lex();
1435     Pow2AlignmentLoc = Lexer.getLoc();
1436     if (ParseAbsoluteExpression(Pow2Alignment))
1437       return true;
1438   }
1439
1440   if (Lexer.isNot(AsmToken::EndOfStatement))
1441     return TokError("unexpected token in '.zerofill' directive");
1442
1443   Lex();
1444
1445   if (Size < 0)
1446     return Error(SizeLoc, "invalid '.zerofill' directive size, can't be less "
1447                  "than zero");
1448
1449   // NOTE: The alignment in the directive is a power of 2 value, the assember
1450   // may internally end up wanting an alignment in bytes.
1451   // FIXME: Diagnose overflow.
1452   if (Pow2Alignment < 0)
1453     return Error(Pow2AlignmentLoc, "invalid '.zerofill' directive alignment, "
1454                  "can't be less than zero");
1455
1456   if (!Sym->isUndefined())
1457     return Error(IDLoc, "invalid symbol redefinition");
1458
1459   // Create the zerofill Symbol with Size and Pow2Alignment
1460   //
1461   // FIXME: Arch specific.
1462   Out.EmitZerofill(getMachOSection(Segment, Section,
1463                                  MCSectionMachO::S_ZEROFILL, 0,
1464                                  SectionKind::getBSS()),
1465                    Sym, Size, 1 << Pow2Alignment);
1466
1467   return false;
1468 }
1469
1470 /// ParseDirectiveDarwinSubsectionsViaSymbols
1471 ///  ::= .subsections_via_symbols
1472 bool AsmParser::ParseDirectiveDarwinSubsectionsViaSymbols() {
1473   if (Lexer.isNot(AsmToken::EndOfStatement))
1474     return TokError("unexpected token in '.subsections_via_symbols' directive");
1475
1476   Lex();
1477
1478   Out.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
1479
1480   return false;
1481 }
1482
1483 /// ParseDirectiveAbort
1484 ///  ::= .abort [ "abort_string" ]
1485 bool AsmParser::ParseDirectiveAbort() {
1486   // FIXME: Use loc from directive.
1487   SMLoc Loc = Lexer.getLoc();
1488
1489   StringRef Str = "";
1490   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1491     if (Lexer.isNot(AsmToken::String))
1492       return TokError("expected string in '.abort' directive");
1493
1494     Str = getTok().getString();
1495
1496     Lex();
1497   }
1498
1499   if (Lexer.isNot(AsmToken::EndOfStatement))
1500     return TokError("unexpected token in '.abort' directive");
1501
1502   Lex();
1503
1504   // FIXME: Handle here.
1505   if (Str.empty())
1506     Error(Loc, ".abort detected. Assembly stopping.");
1507   else
1508     Error(Loc, ".abort '" + Str + "' detected. Assembly stopping.");
1509
1510   return false;
1511 }
1512
1513 /// ParseDirectiveLsym
1514 ///  ::= .lsym identifier , expression
1515 bool AsmParser::ParseDirectiveDarwinLsym() {
1516   StringRef Name;
1517   if (ParseIdentifier(Name))
1518     return TokError("expected identifier in directive");
1519
1520   // Handle the identifier as the key symbol.
1521   MCSymbol *Sym = CreateSymbol(Name);
1522
1523   if (Lexer.isNot(AsmToken::Comma))
1524     return TokError("unexpected token in '.lsym' directive");
1525   Lex();
1526
1527   const MCExpr *Value;
1528   SMLoc StartLoc = Lexer.getLoc();
1529   if (ParseExpression(Value))
1530     return true;
1531
1532   if (Lexer.isNot(AsmToken::EndOfStatement))
1533     return TokError("unexpected token in '.lsym' directive");
1534
1535   Lex();
1536
1537   // We don't currently support this directive.
1538   //
1539   // FIXME: Diagnostic location!
1540   (void) Sym;
1541   return TokError("directive '.lsym' is unsupported");
1542 }
1543
1544 /// ParseDirectiveInclude
1545 ///  ::= .include "filename"
1546 bool AsmParser::ParseDirectiveInclude() {
1547   if (Lexer.isNot(AsmToken::String))
1548     return TokError("expected string in '.include' directive");
1549
1550   std::string Filename = getTok().getString();
1551   SMLoc IncludeLoc = Lexer.getLoc();
1552   Lex();
1553
1554   if (Lexer.isNot(AsmToken::EndOfStatement))
1555     return TokError("unexpected token in '.include' directive");
1556
1557   // Strip the quotes.
1558   Filename = Filename.substr(1, Filename.size()-2);
1559
1560   // Attempt to switch the lexer to the included file before consuming the end
1561   // of statement to avoid losing it when we switch.
1562   if (EnterIncludeFile(Filename)) {
1563     PrintMessage(IncludeLoc,
1564                  "Could not find include file '" + Filename + "'",
1565                  "error");
1566     return true;
1567   }
1568
1569   return false;
1570 }
1571
1572 /// ParseDirectiveDarwinDumpOrLoad
1573 ///  ::= ( .dump | .load ) "filename"
1574 bool AsmParser::ParseDirectiveDarwinDumpOrLoad(SMLoc IDLoc, bool IsDump) {
1575   if (Lexer.isNot(AsmToken::String))
1576     return TokError("expected string in '.dump' or '.load' directive");
1577
1578   Lex();
1579
1580   if (Lexer.isNot(AsmToken::EndOfStatement))
1581     return TokError("unexpected token in '.dump' or '.load' directive");
1582
1583   Lex();
1584
1585   // FIXME: If/when .dump and .load are implemented they will be done in the
1586   // the assembly parser and not have any need for an MCStreamer API.
1587   if (IsDump)
1588     Warning(IDLoc, "ignoring directive .dump for now");
1589   else
1590     Warning(IDLoc, "ignoring directive .load for now");
1591
1592   return false;
1593 }
1594
1595 /// ParseDirectiveIf
1596 /// ::= .if expression
1597 bool AsmParser::ParseDirectiveIf(SMLoc DirectiveLoc) {
1598   // Consume the identifier that was the .if directive
1599   Lex();
1600
1601   TheCondStack.push_back(TheCondState);
1602   TheCondState.TheCond = AsmCond::IfCond;
1603   if(TheCondState.Ignore) {
1604     EatToEndOfStatement();
1605   }
1606   else {
1607     int64_t ExprValue;
1608     if (ParseAbsoluteExpression(ExprValue))
1609       return true;
1610
1611     if (Lexer.isNot(AsmToken::EndOfStatement))
1612       return TokError("unexpected token in '.if' directive");
1613
1614     Lex();
1615
1616     TheCondState.CondMet = ExprValue;
1617     TheCondState.Ignore = !TheCondState.CondMet;
1618   }
1619
1620   return false;
1621 }
1622
1623 /// ParseDirectiveElseIf
1624 /// ::= .elseif expression
1625 bool AsmParser::ParseDirectiveElseIf(SMLoc DirectiveLoc) {
1626   if (TheCondState.TheCond != AsmCond::IfCond &&
1627       TheCondState.TheCond != AsmCond::ElseIfCond)
1628       Error(DirectiveLoc, "Encountered a .elseif that doesn't follow a .if or "
1629                           " an .elseif");
1630   TheCondState.TheCond = AsmCond::ElseIfCond;
1631
1632   // Consume the identifier that was the .elseif directive
1633   Lex();
1634
1635   bool LastIgnoreState = false;
1636   if (!TheCondStack.empty())
1637       LastIgnoreState = TheCondStack.back().Ignore;
1638   if (LastIgnoreState || TheCondState.CondMet) {
1639     TheCondState.Ignore = true;
1640     EatToEndOfStatement();
1641   }
1642   else {
1643     int64_t ExprValue;
1644     if (ParseAbsoluteExpression(ExprValue))
1645       return true;
1646
1647     if (Lexer.isNot(AsmToken::EndOfStatement))
1648       return TokError("unexpected token in '.elseif' directive");
1649
1650     Lex();
1651     TheCondState.CondMet = ExprValue;
1652     TheCondState.Ignore = !TheCondState.CondMet;
1653   }
1654
1655   return false;
1656 }
1657
1658 /// ParseDirectiveElse
1659 /// ::= .else
1660 bool AsmParser::ParseDirectiveElse(SMLoc DirectiveLoc) {
1661   // Consume the identifier that was the .else directive
1662   Lex();
1663
1664   if (Lexer.isNot(AsmToken::EndOfStatement))
1665     return TokError("unexpected token in '.else' directive");
1666
1667   Lex();
1668
1669   if (TheCondState.TheCond != AsmCond::IfCond &&
1670       TheCondState.TheCond != AsmCond::ElseIfCond)
1671       Error(DirectiveLoc, "Encountered a .else that doesn't follow a .if or an "
1672                           ".elseif");
1673   TheCondState.TheCond = AsmCond::ElseCond;
1674   bool LastIgnoreState = false;
1675   if (!TheCondStack.empty())
1676     LastIgnoreState = TheCondStack.back().Ignore;
1677   if (LastIgnoreState || TheCondState.CondMet)
1678     TheCondState.Ignore = true;
1679   else
1680     TheCondState.Ignore = false;
1681
1682   return false;
1683 }
1684
1685 /// ParseDirectiveEndIf
1686 /// ::= .endif
1687 bool AsmParser::ParseDirectiveEndIf(SMLoc DirectiveLoc) {
1688   // Consume the identifier that was the .endif directive
1689   Lex();
1690
1691   if (Lexer.isNot(AsmToken::EndOfStatement))
1692     return TokError("unexpected token in '.endif' directive");
1693
1694   Lex();
1695
1696   if ((TheCondState.TheCond == AsmCond::NoCond) ||
1697       TheCondStack.empty())
1698     Error(DirectiveLoc, "Encountered a .endif that doesn't follow a .if or "
1699                         ".else");
1700   if (!TheCondStack.empty()) {
1701     TheCondState = TheCondStack.back();
1702     TheCondStack.pop_back();
1703   }
1704
1705   return false;
1706 }
1707
1708 /// ParseDirectiveFile
1709 /// ::= .file [number] string
1710 bool AsmParser::ParseDirectiveFile(StringRef, SMLoc DirectiveLoc) {
1711   // FIXME: I'm not sure what this is.
1712   int64_t FileNumber = -1;
1713   if (Lexer.is(AsmToken::Integer)) {
1714     FileNumber = getTok().getIntVal();
1715     Lex();
1716
1717     if (FileNumber < 1)
1718       return TokError("file number less than one");
1719   }
1720
1721   if (Lexer.isNot(AsmToken::String))
1722     return TokError("unexpected token in '.file' directive");
1723
1724   StringRef Filename = getTok().getString();
1725   Filename = Filename.substr(1, Filename.size()-2);
1726   Lex();
1727
1728   if (Lexer.isNot(AsmToken::EndOfStatement))
1729     return TokError("unexpected token in '.file' directive");
1730
1731   if (FileNumber == -1)
1732     Out.EmitFileDirective(Filename);
1733   else
1734     Out.EmitDwarfFileDirective(FileNumber, Filename);
1735
1736   return false;
1737 }
1738
1739 /// ParseDirectiveLine
1740 /// ::= .line [number]
1741 bool AsmParser::ParseDirectiveLine(StringRef, SMLoc DirectiveLoc) {
1742   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1743     if (Lexer.isNot(AsmToken::Integer))
1744       return TokError("unexpected token in '.line' directive");
1745
1746     int64_t LineNumber = getTok().getIntVal();
1747     (void) LineNumber;
1748     Lex();
1749
1750     // FIXME: Do something with the .line.
1751   }
1752
1753   if (Lexer.isNot(AsmToken::EndOfStatement))
1754     return TokError("unexpected token in '.file' directive");
1755
1756   return false;
1757 }
1758
1759
1760 /// ParseDirectiveLoc
1761 /// ::= .loc number [number [number]]
1762 bool AsmParser::ParseDirectiveLoc(StringRef, SMLoc DirectiveLoc) {
1763   if (Lexer.isNot(AsmToken::Integer))
1764     return TokError("unexpected token in '.loc' directive");
1765
1766   // FIXME: What are these fields?
1767   int64_t FileNumber = getTok().getIntVal();
1768   (void) FileNumber;
1769   // FIXME: Validate file.
1770
1771   Lex();
1772   if (Lexer.isNot(AsmToken::EndOfStatement)) {
1773     if (Lexer.isNot(AsmToken::Integer))
1774       return TokError("unexpected token in '.loc' directive");
1775
1776     int64_t Param2 = getTok().getIntVal();
1777     (void) Param2;
1778     Lex();
1779
1780     if (Lexer.isNot(AsmToken::EndOfStatement)) {
1781       if (Lexer.isNot(AsmToken::Integer))
1782         return TokError("unexpected token in '.loc' directive");
1783
1784       int64_t Param3 = getTok().getIntVal();
1785       (void) Param3;
1786       Lex();
1787
1788       // FIXME: Do something with the .loc.
1789     }
1790   }
1791
1792   if (Lexer.isNot(AsmToken::EndOfStatement))
1793     return TokError("unexpected token in '.file' directive");
1794
1795   return false;
1796 }
1797