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