TargetInstrInfo::getNOPOpCode() has been replaced by a reference to V9::NOP.

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

diff --git a/lib/CodeGen/LiveIntervalAnalysis.h b/lib/CodeGen/LiveIntervalAnalysis.h
index 4e2cbeba0b003d6b92ac7a2d6b74a4d2e86eca64..e4e31ec24933da3a090527714d857f19e46fac73 100644 (file)
--- a/lib/CodeGen/LiveIntervalAnalysis.h
+++ b/lib/CodeGen/LiveIntervalAnalysis.h
@@ -22,7 +22,6 @@
 
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "LiveInterval.h"
-#include <list>
 
 namespace llvm {
 
@@ -30,17 +29,10 @@ namespace llvm {
     class MRegisterInfo;
     class VirtRegMap;
 
-    class LiveIntervals : public MachineFunctionPass
-    {
-    public:
-        typedef std::list<LiveInterval> Intervals;
-
-    private:
+    class LiveIntervals : public MachineFunctionPass {
         MachineFunction* mf_;
         const TargetMachine* tm_;
         const MRegisterInfo* mri_;
-        MachineBasicBlock* currentMbb_;
-        MachineBasicBlock::iterator currentInstr_;
         LiveVariables* lv_;
 
         typedef std::map<MachineInstr*, unsigned> Mi2IndexMap;
@@ -49,14 +41,12 @@ namespace llvm {
         typedef std::vector<MachineInstr*> Index2MiMap;
         Index2MiMap i2miMap_;
 
-        typedef std::map<unsigned, Intervals::iterator> Reg2IntervalMap;
+        typedef std::map<unsigned, LiveInterval> Reg2IntervalMap;
         Reg2IntervalMap r2iMap_;
 
         typedef std::map<unsigned, unsigned> Reg2RegMap;
         Reg2RegMap r2rMap_;
 
-        Intervals intervals_;
-
     public:
         struct InstrSlots
         {
@@ -88,30 +78,50 @@ namespace llvm {
             return getBaseIndex(index) + InstrSlots::STORE;
         }
 
-        virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-        virtual void releaseMemory();
+        // FIXME: this should really be a const_iterator
+        typedef Reg2IntervalMap::iterator iterator;
+        iterator begin() { return r2iMap_.begin(); }
+        iterator end() { return r2iMap_.end(); }
+        unsigned getNumIntervals() const { return r2iMap_.size(); }
 
-        /// runOnMachineFunction - pass entry point
-        virtual bool runOnMachineFunction(MachineFunction&);
+        LiveInterval &getInterval(unsigned reg) {
+          Reg2IntervalMap::iterator I = r2iMap_.find(reg);
+          assert(I != r2iMap_.end() && "Interval does not exist for register");
+          return I->second;
+        }
 
-        LiveInterval& getInterval(unsigned reg) {
-            assert(r2iMap_.count(reg)&& "Interval does not exist for register");
-            return *r2iMap_.find(reg)->second;
+        const LiveInterval &getInterval(unsigned reg) const {
+          Reg2IntervalMap::const_iterator I = r2iMap_.find(reg);
+          assert(I != r2iMap_.end() && "Interval does not exist for register");
+          return I->second;
         }
 
         /// getInstructionIndex - returns the base index of instr
-        unsigned getInstructionIndex(MachineInstr* instr) const;
+        unsigned getInstructionIndex(MachineInstr* instr) const {
+          Mi2IndexMap::const_iterator it = mi2iMap_.find(instr);
+          assert(it != mi2iMap_.end() && "Invalid instruction!");
+          return it->second;
+        }
 
         /// getInstructionFromIndex - given an index in any slot of an
         /// instruction return a pointer the instruction
-        MachineInstr* getInstructionFromIndex(unsigned index) const;
-
-        Intervals& getIntervals() { return intervals_; }
+        MachineInstr* getInstructionFromIndex(unsigned index) const {
+          index /= InstrSlots::NUM; // convert index to vector index
+          assert(index < i2miMap_.size() &&
+                 "index does not correspond to an instruction");
+          return i2miMap_[index];
+        }
 
         std::vector<LiveInterval*> addIntervalsForSpills(const LiveInterval& i,
                                                          VirtRegMap& vrm,
                                                          int slot);
 
+        virtual void getAnalysisUsage(AnalysisUsage &AU) const;
+        virtual void releaseMemory();
+
+        /// runOnMachineFunction - pass entry point
+        virtual bool runOnMachineFunction(MachineFunction&);
+
     private:
         /// computeIntervals - compute live intervals
         void computeIntervals();
@@ -142,14 +152,29 @@ namespace llvm {
                                        MachineBasicBlock::iterator mi,
                                        LiveInterval& interval);
 
-        bool overlapsAliases(const LiveInterval& lhs, 
-                             const LiveInterval& rhs) const;
+        /// Return true if the two specified registers belong to different
+        /// register classes.  The registers may be either phys or virt regs.
+        bool differingRegisterClasses(unsigned RegA, unsigned RegB) const;
 
+        bool overlapsAliases(const LiveInterval *lhs, 
+                             const LiveInterval *rhs) const;
 
-        LiveInterval& getOrCreateInterval(unsigned reg);
+        static LiveInterval createInterval(unsigned Reg);
+
+        LiveInterval &getOrCreateInterval(unsigned reg) {
+          Reg2IntervalMap::iterator I = r2iMap_.find(reg);
+          if (I == r2iMap_.end())
+            I = r2iMap_.insert(I, std::make_pair(reg, createInterval(reg)));
+          return I->second;
+        }
 
         /// rep - returns the representative of this register
-        unsigned rep(unsigned reg);
+        unsigned rep(unsigned reg) {
+          Reg2RegMap::iterator it = r2rMap_.find(reg);
+          if (it != r2rMap_.end())
+            return it->second = rep(it->second);
+          return reg;
+        }
 
         void printRegName(unsigned reg) const;
     };