// Definition for isSuperRegister. Put it down here since it needs the
// iterator defined above in addition to the MCRegisterInfo class itself.
inline bool MCRegisterInfo::isSuperRegister(MCRegister RegA, MCRegister RegB) const{
- for (MCPhysReg I : superregs(RegA))
- if (I == RegB)
- return true;
- return false;
+ return is_contained(superregs(RegA), RegB);
}
//===----------------------------------------------------------------------===//
if (MO.isRegMask()) {
auto ClobbersPhysRegAndSubRegs = [&](unsigned PhysReg) {
- for (MCPhysReg SR : TRI->subregs_inclusive(PhysReg))
- if (!MO.clobbersPhysReg(SR))
- return false;
-
- return true;
+ return all_of(TRI->subregs_inclusive(PhysReg),
+ [&](MCPhysReg SR) { return MO.clobbersPhysReg(SR); });
};
for (unsigned i = 0, e = TRI->getNumRegs(); i != e; ++i) {
MIB.addReg(Reg, RegState::Implicit | RegState::Define);
continue;
}
- if (LiveBeforeMI.count(Reg))
+ if (any_of(TRI->subregs_inclusive(Reg),
+ [&](MCPhysReg S) { return LiveBeforeMI.count(S); }))
MIB.addReg(Reg, RegState::Implicit);
- else {
- bool HasLiveSubReg = false;
- for (MCPhysReg S : TRI->subregs(Reg)) {
- if (!LiveBeforeMI.count(S))
- continue;
- HasLiveSubReg = true;
- break;
- }
- if (HasLiveSubReg)
- MIB.addReg(Reg, RegState::Implicit);
- }
}
}
if (MRI.isReserved(Reg))
continue;
// Skip the register if we are about to add one of its super registers.
- bool ContainsSuperReg = false;
- for (MCPhysReg SReg : TRI.superregs(Reg)) {
- if (LiveRegs.contains(SReg) && !MRI.isReserved(SReg)) {
- ContainsSuperReg = true;
- break;
- }
- }
- if (ContainsSuperReg)
+ if (any_of(TRI.superregs(Reg), [&](MCPhysReg SReg) {
+ return LiveRegs.contains(SReg) && !MRI.isReserved(SReg);
+ }))
continue;
MBB.addLiveIn(Reg);
}
bool MachineRegisterInfo::isReservedRegUnit(unsigned Unit) const {
const TargetRegisterInfo *TRI = getTargetRegisterInfo();
for (MCRegUnitRootIterator Root(Unit, TRI); Root.isValid(); ++Root) {
- bool IsRootReserved = true;
- for (MCPhysReg Super : TRI->superregs_inclusive(*Root)) {
- MCRegister Reg = Super;
- if (!isReserved(Reg)) {
- IsRootReserved = false;
- break;
- }
- }
- if (IsRootReserved)
+ if (all_of(TRI->superregs_inclusive(*Root),
+ [&](MCPhysReg Super) { return isReserved(Super); }))
return true;
}
return false;
// S1 is can be freely clobbered.
// Ideally we would like a way to model this, but leaving the
// insert_subreg around causes both correctness and performance issues.
- bool SubUsed = false;
- for (const MCPhysReg &SubReg : TRI->subregs(Reg))
- if (isRegUsed(SubReg)) {
- SubUsed = true;
- break;
- }
- bool SuperUsed = false;
- for (MCPhysReg SR : TRI->superregs(Reg)) {
- if (isRegUsed(SR)) {
- SuperUsed = true;
- break;
- }
- }
- if (!SubUsed && !SuperUsed) {
+ if (none_of(TRI->subregs(Reg),
+ [&](MCPhysReg SR) { return isRegUsed(SR); }) &&
+ none_of(TRI->superregs(Reg),
+ [&](MCPhysReg SR) { return isRegUsed(SR); })) {
MBB->getParent()->verify(nullptr, "In Register Scavenger");
llvm_unreachable("Using an undefined register!");
}
- (void)SubUsed;
- (void)SuperUsed;
}
} else {
assert(MO.isDef());
/// Go up the super-register chain until we hit a valid dwarf register number.
static unsigned getDwarfRegNum(unsigned Reg, const TargetRegisterInfo *TRI) {
- int RegNum = TRI->getDwarfRegNum(Reg, false);
- for (MCPhysReg SR : TRI->superregs(Reg)) {
+ int RegNum;
+ for (MCPhysReg SR : TRI->superregs_inclusive(Reg)) {
+ RegNum = TRI->getDwarfRegNum(SR, false);
if (RegNum >= 0)
break;
- RegNum = TRI->getDwarfRegNum(SR, false);
}
assert(RegNum >= 0 && "Invalid Dwarf register number.");