1 //===-- MBlazeRegisterInfo.cpp - MBlaze Register Information --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the MBlaze implementation of the TargetRegisterInfo
13 //===----------------------------------------------------------------------===//
15 #define DEBUG_TYPE "mblaze-frame-info"
17 #include "MBlazeRegisterInfo.h"
19 #include "MBlazeMachineFunction.h"
20 #include "MBlazeSubtarget.h"
21 #include "llvm/ADT/BitVector.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/CodeGen/MachineFrameInfo.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineInstrBuilder.h"
26 #include "llvm/CodeGen/ValueTypes.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/Type.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/raw_ostream.h"
34 #include "llvm/Target/TargetFrameLowering.h"
35 #include "llvm/Target/TargetInstrInfo.h"
36 #include "llvm/Target/TargetMachine.h"
37 #include "llvm/Target/TargetOptions.h"
39 #define GET_REGINFO_TARGET_DESC
40 #include "MBlazeGenRegisterInfo.inc"
45 MBlazeRegisterInfo(const MBlazeSubtarget &ST, const TargetInstrInfo &tii)
46 : MBlazeGenRegisterInfo(MBlaze::R15), Subtarget(ST), TII(tii) {}
48 unsigned MBlazeRegisterInfo::getPICCallReg() {
52 //===----------------------------------------------------------------------===//
53 // Callee Saved Registers methods
54 //===----------------------------------------------------------------------===//
56 /// MBlaze Callee Saved Registers
57 const uint16_t* MBlazeRegisterInfo::
58 getCalleeSavedRegs(const MachineFunction *MF) const {
59 // MBlaze callee-save register range is R20 - R31
60 static const uint16_t CalleeSavedRegs[] = {
61 MBlaze::R20, MBlaze::R21, MBlaze::R22, MBlaze::R23,
62 MBlaze::R24, MBlaze::R25, MBlaze::R26, MBlaze::R27,
63 MBlaze::R28, MBlaze::R29, MBlaze::R30, MBlaze::R31,
67 return CalleeSavedRegs;
70 BitVector MBlazeRegisterInfo::
71 getReservedRegs(const MachineFunction &MF) const {
72 BitVector Reserved(getNumRegs());
73 Reserved.set(MBlaze::R0);
74 Reserved.set(MBlaze::R1);
75 Reserved.set(MBlaze::R2);
76 Reserved.set(MBlaze::R13);
77 Reserved.set(MBlaze::R14);
78 Reserved.set(MBlaze::R15);
79 Reserved.set(MBlaze::R16);
80 Reserved.set(MBlaze::R17);
81 Reserved.set(MBlaze::R18);
82 Reserved.set(MBlaze::R19);
86 // FrameIndex represent objects inside a abstract stack.
87 // We must replace FrameIndex with an stack/frame pointer
89 void MBlazeRegisterInfo::
90 eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
91 unsigned FIOperandNum, RegScavenger *RS) const {
92 MachineInstr &MI = *II;
93 MachineFunction &MF = *MI.getParent()->getParent();
94 MachineFrameInfo *MFI = MF.getFrameInfo();
95 unsigned OFIOperandNum = FIOperandNum == 2 ? 1 : 2;
97 DEBUG(dbgs() << "\nFunction : " << MF.getName() << "\n";
98 dbgs() << "<--------->\n" << MI);
100 int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
101 int stackSize = MFI->getStackSize();
102 int spOffset = MFI->getObjectOffset(FrameIndex);
104 DEBUG(MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
105 dbgs() << "FrameIndex : " << FrameIndex << "\n"
106 << "spOffset : " << spOffset << "\n"
107 << "stackSize : " << stackSize << "\n"
108 << "isFixed : " << MFI->isFixedObjectIndex(FrameIndex) << "\n"
109 << "isLiveIn : " << MBlazeFI->isLiveIn(FrameIndex) << "\n"
110 << "isSpill : " << MFI->isSpillSlotObjectIndex(FrameIndex)
113 // as explained on LowerFormalArguments, detect negative offsets
114 // and adjust SPOffsets considering the final stack size.
115 int Offset = (spOffset < 0) ? (stackSize - spOffset) : spOffset;
116 Offset += MI.getOperand(OFIOperandNum).getImm();
118 DEBUG(dbgs() << "Offset : " << Offset << "\n" << "<--------->\n");
120 MI.getOperand(OFIOperandNum).ChangeToImmediate(Offset);
121 MI.getOperand(FIOperandNum).ChangeToRegister(getFrameRegister(MF), false);
124 void MBlazeRegisterInfo::
125 processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *) const {
126 // Set the stack offset where GP must be saved/loaded from.
127 MachineFrameInfo *MFI = MF.getFrameInfo();
128 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
129 if (MBlazeFI->needGPSaveRestore())
130 MFI->setObjectOffset(MBlazeFI->getGPFI(), MBlazeFI->getGPStackOffset());
133 unsigned MBlazeRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
134 const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering();
136 return TFI->hasFP(MF) ? MBlaze::R19 : MBlaze::R1;
139 unsigned MBlazeRegisterInfo::getEHExceptionRegister() const {
140 llvm_unreachable("What is the exception register");
143 unsigned MBlazeRegisterInfo::getEHHandlerRegister() const {
144 llvm_unreachable("What is the exception handler register");