Use isPhysical/isVirtual methods.
return false;
break;
}
- if (Register::isPhysicalRegister(MO.getReg())) {
+ if (MO.getReg().isPhysical()) {
DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
dbgs() << CurrentIdx << ": Is a physical register\n");
if (handleReject() == RejectAndGiveUp)
phys_regs_and_masks(const MachineInstr &MI) {
std::function<bool(const MachineOperand &)> Pred =
[](const MachineOperand &MOP) {
- return MOP.isRegMask() || (MOP.isReg() && !MOP.isDebug() &&
- Register::isPhysicalRegister(MOP.getReg()));
+ return MOP.isRegMask() ||
+ (MOP.isReg() && !MOP.isDebug() && MOP.getReg().isPhysical());
};
return make_filter_range(const_mi_bundle_ops(MI), Pred);
}
getUndefRegState(RegOp.isUndef()) |
getInternalReadRegState(RegOp.isInternalRead()) |
getDebugRegState(RegOp.isDebug()) |
- getRenamableRegState(Register::isPhysicalRegister(RegOp.getReg()) &&
+ getRenamableRegState(RegOp.getReg().isPhysical() &&
RegOp.isRenamable());
}
/// Get the low-level type of \p Reg or LLT{} if Reg is not a generic
/// (target independent) virtual register.
LLT getType(Register Reg) const {
- if (Register::isVirtualRegister(Reg) && VRegToType.inBounds(Reg))
+ if (Reg.isVirtual() && VRegToType.inBounds(Reg))
return VRegToType[Reg];
return LLT{};
}
/// addRegAllocationHint - Add a register allocation hint to the hints
/// vector for VReg.
void addRegAllocationHint(Register VReg, Register PrefReg) {
- assert(Register::isVirtualRegister(VReg));
+ assert(VReg.isVirtual());
RegAllocHints[VReg].second.push_back(PrefReg);
}
/// Convert a virtual register number to a 0-based index.
/// The first virtual register in a function will get the index 0.
static unsigned virtReg2Index(Register Reg) {
- assert(isVirtualRegister(Reg) && "Not a virtual register");
+ assert(Reg.isVirtual() && "Not a virtual register");
return Reg & ~MCRegister::VirtualRegFlag;
}
llvm_unreachable("<unknown operand type>");
case MachineOperand::MO_Register: {
Register Reg = MO.getReg();
- assert(Register::isPhysicalRegister(Reg));
+ assert(Reg.isPhysical());
assert(!MO.getSubReg() && "Subregs should be eliminated!");
O << AArch64InstPrinter::getRegisterName(Reg);
break;
}
MachineInstr *AArch64CondBrTuning::getOperandDef(const MachineOperand &MO) {
- if (!Register::isVirtualRegister(MO.getReg()))
+ if (!MO.getReg().isVirtual())
return nullptr;
return MRI->getUniqueVRegDef(MO.getReg());
}
// We should not have any relevant physreg defs that are replacable by
// zero before register allocation. So we just check for dead vreg defs.
Register Reg = MO.getReg();
- if (!Register::isVirtualRegister(Reg) ||
- (!MO.isDead() && !MRI->use_nodbg_empty(Reg)))
+ if (!Reg.isVirtual() || (!MO.isDead() && !MRI->use_nodbg_empty(Reg)))
continue;
assert(!MO.isImplicit() && "Unexpected implicit def!");
LLVM_DEBUG(dbgs() << " Dead def operand #" << I << " in:\n ";
"Operand has register constraints without being a register!");
Register Reg = MO.getReg();
- if (Register::isPhysicalRegister(Reg)) {
+ if (Reg.isPhysical()) {
if (!OpRegCstraints->contains(Reg))
return false;
} else if (!OpRegCstraints->hasSubClassEq(MRI->getRegClass(Reg)) &&
MachineMemOperand *MMO) {
Register SrcReg0 = SrcReg;
Register SrcReg1 = SrcReg;
- if (Register::isPhysicalRegister(SrcReg)) {
+ if (SrcReg.isPhysical()) {
SrcReg0 = TRI.getSubReg(SrcReg, SubIdx0);
SubIdx0 = 0;
SrcReg1 = TRI.getSubReg(SrcReg, SubIdx1);
case 4:
if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
Opc = AArch64::STRWui;
- if (Register::isVirtualRegister(SrcReg))
+ if (SrcReg.isVirtual())
MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR32RegClass);
else
assert(SrcReg != AArch64::WSP);
case 8:
if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
Opc = AArch64::STRXui;
- if (Register::isVirtualRegister(SrcReg))
+ if (SrcReg.isVirtual())
MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
else
assert(SrcReg != AArch64::SP);
Register DestReg0 = DestReg;
Register DestReg1 = DestReg;
bool IsUndef = true;
- if (Register::isPhysicalRegister(DestReg)) {
+ if (DestReg.isPhysical()) {
DestReg0 = TRI.getSubReg(DestReg, SubIdx0);
SubIdx0 = 0;
DestReg1 = TRI.getSubReg(DestReg, SubIdx1);
case 4:
if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
Opc = AArch64::LDRWui;
- if (Register::isVirtualRegister(DestReg))
+ if (DestReg.isVirtual())
MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR32RegClass);
else
assert(DestReg != AArch64::WSP);
case 8:
if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
Opc = AArch64::LDRXui;
- if (Register::isVirtualRegister(DestReg))
+ if (DestReg.isVirtual())
MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR64RegClass);
else
assert(DestReg != AArch64::SP);
if (MI.isFullCopy()) {
Register DstReg = MI.getOperand(0).getReg();
Register SrcReg = MI.getOperand(1).getReg();
- if (SrcReg == AArch64::SP && Register::isVirtualRegister(DstReg)) {
+ if (SrcReg == AArch64::SP && DstReg.isVirtual()) {
MF.getRegInfo().constrainRegClass(DstReg, &AArch64::GPR64RegClass);
return nullptr;
}
- if (DstReg == AArch64::SP && Register::isVirtualRegister(SrcReg)) {
+ if (DstReg == AArch64::SP && SrcReg.isVirtual()) {
MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
return nullptr;
}
//
// STRXui %xzr, %stack.0
//
- if (IsSpill && DstMO.isUndef() && Register::isPhysicalRegister(SrcReg)) {
+ if (IsSpill && DstMO.isUndef() && SrcReg.isPhysical()) {
assert(SrcMO.getSubReg() == 0 &&
"Unexpected subreg on physical register");
const TargetRegisterClass *SpillRC;
MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
MachineInstr *MI = nullptr;
- if (MO.isReg() && Register::isVirtualRegister(MO.getReg()))
+ if (MO.isReg() && MO.getReg().isVirtual())
MI = MRI.getUniqueVRegDef(MO.getReg());
// And it needs to be in the trace (otherwise, it won't have a depth).
if (!MI || MI->getParent() != &MBB || (unsigned)MI->getOpcode() != CombineOpc)
MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
MachineOperand &MO = Root.getOperand(Operand);
MachineInstr *MI = nullptr;
- if (MO.isReg() && Register::isVirtualRegister(MO.getReg()))
+ if (MO.isReg() && MO.getReg().isVirtual())
MI = MRI.getUniqueVRegDef(MO.getReg());
// Ignore No-op COPYs in FMUL(COPY(DUP(..)))
if (MI && MI->getOpcode() == TargetOpcode::COPY &&
Register SrcReg1 = MUL->getOperand(2).getReg();
bool Src1IsKill = MUL->getOperand(2).isKill();
- unsigned SrcReg2;
+ Register SrcReg2;
bool Src2IsKill;
if (ReplacedAddend) {
// If we just generated a new addend, we must be it's only use.
Src2IsKill = Root.getOperand(IdxOtherOpd).isKill();
}
- if (Register::isVirtualRegister(ResultReg))
+ if (ResultReg.isVirtual())
MRI.constrainRegClass(ResultReg, RC);
- if (Register::isVirtualRegister(SrcReg0))
+ if (SrcReg0.isVirtual())
MRI.constrainRegClass(SrcReg0, RC);
- if (Register::isVirtualRegister(SrcReg1))
+ if (SrcReg1.isVirtual())
MRI.constrainRegClass(SrcReg1, RC);
- if (Register::isVirtualRegister(SrcReg2))
+ if (SrcReg2.isVirtual())
MRI.constrainRegClass(SrcReg2, RC);
MachineInstrBuilder MIB;
Register SrcReg1 = MUL->getOperand(2).getReg();
bool Src1IsKill = MUL->getOperand(2).isKill();
- if (Register::isVirtualRegister(ResultReg))
+ if (ResultReg.isVirtual())
MRI.constrainRegClass(ResultReg, RC);
- if (Register::isVirtualRegister(SrcReg0))
+ if (SrcReg0.isVirtual())
MRI.constrainRegClass(SrcReg0, RC);
- if (Register::isVirtualRegister(SrcReg1))
+ if (SrcReg1.isVirtual())
MRI.constrainRegClass(SrcReg1, RC);
if (Register::isVirtualRegister(VR))
MRI.constrainRegClass(VR, RC);
MachineFunction *MF = MBB->getParent();
MachineRegisterInfo *MRI = &MF->getRegInfo();
Register VReg = MI.getOperand(0).getReg();
- if (!Register::isVirtualRegister(VReg))
+ if (!VReg.isVirtual())
return false;
MachineInstr *DefMI = MRI->getVRegDef(VReg);
MachineOperand &MO = DefMI->getOperand(1);
Register NewReg = MO.getReg();
- if (!Register::isVirtualRegister(NewReg))
+ if (!NewReg.isVirtual())
return false;
assert(!MRI->def_empty(NewReg) && "Register must be defined.");
UseI.getOperand(OpIdx).ChangeToFrameIndex(FI);
UseI.getOperand(OpIdx).setTargetFlags(AArch64II::MO_TAGGED);
}
- } else if (UseI.isCopy() &&
- Register::isVirtualRegister(UseI.getOperand(0).getReg())) {
+ } else if (UseI.isCopy() && UseI.getOperand(0).getReg().isVirtual()) {
uncheckUsesOf(UseI.getOperand(0).getReg(), FI);
}
}
continue;
Register RetagReg = I->getOperand(0).getReg();
- if (!Register::isVirtualRegister(RetagReg))
+ if (!RetagReg.isVirtual())
continue;
int Score = 0;
continue;
if (UseI.isCopy()) {
Register DstReg = UseI.getOperand(0).getReg();
- if (Register::isVirtualRegister(DstReg))
+ if (DstReg.isVirtual())
WorkList.push_back(DstReg);
continue;
}
// so, this will need to be taught about that, and we'll need to get the
// bank out of the minimal class for the register.
// Either way, this needs to be documented (and possibly verified).
- if (!Register::isVirtualRegister(MO.getReg())) {
+ if (!MO.getReg().isVirtual()) {
LLVM_DEBUG(dbgs() << "Generic inst has physical register operand\n");
return true;
}
// It's possible that the destination register won't be constrained. Make
// sure that happens.
- if (!Register::isPhysicalRegister(I.getOperand(0).getReg()))
+ if (!I.getOperand(0).getReg().isPhysical())
RBI.constrainGenericRegister(I.getOperand(0).getReg(), *To, MRI);
return true;
// If the destination is a physical register, then there's nothing to
// change, so we're done.
- if (Register::isPhysicalRegister(DstReg))
+ if (DstReg.isPhysical())
return true;
}
Register DstReg = MI.getOperand(0).getReg();
Register SrcReg = MI.getOperand(1).getReg();
// Check if one of the register is not a generic register.
- if ((Register::isPhysicalRegister(DstReg) ||
- !MRI.getType(DstReg).isValid()) ||
- (Register::isPhysicalRegister(SrcReg) ||
- !MRI.getType(SrcReg).isValid())) {
+ if ((DstReg.isPhysical() || !MRI.getType(DstReg).isValid()) ||
+ (SrcReg.isPhysical() || !MRI.getType(SrcReg).isValid())) {
const RegisterBank *DstRB = getRegBank(DstReg, MRI, TRI);
const RegisterBank *SrcRB = getRegBank(SrcReg, MRI, TRI);
if (!DstRB)
// Do not Track Physical Registers, because it messes up.
for (const auto &RegMaskPair : RPTracker.getPressure().LiveInRegs) {
- if (Register::isVirtualRegister(RegMaskPair.RegUnit))
+ if (RegMaskPair.RegUnit.isVirtual())
LiveInRegs.insert(RegMaskPair.RegUnit);
}
LiveOutRegs.clear();
return false;
Register Reg = MO.getReg();
- if (Register::isVirtualRegister(Reg))
+ if (Reg.isVirtual())
return MRI->getRegClass(Reg)->hasSuperClassEq(TRC);
else
return TRC->contains(Reg);
if ((!MO.isReg()) || (!MO.isUse()))
continue;
Register Reg = MO.getReg();
- if (!Register::isVirtualRegister(Reg))
+ if (!Reg.isVirtual())
continue;
MachineOperand *Op = MI->findRegisterDefOperand(Reg);
if ((!MODef.isReg()) || (!MODef.isDef()))
continue;
Register DefReg = MODef.getReg();
- if (!Register::isVirtualRegister(DefReg)) {
+ if (!DefReg.isVirtual()) {
IsDead = false;
break;
}
Register DPRReg = MI->getOperand(1).getReg();
Register SPRReg = MI->getOperand(2).getReg();
- if (Register::isVirtualRegister(DPRReg) && Register::isVirtualRegister(SPRReg)) {
+ if (DPRReg.isVirtual() && SPRReg.isVirtual()) {
MachineInstr *DPRMI = MRI->getVRegDef(MI->getOperand(1).getReg());
MachineInstr *SPRMI = MRI->getVRegDef(MI->getOperand(2).getReg());
++NumTotal;
Register OpReg = MO.getReg();
- if (!Register::isVirtualRegister(OpReg))
+ if (!OpReg.isVirtual())
break;
MachineInstr *Def = MRI->getVRegDef(OpReg);
MachineInstr *A15SDOptimizer::elideCopies(MachineInstr *MI) {
if (!MI->isFullCopy())
return MI;
- if (!Register::isVirtualRegister(MI->getOperand(1).getReg()))
+ if (!MI->getOperand(1).getReg().isVirtual())
return nullptr;
MachineInstr *Def = MRI->getVRegDef(MI->getOperand(1).getReg());
if (!Def)
if (MI->isPHI()) {
for (unsigned I = 1, E = MI->getNumOperands(); I != E; I += 2) {
Register Reg = MI->getOperand(I).getReg();
- if (!Register::isVirtualRegister(Reg)) {
+ if (!Reg.isVirtual()) {
continue;
}
MachineInstr *NewMI = MRI->getVRegDef(Reg);
Front.push_back(NewMI);
}
} else if (MI->isFullCopy()) {
- if (!Register::isVirtualRegister(MI->getOperand(1).getReg()))
+ if (!MI->getOperand(1).getReg().isVirtual())
continue;
MachineInstr *NewMI = MRI->getVRegDef(MI->getOperand(1).getReg());
if (!NewMI)
default: llvm_unreachable("<unknown operand type>");
case MachineOperand::MO_Register: {
Register Reg = MO.getReg();
- assert(Register::isPhysicalRegister(Reg));
+ assert(Reg.isPhysical());
assert(!MO.getSubReg() && "Subregs should be eliminated!");
if(ARM::GPRPairRegClass.contains(Reg)) {
const MachineFunction &MF = *MI->getParent()->getParent();
// Transfer LiveVariables states, kill / dead info.
if (LV) {
for (const MachineOperand &MO : MI.operands()) {
- if (MO.isReg() && Register::isVirtualRegister(MO.getReg())) {
+ if (MO.isReg() && MO.getReg().isVirtual()) {
Register Reg = MO.getReg();
LiveVariables::VarInfo &VI = LV->getVarInfo(Reg);
MIB = AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
}
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
MIB.addReg(DestReg, RegState::ImplicitDefine);
} else
llvm_unreachable("Unknown reg class!");
MIB = AddDReg(MIB, DestReg, ARM::dsub_0, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
MIB.addReg(DestReg, RegState::ImplicitDefine);
}
} else
MIB = AddDReg(MIB, DestReg, ARM::dsub_1, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_2, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_3, RegState::DefineNoRead, TRI);
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
MIB.addReg(DestReg, RegState::ImplicitDefine);
}
} else
MIB = AddDReg(MIB, DestReg, ARM::dsub_5, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_6, RegState::DefineNoRead, TRI);
MIB = AddDReg(MIB, DestReg, ARM::dsub_7, RegState::DefineNoRead, TRI);
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
MIB.addReg(DestReg, RegState::ImplicitDefine);
} else
llvm_unreachable("Unknown reg class!");
Register Addr0 = MI0.getOperand(1).getReg();
Register Addr1 = MI1.getOperand(1).getReg();
if (Addr0 != Addr1) {
- if (!MRI || !Register::isVirtualRegister(Addr0) ||
- !Register::isVirtualRegister(Addr1))
+ if (!MRI || !Addr0.isVirtual() || !Addr1.isVirtual())
return false;
// This assumes SSA form.
// MI can't have any tied operands, that would conflict with predication.
if (MO.isTied())
return nullptr;
- if (Register::isPhysicalRegister(MO.getReg()))
+ if (MO.getReg().isPhysical())
return nullptr;
if (MO.isDef() && !MO.isDead())
return nullptr;
return 0;
// We must be able to clobber the whole D-reg.
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
// Virtual register must be a def undef foo:ssub_0 operand.
if (!MO.getSubReg() || MI.readsVirtualRegister(Reg))
return 0;
const MachineOperand &MO = MI.getOperand(OpNum);
Register Reg = MO.getReg();
- assert(Register::isPhysicalRegister(Reg) &&
- "Can't break virtual register dependencies.");
+ assert(Reg.isPhysical() && "Can't break virtual register dependencies.");
unsigned DReg = Reg;
// If MI defines an S-reg, find the corresponding D super-register.
for (auto &S : SU.Succs)
if (MI->isPHI() && S.getKind() == SDep::Anti) {
Register Reg = S.getReg();
- if (Register::isVirtualRegister(Reg))
+ if (Reg.isVirtual())
CrossIterationNeeds.insert(std::make_pair(Reg.id(), IterNeed()))
.first->second.set(0);
} else if (S.isAssignedRegDep()) {
int OStg = SMS.stageScheduled(S.getSUnit());
if (OStg >= 0 && OStg != Stg) {
Register Reg = S.getReg();
- if (Register::isVirtualRegister(Reg))
+ if (Reg.isVirtual())
CrossIterationNeeds.insert(std::make_pair(Reg.id(), IterNeed()))
.first->second |= ((1 << (OStg - Stg)) - 1);
}
// Make sure the pair has not already divorced.
if (Hint.second == Reg) {
MRI->setRegAllocationHint(OtherReg, Hint.first, NewReg);
- if (Register::isVirtualRegister(NewReg))
+ if (NewReg.isVirtual())
MRI->setRegAllocationHint(NewReg,
Hint.first == ARMRI::RegPairOdd
? ARMRI::RegPairEven
const TargetRegisterClass *RegClass =
TII.getRegClass(MCID, FIOperandNum, this, *MI.getParent()->getParent());
- if (Offset == 0 &&
- (Register::isVirtualRegister(FrameReg) || RegClass->contains(FrameReg)))
+ if (Offset == 0 && (FrameReg.isVirtual() || RegClass->contains(FrameReg)))
// Must be addrmode4/6.
MI.getOperand(FIOperandNum).ChangeToRegister(FrameReg, false, false, false);
else {
MIB.add(Info.Callee);
if (!IsDirect) {
auto CalleeReg = Info.Callee.getReg();
- if (CalleeReg && !Register::isPhysicalRegister(CalleeReg)) {
+ if (CalleeReg && !CalleeReg.isPhysical()) {
unsigned CalleeIdx = IsThumb ? 2 : 0;
MIB->getOperand(CalleeIdx).setReg(constrainOperandRegClass(
MF, *TRI, MRI, *STI.getInstrInfo(), *STI.getRegBankInfo(),
Register Reg = Op.getReg();
if (Reg == ARM::NoRegister || Reg == ARM::LR)
continue;
- assert(Register::isPhysicalRegister(Reg) && "Unallocated register");
+ assert(Reg.isPhysical() && "Unallocated register");
ClearBB->addLiveIn(Reg);
DoneBB->addLiveIn(Reg);
}
int FI = std::numeric_limits<int>::max();
if (Arg.getOpcode() == ISD::CopyFromReg) {
Register VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
- if (!Register::isVirtualRegister(VR))
+ if (!VR.isVirtual())
return false;
MachineInstr *Def = MRI->getVRegDef(VR);
if (!Def)
MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI,
const RegisterBankInfo &RBI) {
Register DstReg = I.getOperand(0).getReg();
- if (Register::isPhysicalRegister(DstReg))
+ if (DstReg.isPhysical())
return true;
const TargetRegisterClass *RC = guessRegClass(DstReg, MRI, TRI, RBI);
// Distinguish between our multiple MI-level forms of the same
// VLDM/VSTM instructions.
def A9PreRA : SchedPredicate<
- "Register::isVirtualRegister(MI->getOperand(0).getReg())">;
+ "MI->getOperand(0).getReg().isVirtual()">;
def A9PostRA : SchedPredicate<
- "Register::isPhysicalRegister(MI->getOperand(0).getReg())">;
+ "MI->getOperand(0).getReg().isPhysical()">;
// VLDM represents all destination registers as a single register
// tuple, unlike LDM. So the number of write operands is not variadic.
// Look past COPY and INSERT_SUBREG instructions to find the
// real definition MI. This is important for _sfp instructions.
Register Reg = MI->getOperand(1).getReg();
- if (Register::isPhysicalRegister(Reg))
+ if (Reg.isPhysical())
return nullptr;
MachineBasicBlock *MBB = MI->getParent();
break;
if (DefMI->isCopyLike()) {
Reg = DefMI->getOperand(1).getReg();
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
DefMI = MRI->getVRegDef(Reg);
continue;
}
} else if (DefMI->isInsertSubreg()) {
Reg = DefMI->getOperand(2).getReg();
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
DefMI = MRI->getVRegDef(Reg);
continue;
}
unsigned MLxExpansion::getDefReg(MachineInstr *MI) const {
Register Reg = MI->getOperand(0).getReg();
- if (Register::isPhysicalRegister(Reg) || !MRI->hasOneNonDBGUse(Reg))
+ if (Reg.isPhysical() || !MRI->hasOneNonDBGUse(Reg))
return Reg;
MachineBasicBlock *MBB = MI->getParent();
while (UseMI->isCopy() || UseMI->isInsertSubreg()) {
Reg = UseMI->getOperand(0).getReg();
- if (Register::isPhysicalRegister(Reg) || !MRI->hasOneNonDBGUse(Reg))
+ if (Reg.isPhysical() || !MRI->hasOneNonDBGUse(Reg))
return Reg;
UseMI = &*MRI->use_instr_nodbg_begin(Reg);
if (UseMI->getParent() != MBB)
/// a single-MBB loop.
bool MLxExpansion::hasLoopHazard(MachineInstr *MI) const {
Register Reg = MI->getOperand(1).getReg();
- if (Register::isPhysicalRegister(Reg))
+ if (Reg.isPhysical())
return false;
MachineBasicBlock *MBB = MI->getParent();
for (unsigned i = 1, e = DefMI->getNumOperands(); i < e; i += 2) {
if (DefMI->getOperand(i + 1).getMBB() == MBB) {
Register SrcReg = DefMI->getOperand(i).getReg();
- if (Register::isVirtualRegister(SrcReg)) {
+ if (SrcReg.isVirtual()) {
DefMI = MRI->getVRegDef(SrcReg);
goto outer_continue;
}
}
} else if (DefMI->isCopyLike()) {
Reg = DefMI->getOperand(1).getReg();
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
DefMI = MRI->getVRegDef(Reg);
continue;
}
} else if (DefMI->isInsertSubreg()) {
Reg = DefMI->getOperand(2).getReg();
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
DefMI = MRI->getVRegDef(Reg);
continue;
}
const TargetRegisterInfo *TRI,
Register VReg) const {
assert((RC == &ARM::tGPRRegClass ||
- (Register::isPhysicalRegister(SrcReg) && isARMLowRegister(SrcReg))) &&
+ (SrcReg.isPhysical() && isARMLowRegister(SrcReg))) &&
"Unknown regclass!");
if (RC == &ARM::tGPRRegClass ||
- (Register::isPhysicalRegister(SrcReg) && isARMLowRegister(SrcReg))) {
+ (SrcReg.isPhysical() && isARMLowRegister(SrcReg))) {
DebugLoc DL;
if (I != MBB.end()) DL = I->getDebugLoc();
const TargetRegisterClass *RC,
const TargetRegisterInfo *TRI,
Register VReg) const {
- assert(
- (RC->hasSuperClassEq(&ARM::tGPRRegClass) ||
- (Register::isPhysicalRegister(DestReg) && isARMLowRegister(DestReg))) &&
- "Unknown regclass!");
+ assert((RC->hasSuperClassEq(&ARM::tGPRRegClass) ||
+ (DestReg.isPhysical() && isARMLowRegister(DestReg))) &&
+ "Unknown regclass!");
if (RC->hasSuperClassEq(&ARM::tGPRRegClass) ||
- (Register::isPhysicalRegister(DestReg) && isARMLowRegister(DestReg))) {
+ (DestReg.isPhysical() && isARMLowRegister(DestReg))) {
DebugLoc DL;
if (I != MBB.end()) DL = I->getDebugLoc();
// Thumb2 STRD expects its dest-registers to be in rGPR. Not a problem for
// gsub_0, but needs an extra constraint for gsub_1 (which could be sp
// otherwise).
- if (Register::isVirtualRegister(SrcReg)) {
+ if (SrcReg.isVirtual()) {
MachineRegisterInfo *MRI = &MF.getRegInfo();
MRI->constrainRegClass(SrcReg, &ARM::GPRPairnospRegClass);
}
// Thumb2 LDRD expects its dest-registers to be in rGPR. Not a problem for
// gsub_0, but needs an extra constraint for gsub_1 (which could be sp
// otherwise).
- if (Register::isVirtualRegister(DestReg)) {
+ if (DestReg.isVirtual()) {
MachineRegisterInfo *MRI = &MF.getRegInfo();
MRI->constrainRegClass(DestReg, &ARM::GPRPairnospRegClass);
}
AddDReg(MIB, DestReg, ARM::gsub_1, RegState::DefineNoRead, TRI);
MIB.addFrameIndex(FI).addImm(0).addMemOperand(MMO).add(predOps(ARMCC::AL));
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
MIB.addReg(DestReg, RegState::ImplicitDefine);
return;
}
int ImmedOffset = Offset / Scale;
unsigned Mask = (1 << NumBits) - 1;
if ((unsigned)Offset <= Mask * Scale &&
- (Register::isVirtualRegister(FrameReg) ||
- RegClass->contains(FrameReg))) {
- if (Register::isVirtualRegister(FrameReg)) {
+ (FrameReg.isVirtual() || RegClass->contains(FrameReg))) {
+ if (FrameReg.isVirtual()) {
// Make sure the register class for the virtual register is correct
MachineRegisterInfo *MRI = &MF.getRegInfo();
if (!MRI->constrainRegClass(FrameReg, RegClass))
}
Offset = (isSub) ? -Offset : Offset;
- return Offset == 0 && (Register::isVirtualRegister(FrameReg) ||
- RegClass->contains(FrameReg));
+ return Offset == 0 && (FrameReg.isVirtual() || RegClass->contains(FrameReg));
}
ARMCC::CondCodes llvm::getITInstrPredicate(const MachineInstr &MI,
Register LdReg = DestReg;
if (DestReg == ARM::SP)
assert(BaseReg == ARM::SP && "Unexpected!");
- if (!isARMLowRegister(DestReg) && !Register::isVirtualRegister(DestReg))
+ if (!isARMLowRegister(DestReg) && !DestReg.isVirtual())
LdReg = MF.getRegInfo().createVirtualRegister(&ARM::tGPRRegClass);
if (NumBytes <= 255 && NumBytes >= 0 && CanChangeCC) {
// Most likely, this physical register is aliased to
// function call return value or current function parameters.
Register Reg = opnd.getReg();
- if (!Register::isVirtualRegister(Reg))
+ if (!Reg.isVirtual())
return false;
if (MRI->getRegClass(Reg) == &BPF::GPRRegClass)
RegisterRef RD = MI.getOperand(0);
RegisterRef RS = MI.getOperand(1);
assert(RD.Sub == 0);
- if (!Register::isPhysicalRegister(RS.Reg))
+ if (!RS.Reg.isPhysical())
return false;
RegExtMap::const_iterator F = VRX.find(RD.Reg);
if (F == VRX.end())
return SRs;
}
- if (Register::isPhysicalRegister(R.Reg)) {
+ if (R.Reg.isPhysical()) {
MCSubRegIterator I(R.Reg, &TRI);
if (!I.isValid())
SRs.insert({R.Reg, 0});
if (!Op.isReg() || !Op.isUse() || Op.isUndef())
continue;
RegisterRef R = { Op.getReg(), Op.getSubReg() };
- if (Register::isPhysicalRegister(R.Reg) && Reserved[R.Reg])
+ if (R.Reg.isPhysical() && Reserved[R.Reg])
continue;
bool IsKill = Op.isKill();
for (auto S : expandToSubRegs(R, MRI, TRI)) {
continue;
RegisterRef R = { Op.getReg(), Op.getSubReg() };
for (auto S : expandToSubRegs(R, MRI, TRI)) {
- if (Register::isPhysicalRegister(S.Reg) && Reserved[S.Reg])
+ if (S.Reg.isPhysical() && Reserved[S.Reg])
continue;
if (Op.isDead())
Clobbers.insert(S);
// Update maps for defs.
for (RegisterRef S : Defs) {
// Defs should already be expanded into subregs.
- assert(!Register::isPhysicalRegister(S.Reg) ||
+ assert(!S.Reg.isPhysical() ||
!MCSubRegIterator(S.Reg, &TRI, false).isValid());
if (LastDef[S] != IndexType::None || LastUse[S] != IndexType::None)
closeRange(S);
// Update maps for clobbers.
for (RegisterRef S : Clobbers) {
// Clobbers should already be expanded into subregs.
- assert(!Register::isPhysicalRegister(S.Reg) ||
+ assert(!S.Reg.isPhysical() ||
!MCSubRegIterator(S.Reg, &TRI, false).isValid());
if (LastDef[S] != IndexType::None || LastUse[S] != IndexType::None)
closeRange(S);
if (RegA == RegB)
return true;
- if (Register::isPhysicalRegister(RegA))
+ if (RegA.isPhysical())
for (MCSubRegIterator SubRegs(RegA, &HRI); SubRegs.isValid(); ++SubRegs)
if (RegB == *SubRegs)
return true;
- if (Register::isPhysicalRegister(RegB))
+ if (RegB.isPhysical())
for (MCSubRegIterator SubRegs(RegB, &HRI); SubRegs.isValid(); ++SubRegs)
if (RegA == *SubRegs)
return true;
// Get DefIdx and UseIdx for super registers.
const MachineOperand &DefMO = DefMI.getOperand(DefIdx);
- if (DefMO.isReg() && Register::isPhysicalRegister(DefMO.getReg())) {
+ if (DefMO.isReg() && DefMO.getReg().isPhysical()) {
if (DefMO.isImplicit()) {
for (MCSuperRegIterator SR(DefMO.getReg(), &HRI); SR.isValid(); ++SR) {
int Idx = DefMI.findRegisterDefOperandIdx(*SR, false, false, &HRI);
// The code below checks for all the physical registers, not just R0/D0/V0.
else if (SchedRetvalOptimization) {
const MachineInstr *MI = DAG->SUnits[su].getInstr();
- if (MI->isCopy() &&
- Register::isPhysicalRegister(MI->getOperand(1).getReg())) {
+ if (MI->isCopy() && MI->getOperand(1).getReg().isPhysical()) {
// %vregX = COPY %r0
VRegHoldingReg[MI->getOperand(0).getReg()] = MI->getOperand(1).getReg();
LastVRegUse.erase(MI->getOperand(1).getReg());
VRegHoldingReg.count(MO.getReg())) {
// <use of %vregX>
LastVRegUse[VRegHoldingReg[MO.getReg()]] = &DAG->SUnits[su];
- } else if (MO.isDef() && Register::isPhysicalRegister(MO.getReg())) {
+ } else if (MO.isDef() && MO.getReg().isPhysical()) {
for (MCRegAliasIterator AI(MO.getReg(), &TRI, true); AI.isValid();
++AI) {
if (LastVRegUse.count(*AI) &&
// MI can't have any tied operands, that would conflict with predication.
if (MO.isTied())
return nullptr;
- if (Register::isPhysicalRegister(MO.getReg()))
+ if (MO.getReg().isPhysical())
return nullptr;
if (MO.isDef() && !MO.isDead())
return nullptr;
for (unsigned i = 0, e = II->getNumOperands(); i != e; ++i) {
MachineOperand &MO = II->getOperand(i);
if (MO.isReg() && MO.getReg() != 0 && !MO.isDef() &&
- !Register::isVirtualRegister(MO.getReg()))
+ !MO.getReg().isVirtual())
Candidates.reset(MO.getReg());
}
bool MipsInstructionSelector::selectCopy(MachineInstr &I,
MachineRegisterInfo &MRI) const {
Register DstReg = I.getOperand(0).getReg();
- if (Register::isPhysicalRegister(DstReg))
+ if (DstReg.isPhysical())
return true;
const TargetRegisterClass *RC = getRegClassForTypeOnBank(DstReg, MRI);
const Register DestReg = I.getOperand(0).getReg();
const TargetRegisterClass *DefRC = nullptr;
- if (Register::isPhysicalRegister(DestReg))
+ if (DestReg.isPhysical())
DefRC = TRI.getRegClass(DestReg);
else
DefRC = getRegClassForTypeOnBank(DestReg, MRI);
MachineOperand &MO = MI.getOperand(0);
- if (!MO.isReg() || !MO.isUse() || !Register::isVirtualRegister(MO.getReg()))
+ if (!MO.isReg() || !MO.isUse() || !MO.getReg().isVirtual())
return nullptr;
return &MO;
MachineInstr *NonCopyInstr = skipCopiesOutgoing(&UseMI);
// Copy with many uses.
if (NonCopyInstr->getOpcode() == TargetOpcode::COPY &&
- !Register::isPhysicalRegister(NonCopyInstr->getOperand(0).getReg()))
+ !NonCopyInstr->getOperand(0).getReg().isPhysical())
addDefUses(NonCopyInstr->getOperand(0).getReg(), MRI);
else
DefUses.push_back(skipCopiesOutgoing(&UseMI));
const MachineRegisterInfo &MRI = MF.getRegInfo();
MachineInstr *Ret = MI;
while (Ret->getOpcode() == TargetOpcode::COPY &&
- !Register::isPhysicalRegister(Ret->getOperand(0).getReg()) &&
+ !Ret->getOperand(0).getReg().isPhysical() &&
MRI.hasOneUse(Ret->getOperand(0).getReg())) {
Ret = &(*MRI.use_instr_begin(Ret->getOperand(0).getReg()));
}
const MachineRegisterInfo &MRI = MF.getRegInfo();
MachineInstr *Ret = MI;
while (Ret->getOpcode() == TargetOpcode::COPY &&
- !Register::isPhysicalRegister(Ret->getOperand(1).getReg()))
+ !Ret->getOperand(1).getReg().isPhysical())
Ret = MRI.getVRegDef(Ret->getOperand(1).getReg());
return Ret;
}
void MipsRegisterBankInfo::TypeInfoForMF::setTypesAccordingToPhysicalRegister(
const MachineInstr *MI, const MachineInstr *CopyInst, unsigned Op) {
- assert((Register::isPhysicalRegister(CopyInst->getOperand(Op).getReg())) &&
+ assert((CopyInst->getOperand(Op).getReg().isPhysical()) &&
"Copies of non physical registers should not be considered here.\n");
const MachineFunction &MF = *CopyInst->getMF();
void NVPTXAsmPrinter::emitImplicitDef(const MachineInstr *MI) const {
Register RegNo = MI->getOperand(0).getReg();
- if (Register::isVirtualRegister(RegNo)) {
+ if (RegNo.isVirtual()) {
OutStreamer->AddComment(Twine("implicit-def: ") +
getVirtualRegisterName(RegNo));
} else {
const MachineOperand &MO = MI->getOperand(opNum);
switch (MO.getType()) {
case MachineOperand::MO_Register:
- if (Register::isPhysicalRegister(MO.getReg())) {
+ if (MO.getReg().isPhysical()) {
if (MO.getReg() == NVPTX::VRDepot)
O << DEPOTNAME << getFunctionNumber();
else
auto &Op = Root.getOperand(1);
const auto &MRI = MF.getRegInfo();
MachineInstr *GenericAddrDef = nullptr;
- if (Op.isReg() && Register::isVirtualRegister(Op.getReg())) {
+ if (Op.isReg() && Op.getReg().isVirtual()) {
GenericAddrDef = MRI.getUniqueVRegDef(Op.getReg());
}
if (Op1.isIdenticalTo(Op2)) {
// filter out instructions with physical-register uses
- if (Op1.isReg() &&
- Register::isPhysicalRegister(Op1.getReg())
+ if (Op1.isReg() && Op1.getReg().isPhysical()
// If the physical register is constant then we can assume the value
// has not changed between uses.
&& !(Op1.isUse() && MRI->isConstantPhysReg(Op1.getReg()))) {
// If the operands are not identical, but are registers, check to see if the
// definition of the register produces the same value. If they produce the
// same value, consider them to be identical.
- if (Op1.isReg() && Op2.isReg() &&
- Register::isVirtualRegister(Op1.getReg()) &&
- Register::isVirtualRegister(Op2.getReg())) {
+ if (Op1.isReg() && Op2.isReg() && Op1.getReg().isVirtual() &&
+ Op2.getReg().isVirtual()) {
MachineInstr *Op1Def = MRI->getVRegDef(Op1.getReg());
MachineInstr *Op2Def = MRI->getVRegDef(Op2.getReg());
if (TII->produceSameValue(*Op1Def, *Op2Def, MRI)) {
<< TargetMBB.getNumber() << "\n");
for (auto &Use : MI.uses()) {
- if (Use.isReg() && Register::isVirtualRegister(Use.getReg())) {
+ if (Use.isReg() && Use.getReg().isVirtual()) {
MachineInstr *DefInst = MRI->getVRegDef(Use.getReg());
if (DefInst->isPHI() && DefInst->getParent() == MI.getParent()) {
LLVM_DEBUG(dbgs() << " *** Cannot move this instruction ***\n");
MachineFunction *F = BB->getParent();
MachineRegisterInfo &RegInfo = F->getRegInfo();
Register incr = MI.getOperand(3).getReg();
- bool IsSignExtended = Register::isVirtualRegister(incr) &&
- isSignExtended(*RegInfo.getVRegDef(incr), TII);
+ bool IsSignExtended =
+ incr.isVirtual() && isSignExtended(*RegInfo.getVRegDef(incr), TII);
if (CmpOpcode == PPC::CMPW && !IsSignExtended) {
Register ValueReg = RegInfo.createVirtualRegister(&PPC::GPRCRegClass);
Register Reg = DefMO.getReg();
bool IsRegCR;
- if (Register::isVirtualRegister(Reg)) {
+ if (Reg.isVirtual()) {
const MachineRegisterInfo *MRI =
&DefMI.getParent()->getParent()->getRegInfo();
IsRegCR = MRI->getRegClass(Reg)->hasSuperClassEq(&PPC::CRRCRegClass) ||
auto IsAllOpsVirtualReg = [](const MachineInstr &Instr) {
for (const auto &MO : Instr.explicit_operands())
- if (!(MO.isReg() && Register::isVirtualRegister(MO.getReg())))
+ if (!(MO.isReg() && MO.getReg().isVirtual()))
return false;
return true;
};
IsUsedOnceR = true;
}
- if (!Register::isVirtualRegister(MULRegL) ||
- !Register::isVirtualRegister(MULRegR))
+ if (!MULRegL.isVirtual() || !MULRegR.isVirtual())
return false;
MULInstrL = MRI->getVRegDef(MULRegL);
if (!MO.isReg())
continue;
Register Reg = MO.getReg();
- if (Reg == 0 || !Register::isVirtualRegister(Reg))
+ if (Reg == 0 || !Reg.isVirtual())
continue;
// Find the toc address.
MachineInstr *DefMI = MRI->getVRegDef(Reg);
// If the conditional branch uses a physical register, then it cannot be
// turned into a select.
- if (Register::isPhysicalRegister(Cond[1].getReg()))
+ if (Cond[1].getReg().isPhysical())
return false;
// Check register classes.
if (!MI.getOperand(i).isReg())
continue;
Register Reg = MI.getOperand(i).getReg();
- if (!Register::isVirtualRegister(Reg))
+ if (!Reg.isVirtual())
continue;
Register TrueReg = TRI->lookThruCopyLike(Reg, MRI);
- if (Register::isVirtualRegister(TrueReg)) {
+ if (TrueReg.isVirtual()) {
MachineInstr *DefMIForTrueReg = MRI->getVRegDef(TrueReg);
if (DefMIForTrueReg->getOpcode() == PPC::LI ||
DefMIForTrueReg->getOpcode() == PPC::LI8 ||
MachineInstr **ToErase) const {
MachineRegisterInfo *MRI = &MI.getParent()->getParent()->getRegInfo();
Register FoldingReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(FoldingReg))
+ if (!FoldingReg.isVirtual())
return false;
MachineInstr *SrcMI = MRI->getVRegDef(FoldingReg);
if (SrcMI->getOpcode() != PPC::RLWINM &&
// If operand at III.ZeroIsSpecialNew is physical reg(eg: ZERO/ZERO8), no
// need to fix up register class.
Register RegToModify = MI.getOperand(III.ZeroIsSpecialNew).getReg();
- if (Register::isVirtualRegister(RegToModify)) {
+ if (RegToModify.isVirtual()) {
const TargetRegisterClass *NewRC =
MRI.getRegClass(RegToModify)->hasSuperClassEq(&PPC::GPRCRegClass) ?
&PPC::GPRC_and_GPRC_NOR0RegClass : &PPC::G8RC_and_G8RC_NOX0RegClass;
return nullptr;
Register Reg = Op->getReg();
- if (!Register::isVirtualRegister(Reg))
+ if (!Reg.isVirtual())
return nullptr;
return MRI->getVRegDef(Reg);
for (unsigned PHIOp = 1, NumOps = VisitedPHI->getNumOperands();
PHIOp != NumOps; PHIOp += 2) {
Register RegOp = VisitedPHI->getOperand(PHIOp).getReg();
- if (!Register::isVirtualRegister(RegOp))
+ if (!RegOp.isVirtual())
return false;
MachineInstr *Instr = MRI->getVRegDef(RegOp);
// While collecting the PHI nodes, we check if they can be converted (i.e.
unsigned Opcode = Instr->getOpcode();
if (Opcode == PPC::COPY) {
Register Reg = Instr->getOperand(1).getReg();
- if (!Register::isVirtualRegister(Reg) ||
- MRI->getRegClass(Reg) != &PPC::ACCRCRegClass)
+ if (!Reg.isVirtual() || MRI->getRegClass(Reg) != &PPC::ACCRCRegClass)
return false;
} else if (Opcode != PPC::IMPLICIT_DEF && Opcode != PPC::PHI)
return false;
case PPC::COPY: {
Register Src = MI.getOperand(1).getReg();
Register Dst = MI.getOperand(0).getReg();
- if (!Register::isVirtualRegister(Src) ||
- !Register::isVirtualRegister(Dst))
+ if (!Src.isVirtual() || !Dst.isVirtual())
break;
if (MRI->getRegClass(Src) != &PPC::UACCRCRegClass ||
MRI->getRegClass(Dst) != &PPC::ACCRCRegClass)
Register TrueReg2 =
TRI->lookThruCopyLike(MI.getOperand(2).getReg(), MRI);
- if (!(TrueReg1 == TrueReg2 && Register::isVirtualRegister(TrueReg1)))
+ if (!(TrueReg1 == TrueReg2 && TrueReg1.isVirtual()))
break;
MachineInstr *DefMI = MRI->getVRegDef(TrueReg1);
return false;
Register FeedReg1 =
TRI->lookThruCopyLike(DefMI->getOperand(1).getReg(), MRI);
- if (Register::isVirtualRegister(FeedReg1)) {
+ if (FeedReg1.isVirtual()) {
MachineInstr *LoadMI = MRI->getVRegDef(FeedReg1);
if (LoadMI && LoadMI->getOpcode() == PPC::LXVDSX)
return true;
Register FeedReg1 = TRI->lookThruCopyLike(DefReg1, MRI);
Register FeedReg2 = TRI->lookThruCopyLike(DefReg2, MRI);
- if (!(FeedReg1 == FeedReg2 &&
- Register::isVirtualRegister(FeedReg1)))
+ if (!(FeedReg1 == FeedReg2 && FeedReg1.isVirtual()))
break;
}
unsigned OpNo = MyOpcode == PPC::XXSPLTW ? 1 : 2;
Register TrueReg =
TRI->lookThruCopyLike(MI.getOperand(OpNo).getReg(), MRI);
- if (!Register::isVirtualRegister(TrueReg))
+ if (!TrueReg.isVirtual())
break;
MachineInstr *DefMI = MRI->getVRegDef(TrueReg);
if (!DefMI)
if (DefOpcode != PPC::XVCVSPSXWS && DefOpcode != PPC::XVCVSPUXWS)
return false;
Register ConvReg = DefMI->getOperand(1).getReg();
- if (!Register::isVirtualRegister(ConvReg))
+ if (!ConvReg.isVirtual())
return false;
MachineInstr *Splt = MRI->getVRegDef(ConvReg);
return Splt && (Splt->getOpcode() == PPC::LXVWSX ||
// If this is a DP->SP conversion fed by an FRSP, the FRSP is redundant.
Register TrueReg =
TRI->lookThruCopyLike(MI.getOperand(1).getReg(), MRI);
- if (!Register::isVirtualRegister(TrueReg))
+ if (!TrueReg.isVirtual())
break;
MachineInstr *DefMI = MRI->getVRegDef(TrueReg);
TRI->lookThruCopyLike(DefMI->getOperand(1).getReg(), MRI);
Register DefsReg2 =
TRI->lookThruCopyLike(DefMI->getOperand(2).getReg(), MRI);
- if (!Register::isVirtualRegister(DefsReg1) ||
- !Register::isVirtualRegister(DefsReg2))
+ if (!DefsReg1.isVirtual() || !DefsReg2.isVirtual())
break;
MachineInstr *P1 = MRI->getVRegDef(DefsReg1);
MachineInstr *P2 = MRI->getVRegDef(DefsReg2);
case PPC::EXTSH8_32_64: {
if (!EnableSExtElimination) break;
Register NarrowReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(NarrowReg))
+ if (!NarrowReg.isVirtual())
break;
MachineInstr *SrcMI = MRI->getVRegDef(NarrowReg);
case PPC::EXTSW_32_64: {
if (!EnableSExtElimination) break;
Register NarrowReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(NarrowReg))
+ if (!NarrowReg.isVirtual())
break;
MachineInstr *SrcMI = MRI->getVRegDef(NarrowReg);
break;
Register SrcReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(SrcReg))
+ if (!SrcReg.isVirtual())
break;
MachineInstr *SrcMI = MRI->getVRegDef(SrcReg);
SrcMI = SubRegMI;
if (SubRegMI->getOpcode() == PPC::COPY) {
Register CopyReg = SubRegMI->getOperand(1).getReg();
- if (Register::isVirtualRegister(CopyReg))
+ if (CopyReg.isVirtual())
SrcMI = MRI->getVRegDef(CopyReg);
}
if (!SrcMI->getOperand(0).isReg())
(*BII).getOperand(1).isReg()) {
// We optimize only if the condition code is used only by one BCC.
Register CndReg = (*BII).getOperand(1).getReg();
- if (!Register::isVirtualRegister(CndReg) || !MRI->hasOneNonDBGUse(CndReg))
+ if (!CndReg.isVirtual() || !MRI->hasOneNonDBGUse(CndReg))
return false;
MachineInstr *CMPI = MRI->getVRegDef(CndReg);
// We skip this BB if a physical register is used in comparison.
for (MachineOperand &MO : CMPI->operands())
- if (MO.isReg() && !Register::isVirtualRegister(MO.getReg()))
+ if (MO.isReg() && !MO.getReg().isVirtual())
return false;
return true;
return false;
Register SrcReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(SrcReg))
+ if (!SrcReg.isVirtual())
return false;
MachineInstr *SrcMI = MRI->getVRegDef(SrcReg);
return false;
Register SrcReg = MI.getOperand(1).getReg();
- if (!Register::isVirtualRegister(SrcReg))
+ if (!SrcReg.isVirtual())
return false;
MachineInstr *SrcMI = MRI->getVRegDef(SrcReg);
assert(SrcMI->getNumOperands() == 2 && "EXTSW should have 2 operands");
assert(SrcMI->getOperand(1).isReg() &&
"EXTSW's second operand should be a register");
- if (!Register::isVirtualRegister(SrcMI->getOperand(1).getReg()))
+ if (!SrcMI->getOperand(1).getReg().isVirtual())
return false;
LLVM_DEBUG(dbgs() << "Combining pair: ");
if (!RA.isReg())
return true;
- return Register::isVirtualRegister(RA.getReg()) ||
- (RA.getReg() != PPC::ZERO && RA.getReg() != PPC::ZERO8);
+ return RA.getReg().isVirtual() ||
+ (RA.getReg() != PPC::ZERO && RA.getReg() != PPC::ZERO8);
}
// [addis rt,ra,si - ld rt,ds(ra)] etc.
case FusionFeature::FK_AddisLoad: {
return true;
// Only check it for non-virtual register.
- if (!Register::isVirtualRegister(RT.getReg()))
+ if (!RT.getReg().isVirtual())
// addis(rt) = ld(ra) = ld(rt)
// ld(rt) cannot be zero
if (!matchingRegOps(SecondMI, 0, SecondMI, 2) ||
// { ld,ldx } - cmpli 0,1,rx,{ 0,1 }
case FusionFeature::FK_LoadCmp2: {
const MachineOperand &BT = SecondMI.getOperand(0);
- if (!BT.isReg() ||
- (!Register::isVirtualRegister(BT.getReg()) && BT.getReg() != PPC::CR0))
+ if (!BT.isReg() || (!BT.getReg().isVirtual() && BT.getReg() != PPC::CR0))
return false;
if (SecondMI.getOpcode() == PPC::CMPDI &&
matchingImmOps(SecondMI, 2, -1, 16))
// { lha,lhax,lwa,lwax } - cmpi 0,L,rx,{ 0,1,-1 }
case FusionFeature::FK_LoadCmp3: {
const MachineOperand &BT = SecondMI.getOperand(0);
- if (!BT.isReg() ||
- (!Register::isVirtualRegister(BT.getReg()) && BT.getReg() != PPC::CR0))
+ if (!BT.isReg() || (!BT.getReg().isVirtual() && BT.getReg() != PPC::CR0))
return false;
return matchingImmOps(SecondMI, 2, 0) || matchingImmOps(SecondMI, 2, 1) ||
matchingImmOps(SecondMI, 2, -1, 16);
return Copy;
Register CopySrc = Copy->getOperand(1).getReg();
Subreg = Copy->getOperand(1).getSubReg();
- if (!Register::isVirtualRegister(CopySrc)) {
+ if (!CopySrc.isVirtual()) {
const TargetRegisterInfo *TRI = &TII->getRegisterInfo();
// Set the Subreg
if (CopySrc == PPC::CR0EQ || CopySrc == PPC::CR6EQ)
case TargetOpcode::COPY: {
ResultOp = &Use.getOperand(0);
ResultReg = ResultOp->getReg();
- if (Register::isVirtualRegister(ResultReg) &&
+ if (ResultReg.isVirtual() &&
MRI->getRegClass(ResultReg)->contains(PPC::UACC0) &&
VRM->hasPhys(ResultReg)) {
Register UACCPhys = VRM->getPhys(ResultReg);
continue;
Register AddendSrcReg = AddendMI->getOperand(1).getReg();
- if (Register::isVirtualRegister(AddendSrcReg)) {
+ if (AddendSrcReg.isVirtual()) {
if (MRI.getRegClass(AddendMI->getOperand(0).getReg()) !=
MRI.getRegClass(AddendSrcReg))
continue;
// legality checks above, the live range for the addend source register
// could be extended), but it seems likely that such a trivial copy can
// be coalesced away later, and thus is not worth the effort.
- if (Register::isVirtualRegister(AddendSrcReg) &&
+ if (AddendSrcReg.isVirtual() &&
!LIS->getInterval(AddendSrcReg).liveAt(FMAIdx))
continue;
if (!isVecReg(Reg) && !isScalarVecReg(Reg))
continue;
- if (!Register::isVirtualRegister(Reg)) {
+ if (!Reg.isVirtual()) {
if (!(MI->isCopy() && isScalarVecReg(Reg)))
SwapVector[EntryIdx].MentionsPhysVR = 1;
continue;
const TargetRegisterClass *RC = TRI->getRegClass(MCOI.RegClass);
if (RC == &SystemZ::VR32BitRegClass || RC == &SystemZ::VR64BitRegClass) {
Register Reg = MI.getOperand(I).getReg();
- Register PhysReg = Register::isVirtualRegister(Reg)
+ Register PhysReg = Reg.isVirtual()
? (VRM ? Register(VRM->getPhys(Reg)) : Register())
: Reg;
if (!PhysReg ||
else {
Register DstReg = MI.getOperand(0).getReg();
Register DstPhys =
- (Register::isVirtualRegister(DstReg) ? Register(VRM->getPhys(DstReg))
- : DstReg);
+ (DstReg.isVirtual() ? Register(VRM->getPhys(DstReg)) : DstReg);
Register SrcReg = (OpNum == 2 ? MI.getOperand(1).getReg()
: ((OpNum == 1 && MI.isCommutable())
? MI.getOperand(2).getReg()
: Register()));
if (DstPhys && !SystemZ::GRH32BitRegClass.contains(DstPhys) && SrcReg &&
- Register::isVirtualRegister(SrcReg) &&
- DstPhys == VRM->getPhys(SrcReg))
+ SrcReg.isVirtual() && DstPhys == VRM->getPhys(SrcReg))
NeedsCommute = (OpNum == 1);
else
return nullptr;
// Constrain the register classes if converted from a vector opcode. The
// allocated regs are in an FP reg-class per previous check above.
for (const MachineOperand &MO : MIB->operands())
- if (MO.isReg() && Register::isVirtualRegister(MO.getReg())) {
+ if (MO.isReg() && MO.getReg().isVirtual()) {
Register Reg = MO.getReg();
if (MRI.getRegClass(Reg) == &SystemZ::VR32BitRegClass)
MRI.setRegClass(Reg, &SystemZ::FP32BitRegClass);
auto tryAddHint = [&](const MachineOperand *MO) -> void {
Register Reg = MO->getReg();
- Register PhysReg = Register::isPhysicalRegister(Reg)
- ? Reg
- : Register(VRM->getPhys(Reg));
+ Register PhysReg =
+ Reg.isPhysical() ? Reg : Register(VRM->getPhys(Reg));
if (PhysReg) {
if (MO->getSubReg())
PhysReg = getSubReg(PhysReg, MO->getSubReg());
MEE++;
for (; MII != MEE; ++MII) {
for (const MachineOperand &MO : MII->operands())
- if (MO.isReg() && Register::isPhysicalRegister(MO.getReg())) {
+ if (MO.isReg() && MO.getReg().isPhysical()) {
for (MCSuperRegIterator SI(MO.getReg(), this, true/*IncludeSelf*/);
SI.isValid(); ++SI)
if (NewRC->contains(*SI)) {
if (!MO.isReg() || MO.isImplicit() || !MO.isDef())
return false;
Register Reg = MO.getReg();
- return Register::isVirtualRegister(Reg) && MFI.isVRegStackified(Reg);
+ return Reg.isVirtual() && MFI.isVRegStackified(Reg);
}
bool WebAssembly::mayThrow(const MachineInstr &MI) {
std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
Register RegNo = MO.getReg();
- assert(Register::isVirtualRegister(RegNo) &&
+ assert(RegNo.isVirtual() &&
"Unlowered physical register encountered during assembly printing");
assert(!MFI->isVRegStackified(RegNo));
unsigned WAReg = MFI->getWAReg(RegNo);
for (auto &MI : Split) {
for (auto &MO : MI.explicit_uses()) {
- if (!MO.isReg() || Register::isPhysicalRegister(MO.getReg()))
+ if (!MO.isReg() || MO.getReg().isPhysical())
continue;
if (MachineInstr *Def = MRI.getUniqueVRegDef(MO.getReg()))
if (Def->getParent() == &MBB)
!Insert->readsRegister(Reg))
continue;
- if (Register::isPhysicalRegister(Reg)) {
+ if (Reg.isPhysical()) {
// Ignore ARGUMENTS; it's just used to keep the ARGUMENT_* instructions
// from moving down, and we've already checked for that.
if (Reg == WebAssembly::ARGUMENTS)
if (!MO.isReg())
return false;
Register DefReg = MO.getReg();
- if (!Register::isVirtualRegister(DefReg) ||
- !MFI.isVRegStackified(DefReg))
+ if (!DefReg.isVirtual() || !MFI.isVRegStackified(DefReg))
return false;
assert(MRI.hasOneNonDBGUse(DefReg));
const MachineOperand &NewUse = *MRI.use_nodbg_begin(DefReg);
assert(Use.isUse() && "explicit_uses() should only iterate over uses");
assert(!Use.isImplicit() &&
"explicit_uses() should only iterate over explicit operands");
- if (Register::isPhysicalRegister(Reg))
+ if (Reg.isPhysical())
continue;
// Identify the definition for this register at this point.
MachineOperand &OtherMO = MI.getOperand(3 - FIOperandNum);
if (OtherMO.isReg()) {
Register OtherMOReg = OtherMO.getReg();
- if (Register::isVirtualRegister(OtherMOReg)) {
+ if (OtherMOReg.isVirtual()) {
MachineInstr *Def = MF.getRegInfo().getUniqueVRegDef(OtherMOReg);
// TODO: For now we just opportunistically do this in the case where
// the CONST_I32/64 happens to have exactly one def and one use. We
// Physical registers will not be converted. Assume that converting the
// COPY to the destination domain will eventually result in a actual
// instruction.
- if (Register::isPhysicalRegister(MO.getReg()))
+ if (MO.getReg().isPhysical())
return 1;
RegDomain OpDomain = getDomain(MRI->getRegClass(MO.getReg()),
NewMI.add(VAStartPseudoInstr->getOperand(i + 1));
}
NewMI.addReg(VAStartPseudoInstr->getOperand(OpndIdx).getReg());
- assert(Register::isPhysicalRegister(
- VAStartPseudoInstr->getOperand(OpndIdx).getReg()));
+ assert(VAStartPseudoInstr->getOperand(OpndIdx).getReg().isPhysical());
}
// The original block will now fall through to the GuardedRegsBlk.
X86InstrInfo::getUndefRegClearance(const MachineInstr &MI, unsigned OpNum,
const TargetRegisterInfo *TRI) const {
const MachineOperand &MO = MI.getOperand(OpNum);
- if (Register::isPhysicalRegister(MO.getReg()) &&
- hasUndefRegUpdate(MI.getOpcode(), OpNum))
+ if (MO.getReg().isPhysical() && hasUndefRegUpdate(MI.getOpcode(), OpNum))
return UndefRegClearance;
return 0;
const MachineOperand &Op1 = MI.getOperand(1);
const MachineOperand &Op2 = MI.getOperand(3);
- assert(Op2.isReg() && (Op2.getReg() == X86::NoRegister ||
- Register::isPhysicalRegister(Op2.getReg())));
+ assert(Op2.isReg() &&
+ (Op2.getReg() == X86::NoRegister || Op2.getReg().isPhysical()));
// Omit situations like:
// %rsi = lea %rsi, 4, ...
static inline bool isIdenticalOp(const MachineOperand &MO1,
const MachineOperand &MO2) {
- return MO1.isIdenticalTo(MO2) &&
- (!MO1.isReg() || !Register::isPhysicalRegister(MO1.getReg()));
+ return MO1.isIdenticalTo(MO2) && (!MO1.isReg() || !MO1.getReg().isPhysical());
}
#ifndef NDEBUG
if (!MO.isReg() || !MO.isDef() || MO.isDead())
continue;
auto Reg = MO.getReg();
- if (Register::isPhysicalRegister(Reg))
+ if (Reg.isPhysical())
continue;
if (MRI->getRegClassOrRegBank(Reg) == RC && MRI->getType(Reg) == Ty &&
if (!MO.isReg() || !MO.isDef() || MO.isDead())
continue;
auto Reg = MO.getReg();
- if (Register::isPhysicalRegister(Reg))
+ if (Reg.isPhysical())
continue;
auto UI = MRI->use_begin(Reg);
auto UE = MRI->use_end();