lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

   1 //- WebAssemblyISelDAGToDAG.cpp - A dag to dag inst selector for WebAssembly -//
   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 defines an instruction selector for the WebAssembly target.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
  15 #include "WebAssembly.h"
  16 #include "WebAssemblyTargetMachine.h"
  17 #include "llvm/CodeGen/SelectionDAGISel.h"
  18 #include "llvm/IR/DiagnosticInfo.h"
  19 #include "llvm/IR/Function.h" // To access function attributes.
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/KnownBits.h"
  22 #include "llvm/Support/MathExtras.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 using namespace llvm;
  25
  26 #define DEBUG_TYPE "wasm-isel"
  27
  28 //===--------------------------------------------------------------------===//
  29 /// WebAssembly-specific code to select WebAssembly machine instructions for
  30 /// SelectionDAG operations.
  31 ///
  32 namespace {
  33 class WebAssemblyDAGToDAGISel final : public SelectionDAGISel {
  34   /// Keep a pointer to the WebAssemblySubtarget around so that we can make the
  35   /// right decision when generating code for different targets.
  36   const WebAssemblySubtarget *Subtarget;
  37
  38   bool ForCodeSize;
  39
  40 public:
  41   WebAssemblyDAGToDAGISel(WebAssemblyTargetMachine &TM,
  42                           CodeGenOpt::Level OptLevel)
  43       : SelectionDAGISel(TM, OptLevel), Subtarget(nullptr), ForCodeSize(false) {
  44   }
  45
  46   StringRef getPassName() const override {
  47     return "WebAssembly Instruction Selection";
  48   }
  49
  50   bool runOnMachineFunction(MachineFunction &MF) override {
  51     LLVM_DEBUG(dbgs() << "********** ISelDAGToDAG **********\n"
  52                          "********** Function: "
  53                       << MF.getName() << '\n');
  54
  55     ForCodeSize = MF.getFunction().hasOptSize();
  56     Subtarget = &MF.getSubtarget<WebAssemblySubtarget>();
  57     return SelectionDAGISel::runOnMachineFunction(MF);
  58   }
  59
  60   void Select(SDNode *Node) override;
  61
  62   bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
  63                                     std::vector<SDValue> &OutOps) override;
  64
  65 // Include the pieces autogenerated from the target description.
  66 #include "WebAssemblyGenDAGISel.inc"
  67
  68 private:
  69   // add select functions here...
  70 };
  71 } // end anonymous namespace
  72
  73 void WebAssemblyDAGToDAGISel::Select(SDNode *Node) {
  74   // If we have a custom node, we already have selected!
  75   if (Node->isMachineOpcode()) {
  76     LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
  77     Node->setNodeId(-1);
  78     return;
  79   }
  80
  81   // Few custom selection stuff.
  82   SDLoc DL(Node);
  83   MachineFunction &MF = CurDAG->getMachineFunction();
  84   switch (Node->getOpcode()) {
  85   case ISD::ATOMIC_FENCE: {
  86     if (!MF.getSubtarget<WebAssemblySubtarget>().hasAtomics())
  87       break;
  88
  89     uint64_t SyncScopeID =
  90         cast<ConstantSDNode>(Node->getOperand(2).getNode())->getZExtValue();
  91     MachineSDNode *Fence = nullptr;
  92     switch (SyncScopeID) {
  93     case SyncScope::SingleThread:
  94       // We lower a single-thread fence to a pseudo compiler barrier instruction
  95       // preventing instruction reordering. This will not be emitted in final
  96       // binary.
  97       Fence = CurDAG->getMachineNode(WebAssembly::COMPILER_FENCE,
  98                                      DL,                 // debug loc
  99                                      MVT::Other,         // outchain type
 100                                      Node->getOperand(0) // inchain
 101       );
 102       break;
 103     case SyncScope::System:
 104       // Currently wasm only supports sequentially consistent atomics, so we
 105       // always set the order to 0 (sequentially consistent).
 106       Fence = CurDAG->getMachineNode(
 107           WebAssembly::ATOMIC_FENCE,
 108           DL,                                         // debug loc
 109           MVT::Other,                                 // outchain type
 110           CurDAG->getTargetConstant(0, DL, MVT::i32), // order
 111           Node->getOperand(0)                         // inchain
 112       );
 113       break;
 114     default:
 115       llvm_unreachable("Unknown scope!");
 116     }
 117
 118     ReplaceNode(Node, Fence);
 119     CurDAG->RemoveDeadNode(Node);
 120     return;
 121   }
 122
 123   case ISD::GlobalTLSAddress: {
 124     const auto *GA = cast<GlobalAddressSDNode>(Node);
 125
 126     if (!MF.getSubtarget<WebAssemblySubtarget>().hasBulkMemory())
 127       report_fatal_error("cannot use thread-local storage without bulk memory",
 128                          false);
 129
 130     // Currently Emscripten does not support dynamic linking with threads.
 131     // Therefore, if we have thread-local storage, only the local-exec model
 132     // is possible.
 133     // TODO: remove this and implement proper TLS models once Emscripten
 134     // supports dynamic linking with threads.
 135     if (GA->getGlobal()->getThreadLocalMode() !=
 136             GlobalValue::LocalExecTLSModel &&
 137         !Subtarget->getTargetTriple().isOSEmscripten()) {
 138       report_fatal_error("only -ftls-model=local-exec is supported for now on "
 139                          "non-Emscripten OSes: variable " +
 140                              GA->getGlobal()->getName(),
 141                          false);
 142     }
 143
 144     MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 145     assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 146
 147     SDValue TLSBaseSym = CurDAG->getTargetExternalSymbol("__tls_base", PtrVT);
 148     SDValue TLSOffsetSym = CurDAG->getTargetGlobalAddress(
 149         GA->getGlobal(), DL, PtrVT, GA->getOffset(), 0);
 150
 151     MachineSDNode *TLSBase = CurDAG->getMachineNode(WebAssembly::GLOBAL_GET_I32,
 152                                                     DL, MVT::i32, TLSBaseSym);
 153     MachineSDNode *TLSOffset = CurDAG->getMachineNode(
 154         WebAssembly::CONST_I32, DL, MVT::i32, TLSOffsetSym);
 155     MachineSDNode *TLSAddress =
 156         CurDAG->getMachineNode(WebAssembly::ADD_I32, DL, MVT::i32,
 157                                SDValue(TLSBase, 0), SDValue(TLSOffset, 0));
 158     ReplaceNode(Node, TLSAddress);
 159     return;
 160   }
 161
 162   case ISD::INTRINSIC_WO_CHAIN: {
 163     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(0))->getZExtValue();
 164     switch (IntNo) {
 165     case Intrinsic::wasm_tls_size: {
 166       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 167       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 168
 169       MachineSDNode *TLSSize = CurDAG->getMachineNode(
 170           WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
 171           CurDAG->getTargetExternalSymbol("__tls_size", MVT::i32));
 172       ReplaceNode(Node, TLSSize);
 173       return;
 174     }
 175     case Intrinsic::wasm_tls_align: {
 176       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 177       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 178
 179       MachineSDNode *TLSAlign = CurDAG->getMachineNode(
 180           WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
 181           CurDAG->getTargetExternalSymbol("__tls_align", MVT::i32));
 182       ReplaceNode(Node, TLSAlign);
 183       return;
 184     }
 185     }
 186     break;
 187   }
 188   case ISD::INTRINSIC_W_CHAIN: {
 189     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
 190     switch (IntNo) {
 191     case Intrinsic::wasm_tls_base: {
 192       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 193       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 194
 195       MachineSDNode *TLSBase = CurDAG->getMachineNode(
 196           WebAssembly::GLOBAL_GET_I32, DL, MVT::i32, MVT::Other,
 197           CurDAG->getTargetExternalSymbol("__tls_base", PtrVT),
 198           Node->getOperand(0));
 199       ReplaceNode(Node, TLSBase);
 200       return;
 201     }
 202     }
 203     break;
 204   }
 205
 206   default:
 207     break;
 208   }
 209
 210   // Select the default instruction.
 211   SelectCode(Node);
 212 }
 213
 214 bool WebAssemblyDAGToDAGISel::SelectInlineAsmMemoryOperand(
 215     const SDValue &Op, unsigned ConstraintID, std::vector<SDValue> &OutOps) {
 216   switch (ConstraintID) {
 217   case InlineAsm::Constraint_i:
 218   case InlineAsm::Constraint_m:
 219     // We just support simple memory operands that just have a single address
 220     // operand and need no special handling.
 221     OutOps.push_back(Op);
 222     return false;
 223   default:
 224     break;
 225   }
 226
 227   return true;
 228 }
 229
 230 /// This pass converts a legalized DAG into a WebAssembly-specific DAG, ready
 231 /// for instruction scheduling.
 232 FunctionPass *llvm::createWebAssemblyISelDag(WebAssemblyTargetMachine &TM,
 233                                              CodeGenOpt::Level OptLevel) {
 234   return new WebAssemblyDAGToDAGISel(TM, OptLevel);
 235 }