LLVM  13.0.0git
MSP430FrameLowering.cpp
Go to the documentation of this file.
1 //===-- MSP430FrameLowering.cpp - MSP430 Frame Information ----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains the MSP430 implementation of TargetFrameLowering class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "MSP430FrameLowering.h"
14 #include "MSP430InstrInfo.h"
16 #include "MSP430Subtarget.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/IR/Function.h"
25 
26 using namespace llvm;
27 
29  const MachineFrameInfo &MFI = MF.getFrameInfo();
30 
31  return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
33  MFI.isFrameAddressTaken());
34 }
35 
37  return !MF.getFrameInfo().hasVarSizedObjects();
38 }
39 
41  MachineBasicBlock &MBB) const {
42  assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
43  MachineFrameInfo &MFI = MF.getFrameInfo();
45  const MSP430InstrInfo &TII =
46  *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
47 
49  DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
50 
51  // Get the number of bytes to allocate from the FrameInfo.
52  uint64_t StackSize = MFI.getStackSize();
53 
54  uint64_t NumBytes = 0;
55  if (hasFP(MF)) {
56  // Calculate required stack adjustment
57  uint64_t FrameSize = StackSize - 2;
58  NumBytes = FrameSize - MSP430FI->getCalleeSavedFrameSize();
59 
60  // Get the offset of the stack slot for the EBP register... which is
61  // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
62  // Update the frame offset adjustment.
63  MFI.setOffsetAdjustment(-NumBytes);
64 
65  // Save FP into the appropriate stack slot...
66  BuildMI(MBB, MBBI, DL, TII.get(MSP430::PUSH16r))
68 
69  // Update FP with the new base value...
70  BuildMI(MBB, MBBI, DL, TII.get(MSP430::MOV16rr), MSP430::R4)
71  .addReg(MSP430::SP);
72 
73  // Mark the FramePtr as live-in in every block except the entry.
74  for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
75  I != E; ++I)
76  I->addLiveIn(MSP430::R4);
77 
78  } else
79  NumBytes = StackSize - MSP430FI->getCalleeSavedFrameSize();
80 
81  // Skip the callee-saved push instructions.
82  while (MBBI != MBB.end() && (MBBI->getOpcode() == MSP430::PUSH16r))
83  ++MBBI;
84 
85  if (MBBI != MBB.end())
86  DL = MBBI->getDebugLoc();
87 
88  if (NumBytes) { // adjust stack pointer: SP -= numbytes
89  // If there is an SUB16ri of SP immediately before this instruction, merge
90  // the two.
91  //NumBytes -= mergeSPUpdates(MBB, MBBI, true);
92  // If there is an ADD16ri or SUB16ri of SP immediately after this
93  // instruction, merge the two instructions.
94  // mergeSPUpdatesDown(MBB, MBBI, &NumBytes);
95 
96  if (NumBytes) {
97  MachineInstr *MI =
98  BuildMI(MBB, MBBI, DL, TII.get(MSP430::SUB16ri), MSP430::SP)
99  .addReg(MSP430::SP).addImm(NumBytes);
100  // The SRW implicit def is dead.
101  MI->getOperand(3).setIsDead();
102  }
103  }
104 }
105 
107  MachineBasicBlock &MBB) const {
108  const MachineFrameInfo &MFI = MF.getFrameInfo();
110  const MSP430InstrInfo &TII =
111  *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
112 
114  unsigned RetOpcode = MBBI->getOpcode();
115  DebugLoc DL = MBBI->getDebugLoc();
116 
117  switch (RetOpcode) {
118  case MSP430::RET:
119  case MSP430::RETI: break; // These are ok
120  default:
121  llvm_unreachable("Can only insert epilog into returning blocks");
122  }
123 
124  // Get the number of bytes to allocate from the FrameInfo
125  uint64_t StackSize = MFI.getStackSize();
126  unsigned CSSize = MSP430FI->getCalleeSavedFrameSize();
127  uint64_t NumBytes = 0;
128 
129  if (hasFP(MF)) {
130  // Calculate required stack adjustment
131  uint64_t FrameSize = StackSize - 2;
132  NumBytes = FrameSize - CSSize;
133 
134  // pop FP.
135  BuildMI(MBB, MBBI, DL, TII.get(MSP430::POP16r), MSP430::R4);
136  } else
137  NumBytes = StackSize - CSSize;
138 
139  // Skip the callee-saved pop instructions.
140  while (MBBI != MBB.begin()) {
141  MachineBasicBlock::iterator PI = std::prev(MBBI);
142  unsigned Opc = PI->getOpcode();
143  if (Opc != MSP430::POP16r && !PI->isTerminator())
144  break;
145  --MBBI;
146  }
147 
148  DL = MBBI->getDebugLoc();
149 
150  // If there is an ADD16ri or SUB16ri of SP immediately before this
151  // instruction, merge the two instructions.
152  //if (NumBytes || MFI.hasVarSizedObjects())
153  // mergeSPUpdatesUp(MBB, MBBI, StackPtr, &NumBytes);
154 
155  if (MFI.hasVarSizedObjects()) {
156  BuildMI(MBB, MBBI, DL,
157  TII.get(MSP430::MOV16rr), MSP430::SP).addReg(MSP430::R4);
158  if (CSSize) {
159  MachineInstr *MI =
160  BuildMI(MBB, MBBI, DL,
161  TII.get(MSP430::SUB16ri), MSP430::SP)
162  .addReg(MSP430::SP).addImm(CSSize);
163  // The SRW implicit def is dead.
164  MI->getOperand(3).setIsDead();
165  }
166  } else {
167  // adjust stack pointer back: SP += numbytes
168  if (NumBytes) {
169  MachineInstr *MI =
170  BuildMI(MBB, MBBI, DL, TII.get(MSP430::ADD16ri), MSP430::SP)
171  .addReg(MSP430::SP).addImm(NumBytes);
172  // The SRW implicit def is dead.
173  MI->getOperand(3).setIsDead();
174  }
175  }
176 }
177 
178 // FIXME: Can we eleminate these in favour of generic code?
182  if (CSI.empty())
183  return false;
184 
185  DebugLoc DL;
186  if (MI != MBB.end()) DL = MI->getDebugLoc();
187 
188  MachineFunction &MF = *MBB.getParent();
189  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
191  MFI->setCalleeSavedFrameSize(CSI.size() * 2);
192 
193  for (unsigned i = CSI.size(); i != 0; --i) {
194  unsigned Reg = CSI[i-1].getReg();
195  // Add the callee-saved register as live-in. It's killed at the spill.
196  MBB.addLiveIn(Reg);
197  BuildMI(MBB, MI, DL, TII.get(MSP430::PUSH16r))
199  }
200  return true;
201 }
202 
206  if (CSI.empty())
207  return false;
208 
209  DebugLoc DL;
210  if (MI != MBB.end()) DL = MI->getDebugLoc();
211 
212  MachineFunction &MF = *MBB.getParent();
213  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
214 
215  for (unsigned i = 0, e = CSI.size(); i != e; ++i)
216  BuildMI(MBB, MI, DL, TII.get(MSP430::POP16r), CSI[i].getReg());
217 
218  return true;
219 }
220 
224  const MSP430InstrInfo &TII =
225  *static_cast<const MSP430InstrInfo *>(MF.getSubtarget().getInstrInfo());
226  if (!hasReservedCallFrame(MF)) {
227  // If the stack pointer can be changed after prologue, turn the
228  // adjcallstackup instruction into a 'sub SP, <amt>' and the
229  // adjcallstackdown instruction into 'add SP, <amt>'
230  // TODO: consider using push / pop instead of sub + store / add
231  MachineInstr &Old = *I;
232  uint64_t Amount = TII.getFrameSize(Old);
233  if (Amount != 0) {
234  // We need to keep the stack aligned properly. To do this, we round the
235  // amount of space needed for the outgoing arguments up to the next
236  // alignment boundary.
237  Amount = alignTo(Amount, getStackAlign());
238 
239  MachineInstr *New = nullptr;
240  if (Old.getOpcode() == TII.getCallFrameSetupOpcode()) {
241  New =
242  BuildMI(MF, Old.getDebugLoc(), TII.get(MSP430::SUB16ri), MSP430::SP)
243  .addReg(MSP430::SP)
244  .addImm(Amount);
245  } else {
246  assert(Old.getOpcode() == TII.getCallFrameDestroyOpcode());
247  // factor out the amount the callee already popped.
248  Amount -= TII.getFramePoppedByCallee(Old);
249  if (Amount)
250  New = BuildMI(MF, Old.getDebugLoc(), TII.get(MSP430::ADD16ri),
251  MSP430::SP)
252  .addReg(MSP430::SP)
253  .addImm(Amount);
254  }
255 
256  if (New) {
257  // The SRW implicit def is dead.
258  New->getOperand(3).setIsDead();
259 
260  // Replace the pseudo instruction with a new instruction...
261  MBB.insert(I, New);
262  }
263  }
264  } else if (I->getOpcode() == TII.getCallFrameDestroyOpcode()) {
265  // If we are performing frame pointer elimination and if the callee pops
266  // something off the stack pointer, add it back.
267  if (uint64_t CalleeAmt = TII.getFramePoppedByCallee(*I)) {
268  MachineInstr &Old = *I;
269  MachineInstr *New =
270  BuildMI(MF, Old.getDebugLoc(), TII.get(MSP430::SUB16ri), MSP430::SP)
271  .addReg(MSP430::SP)
272  .addImm(CalleeAmt);
273  // The SRW implicit def is dead.
274  New->getOperand(3).setIsDead();
275 
276  MBB.insert(I, New);
277  }
278  }
279 
280  return MBB.erase(I);
281 }
282 
283 void
285  RegScavenger *) const {
286  // Create a frame entry for the FP register that must be saved.
287  if (hasFP(MF)) {
288  int FrameIdx = MF.getFrameInfo().CreateFixedObject(2, -4, true);
289  (void)FrameIdx;
290  assert(FrameIdx == MF.getFrameInfo().getObjectIndexBegin() &&
291  "Slot for FP register must be last in order to be found!");
292  }
293 }
i
i
Definition: README.txt:29
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:158
llvm::MachineFrameInfo::hasVarSizedObjects
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
Definition: MachineFrameInfo.h:351
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:100
llvm::MachineInstrBuilder::addImm
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
Definition: MachineInstrBuilder.h:132
llvm
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::MSP430FrameLowering::emitPrologue
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
Definition: MSP430FrameLowering.cpp:40
llvm::TargetSubtargetInfo::getInstrInfo
virtual const TargetInstrInfo * getInstrInfo() const
Definition: TargetSubtargetInfo.h:92
llvm::MachineFunction::end
iterator end()
Definition: MachineFunction.h:739
R4
#define R4(n)
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
MSP430Subtarget.h
MSP430InstrInfo.h
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
MachineRegisterInfo.h
llvm::MachineBasicBlock::erase
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
Definition: MachineBasicBlock.cpp:1322
llvm::MSP430MachineFunctionInfo
MSP430MachineFunctionInfo - This class is derived from MachineFunction and contains private MSP430 ta...
Definition: MSP430MachineFunctionInfo.h:22
llvm::MachineFunction::front
const MachineBasicBlock & front() const
Definition: MachineFunction.h:749
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:305
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineFunction::getInfo
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Definition: MachineFunction.h:653
llvm::TargetFrameLowering::getStackAlign
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
Definition: TargetFrameLowering.h:99
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
llvm::MSP430FrameLowering::eliminateCallFramePseudoInstr
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
Definition: MSP430FrameLowering.cpp:221
llvm::MachineFunction::begin
iterator begin()
Definition: MachineFunction.h:737
llvm::MachineFrameInfo::getStackSize
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
Definition: MachineFrameInfo.h:563
llvm::MachineFrameInfo::getObjectIndexBegin
int getObjectIndexBegin() const
Return the minimum frame object index.
Definition: MachineFrameInfo.h:388
llvm::RegState::Kill
@ Kill
The last use of a register.
Definition: MachineInstrBuilder.h:49
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::TargetOptions::DisableFramePointerElim
bool DisableFramePointerElim(const MachineFunction &MF) const
DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...
Definition: TargetOptionsImpl.cpp:24
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:555
llvm::MachineInstr::getDebugLoc
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:418
MSP430FrameLowering.h
llvm::MSP430InstrInfo
Definition: MSP430InstrInfo.h:26
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MSP430FrameLowering::emitEpilogue
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
Definition: MSP430FrameLowering.cpp:106
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::RegScavenger
Definition: RegisterScavenging.h:34
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:115
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineFrameInfo::CreateFixedObject
int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
Definition: MachineFrameInfo.cpp:83
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:571
llvm::MachineBasicBlock::getParent
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
Definition: MachineBasicBlock.h:225
llvm::MSP430MachineFunctionInfo::setCalleeSavedFrameSize
void setCalleeSavedFrameSize(unsigned bytes)
Definition: MSP430MachineFunctionInfo.h:47
llvm::MSP430FrameLowering::restoreCalleeSavedRegisters
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
Definition: MSP430FrameLowering.cpp:203
MachineModuleInfo.h
llvm::MachineInstrBuilder::addReg
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Definition: MachineInstrBuilder.h:98
llvm::MSP430MachineFunctionInfo::getCalleeSavedFrameSize
unsigned getCalleeSavedFrameSize() const
Definition: MSP430MachineFunctionInfo.h:46
llvm::MachineFunction
Definition: MachineFunction.h:227
TargetOptions.h
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:33
DataLayout.h
llvm::MachineBasicBlock::getLastNonDebugInstr
iterator getLastNonDebugInstr(bool SkipPseudoOp=false)
Returns an iterator to the last non-debug instruction in the basic block, or end().
Definition: MachineBasicBlock.cpp:264
MBBI
MachineBasicBlock MachineBasicBlock::iterator MBBI
Definition: AArch64SLSHardening.cpp:75
llvm::MachineInstr::getOpcode
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:478
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MachineBasicBlock::addLiveIn
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
Definition: MachineBasicBlock.h:367
llvm::MachineFrameInfo::isFrameAddressTaken
bool isFrameAddressTaken() const
This method may be called any time after instruction selection is complete to determine if there is a...
Definition: MachineFrameInfo.h:366
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MSP430FrameLowering::hasFP
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
Definition: MSP430FrameLowering.cpp:28
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:551
llvm::MachineBasicBlock::insert
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
Definition: MachineBasicBlock.cpp:1335
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
MachineFrameInfo.h
llvm::ARCISD::RET
@ RET
Definition: ARCISelLowering.h:52
Function.h
llvm::MSP430FrameLowering::spillCalleeSavedRegisters
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
Definition: MSP430FrameLowering.cpp:179
MSP430MachineFunctionInfo.h
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
MachineInstrBuilder.h
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:329
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::MachineFrameInfo::setOffsetAdjustment
void setOffsetAdjustment(int Adj)
Set the correction for frame offsets.
Definition: MachineFrameInfo.h:575
llvm::MSP430FrameLowering::hasReservedCallFrame
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
Definition: MSP430FrameLowering.cpp:36
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
MachineFunction.h
llvm::MachineInstrBundleIterator< MachineInstr >
llvm::MSP430FrameLowering::processFunctionBeforeFrameFinalized
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
Definition: MSP430FrameLowering.cpp:284
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270