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                             DebugLoc DL) {
85   auto *SPSymbol = MF.createExternalSymbolName("__stack_pointer");
86   MachineRegisterInfo &MRI = MF.getRegInfo();
87   const TargetRegisterClass *PtrRC =
88       MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
89   unsigned SPAddr = MRI.createVirtualRegister(PtrRC);
90   unsigned Discard = MRI.createVirtualRegister(PtrRC);
91   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
92 
93   BuildMI(MBB, InsertAddr, DL, TII->get(WebAssembly::CONST_I32), SPAddr)
94       .addExternalSymbol(SPSymbol);
95   auto *MMO = new MachineMemOperand(MachinePointerInfo(),
96                                     MachineMemOperand::MOStore, 4, 4);
97   BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::STORE_I32),
98           Discard)
99       .addImm(0)
100       .addReg(SPAddr)
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 SPAddr = MRI.createVirtualRegister(PtrRC);
140   unsigned SPReg = MRI.createVirtualRegister(PtrRC);
141   auto *SPSymbol = MF.createExternalSymbolName("__stack_pointer");
142   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), SPAddr)
143       .addExternalSymbol(SPSymbol);
144   // This MachinePointerInfo should reference __stack_pointer as well but
145   // doesn't because MachinePointerInfo() takes a GV which we don't have for
146   // __stack_pointer. TODO: check if PseudoSourceValue::ExternalSymbolCallEntry
147   // is appropriate instead. (likewise for EmitEpologue below)
148   auto *LoadMMO = new MachineMemOperand(MachinePointerInfo(),
149                                         MachineMemOperand::MOLoad, 4, 4);
150   // Load the SP value.
151   BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::LOAD_I32),
152           StackSize ? SPReg : (unsigned)WebAssembly::SP32)
153       .addImm(0)       // offset
154       .addReg(SPAddr)  // addr
155       .addImm(2)       // p2align
156       .addMemOperand(LoadMMO);
157 
158   if (StackSize) {
159     // Subtract the frame size
160     unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
161     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
162         .addImm(StackSize);
163     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::SUB_I32),
164             WebAssembly::SP32)
165         .addReg(SPReg)
166         .addReg(OffsetReg);
167   }
168   if (hasFP(MF)) {
169     // Unlike most conventional targets (where FP points to the saved FP),
170     // FP points to the bottom of the fixed-size locals, so we can use positive
171     // offsets in load/store instructions.
172     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY),
173             WebAssembly::FP32)
174         .addReg(WebAssembly::SP32);
175   }
176   if (StackSize && needsSPWriteback(MF, *MFI)) {
177     writeSPToMemory(WebAssembly::SP32, MF, MBB, InsertPt, InsertPt, DL);
178   }
179 }
180 
181 void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
182                                             MachineBasicBlock &MBB) const {
183   auto *MFI = MF.getFrameInfo();
184   uint64_t StackSize = MFI->getStackSize();
185   if (!needsSP(MF, *MFI) || !needsSPWriteback(MF, *MFI)) return;
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   // 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     const TargetRegisterClass *PtrRC =
200         MRI.getTargetRegisterInfo()->getPointerRegClass(MF);
201     unsigned OffsetReg = MRI.createVirtualRegister(PtrRC);
202     InsertAddr =
203         BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::CONST_I32), OffsetReg)
204             .addImm(StackSize);
205     // In the epilog we don't need to write the result back to the SP32 physreg
206     // because it won't be used again. We can use a stackified register instead.
207     SPReg = MRI.createVirtualRegister(PtrRC);
208     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::ADD_I32), SPReg)
209         .addReg(hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32)
210         .addReg(OffsetReg);
211   } else {
212     SPReg = hasFP(MF) ? WebAssembly::FP32 : WebAssembly::SP32;
213   }
214 
215   writeSPToMemory(SPReg, MF, MBB, InsertAddr, InsertPt, DL);
216 }
217