Line data Source code
1 : //===-- WebAssemblyCallIndirectFixup.cpp - Fix call_indirects -------------===//
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 : /// This file converts pseudo call_indirect instructions into real
12 : /// call_indirects.
13 : ///
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.
18 : ///
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
21 : /// executed in.
22 : ///
23 : //===----------------------------------------------------------------------===//
24 :
25 : #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" // for WebAssembly::ARGUMENT_*
26 : #include "WebAssembly.h"
27 : #include "WebAssemblyMachineFunctionInfo.h"
28 : #include "WebAssemblySubtarget.h"
29 : #include "llvm/Analysis/AliasAnalysis.h"
30 : #include "llvm/CodeGen/LiveIntervals.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"
38 : using namespace llvm;
39 :
40 : #define DEBUG_TYPE "wasm-call-indirect-fixup"
41 :
42 : namespace {
43 : class WebAssemblyCallIndirectFixup final : public MachineFunctionPass {
44 305 : StringRef getPassName() const override {
45 305 : return "WebAssembly CallIndirect Fixup";
46 : }
47 :
48 : bool runOnMachineFunction(MachineFunction &MF) override;
49 :
50 : public:
51 : static char ID; // Pass identification, replacement for typeid
52 305 : WebAssemblyCallIndirectFixup() : MachineFunctionPass(ID) {}
53 : };
54 : } // end anonymous namespace
55 :
56 : char WebAssemblyCallIndirectFixup::ID = 0;
57 199030 : INITIALIZE_PASS(WebAssemblyCallIndirectFixup, DEBUG_TYPE,
58 : "Rewrite call_indirect argument orderings", false, false)
59 :
60 305 : FunctionPass *llvm::createWebAssemblyCallIndirectFixup() {
61 305 : return new WebAssemblyCallIndirectFixup();
62 : }
63 :
64 : static unsigned GetNonPseudoCallIndirectOpcode(const MachineInstr &MI) {
65 25368 : switch (MI.getOpcode()) {
66 : using namespace WebAssembly;
67 : case PCALL_INDIRECT_VOID:
68 : return CALL_INDIRECT_VOID;
69 : case PCALL_INDIRECT_I32:
70 : return CALL_INDIRECT_I32;
71 : case PCALL_INDIRECT_I64:
72 : return CALL_INDIRECT_I64;
73 : case PCALL_INDIRECT_F32:
74 : return CALL_INDIRECT_F32;
75 : case PCALL_INDIRECT_F64:
76 : return CALL_INDIRECT_F64;
77 : case PCALL_INDIRECT_v16i8:
78 : return CALL_INDIRECT_v16i8;
79 : case PCALL_INDIRECT_v8i16:
80 : return CALL_INDIRECT_v8i16;
81 : case PCALL_INDIRECT_v4i32:
82 : return CALL_INDIRECT_v4i32;
83 : case PCALL_INDIRECT_v2i64:
84 : return CALL_INDIRECT_v2i64;
85 : case PCALL_INDIRECT_v4f32:
86 : return CALL_INDIRECT_v4f32;
87 : case PCALL_INDIRECT_v2f64:
88 : return CALL_INDIRECT_v2f64;
89 : default:
90 : return INSTRUCTION_LIST_END;
91 : }
92 : }
93 :
94 : static bool IsPseudoCallIndirect(const MachineInstr &MI) {
95 : return GetNonPseudoCallIndirectOpcode(MI) !=
96 : WebAssembly::INSTRUCTION_LIST_END;
97 : }
98 :
99 2983 : bool WebAssemblyCallIndirectFixup::runOnMachineFunction(MachineFunction &MF) {
100 : LLVM_DEBUG(dbgs() << "********** Fixing up CALL_INDIRECTs **********\n"
101 : << MF.getName() << '\n');
102 :
103 : bool Changed = false;
104 : const WebAssemblyInstrInfo *TII =
105 2983 : MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
106 :
107 6508 : for (MachineBasicBlock &MBB : MF) {
108 28893 : for (MachineInstr &MI : MBB) {
109 33 : if (IsPseudoCallIndirect(MI)) {
110 : LLVM_DEBUG(dbgs() << "Found call_indirect: " << MI << '\n');
111 :
112 : // Rewrite pseudo to non-pseudo
113 33 : const MCInstrDesc &Desc = TII->get(GetNonPseudoCallIndirectOpcode(MI));
114 : MI.setDesc(Desc);
115 :
116 : // Rewrite argument order
117 : SmallVector<MachineOperand, 8> Ops;
118 :
119 : // Set up a placeholder for the type signature immediate.
120 33 : Ops.push_back(MachineOperand::CreateImm(0));
121 :
122 : // Set up the flags immediate, which currently has no defined flags
123 : // so it's always zero.
124 33 : Ops.push_back(MachineOperand::CreateImm(0));
125 :
126 40 : for (const MachineOperand &MO :
127 33 : make_range(MI.operands_begin() + MI.getDesc().getNumDefs() + 1,
128 73 : MI.operands_begin() + MI.getNumExplicitOperands()))
129 40 : Ops.push_back(MO);
130 66 : Ops.push_back(MI.getOperand(MI.getDesc().getNumDefs()));
131 :
132 : // Replace the instructions operands.
133 214 : while (MI.getNumOperands() > MI.getDesc().getNumDefs())
134 148 : MI.RemoveOperand(MI.getNumOperands() - 1);
135 172 : for (const MachineOperand &MO : Ops)
136 139 : MI.addOperand(MO);
137 :
138 : LLVM_DEBUG(dbgs() << " After transform: " << MI);
139 : Changed = true;
140 : }
141 : }
142 : }
143 :
144 : LLVM_DEBUG(dbgs() << "\nDone fixing up CALL_INDIRECTs\n\n");
145 :
146 2983 : return Changed;
147 : }
|
