1 //===-- WebAssemblyCallIndirectFixup.cpp - Fix call_indirects -------------===//
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 This file converts pseudo call_indirect instructions into real
14 /// The order of arguments for a call_indirect is the arguments to the function
15 /// call, followed by the function pointer. There's no natural way to express
16 /// a machineinstr with varargs followed by one more arg, so we express it as
17 /// the function pointer followed by varargs, then rewrite it here.
19 /// We need to rewrite the order of the arguments on the machineinstrs
20 /// themselves so that register stackification knows the order they'll be
23 //===----------------------------------------------------------------------===//
25 #include "WebAssembly.h"
26 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" // for WebAssembly::ARGUMENT_*
27 #include "WebAssemblyMachineFunctionInfo.h"
28 #include "WebAssemblySubtarget.h"
29 #include "llvm/Analysis/AliasAnalysis.h"
30 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
31 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
32 #include "llvm/CodeGen/MachineDominators.h"
33 #include "llvm/CodeGen/MachineInstrBuilder.h"
34 #include "llvm/CodeGen/MachineRegisterInfo.h"
35 #include "llvm/CodeGen/Passes.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/raw_ostream.h"
40 #define DEBUG_TYPE "wasm-call-indirect-fixup"
43 class WebAssemblyCallIndirectFixup final : public MachineFunctionPass {
44 StringRef getPassName() const override {
45 return "WebAssembly CallIndirect Fixup";
48 bool runOnMachineFunction(MachineFunction &MF) override;
51 static char ID; // Pass identification, replacement for typeid
52 WebAssemblyCallIndirectFixup() : MachineFunctionPass(ID) {}
54 } // end anonymous namespace
56 char WebAssemblyCallIndirectFixup::ID = 0;
57 FunctionPass *llvm::createWebAssemblyCallIndirectFixup() {
58 return new WebAssemblyCallIndirectFixup();
61 static unsigned GetNonPseudoCallIndirectOpcode(const MachineInstr &MI) {
62 switch (MI.getOpcode()) {
63 using namespace WebAssembly;
64 case PCALL_INDIRECT_VOID: return CALL_INDIRECT_VOID;
65 case PCALL_INDIRECT_I32: return CALL_INDIRECT_I32;
66 case PCALL_INDIRECT_I64: return CALL_INDIRECT_I64;
67 case PCALL_INDIRECT_F32: return CALL_INDIRECT_F32;
68 case PCALL_INDIRECT_F64: return CALL_INDIRECT_F64;
69 case PCALL_INDIRECT_v16i8: return CALL_INDIRECT_v16i8;
70 case PCALL_INDIRECT_v8i16: return CALL_INDIRECT_v8i16;
71 case PCALL_INDIRECT_v4i32: return CALL_INDIRECT_v4i32;
72 case PCALL_INDIRECT_v4f32: return CALL_INDIRECT_v4f32;
73 default: return INSTRUCTION_LIST_END;
77 static bool IsPseudoCallIndirect(const MachineInstr &MI) {
78 return GetNonPseudoCallIndirectOpcode(MI) !=
79 WebAssembly::INSTRUCTION_LIST_END;
82 bool WebAssemblyCallIndirectFixup::runOnMachineFunction(MachineFunction &MF) {
83 DEBUG(dbgs() << "********** Fixing up CALL_INDIRECTs **********\n"
84 << MF.getName() << '\n');
87 const WebAssemblyInstrInfo *TII =
88 MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
90 for (MachineBasicBlock &MBB : MF) {
91 for (MachineInstr &MI : MBB) {
92 if (IsPseudoCallIndirect(MI)) {
93 DEBUG(dbgs() << "Found call_indirect: " << MI << '\n');
95 // Rewrite pseudo to non-pseudo
96 const MCInstrDesc &Desc = TII->get(GetNonPseudoCallIndirectOpcode(MI));
99 // Rewrite argument order
100 auto Uses = MI.explicit_uses();
101 MachineInstr::mop_iterator it = Uses.begin();
102 const MachineOperand MO = *it;
104 // Set up the flags immediate, which currently has no defined flags
105 // so it's always zero.
106 it->ChangeToImmediate(0);
108 MI.addOperand(MF, MO);
110 DEBUG(dbgs() << " After transform: " << MI);
116 DEBUG(dbgs() << "\nDone fixing up CALL_INDIRECTs\n\n");