Convert indentation to 2 spaces.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15489 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 152 insertions, 152 deletions

diff --git a/include/llvm/CodeGen/LiveIntervalAnalysis.h b/include/llvm/CodeGen/LiveIntervalAnalysis.h
index e4e31ec249..de7cc8001f 100644
--- a/include/llvm/CodeGen/LiveIntervalAnalysis.h
+++ b/include/llvm/CodeGen/LiveIntervalAnalysis.h
@@ -25,160 +25,160 @@
 
 namespace llvm {
 
-    class LiveVariables;
-    class MRegisterInfo;
-    class VirtRegMap;
-
-    class LiveIntervals : public MachineFunctionPass {
-        MachineFunction* mf_;
-        const TargetMachine* tm_;
-        const MRegisterInfo* mri_;
-        LiveVariables* lv_;
-
-        typedef std::map<MachineInstr*, unsigned> Mi2IndexMap;
-        Mi2IndexMap mi2iMap_;
-
-        typedef std::vector<MachineInstr*> Index2MiMap;
-        Index2MiMap i2miMap_;
-
-        typedef std::map<unsigned, LiveInterval> Reg2IntervalMap;
-        Reg2IntervalMap r2iMap_;
-
-        typedef std::map<unsigned, unsigned> Reg2RegMap;
-        Reg2RegMap r2rMap_;
-
-    public:
-        struct InstrSlots
-        {
-            enum {
-                LOAD  = 0,
-                USE   = 1,
-                DEF   = 2,
-                STORE = 3,
-                NUM   = 4,
-            };
-        };
-
-        static unsigned getBaseIndex(unsigned index) {
-            return index - (index % InstrSlots::NUM);
-        }
-        static unsigned getBoundaryIndex(unsigned index) {
-            return getBaseIndex(index + InstrSlots::NUM - 1);
-        }
-        static unsigned getLoadIndex(unsigned index) {
-            return getBaseIndex(index) + InstrSlots::LOAD;
-        }
-        static unsigned getUseIndex(unsigned index) {
-            return getBaseIndex(index) + InstrSlots::USE;
-        }
-        static unsigned getDefIndex(unsigned index) {
-            return getBaseIndex(index) + InstrSlots::DEF;
-        }
-        static unsigned getStoreIndex(unsigned index) {
-            return getBaseIndex(index) + InstrSlots::STORE;
-        }
-
-        // 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(); }
-
-        LiveInterval &getInterval(unsigned reg) {
-          Reg2IntervalMap::iterator I = r2iMap_.find(reg);
-          assert(I != r2iMap_.end() && "Interval does not exist for register");
-          return I->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 {
-          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 {
-          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();
-
-        /// joinIntervals - join compatible live intervals
-        void joinIntervals();
-
-        /// joinIntervalsInMachineBB - Join intervals based on move
-        /// instructions in the specified basic block.
-        void joinIntervalsInMachineBB(MachineBasicBlock *MBB);
-
-        /// handleRegisterDef - update intervals for a register def
-        /// (calls handlePhysicalRegisterDef and
-        /// handleVirtualRegisterDef)
-        void handleRegisterDef(MachineBasicBlock* mbb,
-                               MachineBasicBlock::iterator mi,
-                               unsigned reg);
-
-        /// handleVirtualRegisterDef - update intervals for a virtual
-        /// register def
-        void handleVirtualRegisterDef(MachineBasicBlock* mbb,
-                                      MachineBasicBlock::iterator mi,
-                                      LiveInterval& interval);
-
-        /// handlePhysicalRegisterDef - update intervals for a
-        /// physical register def
-        void handlePhysicalRegisterDef(MachineBasicBlock* mbb,
-                                       MachineBasicBlock::iterator mi,
-                                       LiveInterval& interval);
-
-        /// 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;
-
-        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) {
-          Reg2RegMap::iterator it = r2rMap_.find(reg);
-          if (it != r2rMap_.end())
-            return it->second = rep(it->second);
-          return reg;
-        }
-
-        void printRegName(unsigned reg) const;
+  class LiveVariables;
+  class MRegisterInfo;
+  class VirtRegMap;
+
+  class LiveIntervals : public MachineFunctionPass {
+    MachineFunction* mf_;
+    const TargetMachine* tm_;
+    const MRegisterInfo* mri_;
+    LiveVariables* lv_;
+
+    typedef std::map<MachineInstr*, unsigned> Mi2IndexMap;
+    Mi2IndexMap mi2iMap_;
+
+    typedef std::vector<MachineInstr*> Index2MiMap;
+    Index2MiMap i2miMap_;
+
+    typedef std::map<unsigned, LiveInterval> Reg2IntervalMap;
+    Reg2IntervalMap r2iMap_;
+
+    typedef std::map<unsigned, unsigned> Reg2RegMap;
+    Reg2RegMap r2rMap_;
+
+  public:
+    struct InstrSlots
+    {
+      enum {
+        LOAD  = 0,
+        USE   = 1,
+        DEF   = 2,
+        STORE = 3,
+        NUM   = 4,
+      };
     };
 
+    static unsigned getBaseIndex(unsigned index) {
+      return index - (index % InstrSlots::NUM);
+    }
+    static unsigned getBoundaryIndex(unsigned index) {
+      return getBaseIndex(index + InstrSlots::NUM - 1);
+    }
+    static unsigned getLoadIndex(unsigned index) {
+      return getBaseIndex(index) + InstrSlots::LOAD;
+    }
+    static unsigned getUseIndex(unsigned index) {
+      return getBaseIndex(index) + InstrSlots::USE;
+    }
+    static unsigned getDefIndex(unsigned index) {
+      return getBaseIndex(index) + InstrSlots::DEF;
+    }
+    static unsigned getStoreIndex(unsigned index) {
+      return getBaseIndex(index) + InstrSlots::STORE;
+    }
+
+    // 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(); }
+
+    LiveInterval &getInterval(unsigned reg) {
+      Reg2IntervalMap::iterator I = r2iMap_.find(reg);
+      assert(I != r2iMap_.end() && "Interval does not exist for register");
+      return I->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 {
+      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 {
+      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();
+
+    /// joinIntervals - join compatible live intervals
+    void joinIntervals();
+
+    /// joinIntervalsInMachineBB - Join intervals based on move
+    /// instructions in the specified basic block.
+    void joinIntervalsInMachineBB(MachineBasicBlock *MBB);
+
+    /// handleRegisterDef - update intervals for a register def
+    /// (calls handlePhysicalRegisterDef and
+    /// handleVirtualRegisterDef)
+    void handleRegisterDef(MachineBasicBlock* mbb,
+                           MachineBasicBlock::iterator mi,
+                           unsigned reg);
+
+    /// handleVirtualRegisterDef - update intervals for a virtual
+    /// register def
+    void handleVirtualRegisterDef(MachineBasicBlock* mbb,
+                                  MachineBasicBlock::iterator mi,
+                                  LiveInterval& interval);
+
+    /// handlePhysicalRegisterDef - update intervals for a
+    /// physical register def
+    void handlePhysicalRegisterDef(MachineBasicBlock* mbb,
+                                   MachineBasicBlock::iterator mi,
+                                   LiveInterval& interval);
+
+    /// 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;
+
+    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) {
+      Reg2RegMap::iterator it = r2rMap_.find(reg);
+      if (it != r2rMap_.end())
+        return it->second = rep(it->second);
+      return reg;
+    }
+
+    void printRegName(unsigned reg) const;
+  };
+
 } // End llvm namespace
 
 #endif