[AVR][BPF][Lanai][Xtensa] 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.

[MaskRay]

Thanks!

llvm/lib/Target/AVR/AsmParser/AVRAsmParser.cpp

#include "AVRGenAsmMatcher.inc"
   OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override;
 
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
 
   ParseStatus parseDirective(AsmToken DirectiveID) override;
 
-  OperandMatchResultTy parseMemriOperand(OperandVector &Operands);
+  ParseStatus parseMemriOperand(OperandVector &Operands);
 
   bool parseOperand(OperandVector &Operands, bool maybeReg);
   int parseRegisterName(unsigned (*matchFn)(StringRef));
   int parseRegisterName();
   int parseRegister(bool RestoreOnFailure = false);
   bool tryParseRegisterOperand(OperandVector &Operands);
   bool tryParseExpression(OperandVector &Operands);
   bool tryParseRelocExpression(OperandVector &Operands);
case AsmToken::Minus: {
     return false;
   }
   }
 
   // Could not parse operand
   return true;
 }
 
-OperandMatchResultTy AVRAsmParser::parseMemriOperand(OperandVector &Operands) {
+ParseStatus AVRAsmParser::parseMemriOperand(OperandVector &Operands) {
   LLVM_DEBUG(dbgs() << "parseMemriOperand()\n");
 
   SMLoc E, S;
   MCExpr const *Expression;
   int RegNo;
 
   // Parse register.
   {
     RegNo = parseRegister();
 
     if (RegNo == AVR::NoRegister)
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     S = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
     Parser.Lex(); // Eat register token.
   }
 
   // Parse immediate;
   {
     if (getParser().parseExpression(Expression))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
   }
 
   Operands.push_back(AVROperand::CreateMemri(RegNo, Expression, S, E));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 bool AVRAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                  SMLoc &EndLoc) {
   StartLoc = Parser.getTok().getLoc();
   RegNo = parseRegister(/*RestoreOnFailure=*/false);
   EndLoc = Parser.getTok().getLoc();
 
bool AVRAsmParser::ParseInstruction(ParseInstructionInfo &Info,
   Operands.push_back(AVROperand::CreateToken(Mnemonic, NameLoc));
 
   int OperandNum = -1;
   while (getLexer().isNot(AsmToken::EndOfStatement)) {
     OperandNum++;
     if (OperandNum > 0)
       eatComma();
 
-    auto MatchResult = MatchOperandParserImpl(Operands, Mnemonic);
+    ParseStatus ParseRes = MatchOperandParserImpl(Operands, Mnemonic);
 
-    if (MatchResult == MatchOperand_Success) {
+    if (ParseRes.isSuccess())
       continue;
-    }
 
-    if (MatchResult == MatchOperand_ParseFail) {
+    if (ParseRes.isFailure()) {
       SMLoc Loc = getLexer().getLoc();
       Parser.eatToEndOfStatement();
 
       return Error(Loc, "failed to parse register and immediate pair");
     }
 
     // These specific operands should be treated as addresses/symbols/labels,
     // other than registers.

llvm/lib/Target/BPF/AsmParser/BPFAsmParser.cpp

class BPFAsmParser : public MCTargetAsmParser {
   bool equalIsAsmAssignment() override { return false; }
   // "*" is used for dereferencing memory that it will be the start of
   // statement.
   bool starIsStartOfStatement() override { return true; }
 
 #define GET_ASSEMBLER_HEADER
 #include "BPFGenAsmMatcher.inc"
 
-  OperandMatchResultTy parseImmediate(OperandVector &Operands);
-  OperandMatchResultTy parseRegister(OperandVector &Operands);
-  OperandMatchResultTy parseOperandAsOperator(OperandVector &Operands);
+  ParseStatus parseImmediate(OperandVector &Operands);
+  ParseStatus parseRegister(OperandVector &Operands);
+  ParseStatus parseOperandAsOperator(OperandVector &Operands);
 
 public:
   enum BPFMatchResultTy {
     Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "BPFGenAsmMatcher.inc"
 #undef GET_OPERAND_DIAGNOSTIC_TYPES
   };
OperandMatchResultTy BPFAsmParser::tryParseRegister(MCRegister &RegNo,
   if (!MatchRegisterName(Name)) {
     getParser().Lex(); // Eat identifier token.
     return MatchOperand_Success;
   }
 
   return MatchOperand_NoMatch;
 }
 
-OperandMatchResultTy
-BPFAsmParser::parseOperandAsOperator(OperandVector &Operands) {
+ParseStatus BPFAsmParser::parseOperandAsOperator(OperandVector &Operands) {
   SMLoc S = getLoc();
 
   if (getLexer().getKind() == AsmToken::Identifier) {
     StringRef Name = getLexer().getTok().getIdentifier();
 
     if (BPFOperand::isValidIdInMiddle(Name)) {
       getLexer().Lex();
       Operands.push_back(BPFOperand::createToken(Name, S));
-      return MatchOperand_Success;
+      return ParseStatus::Success;
     }
 
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
 
   switch (getLexer().getKind()) {
   case AsmToken::Minus:
   case AsmToken::Plus: {
     if (getLexer().peekTok().is(AsmToken::Integer))
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     [[fallthrough]];
   }
 
   case AsmToken::Equal:
   case AsmToken::Greater:
   case AsmToken::Less:
   case AsmToken::Pipe:
   case AsmToken::Star:
   case AsmToken::LParen:
   case AsmToken::RParen:
   case AsmToken::LBrac:
   case AsmToken::RBrac:
   case AsmToken::Slash:
   case AsmToken::Amp:
   case AsmToken::Percent:
   case AsmToken::Caret: {
     StringRef Name = getLexer().getTok().getString();
     getLexer().Lex();
     Operands.push_back(BPFOperand::createToken(Name, S));
 
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   case AsmToken::EqualEqual:
   case AsmToken::ExclaimEqual:
   case AsmToken::GreaterEqual:
   case AsmToken::GreaterGreater:
   case AsmToken::LessEqual:
   case AsmToken::LessLess: {
     Operands.push_back(BPFOperand::createToken(
         getLexer().getTok().getString().substr(0, 1), S));
     Operands.push_back(BPFOperand::createToken(
         getLexer().getTok().getString().substr(1, 1), S));
     getLexer().Lex();
 
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   default:
     break;
   }
 
-  return MatchOperand_NoMatch;
+  return ParseStatus::NoMatch;
 }
 
-OperandMatchResultTy BPFAsmParser::parseRegister(OperandVector &Operands) {
+ParseStatus BPFAsmParser::parseRegister(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   case AsmToken::Identifier:
     StringRef Name = getLexer().getTok().getIdentifier();
     unsigned RegNo = MatchRegisterName(Name);
 
     if (RegNo == 0)
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
 
     getLexer().Lex();
     Operands.push_back(BPFOperand::createReg(RegNo, S, E));
   }
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy BPFAsmParser::parseImmediate(OperandVector &Operands) {
+ParseStatus BPFAsmParser::parseImmediate(OperandVector &Operands) {
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   case AsmToken::LParen:
   case AsmToken::Minus:
   case AsmToken::Plus:
   case AsmToken::Integer:
   case AsmToken::String:
   case AsmToken::Identifier:
     break;
   }
 
   const MCExpr *IdVal;
   SMLoc S = getLoc();
 
   if (getParser().parseExpression(IdVal))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
   Operands.push_back(BPFOperand::createImm(IdVal, S, E));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 /// ParseInstruction - Parse an BPF instruction which is in BPF verifier
 /// format.
 bool BPFAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                     SMLoc NameLoc, OperandVector &Operands) {
   // The first operand could be either register or actually an operator.
   unsigned RegNo = MatchRegisterName(Name);
 
   if (RegNo != 0) {
     SMLoc E = SMLoc::getFromPointer(NameLoc.getPointer() - 1);
     Operands.push_back(BPFOperand::createReg(RegNo, NameLoc, E));
   } else if (BPFOperand::isValidIdAtStart (Name))
     Operands.push_back(BPFOperand::createToken(Name, NameLoc));
   else
     return Error(NameLoc, "invalid register/token name");
 
   while (!getLexer().is(AsmToken::EndOfStatement)) {
     // Attempt to parse token as operator
-    if (parseOperandAsOperator(Operands) == MatchOperand_Success)
+    if (parseOperandAsOperator(Operands).isSuccess())
       continue;
 
     // Attempt to parse token as register
-    if (parseRegister(Operands) == MatchOperand_Success)
+    if (parseRegister(Operands).isSuccess())
       continue;
 
     if (getLexer().is(AsmToken::Comma)) {
       getLexer().Lex();
       continue;
     }
 
     // Attempt to parse token as an immediate
-    if (parseImmediate(Operands) != MatchOperand_Success) {
+    if (!parseImmediate(Operands).isSuccess()) {
       SMLoc Loc = getLexer().getLoc();
       return Error(Loc, "unexpected token");
     }
   }
 
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     SMLoc Loc = getLexer().getLoc();
 

llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp

bool MatchAndEmitInstruction(SMLoc IdLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
 
 // Auto-generated instruction matching functions
 #define GET_ASSEMBLER_HEADER
 #include "LanaiGenAsmMatcher.inc"
 
-  OperandMatchResultTy parseOperand(OperandVector *Operands,
-                                    StringRef Mnemonic);
+  ParseStatus parseOperand(OperandVector *Operands, StringRef Mnemonic);
 
-  OperandMatchResultTy parseMemoryOperand(OperandVector &Operands);
+  ParseStatus parseMemoryOperand(OperandVector &Operands);
 
 public:
   LanaiAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
                  const MCInstrInfo &MII, const MCTargetOptions &Options)
       : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
         Lexer(Parser.getLexer()), SubtargetInfo(STI) {
     setAvailableFeatures(
         ComputeAvailableFeatures(SubtargetInfo.getFeatureBits()));
const LanaiMCExpr *LHSSymbolRefExpr =
         dyn_cast<LanaiMCExpr>(BinaryExpr->getLHS());
     return (LHSSymbolRefExpr &&
             LHSSymbolRefExpr->getKind() == LanaiMCExpr::VK_Lanai_None);
   }
   return false;
 }
 
 // Matches memory operand. Returns true if error encountered.
-OperandMatchResultTy
-LanaiAsmParser::parseMemoryOperand(OperandVector &Operands) {
+ParseStatus LanaiAsmParser::parseMemoryOperand(OperandVector &Operands) {
   // Try to match a memory operand.
   // The memory operands are of the form:
   //  (1)  Register|Immediate|'' '[' '*'? Register '*'? ']' or
   //                            ^
   //  (2)  '[' '*'? Register '*'? AluOperator Register ']'
   //      ^
   //  (3)  '[' '--'|'++' Register '--'|'++' ']'
   //
ParseStatus LanaiAsmParser::parseMemoryOperand(OperandVector &Operands) {
   // Try to parse the offset
   std::unique_ptr<LanaiOperand> Op = parseRegister();
   if (!Op)
     Op = parseImmediate();
 
   // Only continue if next token is '['
   if (Lexer.isNot(AsmToken::LBrac)) {
     if (!Op)
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
 
     // The start of this custom parsing overlaps with register/immediate so
     // consider this as a successful match of an operand of that type as the
     // token stream can't be rewound to allow them to match separately.
     Operands.push_back(std::move(Op));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   Parser.Lex(); // Eat the '['.
   std::unique_ptr<LanaiOperand> Offset = nullptr;
   if (Op)
     Offset.swap(Op);
 
   // Determine if a pre operation
   PreOp = parsePrePost(Type, &OffsetValue);
 
   Op = parseRegister();
   if (!Op) {
     if (!Offset) {
       if ((Op = parseImmediate()) && Lexer.is(AsmToken::RBrac)) {
         Parser.Lex(); // Eat the ']'
 
         // Memory address operations aligned to word boundary are encoded as
         // SLS, the rest as RM.
         if (shouldBeSls(*Op)) {
           Operands.push_back(LanaiOperand::MorphToMemImm(std::move(Op)));
         } else {
-          if (!Op->isLoImm16Signed()) {
-            Error(Parser.getTok().getLoc(),
-                  "Memory address is not word "
-                  "aligned and larger than class RM can handle");
-            return MatchOperand_ParseFail;
-          }
+          if (!Op->isLoImm16Signed())
+            return Error(Parser.getTok().getLoc(),
+                         "Memory address is not word aligned and larger than "
+                         "class RM can handle");
           Operands.push_back(LanaiOperand::MorphToMemRegImm(
               Lanai::R0, std::move(Op), LPAC::ADD));
         }
-        return MatchOperand_Success;
+        return ParseStatus::Success;
       }
     }
 
-    Error(Parser.getTok().getLoc(),
+    return Error(Parser.getTok().getLoc(),
                  "Unknown operand, expected register or immediate");
-    return MatchOperand_ParseFail;
   }
   BaseReg = Op->getReg();
 
   // Determine if a post operation
   if (!PreOp)
     PostOp = parsePrePost(Type, &OffsetValue);
 
   // If ] match form (1) else match form (2)
   if (Lexer.is(AsmToken::RBrac)) {
     Parser.Lex(); // Eat the ']'.
     if (!Offset) {
       SMLoc Start = Parser.getTok().getLoc();
       SMLoc End =
           SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
       const MCConstantExpr *OffsetConstExpr =
           MCConstantExpr::create(OffsetValue, getContext());
       Offset = LanaiOperand::createImm(OffsetConstExpr, Start, End);
     }
   } else {
-    if (Offset || OffsetValue != 0) {
-      Error(Parser.getTok().getLoc(), "Expected ']'");
-      return MatchOperand_ParseFail;
-    }
+    if (Offset || OffsetValue != 0)
+      return Error(Parser.getTok().getLoc(), "Expected ']'");
 
     // Parse operator
     AluOp = parseAluOperator(PreOp, PostOp);
 
     // Second form requires offset register
     Offset = parseRegister();
-    if (!BaseReg || Lexer.isNot(AsmToken::RBrac)) {
-      Error(Parser.getTok().getLoc(), "Expected ']'");
-      return MatchOperand_ParseFail;
-    }
+    if (!BaseReg || Lexer.isNot(AsmToken::RBrac))
+      return Error(Parser.getTok().getLoc(), "Expected ']'");
     Parser.Lex(); // Eat the ']'.
   }
 
   // First form has addition as operator. Add pre- or post-op indicator as
   // needed.
   AluOp = AluWithPrePost(AluOp, PreOp, PostOp);
 
   // Ensure immediate offset is not too large
-  if (Offset->isImm() && !Offset->isLoImm16Signed()) {
-    Error(Parser.getTok().getLoc(),
-          "Memory address is not word "
-          "aligned and larger than class RM can handle");
-    return MatchOperand_ParseFail;
-  }
+  if (Offset->isImm() && !Offset->isLoImm16Signed())
+    return Error(Parser.getTok().getLoc(),
+                 "Memory address is not word aligned and larger than class RM "
+                 "can handle");
 
   Operands.push_back(
       Offset->isImm()
           ? LanaiOperand::MorphToMemRegImm(BaseReg, std::move(Offset), AluOp)
           : LanaiOperand::MorphToMemRegReg(BaseReg, std::move(Offset), AluOp));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 // Looks at a token type and creates the relevant operand from this
 // information, adding to operands.
 // If operand was parsed, returns false, else true.
-OperandMatchResultTy
-LanaiAsmParser::parseOperand(OperandVector *Operands, StringRef Mnemonic) {
+ParseStatus LanaiAsmParser::parseOperand(OperandVector *Operands,
+                                         StringRef Mnemonic) {
   // Check if the current operand has a custom associated parser, if so, try to
   // custom parse the operand, or fallback to the general approach.
-  OperandMatchResultTy Result = MatchOperandParserImpl(*Operands, Mnemonic);
+  ParseStatus Result = MatchOperandParserImpl(*Operands, Mnemonic);
 
-  if (Result == MatchOperand_Success)
+  if (Result.isSuccess())
     return Result;
-  if (Result == MatchOperand_ParseFail) {
+  if (Result.isFailure()) {
     Parser.eatToEndOfStatement();
     return Result;
   }
 
   // Attempt to parse token as register
   std::unique_ptr<LanaiOperand> Op = parseRegister();
 
   // Attempt to parse token as immediate
   if (!Op)
     Op = parseImmediate();
 
   // If the token could not be parsed then fail
   if (!Op) {
     Error(Parser.getTok().getLoc(), "Unknown operand");
     Parser.eatToEndOfStatement();
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
   }
 
   // Push back parsed operand into list of operands
   Operands->push_back(std::move(Op));
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 // Split the mnemonic into ASM operand, conditional code and instruction
 // qualifier (half-word, byte).
 StringRef LanaiAsmParser::splitMnemonic(StringRef Name, SMLoc NameLoc,
                                         OperandVector *Operands) {
   size_t Next = Name.find('.');
 
bool LanaiAsmParser::ParseInstruction(ParseInstructionInfo & /*Info*/,
   // First operand is token for instruction
   StringRef Mnemonic = splitMnemonic(Name, NameLoc, &Operands);
 
   // If there are no more operands, then finish
   if (Lexer.is(AsmToken::EndOfStatement))
     return false;
 
   // Parse first operand
-  if (parseOperand(&Operands, Mnemonic) != MatchOperand_Success)
+  if (!parseOperand(&Operands, Mnemonic).isSuccess())
     return true;
 
   // If it is a st instruction with one 1 operand then it is a "store true".
   // Transform <"st"> to <"s">, <LPCC:ICC_T>
   if (Lexer.is(AsmToken::EndOfStatement) && Name == "st" &&
       Operands.size() == 2) {
     Operands.erase(Operands.begin(), Operands.begin() + 1);
     Operands.insert(Operands.begin(), LanaiOperand::CreateToken("s", NameLoc));
bool LanaiAsmParser::ParseInstruction(ParseInstructionInfo & /*Info*/,
   }
 
   // Parse until end of statement, consuming commas between operands
   while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.is(AsmToken::Comma)) {
     // Consume comma token
     Lex();
 
     // Parse next operand
-    if (parseOperand(&Operands, Mnemonic) != MatchOperand_Success)
+    if (!parseOperand(&Operands, Mnemonic).isSuccess())
       return true;
   }
 
   if (IsMemoryAssignmentError(Operands)) {
     Error(Parser.getTok().getLoc(),
           "the destination register can't equal the base register in an "
           "instruction that modifies the base register.");
     return true;

llvm/lib/Target/Xtensa/AsmParser/XtensaAsmParser.cpp

 #define DEBUG_TYPE "xtensa-asm-parser"
 
 struct XtensaOperand;
 
 class XtensaAsmParser : public MCTargetAsmParser {
 
   SMLoc getLoc() const { return getParser().getTok().getLoc(); }
 
-  bool parseRegister(MCRegister &RegNo,
-                     SMLoc &StartLoc, SMLoc &EndLoc) override;
+  bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+                     SMLoc &EndLoc) override;
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
                                       unsigned Kind) override;
 
 // Auto-generated instruction matching functions
 #define GET_ASSEMBLER_HEADER
 #include "XtensaGenAsmMatcher.inc"
 
-  OperandMatchResultTy parseImmediate(OperandVector &Operands);
-  OperandMatchResultTy parseRegister(OperandVector &Operands,
-                                     bool AllowParens = false, bool SR = false);
-  OperandMatchResultTy parseOperandWithModifier(OperandVector &Operands);
+  ParseStatus parseImmediate(OperandVector &Operands);
+  ParseStatus parseRegister(OperandVector &Operands, bool AllowParens = false,
+                            bool SR = false);
+  ParseStatus parseOperandWithModifier(OperandVector &Operands);
   bool parseOperand(OperandVector &Operands, StringRef Mnemonic,
                     bool SR = false);
   bool ParseInstructionWithSR(ParseInstructionInfo &Info, StringRef Name,
                               SMLoc NameLoc, OperandVector &Operands);
   OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override {
     return MatchOperand_NoMatch;
   }
-  OperandMatchResultTy parsePCRelTarget(OperandVector &Operands);
+  ParseStatus parsePCRelTarget(OperandVector &Operands);
 
 public:
   enum XtensaMatchResultTy {
     Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "XtensaGenAsmMatcher.inc"
 #undef GET_OPERAND_DIAGNOSTIC_TYPES
   };
case Match_InvalidOffset4m32:
     return Error(RefineErrorLoc(IDLoc, Operands, ErrorInfo),
                  "expected immediate in range [0, 60], first 2 bits "
                  "should be zero");
   }
 
   report_fatal_error("Unknown match type detected!");
 }
 
-OperandMatchResultTy
-XtensaAsmParser::parsePCRelTarget(OperandVector &Operands) {
+ParseStatus XtensaAsmParser::parsePCRelTarget(OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
   LLVM_DEBUG(dbgs() << "parsePCRelTarget\n");
 
   SMLoc S = getLexer().getLoc();
 
   // Expressions are acceptable
   const MCExpr *Expr = nullptr;
   if (Parser.parseExpression(Expr)) {
     // We have no way of knowing if a symbol was consumed so we must ParseFail
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
   }
 
   // Currently not support constants
-  if (Expr->getKind() == MCExpr::ExprKind::Constant) {
-    Error(getLoc(), "unknown operand");
-    return MatchOperand_ParseFail;
-  }
+  if (Expr->getKind() == MCExpr::ExprKind::Constant)
+    return Error(getLoc(), "unknown operand");
 
   Operands.push_back(XtensaOperand::createImm(Expr, S, getLexer().getLoc()));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 bool XtensaAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                     SMLoc &EndLoc) {
   const AsmToken &Tok = getParser().getTok();
   StartLoc = Tok.getLoc();
   EndLoc = Tok.getEndLoc();
   RegNo = 0;
   StringRef Name = getLexer().getTok().getIdentifier();
 
   if (!MatchRegisterName(Name) && !MatchRegisterAltName(Name)) {
     getParser().Lex(); // Eat identifier token.
     return false;
   }
 
   return Error(StartLoc, "invalid register name");
 }
 
-OperandMatchResultTy XtensaAsmParser::parseRegister(OperandVector &Operands,
-                                                    bool AllowParens, bool SR) {
+ParseStatus XtensaAsmParser::parseRegister(OperandVector &Operands,
   SMLoc FirstS = getLoc();
   bool HadParens = false;
   AsmToken Buf[2];
   StringRef RegName;
 
   // If this a parenthesised register name is allowed, parse it atomically
   if (AllowParens && getLexer().is(AsmToken::LParen)) {
     size_t ReadCount = getLexer().peekTokens(Buf);
     if (ReadCount == 2 && Buf[1].getKind() == AsmToken::RParen) {
       if ((Buf[0].getKind() == AsmToken::Integer) && (!SR))
-        return MatchOperand_NoMatch;
+        return ParseStatus::NoMatch;
       HadParens = true;
       getParser().Lex(); // Eat '('
     }
   }
 
   unsigned RegNo = 0;
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   case AsmToken::Integer:
     if (!SR)
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
     RegName = StringRef(std::to_string(getLexer().getTok().getIntVal()));
     RegNo = MatchRegisterName(RegName);
     if (RegNo == 0)
       RegNo = MatchRegisterAltName(RegName);
     break;
   case AsmToken::Identifier:
     RegName = getLexer().getTok().getIdentifier();
     RegNo = MatchRegisterName(RegName);
     if (RegNo == 0)
       RegNo = MatchRegisterAltName(RegName);
     break;
   }
 
   if (RegNo == 0) {
     if (HadParens)
       getLexer().UnLex(Buf[0]);
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
   if (HadParens)
     Operands.push_back(XtensaOperand::createToken("(", FirstS));
   SMLoc S = getLoc();
   SMLoc E = getParser().getTok().getEndLoc();
   getLexer().Lex();
   Operands.push_back(XtensaOperand::createReg(RegNo, S, E));
 
   if (HadParens) {
     getParser().Lex(); // Eat ')'
     Operands.push_back(XtensaOperand::createToken(")", getLoc()));
   }
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy XtensaAsmParser::parseImmediate(OperandVector &Operands) {
+ParseStatus XtensaAsmParser::parseImmediate(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E;
   const MCExpr *Res;
 
   switch (getLexer().getKind()) {
   default:
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   case AsmToken::LParen:
   case AsmToken::Minus:
   case AsmToken::Plus:
   case AsmToken::Tilde:
   case AsmToken::Integer:
   case AsmToken::String:
     if (getParser().parseExpression(Res))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
     break;
   case AsmToken::Identifier: {
     StringRef Identifier;
     if (getParser().parseIdentifier(Identifier))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     MCSymbol *Sym = getContext().getOrCreateSymbol(Identifier);
     Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
     break;
   }
   case AsmToken::Percent:
     return parseOperandWithModifier(Operands);
   }
 
   E = SMLoc::getFromPointer(S.getPointer() - 1);
   Operands.push_back(XtensaOperand::createImm(Res, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy
-XtensaAsmParser::parseOperandWithModifier(OperandVector &Operands) {
-  return MatchOperand_ParseFail;
+ParseStatus XtensaAsmParser::parseOperandWithModifier(OperandVector &Operands) {
+  return ParseStatus::Failure;
 }
 
 /// Looks at a token type and creates the relevant operand
 /// from this information, adding to Operands.
 /// If operand was parsed, returns false, else true.
 bool XtensaAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic,
                                    bool SR) {
   // Check if the current operand has a custom associated parser, if so, try to
   // custom parse the operand, or fallback to the general approach.
-  OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
-  if (ResTy == MatchOperand_Success)
+  ParseStatus Res = MatchOperandParserImpl(Operands, Mnemonic);
+  if (Res.isSuccess())
     return false;
 
   // 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_ParseFail)
+  if (Res.isFailure())
     return true;
 
   // Attempt to parse token as register
-  if (parseRegister(Operands, true, SR) == MatchOperand_Success)
+  if (parseRegister(Operands, true, SR).isSuccess())
     return false;
 
   // Attempt to parse token as an immediate
-  if (parseImmediate(Operands) == MatchOperand_Success) {
+  if (parseImmediate(Operands).isSuccess())
     return false;
-  }
 
   // Finally we have exhausted all options and must declare defeat.
-  Error(getLoc(), "unknown operand");
-  return true;
+  return Error(getLoc(), "unknown operand");
 }
 
 bool XtensaAsmParser::ParseInstructionWithSR(ParseInstructionInfo &Info,
                                              StringRef Name, SMLoc NameLoc,
                                              OperandVector &Operands) {
   if ((Name.startswith("wsr.") || Name.startswith("rsr.") ||
        Name.startswith("xsr.")) &&
       (Name.size() > 4)) {
     // Parse case when instruction name is concatenated with SR register
     // name, like "wsr.sar a1"
 
     // First operand is token for instruction
     Operands.push_back(XtensaOperand::createToken(Name.take_front(3), NameLoc));
 
     StringRef RegName = Name.drop_front(4);
     unsigned RegNo = MatchRegisterName(RegName);
 
     if (RegNo == 0)
       RegNo = MatchRegisterAltName(RegName);
 
-    if (RegNo == 0) {
-      Error(NameLoc, "invalid register name");
-      return true;
-    }
+    if (RegNo == 0)
+      return Error(NameLoc, "invalid register name");
 
     // Parse operand
     if (parseOperand(Operands, Name))
       return true;
 
     SMLoc S = getLoc();
     SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
     Operands.push_back(XtensaOperand::createReg(RegNo, S, E));