MBlazeFrameLowering.cpp revision 33464912237efaa0ed7060829e66b59055bdd48b 
1//=======- MBlazeFrameInfo.cpp - MBlaze Frame 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 TargetFrameInfo class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MBlazeFrameInfo.h"
15#include "MBlazeInstrInfo.h"
16#include "MBlazeMachineFunction.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
30//===----------------------------------------------------------------------===//
31//
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 are done through a positive offset
38// from the stack/frame pointer, so the stack is considered
39// to grow up.
40//
41//===----------------------------------------------------------------------===//
42
43void MBlazeFrameInfo::adjustMBlazeStackFrame(MachineFunction &MF) const {
44  MachineFrameInfo *MFI = MF.getFrameInfo();
45  MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
46  const MBlazeRegisterInfo *RegInfo =
47    static_cast<const MBlazeRegisterInfo*>(MF.getTarget().getRegisterInfo());
48
49  // See the description at MicroBlazeMachineFunction.h
50  int TopCPUSavedRegOff = -1;
51
52  // Adjust CPU Callee Saved Registers Area. Registers RA and FP must
53  // be saved in this CPU Area there is the need. This whole Area must
54  // be aligned to the default Stack Alignment requirements.
55  unsigned StackOffset = MFI->getStackSize();
56  unsigned RegSize = 4;
57
58  // Replace the dummy '0' SPOffset by the negative offsets, as explained on
59  // LowerFORMAL_ARGUMENTS. Leaving '0' for while is necessary to avoid
60  // the approach done by calculateFrameObjectOffsets to the stack frame.
61  MBlazeFI->adjustLoadArgsFI(MFI);
62  MBlazeFI->adjustStoreVarArgsFI(MFI);
63
64  if (RegInfo->hasFP(MF)) {
65    MFI->setObjectOffset(MFI->CreateStackObject(RegSize, RegSize, true),
66                         StackOffset);
67    MBlazeFI->setFPStackOffset(StackOffset);
68    TopCPUSavedRegOff = StackOffset;
69    StackOffset += RegSize;
70  }
71
72  if (MFI->adjustsStack()) {
73    MBlazeFI->setRAStackOffset(0);
74    MFI->setObjectOffset(MFI->CreateStackObject(RegSize, RegSize, true),
75                         StackOffset);
76    TopCPUSavedRegOff = StackOffset;
77    StackOffset += RegSize;
78  }
79
80  // Update frame info
81  MFI->setStackSize(StackOffset);
82
83  // Recalculate the final tops offset. The final values must be '0'
84  // if there isn't a callee saved register for CPU or FPU, otherwise
85  // a negative offset is needed.
86  if (TopCPUSavedRegOff >= 0)
87    MBlazeFI->setCPUTopSavedRegOff(TopCPUSavedRegOff-StackOffset);
88}
89
90void MBlazeFrameInfo::emitPrologue(MachineFunction &MF) const {
91  MachineBasicBlock &MBB   = MF.front();
92  MachineFrameInfo *MFI    = MF.getFrameInfo();
93  const MBlazeRegisterInfo *RegInfo =
94    static_cast<const MBlazeRegisterInfo*>(MF.getTarget().getRegisterInfo());
95  const MBlazeInstrInfo &TII =
96    *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo());
97  MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
98  MachineBasicBlock::iterator MBBI = MBB.begin();
99  DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
100
101  // Get the right frame order for MBlaze.
102  adjustMBlazeStackFrame(MF);
103
104  // Get the number of bytes to allocate from the FrameInfo.
105  unsigned StackSize = MFI->getStackSize();
106
107  // No need to allocate space on the stack.
108  if (StackSize == 0 && !MFI->adjustsStack()) return;
109  if (StackSize < 28 && MFI->adjustsStack()) StackSize = 28;
110
111  int FPOffset = MBlazeFI->getFPStackOffset();
112  int RAOffset = MBlazeFI->getRAStackOffset();
113
114  // Adjust stack : addi R1, R1, -imm
115  BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADDI), MBlaze::R1)
116      .addReg(MBlaze::R1).addImm(-StackSize);
117
118  // Save the return address only if the function isnt a leaf one.
119  // swi  R15, R1, stack_loc
120  if (MFI->adjustsStack()) {
121    BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI))
122        .addReg(MBlaze::R15).addReg(MBlaze::R1).addImm(RAOffset);
123  }
124
125  // if framepointer enabled, save it and set it
126  // to point to the stack pointer
127  if (RegInfo->hasFP(MF)) {
128    // swi  R19, R1, stack_loc
129    BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI))
130      .addReg(MBlaze::R19).addReg(MBlaze::R1).addImm(FPOffset);
131
132    // add R19, R1, R0
133    BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADD), MBlaze::R19)
134      .addReg(MBlaze::R1).addReg(MBlaze::R0);
135  }
136}
137
138void MBlazeFrameInfo::emitEpilogue(MachineFunction &MF,
139                                   MachineBasicBlock &MBB) const {
140  MachineBasicBlock::iterator MBBI = prior(MBB.end());
141  MachineFrameInfo *MFI            = MF.getFrameInfo();
142  MBlazeFunctionInfo *MBlazeFI         = MF.getInfo<MBlazeFunctionInfo>();
143  const MBlazeRegisterInfo *RegInfo =
144    static_cast<const MBlazeRegisterInfo*>(MF.getTarget().getRegisterInfo());
145  const MBlazeInstrInfo &TII =
146    *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo());
147
148  DebugLoc dl = MBBI->getDebugLoc();
149
150  // Get the FI's where RA and FP are saved.
151  int FPOffset = MBlazeFI->getFPStackOffset();
152  int RAOffset = MBlazeFI->getRAStackOffset();
153
154  // if framepointer enabled, restore it and restore the
155  // stack pointer
156  if (RegInfo->hasFP(MF)) {
157    // add R1, R19, R0
158    BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADD), MBlaze::R1)
159      .addReg(MBlaze::R19).addReg(MBlaze::R0);
160
161    // lwi  R19, R1, stack_loc
162    BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R19)
163      .addReg(MBlaze::R1).addImm(FPOffset);
164  }
165
166  // Restore the return address only if the function isnt a leaf one.
167  // lwi R15, R1, stack_loc
168  if (MFI->adjustsStack()) {
169    BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R15)
170      .addReg(MBlaze::R1).addImm(RAOffset);
171  }
172
173  // Get the number of bytes from FrameInfo
174  int StackSize = (int) MFI->getStackSize();
175  if (StackSize < 28 && MFI->adjustsStack()) StackSize = 28;
176
177  // adjust stack.
178  // addi R1, R1, imm
179  if (StackSize) {
180    BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADDI), MBlaze::R1)
181      .addReg(MBlaze::R1).addImm(StackSize);
182  }
183}
184