1//===-- WebAssemblyPeephole.cpp - WebAssembly Peephole Optimiztions -------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Late peephole optimizations for WebAssembly.
11///
12//===----------------------------------------------------------------------===//
13
14#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
15#include "WebAssembly.h"
16#include "WebAssemblyMachineFunctionInfo.h"
17#include "WebAssemblySubtarget.h"
18#include "llvm/Analysis/TargetLibraryInfo.h"
19#include "llvm/CodeGen/MachineFunctionPass.h"
20#include "llvm/CodeGen/MachineInstrBuilder.h"
21#include "llvm/CodeGen/MachineRegisterInfo.h"
22using namespace llvm;
23
24#define DEBUG_TYPE "wasm-peephole"
25
26static cl::opt<bool> DisableWebAssemblyFallthroughReturnOpt(
27    "disable-wasm-fallthrough-return-opt", cl::Hidden,
28    cl::desc("WebAssembly: Disable fallthrough-return optimizations."),
29    cl::init(false));
30
31namespace {
32class WebAssemblyPeephole final : public MachineFunctionPass {
33  StringRef getPassName() const override {
34    return "WebAssembly late peephole optimizer";
35  }
36
37  void getAnalysisUsage(AnalysisUsage &AU) const override {
38    AU.setPreservesCFG();
39    AU.addRequired<TargetLibraryInfoWrapperPass>();
40    MachineFunctionPass::getAnalysisUsage(AU);
41  }
42
43  bool runOnMachineFunction(MachineFunction &MF) override;
44
45public:
46  static char ID;
47  WebAssemblyPeephole() : MachineFunctionPass(ID) {}
48};
49} // end anonymous namespace
50
51char WebAssemblyPeephole::ID = 0;
52INITIALIZE_PASS(WebAssemblyPeephole, DEBUG_TYPE,
53                "WebAssembly peephole optimizations", false, false)
54
55FunctionPass *llvm::createWebAssemblyPeephole() {
56  return new WebAssemblyPeephole();
57}
58
59/// If desirable, rewrite NewReg to a drop register.
60static bool maybeRewriteToDrop(unsigned OldReg, unsigned NewReg,
61                               MachineOperand &MO, WebAssemblyFunctionInfo &MFI,
62                               MachineRegisterInfo &MRI) {
63  bool Changed = false;
64  if (OldReg == NewReg) {
65    Changed = true;
66    Register NewReg = MRI.createVirtualRegister(MRI.getRegClass(OldReg));
67    MO.setReg(NewReg);
68    MO.setIsDead();
69    MFI.stackifyVReg(NewReg);
70  }
71  return Changed;
72}
73
74static bool maybeRewriteToFallthrough(MachineInstr &MI, MachineBasicBlock &MBB,
75                                      const MachineFunction &MF,
76                                      WebAssemblyFunctionInfo &MFI,
77                                      MachineRegisterInfo &MRI,
78                                      const WebAssemblyInstrInfo &TII) {
79  if (DisableWebAssemblyFallthroughReturnOpt)
80    return false;
81  if (&MBB != &MF.back())
82    return false;
83
84  MachineBasicBlock::iterator End = MBB.end();
85  --End;
86  assert(End->getOpcode() == WebAssembly::END_FUNCTION);
87  --End;
88  if (&MI != &*End)
89    return false;
90
91  for (auto &MO : MI.explicit_operands()) {
92    // If the operand isn't stackified, insert a COPY to read the operands and
93    // stackify them.
94    Register Reg = MO.getReg();
95    if (!MFI.isVRegStackified(Reg)) {
96      unsigned CopyLocalOpc;
97      const TargetRegisterClass *RegClass = MRI.getRegClass(Reg);
98      switch (RegClass->getID()) {
99      case WebAssembly::I32RegClassID:
100        CopyLocalOpc = WebAssembly::COPY_I32;
101        break;
102      case WebAssembly::I64RegClassID:
103        CopyLocalOpc = WebAssembly::COPY_I64;
104        break;
105      case WebAssembly::F32RegClassID:
106        CopyLocalOpc = WebAssembly::COPY_F32;
107        break;
108      case WebAssembly::F64RegClassID:
109        CopyLocalOpc = WebAssembly::COPY_F64;
110        break;
111      case WebAssembly::V128RegClassID:
112        CopyLocalOpc = WebAssembly::COPY_V128;
113        break;
114      case WebAssembly::EXNREFRegClassID:
115        CopyLocalOpc = WebAssembly::COPY_EXNREF;
116        break;
117      default:
118        llvm_unreachable("Unexpected register class for return operand");
119      }
120      Register NewReg = MRI.createVirtualRegister(RegClass);
121      BuildMI(MBB, MI, MI.getDebugLoc(), TII.get(CopyLocalOpc), NewReg)
122          .addReg(Reg);
123      MO.setReg(NewReg);
124      MFI.stackifyVReg(NewReg);
125    }
126  }
127
128  MI.setDesc(TII.get(WebAssembly::FALLTHROUGH_RETURN));
129  return true;
130}
131
132bool WebAssemblyPeephole::runOnMachineFunction(MachineFunction &MF) {
133  LLVM_DEBUG({
134    dbgs() << "********** Peephole **********\n"
135           << "********** Function: " << MF.getName() << '\n';
136  });
137
138  MachineRegisterInfo &MRI = MF.getRegInfo();
139  WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
140  const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
141  const WebAssemblyTargetLowering &TLI =
142      *MF.getSubtarget<WebAssemblySubtarget>().getTargetLowering();
143  auto &LibInfo =
144      getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(MF.getFunction());
145  bool Changed = false;
146
147  for (auto &MBB : MF)
148    for (auto &MI : MBB)
149      switch (MI.getOpcode()) {
150      default:
151        break;
152      case WebAssembly::CALL_i32:
153      case WebAssembly::CALL_i64: {
154        MachineOperand &Op1 = MI.getOperand(1);
155        if (Op1.isSymbol()) {
156          StringRef Name(Op1.getSymbolName());
157          if (Name == TLI.getLibcallName(RTLIB::MEMCPY) ||
158              Name == TLI.getLibcallName(RTLIB::MEMMOVE) ||
159              Name == TLI.getLibcallName(RTLIB::MEMSET)) {
160            LibFunc Func;
161            if (LibInfo.getLibFunc(Name, Func)) {
162              const auto &Op2 = MI.getOperand(2);
163              if (!Op2.isReg())
164                report_fatal_error("Peephole: call to builtin function with "
165                                   "wrong signature, not consuming reg");
166              MachineOperand &MO = MI.getOperand(0);
167              Register OldReg = MO.getReg();
168              Register NewReg = Op2.getReg();
169
170              if (MRI.getRegClass(NewReg) != MRI.getRegClass(OldReg))
171                report_fatal_error("Peephole: call to builtin function with "
172                                   "wrong signature, from/to mismatch");
173              Changed |= maybeRewriteToDrop(OldReg, NewReg, MO, MFI, MRI);
174            }
175          }
176        }
177        break;
178      }
179      // Optimize away an explicit void return at the end of the function.
180      case WebAssembly::RETURN:
181        Changed |= maybeRewriteToFallthrough(MI, MBB, MF, MFI, MRI, TII);
182        break;
183      }
184
185  return Changed;
186}
187