LLVM 17.0.0git
TargetFrameLoweringImpl.cpp
Go to the documentation of this file.
1//===- TargetFrameLoweringImpl.cpp - Implement target frame interface ------==//
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// Implements the layout of a stack frame on the target machine.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/BitVector.h"
19#include "llvm/IR/Attributes.h"
20#include "llvm/IR/CallingConv.h"
21#include "llvm/IR/Function.h"
22#include "llvm/IR/InstrTypes.h"
23#include "llvm/MC/MCAsmInfo.h"
28
29using namespace llvm;
30
32
34 assert(MF.getFunction().hasFnAttribute(Attribute::NoReturn) &&
35 MF.getFunction().hasFnAttribute(Attribute::NoUnwind) &&
36 !MF.getFunction().hasFnAttribute(Attribute::UWTable));
37 return false;
38}
39
41 return MF.needsFrameMoves() &&
43}
44
45/// Returns the displacement from the frame register to the stack
46/// frame of the specified index, along with the frame register used
47/// (in output arg FrameReg). This is the default implementation which
48/// is overridden for some targets.
51 Register &FrameReg) const {
52 const MachineFrameInfo &MFI = MF.getFrameInfo();
54
55 // By default, assume all frame indices are referenced via whatever
56 // getFrameRegister() says. The target can override this if it's doing
57 // something different.
58 FrameReg = RI->getFrameRegister(MF);
59
63}
64
66 const MachineFunction &MF) const {
67 return MF.getFrameInfo().hasStackObjects();
68}
69
71 BitVector &CalleeSaves) const {
73 CalleeSaves.resize(TRI.getNumRegs());
74
75 const MachineFrameInfo &MFI = MF.getFrameInfo();
76 if (!MFI.isCalleeSavedInfoValid())
77 return;
78
79 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
80 CalleeSaves.set(Info.getReg());
81}
82
84 BitVector &SavedRegs,
85 RegScavenger *RS) const {
87
88 // Resize before the early returns. Some backends expect that
89 // SavedRegs.size() == TRI.getNumRegs() after this call even if there are no
90 // saved registers.
91 SavedRegs.resize(TRI.getNumRegs());
92
93 // When interprocedural register allocation is enabled caller saved registers
94 // are preferred over callee saved registers.
95 if (MF.getTarget().Options.EnableIPRA &&
98 return;
99
100 // Get the callee saved register list...
101 const MCPhysReg *CSRegs = MF.getRegInfo().getCalleeSavedRegs();
102
103 // Early exit if there are no callee saved registers.
104 if (!CSRegs || CSRegs[0] == 0)
105 return;
106
107 // In Naked functions we aren't going to save any registers.
108 if (MF.getFunction().hasFnAttribute(Attribute::Naked))
109 return;
110
111 // Noreturn+nounwind functions never restore CSR, so no saves are needed.
112 // Purely noreturn functions may still return through throws, so those must
113 // save CSR for caller exception handlers.
114 //
115 // If the function uses longjmp to break out of its current path of
116 // execution we do not need the CSR spills either: setjmp stores all CSRs
117 // it was called with into the jmp_buf, which longjmp then restores.
118 if (MF.getFunction().hasFnAttribute(Attribute::NoReturn) &&
119 MF.getFunction().hasFnAttribute(Attribute::NoUnwind) &&
120 !MF.getFunction().hasFnAttribute(Attribute::UWTable) &&
122 return;
123
124 // Functions which call __builtin_unwind_init get all their registers saved.
125 bool CallsUnwindInit = MF.callsUnwindInit();
126 const MachineRegisterInfo &MRI = MF.getRegInfo();
127 for (unsigned i = 0; CSRegs[i]; ++i) {
128 unsigned Reg = CSRegs[i];
129 if (CallsUnwindInit || MRI.isPhysRegModified(Reg))
130 SavedRegs.set(Reg);
131 }
132}
133
135 const MachineFunction &MF) const {
136 // When HHVM function is called, the stack is skewed as the return address
137 // is removed from the stack before we enter the function.
139 return MF.getTarget().getAllocaPointerSize();
140
141 return 0;
142}
143
145 const MachineFunction &MF) const {
146 if (!hasFP(MF))
147 return false;
148
149 const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
150 return RegInfo->useFPForScavengingIndex(MF) &&
151 !RegInfo->hasStackRealignment(MF);
152}
153
155 if (!F.hasLocalLinkage() || F.hasAddressTaken() ||
156 !F.hasFnAttribute(Attribute::NoRecurse))
157 return false;
158 // Function should not be optimized as tail call.
159 for (const User *U : F.users())
160 if (auto *CB = dyn_cast<CallBase>(U))
161 if (CB->isTailCall())
162 return false;
163 return true;
164}
165
167 llvm_unreachable("getInitialCFAOffset() not implemented!");
168}
169
172 llvm_unreachable("getInitialCFARegister() not implemented!");
173}
174
179}
unsigned const MachineRegisterInfo * MRI
This file contains the simple types necessary to represent the attributes associated with functions a...
This file implements the BitVector class.
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:210
#define F(x, y, z)
Definition: MD5.cpp:55
unsigned const TargetRegisterInfo * TRI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:334
BitVector & set()
Definition: BitVector.h:344
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:237
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:640
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:797
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
int getOffsetAdjustment() const
Return the correction for frame offsets.
bool isCalleeSavedInfoValid() const
Has the callee saved info been calculated yet?
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
bool hasStackObjects() const
Return true if there are any stack objects in this function.
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
bool callsUnwindInit() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:36
int64_t getFixed() const
Returns the fixed component of the stack.
Definition: TypeSize.h:52
virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const
Return the skew that has to be applied to stack alignment under certain conditions (e....
virtual bool allocateScavengingFrameIndexesNearIncomingSP(const MachineFunction &MF) const
Control the placement of special register scavenging spill slots when allocating a stack frame.
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
virtual bool enableCalleeSaveSkip(const MachineFunction &MF) const
Returns true if the target can safely skip saving callee-saved registers for noreturn nounwind functi...
virtual Register getInitialCFARegister(const MachineFunction &MF) const
Return initial CFA register value i.e.
virtual bool hasFP(const MachineFunction &MF) const =0
hasFP - Return true if the specified function should have a dedicated frame pointer register.
virtual void getCalleeSaves(const MachineFunction &MF, BitVector &SavedRegs) const
Returns the callee-saved registers as computed by determineCalleeSaves in the BitVector SavedRegs.
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
virtual DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const
Return the frame base information to be encoded in the DWARF subprogram debug info.
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
virtual bool isProfitableForNoCSROpt(const Function &F) const
Check if the no-CSR optimisation is profitable for the given function.
static bool isSafeForNoCSROpt(const Function &F)
Check if given function is safe for not having callee saved registers.
virtual bool enableCFIFixup(MachineFunction &MF) const
Returns true if we may need to fix the unwind information for the function.
virtual int getInitialCFAOffset(const MachineFunction &MF) const
Return initial CFA offset value i.e.
virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
unsigned getAllocaPointerSize() const
TargetOptions Options
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual bool useFPForScavengingIndex(const MachineFunction &MF) const
Returns true if the target wants to use frame pointer based accesses to spill to the scavenger emerge...
bool hasStackRealignment(const MachineFunction &MF) const
True if stack realignment is required and still possible.
virtual Register getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ HHVM
Used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cache,...
Definition: CallingConv.h:165
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18