1238                            SmallVectorImpl<AsmToken> &Tokens);
1241                            SmallVectorImpl<AsmToken> &Tokens);
1244                            SmallVectorImpl<AsmToken> &Tokens);
1246                         unsigned &RegWidth, SmallVectorImpl<AsmToken> &Tokens);
1254   bool isRegister(const AsmToken &Token, const AsmToken &NextToken) const;
1433   bool ParseDirective(AsmToken DirectiveID) override;
1463   bool isOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const;
1464   bool isRegOrOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const;
1465   bool isNamedOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const;
1466   bool isOpcodeModifierWithVal(const AsmToken &Token, const AsmToken &NextToken) const;
1567   bool isId(const AsmToken &Token, const StringRef Id) const;
1568   bool isToken(const AsmToken::TokenKind Kind) const;
1571   bool trySkipId(const StringRef Id, const AsmToken::TokenKind Kind);
1572   bool trySkipToken(const AsmToken::TokenKind Kind);
1573   bool skipToken(const AsmToken::TokenKind Kind, const StringRef ErrMsg);
1577   void peekTokens(MutableArrayRef<AsmToken> Tokens);
1578   AsmToken::TokenKind getTokenKind() const;
1582   AsmToken peekToken();
1583   AsmToken getToken() const;
2398 AMDGPUAsmParser::isRegister(const AsmToken &Token,  in isRegister()
2399                             const AsmToken &NextToken) const {  in isRegister()
2402   if (Token.is(AsmToken::LBrac))  in isRegister()
2405   if (!Token.is(AsmToken::Identifier))  in isRegister()
2422       if (NextToken.is(AsmToken::LBrac))  in isRegister()
2476   if (!skipToken(AsmToken::LBrac, "missing register index"))  in ParseRegRange()
2485   if (trySkipToken(AsmToken::Colon)) {  in ParseRegRange()
2493   if (!skipToken(AsmToken::RBrac, "expected a closing square bracket"))  in ParseRegRange()
2518                                           SmallVectorImpl<AsmToken> &Tokens) {  in ParseSpecialReg()
2519   assert(isToken(AsmToken::Identifier));  in ParseSpecialReg()
2533                                           SmallVectorImpl<AsmToken> &Tokens) {  in ParseRegularReg()
2534   assert(isToken(AsmToken::Identifier));  in ParseRegularReg()
2567                                        SmallVectorImpl<AsmToken> &Tokens) {  in ParseRegList()
2571   if (!skipToken(AsmToken::LBrac,  in ParseRegList()
2586   for (; trySkipToken(AsmToken::Comma); ) {  in ParseRegList()
2608   if (!skipToken(AsmToken::RBrac,  in ParseRegList()
2621                                           SmallVectorImpl<AsmToken> &Tokens) {  in ParseAMDGPURegister()
2625   if (isToken(AsmToken::Identifier)) {  in ParseAMDGPURegister()
2656   SmallVector<AsmToken, 1> Tokens;  in ParseAMDGPURegister()
2744   bool IsReal = Tok.is(AsmToken::Real);  in parseImm()
2748   if (!IsReal && Tok.is(AsmToken::Minus) && NextTok.is(AsmToken::Real)) {  in parseImm()
2835 AMDGPUAsmParser::isNamedOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const {  in isNamedOperandModifier()
2836   if (Token.is(AsmToken::Identifier) && NextToken.is(AsmToken::LParen)) {  in isNamedOperandModifier()
2844 AMDGPUAsmParser::isOpcodeModifierWithVal(const AsmToken &Token, const AsmToken &NextToken) const {  in isOpcodeModifierWithVal()
2845   return Token.is(AsmToken::Identifier) && NextToken.is(AsmToken::Colon);  in isOpcodeModifierWithVal()
2849 AMDGPUAsmParser::isOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const {  in isOperandModifier()
2850   return isNamedOperandModifier(Token, NextToken) || Token.is(AsmToken::Pipe);  in isOperandModifier()
2854 AMDGPUAsmParser::isRegOrOperandModifier(const AsmToken &Token, const AsmToken &NextToken) const {  in isRegOrOperandModifier()
2876   AsmToken Tok = getToken();  in isModifier()
2877   AsmToken NextToken[2];  in isModifier()
2881          (Tok.is(AsmToken::Minus) && isRegOrOperandModifier(NextToken[0], NextToken[1])) ||  in isModifier()
2910   AsmToken NextToken[2];  in parseSP3NegModifier()
2913   if (isToken(AsmToken::Minus) &&  in parseSP3NegModifier()
2915        NextToken[0].is(AsmToken::Pipe) ||  in parseSP3NegModifier()
2932   if (isToken(AsmToken::Minus) && peekToken().is(AsmToken::Minus)) {  in parseRegOrImmWithFPInputMods()
2945   if (Neg && !skipToken(AsmToken::LParen, "expected left paren after neg"))  in parseRegOrImmWithFPInputMods()
2949   if (Abs && !skipToken(AsmToken::LParen, "expected left paren after abs"))  in parseRegOrImmWithFPInputMods()
2953   SP3Abs = trySkipToken(AsmToken::Pipe);  in parseRegOrImmWithFPInputMods()
2969   if (SP3Abs && !skipToken(AsmToken::Pipe, "expected vertical bar"))  in parseRegOrImmWithFPInputMods()
2971   if (Abs && !skipToken(AsmToken::RParen, "expected closing parentheses"))  in parseRegOrImmWithFPInputMods()
2973   if (Neg && !skipToken(AsmToken::RParen, "expected closing parentheses"))  in parseRegOrImmWithFPInputMods()
2995   if (Sext && !skipToken(AsmToken::LParen, "expected left paren after sext"))  in parseRegOrImmWithIntInputMods()
3008   if (Sext && !skipToken(AsmToken::RParen, "expected closing parentheses"))  in parseRegOrImmWithIntInputMods()
4435   if (!isToken(AsmToken::Integer) && !isToken(AsmToken::Identifier)) {  in ParseAsAbsoluteExpression()
4450   if (!trySkipToken(AsmToken::Comma))  in ParseDirectiveMajorMinor()
4551     while (trySkipToken(AsmToken::EndOfStatement));  in ParseDirectiveAMDHSAKernel()
4870   if (isToken(AsmToken::EndOfStatement)) {  in ParseDirectiveHSACodeObjectISA()
4881   if (!trySkipToken(AsmToken::Comma))  in ParseDirectiveHSACodeObjectISA()
4887   if (!trySkipToken(AsmToken::Comma))  in ParseDirectiveHSACodeObjectISA()
4893   if (!trySkipToken(AsmToken::Comma))  in ParseDirectiveHSACodeObjectISA()
4972     while(trySkipToken(AsmToken::EndOfStatement));  in ParseDirectiveAMDKernelCodeT()
5062   while (!isToken(AsmToken::Eof)) {  in ParseToEndDirective()
5063     while (isToken(AsmToken::Space)) {  in ParseToEndDirective()
5081   if (isToken(AsmToken::Eof) && !FoundEnd) {  in ParseToEndDirective()
5119     if (!trySkipToken(AsmToken::Comma)) {  in ParseDirectivePALMetadata()
5128     if (!trySkipToken(AsmToken::Comma))  in ParseDirectivePALMetadata()
5146   if (parseToken(AsmToken::Comma, "expected ','"))  in ParseDirectiveAMDGPULDS()
5161   if (trySkipToken(AsmToken::Comma)) {  in ParseDirectiveAMDGPULDS()
5175   if (parseToken(AsmToken::EndOfStatement,  in ParseDirectiveAMDGPULDS()
5187 bool AMDGPUAsmParser::ParseDirective(AsmToken DirectiveID) {  in ParseDirective()
5313       isToken(AsmToken::EndOfStatement))  in parseOperand()
5318   if (Mode == OperandMode_NSA && trySkipToken(AsmToken::LBrac)) {  in parseOperand()
5330       if (trySkipToken(AsmToken::RBrac))  in parseOperand()
5333       if (!skipToken(AsmToken::Comma,  in parseOperand()
5382   while (!trySkipToken(AsmToken::EndOfStatement)) {  in ParseInstruction()
5398       while (!trySkipToken(AsmToken::EndOfStatement)) {  in ParseInstruction()
5405     trySkipToken(AsmToken::Comma);  in ParseInstruction()
5418   if (!trySkipId(Prefix, AsmToken::Colon))  in parseIntWithPrefix()
5449   if (!trySkipId(Prefix, AsmToken::Colon))  in parseOperandArrayWithPrefix()
5452   if (!skipToken(AsmToken::LBrac, "expected a left square bracket"))  in parseOperandArrayWithPrefix()
5473     if (trySkipToken(AsmToken::RBrac))  in parseOperandArrayWithPrefix()
5481     if (!skipToken(AsmToken::Comma, "expected a comma"))  in parseOperandArrayWithPrefix()
5593   if (!trySkipId(Prefix, AsmToken::Colon))  in parseStringWithPrefix()
5646         !peekToken().is(AsmToken::Comma)) {  in parseDfmtNfmt()
5647       trySkipToken(AsmToken::Comma);  in parseDfmtNfmt()
5711   if (trySkipToken(AsmToken::Comma)) {  in parseSymbolicSplitFormat()
5782   if (!trySkipId("format", AsmToken::Colon))  in parseSymbolicOrNumericFormat()
5785   if (trySkipToken(AsmToken::LBrac)) {  in parseSymbolicOrNumericFormat()
5797     if (!skipToken(AsmToken::RBrac, "expected a closing square bracket"))  in parseSymbolicOrNumericFormat()
5825     trySkipToken(AsmToken::Comma);  in parseFORMAT()
5827   if (isToken(AsmToken::EndOfStatement)) {  in parseFORMAT()
5838   trySkipToken(AsmToken::Comma);  in parseFORMAT()
5853   if (isId("format") && peekToken().is(AsmToken::Colon)) {  in parseFORMAT()
6016   if (!skipToken(AsmToken::Identifier, "expected a counter name") ||  in parseCnt()
6017       !skipToken(AsmToken::LParen, "expected a left parenthesis"))  in parseCnt()
6046   if (!skipToken(AsmToken::RParen, "expected a closing parenthesis"))  in parseCnt()
6049   if (trySkipToken(AsmToken::Amp) || trySkipToken(AsmToken::Comma)) {  in parseCnt()
6050     if (isToken(AsmToken::EndOfStatement)) {  in parseCnt()
6065   if (isToken(AsmToken::Identifier) && peekToken().is(AsmToken::LParen)) {  in parseSWaitCntOps()
6066     while (!isToken(AsmToken::EndOfStatement)) {  in parseSWaitCntOps()
6096   if (isToken(AsmToken::Identifier) &&  in parseHwregBody()
6104   if (trySkipToken(AsmToken::RParen))  in parseHwregBody()
6108   if (!skipToken(AsmToken::Comma, "expected a comma or a closing parenthesis"))  in parseHwregBody()
6115   if (!skipToken(AsmToken::Comma, "expected a comma"))  in parseHwregBody()
6120          skipToken(AsmToken::RParen, "expected a closing parenthesis");  in parseHwregBody()
6159   if (trySkipId("hwreg", AsmToken::LParen)) {  in parseHwreg()
6197   if (isToken(AsmToken::Identifier) && (Msg.Id = getMsgId(getTokenStr())) >= 0) {  in parseSendMsgBody()
6204   if (trySkipToken(AsmToken::Comma)) {  in parseSendMsgBody()
6207     if (isToken(AsmToken::Identifier) &&  in parseSendMsgBody()
6214     if (trySkipToken(AsmToken::Comma)) {  in parseSendMsgBody()
6222   return skipToken(AsmToken::RParen, "expected a closing parenthesis");  in parseSendMsgBody()
6270   if (trySkipId("sendmsg", AsmToken::LParen)) {  in parseSendMsgOp()
6401 AMDGPUAsmParser::isId(const AsmToken &Token, const StringRef Id) const {  in isId()
6402   return Token.is(AsmToken::Identifier) && Token.getString() == Id;  in isId()
6411 AMDGPUAsmParser::isToken(const AsmToken::TokenKind Kind) const {  in isToken()
6426   if (isToken(AsmToken::Identifier)) {  in trySkipId()
6437 AMDGPUAsmParser::trySkipId(const StringRef Id, const AsmToken::TokenKind Kind) {  in trySkipId()
6447 AMDGPUAsmParser::trySkipToken(const AsmToken::TokenKind Kind) {  in trySkipToken()
6456 AMDGPUAsmParser::skipToken(const AsmToken::TokenKind Kind,  in skipToken()
6504   if (isToken(AsmToken::String)) {  in parseString()
6516   if (isToken(AsmToken::Identifier)) {  in parseId()
6527 AsmToken
6532 AsmToken
6534   return isToken(AsmToken::EndOfStatement) ? getToken() : getLexer().peekTok();  in peekToken()
6538 AMDGPUAsmParser::peekTokens(MutableArrayRef<AsmToken> Tokens) {  in peekTokens()
6542     Tokens[Idx] = AsmToken(AsmToken::Error, "");  in peekTokens()
6545 AsmToken::TokenKind
6631   if (!skipToken(AsmToken::Comma, "expected a comma")) {  in parseSwizzleOperand()
6752   if (!skipToken(AsmToken::Comma, "expected a comma")) {  in parseSwizzleBitmaskPerm()
6814   if (skipToken(AsmToken::LParen, "expected a left parentheses")) {  in parseSwizzleMacro()
6833     return Ok && skipToken(AsmToken::RParen, "expected a closing parentheses");  in parseSwizzleMacro()
6847     if (skipToken(AsmToken::Colon, "expected a colon")) {  in parseSwizzleOp()
6878   if (trySkipToken(AsmToken::RParen)) {  in parseGPRIdxMacro()
6908     if (trySkipToken(AsmToken::RParen))  in parseGPRIdxMacro()
6910     if (!skipToken(AsmToken::Comma,  in parseGPRIdxMacro()
6926   if (trySkipId("gpr_idx", AsmToken::LParen)) {  in parseGPRIdxMode()
7385         isToken(AsmToken::EndOfStatement))  in parseOptionalOperand()
7388     trySkipToken(AsmToken::Comma);  in parseOptionalOperand()
7743   if (isToken(AsmToken::Integer)) {  in parseDimId()
7774   if (!trySkipId("dim", AsmToken::Colon))  in parseDim()
7796   if (!isGFX10Plus() || !trySkipId("dpp8", AsmToken::Colon))  in parseDPP8()
7803   if (!skipToken(AsmToken::LBrac, "expected an opening square bracket"))  in parseDPP8()
7807     if (i > 0 && !skipToken(AsmToken::Comma, "expected a comma"))  in parseDPP8()
7819   if (!skipToken(AsmToken::RBrac, "expected a closing square bracket"))  in parseDPP8()
7859   if (!skipToken(AsmToken::LBrac, "expected an opening square bracket"))  in parseDPPCtrlPerm()
7864     if (i > 0 && !skipToken(AsmToken::Comma, "expected a comma"))  in parseDPPCtrlPerm()
7879   if (!skipToken(AsmToken::RBrac, "expected a closing square bracket"))  in parseDPPCtrlPerm()
7937   if (!isToken(AsmToken::Identifier) ||  in parseDPPCtrl()
7952     if (skipToken(AsmToken::Colon, "expected a colon")) {  in parseDPPCtrl()