X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FLiveVariables.h;h=866b981b394d8cead1851f1aeed8491f6dd85821;hb=a62e52ab181c10738066e65a6dcc6c3cdfa5d806;hp=50e4166f455927cdb514b81eaaa33d9d736e225b;hpb=71499ded4d76233f3b605638b539548bea8bb2f1;p=oota-llvm.git diff --git a/include/llvm/CodeGen/LiveVariables.h b/include/llvm/CodeGen/LiveVariables.h index 50e4166f455..866b981b394 100644 --- a/include/llvm/CodeGen/LiveVariables.h +++ b/include/llvm/CodeGen/LiveVariables.h @@ -1,12 +1,12 @@ //===-- llvm/CodeGen/LiveVariables.h - Live Variable Analysis ---*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// -// +// // This file implements the LiveVariable analysis pass. For each machine // instruction in the function, this pass calculates the set of registers that // are immediately dead after the instruction (i.e., the instruction calculates @@ -23,7 +23,7 @@ // to resolve physical register lifetimes in each basic block). If a physical // register is not register allocatable, it is not tracked. This is useful for // things like the stack pointer and condition codes. -// +// //===----------------------------------------------------------------------===// #ifndef LLVM_CODEGEN_LIVEVARIABLES_H @@ -39,8 +39,7 @@ class MRegisterInfo; class LiveVariables : public MachineFunctionPass { public: struct VarInfo { - /// DefBlock - The basic block which defines this value... - MachineBasicBlock *DefBlock; + /// DefInst - The machine instruction that defines this register. MachineInstr *DefInst; /// AliveBlocks - Set of blocks of which this value is alive completely @@ -49,25 +48,23 @@ public: /// std::vector AliveBlocks; - /// Kills - List of MachineBasicblock's which contain the last use of this - /// virtual register (kill it). This also includes the specific instruction - /// which kills the value. + /// Kills - List of MachineInstruction's which are the last use of this + /// virtual register (kill it) in their basic block. /// - std::vector > Kills; + std::vector Kills; - VarInfo() : DefBlock(0), DefInst(0) {} + VarInfo() : DefInst(0) {} /// removeKill - Delete a kill corresponding to the specified /// machine instruction. Returns true if there was a kill /// corresponding to this instruction, false otherwise. bool removeKill(MachineInstr *MI) { - for (std::vector >::iterator - i = Kills.begin(); i != Kills.end(); ++i) { - if (i->second == MI) { + for (std::vector::iterator i = Kills.begin(), + e = Kills.end(); i != e; ++i) + if (*i == MI) { Kills.erase(i); return true; } - } return false; } }; @@ -99,35 +96,22 @@ private: std::vector AllocatablePhysicalRegisters; private: // Intermediate data structures - - /// BBMap - Maps LLVM basic blocks to their corresponding machine basic block. - /// This also provides a numbering of the basic blocks in the function. - std::map > BBMap; - const MRegisterInfo *RegInfo; MachineInstr **PhysRegInfo; bool *PhysRegUsed; + void HandlePhysRegUse(unsigned Reg, MachineInstr *MI); + void HandlePhysRegDef(unsigned Reg, MachineInstr *MI); + public: virtual bool runOnMachineFunction(MachineFunction &MF); - /// getMachineBasicBlockIndex - Turn a MachineBasicBlock into an index number - /// suitable for use with VarInfo's. - /// - const std::pair - &getMachineBasicBlockInfo(MachineBasicBlock *MBB) const; - const std::pair - &getBasicBlockInfo(const BasicBlock *BB) const { - return BBMap.find(BB)->second; - } - - /// killed_iterator - Iterate over registers killed by a machine instruction /// typedef std::multimap::iterator killed_iterator; - + /// killed_begin/end - Get access to the range of registers killed by a /// machine instruction. killed_iterator killed_begin(MachineInstr *MI) { @@ -141,6 +125,16 @@ public: return RegistersKilled.equal_range(MI); } + /// KillsRegister - Return true if the specified instruction kills the + /// specified register. + bool KillsRegister(MachineInstr *MI, unsigned Reg) { + std::pair KIP = killed_range(MI); + for (; KIP.first != KIP.second; ++KIP.first) + if (KIP.first->second == Reg) + return true; + return false; + } + killed_iterator dead_begin(MachineInstr *MI) { return RegistersDead.lower_bound(MI); } @@ -155,15 +149,19 @@ public: //===--------------------------------------------------------------------===// // API to update live variable information + /// instructionChanged - When the address of an instruction changes, this + /// method should be called so that live variables can update its internal + /// data structures. This removes the records for OldMI, transfering them to + /// the records for NewMI. + void instructionChanged(MachineInstr *OldMI, MachineInstr *NewMI); + /// addVirtualRegisterKilled - Add information about the fact that the /// specified register is killed after being used by the specified /// instruction. /// - void addVirtualRegisterKilled(unsigned IncomingReg, - MachineBasicBlock *MBB, - MachineInstr *MI) { + void addVirtualRegisterKilled(unsigned IncomingReg, MachineInstr *MI) { RegistersKilled.insert(std::make_pair(MI, IncomingReg)); - getVarInfo(IncomingReg).Kills.push_back(std::make_pair(MBB, MI)); + getVarInfo(IncomingReg).Kills.push_back(MI); } /// removeVirtualRegisterKilled - Remove the specified virtual @@ -197,11 +195,9 @@ public: /// addVirtualRegisterDead - Add information about the fact that the specified /// register is dead after being used by the specified instruction. /// - void addVirtualRegisterDead(unsigned IncomingReg, - MachineBasicBlock *MBB, - MachineInstr *MI) { + void addVirtualRegisterDead(unsigned IncomingReg, MachineInstr *MI) { RegistersDead.insert(std::make_pair(MI, IncomingReg)); - getVarInfo(IncomingReg).Kills.push_back(std::make_pair(MBB, MI)); + getVarInfo(IncomingReg).Kills.push_back(MI); } /// removeVirtualRegisterDead - Remove the specified virtual @@ -239,22 +235,15 @@ public: VirtRegInfo.clear(); RegistersKilled.clear(); RegistersDead.clear(); - BBMap.clear(); } /// getVarInfo - Return the VarInfo structure for the specified VIRTUAL /// register. VarInfo &getVarInfo(unsigned RegIdx); - const std::vector& getAllocatablePhysicalRegisters() const { - return AllocatablePhysicalRegisters; - } - - void MarkVirtRegAliveInBlock(VarInfo &VRInfo, const BasicBlock *BB); + void MarkVirtRegAliveInBlock(VarInfo &VRInfo, MachineBasicBlock *BB); void HandleVirtRegUse(VarInfo &VRInfo, MachineBasicBlock *MBB, - MachineInstr *MI); - void HandlePhysRegUse(unsigned Reg, MachineInstr *MI); - void HandlePhysRegDef(unsigned Reg, MachineInstr *MI); + MachineInstr *MI); }; } // End llvm namespace