//===-- WebAssemblyFrameLowering.cpp - WebAssembly Frame Lowering ----------==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file contains the WebAssembly implementation of /// TargetFrameLowering class. /// /// On WebAssembly, there aren't a lot of things to do here. There are no /// callee-saved registers to save, and no spill slots. /// /// The stack grows downward. /// //===----------------------------------------------------------------------===// #include "WebAssemblyFrameLowering.h" #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" #include "Utils/WebAssemblyTypeUtilities.h" #include "WebAssembly.h" #include "WebAssemblyInstrInfo.h" #include "WebAssemblyMachineFunctionInfo.h" #include "WebAssemblySubtarget.h" #include "WebAssemblyTargetMachine.h" #include "llvm/CodeGen/Analysis.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineModuleInfoImpls.h" #include "llvm/CodeGen/MachineRegisterInfo.h" #include "llvm/IR/Instructions.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/Support/Debug.h" usingnamespacellvm; #define DEBUG_TYPE … // TODO: wasm64 // TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions // In an ideal world, when objects are added to the MachineFrameInfo by // FunctionLoweringInfo::set, we could somehow hook into target-specific code to // ensure they are assigned the right stack ID. However there isn't a hook that // runs between then and DAG building time, though, so instead we hoist stack // objects lazily when they are first used, and comprehensively after the DAG is // built via the PreprocessISelDAG hook, called by the // SelectionDAGISel::runOnMachineFunction. We have to do it in two places // because we want to do it while building the selection DAG for uses of alloca, // but not all alloca instructions are used so we have to follow up afterwards. std::optional<unsigned> WebAssemblyFrameLowering::getLocalForStackObject(MachineFunction &MF, int FrameIndex) { … } /// We need a base pointer in the case of having items on the stack that /// require stricter alignment than the stack pointer itself. Because we need /// to shift the stack pointer by some unknown amount to force the alignment, /// we need to record the value of the stack pointer on entry to the function. bool WebAssemblyFrameLowering::hasBP(const MachineFunction &MF) const { … } /// Return true if the specified function should have a dedicated frame pointer /// register. bool WebAssemblyFrameLowering::hasFP(const MachineFunction &MF) const { … } /// Under normal circumstances, when a frame pointer is not required, we reserve /// argument space for call sites in the function immediately on entry to the /// current function. This eliminates the need for add/sub sp brackets around /// call sites. Returns true if the call frame is included as part of the stack /// frame. bool WebAssemblyFrameLowering::hasReservedCallFrame( const MachineFunction &MF) const { … } // Returns true if this function needs a local user-space stack pointer for its // local frame (not for exception handling). bool WebAssemblyFrameLowering::needsSPForLocalFrame( const MachineFunction &MF) const { … } // In function with EH pads, we need to make a copy of the value of // __stack_pointer global in SP32/64 register, in order to use it when // restoring __stack_pointer after an exception is caught. bool WebAssemblyFrameLowering::needsPrologForEH( const MachineFunction &MF) const { … } /// Returns true if this function needs a local user-space stack pointer. /// Unlike a machine stack pointer, the wasm user stack pointer is a global /// variable, so it is loaded into a register in the prolog. bool WebAssemblyFrameLowering::needsSP(const MachineFunction &MF) const { … } /// Returns true if the local user-space stack pointer needs to be written back /// to __stack_pointer global by this function (this is not meaningful if /// needsSP is false). If false, the stack red zone can be used and only a local /// SP is needed. bool WebAssemblyFrameLowering::needsSPWriteback( const MachineFunction &MF) const { … } unsigned WebAssemblyFrameLowering::getSPReg(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getFPReg(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcConst(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcAdd(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcSub(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcAnd(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcGlobGet(const MachineFunction &MF) { … } unsigned WebAssemblyFrameLowering::getOpcGlobSet(const MachineFunction &MF) { … } void WebAssemblyFrameLowering::writeSPToGlobal( unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const { … } MachineBasicBlock::iterator WebAssemblyFrameLowering::eliminateCallFramePseudoInstr( MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const { … } void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const { … } void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const { … } bool WebAssemblyFrameLowering::isSupportedStackID( TargetStackID::Value ID) const { … } TargetFrameLowering::DwarfFrameBase WebAssemblyFrameLowering::getDwarfFrameBase(const MachineFunction &MF) const { … }