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 /// \brief 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 "llvm/CodeGen/MachineFrameInfo.h"
28 #include "llvm/CodeGen/MachineFunction.h"
29 #include "llvm/CodeGen/MachineInstrBuilder.h"
30 #include "llvm/CodeGen/MachineModuleInfo.h"
31 #include "llvm/CodeGen/MachineRegisterInfo.h"
32 #include "llvm/Support/Debug.h"
33 using namespace llvm;
34 
35 #define DEBUG_TYPE "wasm-frame-info"
36 
37 // TODO: wasm64
38 // TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions
39 
40 /// Return true if the specified function should have a dedicated frame pointer
41 /// register.
42 bool WebAssemblyFrameLowering::hasFP(const MachineFunction &MF) const {
43   const MachineFrameInfo *MFI = MF.getFrameInfo();
44   const auto *RegInfo =
45       MF.getSubtarget<WebAssemblySubtarget>().getRegisterInfo();
46   return MFI->isFrameAddressTaken() || MFI->hasVarSizedObjects() ||
47          MFI->hasStackMap() || MFI->hasPatchPoint() ||
48          RegInfo->needsStackRealignment(MF);
49 }
50 
51 /// Under normal circumstances, when a frame pointer is not required, we reserve
52 /// argument space for call sites in the function immediately on entry to the
53 /// current function. This eliminates the need for add/sub sp brackets around
54 /// call sites. Returns true if the call frame is included as part of the stack
55 /// frame.
56 bool WebAssemblyFrameLowering::hasReservedCallFrame(
57     const MachineFunction &MF) const {
58   return !MF.getFrameInfo()->hasVarSizedObjects();
59 }
60 
61 
62 /// Returns true if this function needs a local user-space stack pointer.
63 /// Unlike a machine stack pointer, the wasm user stack pointer is a global
64 /// variable, so it is loaded into a register in the prolog.
65 bool WebAssemblyFrameLowering::needsSP(const MachineFunction &MF,
66                                        const MachineFrameInfo &MFI) const {
67   return MFI.getStackSize() || MFI.adjustsStack() || hasFP(MF);
68 }
69 
70 /// Returns true if the local user-space stack pointer needs to be written back
71 /// to memory by this function (this is not meaningful if needsSP is false). If
72 /// false, the stack red zone can be used and only a local SP is needed.
73 bool WebAssemblyFrameLowering::needsSPWriteback(
74     const MachineFunction &MF, const MachineFrameInfo &MFI) const {
75   return MFI.getStackSize() > RedZoneSize || MFI.hasCalls() ||
76          MF.getFunction()->hasFnAttribute(Attribute::NoRedZone);
77 }
78 
79 static void writeSPToMemory(unsigned SrcReg, MachineFunction &MF,
80                             MachineBasicBlock &MBB,
81                             MachineBasicBlock::iterator &InsertAddr,
82                             MachineBasicBlock::iterator &InsertStore,
83                             DebugLoc DL) {
84   auto *SPSymbol = MF.createExternalSymbolName("__stack_pointer");
85   unsigned SPAddr =
86       MF.getRegInfo().createVirtualRegister(&WebAssembly::I32RegClass);
87   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
88 
89   BuildMI(MBB, InsertAddr, DL, TII->get(WebAssembly::CONST_I32), SPAddr)
90       .addExternalSymbol(SPSymbol);
91   auto *MMO = new MachineMemOperand(MachinePointerInfo(),
92                                     MachineMemOperand::MOStore, 4, 4);
93   BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::STORE_I32),
94           SrcReg)
95       .addImm(0)
96       .addReg(SPAddr)
97       .addImm(2)  // p2align
98       .addReg(SrcReg)
99       .addMemOperand(MMO);
100   MF.getInfo<WebAssemblyFunctionInfo>()->stackifyVReg(SPAddr);
101 }
102 
103 void WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
104     MachineFunction &MF, MachineBasicBlock &MBB,
105     MachineBasicBlock::iterator I) const {
106   assert(!I->getOperand(0).getImm() && hasFP(MF) &&
107          "Call frame pseudos should only be used for dynamic stack adjustment");
108   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
109   if (I->getOpcode() == TII->getCallFrameDestroyOpcode() &&
110       needsSPWriteback(MF, *MF.getFrameInfo())) {
111     DebugLoc DL = I->getDebugLoc();
112     writeSPToMemory(WebAssembly::SP32, MF, MBB, I, I, DL);
113   }
114   MBB.erase(I);
115 }
116 
117 void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
118                                             MachineBasicBlock &MBB) const {
119   // TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions
120   auto *MFI = MF.getFrameInfo();
121   assert(MFI->getCalleeSavedInfo().empty() &&
122          "WebAssembly should not have callee-saved registers");
123   auto *WFI = MF.getInfo<WebAssemblyFunctionInfo>();
124 
125   if (!needsSP(MF, *MFI)) return;
126   uint64_t StackSize = MFI->getStackSize();
127 
128   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
129   auto &MRI = MF.getRegInfo();
130 
131   auto InsertPt = MBB.begin();
132   DebugLoc DL;
133 
134   unsigned SPAddr = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
135   unsigned SPReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
136   auto *SPSymbol = MF.createExternalSymbolName("__stack_pointer");
137   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), SPAddr)
138       .addExternalSymbol(SPSymbol);
139   // This MachinePointerInfo should reference __stack_pointer as well but
140   // doesn't because MachinePointerInfo() takes a GV which we don't have for
141   // __stack_pointer. TODO: check if PseudoSourceValue::ExternalSymbolCallEntry
142   // is appropriate instead. (likewise for EmitEpologue below)
143   auto *LoadMMO = new MachineMemOperand(MachinePointerInfo(),
144                                         MachineMemOperand::MOLoad, 4, 4);
145   // Load the SP value.
146   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::LOAD_I32),
147           StackSize ? SPReg : (unsigned)WebAssembly::SP32)
148       .addImm(0)       // offset
149       .addReg(SPAddr)  // addr
150       .addImm(2)       // p2align
151       .addMemOperand(LoadMMO);
152   WFI->stackifyVReg(SPAddr);
153 
154   if (StackSize) {
155     // Subtract the frame size
156     unsigned OffsetReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
157     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
158         .addImm(StackSize);
159     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::SUB_I32),
160             WebAssembly::SP32)
161         .addReg(SPReg)
162         .addReg(OffsetReg);
163     WFI->stackifyVReg(OffsetReg);
164     WFI->stackifyVReg(SPReg);
165   }
166   if (hasFP(MF)) {
167     // Unlike most conventional targets (where FP points to the saved FP),
168     // FP points to the bottom of the fixed-size locals, so we can use positive
169     // offsets in load/store instructions.
170     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY_LOCAL_I32),
171             WebAssembly::FP32)
172         .addReg(WebAssembly::SP32);
173   }
174   if (StackSize && needsSPWriteback(MF, *MFI)) {
175     writeSPToMemory(WebAssembly::SP32, MF, MBB, InsertPt, InsertPt, DL);
176   }
177 }
178 
179 void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
180                                             MachineBasicBlock &MBB) const {
181   auto *MFI = MF.getFrameInfo();
182   uint64_t StackSize = MFI->getStackSize();
183   if (!needsSP(MF, *MFI) || !needsSPWriteback(MF, *MFI)) return;
184   auto *WFI = MF.getInfo<WebAssemblyFunctionInfo>();
185   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
186   auto &MRI = MF.getRegInfo();
187   auto InsertPt = MBB.getFirstTerminator();
188   DebugLoc DL;
189 
190   if (InsertPt != MBB.end()) {
191     DL = InsertPt->getDebugLoc();
192   }
193 
194   // Restore the stack pointer. If we had fixed-size locals, add the offset
195   // subtracted in the prolog.
196   unsigned SPReg = 0;
197   MachineBasicBlock::iterator InsertAddr = InsertPt;
198   if (StackSize) {
199     unsigned OffsetReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
200     InsertAddr =
201         BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
202             .addImm(StackSize);
203     // In the epilog we don't need to write the result back to the SP32 physreg
204     // because it won't be used again. We can use a stackified register instead.
205     SPReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
206     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::ADD_I32), SPReg)
207         .addReg(hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32)
208         .addReg(OffsetReg);
209     WFI->stackifyVReg(OffsetReg);
210     WFI->stackifyVReg(SPReg);
211   } else {
212     SPReg = hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32;
213   }
214 
215   writeSPToMemory(SPReg, MF, MBB, InsertAddr, InsertPt, DL);
216 }
217