mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-28 22:29:56 +00:00
This builds on some frame-lowering code that has existed since 2005 (r24224) but was disabled in 2008 (r48188) because it needed base pointer support to function correctly. This implementation follows the strategy suggested by Dale Johannesen in r48188 where the following comment was added: This does not currently work, because the delta between old and new stack pointers is added to offsets that reference incoming parameters after the prolog is generated, and the code that does that doesn't handle a variable delta. You don't want to do that anyway; a better approach is to reserve another register that retains to the incoming stack pointer, and reference parameters relative to that. And now we do exactly that. If we don't need a frame pointer, then we use r31 as a base pointer. If we do need a frame pointer, then we use r30 as a base pointer. The base pointer retains the value of the stack pointer before it was decremented in the prologue. We then use the base pointer to resolve all negative frame indicies. The basic scheme follows that for base pointers in the X86 backend. We use a base pointer when we need to dynamically realign the incoming stack pointer. This currently applies only to static objects (dynamic allocas with large alignments, and base-pointer support in SjLj lowering will come in future commits). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@186478 91177308-0d34-0410-b5e6-96231b3b80d8
179 lines
6.5 KiB
C++
179 lines
6.5 KiB
C++
//===-- PPCMachineFunctionInfo.h - Private data used for PowerPC --*- C++ -*-=//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares the PowerPC specific subclass of MachineFunctionInfo.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef PPC_MACHINE_FUNCTION_INFO_H
|
|
#define PPC_MACHINE_FUNCTION_INFO_H
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// PPCFunctionInfo - This class is derived from MachineFunction private
|
|
/// PowerPC target-specific information for each MachineFunction.
|
|
class PPCFunctionInfo : public MachineFunctionInfo {
|
|
virtual void anchor();
|
|
|
|
/// FramePointerSaveIndex - Frame index of where the old frame pointer is
|
|
/// stored. Also used as an anchor for instructions that need to be altered
|
|
/// when using frame pointers (dyna_add, dyna_sub.)
|
|
int FramePointerSaveIndex;
|
|
|
|
/// ReturnAddrSaveIndex - Frame index of where the return address is stored.
|
|
///
|
|
int ReturnAddrSaveIndex;
|
|
|
|
/// Frame index where the old base pointer is stored.
|
|
int BasePointerSaveIndex;
|
|
|
|
/// MustSaveLR - Indicates whether LR is defined (or clobbered) in the current
|
|
/// function. This is only valid after the initial scan of the function by
|
|
/// PEI.
|
|
bool MustSaveLR;
|
|
|
|
/// Does this function have any stack spills.
|
|
bool HasSpills;
|
|
|
|
/// Does this function spill using instructions with only r+r (not r+i)
|
|
/// forms.
|
|
bool HasNonRISpills;
|
|
|
|
/// SpillsCR - Indicates whether CR is spilled in the current function.
|
|
bool SpillsCR;
|
|
|
|
/// Indicates whether VRSAVE is spilled in the current function.
|
|
bool SpillsVRSAVE;
|
|
|
|
/// LRStoreRequired - The bool indicates whether there is some explicit use of
|
|
/// the LR/LR8 stack slot that is not obvious from scanning the code. This
|
|
/// requires that the code generator produce a store of LR to the stack on
|
|
/// entry, even though LR may otherwise apparently not be used.
|
|
bool LRStoreRequired;
|
|
|
|
/// MinReservedArea - This is the frame size that is at least reserved in a
|
|
/// potential caller (parameter+linkage area).
|
|
unsigned MinReservedArea;
|
|
|
|
/// TailCallSPDelta - Stack pointer delta used when tail calling. Maximum
|
|
/// amount the stack pointer is adjusted to make the frame bigger for tail
|
|
/// calls. Used for creating an area before the register spill area.
|
|
int TailCallSPDelta;
|
|
|
|
/// HasFastCall - Does this function contain a fast call. Used to determine
|
|
/// how the caller's stack pointer should be calculated (epilog/dynamicalloc).
|
|
bool HasFastCall;
|
|
|
|
/// VarArgsFrameIndex - FrameIndex for start of varargs area.
|
|
int VarArgsFrameIndex;
|
|
/// VarArgsStackOffset - StackOffset for start of stack
|
|
/// arguments.
|
|
int VarArgsStackOffset;
|
|
/// VarArgsNumGPR - Index of the first unused integer
|
|
/// register for parameter passing.
|
|
unsigned VarArgsNumGPR;
|
|
/// VarArgsNumFPR - Index of the first unused double
|
|
/// register for parameter passing.
|
|
unsigned VarArgsNumFPR;
|
|
|
|
/// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4.
|
|
int CRSpillFrameIndex;
|
|
|
|
/// If any of CR[2-4] need to be saved in the prologue and restored in the
|
|
/// epilogue then they are added to this array. This is used for the
|
|
/// 64-bit SVR4 ABI.
|
|
SmallVector<unsigned, 3> MustSaveCRs;
|
|
|
|
public:
|
|
explicit PPCFunctionInfo(MachineFunction &MF)
|
|
: FramePointerSaveIndex(0),
|
|
ReturnAddrSaveIndex(0),
|
|
BasePointerSaveIndex(0),
|
|
HasSpills(false),
|
|
HasNonRISpills(false),
|
|
SpillsCR(false),
|
|
SpillsVRSAVE(false),
|
|
LRStoreRequired(false),
|
|
MinReservedArea(0),
|
|
TailCallSPDelta(0),
|
|
HasFastCall(false),
|
|
VarArgsFrameIndex(0),
|
|
VarArgsStackOffset(0),
|
|
VarArgsNumGPR(0),
|
|
VarArgsNumFPR(0),
|
|
CRSpillFrameIndex(0) {}
|
|
|
|
int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
|
|
void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
|
|
|
|
int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
|
|
void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
|
|
|
|
int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
|
|
void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
|
|
|
|
unsigned getMinReservedArea() const { return MinReservedArea; }
|
|
void setMinReservedArea(unsigned size) { MinReservedArea = size; }
|
|
|
|
int getTailCallSPDelta() const { return TailCallSPDelta; }
|
|
void setTailCallSPDelta(int size) { TailCallSPDelta = size; }
|
|
|
|
/// MustSaveLR - This is set when the prolog/epilog inserter does its initial
|
|
/// scan of the function. It is true if the LR/LR8 register is ever explicitly
|
|
/// defined/clobbered in the machine function (e.g. by calls and movpctolr,
|
|
/// which is used in PIC generation), or if the LR stack slot is explicitly
|
|
/// referenced by builtin_return_address.
|
|
void setMustSaveLR(bool U) { MustSaveLR = U; }
|
|
bool mustSaveLR() const { return MustSaveLR; }
|
|
|
|
void setHasSpills() { HasSpills = true; }
|
|
bool hasSpills() const { return HasSpills; }
|
|
|
|
void setHasNonRISpills() { HasNonRISpills = true; }
|
|
bool hasNonRISpills() const { return HasNonRISpills; }
|
|
|
|
void setSpillsCR() { SpillsCR = true; }
|
|
bool isCRSpilled() const { return SpillsCR; }
|
|
|
|
void setSpillsVRSAVE() { SpillsVRSAVE = true; }
|
|
bool isVRSAVESpilled() const { return SpillsVRSAVE; }
|
|
|
|
void setLRStoreRequired() { LRStoreRequired = true; }
|
|
bool isLRStoreRequired() const { return LRStoreRequired; }
|
|
|
|
void setHasFastCall() { HasFastCall = true; }
|
|
bool hasFastCall() const { return HasFastCall;}
|
|
|
|
int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
|
|
void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
|
|
|
|
int getVarArgsStackOffset() const { return VarArgsStackOffset; }
|
|
void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
|
|
|
|
unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
|
|
void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
|
|
|
|
unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
|
|
void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
|
|
|
|
int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
|
|
void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
|
|
|
|
const SmallVectorImpl<unsigned> &
|
|
getMustSaveCRs() const { return MustSaveCRs; }
|
|
void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
|
|
};
|
|
|
|
} // end of namespace llvm
|
|
|
|
|
|
#endif
|