lib/CodeGen/RegAlloc/PhyRegAlloc.h

   1 /* Title:   PhyRegAlloc.h   -*- C++ -*-
   2    Author:  Ruchira Sasanka
   3    Date:    Aug 20, 01
   4    Purpose: This is the main entry point for register allocation.
   5
   6    Notes:
   7    =====
   8
   9  * RegisterClasses: Each RegClass accepts a
  10    MachineRegClass which contains machine specific info about that register
  11    class. The code in the RegClass is machine independent and they use
  12    access functions in the MachineRegClass object passed into it to get
  13    machine specific info.
  14
  15  * Machine dependent work: All parts of the register coloring algorithm
  16    except coloring of an individual node are machine independent.
  17
  18    Register allocation must be done  as:
  19
  20       MethodLiveVarInfo LVI(*MethodI );           // compute LV info
  21       LVI.analyze();
  22
  23       TargetMachine &target = ....
  24
  25
  26       PhyRegAlloc PRA(*MethodI, target, &LVI);     // allocate regs
  27       PRA.allocateRegisters();
  28
  29
  30
  31 */
  32
  33 #ifndef PHY_REG_ALLOC_H
  34 #define PHY_REG_ALLOC_H
  35
  36 #include "llvm/CodeGen/MachineInstr.h"
  37 #include "llvm/CodeGen/RegClass.h"
  38 #include "llvm/CodeGen/LiveRangeInfo.h"
  39 #include "llvm/Analysis/LiveVar/MethodLiveVarInfo.h"
  40 #include "llvm/Analysis/LoopDepth.h"
  41
  42 #include <deque>
  43
  44
  45 //----------------------------------------------------------------------------
  46 // Class AddedInstrns:
  47 // When register allocator inserts new instructions in to the existing
  48 // instruction stream, it does NOT directly modify the instruction stream.
  49 // Rather, it creates an object of AddedInstrns and stick it in the
  50 // AddedInstrMap for an existing instruction. This class contains two vectors
  51 // to store such instructions added before and after an existing instruction.
  52 //----------------------------------------------------------------------------
  53
  54 class AddedInstrns
  55 {
  56  public:
  57   std::deque<MachineInstr*> InstrnsBefore;// Added insts BEFORE an existing inst
  58   std::deque<MachineInstr*> InstrnsAfter; // Added insts AFTER an existing inst
  59 };
  60
  61 typedef std::hash_map<const MachineInstr *, AddedInstrns *> AddedInstrMapType;
  62
  63
  64
  65 //----------------------------------------------------------------------------
  66 // class PhyRegAlloc:
  67 // Main class the register allocator. Call allocateRegisters() to allocate
  68 // registers for a Method.
  69 //----------------------------------------------------------------------------
  70
  71
  72 class PhyRegAlloc: public NonCopyable
  73 {
  74
  75   std::vector<RegClass *> RegClassList; // vector of register classes
  76   const TargetMachine &TM;              // target machine
  77   const Method* Meth;                   // name of the method we work on
  78   MachineCodeForMethod& mcInfo;         // descriptor for method's native code
  79   MethodLiveVarInfo *const LVI;         // LV information for this method
  80                                         // (already computed for BBs)
  81   LiveRangeInfo LRI;                    // LR info  (will be computed)
  82   const MachineRegInfo &MRI;            // Machine Register information
  83   const unsigned NumOfRegClasses;       // recorded here for efficiency
  84
  85
  86   AddedInstrMapType AddedInstrMap;      // to store instrns added in this phase
  87   cfg::LoopDepthCalculator LoopDepthCalc;    // to calculate loop depths
  88   ReservedColorListType ResColList;     // A set of reserved regs if desired.
  89                                         // currently not used
  90
  91
  92
  93   //------- ------------------ private methods---------------------------------
  94
  95   void addInterference(const Value *const Def, const LiveVarSet *const LVSet,
  96                        const bool isCallInst);
  97
  98   void addInterferencesForArgs();
  99   void createIGNodeListsAndIGs();
 100   void buildInterferenceGraphs();
 101
 102   void setCallInterferences(const MachineInstr *MInst,
 103                             const LiveVarSet *const LVSetAft );
 104
 105   void move2DelayedInstr(const MachineInstr *OrigMI,
 106                          const MachineInstr *DelayedMI );
 107
 108   void markUnusableSugColors();
 109   void allocateStackSpace4SpilledLRs();
 110
 111   void insertCode4SpilledLR     (const LiveRange *LR,
 112                                  MachineInstr *MInst,
 113                                  const BasicBlock *BB,
 114                                  const unsigned OpNum);
 115
 116   inline void constructLiveRanges() { LRI.constructLiveRanges(); }
 117
 118   void colorIncomingArgs();
 119   void colorCallRetArgs();
 120   void updateMachineCode();
 121
 122   void printLabel(const Value *const Val);
 123   void printMachineCode();
 124
 125   friend class UltraSparcRegInfo;
 126
 127
 128   int getUsableUniRegAtMI(RegClass *RC,  const int RegType,
 129                           const MachineInstr *MInst,
 130                           const LiveVarSet *LVSetBef, MachineInstr *MIBef,
 131                           MachineInstr *MIAft );
 132
 133   int getUnusedUniRegAtMI(RegClass *RC,  const MachineInstr *MInst,
 134                        const LiveVarSet *LVSetBef);
 135
 136   void setRelRegsUsedByThisInst(RegClass *RC, const MachineInstr *MInst );
 137   int getUniRegNotUsedByThisInst(RegClass *RC, const MachineInstr *MInst);
 138
 139   void addInterf4PseudoInstr(const MachineInstr *MInst);
 140
 141  public:
 142   PhyRegAlloc(Method *const M, const TargetMachine& TM,
 143               MethodLiveVarInfo *const Lvi);
 144   ~PhyRegAlloc();
 145
 146   // main method called for allocating registers
 147   //
 148   void allocateRegisters();
 149
 150 };
 151
 152
 153 #endif
 154