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    TargetRegClass 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 TargetRegClass 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
  19 #ifndef PHY_REG_ALLOC_H
  20 #define PHY_REG_ALLOC_H
  21
  22 #include "llvm/CodeGen/LiveRangeInfo.h"
  23 #include "Support/NonCopyable.h"
  24 #include <map>
  25
  26 class MachineFunction;
  27 class TargetRegInfo;
  28 class FunctionLiveVarInfo;
  29 class MachineInstr;
  30 class LoopInfo;
  31 class RegClass;
  32
  33 //----------------------------------------------------------------------------
  34 // Class AddedInstrns:
  35 // When register allocator inserts new instructions in to the existing
  36 // instruction stream, it does NOT directly modify the instruction stream.
  37 // Rather, it creates an object of AddedInstrns and stick it in the
  38 // AddedInstrMap for an existing instruction. This class contains two vectors
  39 // to store such instructions added before and after an existing instruction.
  40 //----------------------------------------------------------------------------
  41
  42 struct AddedInstrns {
  43   std::vector<MachineInstr*> InstrnsBefore;//Insts added BEFORE an existing inst
  44   std::vector<MachineInstr*> InstrnsAfter; //Insts added AFTER an existing inst
  45 };
  46
  47 //----------------------------------------------------------------------------
  48 // class PhyRegAlloc:
  49 // Main class the register allocator. Call allocateRegisters() to allocate
  50 // registers for a Function.
  51 //----------------------------------------------------------------------------
  52
  53 class PhyRegAlloc : public NonCopyable {
  54   std::vector<RegClass *> RegClassList; // vector of register classes
  55   const TargetMachine &TM;              // target machine
  56   const Function *Fn;                   // name of the function we work on
  57   MachineFunction &MF;                  // descriptor for method's native code
  58   FunctionLiveVarInfo *const LVI;       // LV information for this method
  59                                         // (already computed for BBs)
  60   LiveRangeInfo LRI;                    // LR info  (will be computed)
  61   const TargetRegInfo &MRI;             // Machine Register information
  62   const unsigned NumOfRegClasses;       // recorded here for efficiency
  63
  64   // Map to indicate whether operands of each MachineInstr have been updated
  65   // according to their assigned colors.  This is primarily for debugging and
  66   // could be removed in the long run.
  67   std::map<const MachineInstr *, bool> OperandsColoredMap;
  68
  69   // AddedInstrMap - Used to store instrns added in this phase
  70   std::map<const MachineInstr *, AddedInstrns> AddedInstrMap;
  71
  72   AddedInstrns AddedInstrAtEntry;       // to store instrns added at entry
  73   LoopInfo *LoopDepthCalc;              // to calculate loop depths
  74   std::vector<unsigned> ResColList;     // A set of reserved regs if desired.
  75                                         // currently not used
  76
  77 public:
  78   PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
  79               LoopInfo *LoopDepthCalc);
  80   ~PhyRegAlloc();
  81
  82   // main method called for allocating registers
  83   //
  84   void allocateRegisters();
  85
  86
  87   // access to register classes by class ID
  88   //
  89   const RegClass*  getRegClassByID(unsigned int id) const {
  90                                                     return RegClassList[id];
  91   }
  92         RegClass*  getRegClassByID(unsigned int id)       {
  93                                                     return RegClassList[id]; }
  94
  95
  96 private:
  97   void addInterference(const Value *Def, const ValueSet *LVSet,
  98                        bool isCallInst);
  99
 100   void addInterferencesForArgs();
 101   void createIGNodeListsAndIGs();
 102   void buildInterferenceGraphs();
 103
 104   void setCallInterferences(const MachineInstr *MInst,
 105                             const ValueSet *LVSetAft );
 106
 107   void move2DelayedInstr(const MachineInstr *OrigMI,
 108                          const MachineInstr *DelayedMI );
 109
 110   void markUnusableSugColors();
 111   void allocateStackSpace4SpilledLRs();
 112
 113   void insertCode4SpilledLR     (const LiveRange *LR,
 114                                  MachineInstr *MInst,
 115                                  const BasicBlock *BB,
 116                                  const unsigned OpNum);
 117
 118   inline void constructLiveRanges() { LRI.constructLiveRanges(); }
 119
 120   void colorIncomingArgs();
 121   void colorCallRetArgs();
 122   void updateMachineCode();
 123   void updateInstruction(MachineInstr* MInst, BasicBlock* BB);
 124
 125   void printLabel(const Value *const Val);
 126   void printMachineCode();
 127
 128
 129   friend class UltraSparcRegInfo;  // FIXME: remove this
 130
 131   int getUsableUniRegAtMI(int RegType,
 132                           const ValueSet *LVSetBef,
 133                           MachineInstr *MInst,
 134                           std::vector<MachineInstr*>& MIBef,
 135                           std::vector<MachineInstr*>& MIAft);
 136
 137   int getUnusedUniRegAtMI(RegClass *RC,  const MachineInstr *MInst,
 138                           const ValueSet *LVSetBef);
 139
 140   void setRelRegsUsedByThisInst(RegClass *RC, const MachineInstr *MInst );
 141   int getUniRegNotUsedByThisInst(RegClass *RC, const MachineInstr *MInst);
 142
 143   void addInterf4PseudoInstr(const MachineInstr *MInst);
 144 };
 145
 146
 147 #endif
 148