Line data Source code
1 : //===-- WebAssemblyFrameLowering.cpp - WebAssembly Frame Lowering ----------==//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : ///
10 : /// \file
11 : /// This file contains the WebAssembly implementation of
12 : /// TargetFrameLowering class.
13 : ///
14 : /// On WebAssembly, there aren't a lot of things to do here. There are no
15 : /// callee-saved registers to save, and no spill slots.
16 : ///
17 : /// The stack grows downward.
18 : ///
19 : //===----------------------------------------------------------------------===//
20 :
21 : #include "WebAssemblyFrameLowering.h"
22 : #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
23 : #include "WebAssemblyInstrInfo.h"
24 : #include "WebAssemblyMachineFunctionInfo.h"
25 : #include "WebAssemblySubtarget.h"
26 : #include "WebAssemblyTargetMachine.h"
27 : #include "WebAssemblyUtilities.h"
28 : #include "llvm/CodeGen/MachineFrameInfo.h"
29 : #include "llvm/CodeGen/MachineFunction.h"
30 : #include "llvm/CodeGen/MachineInstrBuilder.h"
31 : #include "llvm/CodeGen/MachineModuleInfoImpls.h"
32 : #include "llvm/CodeGen/MachineRegisterInfo.h"
33 : #include "llvm/MC/MCAsmInfo.h"
34 : #include "llvm/Support/Debug.h"
35 : using namespace llvm;
36 :
37 : #define DEBUG_TYPE "wasm-frame-info"
38 :
39 : // TODO: wasm64
40 : // TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions
41 :
42 : /// We need a base pointer in the case of having items on the stack that
43 : /// require stricter alignment than the stack pointer itself. Because we need
44 : /// to shift the stack pointer by some unknown amount to force the alignment,
45 : /// we need to record the value of the stack pointer on entry to the function.
46 9605 : bool WebAssemblyFrameLowering::hasBP(const MachineFunction &MF) const {
47 : const auto *RegInfo =
48 9605 : MF.getSubtarget<WebAssemblySubtarget>().getRegisterInfo();
49 9605 : return RegInfo->needsStackRealignment(MF);
50 : }
51 :
52 : /// Return true if the specified function should have a dedicated frame pointer
53 : /// register.
54 9443 : bool WebAssemblyFrameLowering::hasFP(const MachineFunction &MF) const {
55 9443 : const MachineFrameInfo &MFI = MF.getFrameInfo();
56 :
57 : // When we have var-sized objects, we move the stack pointer by an unknown
58 : // amount, and need to emit a frame pointer to restore the stack to where we
59 : // were on function entry.
60 : // If we already need a base pointer, we use that to fix up the stack pointer.
61 : // If there are no fixed-size objects, we would have no use of a frame
62 : // pointer, and thus should not emit one.
63 9443 : bool HasFixedSizedObjects = MFI.getStackSize() > 0;
64 9443 : bool NeedsFixedReference = !hasBP(MF) || HasFixedSizedObjects;
65 :
66 18865 : return MFI.isFrameAddressTaken() ||
67 9422 : (MFI.hasVarSizedObjects() && NeedsFixedReference) ||
68 18831 : MFI.hasStackMap() || MFI.hasPatchPoint();
69 : }
70 :
71 : /// Under normal circumstances, when a frame pointer is not required, we reserve
72 : /// argument space for call sites in the function immediately on entry to the
73 : /// current function. This eliminates the need for add/sub sp brackets around
74 : /// call sites. Returns true if the call frame is included as part of the stack
75 : /// frame.
76 26 : bool WebAssemblyFrameLowering::hasReservedCallFrame(
77 : const MachineFunction &MF) const {
78 26 : return !MF.getFrameInfo().hasVarSizedObjects();
79 : }
80 :
81 : // Returns true if this function needs a local user-space stack pointer for its
82 : // local frame (not for exception handling).
83 6149 : bool WebAssemblyFrameLowering::needsSPForLocalFrame(
84 : const MachineFunction &MF) const {
85 6149 : auto &MFI = MF.getFrameInfo();
86 6149 : return MFI.getStackSize() || MFI.adjustsStack() || hasFP(MF);
87 : }
88 :
89 : // In function with EH pads, we need to make a copy of the value of
90 : // __stack_pointer global in SP32 register, in order to use it when restoring
91 : // __stack_pointer after an exception is caught.
92 8786 : bool WebAssemblyFrameLowering::needsPrologForEH(
93 : const MachineFunction &MF) const {
94 8786 : auto EHType = MF.getTarget().getMCAsmInfo()->getExceptionHandlingType();
95 21 : return EHType == ExceptionHandling::Wasm &&
96 8786 : MF.getFunction().hasPersonalityFn() && MF.getFrameInfo().hasCalls();
97 : }
98 :
99 : /// Returns true if this function needs a local user-space stack pointer.
100 : /// Unlike a machine stack pointer, the wasm user stack pointer is a global
101 : /// variable, so it is loaded into a register in the prolog.
102 5973 : bool WebAssemblyFrameLowering::needsSP(const MachineFunction &MF) const {
103 5973 : return needsSPForLocalFrame(MF) || needsPrologForEH(MF);
104 : }
105 :
106 : /// Returns true if the local user-space stack pointer needs to be written back
107 : /// to __stack_pointer global by this function (this is not meaningful if
108 : /// needsSP is false). If false, the stack red zone can be used and only a local
109 : /// SP is needed.
110 176 : bool WebAssemblyFrameLowering::needsSPWriteback(
111 : const MachineFunction &MF) const {
112 176 : auto &MFI = MF.getFrameInfo();
113 : assert(needsSP(MF));
114 : // When we don't need a local stack pointer for its local frame but only to
115 : // support EH, we don't need to write SP back in the epilog, because we don't
116 : // bump down the stack pointer in the prolog. We need to write SP back in the
117 : // epilog only if
118 : // 1. We need SP not only for EH support but also because we actually use
119 : // stack or we have a frame address taken.
120 : // 2. We cannot use the red zone.
121 212 : bool CanUseRedZone = MFI.getStackSize() <= RedZoneSize && !MFI.hasCalls() &&
122 36 : !MF.getFunction().hasFnAttribute(Attribute::NoRedZone);
123 176 : return needsSPForLocalFrame(MF) && !CanUseRedZone;
124 : }
125 :
126 163 : void WebAssemblyFrameLowering::writeSPToGlobal(
127 : unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB,
128 : MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const {
129 163 : const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
130 :
131 : const char *ES = "__stack_pointer";
132 163 : auto *SPSymbol = MF.createExternalSymbolName(ES);
133 326 : BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::SET_GLOBAL_I32))
134 : .addExternalSymbol(SPSymbol, WebAssemblyII::MO_SYMBOL_GLOBAL)
135 163 : .addReg(SrcReg);
136 163 : }
137 :
138 : MachineBasicBlock::iterator
139 18 : WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
140 : MachineFunction &MF, MachineBasicBlock &MBB,
141 : MachineBasicBlock::iterator I) const {
142 : assert(!I->getOperand(0).getImm() && (hasFP(MF) || hasBP(MF)) &&
143 : "Call frame pseudos should only be used for dynamic stack adjustment");
144 18 : const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
145 45 : if (I->getOpcode() == TII->getCallFrameDestroyOpcode() &&
146 9 : needsSPWriteback(MF)) {
147 : DebugLoc DL = I->getDebugLoc();
148 8 : writeSPToGlobal(WebAssembly::SP32, MF, MBB, I, DL);
149 : }
150 18 : return MBB.erase(I);
151 : }
152 :
153 2983 : void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
154 : MachineBasicBlock &MBB) const {
155 : // TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions
156 2983 : auto &MFI = MF.getFrameInfo();
157 : assert(MFI.getCalleeSavedInfo().empty() &&
158 : "WebAssembly should not have callee-saved registers");
159 :
160 2983 : if (!needsSP(MF))
161 2891 : return;
162 92 : uint64_t StackSize = MFI.getStackSize();
163 :
164 92 : const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
165 92 : auto &MRI = MF.getRegInfo();
166 :
167 92 : auto InsertPt = MBB.begin();
168 227 : while (InsertPt != MBB.end() && WebAssembly::isArgument(*InsertPt))
169 : ++InsertPt;
170 92 : DebugLoc DL;
171 :
172 : const TargetRegisterClass *PtrRC =
173 92 : MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
174 : unsigned SPReg = WebAssembly::SP32;
175 92 : if (StackSize)
176 79 : SPReg = MRI.createVirtualRegister(PtrRC);
177 :
178 : const char *ES = "__stack_pointer";
179 92 : auto *SPSymbol = MF.createExternalSymbolName(ES);
180 184 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::GET_GLOBAL_I32), SPReg)
181 : .addExternalSymbol(SPSymbol, WebAssemblyII::MO_SYMBOL_GLOBAL);
182 :
183 92 : bool HasBP = hasBP(MF);
184 92 : if (HasBP) {
185 : auto FI = MF.getInfo<WebAssemblyFunctionInfo>();
186 5 : unsigned BasePtr = MRI.createVirtualRegister(PtrRC);
187 : FI->setBasePointerVreg(BasePtr);
188 15 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY), BasePtr)
189 5 : .addReg(SPReg);
190 : }
191 92 : if (StackSize) {
192 : // Subtract the frame size
193 79 : unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
194 158 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
195 79 : .addImm(StackSize);
196 79 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::SUB_I32),
197 158 : WebAssembly::SP32)
198 79 : .addReg(SPReg)
199 79 : .addReg(OffsetReg);
200 : }
201 92 : if (HasBP) {
202 5 : unsigned BitmaskReg = MRI.createVirtualRegister(PtrRC);
203 5 : unsigned Alignment = MFI.getMaxAlignment();
204 : assert((1u << countTrailingZeros(Alignment)) == Alignment &&
205 : "Alignment must be a power of 2");
206 10 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), BitmaskReg)
207 5 : .addImm((int)~(Alignment - 1));
208 5 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::AND_I32),
209 10 : WebAssembly::SP32)
210 5 : .addReg(WebAssembly::SP32)
211 5 : .addReg(BitmaskReg);
212 : }
213 92 : if (hasFP(MF)) {
214 : // Unlike most conventional targets (where FP points to the saved FP),
215 : // FP points to the bottom of the fixed-size locals, so we can use positive
216 : // offsets in load/store instructions.
217 30 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY), WebAssembly::FP32)
218 10 : .addReg(WebAssembly::SP32);
219 : }
220 92 : if (StackSize && needsSPWriteback(MF)) {
221 67 : writeSPToGlobal(WebAssembly::SP32, MF, MBB, InsertPt, DL);
222 : }
223 : }
224 :
225 2990 : void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
226 : MachineBasicBlock &MBB) const {
227 2990 : uint64_t StackSize = MF.getFrameInfo().getStackSize();
228 2990 : if (!needsSP(MF) || !needsSPWriteback(MF))
229 2920 : return;
230 70 : const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
231 70 : auto &MRI = MF.getRegInfo();
232 70 : auto InsertPt = MBB.getFirstTerminator();
233 70 : DebugLoc DL;
234 :
235 70 : if (InsertPt != MBB.end())
236 : DL = InsertPt->getDebugLoc();
237 :
238 : // Restore the stack pointer. If we had fixed-size locals, add the offset
239 : // subtracted in the prolog.
240 : unsigned SPReg = 0;
241 70 : if (hasBP(MF)) {
242 : auto FI = MF.getInfo<WebAssemblyFunctionInfo>();
243 5 : SPReg = FI->getBasePointerVreg();
244 65 : } else if (StackSize) {
245 : const TargetRegisterClass *PtrRC =
246 59 : MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
247 59 : unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
248 177 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
249 59 : .addImm(StackSize);
250 : // In the epilog we don't need to write the result back to the SP32 physreg
251 : // because it won't be used again. We can use a stackified register instead.
252 59 : SPReg = MRI.createVirtualRegister(PtrRC);
253 177 : BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::ADD_I32), SPReg)
254 117 : .addReg(hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32)
255 59 : .addReg(OffsetReg);
256 : } else {
257 6 : SPReg = hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32;
258 : }
259 :
260 70 : writeSPToGlobal(SPReg, MF, MBB, InsertPt, DL);
261 : }
|
