lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp

   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"
  37 using namespace llvm;
  38
  39 #define DEBUG_TYPE "wasm-call-indirect-fixup"
  40
  41 namespace {
  42 class WebAssemblyCallIndirectFixup final : public MachineFunctionPass {
  43   StringRef getPassName() const override {
  44     return "WebAssembly CallIndirect Fixup";
  45   }
  46
  47   bool runOnMachineFunction(MachineFunction &MF) override;
  48
  49 public:
  50   static char ID; // Pass identification, replacement for typeid
  51   WebAssemblyCallIndirectFixup() : MachineFunctionPass(ID) {}
  52 };
  53 } // end anonymous namespace
  54
  55 char WebAssemblyCallIndirectFixup::ID = 0;
  56 INITIALIZE_PASS(WebAssemblyCallIndirectFixup, DEBUG_TYPE,
  57                 "Rewrite call_indirect argument orderings", false, false)
  58
  59 FunctionPass *llvm::createWebAssemblyCallIndirectFixup() {
  60   return new WebAssemblyCallIndirectFixup();
  61 }
  62
  63 static 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
  97 static bool isPseudoCallIndirect(const MachineInstr &MI) {
  98   return getNonPseudoCallIndirectOpcode(MI) !=
  99          WebAssembly::INSTRUCTION_LIST_END;
 100 }
 101
 102 bool 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 }