Typo.

[oota-llvm.git] / lib / CodeGen / VirtRegMap.h

diff --git a/lib/CodeGen/VirtRegMap.h b/lib/CodeGen/VirtRegMap.h
index 61ce92f621026e834ffbaa424eb4269c8bd3688a..f6d305e494f4773acb562d7a4bee7a85fd1364d7 100644 (file)
--- a/lib/CodeGen/VirtRegMap.h
+++ b/lib/CodeGen/VirtRegMap.h
@@ -25,14 +25,15 @@
 
 namespace llvm {
   class MachineInstr;
+  class MachineFunction;
   class TargetInstrInfo;
 
   class VirtRegMap {
   public:
     enum {
       NO_PHYS_REG = 0,
-      NO_STACK_SLOT = ~0 >> 1,
-      MAX_STACK_SLOT = (1 << 18)-1
+      NO_STACK_SLOT = (1L << 30)-1,
+      MAX_STACK_SLOT = (1L << 18)-1
     };
 
     enum ModRef { isRef = 1, isMod = 2, isModRef = 3 };
@@ -54,19 +55,20 @@ namespace llvm {
     /// which corresponds to the stack slot this register is spilled
     /// at.
     IndexedMap<int, VirtReg2IndexFunctor> Virt2StackSlotMap;
+    IndexedMap<int, VirtReg2IndexFunctor> Virt2ReMatIdMap;
     /// MI2VirtMap - This is MachineInstr to virtual register
     /// mapping. In the case of memory spill code being folded into
     /// instructions, we need to know which virtual register was
     /// read/written by this instruction.
     MI2VirtMapTy MI2VirtMap;
 
-    /// ReMatMap - This is irtual register to re-materialized instruction
+    /// ReMatMap - This is virtual register to re-materialized instruction
     /// mapping. Each virtual register whose definition is going to be
     /// re-materialized has an entry in it.
-    std::map<unsigned, const MachineInstr*> ReMatMap;
+    IndexedMap<MachineInstr*, VirtReg2IndexFunctor> ReMatMap;
 
     /// ReMatId - Instead of assigning a stack slot to a to be rematerialized
-    /// virtaul register, an unique id is being assinged. This keeps track of
+    /// virtual register, an unique id is being assigned. This keeps track of
     /// the highest id used so far. Note, this starts at (1<<18) to avoid
     /// conflicts with stack slot numbers.
     int ReMatId;
@@ -75,7 +77,7 @@ namespace llvm {
     void operator=(const VirtRegMap&); // DO NOT IMPLEMENT
 
   public:
-    VirtRegMap(MachineFunction &mf);
+    explicit VirtRegMap(MachineFunction &mf);
 
     void grow();
 
@@ -118,10 +120,11 @@ namespace llvm {
       grow();
     }
 
-    /// @brief returns true is the specified virtual register is
-    /// mapped to a stack slot
-    bool hasStackSlot(unsigned virtReg) const {
-      return getStackSlot(virtReg) != NO_STACK_SLOT;
+    /// @brief returns true is the specified virtual register is not
+    /// mapped to a stack slot or rematerialized.
+    bool isAssignedReg(unsigned virtReg) const {
+      return getStackSlot(virtReg) == NO_STACK_SLOT &&
+        getReMatId(virtReg) == NO_STACK_SLOT;
     }
 
     /// @brief returns the stack slot mapped to the specified virtual
@@ -131,6 +134,13 @@ namespace llvm {
       return Virt2StackSlotMap[virtReg];
     }
 
+    /// @brief returns the rematerialization id mapped to the specified virtual
+    /// register
+    int getReMatId(unsigned virtReg) const {
+      assert(MRegisterInfo::isVirtualRegister(virtReg));
+      return Virt2ReMatIdMap[virtReg];
+    }
+
     /// @brief create a mapping for the specifed virtual register to
     /// the next available stack slot
     int assignVirt2StackSlot(unsigned virtReg);
@@ -141,22 +151,26 @@ namespace llvm {
     /// @brief assign an unique re-materialization id to the specified
     /// virtual register.
     int assignVirtReMatId(unsigned virtReg);
+    /// @brief assign an unique re-materialization id to the specified
+    /// virtual register.
+    void assignVirtReMatId(unsigned virtReg, int id);
 
     /// @brief returns true if the specified virtual register is being
     /// re-materialized.
     bool isReMaterialized(unsigned virtReg) const {
-      return ReMatMap.count(virtReg) != 0;
+      return ReMatMap[virtReg] != NULL;
     }
 
     /// @brief returns the original machine instruction being re-issued
     /// to re-materialize the specified virtual register.
-    const MachineInstr *getReMaterializedMI(unsigned virtReg) {
+    MachineInstr *getReMaterializedMI(unsigned virtReg) const {
       return ReMatMap[virtReg];
     }
 
     /// @brief records the specified virtual register will be
     /// re-materialized and the original instruction which will be re-issed
-    /// for this purpose.
+    /// for this purpose.  If parameter all is true, then all uses of the
+    /// registers are rematerialized and it's safe to delete the definition.
     void setVirtIsReMaterialized(unsigned virtReg, MachineInstr *def) {
       ReMatMap[virtReg] = def;
     }
@@ -167,6 +181,10 @@ namespace llvm {
     void virtFolded(unsigned VirtReg, MachineInstr *OldMI, unsigned OpNum,
                     MachineInstr *NewMI);
 
+    /// @brief Updates information about the specified virtual register's value
+    /// folded into the specified machine instruction.
+    void virtFolded(unsigned VirtReg, MachineInstr *MI, ModRef MRInfo);
+
     /// @brief returns the virtual registers' values folded in memory
     /// operands of this instruction
     std::pair<MI2VirtMapTy::const_iterator, MI2VirtMapTy::const_iterator>