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   assert(needsSP(MF, MFI));
76   return MFI.getStackSize() > RedZoneSize || MFI.hasCalls() ||
77          MF.getFunction()->hasFnAttribute(Attribute::NoRedZone);
78 }
79 
80 static void writeSPToMemory(unsigned SrcReg, MachineFunction &MF,
81                             MachineBasicBlock &MBB,
82                             MachineBasicBlock::iterator &InsertAddr,
83                             MachineBasicBlock::iterator &InsertStore,
84                             const DebugLoc &DL) {
85   const char *ES = "__stack_pointer";
86   auto *SPSymbol = MF.createExternalSymbolName(ES);
87   MachineRegisterInfo &MRI = MF.getRegInfo();
88   const TargetRegisterClass *PtrRC =
89       MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
90   unsigned Zero = MRI.createVirtualRegister(PtrRC);
91   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
92 
93   BuildMI(MBB, InsertAddr, DL, TII->get(WebAssembly::CONST_I32), Zero)
94       .addImm(0);
95   MachineMemOperand *MMO = MF.getMachineMemOperand(
96       MachinePointerInfo(MF.getPSVManager().getExternalSymbolCallEntry(ES)),
97       MachineMemOperand::MOStore, 4, 4);
98   BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::STORE_I32))
99       .addExternalSymbol(SPSymbol)
100       .addReg(Zero)
101       .addImm(2)  // p2align
102       .addReg(SrcReg)
103       .addMemOperand(MMO);
104 }
105 
106 MachineBasicBlock::iterator
107 WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
108     MachineFunction &MF, MachineBasicBlock &MBB,
109     MachineBasicBlock::iterator I) const {
110   assert(!I->getOperand(0).getImm() && hasFP(MF) &&
111          "Call frame pseudos should only be used for dynamic stack adjustment");
112   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
113   if (I->getOpcode() == TII->getCallFrameDestroyOpcode() &&
114       needsSPWriteback(MF, MF.getFrameInfo())) {
115     DebugLoc DL = I->getDebugLoc();
116     writeSPToMemory(WebAssembly::SP32, MF, MBB, I, I, DL);
117   }
118   return MBB.erase(I);
119 }
120 
121 void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
122                                             MachineBasicBlock &MBB) const {
123   // TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions
124   auto &MFI = MF.getFrameInfo();
125   assert(MFI.getCalleeSavedInfo().empty() &&
126          "WebAssembly should not have callee-saved registers");
127 
128   if (!needsSP(MF, MFI)) return;
129   uint64_t StackSize = MFI.getStackSize();
130 
131   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
132   auto &MRI = MF.getRegInfo();
133 
134   auto InsertPt = MBB.begin();
135   DebugLoc DL;
136 
137   const TargetRegisterClass *PtrRC =
138       MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
139   unsigned Zero = MRI.createVirtualRegister(PtrRC);
140   unsigned SPReg = MRI.createVirtualRegister(PtrRC);
141   const char *ES = "__stack_pointer";
142   auto *SPSymbol = MF.createExternalSymbolName(ES);
143   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), Zero)
144       .addImm(0);
145   MachineMemOperand *LoadMMO = MF.getMachineMemOperand(
146       MachinePointerInfo(MF.getPSVManager().getExternalSymbolCallEntry(ES)),
147       MachineMemOperand::MOLoad, 4, 4);
148   // Load the SP value.
149   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::LOAD_I32),
150           StackSize ? SPReg : (unsigned)WebAssembly::SP32)
151       .addExternalSymbol(SPSymbol)
152       .addReg(Zero)    // addr
153       .addImm(2)       // p2align
154       .addMemOperand(LoadMMO);
155 
156   if (StackSize) {
157     // Subtract the frame size
158     unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
159     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
160         .addImm(StackSize);
161     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::SUB_I32),
162             WebAssembly::SP32)
163         .addReg(SPReg)
164         .addReg(OffsetReg);
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),
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   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
185   auto &MRI = MF.getRegInfo();
186   auto InsertPt = MBB.getFirstTerminator();
187   DebugLoc DL;
188 
189   if (InsertPt != MBB.end())
190     DL = InsertPt->getDebugLoc();
191 
192   // Restore the stack pointer. If we had fixed-size locals, add the offset
193   // subtracted in the prolog.
194   unsigned SPReg = 0;
195   MachineBasicBlock::iterator InsertAddr = InsertPt;
196   if (StackSize) {
197     const TargetRegisterClass *PtrRC =
198         MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
199     unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
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(PtrRC);
206     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::ADD_I32), SPReg)
207         .addReg(hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32)
208         .addReg(OffsetReg);
209   } else {
210     SPReg = hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32;
211   }
212 
213   writeSPToMemory(SPReg, MF, MBB, InsertAddr, InsertPt, DL);
214 }
215