Add a map

[oota-llvm.git] / lib / CodeGen / RegAlloc / PhyRegAlloc.h

diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.h b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
index c55f8e0009b086d86335f448c71444ba731364c9..e30cc8f9cc99e3aeabc58b667241020b07345a8b 100644 (file)
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.h
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
@@ -20,7 +20,7 @@
 #define PHY_REG_ALLOC_H
 
 #include "llvm/CodeGen/LiveRangeInfo.h"
-#include "Support/NonCopyable.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
 #include <map>
 
 class MachineFunction;
@@ -50,7 +50,7 @@ struct AddedInstrns {
 // registers for a Function.
 //----------------------------------------------------------------------------
 
-class PhyRegAlloc : public NonCopyable {
+class PhyRegAlloc {
   std::vector<RegClass *> RegClassList; // vector of register classes
   const TargetMachine &TM;              // target machine
   const Function *Fn;                   // name of the function we work on
@@ -61,15 +61,23 @@ class PhyRegAlloc : public NonCopyable {
   const TargetRegInfo &MRI;             // Machine Register information
   const unsigned NumOfRegClasses;       // recorded here for efficiency
 
+  // Map to indicate whether operands of each MachineInstr have been updated
+  // according to their assigned colors.  This is primarily for debugging and
+  // could be removed in the long run.
+  std::map<const MachineInstr *, bool> OperandsColoredMap;
   
   // AddedInstrMap - Used to store instrns added in this phase
   std::map<const MachineInstr *, AddedInstrns> AddedInstrMap;
 
+  // ScratchRegsUsed - Contains scratch register uses for a particular MI.
+  typedef std::multimap<const MachineInstr*, int> ScratchRegsUsedTy;
+  ScratchRegsUsedTy ScratchRegsUsed;
+
   AddedInstrns AddedInstrAtEntry;       // to store instrns added at entry
   LoopInfo *LoopDepthCalc;              // to calculate loop depths 
-  std::vector<unsigned> ResColList;     // A set of reserved regs if desired.
-                                        // currently not used
 
+  PhyRegAlloc(const PhyRegAlloc&);     // DO NOT IMPLEMENT
+  void operator=(const PhyRegAlloc&);  // DO NOT IMPLEMENT
 public:
   PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
               LoopInfo *LoopDepthCalc);
@@ -79,16 +87,15 @@ public:
   //
   void allocateRegisters();           
 
-
   // access to register classes by class ID
   // 
-  const RegClass*  getRegClassByID(unsigned int id) const {
-                                                    return RegClassList[id];
+  const RegClass* getRegClassByID(unsigned id) const {
+    return RegClassList[id];
   }
-        RegClass*  getRegClassByID(unsigned int id)       {
-                                                    return RegClassList[id]; }
-  
-  
+  RegClass* getRegClassByID(unsigned id) {
+    return RegClassList[id];
+  }
+
 private:
   void addInterference(const Value *Def, const ValueSet *LVSet, 
                       bool isCallInst);
@@ -97,45 +104,60 @@ private:
   void createIGNodeListsAndIGs();
   void buildInterferenceGraphs();
 
-  void setCallInterferences(const MachineInstr *MInst, 
-                           const ValueSet *LVSetAft );
+  void setCallInterferences(const MachineInstr *MI, 
+                           const ValueSet *LVSetAft);
 
   void move2DelayedInstr(const MachineInstr *OrigMI, 
-                        const MachineInstr *DelayedMI );
+                        const MachineInstr *DelayedMI);
 
   void markUnusableSugColors();
   void allocateStackSpace4SpilledLRs();
 
-  void insertCode4SpilledLR     (const LiveRange *LR, 
-                                 MachineInstr *MInst,
-                                 const BasicBlock *BB,
-                                 const unsigned OpNum);
+  void insertCode4SpilledLR(const LiveRange *LR, 
+                            MachineBasicBlock::iterator& MII,
+                            MachineBasicBlock &MBB, unsigned OpNum);
+
+  // Method for inserting caller saving code. The caller must save all the
+  // volatile registers live across a call.
+  void insertCallerSavingCode(std::vector<MachineInstr*>& instrnsBefore,
+                              std::vector<MachineInstr*>& instrnsAfter,
+                              MachineInstr *CallMI,
+                              const BasicBlock *BB);
 
   inline void constructLiveRanges() { LRI.constructLiveRanges(); }      
 
   void colorIncomingArgs();
   void colorCallRetArgs();
   void updateMachineCode();
+  void updateInstruction(MachineBasicBlock::iterator& MII,
+                         MachineBasicBlock &MBB);
 
-  void printLabel(const Value *const Val);
+  void printLabel(const Value *Val);
   void printMachineCode();
 
 
-  friend class UltraSparcRegInfo;  // FIXME: remove this
-
-  int getUsableUniRegAtMI(int RegType, 
-                         const ValueSet *LVSetBef,
-                         MachineInstr *MInst,
+  int getUsableUniRegAtMI(int RegType, const ValueSet *LVSetBef,
+                         MachineInstr *MI,
                           std::vector<MachineInstr*>& MIBef,
                           std::vector<MachineInstr*>& MIAft);
   
-  int getUnusedUniRegAtMI(RegClass *RC,  const MachineInstr *MInst, 
-                          const ValueSet *LVSetBef);
+  // Callback method used to find unused registers. 
+  // LVSetBef is the live variable set to search for an unused register.
+  // If it is not specified, the LV set before the current MI is used.
+  // This is sufficient as long as no new copy instructions are generated
+  // to copy the free register to memory.
+  // 
+  int getUnusedUniRegAtMI(RegClass *RC, int RegType,
+                          const MachineInstr *MI,
+                          const ValueSet *LVSetBef = 0);
+  
+  void setRelRegsUsedByThisInst(RegClass *RC, int RegType,
+                                const MachineInstr *MI);
 
-  void setRelRegsUsedByThisInst(RegClass *RC, const MachineInstr *MInst );
-  int getUniRegNotUsedByThisInst(RegClass *RC, const MachineInstr *MInst);
+  int getUniRegNotUsedByThisInst(RegClass *RC, int RegType,
+                                 const MachineInstr *MI);
 
-  void addInterf4PseudoInstr(const MachineInstr *MInst);
+  void addInterf4PseudoInstr(const MachineInstr *MI);
 };