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/IR/IntrinsicsWebAssembly.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/KnownBits.h"
23 #include "llvm/Support/MathExtras.h"
24 #include "llvm/Support/raw_ostream.h"
25 using namespace llvm;
26 
27 #define DEBUG_TYPE "wasm-isel"
28 
29 //===--------------------------------------------------------------------===//
30 /// WebAssembly-specific code to select WebAssembly machine instructions for
31 /// SelectionDAG operations.
32 ///
33 namespace {
34 class WebAssemblyDAGToDAGISel final : public SelectionDAGISel {
35   /// Keep a pointer to the WebAssemblySubtarget around so that we can make the
36   /// right decision when generating code for different targets.
37   const WebAssemblySubtarget *Subtarget;
38 
39 public:
40   WebAssemblyDAGToDAGISel(WebAssemblyTargetMachine &TM,
41                           CodeGenOpt::Level OptLevel)
42       : SelectionDAGISel(TM, OptLevel), Subtarget(nullptr) {
43   }
44 
45   StringRef getPassName() const override {
46     return "WebAssembly Instruction Selection";
47   }
48 
49   bool runOnMachineFunction(MachineFunction &MF) override {
50     LLVM_DEBUG(dbgs() << "********** ISelDAGToDAG **********\n"
51                          "********** Function: "
52                       << MF.getName() << '\n');
53 
54     Subtarget = &MF.getSubtarget<WebAssemblySubtarget>();
55 
56     return SelectionDAGISel::runOnMachineFunction(MF);
57   }
58 
59   void Select(SDNode *Node) override;
60 
61   bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
62                                     std::vector<SDValue> &OutOps) override;
63 
64 // Include the pieces autogenerated from the target description.
65 #include "WebAssemblyGenDAGISel.inc"
66 
67 private:
68   // add select functions here...
69 };
70 } // end anonymous namespace
71 
72 void WebAssemblyDAGToDAGISel::Select(SDNode *Node) {
73   // If we have a custom node, we already have selected!
74   if (Node->isMachineOpcode()) {
75     LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
76     Node->setNodeId(-1);
77     return;
78   }
79 
80   MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
81   auto GlobalGetIns = PtrVT == MVT::i64 ? WebAssembly::GLOBAL_GET_I64
82                                         : WebAssembly::GLOBAL_GET_I32;
83   auto ConstIns =
84       PtrVT == MVT::i64 ? WebAssembly::CONST_I64 : WebAssembly::CONST_I32;
85   auto AddIns = PtrVT == MVT::i64 ? WebAssembly::ADD_I64 : WebAssembly::ADD_I32;
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     SDValue TLSBaseSym = CurDAG->getTargetExternalSymbol("__tls_base", PtrVT);
151     SDValue TLSOffsetSym = CurDAG->getTargetGlobalAddress(
152         GA->getGlobal(), DL, PtrVT, GA->getOffset(),
153         WebAssemblyII::MO_TLS_BASE_REL);
154 
155     MachineSDNode *TLSBase =
156         CurDAG->getMachineNode(GlobalGetIns, DL, PtrVT, TLSBaseSym);
157     MachineSDNode *TLSOffset =
158         CurDAG->getMachineNode(ConstIns, DL, PtrVT, TLSOffsetSym);
159     MachineSDNode *TLSAddress = CurDAG->getMachineNode(
160         AddIns, DL, PtrVT, SDValue(TLSBase, 0), SDValue(TLSOffset, 0));
161     ReplaceNode(Node, TLSAddress);
162     return;
163   }
164 
165   case ISD::INTRINSIC_WO_CHAIN: {
166     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(0))->getZExtValue();
167     switch (IntNo) {
168     case Intrinsic::wasm_tls_size: {
169       MachineSDNode *TLSSize = CurDAG->getMachineNode(
170           GlobalGetIns, DL, PtrVT,
171           CurDAG->getTargetExternalSymbol("__tls_size", PtrVT));
172       ReplaceNode(Node, TLSSize);
173       return;
174     }
175     case Intrinsic::wasm_tls_align: {
176       MachineSDNode *TLSAlign = CurDAG->getMachineNode(
177           GlobalGetIns, DL, PtrVT,
178           CurDAG->getTargetExternalSymbol("__tls_align", PtrVT));
179       ReplaceNode(Node, TLSAlign);
180       return;
181     }
182     }
183     break;
184   }
185   case ISD::INTRINSIC_W_CHAIN: {
186     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
187     switch (IntNo) {
188     case Intrinsic::wasm_tls_base: {
189       MachineSDNode *TLSBase = CurDAG->getMachineNode(
190           GlobalGetIns, DL, PtrVT, MVT::Other,
191           CurDAG->getTargetExternalSymbol("__tls_base", PtrVT),
192           Node->getOperand(0));
193       ReplaceNode(Node, TLSBase);
194       return;
195     }
196     }
197     break;
198   }
199   case WebAssemblyISD::CALL:
200   case WebAssemblyISD::RET_CALL: {
201     // CALL has both variable operands and variable results, but ISel only
202     // supports one or the other. Split calls into two nodes glued together, one
203     // for the operands and one for the results. These two nodes will be
204     // recombined in a custom inserter hook into a single MachineInstr.
205     SmallVector<SDValue, 16> Ops;
206     for (size_t i = 1; i < Node->getNumOperands(); ++i) {
207       SDValue Op = Node->getOperand(i);
208       if (i == 1 && Op->getOpcode() == WebAssemblyISD::Wrapper)
209         Op = Op->getOperand(0);
210       Ops.push_back(Op);
211     }
212 
213     // Add the chain last
214     Ops.push_back(Node->getOperand(0));
215     MachineSDNode *CallParams =
216         CurDAG->getMachineNode(WebAssembly::CALL_PARAMS, DL, MVT::Glue, Ops);
217 
218     unsigned Results = Node->getOpcode() == WebAssemblyISD::CALL
219                            ? WebAssembly::CALL_RESULTS
220                            : WebAssembly::RET_CALL_RESULTS;
221 
222     SDValue Link(CallParams, 0);
223     MachineSDNode *CallResults =
224         CurDAG->getMachineNode(Results, DL, Node->getVTList(), Link);
225     ReplaceNode(Node, CallResults);
226     return;
227   }
228 
229   default:
230     break;
231   }
232 
233   // Select the default instruction.
234   SelectCode(Node);
235 }
236 
237 bool WebAssemblyDAGToDAGISel::SelectInlineAsmMemoryOperand(
238     const SDValue &Op, unsigned ConstraintID, std::vector<SDValue> &OutOps) {
239   switch (ConstraintID) {
240   case InlineAsm::Constraint_m:
241     // We just support simple memory operands that just have a single address
242     // operand and need no special handling.
243     OutOps.push_back(Op);
244     return false;
245   default:
246     break;
247   }
248 
249   return true;
250 }
251 
252 /// This pass converts a legalized DAG into a WebAssembly-specific DAG, ready
253 /// for instruction scheduling.
254 FunctionPass *llvm::createWebAssemblyISelDag(WebAssemblyTargetMachine &TM,
255                                              CodeGenOpt::Level OptLevel) {
256   return new WebAssemblyDAGToDAGISel(TM, OptLevel);
257 }
258