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 MachineBasicBlock::iterator
104 WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
105     MachineFunction &MF, MachineBasicBlock &MBB,
106     MachineBasicBlock::iterator I) const {
107   assert(!I->getOperand(0).getImm() && hasFP(MF) &&
108          "Call frame pseudos should only be used for dynamic stack adjustment");
109   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
110   if (I->getOpcode() == TII->getCallFrameDestroyOpcode() &&
111       needsSPWriteback(MF, *MF.getFrameInfo())) {
112     DebugLoc DL = I->getDebugLoc();
113     writeSPToMemory(WebAssembly::SP32, MF, MBB, I, I, DL);
114   }
115   return MBB.erase(I);
116 }
117 
118 void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
119                                             MachineBasicBlock &MBB) const {
120   // TODO: Do ".setMIFlag(MachineInstr::FrameSetup)" on emitted instructions
121   auto *MFI = MF.getFrameInfo();
122   assert(MFI->getCalleeSavedInfo().empty() &&
123          "WebAssembly should not have callee-saved registers");
124   auto *WFI = MF.getInfo<WebAssemblyFunctionInfo>();
125 
126   if (!needsSP(MF, *MFI)) return;
127   uint64_t StackSize = MFI->getStackSize();
128 
129   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
130   auto &MRI = MF.getRegInfo();
131 
132   auto InsertPt = MBB.begin();
133   DebugLoc DL;
134 
135   unsigned SPAddr = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
136   unsigned SPReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
137   auto *SPSymbol = MF.createExternalSymbolName("__stack_pointer");
138   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), SPAddr)
139       .addExternalSymbol(SPSymbol);
140   // This MachinePointerInfo should reference __stack_pointer as well but
141   // doesn't because MachinePointerInfo() takes a GV which we don't have for
142   // __stack_pointer. TODO: check if PseudoSourceValue::ExternalSymbolCallEntry
143   // is appropriate instead. (likewise for EmitEpologue below)
144   auto *LoadMMO = new MachineMemOperand(MachinePointerInfo(),
145                                         MachineMemOperand::MOLoad, 4, 4);
146   // Load the SP value.
147   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::LOAD_I32),
148           StackSize ? SPReg : (unsigned)WebAssembly::SP32)
149       .addImm(0)       // offset
150       .addReg(SPAddr)  // addr
151       .addImm(2)       // p2align
152       .addMemOperand(LoadMMO);
153   WFI->stackifyVReg(SPAddr);
154 
155   if (StackSize) {
156     // Subtract the frame size
157     unsigned OffsetReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
158     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
159         .addImm(StackSize);
160     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::SUB_I32),
161             WebAssembly::SP32)
162         .addReg(SPReg)
163         .addReg(OffsetReg);
164     WFI->stackifyVReg(OffsetReg);
165     WFI->stackifyVReg(SPReg);
166   }
167   if (hasFP(MF)) {
168     // Unlike most conventional targets (where FP points to the saved FP),
169     // FP points to the bottom of the fixed-size locals, so we can use positive
170     // offsets in load/store instructions.
171     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY_LOCAL_I32),
172             WebAssembly::FP32)
173         .addReg(WebAssembly::SP32);
174   }
175   if (StackSize && needsSPWriteback(MF, *MFI)) {
176     writeSPToMemory(WebAssembly::SP32, MF, MBB, InsertPt, InsertPt, DL);
177   }
178 }
179 
180 void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
181                                             MachineBasicBlock &MBB) const {
182   auto *MFI = MF.getFrameInfo();
183   uint64_t StackSize = MFI->getStackSize();
184   if (!needsSP(MF, *MFI) || !needsSPWriteback(MF, *MFI)) return;
185   auto *WFI = MF.getInfo<WebAssemblyFunctionInfo>();
186   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
187   auto &MRI = MF.getRegInfo();
188   auto InsertPt = MBB.getFirstTerminator();
189   DebugLoc DL;
190 
191   if (InsertPt != MBB.end()) {
192     DL = InsertPt->getDebugLoc();
193   }
194 
195   // Restore the stack pointer. If we had fixed-size locals, add the offset
196   // subtracted in the prolog.
197   unsigned SPReg = 0;
198   MachineBasicBlock::iterator InsertAddr = InsertPt;
199   if (StackSize) {
200     unsigned OffsetReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
201     InsertAddr =
202         BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
203             .addImm(StackSize);
204     // In the epilog we don't need to write the result back to the SP32 physreg
205     // because it won't be used again. We can use a stackified register instead.
206     SPReg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
207     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::ADD_I32), SPReg)
208         .addReg(hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32)
209         .addReg(OffsetReg);
210     WFI->stackifyVReg(OffsetReg);
211     WFI->stackifyVReg(SPReg);
212   } else {
213     SPReg = hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32;
214   }
215 
216   writeSPToMemory(SPReg, MF, MBB, InsertAddr, InsertPt, DL);
217 }
218