1//===-- WebAssemblyCallIndirectFixup.cpp - Fix call_indirects -------------===//
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/// This file converts pseudo call_indirect instructions into real
11/// call_indirects.
12///
13/// The order of arguments for a call_indirect is the arguments to the function
14/// call, followed by the function pointer. There's no natural way to express
15/// a machineinstr with varargs followed by one more arg, so we express it as
16/// the function pointer followed by varargs, then rewrite it here.
17///
18/// We need to rewrite the order of the arguments on the machineinstrs
19/// themselves so that register stackification knows the order they'll be
20/// executed in.
21///
22//===----------------------------------------------------------------------===//
23
24#include "MCTargetDesc/WebAssemblyMCTargetDesc.h" // for WebAssembly::ARGUMENT_*
25#include "WebAssembly.h"
26#include "WebAssemblyMachineFunctionInfo.h"
27#include "WebAssemblySubtarget.h"
28#include "llvm/Analysis/AliasAnalysis.h"
29#include "llvm/CodeGen/LiveIntervals.h"
30#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
31#include "llvm/CodeGen/MachineDominators.h"
32#include "llvm/CodeGen/MachineInstrBuilder.h"
33#include "llvm/CodeGen/MachineRegisterInfo.h"
34#include "llvm/CodeGen/Passes.h"
35#include "llvm/Support/Debug.h"
36#include "llvm/Support/raw_ostream.h"
37using namespace llvm;
38
39#define DEBUG_TYPE "wasm-call-indirect-fixup"
40
41namespace {
42class WebAssemblyCallIndirectFixup final : public MachineFunctionPass {
43  StringRef getPassName() const override {
44    return "WebAssembly CallIndirect Fixup";
45  }
46
47  bool runOnMachineFunction(MachineFunction &MF) override;
48
49public:
50  static char ID; // Pass identification, replacement for typeid
51  WebAssemblyCallIndirectFixup() : MachineFunctionPass(ID) {}
52};
53} // end anonymous namespace
54
55char WebAssemblyCallIndirectFixup::ID = 0;
56INITIALIZE_PASS(WebAssemblyCallIndirectFixup, DEBUG_TYPE,
57                "Rewrite call_indirect argument orderings", false, false)
58
59FunctionPass *llvm::createWebAssemblyCallIndirectFixup() {
60  return new WebAssemblyCallIndirectFixup();
61}
62
63static unsigned getNonPseudoCallIndirectOpcode(const MachineInstr &MI) {
64  switch (MI.getOpcode()) {
65    using namespace WebAssembly;
66  case PCALL_INDIRECT_VOID:
67    return CALL_INDIRECT_VOID;
68  case PCALL_INDIRECT_i32:
69    return CALL_INDIRECT_i32;
70  case PCALL_INDIRECT_i64:
71    return CALL_INDIRECT_i64;
72  case PCALL_INDIRECT_f32:
73    return CALL_INDIRECT_f32;
74  case PCALL_INDIRECT_f64:
75    return CALL_INDIRECT_f64;
76  case PCALL_INDIRECT_v16i8:
77    return CALL_INDIRECT_v16i8;
78  case PCALL_INDIRECT_v8i16:
79    return CALL_INDIRECT_v8i16;
80  case PCALL_INDIRECT_v4i32:
81    return CALL_INDIRECT_v4i32;
82  case PCALL_INDIRECT_v2i64:
83    return CALL_INDIRECT_v2i64;
84  case PCALL_INDIRECT_v4f32:
85    return CALL_INDIRECT_v4f32;
86  case PCALL_INDIRECT_v2f64:
87    return CALL_INDIRECT_v2f64;
88  case PCALL_INDIRECT_exnref:
89    return CALL_INDIRECT_exnref;
90  case PRET_CALL_INDIRECT:
91    return RET_CALL_INDIRECT;
92  default:
93    return INSTRUCTION_LIST_END;
94  }
95}
96
97static bool isPseudoCallIndirect(const MachineInstr &MI) {
98  return getNonPseudoCallIndirectOpcode(MI) !=
99         WebAssembly::INSTRUCTION_LIST_END;
100}
101
102bool WebAssemblyCallIndirectFixup::runOnMachineFunction(MachineFunction &MF) {
103  LLVM_DEBUG(dbgs() << "********** Fixing up CALL_INDIRECTs **********\n"
104                    << "********** Function: " << MF.getName() << '\n');
105
106  bool Changed = false;
107  const WebAssemblyInstrInfo *TII =
108      MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
109
110  for (MachineBasicBlock &MBB : MF) {
111    for (MachineInstr &MI : MBB) {
112      if (isPseudoCallIndirect(MI)) {
113        LLVM_DEBUG(dbgs() << "Found call_indirect: " << MI << '\n');
114
115        // Rewrite pseudo to non-pseudo
116        const MCInstrDesc &Desc = TII->get(getNonPseudoCallIndirectOpcode(MI));
117        MI.setDesc(Desc);
118
119        // Rewrite argument order
120        SmallVector<MachineOperand, 8> Ops;
121
122        // Set up a placeholder for the type signature immediate.
123        Ops.push_back(MachineOperand::CreateImm(0));
124
125        // Set up the flags immediate, which currently has no defined flags
126        // so it's always zero.
127        Ops.push_back(MachineOperand::CreateImm(0));
128
129        for (const MachineOperand &MO :
130             make_range(MI.operands_begin() + MI.getDesc().getNumDefs() + 1,
131                        MI.operands_begin() + MI.getNumExplicitOperands()))
132          Ops.push_back(MO);
133        Ops.push_back(MI.getOperand(MI.getDesc().getNumDefs()));
134
135        // Replace the instructions operands.
136        while (MI.getNumOperands() > MI.getDesc().getNumDefs())
137          MI.RemoveOperand(MI.getNumOperands() - 1);
138        for (const MachineOperand &MO : Ops)
139          MI.addOperand(MO);
140
141        LLVM_DEBUG(dbgs() << "  After transform: " << MI);
142        Changed = true;
143      }
144    }
145  }
146
147  LLVM_DEBUG(dbgs() << "\nDone fixing up CALL_INDIRECTs\n\n");
148
149  return Changed;
150}
151