LLVM  6.0.0svn
TargetFrameLoweringImpl.cpp
Go to the documentation of this file.
1 //===- TargetFrameLoweringImpl.cpp - Implement target frame interface ------==//
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 // Implements the layout of a stack frame on the target machine.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/BitVector.h"
21 #include "llvm/IR/Attributes.h"
22 #include "llvm/IR/CallingConv.h"
23 #include "llvm/IR/Function.h"
24 #include "llvm/MC/MCRegisterInfo.h"
25 #include "llvm/Support/Compiler.h"
28 
29 using namespace llvm;
30 
32 
33 /// The default implementation just looks at attribute "no-frame-pointer-elim".
35  auto Attr = MF.getFunction()->getFnAttribute("no-frame-pointer-elim");
36  return Attr.getValueAsString() == "true";
37 }
38 
39 /// Returns the displacement from the frame register to the stack
40 /// frame of the specified index, along with the frame register used
41 /// (in output arg FrameReg). This is the default implementation which
42 /// is overridden for some targets.
44  int FI, unsigned &FrameReg) const {
45  const MachineFrameInfo &MFI = MF.getFrameInfo();
47 
48  // By default, assume all frame indices are referenced via whatever
49  // getFrameRegister() says. The target can override this if it's doing
50  // something different.
51  FrameReg = RI->getFrameRegister(MF);
52 
53  return MFI.getObjectOffset(FI) + MFI.getStackSize() -
55 }
56 
58  const MachineFunction &MF) const {
59  return MF.getFrameInfo().hasStackObjects();
60 }
61 
63  BitVector &SavedRegs,
64  RegScavenger *RS) const {
65  const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
66 
67  // Resize before the early returns. Some backends expect that
68  // SavedRegs.size() == TRI.getNumRegs() after this call even if there are no
69  // saved registers.
70  SavedRegs.resize(TRI.getNumRegs());
71 
72  // When interprocedural register allocation is enabled caller saved registers
73  // are preferred over callee saved registers.
75  return;
76 
77  // Get the callee saved register list...
78  const MCPhysReg *CSRegs = MF.getRegInfo().getCalleeSavedRegs();
79 
80  // Early exit if there are no callee saved registers.
81  if (!CSRegs || CSRegs[0] == 0)
82  return;
83 
84  // In Naked functions we aren't going to save any registers.
85  if (MF.getFunction()->hasFnAttribute(Attribute::Naked))
86  return;
87 
88  // Functions which call __builtin_unwind_init get all their registers saved.
89  bool CallsUnwindInit = MF.callsUnwindInit();
90  const MachineRegisterInfo &MRI = MF.getRegInfo();
91  for (unsigned i = 0; CSRegs[i]; ++i) {
92  unsigned Reg = CSRegs[i];
93  if (CallsUnwindInit || MRI.isPhysRegModified(Reg))
94  SavedRegs.set(Reg);
95  }
96 }
97 
99  const MachineFunction &MF) const {
100  // When HHVM function is called, the stack is skewed as the return address
101  // is removed from the stack before we enter the function.
103  return MF.getTarget().getPointerSize();
104 
105  return 0;
106 }
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:372
BitVector & set()
Definition: BitVector.h:398
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Calling convention used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cac...
Definition: CallingConv.h:164
unsigned getPointerSize() const
Get the pointer size for this target.
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:176
virtual int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
bool hasStackObjects() const
Return true if there are any stack objects in this function.
bool isPhysRegModified(unsigned PhysReg, bool SkipNoReturnDef=false) const
Return true if the specified register is modified in this function.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:262
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
Reg
All possible values of the reg field in the ModR/M byte.
This file contains the simple types necessary to represent the attributes associated with functions a...
virtual bool noFramePointerElim(const MachineFunction &MF) const
Return true if the target needs to disable frame pointer elimination.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
virtual unsigned getFrameRegister(const MachineFunction &MF) const =0
Debug information queries.
virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const
Return the skew that has to be applied to stack alignment under certain conditions (e...
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
unsigned const MachineRegisterInfo * MRI
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:194
bool callsUnwindInit() const
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
static bool isSafeForNoCSROpt(const Function *F)
Check if given function is safe for not having callee saved registers.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:195
TargetOptions Options
Definition: TargetMachine.h:96
int getOffsetAdjustment() const
Return the correction for frame offsets.
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:270
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects...