Lines Matching refs:AsmToken
81 typedef std::vector<AsmToken> MCAsmMacroArgument;
196 StringRef IDVal, AsmToken ID,
248 const AsmToken &Lex() override;
368 unsigned getBinOpPrecedence(AsmToken::TokenKind K,
732 while (Lexer.is(AsmToken::Space)) in lexLeadingSpaces()
909 const AsmToken &AsmParser::Lex() { in Lex()
910 if (Lexer.getTok().is(AsmToken::Error)) in Lex()
914 if (getTok().is(AsmToken::EndOfStatement)) { in Lex()
921 const AsmToken *tok = &Lexer.Lex(); in Lex()
924 while (tok->is(AsmToken::Comment)) { in Lex()
930 if (tok->is(AsmToken::Eof)) { in Lex()
999 while (Lexer.isNot(AsmToken::Eof)) { in Run()
1006 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in Run()
1097 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in eatToEndOfStatement()
1101 if (Lexer.is(AsmToken::EndOfStatement)) in eatToEndOfStatement()
1108 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in parseStringToEndOfStatement()
1118 while (Lexer.isNot(AsmToken::EndOfStatement) && in parseStringToComma()
1119 Lexer.isNot(AsmToken::Comma) && Lexer.isNot(AsmToken::Eof)) in parseStringToComma()
1147 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression")) in parseBracketExpr()
1161 AsmToken::TokenKind FirstTokenKind = Lexer.getKind(); in parsePrimaryExpr()
1166 case AsmToken::Error: in parsePrimaryExpr()
1168 case AsmToken::Exclaim: in parsePrimaryExpr()
1174 case AsmToken::Dollar: in parsePrimaryExpr()
1175 case AsmToken::Star: in parsePrimaryExpr()
1176 case AsmToken::At: in parsePrimaryExpr()
1177 case AsmToken::String: in parsePrimaryExpr()
1178 case AsmToken::Identifier: { in parsePrimaryExpr()
1183 if (getTok().is(AsmToken::Dollar) || getTok().is(AsmToken::Star)) { in parsePrimaryExpr()
1185 if ((getTok().is(AsmToken::Dollar) && MAI.getDollarIsPC()) || in parsePrimaryExpr()
1186 (getTok().is(AsmToken::Star) && MAI.getStarIsPC())) in parsePrimaryExpr()
1207 if (FirstTokenKind == AsmToken::String) { in parsePrimaryExpr()
1208 if (Lexer.is(AsmToken::At)) { in parsePrimaryExpr()
1220 } else if (Lexer.is(AsmToken::LParen)) { in parsePrimaryExpr()
1275 case AsmToken::BigNum: in parsePrimaryExpr()
1277 case AsmToken::Integer: { in parsePrimaryExpr()
1284 if (Lexer.getKind() == AsmToken::Identifier) { in parsePrimaryExpr()
1308 case AsmToken::Real: { in parsePrimaryExpr()
1316 case AsmToken::Dot: { in parsePrimaryExpr()
1329 case AsmToken::LParen: in parsePrimaryExpr()
1332 case AsmToken::LBrac: in parsePrimaryExpr()
1337 case AsmToken::Minus: in parsePrimaryExpr()
1343 case AsmToken::Plus: in parsePrimaryExpr()
1349 case AsmToken::Tilde: in parsePrimaryExpr()
1357 case AsmToken::PercentCall16: in parsePrimaryExpr()
1358 case AsmToken::PercentCall_Hi: in parsePrimaryExpr()
1359 case AsmToken::PercentCall_Lo: in parsePrimaryExpr()
1360 case AsmToken::PercentDtprel_Hi: in parsePrimaryExpr()
1361 case AsmToken::PercentDtprel_Lo: in parsePrimaryExpr()
1362 case AsmToken::PercentGot: in parsePrimaryExpr()
1363 case AsmToken::PercentGot_Disp: in parsePrimaryExpr()
1364 case AsmToken::PercentGot_Hi: in parsePrimaryExpr()
1365 case AsmToken::PercentGot_Lo: in parsePrimaryExpr()
1366 case AsmToken::PercentGot_Ofst: in parsePrimaryExpr()
1367 case AsmToken::PercentGot_Page: in parsePrimaryExpr()
1368 case AsmToken::PercentGottprel: in parsePrimaryExpr()
1369 case AsmToken::PercentGp_Rel: in parsePrimaryExpr()
1370 case AsmToken::PercentHi: in parsePrimaryExpr()
1371 case AsmToken::PercentHigher: in parsePrimaryExpr()
1372 case AsmToken::PercentHighest: in parsePrimaryExpr()
1373 case AsmToken::PercentLo: in parsePrimaryExpr()
1374 case AsmToken::PercentNeg: in parsePrimaryExpr()
1375 case AsmToken::PercentPcrel_Hi: in parsePrimaryExpr()
1376 case AsmToken::PercentPcrel_Lo: in parsePrimaryExpr()
1377 case AsmToken::PercentTlsgd: in parsePrimaryExpr()
1378 case AsmToken::PercentTlsldm: in parsePrimaryExpr()
1379 case AsmToken::PercentTprel_Hi: in parsePrimaryExpr()
1380 case AsmToken::PercentTprel_Lo: in parsePrimaryExpr()
1382 if (Lexer.isNot(AsmToken::LParen)) in parsePrimaryExpr()
1512 if (parseOptionalToken(AsmToken::At)) { in parseExpression()
1513 if (Lexer.isNot(AsmToken::Identifier)) in parseExpression()
1578 static unsigned getDarwinBinOpPrecedence(AsmToken::TokenKind K, in getDarwinBinOpPrecedence()
1586 case AsmToken::AmpAmp: in getDarwinBinOpPrecedence()
1589 case AsmToken::PipePipe: in getDarwinBinOpPrecedence()
1594 case AsmToken::Pipe: in getDarwinBinOpPrecedence()
1597 case AsmToken::Caret: in getDarwinBinOpPrecedence()
1600 case AsmToken::Amp: in getDarwinBinOpPrecedence()
1605 case AsmToken::EqualEqual: in getDarwinBinOpPrecedence()
1608 case AsmToken::ExclaimEqual: in getDarwinBinOpPrecedence()
1609 case AsmToken::LessGreater: in getDarwinBinOpPrecedence()
1612 case AsmToken::Less: in getDarwinBinOpPrecedence()
1615 case AsmToken::LessEqual: in getDarwinBinOpPrecedence()
1618 case AsmToken::Greater: in getDarwinBinOpPrecedence()
1621 case AsmToken::GreaterEqual: in getDarwinBinOpPrecedence()
1626 case AsmToken::LessLess: in getDarwinBinOpPrecedence()
1629 case AsmToken::GreaterGreater: in getDarwinBinOpPrecedence()
1634 case AsmToken::Plus: in getDarwinBinOpPrecedence()
1637 case AsmToken::Minus: in getDarwinBinOpPrecedence()
1642 case AsmToken::Star: in getDarwinBinOpPrecedence()
1645 case AsmToken::Slash: in getDarwinBinOpPrecedence()
1648 case AsmToken::Percent: in getDarwinBinOpPrecedence()
1655 AsmToken::TokenKind K, in getGNUBinOpPrecedence()
1663 case AsmToken::AmpAmp: in getGNUBinOpPrecedence()
1666 case AsmToken::PipePipe: in getGNUBinOpPrecedence()
1671 case AsmToken::EqualEqual: in getGNUBinOpPrecedence()
1674 case AsmToken::ExclaimEqual: in getGNUBinOpPrecedence()
1675 case AsmToken::LessGreater: in getGNUBinOpPrecedence()
1678 case AsmToken::Less: in getGNUBinOpPrecedence()
1681 case AsmToken::LessEqual: in getGNUBinOpPrecedence()
1684 case AsmToken::Greater: in getGNUBinOpPrecedence()
1687 case AsmToken::GreaterEqual: in getGNUBinOpPrecedence()
1692 case AsmToken::Plus: in getGNUBinOpPrecedence()
1695 case AsmToken::Minus: in getGNUBinOpPrecedence()
1701 case AsmToken::Pipe: in getGNUBinOpPrecedence()
1704 case AsmToken::Exclaim: in getGNUBinOpPrecedence()
1711 case AsmToken::Caret: in getGNUBinOpPrecedence()
1714 case AsmToken::Amp: in getGNUBinOpPrecedence()
1719 case AsmToken::Star: in getGNUBinOpPrecedence()
1722 case AsmToken::Slash: in getGNUBinOpPrecedence()
1725 case AsmToken::Percent: in getGNUBinOpPrecedence()
1728 case AsmToken::LessLess: in getGNUBinOpPrecedence()
1731 case AsmToken::GreaterGreater: in getGNUBinOpPrecedence()
1737 unsigned AsmParser::getBinOpPrecedence(AsmToken::TokenKind K, in getBinOpPrecedence()
1785 while (Lexer.is(AsmToken::Space)) in parseStatement()
1787 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
1796 AsmToken ID = getTok(); in parseStatement()
1801 if (Lexer.is(AsmToken::HashDirective)) in parseStatement()
1806 if (Lexer.is(AsmToken::Integer)) { in parseStatement()
1817 if (Lexer.getKind() != AsmToken::Colon) { in parseStatement()
1824 } else if (Lexer.is(AsmToken::Dot)) { in parseStatement()
1828 } else if (Lexer.is(AsmToken::LCurly)) { in parseStatement()
1833 } else if (Lexer.is(AsmToken::RCurly)) { in parseStatement()
1837 } else if (Lexer.is(AsmToken::Star) && in parseStatement()
1906 if (Lexer.is(AsmToken::Colon) && getTargetParser().isLabel(ID)) { in parseStatement()
1939 if (getTok().is(AsmToken::Hash)) { in parseStatement()
1942 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr)); in parseStatement()
1947 if (getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
1979 if (Lexer.is(AsmToken::Equal) && getTargetParser().equalIsAsmAssignment()) { in parseStatement()
2320 AsmToken ID, in parseAndMatchAndEmitTargetInstruction()
2394 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly)) in parseCurlyBlockScope()
2399 if (Lexer.is(AsmToken::EndOfStatement)) in parseCurlyBlockScope()
2414 assert(getTok().is(AsmToken::Integer) && in parseCppHashLineFilenameComment()
2418 assert(getTok().is(AsmToken::String) && in parseCppHashLineFilenameComment()
2510 for (const AsmToken &Token : A[Index]) in expandMacro()
2519 Token.is(AsmToken::Integer)) in expandMacro()
2525 Token.is(AsmToken::String)) { in expandMacro()
2530 else if (Token.isNot(AsmToken::String) || VarargParameter) in expandMacro()
2597 for (const AsmToken &Token : A[Index]) in expandMacro()
2633 static bool isOperator(AsmToken::TokenKind kind) { in isOperator()
2637 case AsmToken::Plus: in isOperator()
2638 case AsmToken::Minus: in isOperator()
2639 case AsmToken::Tilde: in isOperator()
2640 case AsmToken::Slash: in isOperator()
2641 case AsmToken::Star: in isOperator()
2642 case AsmToken::Dot: in isOperator()
2643 case AsmToken::Equal: in isOperator()
2644 case AsmToken::EqualEqual: in isOperator()
2645 case AsmToken::Pipe: in isOperator()
2646 case AsmToken::PipePipe: in isOperator()
2647 case AsmToken::Caret: in isOperator()
2648 case AsmToken::Amp: in isOperator()
2649 case AsmToken::AmpAmp: in isOperator()
2650 case AsmToken::Exclaim: in isOperator()
2651 case AsmToken::ExclaimEqual: in isOperator()
2652 case AsmToken::Less: in isOperator()
2653 case AsmToken::LessEqual: in isOperator()
2654 case AsmToken::LessLess: in isOperator()
2655 case AsmToken::LessGreater: in isOperator()
2656 case AsmToken::Greater: in isOperator()
2657 case AsmToken::GreaterEqual: in isOperator()
2658 case AsmToken::GreaterGreater: in isOperator()
2684 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseMacroArgument()
2686 MA.emplace_back(AsmToken::String, Str); in parseMacroArgument()
2700 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal)) in parseMacroArgument()
2705 if (Lexer.is(AsmToken::Comma)) in parseMacroArgument()
2708 if (parseOptionalToken(AsmToken::Space)) in parseMacroArgument()
2720 parseOptionalToken(AsmToken::Space); in parseMacroArgument()
2730 if (Lexer.is(AsmToken::EndOfStatement)) in parseMacroArgument()
2734 if (Lexer.is(AsmToken::LParen)) in parseMacroArgument()
2736 else if (Lexer.is(AsmToken::RParen) && ParenLevel) in parseMacroArgument()
2768 if (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) { in parseMacroArguments()
2772 if (Lexer.isNot(AsmToken::Equal)) in parseMacroArguments()
2786 if (AltMacroMode && Lexer.is(AsmToken::Percent)) { in parseMacroArguments()
2798 AsmToken newToken(AsmToken::Integer, in parseMacroArguments()
2801 } else if (AltMacroMode && Lexer.is(AsmToken::Less) && in parseMacroArguments()
2808 AsmToken newToken(AsmToken::String, in parseMacroArguments()
2843 if (Lexer.is(AsmToken::EndOfStatement)) { in parseMacroArguments()
2861 parseOptionalToken(AsmToken::Comma); in parseMacroArguments()
2923 if (getTok().is(AsmToken::EndOfStatement)) in handleMacroExit()
2981 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) { in parseIdentifier()
2986 AsmToken Buf[1]; in parseIdentifier()
2989 if (Buf[0].isNot(AsmToken::Identifier) && Buf[0].isNot(AsmToken::Integer)) in parseIdentifier()
3005 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String)) in parseIdentifier()
3029 if (check(getTok().isNot(AsmToken::String), "expected string")) in parseEscapedString()
3138 } while (!ZeroTerminated && getTok().is(AsmToken::String)); in parseDirectiveAscii()
3157 check(getTok().isNot(AsmToken::Identifier), "expected relocation name")) in parseDirectiveReloc()
3164 if (Lexer.is(AsmToken::Comma)) { in parseDirectiveReloc()
3212 if (Asm.getTok().isNot(AsmToken::Integer) && in parseHexOcta()
3213 Asm.getTok().isNot(AsmToken::BigNum)) in parseHexOcta()
3257 if (getLexer().is(AsmToken::Minus)) { in parseRealValue()
3260 } else if (getLexer().is(AsmToken::Plus)) in parseRealValue()
3263 if (Lexer.is(AsmToken::Error)) in parseRealValue()
3265 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) && in parseRealValue()
3266 Lexer.isNot(AsmToken::Identifier)) in parseRealValue()
3272 if (getLexer().is(AsmToken::Identifier)) { in parseRealValue()
3320 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveZero()
3346 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveFill()
3350 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveFill()
3386 if (parseOptionalToken(AsmToken::Comma)) in parseDirectiveOrg()
3410 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveAlign()
3414 if (getTok().isNot(AsmToken::Comma)) { in parseDirectiveAlign()
3419 if (parseOptionalToken(AsmToken::Comma)) in parseDirectiveAlign()
3430 if (IsPow2 && (ValueSize == 1) && getTok().is(AsmToken::EndOfStatement)) { in parseDirectiveAlign()
3516 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveFile()
3534 if (getLexer().is(AsmToken::String)) { in parseDirectiveFile()
3552 while (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveFile()
3554 if (check(getTok().isNot(AsmToken::Identifier), in parseDirectiveFile()
3568 check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
3632 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLine()
3659 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
3667 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
3758 check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
3762 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCVFile()
3763 if (check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
3844 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
3855 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
3868 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVInlineSiteId()
3898 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
3906 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
4020 while (getLexer().is(AsmToken::Identifier)) { in parseDirectiveCVDefRange()
4038 AsmToken::Comma, in parseDirectiveCVDefRange()
4051 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
4064 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
4077 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
4081 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
4097 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
4102 AsmToken::Comma, in parseDirectiveCVDefRange()
4106 if (parseToken(AsmToken::Comma, "expected comma before base pointer offset " in parseDirectiveCVDefRange()
4185 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFISections()
4193 if (parseOptionalToken(AsmToken::EndOfStatement)) in parseDirectiveCFISections()
4209 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFIStartProc()
4242 if (getLexer().isNot(AsmToken::Integer)) { in parseRegisterOrRegisterNumber()
4459 while (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFIEscape()
4544 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
4548 while (getLexer().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
4565 if (Lexer.is(AsmToken::Colon)) { in parseDirectiveMacro()
4585 if (getLexer().is(AsmToken::Equal)) { in parseDirectiveMacro()
4601 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
4609 AsmToken EndToken, StartToken = getTok(); in parseDirectiveMacro()
4614 while (Lexer.is(AsmToken::Error)) { in parseDirectiveMacro()
4619 if (getLexer().is(AsmToken::Eof)) in parseDirectiveMacro()
4624 if (getLexer().is(AsmToken::Identifier)) { in parseDirectiveMacro()
4630 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveMacro()
4643 } else if (Lexer.is(AsmToken::HashDirective)) { in parseDirectiveMacro()
4792 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveEndMacro()
4857 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveBundleLock()
4887 if (parseOptionalToken(AsmToken::Comma)) in parseDirectiveSpace()
5054 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveComm()
5118 if (check(getTok().isNot(AsmToken::String), in parseDirectiveInclude()
5121 check(getTok().isNot(AsmToken::EndOfStatement), in parseDirectiveInclude()
5138 if (check(getTok().isNot(AsmToken::String), in parseDirectiveIncbin()
5146 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveIncbin()
5149 if (getTok().isNot(AsmToken::Comma)) { in parseDirectiveIncbin()
5153 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveIncbin()
5265 if (Lexer.isNot(AsmToken::String)) { in parseDirectiveIfeqs()
5274 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveIfeqs()
5283 if (Lexer.isNot(AsmToken::String)) { in parseDirectiveIfeqs()
5384 while (Lexer.isNot(AsmToken::Eof)) in parseDirectiveEnd()
5405 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveError()
5406 if (Lexer.isNot(AsmToken::String)) in parseDirectiveError()
5428 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveWarning()
5429 if (Lexer.isNot(AsmToken::String)) in parseDirectiveWarning()
5634 AsmToken EndToken, StartToken = getTok(); in parseMacroLikeBody()
5639 if (getLexer().is(AsmToken::Eof)) { in parseMacroLikeBody()
5644 if (Lexer.is(AsmToken::Identifier)) { in parseMacroLikeBody()
5653 if (Lexer.is(AsmToken::EndOfStatement)) in parseMacroLikeBody()
5790 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1)); in parseDirectiveIrpc()
5809 assert(getLexer().is(AsmToken::EndOfStatement)); in parseDirectiveEndr()
5849 const AsmToken StrTok = getTok(); in parseDirectivePrint()
5851 if (StrTok.isNot(AsmToken::String) || StrTok.getString().front() != '"') in parseDirectivePrint()
5903 while (getLexer().is(AsmToken::At)) { in parseDirectivePseudoProbe()
5908 if (getLexer().is(AsmToken::Integer)) { in parseDirectivePseudoProbe()
5915 if (getLexer().is(AsmToken::Colon)) in parseDirectivePseudoProbe()
5919 if (getLexer().is(AsmToken::Integer)) { in parseDirectivePseudoProbe()
6007 while (getLexer().isNot(AsmToken::Eof)) { in parseMSInlineAsm()
6258 AsmToken LabelTok = getTok(); in parseAsHLASMLabel()
6276 if (getTok().is(AsmToken::EndOfStatement)) in parseAsHLASMLabel()
6303 AsmToken OperationEntryTok = Lexer.getTok(); in parseAsMachineInstruction()
6332 if (getTok().isNot(AsmToken::Space)) in parseStatement()
6337 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
6354 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()