class MCContext;
class MCInst;
class MCInstrInfo;
+class MCRegister;
class MCStreamer;
class MCSubtargetInfo;
class MCSymbol;
return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
}
- virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ virtual bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) = 0;
/// tryParseRegister - parse one register if possible
/// location, without failing the entire parse if it can't. Must not consume
/// tokens if the parse fails.
virtual OperandMatchResultTy
- tryParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) = 0;
+ tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) = 0;
/// ParseInstruction - Parse one assembly instruction.
///
/// parse register name or number.
bool AsmParser::parseRegisterOrRegisterNumber(int64_t &Register,
SMLoc DirectiveLoc) {
- unsigned RegNo;
+ MCRegister RegNo;
if (getLexer().isNot(AsmToken::Integer)) {
- if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
+ if (getTargetParser().parseRegister(RegNo, DirectiveLoc, DirectiveLoc))
return true;
Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
} else
/// parse register name or number.
bool MasmParser::parseRegisterOrRegisterNumber(int64_t &Register,
SMLoc DirectiveLoc) {
- unsigned RegNo;
+ MCRegister RegNo;
if (getLexer().isNot(AsmToken::Integer)) {
- if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
+ if (getTargetParser().parseRegister(RegNo, DirectiveLoc, DirectiveLoc))
return true;
Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
} else
eatToEndOfStatement();
} else {
bool is_defined = false;
- unsigned RegNo;
+ MCRegister Reg;
SMLoc StartLoc, EndLoc;
- is_defined = (getTargetParser().tryParseRegister(
- RegNo, StartLoc, EndLoc) == MatchOperand_Success);
+ is_defined = (getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc) ==
+ MatchOperand_Success);
if (!is_defined) {
StringRef Name;
if (check(parseIdentifier(Name), "expected identifier after 'ifdef'") ||
eatToEndOfStatement();
} else {
bool is_defined = false;
- unsigned RegNo;
+ MCRegister Reg;
SMLoc StartLoc, EndLoc;
- is_defined = (getTargetParser().tryParseRegister(RegNo, StartLoc, EndLoc) ==
+ is_defined = (getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc) ==
MatchOperand_Success);
if (!is_defined) {
StringRef Name;
}
bool IsDefined = false;
- unsigned RegNo;
+ MCRegister Reg;
SMLoc StartLoc, EndLoc;
- IsDefined = (getTargetParser().tryParseRegister(RegNo, StartLoc, EndLoc) ==
+ IsDefined = (getTargetParser().tryParseRegister(Reg, StartLoc, EndLoc) ==
MatchOperand_Success);
if (!IsDefined) {
StringRef Name;
/// }
- OperandMatchResultTy tryParseScalarRegister(unsigned &Reg);
- OperandMatchResultTy tryParseVectorRegister(unsigned &Reg, StringRef &Kind,
+ OperandMatchResultTy tryParseScalarRegister(MCRegister &Reg);
+ OperandMatchResultTy tryParseVectorRegister(MCRegister &Reg, StringRef &Kind,
RegKind MatchKind);
OperandMatchResultTy tryParseMatrixRegister(OperandVector &Operands);
OperandMatchResultTy tryParseSVCR(OperandVector &Operands);
const MCParsedAsmOperand &Op2) const override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseDirective(AsmToken DirectiveID) override;
unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
.Default(0);
}
-bool AArch64AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool AArch64AsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success;
}
-OperandMatchResultTy AArch64AsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy AArch64AsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
StartLoc = getLoc();
/// Identifier when called, and if it is a register name the token is eaten and
/// the register is added to the operand list.
OperandMatchResultTy
-AArch64AsmParser::tryParseScalarRegister(unsigned &RegNum) {
+AArch64AsmParser::tryParseScalarRegister(MCRegister &RegNum) {
const AsmToken &Tok = getTok();
if (Tok.isNot(AsmToken::Identifier))
return MatchOperand_NoMatch;
AArch64AsmParser::tryParseSyspXzrPair(OperandVector &Operands) {
SMLoc StartLoc = getLoc();
- unsigned RegNum;
+ MCRegister RegNum;
// The case where xzr, xzr is not present is handled by an InstAlias.
SMLoc S = getLoc();
// Check for a vector register specifier first.
StringRef Kind;
- unsigned Reg;
+ MCRegister Reg;
OperandMatchResultTy Res =
tryParseVectorRegister(Reg, Kind, RegKind::NeonVector);
if (Res != MatchOperand_Success)
// optional kind specifier. If it is a register specifier, eat the token
// and return it.
OperandMatchResultTy
-AArch64AsmParser::tryParseVectorRegister(unsigned &Reg, StringRef &Kind,
+AArch64AsmParser::tryParseVectorRegister(MCRegister &Reg, StringRef &Kind,
RegKind MatchKind) {
const AsmToken &Tok = getTok();
// Check for a SVE predicate register specifier first.
const SMLoc S = getLoc();
StringRef Kind;
- unsigned RegNum;
+ MCRegister RegNum;
auto Res = tryParseVectorRegister(RegNum, Kind, RK);
if (Res != MatchOperand_Success)
return Res;
return MatchOperand_NoMatch;
// Wrapper around parse function
- auto ParseVector = [this](unsigned &Reg, StringRef &Kind, SMLoc Loc,
+ auto ParseVector = [this](MCRegister &Reg, StringRef &Kind, SMLoc Loc,
bool NoMatchIsError) {
auto RegTok = getTok();
auto ParseRes = tryParseVectorRegister(Reg, Kind, VectorKind);
Lex(); // Eat left bracket token.
StringRef Kind;
- unsigned FirstReg;
+ MCRegister FirstReg;
auto ParseRes = ParseVector(FirstReg, Kind, getLoc(), ExpectMatch);
// Put back the original left bracket if there was no match, so that
SMLoc Loc = getLoc();
StringRef NextKind;
- unsigned Reg;
+ MCRegister Reg;
ParseRes = ParseVector(Reg, NextKind, getLoc(), true);
if (ParseRes != MatchOperand_Success)
return ParseRes;
while (parseOptionalToken(AsmToken::Comma)) {
SMLoc Loc = getLoc();
StringRef NextKind;
- unsigned Reg;
+ MCRegister Reg;
ParseRes = ParseVector(Reg, NextKind, getLoc(), true);
if (ParseRes != MatchOperand_Success)
return ParseRes;
AArch64AsmParser::tryParseGPR64sp0Operand(OperandVector &Operands) {
SMLoc StartLoc = getLoc();
- unsigned RegNum;
+ MCRegister RegNum;
OperandMatchResultTy Res = tryParseScalarRegister(RegNum);
if (Res != MatchOperand_Success)
return Res;
AArch64AsmParser::tryParseGPROperand(OperandVector &Operands) {
SMLoc StartLoc = getLoc();
- unsigned RegNum;
+ MCRegister RegNum;
OperandMatchResultTy Res = tryParseScalarRegister(RegNum);
if (Res != MatchOperand_Success)
return Res;
bool AArch64AsmParser::parseRegisterInRange(unsigned &Out, unsigned Base,
unsigned First, unsigned Last) {
- unsigned Reg;
+ MCRegister Reg;
SMLoc Start, End;
- if (check(ParseRegister(Reg, Start, End), getLoc(), "expected register"))
+ if (check(parseRegister(Reg, Start, End), getLoc(), "expected register"))
return true;
// Special handling for FP and LR; they aren't linearly after x28 in
Lex(); // Eat the '.req' token.
SMLoc SRegLoc = getLoc();
RegKind RegisterKind = RegKind::Scalar;
- unsigned RegNum;
+ MCRegister RegNum;
OperandMatchResultTy ParseRes = tryParseScalarRegister(RegNum);
if (ParseRes != MatchOperand_Success) {
/// ::= .seh_save_any_reg_px
bool AArch64AsmParser::parseDirectiveSEHSaveAnyReg(SMLoc L, bool Paired,
bool Writeback) {
- unsigned Reg;
+ MCRegister Reg;
SMLoc Start, End;
int64_t Offset;
- if (check(ParseRegister(Reg, Start, End), getLoc(), "expected register") ||
+ if (check(parseRegister(Reg, Start, End), getLoc(), "expected register") ||
parseComma() || parseImmExpr(Offset))
return true;
return MatchOperand_ParseFail;
}
- unsigned FirstReg;
+ MCRegister FirstReg;
OperandMatchResultTy Res = tryParseScalarRegister(FirstReg);
if (Res != MatchOperand_Success) {
Error(S, "expected first even register of a "
Lex();
SMLoc E = getLoc();
- unsigned SecondReg;
+ MCRegister SecondReg;
Res = tryParseScalarRegister(SecondReg);
if (Res != MatchOperand_Success) {
Error(E, "expected second odd register of a "
AArch64AsmParser::tryParseSVEDataVector(OperandVector &Operands) {
const SMLoc S = getLoc();
// Check for a SVE vector register specifier first.
- unsigned RegNum;
+ MCRegister RegNum;
StringRef Kind;
OperandMatchResultTy Res =
AArch64AsmParser::tryParseGPR64x8(OperandVector &Operands) {
SMLoc SS = getLoc();
- unsigned XReg;
+ MCRegister XReg;
if (tryParseScalarRegister(XReg) != MatchOperand_Success)
return MatchOperand_NoMatch;
StringRef getMatchedVariantName() const;
std::unique_ptr<AMDGPUOperand> parseRegister(bool RestoreOnFailure = false);
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
+ bool ParseRegister(MCRegister &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
bool RestoreOnFailure);
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
unsigned checkTargetMatchPredicate(MCInst &Inst) override;
unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
.Default(AMDGPU::NoRegister);
}
-bool AMDGPUAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool AMDGPUAsmParser::ParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc, bool RestoreOnFailure) {
auto R = parseRegister();
if (!R) return true;
return false;
}
-bool AMDGPUAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool AMDGPUAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return ParseRegister(RegNo, StartLoc, EndLoc, /*RestoreOnFailure=*/false);
}
-OperandMatchResultTy AMDGPUAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy AMDGPUAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
bool Result =
}
// Implementation of the MCTargetAsmParser interface:
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
/// }
-bool ARMAsmParser::ParseRegister(unsigned &RegNo,
- SMLoc &StartLoc, SMLoc &EndLoc) {
+bool ARMAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
StartLoc = Tok.getLoc();
EndLoc = Tok.getEndLoc();
return (RegNo == (unsigned)-1);
}
-OperandMatchResultTy ARMAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy ARMAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
- if (ParseRegister(RegNo, StartLoc, EndLoc))
+ if (parseRegister(RegNo, StartLoc, EndLoc))
return MatchOperand_NoMatch;
return MatchOperand_Success;
}
bool ARMAsmParser::parseDirectiveReq(StringRef Name, SMLoc L) {
MCAsmParser &Parser = getParser();
Parser.Lex(); // Eat the '.req' token.
- unsigned Reg;
+ MCRegister Reg;
SMLoc SRegLoc, ERegLoc;
- if (check(ParseRegister(Reg, SRegLoc, ERegLoc), SRegLoc,
+ if (check(parseRegister(Reg, SRegLoc, ERegLoc), SRegLoc,
"register name expected") ||
parseEOL())
return true;
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
return MatchOperand_Success;
}
-bool AVRAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool AVRAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
StartLoc = Parser.getTok().getLoc();
RegNo = parseRegister(/*RestoreOnFailure=*/false);
return (RegNo == AVR::NoRegister);
}
-OperandMatchResultTy AVRAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy AVRAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
StartLoc = Parser.getTok().getLoc();
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
llvm_unreachable("Unknown match type detected!");
}
-bool BPFAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool BPFAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success)
return Error(StartLoc, "invalid register name");
return false;
}
-OperandMatchResultTy BPFAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy BPFAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
bool ParseDirectiveFalign(unsigned Size, SMLoc L);
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseDirectiveSubsection(SMLoc L);
bool ParseDirectiveComm(bool IsLocal, SMLoc L);
}
bool HexagonAsmParser::parseOperand(OperandVector &Operands) {
- unsigned Register;
+ MCRegister Register;
SMLoc Begin;
SMLoc End;
MCAsmLexer &Lexer = getLexer();
- if (!ParseRegister(Register, Begin, End)) {
+ if (!parseRegister(Register, Begin, End)) {
if (!ErrorMissingParenthesis)
switch (Register) {
default:
return false;
}
-bool HexagonAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool HexagonAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success;
}
-OperandMatchResultTy HexagonAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy HexagonAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
MCAsmLexer &Lexer = getLexer();
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
- bool ParseRegister(unsigned &RegNum, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNum, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool MatchAndEmitInstruction(SMLoc IdLoc, unsigned &Opcode,
return nullptr;
}
-bool LanaiAsmParser::ParseRegister(unsigned &RegNum, SMLoc &StartLoc,
+bool LanaiAsmParser::parseRegister(MCRegister &RegNum, SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
StartLoc = Tok.getLoc();
return (Op == nullptr);
}
-OperandMatchResultTy LanaiAsmParser::tryParseRegister(unsigned &RegNum,
+OperandMatchResultTy LanaiAsmParser::tryParseRegister(MCRegister &RegNum,
SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
using InstSeq = SmallVector<Inst>;
/// Parse a register as used in CFI directives.
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
return RegNo == LoongArch::NoRegister;
}
-bool LoongArchAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool LoongArchAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return Error(getLoc(), "invalid register number");
}
-OperandMatchResultTy LoongArchAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy LoongArchAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
llvm_unreachable("Unimplemented function.");
const uint64_t &ErrorInfo);
bool missingFeature(const SMLoc &Loc, const uint64_t &ErrorInfo);
bool emit(MCInst &Inst, SMLoc const &Loc, MCStreamer &Out) const;
- bool parseRegisterName(unsigned int &RegNo, SMLoc Loc,
- StringRef RegisterName);
- OperandMatchResultTy parseRegister(unsigned int &RegNo);
+ bool parseRegisterName(MCRegister &RegNo, SMLoc Loc, StringRef RegisterName);
+ OperandMatchResultTy parseRegister(MCRegister &RegNo);
// Parser functions.
void eatComma();
unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
unsigned Kind) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
// OuterDisp(%OuterReg, %InnerReg.Size * Scale, InnerDisp)
Kind Op;
- unsigned OuterReg;
- unsigned InnerReg;
+ MCRegister OuterReg;
+ MCRegister InnerReg;
const MCExpr *OuterDisp;
const MCExpr *InnerDisp;
uint8_t Size : 4;
return Match_InvalidOperand;
}
-bool M68kAsmParser::parseRegisterName(unsigned &RegNo, SMLoc Loc,
+bool M68kAsmParser::parseRegisterName(MCRegister &RegNo, SMLoc Loc,
StringRef RegisterName) {
auto RegisterNameLower = RegisterName.lower();
return false;
}
-OperandMatchResultTy M68kAsmParser::parseRegister(unsigned &RegNo) {
+OperandMatchResultTy M68kAsmParser::parseRegister(MCRegister &RegNo) {
bool HasPercent = false;
AsmToken PercentToken;
return MatchOperand_Success;
}
-bool M68kAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool M68kAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
auto Result = tryParseRegister(RegNo, StartLoc, EndLoc);
if (Result != MatchOperand_Success) {
return false;
}
-OperandMatchResultTy M68kAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy M68kAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
StartLoc = getLexer().getLoc();
bool IsFirstRegister =
(MemOp.Op == M68kMemOp::Kind::RegMask) && (MemOp.RegMask == 0);
- unsigned FirstRegister;
+ MCRegister FirstRegister;
auto Result = parseRegister(FirstRegister);
if (IsFirstRegister && (Result == llvm::MatchOperand_NoMatch)) {
return MatchOperand_NoMatch;
return MatchOperand_ParseFail;
}
- unsigned LastRegister = FirstRegister;
+ MCRegister LastRegister = FirstRegister;
if (getLexer().is(AsmToken::Minus)) {
getLexer().Lex();
Result = parseRegister(LastRegister);
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
static unsigned MatchRegisterName(StringRef Name);
static unsigned MatchRegisterAltName(StringRef Name);
-bool MSP430AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool MSP430AsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
switch (tryParseRegister(RegNo, StartLoc, EndLoc)) {
case MatchOperand_ParseFail:
llvm_unreachable("unknown match result type");
}
-OperandMatchResultTy MSP430AsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy MSP430AsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
if (getLexer().getKind() == AsmToken::Identifier) {
default: return true;
case AsmToken::Identifier: {
// try rN
- unsigned RegNo;
+ MCRegister RegNo;
SMLoc StartLoc, EndLoc;
- if (!ParseRegister(RegNo, StartLoc, EndLoc)) {
+ if (!parseRegister(RegNo, StartLoc, EndLoc)) {
Operands.push_back(MSP430Operand::CreateReg(RegNo, StartLoc, EndLoc));
return false;
}
const MCExpr *Val;
// Try constexpr[(rN)]
if (!getParser().parseExpression(Val)) {
- unsigned RegNo = MSP430::PC;
+ MCRegister RegNo = MSP430::PC;
SMLoc EndLoc = getParser().getTok().getLoc();
// Try (rN)
if (getLexer().getKind() == AsmToken::LParen) {
getLexer().Lex(); // Eat '('
SMLoc RegStartLoc;
- if (ParseRegister(RegNo, RegStartLoc, EndLoc))
+ if (parseRegister(RegNo, RegStartLoc, EndLoc))
return true;
if (getLexer().getKind() != AsmToken::RParen)
return true;
// Try @rN[+]
SMLoc StartLoc = getParser().getTok().getLoc();
getLexer().Lex(); // Eat '@'
- unsigned RegNo;
+ MCRegister RegNo;
SMLoc RegStartLoc, EndLoc;
- if (ParseRegister(RegNo, RegStartLoc, EndLoc))
+ if (parseRegister(RegNo, RegStartLoc, EndLoc))
return true;
if (getLexer().getKind() == AsmToken::Plus) {
Operands.push_back(MSP430Operand::CreatePostIndReg(RegNo, StartLoc, EndLoc));
bool MatchingInlineAsm) override;
/// Parse a register as used in CFI directives
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool parseParenSuffix(StringRef Name, OperandVector &Operands);
return true;
}
-bool MipsAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool MipsAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success;
}
-OperandMatchResultTy MipsAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy MipsAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
SmallVector<std::unique_ptr<MCParsedAsmOperand>, 1> Operands;
bool isPPC64() const { return IsPPC64; }
- bool MatchRegisterName(unsigned &RegNo, int64_t &IntVal);
+ bool MatchRegisterName(MCRegister &RegNo, int64_t &IntVal);
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
const MCExpr *ExtractModifierFromExpr(const MCExpr *E,
llvm_unreachable("Implement any new match types added!");
}
-bool PPCAsmParser::MatchRegisterName(unsigned &RegNo, int64_t &IntVal) {
+bool PPCAsmParser::MatchRegisterName(MCRegister &RegNo, int64_t &IntVal) {
if (getParser().getTok().is(AsmToken::Percent))
getParser().Lex(); // Eat the '%'.
return false;
}
-bool PPCAsmParser::
-ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) {
+bool PPCAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) {
if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success)
return TokError("invalid register name");
return false;
}
-OperandMatchResultTy PPCAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy PPCAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
// Special handling for register names. These are interpreted
// as immediates corresponding to the register number.
case AsmToken::Percent: {
- unsigned RegNo;
+ MCRegister RegNo;
int64_t IntVal;
if (MatchRegisterName(RegNo, IntVal))
return Error(S, "invalid register name");
int64_t IntVal;
switch (getLexer().getKind()) {
case AsmToken::Percent: {
- unsigned RegNo;
+ MCRegister RegNo;
if (MatchRegisterName(RegNo, IntVal))
return Error(S, "invalid register name");
break;
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
return RegNo == RISCV::NoRegister;
}
-bool RISCVAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool RISCVAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success)
return Error(StartLoc, "invalid register name");
return false;
}
-OperandMatchResultTy RISCVAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy RISCVAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = getParser().getTok();
OperandVector &Operands, MCStreamer &Out,
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
const MCExpr *subExpr);
// returns true if Tok is matched to a register and returns register in RegNo.
- bool matchRegisterName(const AsmToken &Tok, unsigned &RegNo,
+ bool matchRegisterName(const AsmToken &Tok, MCRegister &RegNo,
unsigned &RegKind);
bool matchSparcAsmModifiers(const MCExpr *&EVal, SMLoc &EndLoc);
llvm_unreachable("Implement any new match types added!");
}
-bool SparcAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool SparcAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success)
return Error(StartLoc, "invalid register name");
return false;
}
-OperandMatchResultTy SparcAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy SparcAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
const AsmToken &Tok = Parser.getTok();
return MatchOperand_NoMatch;
Parser.Lex(); // eat %
- unsigned RegNo, RegKind;
+ MCRegister RegNo;
+ unsigned RegKind;
if (!matchRegisterName(Parser.getTok(), RegNo, RegKind))
return MatchOperand_NoMatch;
switch (getLexer().getKind()) {
default: break;
- case AsmToken::Percent:
+ case AsmToken::Percent: {
Parser.Lex(); // Eat the '%'.
- unsigned RegNo;
+ MCRegister RegNo;
unsigned RegKind;
if (matchRegisterName(Parser.getTok(), RegNo, RegKind)) {
StringRef name = Parser.getTok().getString();
Op = SparcOperand::CreateImm(EVal, S, E);
}
break;
+ }
case AsmToken::Plus:
case AsmToken::Minus:
return MatchOperand_Success;
}
-bool SparcAsmParser::matchRegisterName(const AsmToken &Tok, unsigned &RegNo,
+bool SparcAsmParser::matchRegisterName(const AsmToken &Tok, MCRegister &RegNo,
unsigned &RegKind) {
int64_t intVal = 0;
RegNo = 0;
// Override MCTargetAsmParser.
bool ParseDirective(AsmToken DirectiveID) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ bool ParseRegister(MCRegister &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
bool RestoreOnFailure);
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
return true;
}
-bool SystemZAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool SystemZAsmParser::ParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc, bool RestoreOnFailure) {
Register Reg;
if (parseRegister(Reg, RestoreOnFailure))
return false;
}
-bool SystemZAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool SystemZAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return ParseRegister(RegNo, StartLoc, EndLoc, /*RestoreOnFailure=*/false);
}
-OperandMatchResultTy SystemZAsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy SystemZAsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
bool Result =
OperandVector &Operands, MCStreamer &Out,
uint64_t &ErrorInfo,
bool MatchingInlineAsm) override;
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
int parseRegisterName(unsigned (*matchFn)(StringRef));
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
SMLoc NameLoc, OperandVector &Operands) override;
llvm_unreachable("Implement any new match types added!");
}
-bool VEAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool VEAsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
if (tryParseRegister(RegNo, StartLoc, EndLoc) != MatchOperand_Success)
return Error(StartLoc, "invalid register name");
/// \note Generated by TableGen.
static unsigned MatchRegisterAltName(StringRef Name);
-OperandMatchResultTy
-VEAsmParser::tryParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) {
+OperandMatchResultTy VEAsmParser::tryParseRegister(MCRegister &RegNo,
+ SMLoc &StartLoc,
+ SMLoc &EndLoc) {
const AsmToken Tok = Parser.getTok();
StartLoc = Tok.getLoc();
EndLoc = Tok.getEndLoc();
}
const MCExpr *IndexValue = nullptr;
- unsigned IndexReg = 0;
+ MCRegister IndexReg;
switch (getLexer().getKind()) {
default:
- if (ParseRegister(IndexReg, S, E))
+ if (parseRegister(IndexReg, S, E))
return MatchOperand_ParseFail;
break;
break;
}
- unsigned BaseReg = 0;
- if (ParseRegister(BaseReg, S, E))
+ MCRegister BaseReg;
+ if (parseRegister(BaseReg, S, E))
return MatchOperand_ParseFail;
if (!Parser.getTok().is(AsmToken::RParen))
// (base)
// base
- unsigned BaseReg = VE::NoRegister;
+ MCRegister BaseReg;
std::unique_ptr<VEOperand> Offset;
switch (getLexer().getKind()) {
default:
}
case AsmToken::Percent:
- if (ParseRegister(BaseReg, S, E))
+ if (parseRegister(BaseReg, S, E))
return MatchOperand_NoMatch;
Offset =
VEOperand::CreateImm(MCConstantExpr::create(0, getContext()), S, E);
switch (getLexer().getKind()) {
default:
- if (ParseRegister(BaseReg, S, E))
+ if (parseRegister(BaseReg, S, E))
return MatchOperand_ParseFail;
break;
case AsmToken::Comma:
Parser.Lex(); // Eat the ,
- if (ParseRegister(BaseReg, S, E))
+ if (parseRegister(BaseReg, S, E))
return MatchOperand_ParseFail;
break;
const AsmToken Tok1 = Parser.getTok();
Parser.Lex(); // Eat the '('.
- unsigned RegNo1;
+ MCRegister RegNo1;
SMLoc S1, E1;
if (tryParseRegister(RegNo1, S1, E1) != MatchOperand_Success) {
getLexer().UnLex(Tok1);
return MatchOperand_ParseFail;
Parser.Lex(); // Eat the ','.
- unsigned RegNo2;
+ MCRegister RegNo2;
SMLoc S2, E2;
if (tryParseRegister(RegNo2, S2, E2) != MatchOperand_Success)
return MatchOperand_ParseFail;
default:
break;
- case AsmToken::Percent:
- unsigned RegNo;
+ 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:
#include "WebAssemblyGenAsmMatcher.inc"
// TODO: This is required to be implemented, but appears unused.
- bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
+ bool parseRegister(MCRegister & /*RegNo*/, SMLoc & /*StartLoc*/,
SMLoc & /*EndLoc*/) override {
- llvm_unreachable("ParseRegister is not implemented.");
+ llvm_unreachable("parseRegister is not implemented.");
}
- OperandMatchResultTy tryParseRegister(unsigned & /*RegNo*/,
+ OperandMatchResultTy tryParseRegister(MCRegister & /*RegNo*/,
SMLoc & /*StartLoc*/,
SMLoc & /*EndLoc*/) override {
llvm_unreachable("tryParseRegister is not implemented.");
return Parser.Error(L, Msg, Range);
}
- bool MatchRegisterByName(unsigned &RegNo, StringRef RegName, SMLoc StartLoc,
+ bool MatchRegisterByName(MCRegister &RegNo, StringRef RegName, SMLoc StartLoc,
SMLoc EndLoc);
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
+ bool ParseRegister(MCRegister &RegNo, SMLoc &StartLoc, SMLoc &EndLoc,
bool RestoreOnFailure);
std::unique_ptr<X86Operand> DefaultMemSIOperand(SMLoc Loc);
bool parseDirectiveFPOEndProc(SMLoc L);
/// SEH directives.
- bool parseSEHRegisterNumber(unsigned RegClassID, unsigned &RegNo);
+ bool parseSEHRegisterNumber(unsigned RegClassID, MCRegister &RegNo);
bool parseDirectiveSEHPushReg(SMLoc);
bool parseDirectiveSEHSetFrame(SMLoc);
bool parseDirectiveSEHSaveReg(SMLoc);
setAvailableFeatures(ComputeAvailableFeatures(getSTI().getFeatureBits()));
}
- bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
- OperandMatchResultTy tryParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+ bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
+ SMLoc &EndLoc) override;
+ OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) override;
bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
return checkScale(Scale, ErrMsg);
}
-bool X86AsmParser::MatchRegisterByName(unsigned &RegNo, StringRef RegName,
+bool X86AsmParser::MatchRegisterByName(MCRegister &RegNo, StringRef RegName,
SMLoc StartLoc, SMLoc EndLoc) {
// If we encounter a %, ignore it. This code handles registers with and
// without the prefix, unprefixed registers can occur in cfi directives.
return false;
}
-bool X86AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool X86AsmParser::ParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc, bool RestoreOnFailure) {
MCAsmParser &Parser = getParser();
MCAsmLexer &Lexer = getLexer();
return false;
}
-bool X86AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
+bool X86AsmParser::parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) {
return ParseRegister(RegNo, StartLoc, EndLoc, /*RestoreOnFailure=*/false);
}
-OperandMatchResultTy X86AsmParser::tryParseRegister(unsigned &RegNo,
+OperandMatchResultTy X86AsmParser::tryParseRegister(MCRegister &RegNo,
SMLoc &StartLoc,
SMLoc &EndLoc) {
bool Result =
}
}
// Register, or (MASM only) <register>.<field>
- unsigned Reg;
+ MCRegister Reg;
if (Tok.is(AsmToken::Identifier)) {
if (!ParseRegister(Reg, IdentLoc, End, /*RestoreOnFailure=*/true)) {
if (SM.onRegister(Reg, ErrMsg))
return ParseRoundingModeOp(Start, Operands);
// Register operand.
- unsigned RegNo = 0;
- if (Tok.is(AsmToken::Identifier) && !ParseRegister(RegNo, Start, End)) {
+ MCRegister RegNo;
+ if (Tok.is(AsmToken::Identifier) && !parseRegister(RegNo, Start, End)) {
if (RegNo == X86::RIP)
return Error(Start, "rip can only be used as a base register");
// A Register followed by ':' is considered a segment override
SMLoc StartLoc = Z ? consumeToken() : consumedToken;
// Parse an op-mask register mark ({%k<NUM>}), which is now to be
// expected
- unsigned RegNo;
+ MCRegister RegNo;
SMLoc RegLoc;
- if (!ParseRegister(RegNo, RegLoc, StartLoc) &&
+ if (!parseRegister(RegNo, RegLoc, StartLoc) &&
X86MCRegisterClasses[X86::VK1RegClassID].contains(RegNo)) {
if (RegNo == X86::K0)
return Error(RegLoc, "Register k0 can't be used as write mask");
(isParsingIntelSyntax() && getTok().is(AsmToken::Identifier) &&
MatchRegisterName(Parser.getTok().getString()))) {
SMLoc StartLoc = Parser.getTok().getLoc();
- unsigned RegNo;
- if (ParseRegister(RegNo, StartLoc, EndLoc))
+ MCRegister RegNo;
+ if (parseRegister(RegNo, StartLoc, EndLoc))
return true;
Res = X86MCExpr::create(RegNo, Parser.getContext());
return false;
// .cv_fpo_setframe ebp
bool X86AsmParser::parseDirectiveFPOSetFrame(SMLoc L) {
- unsigned Reg;
+ MCRegister Reg;
SMLoc DummyLoc;
- if (ParseRegister(Reg, DummyLoc, DummyLoc) || parseEOL())
+ if (parseRegister(Reg, DummyLoc, DummyLoc) || parseEOL())
return true;
return getTargetStreamer().emitFPOSetFrame(Reg, L);
}
// .cv_fpo_pushreg ebx
bool X86AsmParser::parseDirectiveFPOPushReg(SMLoc L) {
- unsigned Reg;
+ MCRegister Reg;
SMLoc DummyLoc;
- if (ParseRegister(Reg, DummyLoc, DummyLoc) || parseEOL())
+ if (parseRegister(Reg, DummyLoc, DummyLoc) || parseEOL())
return true;
return getTargetStreamer().emitFPOPushReg(Reg, L);
}
}
bool X86AsmParser::parseSEHRegisterNumber(unsigned RegClassID,
- unsigned &RegNo) {
+ MCRegister &RegNo) {
SMLoc startLoc = getLexer().getLoc();
const MCRegisterInfo *MRI = getContext().getRegisterInfo();
// Try parsing the argument as a register first.
if (getLexer().getTok().isNot(AsmToken::Integer)) {
SMLoc endLoc;
- if (ParseRegister(RegNo, startLoc, endLoc))
+ if (parseRegister(RegNo, startLoc, endLoc))
return true;
if (!X86MCRegisterClasses[RegClassID].contains(RegNo)) {
}
bool X86AsmParser::parseDirectiveSEHPushReg(SMLoc Loc) {
- unsigned Reg = 0;
+ MCRegister Reg;
if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
return true;
}
bool X86AsmParser::parseDirectiveSEHSetFrame(SMLoc Loc) {
- unsigned Reg = 0;
+ MCRegister Reg;
int64_t Off;
if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
return true;
}
bool X86AsmParser::parseDirectiveSEHSaveReg(SMLoc Loc) {
- unsigned Reg = 0;
+ MCRegister Reg;
int64_t Off;
if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
return true;
}
bool X86AsmParser::parseDirectiveSEHSaveXMM(SMLoc Loc) {
- unsigned Reg = 0;
+ MCRegister Reg;
int64_t Off;
if (parseSEHRegisterNumber(X86::VR128XRegClassID, Reg))
return true;