2017-06-06 22:22:41 +00:00
|
|
|
//===- TargetFrameLoweringImpl.cpp - Implement target frame interface ------==//
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2004-03-11 23:52:43 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 22:55:34 +00:00
|
|
|
//
|
2004-03-11 23:52:43 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Implements the layout of a stack frame on the target machine.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-07-14 17:17:13 +00:00
|
|
|
#include "llvm/ADT/BitVector.h"
|
2010-11-20 16:14:57 +00:00
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2015-07-14 17:17:13 +00:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2017-06-06 22:22:41 +00:00
|
|
|
#include "llvm/IR/Attributes.h"
|
HHVM calling conventions.
HHVM calling convention, hhvmcc, is used by HHVM JIT for
functions in translated cache. We currently support LLVM back end to
generate code for X86-64 and may support other architectures in the
future.
In HHVM calling convention any GP register could be used to pass and
return values, with the exception of R12 which is reserved for
thread-local area and is callee-saved. Other than R12, we always
pass RBX and RBP as args, which are our virtual machine's stack pointer
and frame pointer respectively.
When we enter translation cache via hhvmcc function, we expect
the stack to be aligned at 16 bytes, i.e. skewed by 8 bytes as opposed
to standard ABI alignment. This affects stack object alignment and stack
adjustments for function calls.
One extra calling convention, hhvm_ccc, is used to call C++ helpers from
HHVM's translation cache. It is almost identical to standard C calling
convention with an exception of first argument which is passed in RBP
(before we use RDI, RSI, etc.)
Differential Revision: http://reviews.llvm.org/D12681
llvm-svn: 248832
2015-09-29 22:09:16 +00:00
|
|
|
#include "llvm/IR/CallingConv.h"
|
2015-05-23 01:14:08 +00:00
|
|
|
#include "llvm/IR/Function.h"
|
2017-06-06 22:22:41 +00:00
|
|
|
#include "llvm/MC/MCRegisterInfo.h"
|
|
|
|
#include "llvm/Support/Compiler.h"
|
2016-07-13 23:39:34 +00:00
|
|
|
#include "llvm/Target/TargetFrameLowering.h"
|
2017-06-06 22:22:41 +00:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2010-11-20 15:59:32 +00:00
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2014-08-04 21:25:23 +00:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2017-06-06 22:22:41 +00:00
|
|
|
|
2004-03-11 23:52:43 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2017-06-06 22:22:41 +00:00
|
|
|
TargetFrameLowering::~TargetFrameLowering() = default;
|
2010-11-18 23:25:52 +00:00
|
|
|
|
2015-05-23 01:14:08 +00:00
|
|
|
/// The default implementation just looks at attribute "no-frame-pointer-elim".
|
|
|
|
bool TargetFrameLowering::noFramePointerElim(const MachineFunction &MF) const {
|
|
|
|
auto Attr = MF.getFunction()->getFnAttribute("no-frame-pointer-elim");
|
|
|
|
return Attr.getValueAsString() == "true";
|
|
|
|
}
|
|
|
|
|
2015-08-15 02:32:35 +00:00
|
|
|
/// Returns the displacement from the frame register to the stack
|
|
|
|
/// frame of the specified index, along with the frame register used
|
|
|
|
/// (in output arg FrameReg). This is the default implementation which
|
|
|
|
/// is overridden for some targets.
|
2011-01-10 12:39:04 +00:00
|
|
|
int TargetFrameLowering::getFrameIndexReference(const MachineFunction &MF,
|
|
|
|
int FI, unsigned &FrameReg) const {
|
2016-07-28 18:40:00 +00:00
|
|
|
const MachineFrameInfo &MFI = MF.getFrameInfo();
|
2014-08-05 02:39:49 +00:00
|
|
|
const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();
|
2010-11-20 15:59:32 +00:00
|
|
|
|
|
|
|
// By default, assume all frame indices are referenced via whatever
|
|
|
|
// getFrameRegister() says. The target can override this if it's doing
|
|
|
|
// something different.
|
|
|
|
FrameReg = RI->getFrameRegister(MF);
|
2015-08-15 02:32:35 +00:00
|
|
|
|
2016-07-28 18:40:00 +00:00
|
|
|
return MFI.getObjectOffset(FI) + MFI.getStackSize() -
|
|
|
|
getOffsetOfLocalArea() + MFI.getOffsetAdjustment();
|
2010-11-20 15:59:32 +00:00
|
|
|
}
|
2015-02-01 16:56:04 +00:00
|
|
|
|
|
|
|
bool TargetFrameLowering::needsFrameIndexResolution(
|
|
|
|
const MachineFunction &MF) const {
|
2016-07-28 18:40:00 +00:00
|
|
|
return MF.getFrameInfo().hasStackObjects();
|
2015-02-01 16:56:04 +00:00
|
|
|
}
|
2015-07-14 17:17:13 +00:00
|
|
|
|
|
|
|
void TargetFrameLowering::determineCalleeSaves(MachineFunction &MF,
|
|
|
|
BitVector &SavedRegs,
|
|
|
|
RegScavenger *RS) const {
|
|
|
|
const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
|
|
|
|
|
2016-04-08 12:04:32 +00:00
|
|
|
// Resize before the early returns. Some backends expect that
|
|
|
|
// SavedRegs.size() == TRI.getNumRegs() after this call even if there are no
|
|
|
|
// saved registers.
|
|
|
|
SavedRegs.resize(TRI.getNumRegs());
|
|
|
|
|
2016-07-13 23:39:34 +00:00
|
|
|
// When interprocedural register allocation is enabled caller saved registers
|
|
|
|
// are preferred over callee saved registers.
|
2016-07-13 23:39:46 +00:00
|
|
|
if (MF.getTarget().Options.EnableIPRA && isSafeForNoCSROpt(MF.getFunction()))
|
2016-07-13 23:39:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Get the callee saved register list...
|
2017-03-14 09:09:26 +00:00
|
|
|
const MCPhysReg *CSRegs = MF.getRegInfo().getCalleeSavedRegs();
|
2016-07-13 23:39:34 +00:00
|
|
|
|
2015-07-14 17:17:13 +00:00
|
|
|
// Early exit if there are no callee saved registers.
|
|
|
|
if (!CSRegs || CSRegs[0] == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// In Naked functions we aren't going to save any registers.
|
|
|
|
if (MF.getFunction()->hasFnAttribute(Attribute::Naked))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Functions which call __builtin_unwind_init get all their registers saved.
|
2016-12-01 19:32:15 +00:00
|
|
|
bool CallsUnwindInit = MF.callsUnwindInit();
|
2015-07-14 17:17:13 +00:00
|
|
|
const MachineRegisterInfo &MRI = MF.getRegInfo();
|
|
|
|
for (unsigned i = 0; CSRegs[i]; ++i) {
|
|
|
|
unsigned Reg = CSRegs[i];
|
|
|
|
if (CallsUnwindInit || MRI.isPhysRegModified(Reg))
|
|
|
|
SavedRegs.set(Reg);
|
|
|
|
}
|
|
|
|
}
|
HHVM calling conventions.
HHVM calling convention, hhvmcc, is used by HHVM JIT for
functions in translated cache. We currently support LLVM back end to
generate code for X86-64 and may support other architectures in the
future.
In HHVM calling convention any GP register could be used to pass and
return values, with the exception of R12 which is reserved for
thread-local area and is callee-saved. Other than R12, we always
pass RBX and RBP as args, which are our virtual machine's stack pointer
and frame pointer respectively.
When we enter translation cache via hhvmcc function, we expect
the stack to be aligned at 16 bytes, i.e. skewed by 8 bytes as opposed
to standard ABI alignment. This affects stack object alignment and stack
adjustments for function calls.
One extra calling convention, hhvm_ccc, is used to call C++ helpers from
HHVM's translation cache. It is almost identical to standard C calling
convention with an exception of first argument which is passed in RBP
(before we use RDI, RSI, etc.)
Differential Revision: http://reviews.llvm.org/D12681
llvm-svn: 248832
2015-09-29 22:09:16 +00:00
|
|
|
|
|
|
|
unsigned TargetFrameLowering::getStackAlignmentSkew(
|
|
|
|
const MachineFunction &MF) const {
|
|
|
|
// When HHVM function is called, the stack is skewed as the return address
|
|
|
|
// is removed from the stack before we enter the function.
|
|
|
|
if (LLVM_UNLIKELY(MF.getFunction()->getCallingConv() == CallingConv::HHVM))
|
|
|
|
return MF.getTarget().getPointerSize();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|