Index: include/llvm/Target/TargetRegisterInfo.h =================================================================== --- include/llvm/Target/TargetRegisterInfo.h +++ include/llvm/Target/TargetRegisterInfo.h @@ -486,8 +486,14 @@ /// Returns a bitset indexed by physical register number indicating if a /// register is a special register that has particular uses and should be - /// considered unavailable at all times, e.g. SP, RA. This is - /// used by register scavenger to determine what registers are free. + /// considered unavailable at all times, e.g. stack pointer, return address. + /// A reserved register: + /// - is not allocatable + /// - is considered always live + /// - is ignored by liveness tracking + /// It is often necessary to reserve the super registers of a reserved + /// register as well, to avoid them getting allocated indirectly. You may use + /// markSuperRegs() and assertAllSuperRegsMarked() in this case. virtual BitVector getReservedRegs(const MachineFunction &MF) const = 0; /// Returns true if PhysReg is unallocatable and constant throughout the @@ -935,6 +941,14 @@ /// getFrameRegister - This method should return the register used as a base /// for values allocated in the current stack frame. virtual unsigned getFrameRegister(const MachineFunction &MF) const = 0; + + /// Mark a register and all its aliases as reserved in the given set. + void markSuperRegs(BitVector &RegisterSet, unsigned Reg) const; + + /// Returns true if for every register in the set all super registers are part + /// of the set as well. + void assertAllSuperRegsMarked(const BitVector &RegisterSet, + ArrayRef Exceptions = ArrayRef()) const; }; Index: lib/CodeGen/MachineVerifier.cpp =================================================================== --- lib/CodeGen/MachineVerifier.cpp +++ lib/CodeGen/MachineVerifier.cpp @@ -527,16 +527,6 @@ lastIndex = SlotIndex(); regsReserved = MRI->getReservedRegs(); - // A sub-register of a reserved register is also reserved - for (int Reg = regsReserved.find_first(); Reg>=0; - Reg = regsReserved.find_next(Reg)) { - for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) { - // FIXME: This should probably be: - // assert(regsReserved.test(*SubRegs) && "Non-reserved sub-register"); - regsReserved.set(*SubRegs); - } - } - markReachable(&MF->front()); // Build a set of the basic blocks in the function. Index: lib/CodeGen/TargetRegisterInfo.cpp =================================================================== --- lib/CodeGen/TargetRegisterInfo.cpp +++ lib/CodeGen/TargetRegisterInfo.cpp @@ -40,6 +40,37 @@ TargetRegisterInfo::~TargetRegisterInfo() {} +void TargetRegisterInfo::markSuperRegs(BitVector &RegisterSet, unsigned Reg) + const { + for (MCSuperRegIterator AI(Reg, this, true); AI.isValid(); ++AI) + RegisterSet.set(*AI); +} + +void TargetRegisterInfo::assertAllSuperRegsMarked(const BitVector &RegisterSet, + ArrayRef Exceptions) const { +#ifndef NDEBUG + // Check that all super registers of reserved regs are reserved as well. + BitVector Checked(getNumRegs()); + for (int Reg = RegisterSet.find_first(); Reg>=0; + Reg = RegisterSet.find_next(Reg)) { + if (Checked[Reg]) + continue; + for (MCSuperRegIterator SR(Reg, this); SR.isValid(); ++SR) { + if (!RegisterSet[*SR] && is_contained(Exceptions, *SR)) { + errs() << "Error: Super register " << PrintReg(*SR, this) + << " of reserved register " << PrintReg(Reg, this) + << " is not reserved.\n"; + report_fatal_error("Invalid register info."); + } + + // We transitively check superregs. So we can remember this for later + // to avoid compiletime explosion in deep register hierarchies. + Checked.set(*SR); + } + } +#endif +} + namespace llvm { Printable PrintReg(unsigned Reg, const TargetRegisterInfo *TRI, Index: lib/Target/AArch64/AArch64RegisterInfo.cpp =================================================================== --- lib/Target/AArch64/AArch64RegisterInfo.cpp +++ lib/Target/AArch64/AArch64RegisterInfo.cpp @@ -118,26 +118,27 @@ // FIXME: avoid re-calculating this every time. BitVector Reserved(getNumRegs()); - Reserved.set(AArch64::SP); - Reserved.set(AArch64::XZR); - Reserved.set(AArch64::WSP); - Reserved.set(AArch64::WZR); + markSuperRegs(Reserved, AArch64::SP); + markSuperRegs(Reserved, AArch64::XZR); + markSuperRegs(Reserved, AArch64::WSP); + markSuperRegs(Reserved, AArch64::WZR); if (TFI->hasFP(MF) || TT.isOSDarwin()) { - Reserved.set(AArch64::FP); - Reserved.set(AArch64::W29); + markSuperRegs(Reserved, AArch64::FP); + markSuperRegs(Reserved, AArch64::W29); } if (MF.getSubtarget().isX18Reserved()) { - Reserved.set(AArch64::X18); // Platform register - Reserved.set(AArch64::W18); + markSuperRegs(Reserved, AArch64::X18); // Platform register + markSuperRegs(Reserved, AArch64::W18); } if (hasBasePointer(MF)) { - Reserved.set(AArch64::X19); - Reserved.set(AArch64::W19); + markSuperRegs(Reserved, AArch64::X19); + markSuperRegs(Reserved, AArch64::W19); } + assertAllSuperRegsMarked(Reserved); return Reserved; } Index: lib/Target/ARM/ARMBaseRegisterInfo.cpp =================================================================== --- lib/Target/ARM/ARMBaseRegisterInfo.cpp +++ lib/Target/ARM/ARMBaseRegisterInfo.cpp @@ -167,27 +167,29 @@ // FIXME: avoid re-calculating this every time. BitVector Reserved(getNumRegs()); - Reserved.set(ARM::SP); - Reserved.set(ARM::PC); - Reserved.set(ARM::FPSCR); - Reserved.set(ARM::APSR_NZCV); + markSuperRegs(Reserved, ARM::SP); + markSuperRegs(Reserved, ARM::PC); + markSuperRegs(Reserved, ARM::FPSCR); + markSuperRegs(Reserved, ARM::APSR_NZCV); if (TFI->hasFP(MF)) - Reserved.set(getFramePointerReg(STI)); + markSuperRegs(Reserved, getFramePointerReg(STI)); if (hasBasePointer(MF)) - Reserved.set(BasePtr); + markSuperRegs(Reserved, BasePtr); // Some targets reserve R9. if (STI.isR9Reserved()) - Reserved.set(ARM::R9); + markSuperRegs(Reserved, ARM::R9); // Reserve D16-D31 if the subtarget doesn't support them. if (!STI.hasVFP3() || STI.hasD16()) { static_assert(ARM::D31 == ARM::D16 + 15, "Register list not consecutive!"); - Reserved.set(ARM::D16, ARM::D31 + 1); + for (unsigned R = 0; R < 16; ++R) + markSuperRegs(Reserved, ARM::D16 + R); } const TargetRegisterClass *RC = &ARM::GPRPairRegClass; for(TargetRegisterClass::iterator I = RC->begin(), E = RC->end(); I!=E; ++I) for (MCSubRegIterator SI(*I, this); SI.isValid(); ++SI) - if (Reserved.test(*SI)) Reserved.set(*I); + if (Reserved.test(*SI)) markSuperRegs(Reserved, *I); + assertAllSuperRegsMarked(Reserved); return Reserved; } Index: lib/Target/X86/X86RegisterInfo.cpp =================================================================== --- lib/Target/X86/X86RegisterInfo.cpp +++ lib/Target/X86/X86RegisterInfo.cpp @@ -558,6 +558,7 @@ } } + assertAllSuperRegsMarked(Reserved, {X86::SIL, X86::DIL, X86::BPL, X86::SPL}); return Reserved; }