[Sparc] Replace OperandMatchResultTy with ParseStatus (NFC)

[barannikov88]

Summary

ParseStatus is slightly more convenient to use due to implicit
conversion from bool, which allows to do something like:

return Error(L, "msg");

when with MatchOperandResultTy it had to be:

Error(L, "msg");
return MatchOperand_ParseFail;

It also has more appropriate name since parse* methods are not only for
parsing operands.

[koakuma]

Seems OK here, at least.

[barannikov88]

Rebase & ping

llvm/lib/Target/Sparc/AsmParser/SparcAsmParser.cpp

#include "SparcGenAsmMatcher.inc"
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
   ParseStatus parseDirective(AsmToken DirectiveID) override;
 
   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
                                       unsigned Kind) override;
 
   // Custom parse functions for Sparc specific operands.
-  OperandMatchResultTy parseMEMOperand(OperandVector &Operands);
+  ParseStatus parseMEMOperand(OperandVector &Operands);
 
-  OperandMatchResultTy parseMembarTag(OperandVector &Operands);
+  ParseStatus parseMembarTag(OperandVector &Operands);
 
-  OperandMatchResultTy parseASITag(OperandVector &Operands);
+  ParseStatus parseASITag(OperandVector &Operands);
 
   template <TailRelocKind Kind>
-  OperandMatchResultTy parseTailRelocSym(OperandVector &Operands);
+  ParseStatus parseTailRelocSym(OperandVector &Operands);
 
-  template <unsigned N>
-  OperandMatchResultTy parseShiftAmtImm(OperandVector &Operands);
+  template <unsigned N> ParseStatus parseShiftAmtImm(OperandVector &Operands);
 
-  OperandMatchResultTy parseCallTarget(OperandVector &Operands);
+  ParseStatus parseCallTarget(OperandVector &Operands);
 
-  OperandMatchResultTy parseOperand(OperandVector &Operands, StringRef Name);
+  ParseStatus parseOperand(OperandVector &Operands, StringRef Name);
 
-  OperandMatchResultTy
-  parseSparcAsmOperand(std::unique_ptr<SparcOperand> &Operand,
+  ParseStatus parseSparcAsmOperand(std::unique_ptr<SparcOperand> &Operand,
                                    bool isCall = false);
 
-  OperandMatchResultTy parseBranchModifiers(OperandVector &Operands);
+  ParseStatus parseBranchModifiers(OperandVector &Operands);
 
   // Helper function for dealing with %lo / %hi in PIC mode.
   const SparcMCExpr *adjustPICRelocation(SparcMCExpr::VariantKind VK,
                                          const MCExpr *subExpr);
 
   // returns true if Tok is matched to a register and returns register in RegNo.
   bool matchRegisterName(const AsmToken &Tok, MCRegister &RegNo,
                          unsigned &RegKind);
bool SparcAsmParser::ParseInstruction(ParseInstructionInfo &Info,
   Operands.push_back(SparcOperand::CreateToken(Name, NameLoc));
 
   // apply mnemonic aliases, if any, so that we can parse operands correctly.
   applyMnemonicAliases(Name, getAvailableFeatures(), 0);
 
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     // Read the first operand.
     if (getLexer().is(AsmToken::Comma)) {
-      if (parseBranchModifiers(Operands) != MatchOperand_Success) {
+      if (!parseBranchModifiers(Operands).isSuccess()) {
         SMLoc Loc = getLexer().getLoc();
         return Error(Loc, "unexpected token");
       }
     }
-    if (parseOperand(Operands, Name) != MatchOperand_Success) {
+    if (!parseOperand(Operands, Name).isSuccess()) {
       SMLoc Loc = getLexer().getLoc();
       return Error(Loc, "unexpected token");
     }
 
     while (getLexer().is(AsmToken::Comma) || getLexer().is(AsmToken::Plus)) {
       if (getLexer().is(AsmToken::Plus)) {
       // Plus tokens are significant in software_traps (p83, sparcv8.pdf). We must capture them.
         Operands.push_back(SparcOperand::CreateToken("+", Parser.getTok().getLoc()));
       }
       Parser.Lex(); // Eat the comma or plus.
       // Parse and remember the operand.
-      if (parseOperand(Operands, Name) != MatchOperand_Success) {
+      if (!parseOperand(Operands, Name).isSuccess()) {
         SMLoc Loc = getLexer().getLoc();
         return Error(Loc, "unexpected token");
       }
     }
   }
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     SMLoc Loc = getLexer().getLoc();
     return Error(Loc, "unexpected token");
if (IDVal == ".proc") {
     Parser.eatToEndOfStatement();
     return ParseStatus::Success;
   }
 
   // Let the MC layer to handle other directives.
   return ParseStatus::NoMatch;
 }
 
-OperandMatchResultTy
-SparcAsmParser::parseMEMOperand(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseMEMOperand(OperandVector &Operands) {
   SMLoc S, E;
 
   std::unique_ptr<SparcOperand> LHS;
-  if (parseSparcAsmOperand(LHS) != MatchOperand_Success)
-    return MatchOperand_NoMatch;
+  if (!parseSparcAsmOperand(LHS).isSuccess())
+    return ParseStatus::NoMatch;
 
   // Single immediate operand
   if (LHS->isImm()) {
     Operands.push_back(SparcOperand::MorphToMEMri(Sparc::G0, std::move(LHS)));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
-  if (!LHS->isIntReg()) {
-    Error(LHS->getStartLoc(), "invalid register kind for this operand");
-    return MatchOperand_ParseFail;
-  }
+  if (!LHS->isIntReg())
+    return Error(LHS->getStartLoc(), "invalid register kind for this operand");
 
   AsmToken Tok = getLexer().getTok();
   // The plus token may be followed by a register or an immediate value, the
   // minus one is always interpreted as sign for the immediate value
   if (Tok.is(AsmToken::Plus) || Tok.is(AsmToken::Minus)) {
     (void)Parser.parseOptionalToken(AsmToken::Plus);
 
     std::unique_ptr<SparcOperand> RHS;
-    if (parseSparcAsmOperand(RHS) != MatchOperand_Success)
-      return MatchOperand_NoMatch;
+    if (!parseSparcAsmOperand(RHS).isSuccess())
+      return ParseStatus::NoMatch;
 
-    if (RHS->isReg() && !RHS->isIntReg()) {
-      Error(RHS->getStartLoc(), "invalid register kind for this operand");
-      return MatchOperand_ParseFail;
-    }
+    if (RHS->isReg() && !RHS->isIntReg())
+      return Error(RHS->getStartLoc(),
+                   "invalid register kind for this operand");
 
     Operands.push_back(
         RHS->isImm()
             ? SparcOperand::MorphToMEMri(LHS->getReg(), std::move(RHS))
             : SparcOperand::MorphToMEMrr(LHS->getReg(), std::move(RHS)));
 
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   Operands.push_back(SparcOperand::CreateMEMr(LHS->getReg(), S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 template <unsigned N>
-OperandMatchResultTy SparcAsmParser::parseShiftAmtImm(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseShiftAmtImm(OperandVector &Operands) {
   SMLoc S = Parser.getTok().getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
 
   // This is a register, not an immediate
   if (getLexer().getKind() == AsmToken::Percent)
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   const MCExpr *Expr;
   if (getParser().parseExpression(Expr))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
-  if (!CE) {
-    Error(S, "constant expression expected");
-    return MatchOperand_ParseFail;
-  }
+  if (!CE)
+    return Error(S, "constant expression expected");
 
-  if (!isUInt<N>(CE->getValue())) {
-    Error(S, "immediate shift value out of range");
-    return MatchOperand_ParseFail;
-  }
+  if (!isUInt<N>(CE->getValue()))
+    return Error(S, "immediate shift value out of range");
 
   Operands.push_back(SparcOperand::CreateImm(Expr, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 template <SparcAsmParser::TailRelocKind Kind>
-OperandMatchResultTy
-SparcAsmParser::parseTailRelocSym(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseTailRelocSym(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
 
   auto MatchesKind = [](SparcMCExpr::VariantKind VK) -> bool {
     switch (Kind) {
     case TailRelocKind::Load_GOT:
       // Non-TLS relocations on ld (or ldx).
       // ld [%rr + %rr], %rr, %rel(sym)
case TailRelocKind::Call_TLS:
         return true;
       default:
         return false;
       }
     }
     llvm_unreachable("Unhandled SparcAsmParser::TailRelocKind enum");
   };
 
-  if (getLexer().getKind() != AsmToken::Percent) {
-    Error(getLoc(), "expected '%' for operand modifier");
-    return MatchOperand_ParseFail;
-  }
+  if (getLexer().getKind() != AsmToken::Percent)
+    return Error(getLoc(), "expected '%' for operand modifier");
 
   const AsmToken Tok = Parser.getTok();
   getParser().Lex(); // Eat '%'
 
-  if (getLexer().getKind() != AsmToken::Identifier) {
-    Error(getLoc(), "expected valid identifier for operand modifier");
-    return MatchOperand_ParseFail;
-  }
+  if (getLexer().getKind() != AsmToken::Identifier)
+    return Error(getLoc(), "expected valid identifier for operand modifier");
 
   StringRef Name = getParser().getTok().getIdentifier();
   SparcMCExpr::VariantKind VK = SparcMCExpr::parseVariantKind(Name);
-  if (VK == SparcMCExpr::VK_Sparc_None) {
-    Error(getLoc(), "invalid operand modifier");
-    return MatchOperand_ParseFail;
-  }
+  if (VK == SparcMCExpr::VK_Sparc_None)
+    return Error(getLoc(), "invalid operand modifier");
 
   if (!MatchesKind(VK)) {
     // Did not match the specified set of relocation types, put '%' back.
     getLexer().UnLex(Tok);
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
 
   Parser.Lex(); // Eat the identifier.
-  if (getLexer().getKind() != AsmToken::LParen) {
-    Error(getLoc(), "expected '('");
-    return MatchOperand_ParseFail;
-  }
+  if (getLexer().getKind() != AsmToken::LParen)
+    return Error(getLoc(), "expected '('");
 
   getParser().Lex(); // Eat '('
   const MCExpr *SubExpr;
-  if (getParser().parseParenExpression(SubExpr, E)) {
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseParenExpression(SubExpr, E))
+    return ParseStatus::Failure;
 
   const MCExpr *Val = adjustPICRelocation(VK, SubExpr);
   Operands.push_back(SparcOperand::CreateImm(Val, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy SparcAsmParser::parseMembarTag(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseMembarTag(OperandVector &Operands) {
   SMLoc S = Parser.getTok().getLoc();
   const MCExpr *EVal;
   int64_t ImmVal = 0;
 
   std::unique_ptr<SparcOperand> Mask;
-  if (parseSparcAsmOperand(Mask) == MatchOperand_Success) {
+  if (parseSparcAsmOperand(Mask).isSuccess()) {
     if (!Mask->isImm() || !Mask->getImm()->evaluateAsAbsolute(ImmVal) ||
-        ImmVal < 0 || ImmVal > 127) {
-      Error(S, "invalid membar mask number");
-      return MatchOperand_ParseFail;
-    }
+        ImmVal < 0 || ImmVal > 127)
+      return Error(S, "invalid membar mask number");
   }
 
   while (getLexer().getKind() == AsmToken::Hash) {
     SMLoc TagStart = getLexer().getLoc();
     Parser.Lex(); // Eat the '#'.
     unsigned MaskVal = StringSwitch<unsigned>(Parser.getTok().getString())
       .Case("LoadLoad", 0x1)
       .Case("StoreLoad", 0x2)
       .Case("LoadStore", 0x4)
       .Case("StoreStore", 0x8)
       .Case("Lookaside", 0x10)
       .Case("MemIssue", 0x20)
       .Case("Sync", 0x40)
       .Default(0);
 
     Parser.Lex(); // Eat the identifier token.
 
-    if (!MaskVal) {
-      Error(TagStart, "unknown membar tag");
-      return MatchOperand_ParseFail;
-    }
+    if (!MaskVal)
+      return Error(TagStart, "unknown membar tag");
 
     ImmVal |= MaskVal;
 
     if (getLexer().getKind() == AsmToken::Pipe)
       Parser.Lex(); // Eat the '|'.
   }
 
   EVal = MCConstantExpr::create(ImmVal, getContext());
   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
   Operands.push_back(SparcOperand::CreateImm(EVal, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy SparcAsmParser::parseASITag(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseASITag(OperandVector &Operands) {
   SMLoc S = Parser.getTok().getLoc();
   SMLoc E = Parser.getTok().getEndLoc();
   int64_t ASIVal = 0;
 
   if (is64Bit() && (getLexer().getKind() == AsmToken::Hash)) {
     // For now we only support named tags for 64-bit/V9 systems.
     // TODO: add support for 32-bit/V8 systems.
     SMLoc TagStart = getLexer().peekTok(false).getLoc();
     Parser.Lex(); // Eat the '#'.
     auto ASIName = Parser.getTok().getString();
     auto ASITag = SparcASITag::lookupASITagByName(ASIName);
     if (!ASITag)
       ASITag = SparcASITag::lookupASITagByAltName(ASIName);
     Parser.Lex(); // Eat the identifier token.
 
-    if (!ASITag) {
-      Error(TagStart, "unknown ASI tag");
-      return MatchOperand_ParseFail;
-    }
+    if (!ASITag)
+      return Error(TagStart, "unknown ASI tag");
 
     ASIVal = ASITag->Encoding;
   } else if (!getParser().parseAbsoluteExpression(ASIVal)) {
-    if (!isUInt<8>(ASIVal)) {
-      Error(S, "invalid ASI number, must be between 0 and 255");
-      return MatchOperand_ParseFail;
-    }
+    if (!isUInt<8>(ASIVal))
+      return Error(S, "invalid ASI number, must be between 0 and 255");
   } else {
-    Error(S, is64Bit()
-                 ? "malformed ASI tag, must be %asi, a constant integer "
-                   "expression, or a named tag"
-                 : "malformed ASI tag, must be a constant integer expression");
-    return MatchOperand_ParseFail;
+    return Error(
+        S, is64Bit()
   }
 
   Operands.push_back(SparcOperand::CreateASITag(ASIVal, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy SparcAsmParser::parseCallTarget(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseCallTarget(OperandVector &Operands) {
   SMLoc S = Parser.getTok().getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   case AsmToken::LParen:
   case AsmToken::Integer:
   case AsmToken::Identifier:
   case AsmToken::Dot:
     break;
   }
 
   const MCExpr *DestValue;
   if (getParser().parseExpression(DestValue))
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   bool IsPic = getContext().getObjectFileInfo()->isPositionIndependent();
   SparcMCExpr::VariantKind Kind =
       IsPic ? SparcMCExpr::VK_Sparc_WPLT30 : SparcMCExpr::VK_Sparc_WDISP30;
 
   const MCExpr *DestExpr = SparcMCExpr::create(Kind, DestValue, getContext());
   Operands.push_back(SparcOperand::CreateImm(DestExpr, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy
-SparcAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
+ParseStatus SparcAsmParser::parseOperand(OperandVector &Operands,
+                                         StringRef Mnemonic) {
 
-  OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
+  ParseStatus Res = MatchOperandParserImpl(Operands, Mnemonic);
 
   // If there wasn't a custom match, try the generic matcher below. Otherwise,
   // there was a match, but an error occurred, in which case, just return that
   // the operand parsing failed.
-  if (ResTy == MatchOperand_Success || ResTy == MatchOperand_ParseFail)
-    return ResTy;
+  if (Res.isSuccess() || Res.isFailure())
+    return Res;
 
   if (getLexer().is(AsmToken::LBrac)) {
     // Memory operand
     Operands.push_back(SparcOperand::CreateToken("[",
                                                  Parser.getTok().getLoc()));
     Parser.Lex(); // Eat the [
 
     if (Mnemonic == "cas" || Mnemonic == "casl" || Mnemonic == "casa" ||
         Mnemonic == "casx" || Mnemonic == "casxl" || Mnemonic == "casxa") {
       SMLoc S = Parser.getTok().getLoc();
       if (getLexer().getKind() != AsmToken::Percent)
-        return MatchOperand_NoMatch;
+        return ParseStatus::NoMatch;
       Parser.Lex(); // eat %
 
       MCRegister RegNo;
       unsigned RegKind;
       if (!matchRegisterName(Parser.getTok(), RegNo, RegKind))
-        return MatchOperand_NoMatch;
+        return ParseStatus::NoMatch;
 
       Parser.Lex(); // Eat the identifier token.
       SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer()-1);
       Operands.push_back(SparcOperand::CreateReg(RegNo, RegKind, S, E));
-      ResTy = MatchOperand_Success;
+      Res = ParseStatus::Success;
     } else {
-      ResTy = parseMEMOperand(Operands);
+      Res = parseMEMOperand(Operands);
     }
 
-    if (ResTy != MatchOperand_Success)
-      return ResTy;
+    if (!Res.isSuccess())
+      return Res;
 
     if (!getLexer().is(AsmToken::RBrac))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     Operands.push_back(SparcOperand::CreateToken("]",
                                                  Parser.getTok().getLoc()));
     Parser.Lex(); // Eat the ]
 
     // Parse an optional address-space identifier after the address.
     // This will be either an immediate constant expression, or, on 64-bit
     // processors, the %asi register.
     if (is64Bit() && getLexer().is(AsmToken::Percent)) {
       SMLoc S = Parser.getTok().getLoc();
       Parser.Lex(); // Eat the %.
       const AsmToken Tok = Parser.getTok();
       if (Tok.is(AsmToken::Identifier) && Tok.getString() == "asi") {
         // Here we patch the MEM operand from [base + %g0] into [base + 0]
         // as memory operations with ASI tag stored in %asi register needs
         // to use immediate offset. We need to do this because Reg addressing
         // will be parsed as Reg+G0 initially.
         // This allows forms such as `ldxa [%o0] %asi, %o0` to parse correctly.
         SparcOperand &OldMemOp = (SparcOperand &)*Operands[Operands.size() - 2];
         if (OldMemOp.isMEMrr()) {
           if (OldMemOp.getMemOffsetReg() != Sparc::G0) {
-            Error(S, "invalid operand for instruction");
-            return MatchOperand_ParseFail;
+            return Error(S, "invalid operand for instruction");
           }
           Operands[Operands.size() - 2] = SparcOperand::MorphToMEMri(
               OldMemOp.getMemBase(),
               SparcOperand::CreateImm(MCConstantExpr::create(0, getContext()),
                                       OldMemOp.getStartLoc(),
                                       OldMemOp.getEndLoc()));
         }
         Parser.Lex(); // Eat the identifier.
         // In this context, we convert the register operand into
         // a plain "%asi" token since the register access is already
         // implicit in the instruction definition and encoding.
         // See LoadASI/StoreASI in SparcInstrInfo.td.
         Operands.push_back(SparcOperand::CreateToken("%asi", S));
-        return MatchOperand_Success;
+        return ParseStatus::Success;
       }
 
-      Error(S, "malformed ASI tag, must be %asi, a constant integer "
+      return Error(S, "malformed ASI tag, must be %asi, a constant integer "
                       "expression, or a named tag");
-      return MatchOperand_ParseFail;
     }
 
     // If we're not at the end of statement and the next token is not a comma,
     // then it is an immediate ASI value.
     if (getLexer().isNot(AsmToken::EndOfStatement) &&
         getLexer().isNot(AsmToken::Comma))
       return parseASITag(Operands);
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   std::unique_ptr<SparcOperand> Op;
 
-  ResTy = parseSparcAsmOperand(Op, (Mnemonic == "call"));
-  if (ResTy != MatchOperand_Success || !Op)
-    return MatchOperand_ParseFail;
+  Res = parseSparcAsmOperand(Op, (Mnemonic == "call"));
+  if (!Res.isSuccess() || !Op)
+    return ParseStatus::Failure;
 
   // Push the parsed operand into the list of operands
   Operands.push_back(std::move(Op));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy
+ParseStatus
 SparcAsmParser::parseSparcAsmOperand(std::unique_ptr<SparcOperand> &Op,
                                      bool isCall) {
   SMLoc S = Parser.getTok().getLoc();
   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
   const MCExpr *EVal;
 
   Op = nullptr;
   switch (getLexer().getKind()) {
if (!EVal->evaluateAsAbsolute(Res)) {
         else
           Kind = SparcMCExpr::VK_Sparc_GOT13;
       }
       EVal = SparcMCExpr::create(Kind, EVal, getContext());
     }
     Op = SparcOperand::CreateImm(EVal, S, E);
     break;
   }
-  return (Op) ? MatchOperand_Success : MatchOperand_ParseFail;
+  return Op ? ParseStatus::Success : ParseStatus::Failure;
 }
 
-OperandMatchResultTy
-SparcAsmParser::parseBranchModifiers(OperandVector &Operands) {
+ParseStatus SparcAsmParser::parseBranchModifiers(OperandVector &Operands) {
   // parse (,a|,pn|,pt)+
 
   while (getLexer().is(AsmToken::Comma)) {
     Parser.Lex(); // Eat the comma
 
     if (!getLexer().is(AsmToken::Identifier))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     StringRef modName = Parser.getTok().getString();
     if (modName == "a" || modName == "pn" || modName == "pt") {
       Operands.push_back(SparcOperand::CreateToken(modName,
                                                    Parser.getTok().getLoc()));
       Parser.Lex(); // eat the identifier.
     }
   }
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 bool SparcAsmParser::matchRegisterName(const AsmToken &Tok, MCRegister &RegNo,
                                        unsigned &RegKind) {
   int64_t intVal = 0;
   RegNo = 0;
   RegKind = SparcOperand::rk_None;
   if (Tok.is(AsmToken::Identifier)) {