Do not use typeinfo to identify pass in pass manager.

[oota-llvm.git] / include / llvm / CodeGen / LiveVariables.h

diff --git a/include/llvm/CodeGen/LiveVariables.h b/include/llvm/CodeGen/LiveVariables.h
index 786a1fdc7060a3cf72b883b5023f6436a5cfcc1c..ce377cd2cfafb7e8394c173bd597b41fb1e77926 100644 (file)
--- a/include/llvm/CodeGen/LiveVariables.h
+++ b/include/llvm/CodeGen/LiveVariables.h
@@ -31,15 +31,18 @@
 
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/SmallVector.h"
 #include <map>
 
 namespace llvm {
 
 class MRegisterInfo;
-class BitVector;
 
 class LiveVariables : public MachineFunctionPass {
 public:
+  static const int ID; // Pass identifcation, replacement for typeid
+  LiveVariables() : MachineFunctionPass((intptr_t)&ID) {}
+
   /// VarInfo - This represents the regions where a virtual register is live in
   /// the program.  We represent this with three different pieces of
   /// information: the instruction that uniquely defines the value, the set of
@@ -79,12 +82,16 @@ public:
     ///
     BitVector AliveBlocks;
 
+    /// NumUses - Number of uses of this register across the entire function.
+    ///
+    unsigned NumUses;
+
     /// Kills - List of MachineInstruction's which are the last use of this
     /// virtual register (kill it) in their basic block.
     ///
     std::vector<MachineInstr*> Kills;
 
-    VarInfo() : DefInst(0) {}
+    VarInfo() : DefInst(0), NumUses(0) {}
 
     /// removeKill - Delete a kill corresponding to the specified
     /// machine instruction. Returns true if there was a kill
@@ -116,24 +123,45 @@ private:
   BitVector ReservedRegisters;
 
 private:   // Intermediate data structures
+  MachineFunction *MF;
+
   const MRegisterInfo *RegInfo;
 
+  // PhysRegInfo - Keep track of which instruction was the last def/use of a
+  // physical register. This is a purely local property, because all physical
+  // register references as presumed dead across basic blocks.
   MachineInstr **PhysRegInfo;
+
+  // PhysRegUsed - Keep track whether the physical register has been used after
+  // its last definition. This is local property.
   bool          *PhysRegUsed;
 
-  typedef std::map<const MachineBasicBlock*,
-                   std::vector<unsigned> > PHIVarInfoMap;
+  // PhysRegPartUse - Keep track of which instruction was the last partial use
+  // of a physical register (e.g. on X86 a def of EAX followed by a use of AX).
+  // This is a purely local property.
+  MachineInstr **PhysRegPartUse;
 
-  PHIVarInfoMap PHIVarInfo;
+  // PhysRegPartDef - Keep track of a list of instructions which "partially"
+  // defined the physical register (e.g. on X86 AX partially defines EAX).
+  // These are turned into use/mod/write if there is a use of the register
+  // later in the same block. This is local property.
+  SmallVector<MachineInstr*, 4> *PhysRegPartDef;
 
+  SmallVector<unsigned, 4> *PHIVarInfo;
 
   /// addRegisterKilled - We have determined MI kills a register. Look for the
-  /// operand that uses it and mark it as IsKill.
-  void addRegisterKilled(unsigned IncomingReg, MachineInstr *MI);
+  /// operand that uses it and mark it as IsKill. If AddIfNotFound is true,
+  /// add a implicit operand if it's not found. Returns true if the operand
+  /// exists / is added.
+  bool addRegisterKilled(unsigned IncomingReg, MachineInstr *MI,
+                         bool AddIfNotFound = false);
 
   /// addRegisterDead - We have determined MI defined a register without a use.
-  /// Look for the operand that defines it and mark it as IsDead. 
-  void addRegisterDead(unsigned IncomingReg, MachineInstr *MI);
+  /// Look for the operand that defines it and mark it as IsDead. If
+  /// AddIfNotFound is true, add a implicit operand if it's not found. Returns
+  /// true if the operand exists / is added.
+  bool addRegisterDead(unsigned IncomingReg, MachineInstr *MI,
+                       bool AddIfNotFound = false);
 
   void HandlePhysRegUse(unsigned Reg, MachineInstr *MI);
   void HandlePhysRegDef(unsigned Reg, MachineInstr *MI);
@@ -170,11 +198,12 @@ public:
 
   /// addVirtualRegisterKilled - Add information about the fact that the
   /// specified register is killed after being used by the specified
-  /// instruction.
-  ///
-  void addVirtualRegisterKilled(unsigned IncomingReg, MachineInstr *MI) {
-    addRegisterKilled(IncomingReg, MI);
-    getVarInfo(IncomingReg).Kills.push_back(MI); 
+  /// instruction. If AddIfNotFound is true, add a implicit operand if it's
+  /// not found.
+  void addVirtualRegisterKilled(unsigned IncomingReg, MachineInstr *MI,
+                                bool AddIfNotFound = false) {
+    if (addRegisterKilled(IncomingReg, MI, AddIfNotFound))
+      getVarInfo(IncomingReg).Kills.push_back(MI); 
  }
 
   /// removeVirtualRegisterKilled - Remove the specified virtual
@@ -206,11 +235,12 @@ public:
   void removeVirtualRegistersKilled(MachineInstr *MI);
   
   /// addVirtualRegisterDead - Add information about the fact that the specified
-  /// register is dead after being used by the specified instruction.
-  ///
-  void addVirtualRegisterDead(unsigned IncomingReg, MachineInstr *MI) {
-    addRegisterDead(IncomingReg, MI);
-    getVarInfo(IncomingReg).Kills.push_back(MI);
+  /// register is dead after being used by the specified instruction. If
+  /// AddIfNotFound is true, add a implicit operand if it's not found.
+  void addVirtualRegisterDead(unsigned IncomingReg, MachineInstr *MI,
+                              bool AddIfNotFound = false) {
+    if (addRegisterDead(IncomingReg, MI, AddIfNotFound))
+        getVarInfo(IncomingReg).Kills.push_back(MI);
   }
 
   /// removeVirtualRegisterDead - Remove the specified virtual