Lines Matching refs:AsmToken
83 typedef std::vector<AsmToken> MCAsmMacroArgument;
499 const AsmToken &Lex(ExpandKind ExpandNextToken);
500 const AsmToken &Lex() override { return Lex(ExpandMacros); } in Lex()
556 const AsmToken peekTok(bool ShouldSkipSpace = true);
577 AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement);
591 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
596 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
633 SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok);
634 std::string parseStringTo(AsmToken::TokenKind EndTok);
643 unsigned getBinOpPrecedence(AsmToken::TokenKind K,
843 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
857 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
882 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
1165 const AsmToken &Tok = getTok(); in expandMacros()
1169 if (M && M->IsFunction && peekTok().is(AsmToken::LParen)) { in expandMacros()
1175 Lexer.UnLex(AsmToken(AsmToken::Error, MacroId)); in expandMacros()
1208 const AsmToken &MasmParser::Lex(ExpandKind ExpandNextToken) { in Lex()
1209 if (Lexer.getTok().is(AsmToken::Error)) in Lex()
1213 if (getTok().is(AsmToken::EndOfStatement)) { in Lex()
1220 const AsmToken *tok = &Lexer.Lex(); in Lex()
1223 while (ExpandNextToken == ExpandMacros && tok->is(AsmToken::Identifier)) { in Lex()
1225 AsmToken NextTok; in Lex()
1226 MutableArrayRef<AsmToken> Buf(NextTok); in Lex()
1228 if (ReadCount && NextTok.is(AsmToken::Identifier) && in Lex()
1241 while (tok->is(AsmToken::Comment)) { in Lex()
1248 while (tok->is(AsmToken::BackSlash) && in Lex()
1249 peekTok().is(AsmToken::EndOfStatement)) { in Lex()
1255 if (tok->is(AsmToken::Eof)) { in Lex()
1271 const AsmToken MasmParser::peekTok(bool ShouldSkipSpace) { in peekTok()
1272 AsmToken Tok; in peekTok()
1274 MutableArrayRef<AsmToken> Buf(Tok); in peekTok()
1349 while (Lexer.isNot(AsmToken::Eof) || in Run()
1352 if (Lexer.is(AsmToken::Eof)) in Run()
1361 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in Run()
1448 while (Lexer.isNot(AsmToken::EndOfStatement)) { in eatToEndOfStatement()
1449 if (Lexer.is(AsmToken::Eof)) { in eatToEndOfStatement()
1463 if (Lexer.is(AsmToken::EndOfStatement)) in eatToEndOfStatement()
1468 MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) { in parseStringRefsTo()
1472 if (Lexer.is(AsmToken::Eof)) { in parseStringRefsTo()
1491 std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) { in parseStringTo()
1503 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in parseStringToEndOfStatement()
1531 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression")) in parseBracketExpr()
1547 AsmToken::TokenKind FirstTokenKind = Lexer.getKind(); in parsePrimaryExpr()
1552 case AsmToken::Error: in parsePrimaryExpr()
1554 case AsmToken::Exclaim: in parsePrimaryExpr()
1560 case AsmToken::Dollar: in parsePrimaryExpr()
1561 case AsmToken::At: in parsePrimaryExpr()
1562 case AsmToken::Identifier: { in parsePrimaryExpr()
1566 if (getTok().is(AsmToken::Dollar)) { in parsePrimaryExpr()
1601 if (FirstTokenKind == AsmToken::String) { in parsePrimaryExpr()
1602 if (Lexer.is(AsmToken::At)) { in parsePrimaryExpr()
1614 } else if (Lexer.is(AsmToken::LParen)) { in parsePrimaryExpr()
1619 if (parseToken(AsmToken::RParen, in parsePrimaryExpr()
1724 case AsmToken::BigNum: in parsePrimaryExpr()
1726 case AsmToken::Integer: { in parsePrimaryExpr()
1733 case AsmToken::String: { in parsePrimaryExpr()
1747 case AsmToken::Real: { in parsePrimaryExpr()
1755 case AsmToken::Dot: { in parsePrimaryExpr()
1765 case AsmToken::LParen: in parsePrimaryExpr()
1768 case AsmToken::LBrac: in parsePrimaryExpr()
1773 case AsmToken::Minus: in parsePrimaryExpr()
1779 case AsmToken::Plus: in parsePrimaryExpr()
1785 case AsmToken::Tilde: in parsePrimaryExpr()
1793 case AsmToken::PercentCall16: in parsePrimaryExpr()
1794 case AsmToken::PercentCall_Hi: in parsePrimaryExpr()
1795 case AsmToken::PercentCall_Lo: in parsePrimaryExpr()
1796 case AsmToken::PercentDtprel_Hi: in parsePrimaryExpr()
1797 case AsmToken::PercentDtprel_Lo: in parsePrimaryExpr()
1798 case AsmToken::PercentGot: in parsePrimaryExpr()
1799 case AsmToken::PercentGot_Disp: in parsePrimaryExpr()
1800 case AsmToken::PercentGot_Hi: in parsePrimaryExpr()
1801 case AsmToken::PercentGot_Lo: in parsePrimaryExpr()
1802 case AsmToken::PercentGot_Ofst: in parsePrimaryExpr()
1803 case AsmToken::PercentGot_Page: in parsePrimaryExpr()
1804 case AsmToken::PercentGottprel: in parsePrimaryExpr()
1805 case AsmToken::PercentGp_Rel: in parsePrimaryExpr()
1806 case AsmToken::PercentHi: in parsePrimaryExpr()
1807 case AsmToken::PercentHigher: in parsePrimaryExpr()
1808 case AsmToken::PercentHighest: in parsePrimaryExpr()
1809 case AsmToken::PercentLo: in parsePrimaryExpr()
1810 case AsmToken::PercentNeg: in parsePrimaryExpr()
1811 case AsmToken::PercentPcrel_Hi: in parsePrimaryExpr()
1812 case AsmToken::PercentPcrel_Lo: in parsePrimaryExpr()
1813 case AsmToken::PercentTlsgd: in parsePrimaryExpr()
1814 case AsmToken::PercentTlsldm: in parsePrimaryExpr()
1815 case AsmToken::PercentTprel_Hi: in parsePrimaryExpr()
1816 case AsmToken::PercentTprel_Lo: in parsePrimaryExpr()
1818 if (Lexer.isNot(AsmToken::LParen)) in parsePrimaryExpr()
1933 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K, in getGNUBinOpPrecedence()
1942 case AsmToken::AmpAmp: in getGNUBinOpPrecedence()
1945 case AsmToken::PipePipe: in getGNUBinOpPrecedence()
1950 case AsmToken::EqualEqual: in getGNUBinOpPrecedence()
1953 case AsmToken::ExclaimEqual: in getGNUBinOpPrecedence()
1954 case AsmToken::LessGreater: in getGNUBinOpPrecedence()
1957 case AsmToken::Less: in getGNUBinOpPrecedence()
1960 case AsmToken::LessEqual: in getGNUBinOpPrecedence()
1963 case AsmToken::Greater: in getGNUBinOpPrecedence()
1968 case AsmToken::GreaterEqual: in getGNUBinOpPrecedence()
1973 case AsmToken::Plus: in getGNUBinOpPrecedence()
1976 case AsmToken::Minus: in getGNUBinOpPrecedence()
1981 case AsmToken::Pipe: in getGNUBinOpPrecedence()
1984 case AsmToken::Caret: in getGNUBinOpPrecedence()
1987 case AsmToken::Amp: in getGNUBinOpPrecedence()
1992 case AsmToken::Star: in getGNUBinOpPrecedence()
1995 case AsmToken::Slash: in getGNUBinOpPrecedence()
1998 case AsmToken::Percent: in getGNUBinOpPrecedence()
2001 case AsmToken::LessLess: in getGNUBinOpPrecedence()
2004 case AsmToken::GreaterGreater: in getGNUBinOpPrecedence()
2012 unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K, in getBinOpPrecedence()
2025 AsmToken::TokenKind TokKind = Lexer.getKind(); in parseBinOpRHS()
2026 if (Lexer.getKind() == AsmToken::Identifier) { in parseBinOpRHS()
2027 TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString()) in parseBinOpRHS()
2028 .CaseLower("and", AsmToken::Amp) in parseBinOpRHS()
2029 .CaseLower("not", AsmToken::Exclaim) in parseBinOpRHS()
2030 .CaseLower("or", AsmToken::Pipe) in parseBinOpRHS()
2031 .CaseLower("xor", AsmToken::Caret) in parseBinOpRHS()
2032 .CaseLower("shl", AsmToken::LessLess) in parseBinOpRHS()
2033 .CaseLower("shr", AsmToken::GreaterGreater) in parseBinOpRHS()
2034 .CaseLower("eq", AsmToken::EqualEqual) in parseBinOpRHS()
2035 .CaseLower("ne", AsmToken::ExclaimEqual) in parseBinOpRHS()
2036 .CaseLower("lt", AsmToken::Less) in parseBinOpRHS()
2037 .CaseLower("le", AsmToken::LessEqual) in parseBinOpRHS()
2038 .CaseLower("gt", AsmToken::Greater) in parseBinOpRHS()
2039 .CaseLower("ge", AsmToken::GreaterEqual) in parseBinOpRHS()
2078 while (Lexer.is(AsmToken::Space)) in parseStatement()
2080 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
2091 if (getTok().is(AsmToken::Percent)) { in parseStatement()
2093 if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc)) in parseStatement()
2099 AsmToken ID = getTok(); in parseStatement()
2102 if (Lexer.is(AsmToken::HashDirective)) in parseStatement()
2104 if (Lexer.is(AsmToken::Dot)) { in parseStatement()
2108 } else if (Lexer.is(AsmToken::LCurly)) { in parseStatement()
2113 } else if (Lexer.is(AsmToken::RCurly)) { in parseStatement()
2117 } else if (Lexer.is(AsmToken::Star) && in parseStatement()
2122 } else if (Lexer.is(AsmToken::Real)) { in parseStatement()
2210 case AsmToken::Colon: { in parseStatement()
2249 if (getTok().is(AsmToken::Hash)) { in parseStatement()
2250 std::string CommentStr = parseStringTo(AsmToken::EndOfStatement); in parseStatement()
2252 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr)); in parseStatement()
2257 if (getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2306 getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2320 ID.is(AsmToken::Identifier) && getTargetParser().ParseDirective(ID); in parseStatement()
2525 const AsmToken nextTok = getTok(); in parseStatement()
2529 const AsmToken afterNextTok = peekTok(); in parseStatement()
2574 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2585 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2596 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2607 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2617 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2745 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly)) in parseCurlyBlockScope()
2750 if (Lexer.is(AsmToken::EndOfStatement)) in parseCurlyBlockScope()
2765 assert(getTok().is(AsmToken::Integer) && in parseCppHashLineFilenameComment()
2769 assert(getTok().is(AsmToken::String) && in parseCppHashLineFilenameComment()
2941 for (const AsmToken &Token : A[Index]) { in expandMacro()
2949 if (Token.getString().front() == '%' && Token.is(AsmToken::Integer)) in expandMacro()
2968 static bool isOperator(AsmToken::TokenKind kind) { in isOperator()
2972 case AsmToken::Plus: in isOperator()
2973 case AsmToken::Minus: in isOperator()
2974 case AsmToken::Tilde: in isOperator()
2975 case AsmToken::Slash: in isOperator()
2976 case AsmToken::Star: in isOperator()
2977 case AsmToken::Dot: in isOperator()
2978 case AsmToken::Equal: in isOperator()
2979 case AsmToken::EqualEqual: in isOperator()
2980 case AsmToken::Pipe: in isOperator()
2981 case AsmToken::PipePipe: in isOperator()
2982 case AsmToken::Caret: in isOperator()
2983 case AsmToken::Amp: in isOperator()
2984 case AsmToken::AmpAmp: in isOperator()
2985 case AsmToken::Exclaim: in isOperator()
2986 case AsmToken::ExclaimEqual: in isOperator()
2987 case AsmToken::Less: in isOperator()
2988 case AsmToken::LessEqual: in isOperator()
2989 case AsmToken::LessLess: in isOperator()
2990 case AsmToken::LessGreater: in isOperator()
2991 case AsmToken::Greater: in isOperator()
2992 case AsmToken::GreaterEqual: in isOperator()
2993 case AsmToken::GreaterGreater: in isOperator()
3018 AsmToken::TokenKind EndTok) { in parseMacroArgument()
3023 MA.emplace_back(AsmToken::String, S); in parseMacroArgument()
3030 if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) { in parseMacroArgument()
3036 MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar)); in parseMacroArgument()
3049 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal)) in parseMacroArgument()
3053 if (Lexer.is(AsmToken::Comma)) in parseMacroArgument()
3056 if (Lexer.is(AsmToken::Space)) { in parseMacroArgument()
3070 if (Lexer.is(AsmToken::Space)) in parseMacroArgument()
3082 if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0)) in parseMacroArgument()
3086 if (Lexer.is(AsmToken::LParen)) in parseMacroArgument()
3088 else if (Lexer.is(AsmToken::RParen) && ParenLevel) in parseMacroArgument()
3113 AsmToken::TokenKind EndTok) { in parseMacroArguments()
3129 if (Lexer.is(AsmToken::Identifier) && peekTok().is(AsmToken::Equal)) { in parseMacroArguments()
3133 if (Lexer.isNot(AsmToken::Equal)) in parseMacroArguments()
3164 if (Lexer.is(AsmToken::Percent)) { in parseMacroArguments()
3176 AsmToken newToken(AsmToken::Integer, in parseMacroArguments()
3219 if (Lexer.is(AsmToken::Comma)) in parseMacroArguments()
3227 AsmToken::TokenKind ArgumentEndTok) { in handleMacroEntry()
3293 if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name + in handleMacroInvocation()
3295 handleMacroEntry(M, NameLoc, AsmToken::RParen)) in handleMacroInvocation()
3301 while (Lexer.isNot(AsmToken::Eof)) { in handleMacroInvocation()
3313 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in handleMacroInvocation()
3355 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) { in parseIdentifier()
3360 AsmToken nextTok = peekTok(false); in parseIdentifier()
3362 if (nextTok.isNot(AsmToken::Identifier)) in parseIdentifier()
3378 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String)) in parseIdentifier()
3429 if (parseOptionalToken(AsmToken::Comma) && parseMany(parseItem)) in parseDirectiveEquate()
3529 if (check(getTok().isNot(AsmToken::String), "expected string")) in parseEscapedString()
3573 case AsmToken::Percent: { in parseTextItem()
3575 if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res)) in parseTextItem()
3580 case AsmToken::Less: in parseTextItem()
3581 case AsmToken::LessEqual: in parseTextItem()
3582 case AsmToken::LessLess: in parseTextItem()
3583 case AsmToken::LessGreater: in parseTextItem()
3585 case AsmToken::Identifier: { in parseTextItem()
3630 getLexer().UnLex(AsmToken(AsmToken::Identifier, ID)); in parseTextItem()
3680 if (Size == 1 && getTok().is(AsmToken::String)) { in parseScalarInitializer()
3695 if (getTok().is(AsmToken::Identifier) && in parseScalarInitializer()
3708 if (parseToken(AsmToken::LParen, in parseScalarInitializer()
3724 const AsmToken::TokenKind EndToken) { in parseScalarInstList()
3726 (EndToken != AsmToken::Greater || in parseScalarInstList()
3727 getTok().isNot(AsmToken::GreaterGreater))) { in parseScalarInstList()
3731 if (!parseOptionalToken(AsmToken::Comma)) in parseScalarInstList()
3733 parseOptionalToken(AsmToken::EndOfStatement); in parseScalarInstList()
3812 if (Asm.getTok().isNot(AsmToken::Integer) && in parseHexOcta()
3813 Asm.getTok().isNot(AsmToken::BigNum)) in parseHexOcta()
3835 if (getLexer().is(AsmToken::Minus)) { in parseRealValue()
3839 } else if (getLexer().is(AsmToken::Plus)) { in parseRealValue()
3844 if (Lexer.is(AsmToken::Error)) in parseRealValue()
3846 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) && in parseRealValue()
3847 Lexer.isNot(AsmToken::Identifier)) in parseRealValue()
3853 if (getLexer().is(AsmToken::Identifier)) { in parseRealValue()
3894 const AsmToken::TokenKind EndToken) { in parseRealInstList()
3896 (EndToken == AsmToken::Greater && in parseRealInstList()
3897 getTok().isNot(AsmToken::GreaterGreater))) { in parseRealInstList()
3898 const AsmToken NextTok = peekTok(); in parseRealInstList()
3899 if (NextTok.is(AsmToken::Identifier) && in parseRealInstList()
3902 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseRealInstList()
3914 if (parseToken(AsmToken::LParen, in parseRealInstList()
3929 if (!parseOptionalToken(AsmToken::Comma)) in parseRealInstList()
3931 parseOptionalToken(AsmToken::EndOfStatement); in parseRealInstList()
4021 const AsmToken Tok = getTok(); in parseOptionalAngleBracketOpen()
4022 if (parseOptionalToken(AsmToken::LessLess)) { in parseOptionalAngleBracketOpen()
4024 Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4026 } else if (parseOptionalToken(AsmToken::LessGreater)) { in parseOptionalAngleBracketOpen()
4028 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4030 } else if (parseOptionalToken(AsmToken::Less)) { in parseOptionalAngleBracketOpen()
4039 const AsmToken Tok = getTok(); in parseAngleBracketClose()
4040 if (parseOptionalToken(AsmToken::GreaterGreater)) { in parseAngleBracketClose()
4041 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseAngleBracketClose()
4042 } else if (parseToken(AsmToken::Greater, Msg)) { in parseAngleBracketClose()
4055 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4058 if (parseScalarInstList(Field.Type, Values, AsmToken::RCurly) || in parseFieldInitializer()
4059 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4064 if (parseScalarInstList(Field.Type, Values, AsmToken::Greater) || in parseFieldInitializer()
4107 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4110 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) || in parseFieldInitializer()
4111 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4116 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) || in parseFieldInitializer()
4147 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4149 AsmToken::RCurly) || in parseFieldInitializer()
4150 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4154 AsmToken::Greater) || in parseFieldInitializer()
4195 const AsmToken FirstToken = getTok(); in parseStructInitializer()
4197 Optional<AsmToken::TokenKind> EndToken; in parseStructInitializer()
4198 if (parseOptionalToken(AsmToken::LCurly)) { in parseStructInitializer()
4199 EndToken = AsmToken::RCurly; in parseStructInitializer()
4201 EndToken = AsmToken::Greater; in parseStructInitializer()
4203 } else if (FirstToken.is(AsmToken::Identifier) && in parseStructInitializer()
4206 if (parseToken(AsmToken::Identifier)) in parseStructInitializer()
4219 if (parseOptionalToken(AsmToken::Comma)) { in parseStructInitializer()
4223 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4232 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInitializer()
4237 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4245 if (EndToken.value() == AsmToken::Greater) in parseStructInitializer()
4256 const AsmToken::TokenKind EndToken) { in parseStructInstList()
4258 (EndToken == AsmToken::Greater && in parseStructInstList()
4259 getTok().isNot(AsmToken::GreaterGreater))) { in parseStructInstList()
4260 const AsmToken NextTok = peekTok(); in parseStructInstList()
4261 if (NextTok.is(AsmToken::Identifier) && in parseStructInstList()
4264 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseStructInstList()
4276 if (parseToken(AsmToken::LParen, in parseStructInstList()
4290 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInstList()
4292 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInstList()
4527 AsmToken NextTok = getTok(); in parseDirectiveStruct()
4529 if (NextTok.isNot(AsmToken::Comma) && in parseDirectiveStruct()
4530 NextTok.isNot(AsmToken::EndOfStatement) && in parseDirectiveStruct()
4542 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveStruct()
4552 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveStruct()
4570 if (getTok().is(AsmToken::Identifier)) { in parseDirectiveNestedStruct()
4572 parseToken(AsmToken::Identifier); in parseDirectiveNestedStruct()
4574 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveNestedStruct()
4600 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveEnds()
4612 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveNestedEnds()
4684 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveOrg()
4749 if (getTok().is(AsmToken::EndOfStatement)) { in parseDirectiveAlign()
4752 parseToken(AsmToken::EndOfStatement); in parseDirectiveAlign()
4755 parseToken(AsmToken::EndOfStatement)) in parseDirectiveAlign()
4778 if (parseToken(AsmToken::EndOfStatement) || emitAlignTo(2)) in parseDirectiveEven()
4790 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveFile()
4802 if (check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4810 if (getLexer().is(AsmToken::String)) { in parseDirectiveFile()
4828 while (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveFile()
4830 if (check(getTok().isNot(AsmToken::Identifier), in parseDirectiveFile()
4844 check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4907 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLine()
4937 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
4945 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
5036 check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5040 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCVFile()
5041 if (check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5122 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5133 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5146 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVInlineSiteId()
5176 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5184 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5235 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5239 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5300 while (getLexer().is(AsmToken::Identifier)) { in parseDirectiveCVDefRange()
5318 AsmToken::Comma, in parseDirectiveCVDefRange()
5331 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5344 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5357 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5361 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5377 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5382 AsmToken::Comma, in parseDirectiveCVDefRange()
5386 if (parseToken(AsmToken::Comma, "expected comma before base pointer offset " in parseDirectiveCVDefRange()
5473 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFISections()
5493 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFIStartProc()
5496 parseToken(AsmToken::EndOfStatement)) in parseDirectiveCFIStartProc()
5521 if (getLexer().isNot(AsmToken::Integer)) { in parseRegisterOrRegisterNumber()
5536 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIDefCfa()
5560 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRegister()
5604 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIOffset()
5618 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRelOffset()
5661 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIPersonalityOrLsda()
5721 while (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFIEscape()
5774 while (getLexer().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5790 if (Lexer.is(AsmToken::Colon)) { in parseDirectiveMacro()
5793 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveMacro()
5824 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
5832 if (getTok().is(AsmToken::Identifier) && in parseDirectiveMacro()
5843 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveMacro()
5845 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveMacro()
5850 AsmToken EndToken, StartToken = getTok(); in parseDirectiveMacro()
5856 while (Lexer.is(AsmToken::Error)) { in parseDirectiveMacro()
5861 if (getLexer().is(AsmToken::Eof)) in parseDirectiveMacro()
5866 if (getLexer().is(AsmToken::Identifier)) { in parseDirectiveMacro()
5871 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveMacro()
5880 if (MacroDepth == 0 && peekTok().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5915 if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value)) in parseDirectiveExitMacro()
5937 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveEndMacro()
5970 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectivePurgeMacro()
5972 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectivePurgeMacro()
5985 if (parseToken(AsmToken::Colon)) in parseDirectiveExtern()
6049 if (getLexer().isNot(AsmToken::Comma)) in parseDirectiveComm()
6060 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveComm()
6114 std::string FirstLine = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveComment()
6120 if (getTok().is(AsmToken::Eof)) in parseDirectiveComment()
6124 !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter)); in parseDirectiveComment()
6137 Filename = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveInclude()
6139 check(getTok().isNot(AsmToken::EndOfStatement), in parseDirectiveInclude()
6214 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveIfidn()
6425 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveElseIfidn()
6480 while (Lexer.isNot(AsmToken::Eof)) in parseDirectiveEnd()
6497 if (Lexer.isNot(AsmToken::EndOfStatement)) in parseDirectiveError()
6498 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveError()
6519 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfb()
6520 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfb()
6522 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfb()
6563 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfdef()
6564 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfdef()
6566 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfdef()
6594 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveErrorIfidn()
6614 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfidn()
6615 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfidn()
6617 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfidn()
6650 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfe()
6651 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfe()
6653 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfe()
6803 if (getLexer().is(AsmToken::Identifier)) { in isMacroLikeDirective()
6813 if (peekTok().is(AsmToken::Identifier) && in isMacroLikeDirective()
6821 AsmToken EndToken, StartToken = getTok(); in parseMacroLikeBody()
6826 if (getLexer().is(AsmToken::Eof)) { in parseMacroLikeBody()
6835 if (Lexer.is(AsmToken::Identifier) && in parseMacroLikeBody()
6840 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseMacroLikeBody()
6863 std::string Body = parseStringTo(AsmToken::EndOfStatement); in expandStatement()
6881 A.push_back(AsmToken(AsmToken::String, B.getValue())); in expandStatement()
6894 A.push_back(AsmToken(AsmToken::String, Var.TextValue)); in expandStatement()
7025 if (parseOptionalToken(AsmToken::Colon)) { in parseDirectiveFor()
7026 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveFor()
7053 if (parseToken(AsmToken::Comma, in parseDirectiveFor()
7055 parseToken(AsmToken::Less, in parseDirectiveFor()
7062 if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater)) in parseDirectiveFor()
7066 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveFor()
7068 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveFor()
7071 if (parseToken(AsmToken::Greater, in parseDirectiveFor()
7107 parseToken(AsmToken::Comma, in parseDirectiveForc()
7114 Argument = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveForc()
7115 if (getTok().is(AsmToken::EndOfStatement)) in parseDirectiveForc()
7140 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1)); in parseDirectiveForc()
7186 std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveRadix()
7204 std::string Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveEcho()
7376 while (getLexer().isNot(AsmToken::Eof)) { in parseMSInlineAsm()