LLVM 18.0.0git
Go to the documentation of this file.
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
9/// \file
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.
23#include "WebAssembly.h"
35#include "llvm/MC/MCAsmInfo.h"
36#include "llvm/Support/Debug.h"
37using namespace llvm;
39#define DEBUG_TYPE "wasm-frame-info"
41// TODO: wasm64
42// TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions
44// In an ideal world, when objects are added to the MachineFrameInfo by
45// FunctionLoweringInfo::set, we could somehow hook into target-specific code to
46// ensure they are assigned the right stack ID. However there isn't a hook that
47// runs between then and DAG building time, though, so instead we hoist stack
48// objects lazily when they are first used, and comprehensively after the DAG is
49// built via the PreprocessISelDAG hook, called by the
50// SelectionDAGISel::runOnMachineFunction. We have to do it in two places
51// because we want to do it while building the selection DAG for uses of alloca,
52// but not all alloca instructions are used so we have to follow up afterwards.
55 int FrameIndex) {
58 // If already hoisted to a local, done.
59 if (MFI.getStackID(FrameIndex) == TargetStackID::WasmLocal)
60 return static_cast<unsigned>(MFI.getObjectOffset(FrameIndex));
62 // If not allocated in the object address space, this object will be in
63 // linear memory.
64 const AllocaInst *AI = MFI.getObjectAllocation(FrameIndex);
66 return std::nullopt;
68 // Otherwise, allocate this object in the named value stack, outside of linear
69 // memory.
70 SmallVector<EVT, 4> ValueVTs;
71 const WebAssemblyTargetLowering &TLI =
72 *MF.getSubtarget<WebAssemblySubtarget>().getTargetLowering();
74 ComputeValueVTs(TLI, MF.getDataLayout(), AI->getAllocatedType(), ValueVTs);
75 MFI.setStackID(FrameIndex, TargetStackID::WasmLocal);
76 // Abuse SP offset to record the index of the first local in the object.
77 unsigned Local = FuncInfo->getParams().size() + FuncInfo->getLocals().size();
78 MFI.setObjectOffset(FrameIndex, Local);
79 // Allocate WebAssembly locals for each non-aggregate component of the
80 // allocation.
81 for (EVT ValueVT : ValueVTs)
82 FuncInfo->addLocal(ValueVT.getSimpleVT());
83 // Abuse object size to record number of WebAssembly locals allocated to
84 // this object.
85 MFI.setObjectSize(FrameIndex, ValueVTs.size());
86 return static_cast<unsigned>(Local);
89/// We need a base pointer in the case of having items on the stack that
90/// require stricter alignment than the stack pointer itself. Because we need
91/// to shift the stack pointer by some unknown amount to force the alignment,
92/// we need to record the value of the stack pointer on entry to the function.
93bool WebAssemblyFrameLowering::hasBP(const MachineFunction &MF) const {
94 const auto *RegInfo =
95 MF.getSubtarget<WebAssemblySubtarget>().getRegisterInfo();
96 return RegInfo->hasStackRealignment(MF);
99/// Return true if the specified function should have a dedicated frame pointer
100/// register.
102 const MachineFrameInfo &MFI = MF.getFrameInfo();
104 // When we have var-sized objects, we move the stack pointer by an unknown
105 // amount, and need to emit a frame pointer to restore the stack to where we
106 // were on function entry.
107 // If we already need a base pointer, we use that to fix up the stack pointer.
108 // If there are no fixed-size objects, we would have no use of a frame
109 // pointer, and thus should not emit one.
110 bool HasFixedSizedObjects = MFI.getStackSize() > 0;
111 bool NeedsFixedReference = !hasBP(MF) || HasFixedSizedObjects;
113 return MFI.isFrameAddressTaken() ||
114 (MFI.hasVarSizedObjects() && NeedsFixedReference) ||
115 MFI.hasStackMap() || MFI.hasPatchPoint();
118/// Under normal circumstances, when a frame pointer is not required, we reserve
119/// argument space for call sites in the function immediately on entry to the
120/// current function. This eliminates the need for add/sub sp brackets around
121/// call sites. Returns true if the call frame is included as part of the stack
122/// frame.
124 const MachineFunction &MF) const {
125 return !MF.getFrameInfo().hasVarSizedObjects();
128// Returns true if this function needs a local user-space stack pointer for its
129// local frame (not for exception handling).
130bool WebAssemblyFrameLowering::needsSPForLocalFrame(
131 const MachineFunction &MF) const {
132 auto &MFI = MF.getFrameInfo();
133 return MFI.getStackSize() || MFI.adjustsStack() || hasFP(MF);
136// In function with EH pads, we need to make a copy of the value of
137// __stack_pointer global in SP32/64 register, in order to use it when
138// restoring __stack_pointer after an exception is caught.
140 const MachineFunction &MF) const {
141 auto EHType = MF.getTarget().getMCAsmInfo()->getExceptionHandlingType();
142 return EHType == ExceptionHandling::Wasm &&
146/// Returns true if this function needs a local user-space stack pointer.
147/// Unlike a machine stack pointer, the wasm user stack pointer is a global
148/// variable, so it is loaded into a register in the prolog.
149bool WebAssemblyFrameLowering::needsSP(const MachineFunction &MF) const {
150 return needsSPForLocalFrame(MF) || needsPrologForEH(MF);
153/// Returns true if the local user-space stack pointer needs to be written back
154/// to __stack_pointer global by this function (this is not meaningful if
155/// needsSP is false). If false, the stack red zone can be used and only a local
156/// SP is needed.
157bool WebAssemblyFrameLowering::needsSPWriteback(
158 const MachineFunction &MF) const {
159 auto &MFI = MF.getFrameInfo();
160 assert(needsSP(MF));
161 // When we don't need a local stack pointer for its local frame but only to
162 // support EH, we don't need to write SP back in the epilog, because we don't
163 // bump down the stack pointer in the prolog. We need to write SP back in the
164 // epilog only if
165 // 1. We need SP not only for EH support but also because we actually use
166 // stack or we have a frame address taken.
167 // 2. We cannot use the red zone.
168 bool CanUseRedZone = MFI.getStackSize() <= RedZoneSize && !MFI.hasCalls() &&
169 !MF.getFunction().hasFnAttribute(Attribute::NoRedZone);
170 return needsSPForLocalFrame(MF) && !CanUseRedZone;
174 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
175 ? WebAssembly::SP64
176 : WebAssembly::SP32;
180 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
181 ? WebAssembly::FP64
182 : WebAssembly::FP32;
187 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
188 ? WebAssembly::CONST_I64
189 : WebAssembly::CONST_I32;
193 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
194 ? WebAssembly::ADD_I64
195 : WebAssembly::ADD_I32;
199 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
200 ? WebAssembly::SUB_I64
201 : WebAssembly::SUB_I32;
205 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
206 ? WebAssembly::AND_I64
207 : WebAssembly::AND_I32;
212 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
213 ? WebAssembly::GLOBAL_GET_I64
214 : WebAssembly::GLOBAL_GET_I32;
219 return MF.getSubtarget<WebAssemblySubtarget>().hasAddr64()
220 ? WebAssembly::GLOBAL_SET_I64
221 : WebAssembly::GLOBAL_SET_I32;
225 unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB,
226 MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const {
227 const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
229 const char *ES = "__stack_pointer";
230 auto *SPSymbol = MF.createExternalSymbolName(ES);
232 BuildMI(MBB, InsertStore, DL, TII->get(getOpcGlobSet(MF)))
233 .addExternalSymbol(SPSymbol)
234 .addReg(SrcReg);
241 assert(!I->getOperand(0).getImm() && (hasFP(MF) || hasBP(MF)) &&
242 "Call frame pseudos should only be used for dynamic stack adjustment");
243 auto &ST = MF.getSubtarget<WebAssemblySubtarget>();
244 const auto *TII = ST.getInstrInfo();
245 if (I->getOpcode() == TII->getCallFrameDestroyOpcode() &&
246 needsSPWriteback(MF)) {
247 DebugLoc DL = I->getDebugLoc();
248 writeSPToGlobal(getSPReg(MF), MF, MBB, I, DL);
249 }
250 return MBB.erase(I);
254 MachineBasicBlock &MBB) const {
255 // TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions
256 auto &MFI = MF.getFrameInfo();
257 assert(MFI.getCalleeSavedInfo().empty() &&
258 "WebAssembly should not have callee-saved registers");
260 if (!needsSP(MF))
261 return;
262 uint64_t StackSize = MFI.getStackSize();
264 auto &ST = MF.getSubtarget<WebAssemblySubtarget>();
265 const auto *TII = ST.getInstrInfo();
266 auto &MRI = MF.getRegInfo();
268 auto InsertPt = MBB.begin();
269 while (InsertPt != MBB.end() &&
270 WebAssembly::isArgument(InsertPt->getOpcode()))
271 ++InsertPt;
272 DebugLoc DL;
274 const TargetRegisterClass *PtrRC =
275 MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
276 unsigned SPReg = getSPReg(MF);
277 if (StackSize)
278 SPReg = MRI.createVirtualRegister(PtrRC);
280 const char *ES = "__stack_pointer";
281 auto *SPSymbol = MF.createExternalSymbolName(ES);
282 BuildMI(MBB, InsertPt, DL, TII->get(getOpcGlobGet(MF)), SPReg)
283 .addExternalSymbol(SPSymbol);
285 bool HasBP = hasBP(MF);
286 if (HasBP) {
287 auto FI = MF.getInfo<WebAssemblyFunctionInfo>();
288 Register BasePtr = MRI.createVirtualRegister(PtrRC);
289 FI->setBasePointerVreg(BasePtr);
290 BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY), BasePtr)
291 .addReg(SPReg);
292 }
293 if (StackSize) {
294 // Subtract the frame size
295 Register OffsetReg = MRI.createVirtualRegister(PtrRC);
296 BuildMI(MBB, InsertPt, DL, TII->get(getOpcConst(MF)), OffsetReg)
297 .addImm(StackSize);
298 BuildMI(MBB, InsertPt, DL, TII->get(getOpcSub(MF)), getSPReg(MF))
299 .addReg(SPReg)
300 .addReg(OffsetReg);
301 }
302 if (HasBP) {
303 Register BitmaskReg = MRI.createVirtualRegister(PtrRC);
304 Align Alignment = MFI.getMaxAlign();
305 BuildMI(MBB, InsertPt, DL, TII->get(getOpcConst(MF)), BitmaskReg)
306 .addImm((int64_t) ~(Alignment.value() - 1));
307 BuildMI(MBB, InsertPt, DL, TII->get(getOpcAnd(MF)), getSPReg(MF))
308 .addReg(getSPReg(MF))
309 .addReg(BitmaskReg);
310 }
311 if (hasFP(MF)) {
312 // Unlike most conventional targets (where FP points to the saved FP),
313 // FP points to the bottom of the fixed-size locals, so we can use positive
314 // offsets in load/store instructions.
315 BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY), getFPReg(MF))
316 .addReg(getSPReg(MF));
317 }
318 if (StackSize && needsSPWriteback(MF)) {
319 writeSPToGlobal(getSPReg(MF), MF, MBB, InsertPt, DL);
320 }
324 MachineBasicBlock &MBB) const {
325 uint64_t StackSize = MF.getFrameInfo().getStackSize();
326 if (!needsSP(MF) || !needsSPWriteback(MF))
327 return;
328 auto &ST = MF.getSubtarget<WebAssemblySubtarget>();
329 const auto *TII = ST.getInstrInfo();
330 auto &MRI = MF.getRegInfo();
331 auto InsertPt = MBB.getFirstTerminator();
332 DebugLoc DL;
334 if (InsertPt != MBB.end())
335 DL = InsertPt->getDebugLoc();
337 // Restore the stack pointer. If we had fixed-size locals, add the offset
338 // subtracted in the prolog.
339 unsigned SPReg = 0;
340 unsigned SPFPReg = hasFP(MF) ? getFPReg(MF) : getSPReg(MF);
341 if (hasBP(MF)) {
342 auto FI = MF.getInfo<WebAssemblyFunctionInfo>();
343 SPReg = FI->getBasePointerVreg();
344 } else if (StackSize) {
345 const TargetRegisterClass *PtrRC =
346 MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
347 Register OffsetReg = MRI.createVirtualRegister(PtrRC);
348 BuildMI(MBB, InsertPt, DL, TII->get(getOpcConst(MF)), OffsetReg)
349 .addImm(StackSize);
350 // In the epilog we don't need to write the result back to the SP32/64
351 // physreg because it won't be used again. We can use a stackified register
352 // instead.
353 SPReg = MRI.createVirtualRegister(PtrRC);
354 BuildMI(MBB, InsertPt, DL, TII->get(getOpcAdd(MF)), SPReg)
355 .addReg(SPFPReg)
356 .addReg(OffsetReg);
357 } else {
358 SPReg = SPFPReg;
359 }
361 writeSPToGlobal(SPReg, MF, MBB, InsertPt, DL);
365 TargetStackID::Value ID) const {
366 // Use the Object stack for WebAssembly locals which can only be accessed
367 // by name, not via an address in linear memory.
369 return true;
376 DwarfFrameBase Loc;
377 Loc.Kind = DwarfFrameBase::WasmFrameBase;
379 if (needsSP(MF) && MFI.isFrameBaseVirtual()) {
380 unsigned LocalNum = MFI.getFrameBaseLocal();
382 } else {
383 // TODO: This should work on a breakpoint at a function with no frame,
384 // but probably won't work for traversing up the stack.
386 }
387 return Loc;
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
const HexagonInstrInfo * TII
#define I(x, y, z)
Definition: MD5.cpp:58
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
Definition: Instructions.h:58
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:118
unsigned getAddressSpace() const
Return the address space for the allocation.
Definition: Instructions.h:105
A debug info location.
Definition: DebugLoc.h:33
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:815
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:645
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:781
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.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
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.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
size_t size() const
Definition: SmallVector.h:91
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
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)
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.
bool hasFP(const MachineFunction &MF) const override
Return true if the specified function should have a dedicated frame pointer register.
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 ...
const std::vector< MVT > & getLocals() 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.
Definition: AddressRanges.h:18
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< TypeSize > *Offsets, TypeSize StartingOffset)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
Definition: Analysis.cpp:122
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
@ Wasm
WebAssembly Exception Handling.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
Extended Value Type.
Definition: ValueTypes.h:34
union llvm::TargetFrameLowering::DwarfFrameBase::@235 Location
enum llvm::TargetFrameLowering::DwarfFrameBase::FrameBaseKind Kind