1 //===- SPURegisterInfo.h - Cell SPU Register Information Impl ----*- C++ -*-==//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by The Aerospace Corporation.
7 //===----------------------------------------------------------------------===//
9 // This file contains the Cell SPU implementation of the MRegisterInfo class.
11 //===----------------------------------------------------------------------===//
13 #ifndef SPU_REGISTERINFO_H
14 #define SPU_REGISTERINFO_H
17 #include "SPUGenRegisterInfo.h.inc"
21 class TargetInstrInfo;
24 class SPURegisterInfo : public SPUGenRegisterInfo {
26 const SPUSubtarget &Subtarget;
27 const TargetInstrInfo &TII;
29 //! Predicate: Does the machine function use the link register?
30 bool usesLR(MachineFunction &MF) const;
33 SPURegisterInfo(const SPUSubtarget &subtarget, const TargetInstrInfo &tii);
35 //! Translate a register's enum value to a register number
37 This method translates a register's enum value to it's regiser number,
40 static unsigned getRegisterNumbering(unsigned RegEnum);
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;
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;
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;
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;
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;
73 void reMaterialize(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
74 unsigned DestReg, const MachineInstr *Orig) const;
76 //! Fold spills into load/store instructions
77 virtual MachineInstr* foldMemoryOperand(MachineInstr* MI, unsigned OpNum,
78 int FrameIndex) const;
80 //! Fold any load/store to an operand
81 virtual MachineInstr* foldMemoryOperand(MachineInstr* MI, unsigned OpNum,
82 MachineInstr* LoadMI) const;
84 //! Return the array of callee-saved registers
85 virtual const unsigned* getCalleeSavedRegs(const MachineFunction *MF) const;
87 //! Return the register class array of the callee-saved registers
88 virtual const TargetRegisterClass* const *
89 getCalleeSavedRegClasses(const MachineFunction *MF) const;
91 //! Return the reserved registers
92 BitVector getReservedRegs(const MachineFunction &MF) const;
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;
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;
119 //------------------------------------------------------------------------
120 // New methods added:
121 //------------------------------------------------------------------------
123 //! Return the array of argument passing registers
125 \note The size of this array is returned by getArgRegsSize().
127 static const unsigned *getArgRegs();
129 //! Return the size of the argument passing register array
130 static const unsigned getNumArgRegs();
132 //! Get DWARF debugging register number
133 int getDwarfRegNum(unsigned RegNum, bool isEH) const;
135 } // end namespace llvm