[MC] Fix Various End Of Line Comment checkings

[niravd]

Summary

Fix AsmParser lines to correctly handle end-of-line pre-processor
comments parsing when '#' is not the assembly line comment prefix.

[rnk]

lib/MC/MCParser/AsmParser.cpp

2973

HasComma

lib/MC/MCParser/MCAsmParser.cpp

71

I see a lot of usage of this that looks like:

bool HasComma;
parseOptionalToken(Comma, HasComma);
if (HasComma && ...)

Right now, this always returns false. Either the token is there and its not an error, or we consume it and its not an error. In that case, do you think we should indicate presence with the return type? It might be confusing because a boolean parse method return type usually indicates an error. WDYT? Usage would look like:

if (parseOptionalToken(AsmToken::Comma)) {
  if (parseIdentifier(...) || parseThing(...) || ...))
    return true / error / etc;
}

77

This feels like it's below parseToken. Any reason to not keep using Lex?

[niravd]

Modify parseOptionalToken

[niravd]

lib/MC/MCParser/MCAsmParser.cpp

71

I had a similar thought myself but I was unhappy with the fact that the clean way to write this involves multiple conditional statements which duplicates the error suffix additions so I was pushing it off to another cleanup patch while I pondered a cleaner solution. In any case there's no real issue doing it here so I've folded it in.

77

This is to correctly handle # preprocessor line comments as EndOfStatement for those cases that the lexer doesn't have the context.

[rnk]

lgtm

include/llvm/MC/MCParser/MCAsmParser.h

184

Please document the convention here, since it's not "return true on error".

include/llvm/MC/MCParser/MCAsmParser.h

bool printPendingErrors() {
     bool rv = !PendingErrors.empty();
     for (auto Err : PendingErrors) {
       printError(Err.Loc, Twine(Err.Msg), Err.Range);
     }
     PendingErrors.clear();
     return rv;
   }
 
+  bool addErrorSuffix(const Twine &Suffix);
+
   /// \brief Get the next AsmToken in the stream, possibly handling file
   /// inclusion first.
   virtual const AsmToken &Lex() = 0;
 
   /// \brief Get the current AsmToken from the stream.
   const AsmToken &getTok() const;
 
   /// \brief Report an error at the current lexer location.
   bool TokError(const Twine &Msg, SMRange Range = None);
 
   bool parseTokenLoc(SMLoc &Loc);
-  bool parseToken(AsmToken::TokenKind T, const Twine &Msg);
+  bool parseToken(AsmToken::TokenKind T, const Twine &Msg = "unexpected token");
   bool parseOptionalToken(AsmToken::TokenKind T, bool &Present);
 
   bool parseEOL(const Twine &ErrMsg);
 
+  bool parseMany(std::function<bool()> parseOne, bool hasComma = true);
+
   bool parseIntToken(int64_t &V, const Twine &ErrMsg);
 
   bool check(bool P, const llvm::Twine &Msg);
   bool check(bool P, SMLoc Loc, const llvm::Twine &Msg);
 
   /// \brief Parse an identifier or string (as a quoted identifier) and set \p
   /// Res to the identifier contents.
   virtual bool parseIdentifier(StringRef &Res) = 0;

lib/MC/MCParser/AsmParser.cpp

private:
 
   /// \brief Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
   // ".ascii", ".asciz", ".string"
   bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
   bool parseDirectiveReloc(SMLoc DirectiveLoc); // ".reloc"
-  bool parseDirectiveValue(unsigned Size); // ".byte", ".long", ...
-  bool parseDirectiveOctaValue(); // ".octa"
-  bool parseDirectiveRealValue(const fltSemantics &); // ".single", ...
+  bool parseDirectiveValue(StringRef IDVal,
+                           unsigned Size);       // ".byte", ".long", ...
+  bool parseDirectiveOctaValue(StringRef IDVal); // ".octa", ...
+  bool parseDirectiveRealValue(StringRef IDVal,
+                               const fltSemantics &); // ".single", ...
   bool parseDirectiveFill(); // ".fill"
   bool parseDirectiveZero(); // ".zero"
   // ".set", ".equ", ".equiv"
   bool parseDirectiveSet(StringRef IDVal, bool allow_redef);
   bool parseDirectiveOrg(); // ".org"
   // ".align{,32}", ".p2align{,w,l}"
   bool parseDirectiveAlign(bool IsPow2, unsigned ValueSize);
 
if (IDVal[0] == '.' && IDVal != ".") {
     case DK_EQUIV:
       return parseDirectiveSet(IDVal, false);
     case DK_ASCII:
       return parseDirectiveAscii(IDVal, false);
     case DK_ASCIZ:
     case DK_STRING:
       return parseDirectiveAscii(IDVal, true);
     case DK_BYTE:
-      return parseDirectiveValue(1);
+    case DK_DC_B:
+      return parseDirectiveValue(IDVal, 1);
+    case DK_DC:
+    case DK_DC_W:
     case DK_SHORT:
     case DK_VALUE:
     case DK_2BYTE:
-      return parseDirectiveValue(2);
+      return parseDirectiveValue(IDVal, 2);
     case DK_LONG:
     case DK_INT:
     case DK_4BYTE:
-      return parseDirectiveValue(4);
+    case DK_DC_L:
+      return parseDirectiveValue(IDVal, 4);
     case DK_QUAD:
     case DK_8BYTE:
-      return parseDirectiveValue(8);
+      return parseDirectiveValue(IDVal, 8);
+    case DK_DC_A:
+      return parseDirectiveValue(IDVal,
+                                 getContext().getAsmInfo()->getPointerSize());
     case DK_OCTA:
-      return parseDirectiveOctaValue();
+      return parseDirectiveOctaValue(IDVal);
     case DK_SINGLE:
     case DK_FLOAT:
-      return parseDirectiveRealValue(APFloat::IEEEsingle);
+    case DK_DC_S:
+      return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle);
     case DK_DOUBLE:
-      return parseDirectiveRealValue(APFloat::IEEEdouble);
+    case DK_DC_D:
+      return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble);
     case DK_ALIGN: {
       bool IsPow2 = !getContext().getAsmInfo()->getAlignmentIsInBytes();
       return parseDirectiveAlign(IsPow2, /*ExprSize=*/1);
     }
     case DK_ALIGN32: {
       bool IsPow2 = !getContext().getAsmInfo()->getAlignmentIsInBytes();
       return parseDirectiveAlign(IsPow2, /*ExprSize=*/4);
     }
if (IDVal[0] == '.' && IDVal != ".") {
     case DK_ERR:
       return parseDirectiveError(IDLoc, false);
     case DK_ERROR:
       return parseDirectiveError(IDLoc, true);
     case DK_WARNING:
       return parseDirectiveWarning(IDLoc);
     case DK_RELOC:
       return parseDirectiveReloc(IDLoc);
-    case DK_DC:
-      return parseDirectiveValue(2);
-    case DK_DC_A:
-      return parseDirectiveValue(getContext().getAsmInfo()->getPointerSize());
-    case DK_DC_B:
-      return parseDirectiveValue(1);
-    case DK_DC_D:
-      return parseDirectiveRealValue(APFloat::IEEEdouble);
-    case DK_DC_L:
-      return parseDirectiveValue(4);
-    case DK_DC_S:
-      return parseDirectiveRealValue(APFloat::IEEEsingle);
-    case DK_DC_W:
-      return parseDirectiveValue(2);
     case DK_DCB:
     case DK_DCB_W:
       return parseDirectiveDCB(IDVal, 2);
     case DK_DCB_B:
       return parseDirectiveDCB(IDVal, 1);
     case DK_DCB_D:
       return parseDirectiveRealDCB(IDVal, APFloat::IEEEdouble);
     case DK_DCB_L:

 }
 
 /// parseDirectiveSet:
 ///   ::= .equ identifier ',' expression
 ///   ::= .equiv identifier ',' expression
 ///   ::= .set identifier ',' expression
 bool AsmParser::parseDirectiveSet(StringRef IDVal, bool allow_redef) {
   StringRef Name;
-
-  if (check(parseIdentifier(Name),
-            "expected identifier after '" + Twine(IDVal) + "'") ||
-      parseToken(AsmToken::Comma, "unexpected token in '" + Twine(IDVal) + "'"))
-    return true;
-
-  return parseAssignment(Name, allow_redef, true);
+  if (check(parseIdentifier(Name), "expected identifier") ||
+      parseToken(AsmToken::Comma) || parseAssignment(Name, allow_redef, true))
+    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+  return false;
 }
 
 bool AsmParser::parseEscapedString(std::string &Data) {
-  assert(getLexer().is(AsmToken::String) && "Unexpected current token!");
+  if (check(getTok().isNot(AsmToken::String), "expected string"))
+    return true;
 
   Data = "";
   StringRef Str = getTok().getStringContents();
   for (unsigned i = 0, e = Str.size(); i != e; ++i) {
     if (Str[i] != '\\') {
       Data += Str[i];
       continue;
     }
bool AsmParser::parseEscapedString(std::string &Data) {
 
   Lex();
   return false;
 }
 
 /// parseDirectiveAscii:
 ///   ::= ( .ascii | .asciz | .string ) [ "string" ( , "string" )* ]
 bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (checkForValidSection())
-      return true;
-
-    while (true) {
-      std::string Data;
-      if (check(getTok().isNot(AsmToken::String),
-                "expected string in '" + Twine(IDVal) + "' directive") ||
-          parseEscapedString(Data))
-        return true;
-
-      getStreamer().EmitBytes(Data);
-      if (ZeroTerminated)
-        getStreamer().EmitBytes(StringRef("\0", 1));
+  auto parseOp = [&]() -> bool {
+    if (checkForValidSection() || parseEscapedString(Data))
+    return false;
+  };
 
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
-
-      if (parseToken(AsmToken::Comma,
-                     "unexpected token in '" + Twine(IDVal) + "' directive"))
-        return true;
-    }
-  }
-
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 
 /// parseDirectiveReloc
 ///  ::= .reloc expression , identifier [ , expression ]
 bool AsmParser::parseDirectiveReloc(SMLoc DirectiveLoc) {
   const MCExpr *Offset;
   const MCExpr *Expr = nullptr;
 
   SMLoc OffsetLoc = Lexer.getTok().getLoc();
+  int64_t OffsetValue;
+  // We can only deal with constant expressions at the moment.
+
   if (parseExpression(Offset))
     return true;
 
-  // We can only deal with constant expressions at the moment.
-  int64_t OffsetValue;
   if (check(!Offset->evaluateAsAbsolute(OffsetValue), OffsetLoc,
             "expression is not a constant value") ||
       check(OffsetValue < 0, OffsetLoc, "expression is negative") ||
       parseToken(AsmToken::Comma, "expected comma") ||
       check(getTok().isNot(AsmToken::Identifier), "expected relocation name"))
     return true;
 
   SMLoc NameLoc = Lexer.getTok().getLoc();
bool AsmParser::parseDirectiveReloc(SMLoc DirectiveLoc) {
   if (getStreamer().EmitRelocDirective(*Offset, Name, Expr, DirectiveLoc))
     return Error(NameLoc, "unknown relocation name");
 
   return false;
 }
 
 /// parseDirectiveValue
 ///  ::= (.byte | .short | ... ) [ expression (, expression)* ]
-bool AsmParser::parseDirectiveValue(unsigned Size) {
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (checkForValidSection())
-      return true;
-
-    while (true) {
-      const MCExpr *Value;
-      SMLoc ExprLoc = getLexer().getLoc();
-      if (parseExpression(Value))
-        return true;
-
-      // Special case constant expressions to match code generator.
-      if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
-        assert(Size <= 8 && "Invalid size");
-        uint64_t IntValue = MCE->getValue();
-        if (!isUIntN(8 * Size, IntValue) && !isIntN(8 * Size, IntValue))
-          return Error(ExprLoc, "literal value out of range for directive");
-        getStreamer().EmitIntValue(IntValue, Size);
-      } else
-        getStreamer().EmitValue(Value, Size, ExprLoc);
+bool AsmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
+  auto parseOp = [&]() -> bool {
+    if (checkForValidSection() || parseExpression(Value))
+        return Error(ExprLoc, "out of range literal value");
+    return false;
+  };
 
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
-
-      // FIXME: Improve diagnostic.
-      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-        return true;
-    }
-  }
-
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 
 /// ParseDirectiveOctaValue
 ///  ::= .octa [ hexconstant (, hexconstant)* ]
-bool AsmParser::parseDirectiveOctaValue() {
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (checkForValidSection())
-      return true;
 
-    while (true) {
-      if (getTok().is(AsmToken::Error))
-        return true;
-      if (getTok().isNot(AsmToken::Integer) && getTok().isNot(AsmToken::BigNum))
-        return TokError("unknown token in expression");
-
-      SMLoc ExprLoc = getLexer().getLoc();
-      APInt IntValue = getTok().getAPIntVal();
-      Lex();
-
-      uint64_t hi, lo;
-      if (IntValue.isIntN(64)) {
-        hi = 0;
-        lo = IntValue.getZExtValue();
-      } else if (IntValue.isIntN(128)) {
-        // It might actually have more than 128 bits, but the top ones are zero.
-        hi = IntValue.getHiBits(IntValue.getBitWidth() - 64).getZExtValue();
-        lo = IntValue.getLoBits(64).getZExtValue();
-      } else
-        return Error(ExprLoc, "literal value out of range for directive");
-
-      if (MAI.isLittleEndian()) {
-        getStreamer().EmitIntValue(lo, 8);
-        getStreamer().EmitIntValue(hi, 8);
-      } else {
-        getStreamer().EmitIntValue(hi, 8);
-        getStreamer().EmitIntValue(lo, 8);
-      }
+bool AsmParser::parseDirectiveOctaValue(StringRef IDVal) {
+  auto parseOp = [&]() -> bool {
+    if (checkForValidSection())
+    SMLoc ExprLoc = getTok().getLoc();
+    Lex();
+    if (!IntValue.isIntN(128))
+      return Error(ExprLoc, "out of range literal value");
+    if (!IntValue.isIntN(64)) {
+    } else {
+      hi = 0;
+      lo = IntValue.getZExtValue();
+    }
+    return false;
+  };
 
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
-
-      // FIXME: Improve diagnostic.
-      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-        return true;
-    }
-  }
-
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 
 bool AsmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   // We don't truly support arithmetic on floating point expressions, so we
   // have to manually parse unary prefixes.
   bool IsNeg = false;
   if (getLexer().is(AsmToken::Minus)) {
bool AsmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
 
   Res = Value.bitcastToAPInt();
 
   return false;
 }
 
 /// parseDirectiveRealValue
 ///  ::= (.single | .double) [ expression (, expression)* ]
-bool AsmParser::parseDirectiveRealValue(const fltSemantics &Semantics) {
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (checkForValidSection())
-      return true;
-
-    while (true) {
-      APInt AsInt;
-      if (parseRealValue(Semantics, AsInt))
-        return true;
-
-      getStreamer().EmitIntValue(AsInt.getLimitedValue(),
-                                 AsInt.getBitWidth() / 8);
+bool AsmParser::parseDirectiveRealValue(StringRef IDVal,
+                                        const fltSemantics &Semantics) {
+  auto parseOp = [&]() -> bool {
+    if (checkForValidSection() || parseRealValue(Semantics, AsInt))
+    return false;
+  };
 
-      if (Lexer.is(AsmToken::EndOfStatement))
-        break;
-
-      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-        return true;
-    }
-  }
-
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   return false;
 }
 
 /// parseDirectiveZero
 ///  ::= .zero expression
 bool AsmParser::parseDirectiveZero() {
   SMLoc NumBytesLoc = Lexer.getLoc();
   const MCExpr *NumBytes;
bool AsmParser::parseDirectiveFill() {
   const MCExpr *NumValues;
   if (checkForValidSection() || parseExpression(NumValues))
     return true;
 
   int64_t FillSize = 1;
   int64_t FillExpr = 0;
 
   SMLoc SizeLoc, ExprLoc;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
 
-    if (parseToken(AsmToken::Comma, "unexpected token in '.fill' directive") ||
-        parseTokenLoc(SizeLoc) || parseAbsoluteExpression(FillSize))
-      return true;
-
-    if (getLexer().isNot(AsmToken::EndOfStatement)) {
-      if (parseToken(AsmToken::Comma,
-                     "unexpected token in '.fill' directive") ||
-          parseTokenLoc(ExprLoc) || parseAbsoluteExpression(FillExpr) ||
-          parseToken(AsmToken::EndOfStatement,
-                     "unexpected token in '.fill' directive"))
+  bool HasComma;
+  parseOptionalToken(AsmToken::Comma, HasComma);
+  if (HasComma) {
+    SizeLoc = getTok().getLoc();
+    if (parseAbsoluteExpression(FillSize))
+      return true;
+    parseOptionalToken(AsmToken::Comma, HasComma);
+    if (HasComma) {
+      ExprLoc = getTok().getLoc();
+      if (parseAbsoluteExpression(FillExpr))
         return true;
     }
   }
+  if (parseToken(AsmToken::EndOfStatement,
+                 "unexpected token in '.fill' directive"))
+    return true;
 
   if (FillSize < 0) {
     Warning(SizeLoc, "'.fill' directive with negative size has no effect");
     return false;
   }
   if (FillSize > 8) {
     Warning(SizeLoc, "'.fill' directive with size greater than 8 has been truncated to 8");
     FillSize = 8;

 ///  ::= .org expression [ , expression ]
 bool AsmParser::parseDirectiveOrg() {
   const MCExpr *Offset;
   if (checkForValidSection() || parseExpression(Offset))
     return true;
 
   // Parse optional fill expression.
   int64_t FillExpr = 0;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (parseToken(AsmToken::Comma, "unexpected token in '.org' directive") ||
-        parseAbsoluteExpression(FillExpr))
-      return true;
-  }
-
-  if (parseToken(AsmToken::EndOfStatement,
-                 "unexpected token in '.org' directive"))
-    return true;
+  bool hasComma;
+  parseOptionalToken(AsmToken::Comma, hasComma);
+  if ((hasComma && parseAbsoluteExpression(FillExpr)) ||
+      parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in '.org' directive");
 
   getStreamer().emitValueToOffset(Offset, FillExpr);
   return false;
 }
 
 /// parseDirectiveAlign
 ///  ::= {.align, ...} expression [ , expression [ , expression ]]
 bool AsmParser::parseDirectiveAlign(bool IsPow2, unsigned ValueSize) {
   SMLoc AlignmentLoc = getLexer().getLoc();
   int64_t Alignment;
-  if (checkForValidSection() || parseAbsoluteExpression(Alignment))
-    return true;
-
   SMLoc MaxBytesLoc;
   bool HasFillExpr = false;
   int64_t FillExpr = 0;
   int64_t MaxBytesToFill = 0;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-      return true;
 
+  auto parseAlign = [&]() -> bool {
+    if (checkForValidSection() || parseAbsoluteExpression(Alignment))
+      return true;
+    bool hasComma;
+    parseOptionalToken(AsmToken::Comma, hasComma);
+    if (hasComma) {
       // The fill expression can be omitted while specifying a maximum number of
       // alignment bytes, e.g:
       //  .align 3,,4
       if (getTok().isNot(AsmToken::Comma)) {
         HasFillExpr = true;
         if (parseAbsoluteExpression(FillExpr))
           return true;
       }
-
-    if (getTok().isNot(AsmToken::EndOfStatement)) {
-      if (parseToken(AsmToken::Comma, "unexpected token in directive") ||
-          parseTokenLoc(MaxBytesLoc) || parseAbsoluteExpression(MaxBytesToFill))
+      parseOptionalToken(AsmToken::Comma, hasComma);
+      if (hasComma && (parseTokenLoc(MaxBytesLoc) ||
+                       parseAbsoluteExpression(MaxBytesToFill)))
         return true;
     }
-  }
-
-  if (parseToken(AsmToken::EndOfStatement, "unexpected token in directive"))
-    return true;
+    return parseToken(AsmToken::EndOfStatement);
+  };
 
-  if (!HasFillExpr)
-    FillExpr = 0;
+  if (parseAlign())
+    return addErrorSuffix(" in directive");
 
   // Always emit an alignment here even if we thrown an error.
   bool ReturnVal = false;
 
   // Compute alignment in bytes.
   if (IsPow2) {
     // FIXME: Diagnose overflow.
     if (Alignment >= 32) {
bool AsmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
 
   return false;
 }
 
 /// parseDirectiveLine
 /// ::= .line [number]
 bool AsmParser::parseDirectiveLine() {
   int64_t LineNumber;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
+  if (getLexer().is(AsmToken::Integer)) {
     if (parseIntToken(LineNumber, "unexpected token in '.line' directive"))
       return true;
     (void)LineNumber;
     // FIXME: Do something with the .line.
   }
   if (parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.line' directive"))
     return true;
if (getLexer().is(AsmToken::Integer)) {
     if (ColumnPos < 0)
       return TokError("column position less than zero in '.loc' directive");
     Lex();
   }
 
   unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
   unsigned Isa = 0;
   int64_t Discriminator = 0;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    while (true) {
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
 
-      StringRef Name;
-      SMLoc Loc = getTok().getLoc();
-      if (parseIdentifier(Name))
-        return TokError("unexpected token in '.loc' directive");
+  auto parseLocOp = [&]() -> bool {
 
-      if (Name == "basic_block")
-        Flags |= DWARF2_FLAG_BASIC_BLOCK;
-      else if (Name == "prologue_end")
-        Flags |= DWARF2_FLAG_PROLOGUE_END;
-      else if (Name == "epilogue_begin")
-        Flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
-      else if (Name == "is_stmt") {
-        Loc = getTok().getLoc();
-        const MCExpr *Value;
-        if (parseExpression(Value))
-          return true;
-        // The expression must be the constant 0 or 1.
-        if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
-          int Value = MCE->getValue();
-          if (Value == 0)
-            Flags &= ~DWARF2_FLAG_IS_STMT;
-          else if (Value == 1)
-            Flags |= DWARF2_FLAG_IS_STMT;
-          else
-            return Error(Loc, "is_stmt value not 0 or 1");
-        } else {
-          return Error(Loc, "is_stmt value not the constant value of 0 or 1");
-        }
-      } else if (Name == "isa") {
-        Loc = getTok().getLoc();
-        const MCExpr *Value;
-        if (parseExpression(Value))
-          return true;
-        // The expression must be a constant greater or equal to 0.
-        if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
-          int Value = MCE->getValue();
-          if (Value < 0)
-            return Error(Loc, "isa number less than zero");
-          Isa = Value;
-        } else {
-          return Error(Loc, "isa number not a constant value");
-        }
-      } else if (Name == "discriminator") {
-        if (parseAbsoluteExpression(Discriminator))
-          return true;
-      } else {
-        return Error(Loc, "unknown sub-directive in '.loc' directive");
-      }
+    return false;
+  };
 
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
-    }
-  }
-  Lex();
+  if (parseMany(parseLocOp))
+    return true;
 
   getStreamer().EmitDwarfLocDirective(FileNumber, LineNumber, ColumnPos, Flags,
                                       Isa, Discriminator, StringRef());
 
   return false;
 }
 
 /// parseDirectiveStabs
if (parseIntToken(FileNumber,
       // Usually directory and filename are together, otherwise just
       // directory. Allow the strings to have escaped octal character sequence.
       parseEscapedString(Filename) ||
       parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.cv_file' directive"))
     return true;
 
   if (!getStreamer().EmitCVFileDirective(FileNumber, Filename))
-    Error(FileNumberLoc, "file number already allocated");
+    return Error(FileNumberLoc, "file number already allocated");
 
   return false;
 }
 
 bool AsmParser::parseCVFunctionId(int64_t &FunctionId,
                                   StringRef DirectiveName) {
   SMLoc Loc;
   return parseTokenLoc(Loc) ||
bool AsmParser::parseDirectiveCVFuncId() {
   int64_t FunctionId;
 
   if (parseCVFunctionId(FunctionId, ".cv_func_id") ||
       parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.cv_func_id' directive"))
     return true;
 
   if (!getStreamer().EmitCVFuncIdDirective(FunctionId))
-    Error(FunctionIdLoc, "function id already allocated");
+    return Error(FunctionIdLoc, "function id already allocated");
 
   return false;
 }
 
 /// parseDirectiveCVInlineSiteId
 /// ::= .cv_inline_site_id FunctionId
 ///         "within" IAFunc
 ///         "inlined_at" IAFile IALine [IACol]
if (getLexer().is(AsmToken::Integer)) {
     ColumnPos = getTok().getIntVal();
     if (ColumnPos < 0)
       return TokError("column position less than zero in '.cv_loc' directive");
     Lex();
   }
 
   bool PrologueEnd = false;
   uint64_t IsStmt = 0;
-  while (getLexer().isNot(AsmToken::EndOfStatement)) {
+
+  auto parseOp = [&]() -> bool {
     StringRef Name;
     SMLoc Loc = getTok().getLoc();
     if (parseIdentifier(Name))
       return TokError("unexpected token in '.cv_loc' directive");
-
     if (Name == "prologue_end")
       PrologueEnd = true;
     else if (Name == "is_stmt") {
       Loc = getTok().getLoc();
       const MCExpr *Value;
       if (parseExpression(Value))
         return true;
       // The expression must be the constant 0 or 1.
       IsStmt = ~0ULL;
       if (const auto *MCE = dyn_cast<MCConstantExpr>(Value))
         IsStmt = MCE->getValue();
 
       if (IsStmt > 1)
         return Error(Loc, "is_stmt value not 0 or 1");
     } else {
       return Error(Loc, "unknown sub-directive in '.cv_loc' directive");
     }
-  }
-  Lex();
+    return false;
+  };
+
+  if (parseMany(parseOp, false /*hasComma*/))
+    return true;
 
   getStreamer().EmitCVLocDirective(FunctionId, FileNumber, LineNumber,
                                    ColumnPos, PrologueEnd, IsStmt, StringRef(),
                                    DirectiveLoc);
   return false;
 }
 
 /// parseDirectiveCVLinetable
bool AsmParser::parseDirectiveCFISections() {
   getStreamer().EmitCFISections(EH, Debug);
   return false;
 }
 
 /// parseDirectiveCFIStartProc
 /// ::= .cfi_startproc [simple]
 bool AsmParser::parseDirectiveCFIStartProc() {
   StringRef Simple;
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    if (parseIdentifier(Simple) || Simple != "simple")
-      return TokError("unexpected token in .cfi_startproc directive");
 
-  if (parseToken(AsmToken::EndOfStatement, "Expected end of statement"))
-    return true;
+  bool EOL;
+  parseOptionalToken(AsmToken::EndOfStatement, EOL);
+  if (!EOL) {
+    if (check(parseIdentifier(Simple) || Simple != "simple",
+              "unexpected token") ||
+        parseToken(AsmToken::EndOfStatement))
+      return addErrorSuffix(" in '.cfi_startproc' directive");
+  }
 
   getStreamer().EmitCFIStartProc(!Simple.empty());
   return false;
 }
 
 /// parseDirectiveCFIEndProc
 /// ::= .cfi_endproc
 bool AsmParser::parseDirectiveCFIEndProc() {

 
 /// parseDirectiveBundleLock
 /// ::= {.bundle_lock} [align_to_end]
 bool AsmParser::parseDirectiveBundleLock() {
   if (checkForValidSection())
     return true;
   bool AlignToEnd = false;
 
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    StringRef Option;
-    SMLoc Loc = getTok().getLoc();
-    const char *kInvalidOptionError =
-        "invalid option for '.bundle_lock' directive";
 
+  bool EOL;
+  parseOptionalToken(AsmToken::EndOfStatement, EOL);
+  if (!EOL) {
     if (check(parseIdentifier(Option), Loc, kInvalidOptionError) ||
         check(Option != "align_to_end", Loc, kInvalidOptionError) ||
-        check(getTok().isNot(AsmToken::EndOfStatement), Loc,
+        parseToken(AsmToken::EndOfStatement,
                    "unexpected token after '.bundle_lock' directive option"))
       return true;
     AlignToEnd = true;
   }
 
-  Lex();
-
   getStreamer().EmitBundleLock(AlignToEnd);
   return false;
 }
 
 /// parseDirectiveBundleLock
 /// ::= {.bundle_lock}
 bool AsmParser::parseDirectiveBundleUnlock() {
   if (checkForValidSection() ||

 bool AsmParser::parseDirectiveSpace(StringRef IDVal) {
 
   SMLoc NumBytesLoc = Lexer.getLoc();
   const MCExpr *NumBytes;
   if (checkForValidSection() || parseExpression(NumBytes))
     return true;
 
   int64_t FillExpr = 0;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-
-    if (parseToken(AsmToken::Comma,
-                   "unexpected token in '" + Twine(IDVal) + "' directive") ||
-        parseAbsoluteExpression(FillExpr))
-      return true;
-  }
-
-  if (parseToken(AsmToken::EndOfStatement,
-                 "unexpected token in '" + Twine(IDVal) + "' directive"))
-    return true;
+  bool hasComma;
+  parseOptionalToken(AsmToken::Comma, hasComma);
+  if ((hasComma && parseAbsoluteExpression(FillExpr)) ||
+      parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix("in '" + Twine(IDVal) + "' directive");
 
   // FIXME: Sometimes the fill expr is 'nop' if it isn't supplied, instead of 0.
   getStreamer().emitFill(*NumBytes, FillExpr, NumBytesLoc);
 
   return false;
 }
 
 /// parseDirectiveDCB

 }
 
 /// parseDirectiveLEB128
 /// ::= (.sleb128 | .uleb128) [ expression (, expression)* ]
 bool AsmParser::parseDirectiveLEB128(bool Signed) {
   if (checkForValidSection())
     return true;
 
+  auto parseOp = [&]() -> bool {
     const MCExpr *Value;
-
-  while (true) {
     if (parseExpression(Value))
       return true;
-
     if (Signed)
       getStreamer().EmitSLEB128Value(Value);
     else
       getStreamer().EmitULEB128Value(Value);
+    return false;
+  };
 
-    if (getLexer().is(AsmToken::EndOfStatement))
-      break;
-
-    if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-      return true;
-  }
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in directive");
 
   return false;
 }
 
 /// parseDirectiveSymbolAttribute
 ///  ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
 bool AsmParser::parseDirectiveSymbolAttribute(MCSymbolAttr Attr) {
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    while (true) {
-      StringRef Name;
-      SMLoc Loc = getTok().getLoc();
-
-      if (parseIdentifier(Name))
-        return Error(Loc, "expected identifier in directive");
-
-      MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
+  auto parseOp = [&]() -> bool {
+      return Error(Loc, "expected identifier");
 
-      // Assembler local symbols don't make any sense here. Complain loudly.
-      if (Sym->isTemporary())
-        return Error(Loc, "non-local symbol required in directive");
+      return Error(Loc, "non-local symbol required");
 
-      if (!getStreamer().EmitSymbolAttribute(Sym, Attr))
-        return Error(Loc, "unable to emit symbol attribute");
+    return false;
+  };
 
-      if (getLexer().is(AsmToken::EndOfStatement))
-        break;
-
-      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
-        return true;
-    }
-  }
-
-  Lex();
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in directive");
   return false;
 }
 
 /// parseDirectiveComm
 ///  ::= ( .comm | .lcomm ) identifier , size_expression [ , align_expression ]
 bool AsmParser::parseDirectiveComm(bool IsLocal) {
   if (checkForValidSection())
     return true;
if (getLexer().is(AsmToken::Comma)) {
     if ((!IsLocal && Lexer.getMAI().getCOMMDirectiveAlignmentIsInBytes()) ||
         (IsLocal && LCOMM == LCOMM::ByteAlignment)) {
       if (!isPowerOf2_64(Pow2Alignment))
         return Error(Pow2AlignmentLoc, "alignment must be a power of 2");
       Pow2Alignment = Log2_64(Pow2Alignment);
     }
   }
 
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in '.comm' or '.lcomm' directive");
-
-  Lex();
+  if (parseToken(AsmToken::EndOfStatement,
+                 "unexpected token in '.comm' or '.lcomm' directive"))
+    return true;
 
   // NOTE: a size of zero for a .comm should create a undefined symbol
   // but a size of .lcomm creates a bss symbol of size zero.
   if (Size < 0)
     return Error(SizeLoc, "invalid '.comm' or '.lcomm' directive size, can't "
                           "be less than zero");
 
   // NOTE: The alignment in the directive is a power of 2 value, the assembler
bool AsmParser::parseDirectiveIncbin() {
   if (check(getTok().isNot(AsmToken::String),
             "expected string in '.incbin' directive") ||
       parseEscapedString(Filename))
     return true;
 
   int64_t Skip = 0;
   const MCExpr *Count = nullptr;
   SMLoc SkipLoc, CountLoc;
-  if (getLexer().isNot(AsmToken::EndOfStatement)) {
-    if (parseToken(AsmToken::Comma, "unexpected token in '.incbin' directive"))
-      return true;
-
+  bool HasComma;
+  parseOptionalToken(AsmToken::Comma, HasComma);
+  if (HasComma) {
     // The skip expression can be omitted while specifying the count, e.g:
     //  .incbin "filename",,4
     if (getTok().isNot(AsmToken::Comma)) {
       if (parseTokenLoc(SkipLoc) || parseAbsoluteExpression(Skip))
         return true;
     }
-
-    if (getLexer().isNot(AsmToken::EndOfStatement)) {
-      if (parseToken(AsmToken::Comma, "unexpected token in '.incbin' directive") ||
-          parseTokenLoc(CountLoc) || parseExpression(Count))
+    parseOptionalToken(AsmToken::Comma, HasComma);
+    if (HasComma) {
+      CountLoc = getTok().getLoc();
+      if (parseExpression(Count))
         return true;
     }
   }
 
   if (parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.incbin' directive"))
     return true;
 
bool AsmParser::parseDirectiveElseIf(SMLoc DirectiveLoc) {
   if (LastIgnoreState || TheCondState.CondMet) {
     TheCondState.Ignore = true;
     eatToEndOfStatement();
   } else {
     int64_t ExprValue;
     if (parseAbsoluteExpression(ExprValue))
       return true;
 
-    if (getLexer().isNot(AsmToken::EndOfStatement))
-      return TokError("unexpected token in '.elseif' directive");
+    if (parseToken(AsmToken::EndOfStatement,
+                   "unexpected token in '.elseif' directive"))
+      return true;
 
-    Lex();
     TheCondState.CondMet = ExprValue;
     TheCondState.Ignore = !TheCondState.CondMet;
   }
 
   return false;
 }
 
 /// parseDirectiveElse

 /// parseDirectiveEnd
 /// ::= .end
 bool AsmParser::parseDirectiveEnd(SMLoc DirectiveLoc) {
   if (parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.end' directive"))
     return true;
 
   while (Lexer.isNot(AsmToken::Eof))
-    Lex();
+    Lexer.Lex();
 
   return false;
 }
 
 /// parseDirectiveError
 ///   ::= .err
 ///   ::= .error [string]
 bool AsmParser::parseDirectiveError(SMLoc L, bool WithMessage) {
bool AsmParser::parseDirectiveWarning(SMLoc L) {
   if (!TheCondStack.empty()) {
     if (TheCondStack.back().Ignore) {
       eatToEndOfStatement();
       return false;
     }
   }
 
   StringRef Message = ".warning directive invoked in source file";
-  if (Lexer.isNot(AsmToken::EndOfStatement)) {
+
+  bool EOL;
+  parseOptionalToken(AsmToken::EndOfStatement, EOL);
+  if (!EOL) {
     if (Lexer.isNot(AsmToken::String))
       return TokError(".warning argument must be a string");
 
     Message = getTok().getStringContents();
     Lex();
+    if (parseToken(AsmToken::EndOfStatement,
+                   "expected end of statement in '.warning' directive"))
+      return true;
   }
 
   return Warning(L, Message);
 }
 
 /// parseDirectiveEndIf
 /// ::= .endif
 bool AsmParser::parseDirectiveEndIf(SMLoc DirectiveLoc) {

 bool parseAssignmentExpression(StringRef Name, bool allow_redef,
                                MCAsmParser &Parser, MCSymbol *&Sym,
                                const MCExpr *&Value) {
 
   // FIXME: Use better location, we should use proper tokens.
   SMLoc EqualLoc = Parser.getTok().getLoc();
 
   if (Parser.parseExpression(Value)) {
-    Parser.TokError("missing expression");
-    return true;
+    return Parser.TokError("missing expression");
   }
 
   // Note: we don't count b as used in "a = b". This is to allow
   // a = b
   // b = c
 
-  if (Parser.getTok().isNot(AsmToken::EndOfStatement))
-    return Parser.TokError("unexpected token in assignment");
-
-  // Eat the end of statement marker.
-  Parser.Lex();
+  if (Parser.parseToken(AsmToken::EndOfStatement))
+    return true;
 
   // Validate that the LHS is allowed to be a variable (either it has not been
   // used as a symbol, or it is an absolute symbol).
   Sym = Parser.getContext().lookupSymbol(Name);
   if (Sym) {
     // Diagnose assignment to a label.
     //
     // FIXME: Diagnostics. Note the location of the definition as a label.

lib/MC/MCParser/MCAsmParser.cpp

 bool MCAsmParser::parseIntToken(int64_t &V, const Twine &Msg) {
   if (getTok().getKind() != AsmToken::Integer)
     return TokError(Msg);
   V = getTok().getIntVal();
   Lex();
   return false;
 }
 
 bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T, bool &Present) {
   Present = (getTok().getKind() == T);
+  // if token is EOL and current token is # this is an EOL comment.
+  if (getTok().getKind() == AsmToken::Hash && T == AsmToken::EndOfStatement)
+    Present = true;
   if (Present)
-    Lex();
+    parseToken(T);
   return false;
 }
 
 bool MCAsmParser::check(bool P, const Twine &Msg) {
   return check(P, getTok().getLoc(), Msg);
 }
 
 bool MCAsmParser::check(bool P, SMLoc Loc, const Twine &Msg) {

 bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
   HadError = true;
 
   MCPendingError PErr;
   PErr.Loc = L;
   Msg.toVector(PErr.Msg);
   PErr.Range = Range;
   PendingErrors.push_back(PErr);
+
+  // If we threw this parsing error after a lexing error, this should
+  // supercede the lexing error and so we remove it from the Lexer
+  // before it can propagate
+  if (getTok().is(AsmToken::Error))
+    getLexer().Lex();
+  return true;
+}
+
+bool MCAsmParser::addErrorSuffix(const Twine &Suffix) {
+  // Make sure lexing errors have propagated to the parser.
+  if (getTok().is(AsmToken::Error))
+    Lex();
+  for (auto &PErr : PendingErrors)
+    Suffix.toVector(PErr.Msg);
   return true;
 }
 
+bool MCAsmParser::parseMany(std::function<bool()> parseOne, bool hasComma) {
+  bool EOL;
+  if (!parseOptionalToken(AsmToken::EndOfStatement, EOL) && EOL)
+    return false;
+  while (1) {
+    if (parseOne())
+      return true;
+    parseOptionalToken(AsmToken::EndOfStatement, EOL);
+    if (EOL)
+      return false;
+    if (hasComma && parseToken(AsmToken::Comma))
+      return true;
+  }
+  return false;
+}
+
 bool MCAsmParser::parseExpression(const MCExpr *&Res) {
   SMLoc L;
   return parseExpression(Res, L);
 }
 
 LLVM_DUMP_METHOD void MCParsedAsmOperand::dump() const {
   dbgs() << "  " << *this;
 }

test/MC/AsmParser/AArch64/directive-parse-err.s

+// RUN: not llvm-mc -triple aarch64-unknown-unknown %s 2>&1 | FileCheck %s
+// RUN: not llvm-mc -triple aarch64-unknown-unknown %s 2>&1 | grep "error:" | count 60
+
+  // CHECK: [[@LINE+1]]:19: error: unexpected token in '.equ' directive
+  .equ   ident1, 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .equ   ident1, 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:19: error: unexpected token in '.equiv' directive
+  .equiv ident2, 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .equiv ident2, 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:19: error: unexpected token in '.set' directive
+  .set   ident3, 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .set   ident3, 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:20: error: unexpected token in '.ascii' directive
+  .ascii  "string1" $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .ascii  "string1" # EOL COMMENT
+  // CHECK: [[@LINE+1]]:20: error: unexpected token in '.asciz' directive
+  .asciz  "string2" $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .asciz  "string2" # EOL COMMENT
+  // CHECK: [[@LINE+1]]:20: error: unexpected token in '.string' directive
+  .string "string3" $ 
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .string "string3" # EOL COMMENT 
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.byte' directive
+  .byte 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .byte 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.b' directive
+  .dc.b 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.b 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:8: error: unexpected token in '.dc' directive
+  .dc 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.b 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.w' directive
+  .dc.w 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.w 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.short' directive
+  .short 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .short 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.value' directive
+  .value 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .value 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.2byte' directive
+  .2byte 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .2byte 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.long' directive
+  .long 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .long 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.int' directive
+  .int  0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .int  0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.4byte' directive
+  .4byte 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .4byte 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.l' directive
+  .dc.l 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.l 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.quad' directive
+  .quad 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .quad 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.8byte' directive
+  .8byte 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .8byte 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.a' directive
+  .dc.a 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.a 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.octa' directive
+  .octa 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .octa 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:12: error: unexpected token in '.single' directive
+  .single 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .single 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in '.float' directive
+  .float 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .float 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.s' directive
+  .dc.s 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.s 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:12: error: unexpected token in '.double' directive
+  .double 0 $ 
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .double 0 # EOL COMMENT 
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.dc.d' directive
+  .dc.d 0 $   
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .dc.d 0 # EOL COMMENT   
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in '.fill' directive
+  .fill 1, 1 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .fill 1, 1 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:17: error: unexpected token in '.fill' directive
+  .fill 1, 1, 10 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .fill 1, 1, 10 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:16: error: unexpected token in '.org' directive
+        .org 1 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+        .org 1 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:11: error: unexpected token in directive  
+  .align 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .align 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .align32 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .align32 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:12: error: unexpected token in directive
+  .balign 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .balign 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .balignw 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .balignw 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .balignl 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .balignl 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .p2align 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .p2align 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:14: error: unexpected token in directive
+  .p2alignw 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .p2alignw 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:14: error: unexpected token in directive
+  .p2alignl 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .p2alignl 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:8: error: unexpected token in '.line' directive
+  .line $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .line # EOL COMMENT
+  // CHECK: [[@LINE+1]]:10: error: unexpected token in '.line' directive
+  .line 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .line 0 # EOL COMMENT
+
+  .file 1 "hello"
+  // CHECK: [[@LINE+1]]:16: error: unexpected token in '.loc' directive
+        .loc 1 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+        .loc 1 # EOL COMMENT  
+
+  // CHECK: [[@LINE+1]]:21: error: unexpected token in '.cv_file' directive
+  .cv_file 1 "hello" $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .cv_file 1 "hello" # EOL COMMENT
+
+  .cv_func_id 1
+  // CHECK: [[@LINE+1]]:14: error: unexpected token in '.cv_loc' directive
+  .cv_loc 1 1 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .cv_loc 1 1 # EOL COMMENT
+  
+  // CHECK: [[@LINE+1]]:28: error: unexpected token after '.bundle_lock' directive option
+  .bundle_lock align_to_end $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .bundle_lock align_to_end # EOL COMMENT 
+  
+  // CHECK: [[@LINE+1]]:11: error: invalid token in expression in directive
+  .sleb128 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .sleb128 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .sleb128 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .sleb128 0 # EOL COMMENT
+
+  // CHECK: [[@LINE+1]]:11: error: invalid token in expression in directive
+  .uleb128 $  
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .uleb128 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:13: error: unexpected token in directive
+  .uleb128 0 $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .uleb128 0 # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token
+  .globl a1                    $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .globl a1                    # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .global a2                   $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .global a2                   # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .lazy_reference a3           $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .lazy_reference a3           # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .symbol_resolver a4          $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .symbol_resolver a4          # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .private_extern a5           $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .private_extern a5           # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .reference a6                $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .reference a6                # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .weak_definition a7          $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .weak_definition a7          # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .weak_reference a8           $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .weak_reference a8           # EOL COMMENT
+  // CHECK: [[@LINE+1]]:31: error: unexpected token in directive
+  .weak_def_can_be_hidden a9   $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .weak_def_can_be_hidden a9   # EOL COMMENT  
+  // CHECK: [[@LINE+1]]:12: error: .warning argument must be a string
+  .warning  $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .warning  # EOL COMMENT
+  // CHECK: [[@LINE+1]]:21: error: expected end of statement in '.warning' directive
+  .warning "warning" $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .warning "warning" # EOL COMMENT
+
+
+  // CHECK: [[@LINE+1]]:17: error: unexpected token in '.cfi_startproc' directive
+  .cfi_startproc $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .cfi_startproc # EOL COMMENT
+  .cfi_endproc
+  // CHECK: [[@LINE+1]]:24: error: unexpected token in '.cfi_startproc' directive
+  .cfi_startproc simple $
+  // CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+  .cfi_startproc simple # EOL COMMENT
+  .cfi_endproc
+
+  
+  // CHECK-NOT: error:   

test/MC/AsmParser/AArch64/lit.local.cfg

+if 'AArch64' not in config.root.targets:
+    config.unsupported = True

test/MC/AsmParser/exprs-invalid.s

 // RUN: not llvm-mc -triple x86_64-apple-darwin10 %s 2> %t.err | FileCheck %s
 // RUN: FileCheck --check-prefix=CHECK-ERRORS %s < %t.err
 // CHECK:   .section  __TEXT,__text,regular,pure_instructions
-// CHECK-ERRORS: error: invalid octal number
+// CHECK-ERRORS: [[@LINE+1]]:10: error: invalid octal number in '.long' directive
 .long 80+08
 
-// CHECK-ERRORS: error: invalid hexadecimal number
+// CHECK-ERRORS: [[@LINE+1]]:10: error: invalid hexadecimal number in '.long' directive
 .long 80+0xzz
 
-// CHECK-ERRORS: error: literal value out of range for directive
+// CHECK-ERRORS: [[@LINE+1]]:7: error: out of range literal value in '.byte' directive
 .byte 256
 
-// CHECK-ERRORS: error: literal value out of range for directive
+// CHECK-ERRORS: [[@LINE+1]]:7: error: out of range literal value in '.long' directive
 .long 4e71cf69 // double floating point constant due to missing "0x"
 
-// CHECK-ERRORS: error: literal value out of range for directive
+// CHECK-ERRORS: [[@LINE+1]]:7: error: literal value out of range for directive
 .word 0xfffffffff