1 //===- MBlazeRegisterInfo.cpp - MBlaze Register Information -== -*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains the MBlaze implementation of the TargetRegisterInfo 11 // class. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #define DEBUG_TYPE "mblaze-frame-info" 16 17 #include "MBlaze.h" 18 #include "MBlazeSubtarget.h" 19 #include "MBlazeRegisterInfo.h" 20 #include "MBlazeMachineFunction.h" 21 #include "llvm/Constants.h" 22 #include "llvm/Type.h" 23 #include "llvm/Function.h" 24 #include "llvm/CodeGen/ValueTypes.h" 25 #include "llvm/CodeGen/MachineInstrBuilder.h" 26 #include "llvm/CodeGen/MachineFunction.h" 27 #include "llvm/CodeGen/MachineFrameInfo.h" 28 #include "llvm/Target/TargetFrameLowering.h" 29 #include "llvm/Target/TargetMachine.h" 30 #include "llvm/Target/TargetOptions.h" 31 #include "llvm/Target/TargetInstrInfo.h" 32 #include "llvm/Support/CommandLine.h" 33 #include "llvm/Support/Debug.h" 34 #include "llvm/Support/ErrorHandling.h" 35 #include "llvm/Support/raw_ostream.h" 36 #include "llvm/ADT/BitVector.h" 37 #include "llvm/ADT/STLExtras.h" 38 39 #define GET_REGINFO_TARGET_DESC 40 #include "MBlazeGenRegisterInfo.inc" 41 42 using namespace llvm; 43 44 MBlazeRegisterInfo:: 45 MBlazeRegisterInfo(const MBlazeSubtarget &ST, const TargetInstrInfo &tii) 46 : MBlazeGenRegisterInfo(MBlaze::R15), Subtarget(ST), TII(tii) {} 47 48 unsigned MBlazeRegisterInfo::getPICCallReg() { 49 return MBlaze::R20; 50 } 51 52 //===----------------------------------------------------------------------===// 53 // Callee Saved Registers methods 54 //===----------------------------------------------------------------------===// 55 56 /// MBlaze Callee Saved Registers 57 const unsigned* MBlazeRegisterInfo:: 58 getCalleeSavedRegs(const MachineFunction *MF) const { 59 // MBlaze callee-save register range is R20 - R31 60 static const unsigned 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, 64 0 65 }; 66 67 return CalleeSavedRegs; 68 } 69 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); 83 return Reserved; 84 } 85 86 // This function eliminate ADJCALLSTACKDOWN/ADJCALLSTACKUP pseudo instructions 87 void MBlazeRegisterInfo:: 88 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 89 MachineBasicBlock::iterator I) const { 90 const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering(); 91 92 if (!TFI->hasReservedCallFrame(MF)) { 93 // If we have a frame pointer, turn the adjcallstackup instruction into a 94 // 'addi r1, r1, -<amt>' and the adjcallstackdown instruction into 95 // 'addi r1, r1, <amt>' 96 MachineInstr *Old = I; 97 int Amount = Old->getOperand(0).getImm() + 4; 98 if (Amount != 0) { 99 // We need to keep the stack aligned properly. To do this, we round the 100 // amount of space needed for the outgoing arguments up to the next 101 // alignment boundary. 102 unsigned Align = TFI->getStackAlignment(); 103 Amount = (Amount+Align-1)/Align*Align; 104 105 MachineInstr *New; 106 if (Old->getOpcode() == MBlaze::ADJCALLSTACKDOWN) { 107 New = BuildMI(MF,Old->getDebugLoc(),TII.get(MBlaze::ADDIK),MBlaze::R1) 108 .addReg(MBlaze::R1).addImm(-Amount); 109 } else { 110 assert(Old->getOpcode() == MBlaze::ADJCALLSTACKUP); 111 New = BuildMI(MF,Old->getDebugLoc(),TII.get(MBlaze::ADDIK),MBlaze::R1) 112 .addReg(MBlaze::R1).addImm(Amount); 113 } 114 115 // Replace the pseudo instruction with a new instruction... 116 MBB.insert(I, New); 117 } 118 } 119 120 // Simply discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions. 121 MBB.erase(I); 122 } 123 124 // FrameIndex represent objects inside a abstract stack. 125 // We must replace FrameIndex with an stack/frame pointer 126 // direct reference. 127 void MBlazeRegisterInfo:: 128 eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj, 129 RegScavenger *RS) const { 130 MachineInstr &MI = *II; 131 MachineFunction &MF = *MI.getParent()->getParent(); 132 MachineFrameInfo *MFI = MF.getFrameInfo(); 133 134 unsigned i = 0; 135 while (!MI.getOperand(i).isFI()) { 136 ++i; 137 assert(i < MI.getNumOperands() && 138 "Instr doesn't have FrameIndex operand!"); 139 } 140 141 unsigned oi = i == 2 ? 1 : 2; 142 143 DEBUG(dbgs() << "\nFunction : " << MF.getFunction()->getName() << "\n"; 144 dbgs() << "<--------->\n" << MI); 145 146 int FrameIndex = MI.getOperand(i).getIndex(); 147 int stackSize = MFI->getStackSize(); 148 int spOffset = MFI->getObjectOffset(FrameIndex); 149 150 DEBUG(MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 151 dbgs() << "FrameIndex : " << FrameIndex << "\n" 152 << "spOffset : " << spOffset << "\n" 153 << "stackSize : " << stackSize << "\n" 154 << "isFixed : " << MFI->isFixedObjectIndex(FrameIndex) << "\n" 155 << "isLiveIn : " << MBlazeFI->isLiveIn(FrameIndex) << "\n" 156 << "isSpill : " << MFI->isSpillSlotObjectIndex(FrameIndex) 157 << "\n" ); 158 159 // as explained on LowerFormalArguments, detect negative offsets 160 // and adjust SPOffsets considering the final stack size. 161 int Offset = (spOffset < 0) ? (stackSize - spOffset) : spOffset; 162 Offset += MI.getOperand(oi).getImm(); 163 164 DEBUG(dbgs() << "Offset : " << Offset << "\n" << "<--------->\n"); 165 166 MI.getOperand(oi).ChangeToImmediate(Offset); 167 MI.getOperand(i).ChangeToRegister(getFrameRegister(MF), false); 168 } 169 170 void MBlazeRegisterInfo:: 171 processFunctionBeforeFrameFinalized(MachineFunction &MF) const { 172 // Set the stack offset where GP must be saved/loaded from. 173 MachineFrameInfo *MFI = MF.getFrameInfo(); 174 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 175 if (MBlazeFI->needGPSaveRestore()) 176 MFI->setObjectOffset(MBlazeFI->getGPFI(), MBlazeFI->getGPStackOffset()); 177 } 178 179 unsigned MBlazeRegisterInfo::getFrameRegister(const MachineFunction &MF) const { 180 const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering(); 181 182 return TFI->hasFP(MF) ? MBlaze::R19 : MBlaze::R1; 183 } 184 185 unsigned MBlazeRegisterInfo::getEHExceptionRegister() const { 186 llvm_unreachable("What is the exception register"); 187 return 0; 188 } 189 190 unsigned MBlazeRegisterInfo::getEHHandlerRegister() const { 191 llvm_unreachable("What is the exception handler register"); 192 return 0; 193 } 194
