blob: c1ceda7ab0cb00f3319fab7da2811d37f1131d82 [file] [log] [blame]
Akira Hatanaka4552c9a2011-04-15 21:51:11 +00001//=======- MipsFrameLowering.cpp - Mips Frame Information ------*- C++ -*-====//
Anton Korobeynikov33464912010-11-15 00:06:54 +00002//
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//
Akira Hatanaka4552c9a2011-04-15 21:51:11 +00008//===----------------------------------------------------------------------===//
Anton Korobeynikov33464912010-11-15 00:06:54 +00009//
Anton Korobeynikov16c29b52011-01-10 12:39:04 +000010// This file contains the Mips implementation of TargetFrameLowering class.
Anton Korobeynikov33464912010-11-15 00:06:54 +000011//
Akira Hatanaka4552c9a2011-04-15 21:51:11 +000012//===----------------------------------------------------------------------===//
Anton Korobeynikov33464912010-11-15 00:06:54 +000013
Anton Korobeynikov16c29b52011-01-10 12:39:04 +000014#include "MipsFrameLowering.h"
Anton Korobeynikov33464912010-11-15 00:06:54 +000015#include "MipsInstrInfo.h"
16#include "MipsMachineFunction.h"
17#include "llvm/Function.h"
18#include "llvm/CodeGen/MachineFrameInfo.h"
19#include "llvm/CodeGen/MachineFunction.h"
20#include "llvm/CodeGen/MachineInstrBuilder.h"
21#include "llvm/CodeGen/MachineModuleInfo.h"
22#include "llvm/CodeGen/MachineRegisterInfo.h"
23#include "llvm/Target/TargetData.h"
24#include "llvm/Target/TargetOptions.h"
25#include "llvm/Support/CommandLine.h"
26
27using namespace llvm;
28
29
Akira Hatanaka4552c9a2011-04-15 21:51:11 +000030//===----------------------------------------------------------------------===//
Anton Korobeynikov33464912010-11-15 00:06:54 +000031//
32// Stack Frame Processing methods
33// +----------------------------+
34//
35// The stack is allocated decrementing the stack pointer on
36// the first instruction of a function prologue. Once decremented,
37// all stack references are done thought a positive offset
38// from the stack/frame pointer, so the stack is considering
39// to grow up! Otherwise terrible hacks would have to be made
40// to get this stack ABI compliant :)
41//
42// The stack frame required by the ABI (after call):
43// Offset
44//
45// 0 ----------
46// 4 Args to pass
47// . saved $GP (used in PIC)
48// . Alloca allocations
49// . Local Area
50// . CPU "Callee Saved" Registers
51// . saved FP
52// . saved RA
53// . FPU "Callee Saved" Registers
54// StackSize -----------
55//
56// Offset - offset from sp after stack allocation on function prologue
57//
58// The sp is the stack pointer subtracted/added from the stack size
59// at the Prologue/Epilogue
60//
61// References to the previous stack (to obtain arguments) are done
62// with offsets that exceeds the stack size: (stacksize+(4*(num_arg-1))
63//
64// Examples:
65// - reference to the actual stack frame
66// for any local area var there is smt like : FI >= 0, StackOffset: 4
67// sw REGX, 4(SP)
68//
69// - reference to previous stack frame
70// suppose there's a load to the 5th arguments : FI < 0, StackOffset: 16.
71// The emitted instruction will be something like:
72// lw REGX, 16+StackSize(SP)
73//
74// Since the total stack size is unknown on LowerFormalArguments, all
75// stack references (ObjectOffset) created to reference the function
76// arguments, are negative numbers. This way, on eliminateFrameIndex it's
77// possible to detect those references and the offsets are adjusted to
78// their real location.
79//
Akira Hatanaka4552c9a2011-04-15 21:51:11 +000080//===----------------------------------------------------------------------===//
Anton Korobeynikov33464912010-11-15 00:06:54 +000081
Anton Korobeynikovd0c38172010-11-18 21:19:35 +000082// hasFP - Return true if the specified function should have a dedicated frame
Akira Hatanaka4552c9a2011-04-15 21:51:11 +000083// pointer register. This is true if the function has variable sized allocas or
84// if frame pointer elimination is disabled.
Anton Korobeynikov16c29b52011-01-10 12:39:04 +000085bool MipsFrameLowering::hasFP(const MachineFunction &MF) const {
Anton Korobeynikovd0c38172010-11-18 21:19:35 +000086 const MachineFrameInfo *MFI = MF.getFrameInfo();
Akira Hatanaka2e591472011-06-02 00:24:44 +000087 return DisableFramePointerElim(MF) || MFI->hasVarSizedObjects()
88 || MFI->isFrameAddressTaken();
Anton Korobeynikovd0c38172010-11-18 21:19:35 +000089}
90
Akira Hatanaka69c19f72011-05-23 20:16:59 +000091bool MipsFrameLowering::targetHandlesStackFrameRounding() const {
92 return true;
Anton Korobeynikov33464912010-11-15 00:06:54 +000093}
94
Akira Hatanaka69c19f72011-05-23 20:16:59 +000095static unsigned AlignOffset(unsigned Offset, unsigned Align) {
96 return (Offset + Align - 1) / Align * Align;
97}
Akira Hatanaka4552c9a2011-04-15 21:51:11 +000098
Akira Hatanaka0bf3dfb2011-04-15 21:00:26 +000099// expand pair of register and immediate if the immediate doesn't fit in the
100// 16-bit offset field.
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000101// e.g.
102// if OrigImm = 0x10000, OrigReg = $sp:
103// generate the following sequence of instrs:
104// lui $at, hi(0x10000)
105// addu $at, $sp, $at
106//
107// (NewReg, NewImm) = ($at, lo(Ox10000))
108// return true
109static bool expandRegLargeImmPair(unsigned OrigReg, int OrigImm,
110 unsigned& NewReg, int& NewImm,
Akira Hatanaka0bf3dfb2011-04-15 21:00:26 +0000111 MachineBasicBlock& MBB,
112 MachineBasicBlock::iterator I) {
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000113 // OrigImm fits in the 16-bit field
114 if (OrigImm < 0x8000 && OrigImm >= -0x8000) {
115 NewReg = OrigReg;
116 NewImm = OrigImm;
117 return false;
118 }
119
120 MachineFunction* MF = MBB.getParent();
121 const TargetInstrInfo *TII = MF->getTarget().getInstrInfo();
122 DebugLoc DL = I->getDebugLoc();
Akira Hatanakace98deb2011-05-24 21:22:21 +0000123 int ImmLo = (short)(OrigImm & 0xffff);
Akira Hatanaka4552c9a2011-04-15 21:51:11 +0000124 int ImmHi = (((unsigned)OrigImm & 0xffff0000) >> 16) +
Akira Hatanaka0bf3dfb2011-04-15 21:00:26 +0000125 ((OrigImm & 0x8000) != 0);
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000126
127 // FIXME: change this when mips goes MC".
128 BuildMI(MBB, I, DL, TII->get(Mips::NOAT));
129 BuildMI(MBB, I, DL, TII->get(Mips::LUi), Mips::AT).addImm(ImmHi);
Akira Hatanaka0bf3dfb2011-04-15 21:00:26 +0000130 BuildMI(MBB, I, DL, TII->get(Mips::ADDu), Mips::AT).addReg(OrigReg)
131 .addReg(Mips::AT);
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000132 NewReg = Mips::AT;
133 NewImm = ImmLo;
134
135 return true;
136}
137
Anton Korobeynikov16c29b52011-01-10 12:39:04 +0000138void MipsFrameLowering::emitPrologue(MachineFunction &MF) const {
Anton Korobeynikov33464912010-11-15 00:06:54 +0000139 MachineBasicBlock &MBB = MF.front();
140 MachineFrameInfo *MFI = MF.getFrameInfo();
141 MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
142 const MipsRegisterInfo *RegInfo =
143 static_cast<const MipsRegisterInfo*>(MF.getTarget().getRegisterInfo());
144 const MipsInstrInfo &TII =
145 *static_cast<const MipsInstrInfo*>(MF.getTarget().getInstrInfo());
146 MachineBasicBlock::iterator MBBI = MBB.begin();
147 DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
148 bool isPIC = (MF.getTarget().getRelocationModel() == Reloc::PIC_);
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000149 unsigned NewReg = 0;
150 int NewImm = 0;
151 bool ATUsed;
Anton Korobeynikov33464912010-11-15 00:06:54 +0000152
Akira Hatanaka69c19f72011-05-23 20:16:59 +0000153 // First, compute final stack size.
154 unsigned RegSize = STI.isGP32bit() ? 4 : 8;
155 unsigned StackAlign = getStackAlignment();
156 unsigned LocalVarAreaOffset = MipsFI->needGPSaveRestore() ?
157 (MFI->getObjectOffset(MipsFI->getGPFI()) + RegSize) :
Akira Hatanakaf15f4982011-05-25 17:52:48 +0000158 MipsFI->getMaxCallFrameSize();
Akira Hatanaka69c19f72011-05-23 20:16:59 +0000159 unsigned StackSize = AlignOffset(LocalVarAreaOffset, StackAlign) +
160 AlignOffset(MFI->getStackSize(), StackAlign);
Anton Korobeynikov33464912010-11-15 00:06:54 +0000161
Akira Hatanaka69c19f72011-05-23 20:16:59 +0000162 // Update stack size
163 MFI->setStackSize(StackSize);
164
Anton Korobeynikov33464912010-11-15 00:06:54 +0000165 BuildMI(MBB, MBBI, dl, TII.get(Mips::NOREORDER));
166
167 // TODO: check need from GP here.
168 if (isPIC && STI.isABI_O32())
169 BuildMI(MBB, MBBI, dl, TII.get(Mips::CPLOAD))
170 .addReg(RegInfo->getPICCallReg());
171 BuildMI(MBB, MBBI, dl, TII.get(Mips::NOMACRO));
172
Akira Hatanakaf346c692011-05-21 02:29:26 +0000173 // No need to allocate space on the stack.
174 if (StackSize == 0 && !MFI->adjustsStack()) return;
175
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000176 MachineModuleInfo &MMI = MF.getMMI();
177 std::vector<MachineMove> &Moves = MMI.getFrameMoves();
178 MachineLocation DstML, SrcML;
179
Anton Korobeynikov33464912010-11-15 00:06:54 +0000180 // Adjust stack : addi sp, sp, (-imm)
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000181 ATUsed = expandRegLargeImmPair(Mips::SP, -StackSize, NewReg, NewImm, MBB,
Akira Hatanaka8d580652011-04-07 20:25:10 +0000182 MBBI);
Anton Korobeynikov33464912010-11-15 00:06:54 +0000183 BuildMI(MBB, MBBI, dl, TII.get(Mips::ADDiu), Mips::SP)
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000184 .addReg(NewReg).addImm(NewImm);
185
186 // FIXME: change this when mips goes MC".
187 if (ATUsed)
188 BuildMI(MBB, MBBI, dl, TII.get(Mips::ATMACRO));
Anton Korobeynikov33464912010-11-15 00:06:54 +0000189
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000190 // emit ".cfi_def_cfa_offset StackSize"
191 MCSymbol *AdjustSPLabel = MMI.getContext().CreateTempSymbol();
192 BuildMI(MBB, MBBI, dl,
193 TII.get(TargetOpcode::PROLOG_LABEL)).addSym(AdjustSPLabel);
194 DstML = MachineLocation(MachineLocation::VirtualFP);
195 SrcML = MachineLocation(MachineLocation::VirtualFP, -StackSize);
196 Moves.push_back(MachineMove(AdjustSPLabel, DstML, SrcML));
197
Akira Hatanakacf0cd802011-05-26 18:59:03 +0000198 // Find the instruction past the last instruction that saves a callee-saved
199 // register to the stack.
200 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000201
202 if (CSI.size()) {
203 for (unsigned i = 0; i < CSI.size(); ++i)
204 ++MBBI;
Akira Hatanakaf346c692011-05-21 02:29:26 +0000205
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000206 // Iterate over list of callee-saved registers and emit .cfi_offset directives.
207 MCSymbol *CSLabel = MMI.getContext().CreateTempSymbol();
208 BuildMI(MBB, MBBI, dl,
209 TII.get(TargetOpcode::PROLOG_LABEL)).addSym(CSLabel);
210
211 for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(),
212 E = CSI.end(); I != E; ++I) {
213 int64_t Offset = MFI->getObjectOffset(I->getFrameIdx());
214 unsigned Reg = I->getReg();
215
216 // If Reg is a double precision register, emit two cfa_offsets,
217 // one for each of the paired single precision registers.
218 if (Mips::AFGR64RegisterClass->contains(Reg)) {
219 const unsigned *SubRegs = RegInfo->getSubRegisters(Reg);
220 MachineLocation DstML0(MachineLocation::VirtualFP, Offset);
221 MachineLocation DstML1(MachineLocation::VirtualFP, Offset + 4);
222 MachineLocation SrcML0(*SubRegs);
223 MachineLocation SrcML1(*(SubRegs + 1));
224
225 if (!STI.isLittle())
226 std::swap(SrcML0, SrcML1);
227
228 Moves.push_back(MachineMove(CSLabel, DstML0, SrcML0));
229 Moves.push_back(MachineMove(CSLabel, DstML1, SrcML1));
230 }
231 else {
232 // Reg is either in CPURegs or FGR32.
233 DstML = MachineLocation(MachineLocation::VirtualFP, Offset);
234 SrcML = MachineLocation(Reg);
235 Moves.push_back(MachineMove(CSLabel, DstML, SrcML));
236 }
237 }
238 }
239
Akira Hatanakacf0cd802011-05-26 18:59:03 +0000240 // if framepointer enabled, set it to point to the stack pointer.
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000241 if (hasFP(MF)) {
Akira Hatanakaf346c692011-05-21 02:29:26 +0000242 // Insert instruction "move $fp, $sp" at this location.
Anton Korobeynikov33464912010-11-15 00:06:54 +0000243 BuildMI(MBB, MBBI, dl, TII.get(Mips::ADDu), Mips::FP)
244 .addReg(Mips::SP).addReg(Mips::ZERO);
Anton Korobeynikov33464912010-11-15 00:06:54 +0000245
Akira Hatanaka8464fff2011-06-07 02:17:21 +0000246 // emit ".cfi_def_cfa_register $fp"
247 MCSymbol *SetFPLabel = MMI.getContext().CreateTempSymbol();
248 BuildMI(MBB, MBBI, dl,
249 TII.get(TargetOpcode::PROLOG_LABEL)).addSym(SetFPLabel);
250 DstML = MachineLocation(Mips::FP);
251 SrcML = MachineLocation(MachineLocation::VirtualFP);
252 Moves.push_back(MachineMove(SetFPLabel, DstML, SrcML));
253 }
254
Anton Korobeynikov33464912010-11-15 00:06:54 +0000255 // Restore GP from the saved stack location
256 if (MipsFI->needGPSaveRestore())
257 BuildMI(MBB, MBBI, dl, TII.get(Mips::CPRESTORE))
Akira Hatanaka69c19f72011-05-23 20:16:59 +0000258 .addImm(MFI->getObjectOffset(MipsFI->getGPFI()));
Anton Korobeynikov33464912010-11-15 00:06:54 +0000259}
260
Anton Korobeynikov16c29b52011-01-10 12:39:04 +0000261void MipsFrameLowering::emitEpilogue(MachineFunction &MF,
Anton Korobeynikov33464912010-11-15 00:06:54 +0000262 MachineBasicBlock &MBB) const {
Jakob Stoklund Olesen4f28c1c2011-01-13 21:28:52 +0000263 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
Anton Korobeynikov33464912010-11-15 00:06:54 +0000264 MachineFrameInfo *MFI = MF.getFrameInfo();
Anton Korobeynikov33464912010-11-15 00:06:54 +0000265 const MipsInstrInfo &TII =
266 *static_cast<const MipsInstrInfo*>(MF.getTarget().getInstrInfo());
267 DebugLoc dl = MBBI->getDebugLoc();
268
269 // Get the number of bytes from FrameInfo
Akira Hatanakaf346c692011-05-21 02:29:26 +0000270 unsigned StackSize = MFI->getStackSize();
Anton Korobeynikov33464912010-11-15 00:06:54 +0000271
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000272 unsigned NewReg = 0;
273 int NewImm = 0;
Bill Wendling0546f732011-03-04 21:38:47 +0000274 bool ATUsed = false;
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000275
Akira Hatanaka17a1e872011-05-20 18:39:33 +0000276 // if framepointer enabled, restore the stack pointer.
Akira Hatanakaf346c692011-05-21 02:29:26 +0000277 if (hasFP(MF)) {
278 // Find the first instruction that restores a callee-saved register.
279 MachineBasicBlock::iterator I = MBBI;
280
281 for (unsigned i = 0; i < MFI->getCalleeSavedInfo().size(); ++i)
282 --I;
283
284 // Insert instruction "move $sp, $fp" at this location.
285 BuildMI(MBB, I, dl, TII.get(Mips::ADDu), Mips::SP)
Anton Korobeynikov33464912010-11-15 00:06:54 +0000286 .addReg(Mips::FP).addReg(Mips::ZERO);
Akira Hatanakaf346c692011-05-21 02:29:26 +0000287 }
Anton Korobeynikov33464912010-11-15 00:06:54 +0000288
Anton Korobeynikov33464912010-11-15 00:06:54 +0000289 // adjust stack : insert addi sp, sp, (imm)
Akira Hatanakaf346c692011-05-21 02:29:26 +0000290 if (StackSize) {
291 ATUsed = expandRegLargeImmPair(Mips::SP, StackSize, NewReg, NewImm, MBB,
Akira Hatanaka3f92b432011-04-07 20:23:26 +0000292 MBBI);
Anton Korobeynikov33464912010-11-15 00:06:54 +0000293 BuildMI(MBB, MBBI, dl, TII.get(Mips::ADDiu), Mips::SP)
Bruno Cardoso Lopes99027d72011-03-04 20:48:08 +0000294 .addReg(NewReg).addImm(NewImm);
295
296 // FIXME: change this when mips goes MC".
297 if (ATUsed)
298 BuildMI(MBB, MBBI, dl, TII.get(Mips::ATMACRO));
Anton Korobeynikov33464912010-11-15 00:06:54 +0000299 }
300}
Bruno Cardoso Lopesfb67faa2011-01-18 19:50:18 +0000301
Akira Hatanakacf0cd802011-05-26 18:59:03 +0000302void
303MipsFrameLowering::getInitialFrameState(std::vector<MachineMove> &Moves) const {
304 MachineLocation Dst(MachineLocation::VirtualFP);
305 MachineLocation Src(Mips::SP, 0);
306 Moves.push_back(MachineMove(0, Dst, Src));
307}
308
Bruno Cardoso Lopesfb67faa2011-01-18 19:50:18 +0000309void MipsFrameLowering::
Akira Hatanaka17a1e872011-05-20 18:39:33 +0000310processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
311 RegScavenger *RS) const {
312 MachineRegisterInfo& MRI = MF.getRegInfo();
Akira Hatanaka17a1e872011-05-20 18:39:33 +0000313
314 // FIXME: remove this code if register allocator can correctly mark
315 // $fp and $ra used or unused.
316
317 // Mark $fp and $ra as used or unused.
318 if (hasFP(MF))
319 MRI.setPhysRegUsed(Mips::FP);
320
321 // The register allocator might determine $ra is used after seeing
322 // instruction "jr $ra", but we do not want PrologEpilogInserter to insert
323 // instructions to save/restore $ra unless there is a function call.
324 // To correct this, $ra is explicitly marked unused if there is no
325 // function call.
Akira Hatanaka33458fe2011-05-26 20:30:31 +0000326 if (MF.getFrameInfo()->hasCalls())
Akira Hatanaka17a1e872011-05-20 18:39:33 +0000327 MRI.setPhysRegUsed(Mips::RA);
328 else
329 MRI.setPhysRegUnused(Mips::RA);
330}