[llvm-commits] [llvm] r48003 - in /llvm/trunk: include/llvm/CodeGen/RegisterScavenging.h lib/CodeGen/RegisterScavenging.cpp

[Evan Cheng]

On Mar 6, 2008, at 3:22 PM, Bill Wendling wrote:

> Author: void
> Date: Thu Mar  6 17:22:43 2008
> New Revision: 48003
>
> URL: http://llvm.org/viewvc/llvm-project?rev=48003&view=rev
> Log:
> When setting the "unused" info, take into account something like this:
>
>    %r3<def> = OR %x3<kill>, %x3
>
> We don't want to mark the %r3 as unused even though it's a sub- 
> register of %x3.
>
> Modified:
>    llvm/trunk/include/llvm/CodeGen/RegisterScavenging.h
>    llvm/trunk/lib/CodeGen/RegisterScavenging.cpp
>
> Modified: llvm/trunk/include/llvm/CodeGen/RegisterScavenging.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/RegisterScavenging.h?rev=48003&r1=48002&r2=48003&view=diff
>
> = 
> = 
> = 
> = 
> = 
> = 
> = 
> = 
> ======================================================================
> --- llvm/trunk/include/llvm/CodeGen/RegisterScavenging.h (original)
> +++ llvm/trunk/include/llvm/CodeGen/RegisterScavenging.h Thu Mar  6  
> 17:22:43 2008
> @@ -98,7 +98,7 @@
>   ///
>   void setUsed(unsigned Reg);
>   void setUsed(BitVector Regs)   { RegsAvailable &= ~Regs; }
> -  void setUnused(unsigned Reg);
> +  void setUnused(unsigned Reg, const MachineInstr *MI);
>   void setUnused(BitVector Regs) { RegsAvailable |= Regs; }
>
>   /// FindUnusedReg - Find a unused register of the specified  
> register class
>
> Modified: llvm/trunk/lib/CodeGen/RegisterScavenging.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/RegisterScavenging.cpp?rev=48003&r1=48002&r2=48003&view=diff
>
> = 
> = 
> = 
> = 
> = 
> = 
> = 
> = 
> ======================================================================
> --- llvm/trunk/lib/CodeGen/RegisterScavenging.cpp (original)
> +++ llvm/trunk/lib/CodeGen/RegisterScavenging.cpp Thu Mar  6  
> 17:22:43 2008
> @@ -8,9 +8,9 @@
> // 
> = 
> = 
> = 
> ----------------------------------------------------------------------= 
> ==//
> //
> // This file implements the machine register scavenger. It can provide
> -// information such as unused register at any point in a machine  
> basic block.
> -// It also provides a mechanism to make registers availbale by  
> evicting them
> -// to spill slots.
> +// information, such as unused registers, at any point in a machine  
> basic block.
> +// It also provides a mechanism to make registers available by  
> evicting them to
> +// spill slots.
> //
> // 
> = 
> = 
> = 
> ----------------------------------------------------------------------= 
> ==//
>
> @@ -25,6 +25,28 @@
> #include "llvm/ADT/STLExtras.h"
> using namespace llvm;
>
> +/// RedefinesSuperRegPart - Return true if the specified register  
> is redefining
> +/// part of a super-register.
> +static bool RedefinesSuperRegPart(const MachineInstr *MI, unsigned  
> SubReg,
> +                                  const TargetRegisterInfo *TRI) {
> +  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
> +    const MachineOperand &MO = MI->getOperand(i);
> +    if (!MO.isRegister() || !MO.isUse())
> +      continue;
> +    if (TRI->isSuperRegister(SubReg, MO.getReg()))
> +      return true;
> +  }
> +
> +  return false;
> +}
> +
> +static bool RedefinesSuperRegPart(const MachineInstr *MI,
> +                                  const MachineOperand &MO,
> +                                  const TargetRegisterInfo *TRI) {
> +  assert(MO.isRegister() && MO.isDef() && "Not a register def!");
> +  return RedefinesSuperRegPart(MI, MO.getReg(), TRI);
> +}
> +
> /// setUsed - Set the register and its sub-registers as being used.
> void RegScavenger::setUsed(unsigned Reg) {
>   RegsAvailable.reset(Reg);
> @@ -35,12 +57,13 @@
> }
>
> /// setUnused - Set the register and its sub-registers as being  
> unused.
> -void RegScavenger::setUnused(unsigned Reg) {
> +void RegScavenger::setUnused(unsigned Reg, const MachineInstr *MI) {
>   RegsAvailable.set(Reg);
>
>   for (const unsigned *SubRegs = TRI->getSubRegisters(Reg);
>        unsigned SubReg = *SubRegs; ++SubRegs)
> -    RegsAvailable.set(SubReg);
> +    if (!RedefinesSuperRegPart(MI, Reg, TRI))
> +      RegsAvailable.set(SubReg);
> }
>
> void RegScavenger::enterBasicBlock(MachineBasicBlock *mbb) {
> @@ -138,9 +161,12 @@
>     if (MO.isKill() && !isReserved(Reg)) {
>       ChangedRegs.set(Reg);
>
> +      // Mark sub-registers as changed if they aren't defined in  
> the same
> +      // instruction.
>       for (const unsigned *SubRegs = TRI->getSubRegisters(Reg);
>            unsigned SubReg = *SubRegs; ++SubRegs)
> -        ChangedRegs.set(SubReg);
> +        if (!RedefinesSuperRegPart(MI, Reg, TRI))

Why is this necessary? Something that kills a super-register also  
kills the sub-register.


>
> +          ChangedRegs.set(SubReg);
>     }
>   }
>
> @@ -159,7 +185,7 @@
>
>     // If it's dead upon def, then it is now free.
>     if (MO.isDead()) {
> -      setUnused(Reg);
> +      setUnused(Reg, MI);
>       continue;
>     }
>
> @@ -169,6 +195,10 @@
>       continue;
>     }
>
> +    // Skip is this is merely redefining part of a super-register.
> +    if (RedefinesSuperRegPart(MI, MO, TRI))
> +      continue;
> +
>     assert((isUnused(Reg) || isReserved(Reg)) &&
>            "Re-defining a live register!");
>     setUsed(Reg);
> @@ -194,7 +224,7 @@
>     unsigned Reg = MO.getReg();
>     assert(isUsed(Reg));
>     if (!isReserved(Reg))
> -      setUnused(Reg);
> +      setUnused(Reg, MI);

What about the sub-registers?

Evan

>
>   }
>
>   // Process uses.
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits