contrib/llvm/lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp

   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   StringRef getPassName() const override {
  45     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   WebAssemblyCallIndirectFixup() : MachineFunctionPass(ID) {}
  53 };
  54 } // end anonymous namespace
  55
  56 char WebAssemblyCallIndirectFixup::ID = 0;
  57 INITIALIZE_PASS(WebAssemblyCallIndirectFixup, DEBUG_TYPE,
  58                 "Rewrite call_indirect argument orderings", false, false)
  59
  60 FunctionPass *llvm::createWebAssemblyCallIndirectFixup() {
  61   return new WebAssemblyCallIndirectFixup();
  62 }
  63
  64 static unsigned GetNonPseudoCallIndirectOpcode(const MachineInstr &MI) {
  65   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 bool WebAssemblyCallIndirectFixup::runOnMachineFunction(MachineFunction &MF) {
 100   LLVM_DEBUG(dbgs() << "********** Fixing up CALL_INDIRECTs **********\n"
 101                     << "********** Function: " << MF.getName() << '\n');
 102
 103   bool Changed = false;
 104   const WebAssemblyInstrInfo *TII =
 105       MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
 106
 107   for (MachineBasicBlock &MBB : MF) {
 108     for (MachineInstr &MI : MBB) {
 109       if (IsPseudoCallIndirect(MI)) {
 110         LLVM_DEBUG(dbgs() << "Found call_indirect: " << MI << '\n');
 111
 112         // Rewrite pseudo to non-pseudo
 113         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         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         Ops.push_back(MachineOperand::CreateImm(0));
 125
 126         for (const MachineOperand &MO :
 127              make_range(MI.operands_begin() + MI.getDesc().getNumDefs() + 1,
 128                         MI.operands_begin() + MI.getNumExplicitOperands()))
 129           Ops.push_back(MO);
 130         Ops.push_back(MI.getOperand(MI.getDesc().getNumDefs()));
 131
 132         // Replace the instructions operands.
 133         while (MI.getNumOperands() > MI.getDesc().getNumDefs())
 134           MI.RemoveOperand(MI.getNumOperands() - 1);
 135         for (const MachineOperand &MO : Ops)
 136           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   return Changed;
 147 }