[VE] 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.

[barannikov88]

ping

[barannikov88]

ping

[kaz7]

Thanks.

llvm/lib/Target/VE/AsmParser/VEAsmParser.cpp

#include "VEGenAsmMatcher.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 VE specific operands.
-  OperandMatchResultTy parseMEMOperand(OperandVector &Operands);
-  OperandMatchResultTy parseMEMAsOperand(OperandVector &Operands);
-  OperandMatchResultTy parseCCOpOperand(OperandVector &Operands);
-  OperandMatchResultTy parseRDOpOperand(OperandVector &Operands);
-  OperandMatchResultTy parseMImmOperand(OperandVector &Operands);
-  OperandMatchResultTy parseOperand(OperandVector &Operands, StringRef Name);
-  OperandMatchResultTy parseVEAsmOperand(std::unique_ptr<VEOperand> &Operand);
+  ParseStatus parseMEMOperand(OperandVector &Operands);
+  ParseStatus parseMEMAsOperand(OperandVector &Operands);
+  ParseStatus parseCCOpOperand(OperandVector &Operands);
+  ParseStatus parseRDOpOperand(OperandVector &Operands);
+  ParseStatus parseMImmOperand(OperandVector &Operands);
+  ParseStatus parseOperand(OperandVector &Operands, StringRef Name);
+  ParseStatus parseVEAsmOperand(std::unique_ptr<VEOperand> &Operand);
 
   // Helper function to parse expression with a symbol.
   const MCExpr *extractModifierFromExpr(const MCExpr *E,
                                         VEMCExpr::VariantKind &Variant);
   const MCExpr *fixupVariantKind(const MCExpr *E);
   bool parseExpression(const MCExpr *&EVal);
 
   // Split the mnemonic stripping conditional code and quantifiers
bool VEAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 
   // Split name to first token and the rest, e.g. "bgt.l.t" to "b", "gt", and
   // ".l.t".  We treat "b" as a mnemonic, "gt" as first operand, and ".l.t"
   // as second operand.
   StringRef Mnemonic = splitMnemonic(Name, NameLoc, &Operands);
 
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     // Read the first operand.
-    if (parseOperand(Operands, Mnemonic) != MatchOperand_Success) {
+    if (!parseOperand(Operands, Mnemonic).isSuccess()) {
       SMLoc Loc = getLexer().getLoc();
       return Error(Loc, "unexpected token");
     }
 
     while (getLexer().is(AsmToken::Comma)) {
       Parser.Lex(); // Eat the comma.
       // Parse and remember the operand.
-      if (parseOperand(Operands, Mnemonic) != MatchOperand_Success) {
+      if (!parseOperand(Operands, Mnemonic).isSuccess()) {
         SMLoc Loc = getLexer().getLoc();
         return Error(Loc, "unexpected token");
       }
     }
   }
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     SMLoc Loc = getLexer().getLoc();
     return Error(Loc, "unexpected token");
bool VEAsmParser::parseExpression(const MCExpr *&EVal) {
   VEMCExpr::VariantKind Variant;
   const MCExpr *E = extractModifierFromExpr(EVal, Variant);
   if (E)
     EVal = VEMCExpr::create(Variant, E, getParser().getContext());
 
   return false;
 }
 
-OperandMatchResultTy VEAsmParser::parseMEMOperand(OperandVector &Operands) {
+ParseStatus VEAsmParser::parseMEMOperand(OperandVector &Operands) {
   LLVM_DEBUG(dbgs() << "parseMEMOperand\n");
   const AsmToken &Tok = Parser.getTok();
   SMLoc S = Tok.getLoc();
   SMLoc E = Tok.getEndLoc();
   // Parse ASX format
   //   disp
   //   disp(, base)
   //   disp(index)
   //   disp(index, base)
   //   (, base)
   //   (index)
   //   (index, base)
 
   std::unique_ptr<VEOperand> Offset;
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   case AsmToken::Minus:
   case AsmToken::Integer:
   case AsmToken::Dot:
   case AsmToken::Identifier: {
     const MCExpr *EVal;
     if (!parseExpression(EVal))
       Offset = VEOperand::CreateImm(EVal, S, E);
     else
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     break;
   }
 
   case AsmToken::LParen:
     // empty disp (= 0)
     Offset =
         VEOperand::CreateImm(MCConstantExpr::create(0, getContext()), S, E);
     break;
   }
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   case AsmToken::EndOfStatement:
     Operands.push_back(VEOperand::MorphToMEMzii(
         MCConstantExpr::create(0, getContext()), std::move(Offset)));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
 
   case AsmToken::LParen:
     Parser.Lex(); // Eat the (
     break;
   }
 
   const MCExpr *IndexValue = nullptr;
   MCRegister IndexReg;
 
   switch (getLexer().getKind()) {
   default:
     if (parseRegister(IndexReg, S, E))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     break;
 
   case AsmToken::Minus:
   case AsmToken::Integer:
   case AsmToken::Dot:
     if (getParser().parseExpression(IndexValue, E))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     break;
 
   case AsmToken::Comma:
     // empty index
     IndexValue = MCConstantExpr::create(0, getContext());
     break;
   }
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   case AsmToken::RParen:
     Parser.Lex(); // Eat the )
     Operands.push_back(
         IndexValue ? VEOperand::MorphToMEMzii(IndexValue, std::move(Offset))
                    : VEOperand::MorphToMEMzri(IndexReg, std::move(Offset)));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
 
   case AsmToken::Comma:
     Parser.Lex(); // Eat the ,
     break;
   }
 
   MCRegister BaseReg;
   if (parseRegister(BaseReg, S, E))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   if (!Parser.getTok().is(AsmToken::RParen))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   Parser.Lex(); // Eat the )
   Operands.push_back(
       IndexValue
           ? VEOperand::MorphToMEMrii(BaseReg, IndexValue, std::move(Offset))
           : VEOperand::MorphToMEMrri(BaseReg, IndexReg, std::move(Offset)));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy VEAsmParser::parseMEMAsOperand(OperandVector &Operands) {
+ParseStatus VEAsmParser::parseMEMAsOperand(OperandVector &Operands) {
   LLVM_DEBUG(dbgs() << "parseMEMAsOperand\n");
   const AsmToken &Tok = Parser.getTok();
   SMLoc S = Tok.getLoc();
   SMLoc E = Tok.getEndLoc();
   // Parse AS format
   //   disp
   //   disp(, base)
   //   disp(base)
   //   disp()
   //   (, base)
   //   (base)
   //   base
 
   MCRegister BaseReg;
   std::unique_ptr<VEOperand> Offset;
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   case AsmToken::Minus:
   case AsmToken::Integer:
   case AsmToken::Dot:
   case AsmToken::Identifier: {
     const MCExpr *EVal;
     if (!parseExpression(EVal))
       Offset = VEOperand::CreateImm(EVal, S, E);
     else
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     break;
   }
 
   case AsmToken::Percent:
     if (parseRegister(BaseReg, S, E))
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     Offset =
         VEOperand::CreateImm(MCConstantExpr::create(0, getContext()), S, E);
     break;
 
   case AsmToken::LParen:
     // empty disp (= 0)
     Offset =
         VEOperand::CreateImm(MCConstantExpr::create(0, getContext()), S, E);
     break;
   }
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   case AsmToken::EndOfStatement:
   case AsmToken::Comma:
     Operands.push_back(BaseReg != VE::NoRegister
                            ? VEOperand::MorphToMEMri(BaseReg, std::move(Offset))
                            : VEOperand::MorphToMEMzi(std::move(Offset)));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
 
   case AsmToken::LParen:
     if (BaseReg != VE::NoRegister)
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     Parser.Lex(); // Eat the (
     break;
   }
 
   switch (getLexer().getKind()) {
   default:
     if (parseRegister(BaseReg, S, E))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     break;
 
   case AsmToken::Comma:
     Parser.Lex(); // Eat the ,
     if (parseRegister(BaseReg, S, E))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     break;
 
   case AsmToken::RParen:
     break;
   }
 
   if (!Parser.getTok().is(AsmToken::RParen))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   Parser.Lex(); // Eat the )
   Operands.push_back(BaseReg != VE::NoRegister
                          ? VEOperand::MorphToMEMri(BaseReg, std::move(Offset))
                          : VEOperand::MorphToMEMzi(std::move(Offset)));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy VEAsmParser::parseMImmOperand(OperandVector &Operands) {
+ParseStatus VEAsmParser::parseMImmOperand(OperandVector &Operands) {
   LLVM_DEBUG(dbgs() << "parseMImmOperand\n");
 
   // Parsing "(" + number + ")0/1"
   const AsmToken Tok1 = Parser.getTok();
   if (!Tok1.is(AsmToken::LParen))
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   Parser.Lex(); // Eat the '('.
 
   const AsmToken Tok2 = Parser.getTok();
   SMLoc E;
   const MCExpr *EVal;
   if (!Tok2.is(AsmToken::Integer) || getParser().parseExpression(EVal, E)) {
     getLexer().UnLex(Tok1);
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
 
   const AsmToken Tok3 = Parser.getTok();
   if (!Tok3.is(AsmToken::RParen)) {
     getLexer().UnLex(Tok2);
     getLexer().UnLex(Tok1);
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
   Parser.Lex(); // Eat the ')'.
 
   const AsmToken &Tok4 = Parser.getTok();
   StringRef Suffix = Tok4.getString();
   if (Suffix != "1" && Suffix != "0") {
     getLexer().UnLex(Tok3);
     getLexer().UnLex(Tok2);
     getLexer().UnLex(Tok1);
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
   Parser.Lex(); // Eat the value.
   SMLoc EndLoc = SMLoc::getFromPointer(Suffix.end());
   Operands.push_back(
       VEOperand::CreateMImm(EVal, Suffix == "0", Tok1.getLoc(), EndLoc));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy VEAsmParser::parseOperand(OperandVector &Operands,
-                                               StringRef Mnemonic) {
+ParseStatus VEAsmParser::parseOperand(OperandVector &Operands,
   LLVM_DEBUG(dbgs() << "parseOperand\n");
-  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;
 
   switch (getLexer().getKind()) {
   case AsmToken::LParen: {
     // Parsing "(" + %vreg + ", " + %vreg + ")"
     const AsmToken Tok1 = Parser.getTok();
     Parser.Lex(); // Eat the '('.
 
     MCRegister RegNo1;
     SMLoc S1, E1;
     if (tryParseRegister(RegNo1, S1, E1) != MatchOperand_Success) {
       getLexer().UnLex(Tok1);
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     }
 
     if (!Parser.getTok().is(AsmToken::Comma))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     Parser.Lex(); // Eat the ','.
 
     MCRegister RegNo2;
     SMLoc S2, E2;
     if (tryParseRegister(RegNo2, S2, E2) != MatchOperand_Success)
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     if (!Parser.getTok().is(AsmToken::RParen))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     Operands.push_back(VEOperand::CreateToken(Tok1.getString(), Tok1.getLoc()));
     Operands.push_back(VEOperand::CreateReg(RegNo1, S1, E1));
     Operands.push_back(VEOperand::CreateReg(RegNo2, S2, E2));
     Operands.push_back(VEOperand::CreateToken(Parser.getTok().getString(),
                                               Parser.getTok().getLoc()));
     Parser.Lex(); // Eat the ')'.
     break;
   }
   default: {
     std::unique_ptr<VEOperand> Op;
-    ResTy = parseVEAsmOperand(Op);
-    if (ResTy != MatchOperand_Success || !Op)
-      return MatchOperand_ParseFail;
+    Res = parseVEAsmOperand(Op);
+    if (!Res.isSuccess() || !Op)
+      return ParseStatus::Failure;
 
     // Push the parsed operand into the list of operands
     Operands.push_back(std::move(Op));
 
     if (!Parser.getTok().is(AsmToken::LParen))
       break;
 
     // Parsing %vec-reg + "(" + %sclar-reg/number + ")"
     std::unique_ptr<VEOperand> Op1 = VEOperand::CreateToken(
         Parser.getTok().getString(), Parser.getTok().getLoc());
     Parser.Lex(); // Eat the '('.
 
     std::unique_ptr<VEOperand> Op2;
-    ResTy = parseVEAsmOperand(Op2);
-    if (ResTy != MatchOperand_Success || !Op2)
-      return MatchOperand_ParseFail;
+    Res = parseVEAsmOperand(Op2);
+    if (!Res.isSuccess() || !Op2)
+      return ParseStatus::Failure;
 
     if (!Parser.getTok().is(AsmToken::RParen))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     Operands.push_back(std::move(Op1));
     Operands.push_back(std::move(Op2));
     Operands.push_back(VEOperand::CreateToken(Parser.getTok().getString(),
                                               Parser.getTok().getLoc()));
     Parser.Lex(); // Eat the ')'.
     break;
   }
   }
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy
-VEAsmParser::parseVEAsmOperand(std::unique_ptr<VEOperand> &Op) {
+ParseStatus VEAsmParser::parseVEAsmOperand(std::unique_ptr<VEOperand> &Op) {
   LLVM_DEBUG(dbgs() << "parseVEAsmOperand\n");
   SMLoc S = Parser.getTok().getLoc();
   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
   const MCExpr *EVal;
 
   Op = nullptr;
   switch (getLexer().getKind()) {
   default:
     break;
 
   case AsmToken::Percent: {
     MCRegister RegNo;
     if (tryParseRegister(RegNo, S, E) == MatchOperand_Success)
       Op = VEOperand::CreateReg(RegNo, S, E);
     break;
   }
   case AsmToken::Minus:
   case AsmToken::Integer:
   case AsmToken::Dot:
   case AsmToken::Identifier:
     if (!parseExpression(EVal))
       Op = VEOperand::CreateImm(EVal, S, E);
     break;
   }
-  return (Op) ? MatchOperand_Success : MatchOperand_ParseFail;
+  return Op ? ParseStatus::Success : ParseStatus::Failure;
 }
 
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeVEAsmParser() {
   RegisterMCAsmParser<VEAsmParser> A(getTheVETarget());
 }
 
 #define GET_REGISTER_MATCHER