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
  58     // Wasm64 is not fully supported right now (and is not specified)
  59     if (Subtarget->hasAddr64())
  60       report_fatal_error(
  61           "64-bit WebAssembly (wasm64) is not currently supported");
  62
  63     return SelectionDAGISel::runOnMachineFunction(MF);
  64   }
  65
  66   void Select(SDNode *Node) override;
  67
  68   bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
  69                                     std::vector<SDValue> &OutOps) override;
  70
  71 // Include the pieces autogenerated from the target description.
  72 #include "WebAssemblyGenDAGISel.inc"
  73
  74 private:
  75   // add select functions here...
  76 };
  77 } // end anonymous namespace
  78
  79 void WebAssemblyDAGToDAGISel::Select(SDNode *Node) {
  80   // If we have a custom node, we already have selected!
  81   if (Node->isMachineOpcode()) {
  82     LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
  83     Node->setNodeId(-1);
  84     return;
  85   }
  86
  87   // Few custom selection stuff.
  88   SDLoc DL(Node);
  89   MachineFunction &MF = CurDAG->getMachineFunction();
  90   switch (Node->getOpcode()) {
  91   case ISD::ATOMIC_FENCE: {
  92     if (!MF.getSubtarget<WebAssemblySubtarget>().hasAtomics())
  93       break;
  94
  95     uint64_t SyncScopeID =
  96         cast<ConstantSDNode>(Node->getOperand(2).getNode())->getZExtValue();
  97     MachineSDNode *Fence = nullptr;
  98     switch (SyncScopeID) {
  99     case SyncScope::SingleThread:
 100       // We lower a single-thread fence to a pseudo compiler barrier instruction
 101       // preventing instruction reordering. This will not be emitted in final
 102       // binary.
 103       Fence = CurDAG->getMachineNode(WebAssembly::COMPILER_FENCE,
 104                                      DL,                 // debug loc
 105                                      MVT::Other,         // outchain type
 106                                      Node->getOperand(0) // inchain
 107       );
 108       break;
 109     case SyncScope::System:
 110       // Currently wasm only supports sequentially consistent atomics, so we
 111       // always set the order to 0 (sequentially consistent).
 112       Fence = CurDAG->getMachineNode(
 113           WebAssembly::ATOMIC_FENCE,
 114           DL,                                         // debug loc
 115           MVT::Other,                                 // outchain type
 116           CurDAG->getTargetConstant(0, DL, MVT::i32), // order
 117           Node->getOperand(0)                         // inchain
 118       );
 119       break;
 120     default:
 121       llvm_unreachable("Unknown scope!");
 122     }
 123
 124     ReplaceNode(Node, Fence);
 125     CurDAG->RemoveDeadNode(Node);
 126     return;
 127   }
 128
 129   case ISD::GlobalTLSAddress: {
 130     const auto *GA = cast<GlobalAddressSDNode>(Node);
 131
 132     if (!MF.getSubtarget<WebAssemblySubtarget>().hasBulkMemory())
 133       report_fatal_error("cannot use thread-local storage without bulk memory",
 134                          false);
 135
 136     // Currently Emscripten does not support dynamic linking with threads.
 137     // Therefore, if we have thread-local storage, only the local-exec model
 138     // is possible.
 139     // TODO: remove this and implement proper TLS models once Emscripten
 140     // supports dynamic linking with threads.
 141     if (GA->getGlobal()->getThreadLocalMode() !=
 142             GlobalValue::LocalExecTLSModel &&
 143         !Subtarget->getTargetTriple().isOSEmscripten()) {
 144       report_fatal_error("only -ftls-model=local-exec is supported for now on "
 145                          "non-Emscripten OSes: variable " +
 146                              GA->getGlobal()->getName(),
 147                          false);
 148     }
 149
 150     MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 151     assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 152
 153     SDValue TLSBaseSym = CurDAG->getTargetExternalSymbol("__tls_base", PtrVT);
 154     SDValue TLSOffsetSym = CurDAG->getTargetGlobalAddress(
 155         GA->getGlobal(), DL, PtrVT, GA->getOffset(), 0);
 156
 157     MachineSDNode *TLSBase = CurDAG->getMachineNode(WebAssembly::GLOBAL_GET_I32,
 158                                                     DL, MVT::i32, TLSBaseSym);
 159     MachineSDNode *TLSOffset = CurDAG->getMachineNode(
 160         WebAssembly::CONST_I32, DL, MVT::i32, TLSOffsetSym);
 161     MachineSDNode *TLSAddress =
 162         CurDAG->getMachineNode(WebAssembly::ADD_I32, DL, MVT::i32,
 163                                SDValue(TLSBase, 0), SDValue(TLSOffset, 0));
 164     ReplaceNode(Node, TLSAddress);
 165     return;
 166   }
 167
 168   case ISD::INTRINSIC_WO_CHAIN: {
 169     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(0))->getZExtValue();
 170     switch (IntNo) {
 171     case Intrinsic::wasm_tls_size: {
 172       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 173       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 174
 175       MachineSDNode *TLSSize = CurDAG->getMachineNode(
 176           WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
 177           CurDAG->getTargetExternalSymbol("__tls_size", MVT::i32));
 178       ReplaceNode(Node, TLSSize);
 179       return;
 180     }
 181     case Intrinsic::wasm_tls_align: {
 182       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 183       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 184
 185       MachineSDNode *TLSAlign = CurDAG->getMachineNode(
 186           WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
 187           CurDAG->getTargetExternalSymbol("__tls_align", MVT::i32));
 188       ReplaceNode(Node, TLSAlign);
 189       return;
 190     }
 191     }
 192     break;
 193   }
 194   case ISD::INTRINSIC_W_CHAIN: {
 195     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
 196     switch (IntNo) {
 197     case Intrinsic::wasm_tls_base: {
 198       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
 199       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 200
 201       MachineSDNode *TLSBase = CurDAG->getMachineNode(
 202           WebAssembly::GLOBAL_GET_I32, DL, MVT::i32, MVT::Other,
 203           CurDAG->getTargetExternalSymbol("__tls_base", PtrVT),
 204           Node->getOperand(0));
 205       ReplaceNode(Node, TLSBase);
 206       return;
 207     }
 208     }
 209     break;
 210   }
 211
 212   default:
 213     break;
 214   }
 215
 216   // Select the default instruction.
 217   SelectCode(Node);
 218 }
 219
 220 bool WebAssemblyDAGToDAGISel::SelectInlineAsmMemoryOperand(
 221     const SDValue &Op, unsigned ConstraintID, std::vector<SDValue> &OutOps) {
 222   switch (ConstraintID) {
 223   case InlineAsm::Constraint_i:
 224   case InlineAsm::Constraint_m:
 225     // We just support simple memory operands that just have a single address
 226     // operand and need no special handling.
 227     OutOps.push_back(Op);
 228     return false;
 229   default:
 230     break;
 231   }
 232
 233   return true;
 234 }
 235
 236 /// This pass converts a legalized DAG into a WebAssembly-specific DAG, ready
 237 /// for instruction scheduling.
 238 FunctionPass *llvm::createWebAssemblyISelDag(WebAssemblyTargetMachine &TM,
 239                                              CodeGenOpt::Level OptLevel) {
 240   return new WebAssemblyDAGToDAGISel(TM, OptLevel);
 241 }