lib/Target/CellSPU/SPURegisterInfo.h

   1 //===- SPURegisterInfo.h - Cell SPU Register Information Impl ----*- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by The Aerospace Corporation.
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains the Cell SPU implementation of the MRegisterInfo class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef SPU_REGISTERINFO_H
  14 #define SPU_REGISTERINFO_H
  15
  16 #include "SPU.h"
  17 #include "SPUGenRegisterInfo.h.inc"
  18
  19 namespace llvm {
  20   class SPUSubtarget;
  21   class TargetInstrInfo;
  22   class Type;
  23
  24   class SPURegisterInfo : public SPUGenRegisterInfo {
  25   private:
  26     const SPUSubtarget &Subtarget;
  27     const TargetInstrInfo &TII;
  28
  29     //! Predicate: Does the machine function use the link register?
  30     bool usesLR(MachineFunction &MF) const;
  31
  32   public:
  33     SPURegisterInfo(const SPUSubtarget &subtarget, const TargetInstrInfo &tii);
  34
  35     //! Translate a register's enum value to a register number
  36     /*!
  37       This method translates a register's enum value to it's regiser number,
  38       e.g. SPU::R14 -> 14.
  39      */
  40     static unsigned getRegisterNumbering(unsigned RegEnum);
  41
  42     //! Store a register to a stack slot, based on its register class.
  43     void storeRegToStackSlot(MachineBasicBlock &MBB,
  44                              MachineBasicBlock::iterator MBBI,
  45                              unsigned SrcReg, int FrameIndex,
  46                              const TargetRegisterClass *RC) const;
  47
  48     //! Store a register to an address, based on its register class
  49     void storeRegToAddr(MachineFunction &MF, unsigned SrcReg,
  50                         SmallVectorImpl<MachineOperand> &Addr,
  51                         const TargetRegisterClass *RC,
  52                         SmallVectorImpl<MachineInstr*> &NewMIs) const;
  53
  54     //! Load a register from a stack slot, based on its register class.
  55     void loadRegFromStackSlot(MachineBasicBlock &MBB,
  56                               MachineBasicBlock::iterator MBBI,
  57                               unsigned DestReg, int FrameIndex,
  58                               const TargetRegisterClass *RC) const;
  59
  60     //! Loqad a register from an address, based on its register class
  61     virtual void loadRegFromAddr(MachineFunction &MF, unsigned DestReg,
  62                                  SmallVectorImpl<MachineOperand> &Addr,
  63                                  const TargetRegisterClass *RC,
  64                                  SmallVectorImpl<MachineInstr*> &NewMIs) const;
  65
  66     //! Copy a register to another
  67     void copyRegToReg(MachineBasicBlock &MBB,
  68                       MachineBasicBlock::iterator MI,
  69                       unsigned DestReg, unsigned SrcReg,
  70                       const TargetRegisterClass *DestRC,
  71                       const TargetRegisterClass *SrcRC) const;
  72
  73     void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
  74                        unsigned DestReg, const MachineInstr *Orig) const;
  75
  76     //! Fold spills into load/store instructions
  77     virtual MachineInstr* foldMemoryOperand(MachineInstr* MI, unsigned OpNum,
  78                                             int FrameIndex) const;
  79
  80     //! Fold any load/store to an operand
  81     virtual MachineInstr* foldMemoryOperand(MachineInstr* MI, unsigned OpNum,
  82                                             MachineInstr* LoadMI) const;
  83
  84     //! Return the array of callee-saved registers
  85     virtual const unsigned* getCalleeSavedRegs(const MachineFunction *MF) const;
  86
  87     //! Return the register class array of the callee-saved registers
  88     virtual const TargetRegisterClass* const *
  89       getCalleeSavedRegClasses(const MachineFunction *MF) const;
  90
  91     //! Return the reserved registers
  92     BitVector getReservedRegs(const MachineFunction &MF) const;
  93
  94     //! Prediate: Target has dedicated frame pointer
  95     bool hasFP(const MachineFunction &MF) const;
  96     //! Eliminate the call frame setup pseudo-instructions
  97     void eliminateCallFramePseudoInstr(MachineFunction &MF,
  98                                        MachineBasicBlock &MBB,
  99                                        MachineBasicBlock::iterator I) const;
 100     //! Convert frame indicies into machine operands
 101     void eliminateFrameIndex(MachineBasicBlock::iterator II, int,
 102                              RegScavenger *RS) const;
 103     //! Determine the frame's layour
 104     void determineFrameLayout(MachineFunction &MF) const;
 105
 106     void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 107                                               RegScavenger *RS = NULL) const;
 108     //! Emit the function prologue
 109     void emitPrologue(MachineFunction &MF) const;
 110     //! Emit the function epilogue
 111     void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const;
 112     //! Get return address register (LR, aka R0)
 113     unsigned getRARegister() const;
 114     //! Get the stack frame register (SP, aka R1)
 115     unsigned getFrameRegister(MachineFunction &MF) const;
 116     //! Perform target-specific stack frame setup.
 117     void getInitialFrameState(std::vector<MachineMove> &Moves) const;
 118
 119     //------------------------------------------------------------------------
 120     // New methods added:
 121     //------------------------------------------------------------------------
 122
 123     //! Return the array of argument passing registers
 124     /*!
 125       \note The size of this array is returned by getArgRegsSize().
 126      */
 127     static const unsigned *getArgRegs();
 128
 129     //! Return the size of the argument passing register array
 130     static const unsigned getNumArgRegs();
 131
 132     //! Get DWARF debugging register number
 133     int getDwarfRegNum(unsigned RegNum, bool isEH) const;
 134   };
 135 } // end namespace llvm
 136
 137 #endif