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