1 //===-- WebAssemblyPeephole.cpp - WebAssembly Peephole Optimiztions -------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief Late peephole optimizations for WebAssembly.
13 //===----------------------------------------------------------------------===//
15 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
16 #include "WebAssembly.h"
17 #include "WebAssemblyMachineFunctionInfo.h"
18 #include "WebAssemblySubtarget.h"
19 #include "llvm/Analysis/TargetLibraryInfo.h"
20 #include "llvm/CodeGen/MachineFunctionPass.h"
21 #include "llvm/CodeGen/MachineInstrBuilder.h"
22 #include "llvm/CodeGen/MachineRegisterInfo.h"
25 #define DEBUG_TYPE "wasm-peephole"
27 static cl::opt<bool> DisableWebAssemblyFallthroughReturnOpt(
28 "disable-wasm-fallthrough-return-opt", cl::Hidden,
29 cl::desc("WebAssembly: Disable fallthrough-return optimizations."),
33 class WebAssemblyPeephole final : public MachineFunctionPass {
34 StringRef getPassName() const override {
35 return "WebAssembly late peephole optimizer";
38 void getAnalysisUsage(AnalysisUsage &AU) const override {
40 AU.addRequired<TargetLibraryInfoWrapperPass>();
41 MachineFunctionPass::getAnalysisUsage(AU);
44 bool runOnMachineFunction(MachineFunction &MF) override;
48 WebAssemblyPeephole() : MachineFunctionPass(ID) {}
50 } // end anonymous namespace
52 char WebAssemblyPeephole::ID = 0;
53 FunctionPass *llvm::createWebAssemblyPeephole() {
54 return new WebAssemblyPeephole();
57 /// If desirable, rewrite NewReg to a drop register.
58 static bool MaybeRewriteToDrop(unsigned OldReg, unsigned NewReg,
59 MachineOperand &MO, WebAssemblyFunctionInfo &MFI,
60 MachineRegisterInfo &MRI) {
62 if (OldReg == NewReg) {
64 unsigned NewReg = MRI.createVirtualRegister(MRI.getRegClass(OldReg));
67 MFI.stackifyVReg(NewReg);
72 static bool MaybeRewriteToFallthrough(MachineInstr &MI, MachineBasicBlock &MBB,
73 const MachineFunction &MF,
74 WebAssemblyFunctionInfo &MFI,
75 MachineRegisterInfo &MRI,
76 const WebAssemblyInstrInfo &TII,
77 unsigned FallthroughOpc,
78 unsigned CopyLocalOpc) {
79 if (DisableWebAssemblyFallthroughReturnOpt)
81 if (&MBB != &MF.back())
83 if (&MI != &MBB.back())
86 // If the operand isn't stackified, insert a COPY to read the operand and
88 MachineOperand &MO = MI.getOperand(0);
89 unsigned Reg = MO.getReg();
90 if (!MFI.isVRegStackified(Reg)) {
91 unsigned NewReg = MRI.createVirtualRegister(MRI.getRegClass(Reg));
92 BuildMI(MBB, MI, MI.getDebugLoc(), TII.get(CopyLocalOpc), NewReg)
95 MFI.stackifyVReg(NewReg);
98 // Rewrite the return.
99 MI.setDesc(TII.get(FallthroughOpc));
103 bool WebAssemblyPeephole::runOnMachineFunction(MachineFunction &MF) {
105 dbgs() << "********** Peephole **********\n"
106 << "********** Function: " << MF.getName() << '\n';
109 MachineRegisterInfo &MRI = MF.getRegInfo();
110 WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
111 const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
112 const WebAssemblyTargetLowering &TLI =
113 *MF.getSubtarget<WebAssemblySubtarget>().getTargetLowering();
114 auto &LibInfo = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
115 bool Changed = false;
119 switch (MI.getOpcode()) {
122 case WebAssembly::CALL_I32:
123 case WebAssembly::CALL_I64: {
124 MachineOperand &Op1 = MI.getOperand(1);
125 if (Op1.isSymbol()) {
126 StringRef Name(Op1.getSymbolName());
127 if (Name == TLI.getLibcallName(RTLIB::MEMCPY) ||
128 Name == TLI.getLibcallName(RTLIB::MEMMOVE) ||
129 Name == TLI.getLibcallName(RTLIB::MEMSET)) {
131 if (LibInfo.getLibFunc(Name, Func)) {
132 const auto &Op2 = MI.getOperand(2);
134 report_fatal_error("Peephole: call to builtin function with "
135 "wrong signature, not consuming reg");
136 MachineOperand &MO = MI.getOperand(0);
137 unsigned OldReg = MO.getReg();
138 unsigned NewReg = Op2.getReg();
140 if (MRI.getRegClass(NewReg) != MRI.getRegClass(OldReg))
141 report_fatal_error("Peephole: call to builtin function with "
142 "wrong signature, from/to mismatch");
143 Changed |= MaybeRewriteToDrop(OldReg, NewReg, MO, MFI, MRI);
149 // Optimize away an explicit void return at the end of the function.
150 case WebAssembly::RETURN_I32:
151 Changed |= MaybeRewriteToFallthrough(
152 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_I32,
153 WebAssembly::COPY_I32);
155 case WebAssembly::RETURN_I64:
156 Changed |= MaybeRewriteToFallthrough(
157 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_I64,
158 WebAssembly::COPY_I64);
160 case WebAssembly::RETURN_F32:
161 Changed |= MaybeRewriteToFallthrough(
162 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_F32,
163 WebAssembly::COPY_F32);
165 case WebAssembly::RETURN_F64:
166 Changed |= MaybeRewriteToFallthrough(
167 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_F64,
168 WebAssembly::COPY_F64);
170 case WebAssembly::RETURN_v16i8:
171 Changed |= MaybeRewriteToFallthrough(
172 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_v16i8,
173 WebAssembly::COPY_V128);
175 case WebAssembly::RETURN_v8i16:
176 Changed |= MaybeRewriteToFallthrough(
177 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_v8i16,
178 WebAssembly::COPY_V128);
180 case WebAssembly::RETURN_v4i32:
181 Changed |= MaybeRewriteToFallthrough(
182 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_v4i32,
183 WebAssembly::COPY_V128);
185 case WebAssembly::RETURN_v4f32:
186 Changed |= MaybeRewriteToFallthrough(
187 MI, MBB, MF, MFI, MRI, TII, WebAssembly::FALLTHROUGH_RETURN_v4f32,
188 WebAssembly::COPY_V128);
190 case WebAssembly::RETURN_VOID:
191 if (!DisableWebAssemblyFallthroughReturnOpt &&
192 &MBB == &MF.back() && &MI == &MBB.back())
193 MI.setDesc(TII.get(WebAssembly::FALLTHROUGH_RETURN_VOID));