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

llvm/lib/Target/CSKY/AsmParser/CSKYAsmParser.cpp

CSKYTargetStreamer &getTargetStreamer() {
     MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
     return static_cast<CSKYTargetStreamer &>(TS);
   }
 
 // Auto-generated instruction matching functions
 #define GET_ASSEMBLER_HEADER
 #include "CSKYGenAsmMatcher.inc"
 
-  OperandMatchResultTy parseImmediate(OperandVector &Operands);
-  OperandMatchResultTy parseRegister(OperandVector &Operands);
-  OperandMatchResultTy parseBaseRegImm(OperandVector &Operands);
-  OperandMatchResultTy parseCSKYSymbol(OperandVector &Operands);
-  OperandMatchResultTy parseConstpoolSymbol(OperandVector &Operands);
-  OperandMatchResultTy parseDataSymbol(OperandVector &Operands);
-  OperandMatchResultTy parsePSRFlag(OperandVector &Operands);
-  OperandMatchResultTy parseRegSeq(OperandVector &Operands);
-  OperandMatchResultTy parseRegList(OperandVector &Operands);
+  ParseStatus parseImmediate(OperandVector &Operands);
+  ParseStatus parseRegister(OperandVector &Operands);
+  ParseStatus parseBaseRegImm(OperandVector &Operands);
+  ParseStatus parseCSKYSymbol(OperandVector &Operands);
+  ParseStatus parseConstpoolSymbol(OperandVector &Operands);
+  ParseStatus parseDataSymbol(OperandVector &Operands);
+  ParseStatus parsePSRFlag(OperandVector &Operands);
+  ParseStatus parseRegSeq(OperandVector &Operands);
+  ParseStatus parseRegList(OperandVector &Operands);
 
   bool parseOperand(OperandVector &Operands, StringRef Mnemonic);
 
   bool parseDirectiveAttribute();
 
 public:
   enum CSKYMatchResultTy {
     Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
bool CSKYAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
   EndLoc = Tok.getEndLoc();
   StringRef Name = getLexer().getTok().getIdentifier();
 
   if (!matchRegisterNameHelper(getSTI(), (MCRegister &)RegNo, Name)) {
     getParser().Lex(); // Eat identifier token.
     return false;
   }
 
-  return MatchOperand_NoMatch;
+  return true;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseRegister(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::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();
     MCRegister RegNo;
 
     if (matchRegisterNameHelper(getSTI(), (MCRegister &)RegNo, Name))
-      return MatchOperand_NoMatch;
+      return ParseStatus::NoMatch;
 
     getLexer().Lex();
     Operands.push_back(CSKYOperand::createReg(RegNo, S, E));
 
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
   }
 }
 
-OperandMatchResultTy CSKYAsmParser::parseBaseRegImm(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseBaseRegImm(OperandVector &Operands) {
   assert(getLexer().is(AsmToken::LParen));
 
   Operands.push_back(CSKYOperand::createToken("(", getLoc()));
 
   auto Tok = getParser().Lex(); // Eat '('
 
-  if (parseRegister(Operands) != MatchOperand_Success) {
+  if (!parseRegister(Operands).isSuccess()) {
     getLexer().UnLex(Tok);
     Operands.pop_back();
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   }
 
   if (getLexer().is(AsmToken::RParen)) {
     Operands.push_back(CSKYOperand::createToken(")", getLoc()));
     getParser().Lex(); // Eat ')'
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
-  if (getLexer().isNot(AsmToken::Comma)) {
-    Error(getLoc(), "expected ','");
-    return MatchOperand_ParseFail;
-  }
+  if (getLexer().isNot(AsmToken::Comma))
+    return Error(getLoc(), "expected ','");
 
   getParser().Lex(); // Eat ','
 
-  if (parseRegister(Operands) == MatchOperand_Success) {
-    if (getLexer().isNot(AsmToken::LessLess)) {
-      Error(getLoc(), "expected '<<'");
-      return MatchOperand_ParseFail;
-    }
+  if (parseRegister(Operands).isSuccess()) {
+    if (getLexer().isNot(AsmToken::LessLess))
+      return Error(getLoc(), "expected '<<'");
 
     Operands.push_back(CSKYOperand::createToken("<<", getLoc()));
 
     getParser().Lex(); // Eat '<<'
 
-    if (parseImmediate(Operands) != MatchOperand_Success) {
-      Error(getLoc(), "expected imm");
-      return MatchOperand_ParseFail;
-    }
+    if (!parseImmediate(Operands).isSuccess())
+      return Error(getLoc(), "expected imm");
 
-  } else if (parseImmediate(Operands) != MatchOperand_Success) {
-    Error(getLoc(), "expected imm");
-    return MatchOperand_ParseFail;
+  } else if (!parseImmediate(Operands).isSuccess()) {
+    return Error(getLoc(), "expected imm");
   }
 
-  if (getLexer().isNot(AsmToken::RParen)) {
-    Error(getLoc(), "expected ')'");
-    return MatchOperand_ParseFail;
-  }
+  if (getLexer().isNot(AsmToken::RParen))
+    return Error(getLoc(), "expected ')'");
 
   Operands.push_back(CSKYOperand::createToken(")", getLoc()));
 
   getParser().Lex(); // Eat ')'
 
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseImmediate(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::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:
     break;
   }
 
   const MCExpr *IdVal;
   SMLoc S = getLoc();
-  if (getParser().parseExpression(IdVal)) {
-    Error(getLoc(), "unknown expression");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseExpression(IdVal))
+    return Error(getLoc(), "unknown expression");
 
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
   Operands.push_back(CSKYOperand::createImm(IdVal, S, E));
-  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.
 bool CSKYAsmParser::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 =
+  ParseStatus Result =
       MatchOperandParserImpl(Operands, Mnemonic, /*ParseForAllFeatures=*/true);
-  if (Result == MatchOperand_Success)
+  if (Result.isSuccess())
     return false;
-  if (Result == MatchOperand_ParseFail)
+  if (Result.isFailure())
     return true;
 
   // Attempt to parse token as register
   auto Res = parseRegister(Operands);
-  if (Res == MatchOperand_Success)
+  if (Res.isSuccess())
     return false;
-  else if (Res == MatchOperand_ParseFail)
+  if (Res.isFailure())
     return true;
 
   // Attempt to parse token as (register, imm)
   if (getLexer().is(AsmToken::LParen)) {
     Res = parseBaseRegImm(Operands);
-    if (Res == MatchOperand_Success)
+    if (Res.isSuccess())
       return false;
-    else if (Res == MatchOperand_ParseFail)
+    if (Res.isFailure())
       return true;
   }
 
   Res = parseImmediate(Operands);
-  if (Res == MatchOperand_Success)
+  if (Res.isSuccess())
     return false;
-  else if (Res == MatchOperand_ParseFail)
+  if (Res.isFailure())
     return true;
 
   // Finally we have exhausted all options and must declare defeat.
   Error(getLoc(), "unknown operand");
   return true;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseCSKYSymbol(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseCSKYSymbol(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
   const MCExpr *Res;
 
   if (getLexer().getKind() != AsmToken::Identifier)
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   StringRef Identifier;
   AsmToken Tok = getLexer().getTok();
 
-  if (getParser().parseIdentifier(Identifier)) {
-    Error(getLoc(), "unknown identifier");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseIdentifier(Identifier))
+    return Error(getLoc(), "unknown identifier");
 
   CSKYMCExpr::VariantKind Kind = CSKYMCExpr::VK_CSKY_None;
   if (Identifier.consume_back("@GOT"))
     Kind = CSKYMCExpr::VK_CSKY_GOT;
   else if (Identifier.consume_back("@GOTOFF"))
     Kind = CSKYMCExpr::VK_CSKY_GOTOFF;
   else if (Identifier.consume_back("@PLT"))
     Kind = CSKYMCExpr::VK_CSKY_PLT;
ParseStatus CSKYAsmParser::parseCSKYSymbol(OperandVector &Operands) {
 
   if (!Sym)
     Sym = getContext().getOrCreateSymbol(Identifier);
 
   if (Sym->isVariable()) {
     const MCExpr *V = Sym->getVariableValue(/*SetUsed=*/false);
     if (!isa<MCSymbolRefExpr>(V)) {
       getLexer().UnLex(Tok); // Put back if it's not a bare symbol.
-      Error(getLoc(), "unknown symbol");
-      return MatchOperand_ParseFail;
+      return Error(getLoc(), "unknown symbol");
     }
     Res = V;
   } else
     Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
 
   MCBinaryExpr::Opcode Opcode;
   switch (getLexer().getKind()) {
   default:
     if (Kind != CSKYMCExpr::VK_CSKY_None)
       Res = CSKYMCExpr::create(Res, Kind, getContext());
 
     Operands.push_back(CSKYOperand::createImm(Res, S, E));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   case AsmToken::Plus:
     Opcode = MCBinaryExpr::Add;
     break;
   case AsmToken::Minus:
     Opcode = MCBinaryExpr::Sub;
     break;
   }
 
   getLexer().Lex(); // eat + or -
 
   const MCExpr *Expr;
-  if (getParser().parseExpression(Expr)) {
-    Error(getLoc(), "unknown expression");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseExpression(Expr))
+    return Error(getLoc(), "unknown expression");
   Res = MCBinaryExpr::create(Opcode, Res, Expr, getContext());
   Operands.push_back(CSKYOperand::createImm(Res, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseDataSymbol(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseDataSymbol(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
   const MCExpr *Res;
 
   if (!parseOptionalToken(AsmToken::LBrac))
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
   if (getLexer().getKind() != AsmToken::Identifier) {
     const MCExpr *Expr;
-    if (getParser().parseExpression(Expr)) {
-      Error(getLoc(), "unknown expression");
-      return MatchOperand_ParseFail;
-    }
+    if (getParser().parseExpression(Expr))
+      return Error(getLoc(), "unknown expression");
 
     if (parseToken(AsmToken::RBrac, "expected ']'"))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     Operands.push_back(CSKYOperand::createConstpoolOp(Expr, S, E));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   AsmToken Tok = getLexer().getTok();
   StringRef Identifier;
 
-  if (getParser().parseIdentifier(Identifier)) {
-    Error(getLoc(), "unknown identifier " + Identifier);
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseIdentifier(Identifier))
+    return Error(getLoc(), "unknown identifier " + Identifier);
 
   CSKYMCExpr::VariantKind Kind = CSKYMCExpr::VK_CSKY_None;
   if (Identifier.consume_back("@GOT"))
     Kind = CSKYMCExpr::VK_CSKY_GOT_IMM18_BY4;
   else if (Identifier.consume_back("@PLT"))
     Kind = CSKYMCExpr::VK_CSKY_PLT_IMM18_BY4;
 
   MCSymbol *Sym = getContext().getInlineAsmLabel(Identifier);
 
   if (!Sym)
     Sym = getContext().getOrCreateSymbol(Identifier);
 
   if (Sym->isVariable()) {
     const MCExpr *V = Sym->getVariableValue(/*SetUsed=*/false);
     if (!isa<MCSymbolRefExpr>(V)) {
       getLexer().UnLex(Tok); // Put back if it's not a bare symbol.
-      Error(getLoc(), "unknown symbol");
-      return MatchOperand_ParseFail;
+      return Error(getLoc(), "unknown symbol");
     }
     Res = V;
   } else {
     Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
   }
 
   MCBinaryExpr::Opcode Opcode;
   switch (getLexer().getKind()) {
   default:
-    Error(getLoc(), "unknown symbol");
-    return MatchOperand_ParseFail;
+    return Error(getLoc(), "unknown symbol");
   case AsmToken::RBrac:
 
     getLexer().Lex(); // Eat ']'.
 
     if (Kind != CSKYMCExpr::VK_CSKY_None)
       Res = CSKYMCExpr::create(Res, Kind, getContext());
 
     Operands.push_back(CSKYOperand::createConstpoolOp(Res, S, E));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   case AsmToken::Plus:
     Opcode = MCBinaryExpr::Add;
     break;
   case AsmToken::Minus:
     Opcode = MCBinaryExpr::Sub;
     break;
   }
 
   getLexer().Lex(); // eat + or -
 
   const MCExpr *Expr;
-  if (getParser().parseExpression(Expr)) {
-    Error(getLoc(), "unknown expression");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseExpression(Expr))
+    return Error(getLoc(), "unknown expression");
   if (parseToken(AsmToken::RBrac, "expected ']'"))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   Res = MCBinaryExpr::create(Opcode, Res, Expr, getContext());
   Operands.push_back(CSKYOperand::createConstpoolOp(Res, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy
-CSKYAsmParser::parseConstpoolSymbol(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseConstpoolSymbol(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
   const MCExpr *Res;
 
   if (!parseOptionalToken(AsmToken::LBrac))
-    return MatchOperand_NoMatch;
+    return ParseStatus::NoMatch;
 
   if (getLexer().getKind() != AsmToken::Identifier) {
     const MCExpr *Expr;
-    if (getParser().parseExpression(Expr)) {
-      Error(getLoc(), "unknown expression");
-      return MatchOperand_ParseFail;
-    }
+    if (getParser().parseExpression(Expr))
+      return Error(getLoc(), "unknown expression");
     if (parseToken(AsmToken::RBrac))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
 
     Operands.push_back(CSKYOperand::createConstpoolOp(Expr, S, E));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   }
 
   AsmToken Tok = getLexer().getTok();
   StringRef Identifier;
 
-  if (getParser().parseIdentifier(Identifier)) {
-    Error(getLoc(), "unknown identifier");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseIdentifier(Identifier))
+    return Error(getLoc(), "unknown identifier");
 
   MCSymbol *Sym = getContext().getInlineAsmLabel(Identifier);
 
   if (!Sym)
     Sym = getContext().getOrCreateSymbol(Identifier);
 
   if (Sym->isVariable()) {
     const MCExpr *V = Sym->getVariableValue(/*SetUsed=*/false);
     if (!isa<MCSymbolRefExpr>(V)) {
       getLexer().UnLex(Tok); // Put back if it's not a bare symbol.
-      Error(getLoc(), "unknown symbol");
-      return MatchOperand_ParseFail;
+      return Error(getLoc(), "unknown symbol");
     }
     Res = V;
   } else {
     Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
   }
 
   MCBinaryExpr::Opcode Opcode;
   switch (getLexer().getKind()) {
   default:
-    Error(getLoc(), "unknown symbol");
-    return MatchOperand_ParseFail;
+    return Error(getLoc(), "unknown symbol");
   case AsmToken::RBrac:
 
     getLexer().Lex(); // Eat ']'.
 
     Operands.push_back(CSKYOperand::createConstpoolOp(Res, S, E));
-    return MatchOperand_Success;
+    return ParseStatus::Success;
   case AsmToken::Plus:
     Opcode = MCBinaryExpr::Add;
     break;
   case AsmToken::Minus:
     Opcode = MCBinaryExpr::Sub;
     break;
   }
 
   getLexer().Lex(); // eat + or -
 
   const MCExpr *Expr;
-  if (getParser().parseExpression(Expr)) {
-    Error(getLoc(), "unknown expression");
-    return MatchOperand_ParseFail;
-  }
+  if (getParser().parseExpression(Expr))
+    return Error(getLoc(), "unknown expression");
   if (parseToken(AsmToken::RBrac, "expected ']'"))
-    return MatchOperand_ParseFail;
+    return ParseStatus::Failure;
 
   Res = MCBinaryExpr::create(Opcode, Res, Expr, getContext());
   Operands.push_back(CSKYOperand::createConstpoolOp(Res, S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy CSKYAsmParser::parsePSRFlag(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parsePSRFlag(OperandVector &Operands) {
   SMLoc S = getLoc();
   SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
 
   unsigned Flag = 0;
 
   while (getLexer().isNot(AsmToken::EndOfStatement)) {
     StringRef Identifier;
-    if (getParser().parseIdentifier(Identifier)) {
-      Error(getLoc(), "unknown identifier " + Identifier);
-      return MatchOperand_ParseFail;
-    }
+    if (getParser().parseIdentifier(Identifier))
+      return Error(getLoc(), "unknown identifier " + Identifier);
 
     if (Identifier == "sie")
       Flag = (1 << 4) | Flag;
     else if (Identifier == "ee")
       Flag = (1 << 3) | Flag;
     else if (Identifier == "ie")
       Flag = (1 << 2) | Flag;
     else if (Identifier == "fe")
       Flag = (1 << 1) | Flag;
     else if (Identifier == "af")
       Flag = (1 << 0) | Flag;
-    else {
-      Error(getLoc(), "expected " + Identifier);
-      return MatchOperand_ParseFail;
-    }
+    else
+      return Error(getLoc(), "expected " + Identifier);
 
     if (getLexer().is(AsmToken::EndOfStatement))
       break;
 
     if (parseToken(AsmToken::Comma, "expected ','"))
-      return MatchOperand_ParseFail;
+      return ParseStatus::Failure;
   }
 
   Operands.push_back(
       CSKYOperand::createImm(MCConstantExpr::create(Flag, getContext()), S, E));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseRegSeq(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseRegSeq(OperandVector &Operands) {
   SMLoc S = getLoc();
 
-  if (parseRegister(Operands) != MatchOperand_Success)
-    return MatchOperand_NoMatch;
+  if (!parseRegister(Operands).isSuccess())
+    return ParseStatus::NoMatch;
 
   auto Ry = Operands.back()->getReg();
   Operands.pop_back();
 
   if (parseToken(AsmToken::Minus, "expected '-'"))
-    return MatchOperand_ParseFail;
-  if (parseRegister(Operands) != MatchOperand_Success) {
-    Error(getLoc(), "invalid register");
-    return MatchOperand_ParseFail;
-  }
+    return ParseStatus::Failure;
+  if (!parseRegister(Operands).isSuccess())
+    return Error(getLoc(), "invalid register");
 
   auto Rz = Operands.back()->getReg();
   Operands.pop_back();
 
   Operands.push_back(CSKYOperand::createRegSeq(Ry, Rz, S));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
-OperandMatchResultTy CSKYAsmParser::parseRegList(OperandVector &Operands) {
+ParseStatus CSKYAsmParser::parseRegList(OperandVector &Operands) {
   SMLoc S = getLoc();
 
   SmallVector<unsigned, 4> reglist;
 
   while (true) {
 
-    if (parseRegister(Operands) != MatchOperand_Success) {
-      Error(getLoc(), "invalid register");
-      return MatchOperand_ParseFail;
-    }
+    if (!parseRegister(Operands).isSuccess())
+      return Error(getLoc(), "invalid register");
 
     auto Ry = Operands.back()->getReg();
     Operands.pop_back();
 
     if (parseOptionalToken(AsmToken::Minus)) {
-      if (parseRegister(Operands) != MatchOperand_Success) {
-        Error(getLoc(), "invalid register");
-        return MatchOperand_ParseFail;
-      }
+      if (!parseRegister(Operands).isSuccess())
+        return Error(getLoc(), "invalid register");
 
       auto Rz = Operands.back()->getReg();
       Operands.pop_back();
 
       reglist.push_back(Ry);
       reglist.push_back(Rz);
 
       if (getLexer().is(AsmToken::EndOfStatement))
         break;
       (void)parseOptionalToken(AsmToken::Comma);
     } else if (parseOptionalToken(AsmToken::Comma)) {
       reglist.push_back(Ry);
       reglist.push_back(Ry);
     } else if (getLexer().is(AsmToken::EndOfStatement)) {
       reglist.push_back(Ry);
       reglist.push_back(Ry);
       break;
     } else {
-      Error(getLoc(), "invalid register list");
-      return MatchOperand_ParseFail;
+      return Error(getLoc(), "invalid register list");
     }
   }
 
   Operands.push_back(CSKYOperand::createRegList(reglist, S));
-  return MatchOperand_Success;
+  return ParseStatus::Success;
 }
 
 bool CSKYAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                      SMLoc NameLoc, OperandVector &Operands) {
   // First operand is token for instruction.
   Operands.push_back(CSKYOperand::createToken(Name, NameLoc));
 
   // If there are no more operands, then finish.