[llvm] r284978 - [MC] Fix Various End Of Line Comment checkings

Keith Walker via llvm-commits llvm-commits at lists.llvm.org
Wed Oct 26 09:56:50 PDT 2016


Hi,

It appears that this change has introduced a regression in the handling of multiple optional options to the .loc directive.

This can be demonstrated using the command:
  clang --target=aarch64 -c fail.s

with this assembler source as input:

        .text
func:
        .file   1 "fail.c"
        .loc    1 5 16 is_stmt 0 discriminator 1
        ret

and it produces the following error:

fail.s:4:34: error: unexpected token
        .loc    1 5 16 is_stmt 0 discriminator 1
                                 ^

Keith

> -----Original Message-----
> From: llvm-commits [mailto:llvm-commits-bounces at lists.llvm.org] On
> Behalf Of Nirav Dave via llvm-commits
> Sent: 24 October 2016 15:35
> To: llvm-commits at lists.llvm.org
> Subject: [llvm] r284978 - [MC] Fix Various End Of Line Comment checkings
> 
> Author: niravd
> Date: Mon Oct 24 09:35:29 2016
> New Revision: 284978
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=284978&view=rev
> Log:
> [MC] Fix Various End Of Line Comment checkings
> 
> Fix AsmParser lines to correctly handle end-of-line pre-processor
> comments parsing when '#' is not the assembly line comment prefix.
> 
> Reviewers: rnk
> 
> Subscribers: llvm-commits
> 
> Differential Revision: https://reviews.llvm.org/D25567
> 
> Added:
>     llvm/trunk/test/MC/AsmParser/AArch64/
>     llvm/trunk/test/MC/AsmParser/AArch64/directive-parse-err.s
>     llvm/trunk/test/MC/AsmParser/AArch64/lit.local.cfg
> Modified:
>     llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h
>     llvm/trunk/lib/MC/MCParser/AsmParser.cpp
>     llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp
>     llvm/trunk/test/MC/AsmParser/exprs-invalid.s
> 
> Modified: llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h?rev=284978&r1=
> 284977&r2=284978&view=diff
> ========================================================================
> ======
> --- llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h (original)
> +++ llvm/trunk/include/llvm/MC/MCParser/MCAsmParser.h Mon Oct 24
> 09:35:29 2016
> @@ -166,6 +166,8 @@ public:
>      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;
> @@ -177,11 +179,15 @@ public:
>    bool TokError(const Twine &Msg, SMRange Range = None);
> 
>    bool parseTokenLoc(SMLoc &Loc);
> -  bool parseToken(AsmToken::TokenKind T, const Twine &Msg);
> -  bool parseOptionalToken(AsmToken::TokenKind T, bool &Present);
> +  bool parseToken(AsmToken::TokenKind T, const Twine &Msg = "unexpected
> token");
> +  /// \brief Attempt to parse and consume token, returning true on
> +  /// success.
> +  bool parseOptionalToken(AsmToken::TokenKind T);
> 
>    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);
> 
> Modified: llvm/trunk/lib/MC/MCParser/AsmParser.cpp
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/lib/MC/MCParser/AsmParser.cpp?rev=284978&r1=284977&r2
> =284978&view=diff
> ========================================================================
> ======
> --- llvm/trunk/lib/MC/MCParser/AsmParser.cpp (original)
> +++ llvm/trunk/lib/MC/MCParser/AsmParser.cpp Mon Oct 24 09:35:29 2016
> @@ -425,9 +425,11 @@ private:
>    // ".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"
> @@ -1732,25 +1734,34 @@ bool AsmParser::parseStatement(ParseStat
>      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);
> @@ -1923,20 +1934,6 @@ bool AsmParser::parseStatement(ParseStat
>        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);
> @@ -2645,17 +2642,15 @@ bool AsmParser::parseIdentifier(StringRe
>  ///   ::= .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();
> @@ -2716,31 +2711,18 @@ bool AsmParser::parseEscapedString(std::
>  /// 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));
> -
> -      if (getLexer().is(AsmToken::EndOfStatement))
> -        break;
> -
> -      if (parseToken(AsmToken::Comma,
> -                     "unexpected token in '" + Twine(IDVal) + "'
> directive"))
> -        return true;
> -    }
> -  }
> +  auto parseOp = [&]() -> bool {
> +    std::string Data;
> +    if (checkForValidSection() || parseEscapedString(Data))
> +      return true;
> +    getStreamer().EmitBytes(Data);
> +    if (ZeroTerminated)
> +      getStreamer().EmitBytes(StringRef("\0", 1));
> +    return false;
> +  };
> 
> -  Lex();
> +  if (parseMany(parseOp))
> +    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
>    return false;
>  }
> 
> @@ -2751,11 +2733,12 @@ bool AsmParser::parseDirectiveReloc(SMLo
>    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") ||
> @@ -2790,86 +2773,63 @@ bool AsmParser::parseDirectiveReloc(SMLo
> 
>  /// 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);
> -
> -      if (getLexer().is(AsmToken::EndOfStatement))
> -        break;
> -
> -      // FIXME: Improve diagnostic.
> -      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
> -        return true;
> -    }
> -  }
> +bool AsmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
> +  auto parseOp = [&]() -> bool {
> +    const MCExpr *Value;
> +    SMLoc ExprLoc = getLexer().getLoc();
> +    if (checkForValidSection() || 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, "out of range literal value");
> +      getStreamer().EmitIntValue(IntValue, Size);
> +    } else
> +      getStreamer().EmitValue(Value, Size, ExprLoc);
> +    return false;
> +  };
> 
> -  Lex();
> +  if (parseMany(parseOp))
> +    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
>    return false;
>  }
> 
>  /// ParseDirectiveOctaValue
>  ///  ::= .octa [ hexconstant (, hexconstant)* ]
> -bool AsmParser::parseDirectiveOctaValue() {
> -  if (getLexer().isNot(AsmToken::EndOfStatement)) {
> +
> +bool AsmParser::parseDirectiveOctaValue(StringRef IDVal) {
> +  auto parseOp = [&]() -> bool {
>      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);
> -      }
> -
> -      if (getLexer().is(AsmToken::EndOfStatement))
> -        break;
> -
> -      // FIXME: Improve diagnostic.
> -      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
> -        return true;
> +    if (getTok().isNot(AsmToken::Integer) &&
> getTok().isNot(AsmToken::BigNum))
> +      return TokError("unknown token in expression");
> +    SMLoc ExprLoc = getTok().getLoc();
> +    APInt IntValue = getTok().getAPIntVal();
> +    uint64_t hi, lo;
> +    Lex();
> +    if (!IntValue.isIntN(128))
> +      return Error(ExprLoc, "out of range literal value");
> +    if (!IntValue.isIntN(64)) {
> +      hi = IntValue.getHiBits(IntValue.getBitWidth() -
> 64).getZExtValue();
> +      lo = IntValue.getLoBits(64).getZExtValue();
> +    } else {
> +      hi = 0;
> +      lo = IntValue.getZExtValue();
>      }
> -  }
> +    if (MAI.isLittleEndian()) {
> +      getStreamer().EmitIntValue(lo, 8);
> +      getStreamer().EmitIntValue(hi, 8);
> +    } else {
> +      getStreamer().EmitIntValue(hi, 8);
> +      getStreamer().EmitIntValue(lo, 8);
> +    }
> +    return false;
> +  };
> 
> -  Lex();
> +  if (parseMany(parseOp))
> +    return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
>    return false;
>  }
> 
> @@ -2915,28 +2875,19 @@ bool AsmParser::parseRealValue(const flt
> 
>  /// parseDirectiveRealValue
>  ///  ::= (.single | .double) [ expression (, expression)* ]
> -bool AsmParser::parseDirectiveRealValue(const fltSemantics &Semantics)
> {
> -  if (getLexer().isNot(AsmToken::EndOfStatement)) {
> -    if (checkForValidSection())
> +bool AsmParser::parseDirectiveRealValue(StringRef IDVal,
> +                                        const fltSemantics &Semantics)
> {
> +  auto parseOp = [&]() -> bool {
> +    APInt AsInt;
> +    if (checkForValidSection() || parseRealValue(Semantics, AsInt))
>        return true;
> +    getStreamer().EmitIntValue(AsInt.getLimitedValue(),
> +                               AsInt.getBitWidth() / 8);
> +    return false;
> +  };
> 
> -    while (true) {
> -      APInt AsInt;
> -      if (parseRealValue(Semantics, AsInt))
> -        return true;
> -
> -      getStreamer().EmitIntValue(AsInt.getLimitedValue(),
> -                                 AsInt.getBitWidth() / 8);
> -
> -      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;
>  }
> 
> @@ -2975,21 +2926,20 @@ bool AsmParser::parseDirectiveFill() {
>    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))
> +  if (parseOptionalToken(AsmToken::Comma)) {
> +    SizeLoc = getTok().getLoc();
> +    if (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"))
> +    if (parseOptionalToken(AsmToken::Comma)) {
> +      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");
> @@ -3017,15 +2967,11 @@ bool AsmParser::parseDirectiveOrg() {
> 
>    // 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;
> +  if (parseOptionalToken(AsmToken::Comma))
> +    if (parseAbsoluteExpression(FillExpr))
> +      return addErrorSuffix(" in '.org' directive");
> +  if (parseToken(AsmToken::EndOfStatement))
> +    return addErrorSuffix(" in '.org' directive");
> 
>    getStreamer().emitValueToOffset(Offset, FillExpr);
>    return false;
> @@ -3036,38 +2982,33 @@ bool AsmParser::parseDirectiveOrg() {
>  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;
> 
> -    // 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))
> -        return true;
> +  auto parseAlign = [&]() -> bool {
> +    if (checkForValidSection() || parseAbsoluteExpression(Alignment))
> +      return true;
> +    if (parseOptionalToken(AsmToken::Comma)) {
> +      // 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 (parseOptionalToken(AsmToken::Comma))
> +        if (parseTokenLoc(MaxBytesLoc) ||
> +            parseAbsoluteExpression(MaxBytesToFill))
> +          return true;
>      }
> -  }
> +    return parseToken(AsmToken::EndOfStatement);
> +  };
> 
> -  if (parseToken(AsmToken::EndOfStatement, "unexpected token in
> directive"))
> -    return true;
> -
> -  if (!HasFillExpr)
> -    FillExpr = 0;
> +  if (parseAlign())
> +    return addErrorSuffix(" in directive");
> 
>    // Always emit an alignment here even if we thrown an error.
>    bool ReturnVal = false;
> @@ -3185,7 +3126,7 @@ bool AsmParser::parseDirectiveFile(SMLoc
>  /// ::= .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;
> @@ -3234,65 +3175,61 @@ bool AsmParser::parseDirectiveLoc() {
>    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");
> -
> -      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;
> +  auto parseLocOp = [&]() -> bool {
> +    StringRef Name;
> +    SMLoc Loc = getTok().getLoc();
> +    if (parseIdentifier(Name))
> +      return TokError("unexpected token in '.loc' directive");
> +
> +    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, "unknown sub-directive in '.loc' directive");
> +        return Error(Loc, "is_stmt value not the constant value of 0 or
> 1");
>        }
> -
> -      if (getLexer().is(AsmToken::EndOfStatement))
> -        break;
> +    } 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");
>      }
> -  }
> -  Lex();
> +    return false;
> +  };
> +
> +  if (parseMany(parseLocOp))
> +    return true;
> 
>    getStreamer().EmitDwarfLocDirective(FileNumber, LineNumber,
> ColumnPos, Flags,
>                                        Isa, Discriminator, StringRef());
> @@ -3326,7 +3263,7 @@ bool AsmParser::parseDirectiveCVFile() {
>      return true;
> 
>    if (!getStreamer().EmitCVFileDirective(FileNumber, Filename))
> -    Error(FileNumberLoc, "file number already allocated");
> +    return Error(FileNumberLoc, "file number already allocated");
> 
>    return false;
>  }
> @@ -3366,7 +3303,7 @@ bool AsmParser::parseDirectiveCVFuncId()
>      return true;
> 
>    if (!getStreamer().EmitCVFuncIdDirective(FunctionId))
> -    Error(FunctionIdLoc, "function id already allocated");
> +    return Error(FunctionIdLoc, "function id already allocated");
> 
>    return false;
>  }
> @@ -3465,12 +3402,12 @@ bool AsmParser::parseDirectiveCVLoc() {
> 
>    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") {
> @@ -3488,8 +3425,11 @@ bool AsmParser::parseDirectiveCVLoc() {
>      } 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(),
> @@ -3636,12 +3576,12 @@ bool AsmParser::parseDirectiveCFISection
>  /// ::= .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;
> +  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
> +    if (check(parseIdentifier(Simple) || Simple != "simple",
> +              "unexpected token") ||
> +        parseToken(AsmToken::EndOfStatement))
> +      return addErrorSuffix(" in '.cfi_startproc' directive");
> +  }
> 
>    getStreamer().EmitCFIStartProc(!Simple.empty());
>    return false;
> @@ -4214,22 +4154,20 @@ bool AsmParser::parseDirectiveBundleLock
>      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";
> +  StringRef Option;
> +  SMLoc Loc = getTok().getLoc();
> +  const char *kInvalidOptionError =
> +      "invalid option for '.bundle_lock' directive";
> 
> +  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
>      if (check(parseIdentifier(Option), Loc, kInvalidOptionError) ||
>          check(Option != "align_to_end", Loc, kInvalidOptionError) ||
> -        check(getTok().isNot(AsmToken::EndOfStatement), Loc,
> -              "unexpected token after '.bundle_lock' directive
> option"))
> +        parseToken(AsmToken::EndOfStatement,
> +                   "unexpected token after '.bundle_lock' directive
> option"))
>        return true;
>      AlignToEnd = true;
>    }
> 
> -  Lex();
> -
>    getStreamer().EmitBundleLock(AlignToEnd);
>    return false;
>  }
> @@ -4256,17 +4194,11 @@ bool AsmParser::parseDirectiveSpace(Stri
>      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;
> +  if (parseOptionalToken(AsmToken::Comma))
> +    if (parseAbsoluteExpression(FillExpr))
> +      return addErrorSuffix("in '" + Twine(IDVal) + "' directive");
> +  if (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);
> @@ -4378,24 +4310,19 @@ bool AsmParser::parseDirectiveLEB128(boo
>    if (checkForValidSection())
>      return true;
> 
> -  const MCExpr *Value;
> -
> -  while (true) {
> +  auto parseOp = [&]() -> bool {
> +    const MCExpr *Value;
>      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;
>  }
> @@ -4403,32 +4330,24 @@ bool AsmParser::parseDirectiveLEB128(boo
>  /// 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);
> -
> -      // Assembler local symbols don't make any sense here. Complain
> loudly.
> -      if (Sym->isTemporary())
> -        return Error(Loc, "non-local symbol required in directive");
> -
> -      if (!getStreamer().EmitSymbolAttribute(Sym, Attr))
> -        return Error(Loc, "unable to emit symbol attribute");
> +  auto parseOp = [&]() -> bool {
> +    StringRef Name;
> +    SMLoc Loc = getTok().getLoc();
> +    if (parseIdentifier(Name))
> +      return Error(Loc, "expected identifier");
> +    MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
> 
> -      if (getLexer().is(AsmToken::EndOfStatement))
> -        break;
> +    // Assembler local symbols don't make any sense here. Complain
> loudly.
> +    if (Sym->isTemporary())
> +      return Error(Loc, "non-local symbol required");
> 
> -      if (parseToken(AsmToken::Comma, "unexpected token in directive"))
> -        return true;
> -    }
> -  }
> +    if (!getStreamer().EmitSymbolAttribute(Sym, Attr))
> +      return Error(Loc, "unable to emit symbol attribute");
> +    return false;
> +  };
> 
> -  Lex();
> +  if (parseMany(parseOp))
> +    return addErrorSuffix(" in directive");
>    return false;
>  }
> 
> @@ -4476,10 +4395,9 @@ bool AsmParser::parseDirectiveComm(bool
>      }
>    }
> 
> -  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.
> @@ -4562,20 +4480,16 @@ bool AsmParser::parseDirectiveIncbin() {
>    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;
> -
> +  if (parseOptionalToken(AsmToken::Comma)) {
>      // 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))
> +    if (parseOptionalToken(AsmToken::Comma)) {
> +      CountLoc = getTok().getLoc();
> +      if (parseExpression(Count))
>          return true;
>      }
>    }
> @@ -4771,10 +4685,10 @@ bool AsmParser::parseDirectiveElseIf(SML
>      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;
>    }
> @@ -4813,7 +4727,7 @@ bool AsmParser::parseDirectiveEnd(SMLoc
>      return true;
> 
>    while (Lexer.isNot(AsmToken::Eof))
> -    Lex();
> +    Lexer.Lex();
> 
>    return false;
>  }
> @@ -4855,12 +4769,16 @@ bool AsmParser::parseDirectiveWarning(SM
>    }
> 
>    StringRef Message = ".warning directive invoked in source file";
> -  if (Lexer.isNot(AsmToken::EndOfStatement)) {
> +
> +  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
>      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);
> @@ -5547,19 +5465,15 @@ bool parseAssignmentExpression(StringRef
>    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).
> 
> Modified: llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp?rev=284978&r1=284977&
> r2=284978&view=diff
> ========================================================================
> ======
> --- llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp (original)
> +++ llvm/trunk/lib/MC/MCParser/MCAsmParser.cpp Mon Oct 24 09:35:29 2016
> @@ -68,11 +68,14 @@ bool MCAsmParser::parseIntToken(int64_t
>    return false;
>  }
> 
> -bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T, bool
> &Present) {
> -  Present = (getTok().getKind() == T);
> +bool MCAsmParser::parseOptionalToken(AsmToken::TokenKind T) {
> +  bool 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();
> -  return false;
> +    parseToken(T);
> +  return Present;
>  }
> 
>  bool MCAsmParser::check(bool P, const Twine &Msg) {
> @@ -97,9 +100,38 @@ bool MCAsmParser::Error(SMLoc L, const T
>    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) {
> +  if (parseOptionalToken(AsmToken::EndOfStatement))
> +    return false;
> +  while (1) {
> +    if (parseOne())
> +      return true;
> +    if (parseOptionalToken(AsmToken::EndOfStatement))
> +      return false;
> +    if (hasComma && parseToken(AsmToken::Comma))
> +      return true;
> +  }
> +  return false;
> +}
> +
>  bool MCAsmParser::parseExpression(const MCExpr *&Res) {
>    SMLoc L;
>    return parseExpression(Res, L);
> 
> Added: llvm/trunk/test/MC/AsmParser/AArch64/directive-parse-err.s
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/test/MC/AsmParser/AArch64/directive-parse-
> err.s?rev=284978&view=auto
> ========================================================================
> ======
> --- llvm/trunk/test/MC/AsmParser/AArch64/directive-parse-err.s (added)
> +++ llvm/trunk/test/MC/AsmParser/AArch64/directive-parse-err.s Mon Oct
> 24 09:35:29 2016
> @@ -0,0 +1,258 @@
> +// 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:
> 
> Added: llvm/trunk/test/MC/AsmParser/AArch64/lit.local.cfg
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/test/MC/AsmParser/AArch64/lit.local.cfg?rev=284978&vi
> ew=auto
> ========================================================================
> ======
> --- llvm/trunk/test/MC/AsmParser/AArch64/lit.local.cfg (added)
> +++ llvm/trunk/test/MC/AsmParser/AArch64/lit.local.cfg Mon Oct 24
> 09:35:29 2016
> @@ -0,0 +1,2 @@
> +if 'AArch64' not in config.root.targets:
> +    config.unsupported = True
> 
> Modified: llvm/trunk/test/MC/AsmParser/exprs-invalid.s
> URL: http://llvm.org/viewvc/llvm-
> project/llvm/trunk/test/MC/AsmParser/exprs-
> invalid.s?rev=284978&r1=284977&r2=284978&view=diff
> ========================================================================
> ======
> --- llvm/trunk/test/MC/AsmParser/exprs-invalid.s (original)
> +++ llvm/trunk/test/MC/AsmParser/exprs-invalid.s Mon Oct 24 09:35:29
> 2016
> @@ -1,17 +1,17 @@
>  // 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
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits


More information about the llvm-commits mailing list