[WebAssembly] Use `localexec` as default TLS model

[abrown]

Summary

When compiling to the WebAssembly target, there is currently

[abrown]

Re-submitting...

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

1725

We should only make this assumption if !Subtarget->getTargetTriple().isOSEmscripten() because emscripten *does* support dynamic linking (and dynamic linking + threads at the same time!).

How about removing the assertion and instead doing something like this:

// Non-emscripten target currently don't support any kind of dynamic linking
// so we can treat all TLS as LocalExecTLSModel
auto model = Subtarget->getTargetTriple().isOSEmscripten() ? GV->getThreadLocalMode() : LocalExecTLSModel;

[abrown]

Check out https://reviews.llvm.org/D130053 instead.

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

LowerCallResults(MachineInstr &CallResults, DebugLoc DL, MachineBasicBlock *BB,
   }
 
   // Move the function pointer to the end of the arguments for indirect calls
   if (IsIndirect) {
     auto FnPtr = CallParams.getOperand(0);
     CallParams.removeOperand(0);
 
     // For funcrefs, call_indirect is done through __funcref_call_table and the
-    // funcref is always installed in slot 0 of the table, therefore instead of having
-    // the function pointer added at the end of the params list, a zero (the index in
+    // funcref is always installed in slot 0 of the table, therefore instead of
+    // having the function pointer added at the end of the params list, a zero
+    // (the index in
     // __funcref_call_table is added).
     if (IsFuncrefCall) {
       Register RegZero =
           MF.getRegInfo().createVirtualRegister(&WebAssembly::I32RegClass);
       MachineInstrBuilder MIBC0 =
           BuildMI(MF, DL, TII.get(WebAssembly::CONST_I32), RegZero).addImm(0);
 
       BB->insert(CallResults.getIterator(), MIBC0);
WebAssemblyTargetLowering::LowerCall(CallLoweringInfo &CLI,
   } else if (IsVarArg) {
     FINode = DAG.getIntPtrConstant(0, DL);
   }
 
   if (Callee->getOpcode() == ISD::GlobalAddress) {
     // If the callee is a GlobalAddress node (quite common, every direct call
     // is) turn it into a TargetGlobalAddress node so that LowerGlobalAddress
     // doesn't at MO_GOT which is not needed for direct calls.
-    GlobalAddressSDNode* GA = cast<GlobalAddressSDNode>(Callee);
+    GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Callee);
     Callee = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
                                         getPointerTy(DAG.getDataLayout()),
                                         GA->getOffset());
     Callee = DAG.getNode(WebAssemblyISD::Wrapper, DL,
                          getPointerTy(DAG.getDataLayout()), Callee);
   }
 
   // Compute the operands for the CALLn node.
WebAssemblyTargetLowering::LowerGlobalTLSAddress(SDValue Op,
   SDLoc DL(Op);
   const auto *GA = cast<GlobalAddressSDNode>(Op);
 
   MachineFunction &MF = DAG.getMachineFunction();
   if (!MF.getSubtarget<WebAssemblySubtarget>().hasBulkMemory())
     report_fatal_error("cannot use thread-local storage without bulk memory",
                        false);
 
+  // Here we assume that all TLS addresses are `localexec`--i.e., no dynamic
+  // linking in WebAssembly. In the future, if toolchains do support dynamic
+  // linking, this code will have to re-learn how to do this and users will have
+  // to override this default with `-ftls-model=...` and/or
+  // __attribute__((tls_model("...")))`.
   const GlobalValue *GV = GA->getGlobal();
-
-  // Currently Emscripten does not support dynamic linking with threads.
-  // Therefore, if we have thread-local storage, only the local-exec model
-  // is possible.
-  // TODO: remove this and implement proper TLS models once Emscripten
-  // supports dynamic linking with threads.
-  if (GV->getThreadLocalMode() != GlobalValue::LocalExecTLSModel &&
-      !Subtarget->getTargetTriple().isOSEmscripten()) {
-    report_fatal_error("only -ftls-model=local-exec is supported for now on "
-                       "non-Emscripten OSes: variable " +
-                           GV->getName(),
-                       false);
-  }
-
-  auto model = GV->getThreadLocalMode();
-
-  // Unsupported TLS modes
-  assert(model != GlobalValue::NotThreadLocal);
-  assert(model != GlobalValue::InitialExecTLSModel);
-
-  if (model == GlobalValue::LocalExecTLSModel ||
-      model == GlobalValue::LocalDynamicTLSModel ||
-      (model == GlobalValue::GeneralDynamicTLSModel &&
-       getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV))) {
-    // For DSO-local TLS variables we use offset from __tls_base
-
-    MVT PtrVT = getPointerTy(DAG.getDataLayout());
-    auto GlobalGet = PtrVT == MVT::i64 ? WebAssembly::GLOBAL_GET_I64
-                                       : WebAssembly::GLOBAL_GET_I32;
-    const char *BaseName = MF.createExternalSymbolName("__tls_base");
-
-    SDValue BaseAddr(
-        DAG.getMachineNode(GlobalGet, DL, PtrVT,
-                           DAG.getTargetExternalSymbol(BaseName, PtrVT)),
-        0);
 
-    SDValue TLSOffset = DAG.getTargetGlobalAddress(
-        GV, DL, PtrVT, GA->getOffset(), WebAssemblyII::MO_TLS_BASE_REL);
-    SDValue SymOffset =
-        DAG.getNode(WebAssemblyISD::WrapperREL, DL, PtrVT, TLSOffset);
 
-    return DAG.getNode(ISD::ADD, DL, PtrVT, BaseAddr, SymOffset);
-  }
 
-  assert(model == GlobalValue::GeneralDynamicTLSModel);
-
-  EVT VT = Op.getValueType();
-  return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
-                     DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT,
-                                                GA->getOffset(),
-                                                WebAssemblyII::MO_GOT_TLS));
-}
-
 SDValue WebAssemblyTargetLowering::LowerGlobalAddress(SDValue Op,
                                                       SelectionDAG &DAG) const {
   SDLoc DL(Op);
   const auto *GA = cast<GlobalAddressSDNode>(Op);
   EVT VT = Op.getValueType();
   assert(GA->getTargetFlags() == 0 &&
          "Unexpected target flags on generic GlobalAddressSDNode");
   if (!WebAssembly::isValidAddressSpace(GA->getAddressSpace()))
     fail(DL, DAG, "Invalid address space for WebAssembly target");
 
   unsigned OperandFlags = 0;
   if (isPositionIndependent()) {
     const GlobalValue *GV = GA->getGlobal();
     if (getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV)) {
       MachineFunction &MF = DAG.getMachineFunction();
       MVT PtrVT = getPointerTy(MF.getDataLayout());
       const char *BaseName;
       if (GV->getValueType()->isFunctionTy()) {
         BaseName = MF.createExternalSymbolName("__table_base");
         OperandFlags = WebAssemblyII::MO_TABLE_BASE_REL;
-      }
-      else {
+      } else {
         BaseName = MF.createExternalSymbolName("__memory_base");
         OperandFlags = WebAssemblyII::MO_MEMORY_BASE_REL;
       }
       SDValue BaseAddr =
           DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
                       DAG.getTargetExternalSymbol(BaseName, PtrVT));
 
       SDValue SymAddr = DAG.getNode(