1//===-- WebAssemblyFrameLowering.cpp - WebAssembly Frame Lowering ----------==// 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 7//===----------------------------------------------------------------------===// 10/// This file contains the WebAssembly implementation of 11/// TargetFrameLowering class. 13/// On WebAssembly, there aren't a lot of things to do here. There are no 14/// callee-saved registers to save, and no spill slots. 16/// The stack grows downward. 18//===----------------------------------------------------------------------===// 37#define DEBUG_TYPE "wasm-frame-info" 40// TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions 42// In an ideal world, when objects are added to the MachineFrameInfo by 43// FunctionLoweringInfo::set, we could somehow hook into target-specific code to 44// ensure they are assigned the right stack ID. However there isn't a hook that 45// runs between then and DAG building time, though, so instead we hoist stack 46// objects lazily when they are first used, and comprehensively after the DAG is 47// built via the PreprocessISelDAG hook, called by the 48// SelectionDAGISel::runOnMachineFunction. We have to do it in two places 49// because we want to do it while building the selection DAG for uses of alloca, 50// but not all alloca instructions are used so we have to follow up afterwards. 51std::optional<unsigned>
56// If already hoisted to a local, done. 60// If not allocated in the object address space, this object will be in 66// Otherwise, allocate this object in the named value stack, outside of linear 74// Abuse SP offset to record the index of the first local in the object. 77// Allocate WebAssembly locals for each non-aggregate component of the 79for (
EVT ValueVT : ValueVTs)
80 FuncInfo->
addLocal(ValueVT.getSimpleVT());
81// Abuse object size to record number of WebAssembly locals allocated to 84returnstatic_cast<unsigned>(
Local);
87/// We need a base pointer in the case of having items on the stack that 88/// require stricter alignment than the stack pointer itself. Because we need 89/// to shift the stack pointer by some unknown amount to force the alignment, 90/// we need to record the value of the stack pointer on entry to the function. 94return RegInfo->hasStackRealignment(MF);
97/// Return true if the specified function should have a dedicated frame pointer 102// When we have var-sized objects, we move the stack pointer by an unknown 103// amount, and need to emit a frame pointer to restore the stack to where we 104// were on function entry. 105// If we already need a base pointer, we use that to fix up the stack pointer. 106// If there are no fixed-size objects, we would have no use of a frame 107// pointer, and thus should not emit one. 109bool NeedsFixedReference = !hasBP(MF) || HasFixedSizedObjects;
116/// Under normal circumstances, when a frame pointer is not required, we reserve 117/// argument space for call sites in the function immediately on entry to the 118/// current function. This eliminates the need for add/sub sp brackets around 119/// call sites. Returns true if the call frame is included as part of the stack 126// Returns true if this function needs a local user-space stack pointer for its 127// local frame (not for exception handling). 128bool WebAssemblyFrameLowering::needsSPForLocalFrame(
132// llvm.stacksave can explicitly read SP register and it can appear without 134bool HasExplicitSPUse =
138return MFI.getStackSize() || MFI.adjustsStack() ||
hasFP(MF) ||
142// In function with EH pads, we need to make a copy of the value of 143// __stack_pointer global in SP32/64 register, in order to use it when 144// restoring __stack_pointer after an exception is caught. 152/// Returns true if this function needs a local user-space stack pointer. 153/// Unlike a machine stack pointer, the wasm user stack pointer is a global 154/// variable, so it is loaded into a register in the prolog. 159/// Returns true if the local user-space stack pointer needs to be written back 160/// to __stack_pointer global by this function (this is not meaningful if 161/// needsSP is false). If false, the stack red zone can be used and only a local 163bool WebAssemblyFrameLowering::needsSPWriteback(
167// When we don't need a local stack pointer for its local frame but only to 168// support EH, we don't need to write SP back in the epilog, because we don't 169// bump down the stack pointer in the prolog. We need to write SP back in the 171// 1. We need SP not only for EH support but also because we actually use 172// stack or we have a frame address taken. 173// 2. We cannot use the red zone. 174bool CanUseRedZone = MFI.getStackSize() <=
RedZoneSize && !MFI.hasCalls() &&
176return needsSPForLocalFrame(MF) && !CanUseRedZone;
194 ? WebAssembly::CONST_I64
195 : WebAssembly::CONST_I32;
200 ? WebAssembly::ADD_I64
201 : WebAssembly::ADD_I32;
206 ? WebAssembly::SUB_I64
207 : WebAssembly::SUB_I32;
212 ? WebAssembly::AND_I64
213 : WebAssembly::AND_I32;
219 ? WebAssembly::GLOBAL_GET_I64
220 : WebAssembly::GLOBAL_GET_I32;
226 ? WebAssembly::GLOBAL_SET_I64
227 : WebAssembly::GLOBAL_SET_I32;
235constchar *ES =
"__stack_pointer";
247assert(!
I->getOperand(0).getImm() && (
hasFP(MF) || hasBP(MF)) &&
248"Call frame pseudos should only be used for dynamic stack adjustment");
250constauto *
TII = ST.getInstrInfo();
251if (
I->getOpcode() ==
TII->getCallFrameDestroyOpcode() &&
252 needsSPWriteback(MF)) {
261// TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions 263assert(MFI.getCalleeSavedInfo().empty() &&
264"WebAssembly should not have callee-saved registers");
268uint64_t StackSize = MFI.getStackSize();
271constauto *
TII = ST.getInstrInfo();
275while (InsertPt !=
MBB.
end() &&
281MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
284SPReg =
MRI.createVirtualRegister(PtrRC);
286constchar *ES =
"__stack_pointer";
291bool HasBP = hasBP(MF);
295 FI->setBasePointerVreg(BasePtr);
300// Subtract the frame size 301Register OffsetReg =
MRI.createVirtualRegister(PtrRC);
309Register BitmaskReg =
MRI.createVirtualRegister(PtrRC);
310Align Alignment = MFI.getMaxAlign();
318// Unlike most conventional targets (where FP points to the saved FP), 319// FP points to the bottom of the fixed-size locals, so we can use positive 320// offsets in load/store instructions. 324if (StackSize && needsSPWriteback(MF)) {
332if (!needsSP(MF) || !needsSPWriteback(MF))
335constauto *
TII = ST.getInstrInfo();
341DL = InsertPt->getDebugLoc();
343// Restore the stack pointer. If we had fixed-size locals, add the offset 344// subtracted in the prolog. 349SPReg = FI->getBasePointerVreg();
350 }
elseif (StackSize) {
352MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
353Register OffsetReg =
MRI.createVirtualRegister(PtrRC);
356// In the epilog we don't need to write the result back to the SP32/64 357// physreg because it won't be used again. We can use a stackified register 359SPReg =
MRI.createVirtualRegister(PtrRC);
372// Use the Object stack for WebAssembly locals which can only be accessed 373// by name, not via an address in linear memory. 383 Loc.
Kind = DwarfFrameBase::WasmFrameBase;
389// TODO: This should work on a breakpoint at a function with no frame, 390// but probably won't work for traversing up the stack. unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
const HexagonInstrInfo * TII
static constexpr Register SPReg
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class implements WebAssembly-specific bits of TargetFrameLowering class.
This file contains the WebAssembly implementation of the TargetInstrInfo class.
This file provides WebAssembly-specific target descriptions.
This file declares WebAssembly-specific per-machine-function information.
This file declares the WebAssembly-specific subclass of TargetSubtarget.
This file declares the WebAssembly-specific subclass of TargetMachine.
This file contains the declaration of the WebAssembly-specific type parsing utility functions.
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end.
an instruction to allocate memory on the stack
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
unsigned getAddressSpace() const
Return the address space for the allocation.
bool hasPersonalityFn() const
Check whether this function has a personality function.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
ExceptionHandling getExceptionHandlingType() const
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
const AllocaInst * getObjectAllocation(int ObjectIdx) const
Return the underlying Alloca of the specified stack object if it exists.
bool hasCalls() const
Return true if the current function has any function calls.
bool isFrameAddressTaken() const
This method may be called any time after instruction selection is complete to determine if there is a...
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
bool hasPatchPoint() const
This method may be called any time after instruction selection is complete to determine if there is a...
void setObjectSize(int ObjectIdx, int64_t Size)
Change the size of the specified stack object.
void setStackID(int ObjectIdx, uint8_t ID)
bool hasStackMap() const
This method may be called any time after instruction selection is complete to determine if there is a...
uint8_t getStackID(int ObjectIdx) const
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.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
const char * createExternalSymbolName(StringRef Name)
Allocate a string and populate it with the given external symbol name.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & addExternalSymbol(const char *FnName, unsigned TargetFlags=0) const
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
MachineOperand class - Representation of each machine instruction operand.
Wrapper class representing virtual and physical registers.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
bool hasFP(const MachineFunction &MF) const
hasFP - Return true if the specified function should have a dedicated frame pointer register.
virtual bool isSupportedStackID(TargetStackID::Value ID) const
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
static unsigned getOpcAdd(const MachineFunction &MF)
static unsigned getFPReg(const MachineFunction &MF)
bool needsPrologForEH(const MachineFunction &MF) const
static unsigned getOpcGlobSet(const MachineFunction &MF)
bool hasReservedCallFrame(const MachineFunction &MF) const override
Under normal circumstances, when a frame pointer is not required, we reserve argument space for call ...
static unsigned getOpcAnd(const MachineFunction &MF)
static unsigned getSPReg(const MachineFunction &MF)
static unsigned getOpcGlobGet(const MachineFunction &MF)
DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const override
Return the frame base information to be encoded in the DWARF subprogram debug info.
bool isSupportedStackID(TargetStackID::Value ID) const override
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...
static unsigned getOpcConst(const MachineFunction &MF)
bool hasFPImpl(const MachineFunction &MF) const override
Return true if the specified function should have a dedicated frame pointer register.
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
These methods insert prolog and epilog code into the function.
void writeSPToGlobal(unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const
Write SP back to __stack_pointer global.
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
static const size_t RedZoneSize
Size of the red zone for the user stack (leaf functions can use this much space below the stack point...
static std::optional< unsigned > getLocalForStackObject(MachineFunction &MF, int FrameIndex)
static unsigned getOpcSub(const MachineFunction &MF)
This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information ...
unsigned getFrameBaseLocal() const
const std::vector< MVT > & getLocals() const
bool isFrameBaseVirtual() const
const std::vector< MVT > & getParams() const
bool isArgument(unsigned Opc)
bool isWasmVarAddressSpace(unsigned AS)
This is an optimization pass for GlobalISel generic memory operations.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
@ Wasm
WebAssembly Exception Handling.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< EVT > *MemVTs, SmallVectorImpl< TypeSize > *Offsets=nullptr, TypeSize StartingOffset=TypeSize::getZero())
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
union llvm::TargetFrameLowering::DwarfFrameBase::@248 Location
enum llvm::TargetFrameLowering::DwarfFrameBase::FrameBaseKind Kind
struct WasmFrameBase WasmLoc
