[WebAssembly] Allow import and export of TLS symbols between DSOs

[sbc100]

• rebase

[sbc100]

• rebase

[tlively]

It would be great to have tests for the new subsections.

lld/wasm/SyntheticSections.cpp

73

Why do we check sym->isTLS() for exports but not for imports?

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

1566–1567

Should these asserts be report_fatal_errors instead?

[dschuff]

lld/wasm/Writer.cpp

990

what if we have TLS in the input but not config->sharedMemory?

[sbc100]

More testing in tls-non-shared-memory.s

[sbc100]

lld/wasm/Writer.cpp

990

In this case all the TLS handling is basically internalize.

See lld/test/wasm/tls-non-shared-memory.s. I've added an extra case to that test to verify that the imported/GOT usage of the TLS variable is also internalized.

[sbc100]

lld/wasm/SyntheticSections.cpp

73

I'm getting ahead of myself here. The TLS flag is needed when exporting (since we need to tell the dynamic linker to adjust the exported value according to the tls base).

However for imports we don't need to know if a given global is TLS or not since all the GOT.mem imports are of absolute values (its up to the dynamic linker to ensure they are all absolute addresses).

For imports however, we are going to need to tell the dynamic linker about which imports are weak (so it can provide 0 and not error out).

I think I will completely remove IMPORT_INFO from this change since its not used yet.

[sbc100]

• remove IMPORT_INFO

[sbc100]

Add more tests

[tlively]

lld/wasm/SyntheticSections.cpp

64

"toe" => "to"

llvm/lib/Object/WasmObjectFile.cpp

366–367

Do we need to be storing this information somewhere so it can be round-tripped?

[sbc100]

Add srialization via yaml and more testing

[sbc100]

typo

[sbc100]

This change is much more complete now.

• removed ImportInfo for now (will add that later)
• added obj2yaml support for dumping the new subsection
• added a lot more testing

[sbc100]

• more

[sbc100]

• revert part

[sbc100]

• comment

[dschuff]

I think the code is looking good.
I do think it will be cleaner in the long run to make the dylink section properly subsectioned, rather than the backwards-compatible version you have here. We've never declared any kind of backwords compat yet for dylibs, have we?

[sbc100]

• rebase

[sbc100]

ptal.. should be good to land this now

[tlively]

LGTM!

[sbc100]

Looks like this change caused llvm/test/ObjectYAML/wasm/dylink_section.yaml to start failing. Working on a fix now.

lld/test/wasm/pie.ll

 ; to be generated along with __wasm_start as the start
 ; function.
 
 ; RUN: llc -relocation-model=pic -mattr=+mutable-globals,+atomics,+bulk-memory -filetype=obj %s -o %t.shmem.o
 ; RUN: wasm-ld --no-gc-sections --shared-memory --allow-undefined --experimental-pic -pie -o %t.shmem.wasm %t.shmem.o
 ; RUN: obj2yaml %t.shmem.wasm | FileCheck %s --check-prefix=SHMEM
 
 ; SHMEM:         - Type:            CODE
-; SHMEM:           - Index:           6
+; SHMEM:           - Index:           7
 ; SHMEM-NEXT:        Locals:          []
 ; SHMEM-NEXT:        Body:            100310050B
 
 ; SHMEM:         FunctionNames:
 ; SHMEM-NEXT:      - Index:           0
 ; SHMEM-NEXT:        Name:            external_func
 ; SHMEM-NEXT:      - Index:           1
 ; SHMEM-NEXT:        Name:            __wasm_call_ctors
 ; SHMEM-NEXT:      - Index:           2
 ; SHMEM-NEXT:        Name:            __wasm_init_tls
 ; SHMEM-NEXT:      - Index:           3
 ; SHMEM-NEXT:        Name:            __wasm_init_memory
 ; SHMEM-NEXT:      - Index:           4
 ; SHMEM-NEXT:        Name:            __wasm_apply_data_relocs
 ; SHMEM-NEXT:      - Index:           5
 ; SHMEM-NEXT:        Name:            __wasm_apply_global_relocs
 ; SHMEM-NEXT:      - Index:           6
-; SHMEM-NEXT:        Name:            __wasm_start
+; SHMEM-NEXT:        Name:            __wasm_apply_global_tls_relocs
 ; SHMEM-NEXT:      - Index:           7
-; SHMEM-NEXT:        Name:            foo
+; SHMEM-NEXT:        Name:            __wasm_start
 ; SHMEM-NEXT:      - Index:           8
-; SHMEM-NEXT:        Name:            get_data_address
+; SHMEM-NEXT:        Name:            foo
 ; SHMEM-NEXT:      - Index:           9
+; SHMEM-NEXT:        Name:            get_data_address
+; SHMEM-NEXT:      - Index:           10
 ; SHMEM-NEXT:        Name:            _start
 

lld/test/wasm/shared-needed.s

 # SO1:      Sections:
 # SO1-NEXT:   - Type:            CUSTOM
 # SO1-NEXT:     Name:            dylink.0
 # SO1-NEXT:     MemorySize:      4
 # SO1-NEXT:     MemoryAlignment: 2
 # SO1-NEXT:     TableSize:       0
 # SO1-NEXT:     TableAlignment:  0
 # SO1-NEXT:     Needed:          []
+# SO1-NEXT:     ExportInfo:      []
 # SO1-NEXT:   - Type:            TYPE
 
 # SO2:      Sections:
 # SO2-NEXT:   - Type:            CUSTOM
 # SO2-NEXT:     Name:            dylink.0
 # SO2-NEXT:     MemorySize:      0
 # SO2-NEXT:     MemoryAlignment: 0
 # SO2-NEXT:     TableSize:       0
 # SO2-NEXT:     TableAlignment:  0
 # SO2-NEXT:     Needed:
 # SO2-NEXT:       - shared-needed.s.tmp1.so
+# SO2-NEXT:     ExportInfo:      []
 # SO2-NEXT:   - Type:            TYPE

lld/test/wasm/shared.s

 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            dylink.0
 # CHECK-NEXT:     MemorySize:      24
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2
 # CHECK-NEXT:     TableAlignment:  0
 # CHECK-NEXT:     Needed:          []
+# CHECK-NEXT:     ExportInfo:      []
 # CHECK-NEXT:   - Type:            TYPE
 
 # check for import of __table_base and __memory_base globals
 
 # CHECK:        - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           memory

lld/test/wasm/shared64.s

 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            dylink.0
 # CHECK-NEXT:     MemorySize:      36
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2
 # CHECK-NEXT:     TableAlignment:  0
 # CHECK-NEXT:     Needed:          []
+# CHECK-NEXT:     ExportInfo:      []
 # CHECK-NEXT:   - Type:            TYPE
 
 # check for import of __table_base and __memory_base globals
 
 # CHECK:        - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           memory

lld/test/wasm/tls-export.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
-# RUN: wasm-ld -no-gc-sections --shared-memory --no-entry -o %t.wasm %t.o
-# RUN: not wasm-ld --shared-memory --no-entry --export=tls1 -o %t.wasm %t.o 2>&1 | FileCheck %s
-# With --export-all we ignore TLS symbols so we don't expect an error here
-# RUN: wasm-ld --shared-memory --no-entry --export-all -o %t.wasm %t.o
-
-# CHECK: error: TLS symbols cannot yet be exported: `tls1`
+# RUN: wasm-ld -shared --experimental-pic -o %t.so %t.o
+# RUN: obj2yaml %t.so | FileCheck %s
 
 .section  .tdata.tls1,"",@
 .globl  tls1
 .p2align  2
 tls1:
   .int32  1
   .size tls1, 4
 
 .section  .custom_section.target_features,"",@
   .int8 3
   .int8 43
   .int8 7
   .ascii  "atomics"
   .int8 43
   .int8 11
   .ascii  "bulk-memory"
   .int8 43
   .int8 15
   .ascii "mutable-globals"
+
+#      CHECK:    ExportInfo:
+# CHECK-NEXT:      - Name:            tls1
+# CHECK-NEXT:        Flags:           [ TLS ]
+# CHECK-NEXT:  - Type:            TYPE
+
+#      CHECK:  - Type:            GLOBAL
+# CHECK-NEXT:    Globals:
+# CHECK-NEXT:      - Index:           2
+# CHECK-NEXT:        Type:            I32
+# CHECK-NEXT:        Mutable:         false
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           0
+
+#      CHECK:  - Type:            EXPORT
+# CHECK-NEXT:    Exports:
+# CHECK-NEXT:      - Name:            __wasm_call_ctors
+# CHECK-NEXT:        Kind:            FUNCTION
+# CHECK-NEXT:        Index:           0
+# CHECK-NEXT:      - Name:            tls1
+# CHECK-NEXT:        Kind:            GLOBAL
+# CHECK-NEXT:        Index:           2

lld/test/wasm/tls-import.s

-# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
-# RUN: not wasm-ld -shared --experimental-pic --shared-memory -o %t.wasm %t.o 2>&1 | FileCheck %s
-
-# CHECK: error: {{.*}}.o: TLS symbol is undefined, but TLS symbols cannot yet be imported: `foo`
-
-.globl _start
-_start:
-  .functype _start () -> ()
-  i32.const foo@TLSREL
-  drop
-  end_function
-
-.section  .custom_section.target_features,"",@
-  .int8 3
-  .int8 43
-  .int8 7
-  .ascii  "atomics"
-  .int8 43
-  .int8 11
-  .ascii  "bulk-memory"
-  .int8 43
-  .int8 15
-  .ascii "mutable-globals"

lld/test/wasm/tls-non-shared-memory.s

 # Test that linking without shared memory causes __tls_base to be
-# internalized
+# internalized.
 
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 
 .globaltype __tls_base, i32
 
 .globl get_tls1
 get_tls1:
   .functype get_tls1 () -> (i32)
   global.get __tls_base
   i32.const tls1@TLSREL
   i32.add
   end_function
 
+.globl get_tls1_got
+get_tls1_got:
+  .functype get_tls1_got () -> (i32)
+  global.get tls1@GOT@TLS
+  end_function
+
 .section  .data.no_tls,"",@
 .globl  no_tls
 .p2align  2
 no_tls:
   .int32  42
   .size no_tls, 4
 
-.section  .tdata.tls1,"",@
+.section  .tdata.tls1,"T",@
 .globl  tls1
 .p2align  2
 tls1:
   .int32  43
   .size tls1, 2
 
 .section  .custom_section.target_features,"",@
   .int8 2

 # CHECK-NEXT:           Value:           66576
 # __tls_base
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         false
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           1024
+# GOT.data.internal.tls1
+# CHECK-NEXT:       - Index:           2
+# CHECK-NEXT:         Type:            I32
+# CHECK-NEXT:         Mutable:         false
+# CHECK-NEXT:         InitExpr:
+# CHECK-NEXT:           Opcode:          I32_CONST
+# CHECK-NEXT:           Value:           1024
 # CHECK-NEXT:   - Type:            EXPORT
 
 #      CHECK:  - Type:            DATA
 # .data
 # CHECK-NEXT:    Segments:
 # CHECK-NEXT:      - SectionOffset:   7
 # CHECK-NEXT:        InitFlags:       0
 # CHECK-NEXT:        Offset:

lld/wasm/Relocations.cpp

case R_WASM_MEMORY_ADDR_TLS_SLEB64:
                   "` in non-TLS section: " + D->segment->outputSeg->name);
           }
         }
       }
       break;
     }
 
     if (config->isPic) {
-      if (sym->isTLS() && sym->isUndefined()) {
-        error(toString(file) +
-              ": TLS symbol is undefined, but TLS symbols cannot yet be "
-              "imported: `" +
-              toString(*sym) + "`");
-      }
       switch (reloc.Type) {
       case R_WASM_TABLE_INDEX_SLEB:
       case R_WASM_TABLE_INDEX_SLEB64:
       case R_WASM_MEMORY_ADDR_SLEB:
       case R_WASM_MEMORY_ADDR_LEB:
       case R_WASM_MEMORY_ADDR_SLEB64:
       case R_WASM_MEMORY_ADDR_LEB64:
         // Certain relocation types can't be used when building PIC output,

lld/wasm/Symbols.h

struct WasmSym {
   // Function that calls the libc/etc. cleanup function.
   static DefinedFunction *callDtors;
 
   // __wasm_apply_data_relocs
   // Function that applies relocations to data segment post-instantiation.
   static DefinedFunction *applyDataRelocs;
 
   // __wasm_apply_global_relocs
-  // Function that applies relocations to data segment post-instantiation.
+  // Function that applies relocations to wasm globals post-instantiation.
   // Unlike __wasm_apply_data_relocs this needs to run on every thread.
   static DefinedFunction *applyGlobalRelocs;
 
+  // __wasm_apply_global_tls_relocs
+  // Like applyGlobalRelocs but for globals that hold TLS addresess.  These
+  // must be delayed until __wasm_init_tls.
+  static DefinedFunction *applyGlobalTLSRelocs;
+
   // __wasm_init_tls
   // Function that allocates thread-local storage and initializes it.
   static DefinedFunction *initTLS;
 
   // Pointer to the function that is to be used in the start section.
   // (normally an alias of initMemory, or applyGlobalRelocs).
   static DefinedFunction *startFunction;
 

lld/wasm/Symbols.cpp

 }
 
 namespace wasm {
 DefinedFunction *WasmSym::callCtors;
 DefinedFunction *WasmSym::callDtors;
 DefinedFunction *WasmSym::initMemory;
 DefinedFunction *WasmSym::applyDataRelocs;
 DefinedFunction *WasmSym::applyGlobalRelocs;
+DefinedFunction *WasmSym::applyGlobalTLSRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedFunction *WasmSym::startFunction;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 DefinedData *WasmSym::initMemoryFlag;
 GlobalSymbol *WasmSym::stackPointer;

lld/wasm/SyntheticSections.h

public:
   // For the static linking case these internal globals can be completely
   // eliminated by a post-link optimizer such as wasm-opt.
   //
   // TODO(sbc): Another approach to optimizing these away could be to use
   // specific relocation types combined with linker relaxation which could
   // transform a `global.get` to an `i32.const`.
   void addInternalGOTEntry(Symbol *sym);
   bool needsRelocations() { return internalGotSymbols.size(); }
-  void generateRelocationCode(raw_ostream &os) const;
+  void generateRelocationCode(raw_ostream &os, bool TLS) const;
 
-  std::vector<const DefinedData *> dataAddressGlobals;
+  std::vector<DefinedData *> dataAddressGlobals;
   std::vector<InputGlobal *> inputGlobals;
   std::vector<Symbol *> internalGotSymbols;
 
 protected:
   bool isSealed = false;
 };
 
 class ExportSection : public SyntheticSection {

lld/wasm/SyntheticSections.cpp

 
 void DylinkSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   {
     SubSection sub(WASM_DYLINK_MEM_INFO);
     writeUleb128(sub.os, memSize, "MemSize");
     writeUleb128(sub.os, memAlign, "MemAlign");
     writeUleb128(sub.os, out.elemSec->numEntries(), "TableSize");
     writeUleb128(sub.os, 0, "TableAlign");
     sub.writeTo(os);
   }
 
   if (symtab->sharedFiles.size()) {
     SubSection sub(WASM_DYLINK_NEEDED);
     writeUleb128(sub.os, symtab->sharedFiles.size(), "Needed");
     for (auto *so : symtab->sharedFiles)
       writeStr(sub.os, llvm::sys::path::filename(so->getName()), "so name");
     sub.writeTo(os);
   }
+
+  // Under certain circumstances we need to include extra information about the
+  // exports we are providing to the dynamic linker.  Currently this is only the
+  // case for TLS symbols where the exported value is relative to __tls_base
+  // rather than __memory_base.
+  std::vector<const Symbol *> exportInfo;
+  for (const Symbol *sym : symtab->getSymbols()) {
+    if (sym->isExported() && sym->isLive() && sym->isTLS() &&
+        isa<DefinedData>(sym)) {
+      exportInfo.push_back(sym);
+    }
+  }
+
+  if (!exportInfo.empty()) {
+    SubSection sub(WASM_DYLINK_EXPORT_INFO);
+    writeUleb128(sub.os, exportInfo.size(), "num exports");
+
+    for (const Symbol *sym : exportInfo) {
+      LLVM_DEBUG(llvm::dbgs() << "export info: " << toString(*sym) << "\n");
+      StringRef name = sym->getName();
+      if (auto *f = dyn_cast<DefinedFunction>(sym)) {
+        if (Optional<StringRef> exportName = f->function->getExportName()) {
+          name = *exportName;
+        }
+      }
+      writeStr(sub.os, name, "sym name");
+      writeUleb128(sub.os, sym->flags, "sym flags");
+    }
+
+    sub.writeTo(os);
+  }
 }
 
 uint32_t TypeSection::registerType(const WasmSignature &sig) {
   auto pair = typeIndices.insert(std::make_pair(sig, types.size()));
   if (pair.second) {
     LLVM_DEBUG(llvm::dbgs() << "type " << toString(sig) << "\n");
     types.push_back(&sig);
   }
void GlobalSection::addInternalGOTEntry(Symbol *sym) {
   sym->requiresGOT = true;
   if (auto *F = dyn_cast<FunctionSymbol>(sym)) {
     ensureIndirectFunctionTable();
     out.elemSec->addEntry(F);
   }
   internalGotSymbols.push_back(sym);
 }
 
-void GlobalSection::generateRelocationCode(raw_ostream &os) const {
+void GlobalSection::generateRelocationCode(raw_ostream &os, bool TLS) const {
   bool is64 = config->is64.getValueOr(false);
   unsigned opcode_ptr_const = is64 ? WASM_OPCODE_I64_CONST
                                    : WASM_OPCODE_I32_CONST;
   unsigned opcode_ptr_add = is64 ? WASM_OPCODE_I64_ADD
                                  : WASM_OPCODE_I32_ADD;
 
   for (const Symbol *sym : internalGotSymbols) {
+    if (TLS != sym->isTLS())
+      continue;
+
     if (auto *d = dyn_cast<DefinedData>(sym)) {
       // Get __memory_base
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
-      writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "__memory_base");
+      if (sym->isTLS())
+        writeUleb128(os, WasmSym::tlsBase->getGlobalIndex(), "__tls_base");
+      else
+        writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(),
+                     "__memory_base");
 
       // Add the virtual address of the data symbol
       writeU8(os, opcode_ptr_const, "CONST");
       writeSleb128(os, d->getVA(), "offset");
     } else if (auto *f = dyn_cast<FunctionSymbol>(sym)) {
       if (f->isStub)
         continue;
       // Get __table_base

lld/wasm/Writer.cpp

private:
   bool needsPassiveInitialization(const OutputSegment *segment);
   bool hasPassiveInitializedSegments();
 
   void createSyntheticInitFunctions();
   void createInitMemoryFunction();
   void createStartFunction();
   void createApplyDataRelocationsFunction();
   void createApplyGlobalRelocationsFunction();
+  void createApplyGlobalTLSRelocationsFunction();
   void createCallCtorsFunction();
   void createInitTLSFunction();
   void createCommandExportWrappers();
   void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
 
   void assignIndexes();
   void populateSymtab();
   void populateProducers();
if (auto *f = dyn_cast<DefinedFunction>(sym)) {
         // stack pointer to export a mutable global even if none of the input
         // files were built with the `mutable-globals` feature.
         continue;
       }
       export_ = {name, WASM_EXTERNAL_GLOBAL, g->getGlobalIndex()};
     } else if (auto *t = dyn_cast<DefinedTag>(sym)) {
       export_ = {name, WASM_EXTERNAL_TAG, t->getTagIndex()};
     } else if (auto *d = dyn_cast<DefinedData>(sym)) {
-      if (sym->isTLS()) {
-        // We can't currenly export TLS data symbols.
-        if (sym->isExportedExplicit())
-          error("TLS symbols cannot yet be exported: `" + toString(*sym) + "`");
-        continue;
-      }
       out.globalSec->dataAddressGlobals.push_back(d);
       export_ = {name, WASM_EXTERNAL_GLOBAL, globalIndex++};
     } else {
       auto *t = cast<DefinedTable>(sym);
       export_ = {name, WASM_EXTERNAL_TABLE, t->getTableNumber()};
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << name << "\n");
WasmSym::applyDataRelocs = symtab->addSyntheticFunction(
         make<SyntheticFunction>(nullSignature, "__wasm_apply_data_relocs"));
     WasmSym::applyDataRelocs->markLive();
 
     if (out.globalSec->needsRelocations()) {
       WasmSym::applyGlobalRelocs = symtab->addSyntheticFunction(
           "__wasm_apply_global_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
           make<SyntheticFunction>(nullSignature, "__wasm_apply_global_relocs"));
       WasmSym::applyGlobalRelocs->markLive();
+      if (config->sharedMemory) {
+        WasmSym::applyGlobalTLSRelocs = symtab->addSyntheticFunction(
+            "__wasm_apply_global_tls_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
+            make<SyntheticFunction>(nullSignature,
+                                    "__wasm_apply_global_tls_relocs"));
+        WasmSym::applyGlobalTLSRelocs->markLive();
+      }
     }
   }
 
   if (WasmSym::applyGlobalRelocs && WasmSym::initMemory) {
     WasmSym::startFunction = symtab->addSyntheticFunction(
         "__wasm_start", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_start"));
     WasmSym::startFunction->markLive();

 // fro WebAssembly globals. Because these globals are not shared between threads
 // these relocation need to run on every thread.
 void Writer::createApplyGlobalRelocationsFunction() {
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
-    out.globalSec->generateRelocationCode(os);
+    out.globalSec->generateRelocationCode(os, false);
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::applyGlobalRelocs, bodyContent);
 }
 
+// Similar to createApplyGlobalRelocationsFunction but for
+// TLS symbols.  This cannot be run during the start function
+// but must be delayed until __wasm_init_tls is called.
+void Writer::createApplyGlobalTLSRelocationsFunction() {
+  // First write the body's contents to a string.
+  std::string bodyContent;
+  {
+    raw_string_ostream os(bodyContent);
+    writeUleb128(os, 0, "num locals");
+    out.globalSec->generateRelocationCode(os, true);
+    writeU8(os, WASM_OPCODE_END, "END");
+  }
+
+  createFunction(WasmSym::applyGlobalTLSRelocs, bodyContent);
+}
+
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCallCtorsFunction() {
   // If __wasm_call_ctors isn't referenced, there aren't any ctors, and we
   // aren't calling `__wasm_apply_data_relocs` for Emscripten-style PIC, don't
   // define the `__wasm_call_ctors` function.
   if (!WasmSym::callCtors->isLive() && !WasmSym::applyDataRelocs &&
       initFunctions.empty())
if (tlsSeg) {
 
       writeI32Const(os, tlsSeg->size, "memory region size");
 
       writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
       writeUleb128(os, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT");
       writeUleb128(os, tlsSeg->index, "segment index immediate");
       writeU8(os, 0, "memory index immediate");
     }
+
+    if (WasmSym::applyGlobalTLSRelocs) {
+      writeU8(os, WASM_OPCODE_CALL, "CALL");
+      writeUleb128(os, WasmSym::applyGlobalTLSRelocs->getFunctionIndex(),
+                   "function index");
+    }
     writeU8(os, WASM_OPCODE_END, "end function");
   }
 
   createFunction(WasmSym::initTLS, bodyContent);
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
void Writer::run() {
   calculateInitFunctions();
 
   if (!config->relocatable) {
     // Create linker synthesized functions
     if (WasmSym::applyDataRelocs)
       createApplyDataRelocationsFunction();
     if (WasmSym::applyGlobalRelocs)
       createApplyGlobalRelocationsFunction();
+    if (WasmSym::applyGlobalTLSRelocs)
+      createApplyGlobalTLSRelocationsFunction();
     if (WasmSym::initMemory)
       createInitMemoryFunction();
     createStartFunction();
 
     createCallCtorsFunction();
 
     // Create export wrappers for commands if needed.
     //

llvm/include/llvm/BinaryFormat/Wasm.h

 // Wasm uses a 64k page size
 const uint32_t WasmPageSize = 65536;
 
 struct WasmObjectHeader {
   StringRef Magic;
   uint32_t Version;
 };
 
+struct WasmDylinkExport {
+  StringRef Name;
+  uint32_t Flags;
+};
+
 struct WasmDylinkInfo {
   uint32_t MemorySize; // Memory size in bytes
   uint32_t MemoryAlignment;  // P2 alignment of memory
   uint32_t TableSize;  // Table size in elements
   uint32_t TableAlignment;  // P2 alignment of table
   std::vector<StringRef> Needed; // Shared library dependencies
+  std::vector<WasmDylinkExport> ExportInfo; // Shared library dependencies
 };
 
 struct WasmProducerInfo {
   std::vector<std::pair<std::string, std::string>> Languages;
   std::vector<std::pair<std::string, std::string>> Tools;
   std::vector<std::pair<std::string, std::string>> SDKs;
 };
 
enum : unsigned {
   WASM_COMDAT_INFO = 0x7,
   WASM_SYMBOL_TABLE = 0x8,
 };
 
 // Kind codes used in the custom "dylink" section
 enum : unsigned {
   WASM_DYLINK_MEM_INFO = 0x1,
   WASM_DYLINK_NEEDED = 0x2,
+  WASM_DYLINK_EXPORT_INFO = 0x3,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA = 0x0,
   WASM_COMDAT_FUNCTION = 0x1,
   // GLOBAL, TAG, and TABLE are in here but LLVM doesn't use them yet.
   WASM_COMDAT_SECTION = 0x5,

llvm/include/llvm/MC/MCExpr.h

enum VariantKind : uint16_t {
     VK_Hexagon_LD_PLT,
     VK_Hexagon_IE,
     VK_Hexagon_IE_GOT,
 
     VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
     VK_WASM_TLSREL,    // Memory address relative to __tls_base
     VK_WASM_MBREL,     // Memory address relative to __memory_base
     VK_WASM_TBREL,     // Table index relative to __table_base
+    VK_WASM_GOT_TLS,   // Wasm global index of TLS symbol.
 
     VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
     VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
     VK_AMDGPU_REL32_LO,      // symbol@rel32@lo
     VK_AMDGPU_REL32_HI,      // symbol@rel32@hi
     VK_AMDGPU_REL64,         // symbol@rel64
     VK_AMDGPU_ABS32_LO,      // symbol@abs32@lo
     VK_AMDGPU_ABS32_HI,      // symbol@abs32@hi

llvm/include/llvm/ObjectYAML/WasmYAML.h

struct CustomSection : Section {
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_CUSTOM;
   }
 
   StringRef Name;
   yaml::BinaryRef Payload;
 };
 
+struct DylinkExport {
+  StringRef Name;
+  SymbolFlags Flags;
+};
+
 struct DylinkSection : CustomSection {
   DylinkSection() : CustomSection("dylink.0") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "dylink.0";
   }
 
   uint32_t MemorySize;
   uint32_t MemoryAlignment;
   uint32_t TableSize;
   uint32_t TableAlignment;
   std::vector<StringRef> Needed;
+  std::vector<DylinkExport> ExportInfo;
 };
 
 struct NameSection : CustomSection {
   NameSection() : CustomSection("name") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "name";

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Tag)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkExport)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };
 

 template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
   static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
 };
 
 template <> struct MappingTraits<WasmYAML::Tag> {
   static void mapping(IO &IO, WasmYAML::Tag &Tag);
 };
 
+template <> struct MappingTraits<WasmYAML::DylinkExport> {
+  static void mapping(IO &IO, WasmYAML::DylinkExport &Export);
+};
+
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_WASMYAML_H

llvm/lib/MC/MCExpr.cpp

StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_Hexagon_GD_PLT: return "GDPLT";
   case VK_Hexagon_LD_PLT: return "LDPLT";
   case VK_Hexagon_IE: return "IE";
   case VK_Hexagon_IE_GOT: return "IEGOT";
   case VK_WASM_TYPEINDEX: return "TYPEINDEX";
   case VK_WASM_MBREL: return "MBREL";
   case VK_WASM_TLSREL: return "TLSREL";
   case VK_WASM_TBREL: return "TBREL";
+  case VK_WASM_GOT_TLS: return "GOT@TLS";
   case VK_AMDGPU_GOTPCREL32_LO: return "gotpcrel32@lo";
   case VK_AMDGPU_GOTPCREL32_HI: return "gotpcrel32@hi";
   case VK_AMDGPU_REL32_LO: return "rel32@lo";
   case VK_AMDGPU_REL32_HI: return "rel32@hi";
   case VK_AMDGPU_REL64: return "rel64";
   case VK_AMDGPU_ABS32_LO: return "abs32@lo";
   case VK_AMDGPU_ABS32_HI: return "abs32@hi";
   case VK_VE_HI32: return "hi";
return StringSwitch<VariantKind>(Name.lower())
     .Case("tlsldo", VK_ARM_TLSLDO)
     .Case("lo8", VK_AVR_LO8)
     .Case("hi8", VK_AVR_HI8)
     .Case("hlo8", VK_AVR_HLO8)
     .Case("typeindex", VK_WASM_TYPEINDEX)
     .Case("tbrel", VK_WASM_TBREL)
     .Case("mbrel", VK_WASM_MBREL)
     .Case("tlsrel", VK_WASM_TLSREL)
+    .Case("got@tls", VK_WASM_GOT_TLS)
     .Case("gotpcrel32@lo", VK_AMDGPU_GOTPCREL32_LO)
     .Case("gotpcrel32@hi", VK_AMDGPU_GOTPCREL32_HI)
     .Case("rel32@lo", VK_AMDGPU_REL32_LO)
     .Case("rel32@hi", VK_AMDGPU_REL32_HI)
     .Case("rel64", VK_AMDGPU_REL64)
     .Case("abs32@lo", VK_AMDGPU_ABS32_LO)
     .Case("abs32@hi", VK_AMDGPU_ABS32_HI)
     .Case("hi", VK_VE_HI32)

llvm/lib/MC/MCWasmStreamer.cpp

case MCExpr::Binary: {
     const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
     fixSymbolsInTLSFixups(be->getLHS());
     fixSymbolsInTLSFixups(be->getRHS());
     break;
   }
 
   case MCExpr::SymbolRef: {
     const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
-    if (symRef.getKind() == MCSymbolRefExpr::VK_WASM_TLSREL) {
+    switch (symRef.getKind()) {
+    case MCSymbolRefExpr::VK_WASM_TLSREL:
+    case MCSymbolRefExpr::VK_WASM_GOT_TLS:
       getAssembler().registerSymbol(symRef.getSymbol());
       cast<MCSymbolWasm>(symRef.getSymbol()).setTLS();
+      break;
+    default:
+      break;
     }
     break;
   }
 
   case MCExpr::Unary:
     fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
     break;
   }

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
     if (SymA->getName().empty())
       report_fatal_error("relocations against un-named temporaries are not yet "
                          "supported by wasm");
 
     SymA->setUsedInReloc();
   }
 
-  if (RefA->getKind() == MCSymbolRefExpr::VK_GOT)
+  switch (RefA->getKind()) {
+  case MCSymbolRefExpr::VK_GOT:
+  case MCSymbolRefExpr::VK_WASM_GOT_TLS:
     SymA->setUsedInGOT();
+    break;
+  default:
+    break;
+  }
 
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
   LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
 
   if (FixupSection.isWasmData()) {
     DataRelocations.push_back(Rec);
   } else if (FixupSection.getKind().isText()) {
     CodeRelocations.push_back(Rec);

llvm/lib/Object/WasmObjectFile.cpp

 }
 
 Error WasmObjectFile::parseDylink0Section(ReadContext &Ctx) {
   // See
   // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
   HasDylinkSection = true;
 
   const uint8_t *OrigEnd = Ctx.End;
   while (Ctx.Ptr < OrigEnd) {
     Ctx.End = OrigEnd;
     uint8_t Type = readUint8(Ctx);
     uint32_t Size = readVaruint32(Ctx);
     LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
                       << "\n");
     Ctx.End = Ctx.Ptr + Size;
     uint32_t Count;
     switch (Type) {
     case wasm::WASM_DYLINK_MEM_INFO:
       DylinkInfo.MemorySize = readVaruint32(Ctx);
       DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
       DylinkInfo.TableSize = readVaruint32(Ctx);
       DylinkInfo.TableAlignment = readVaruint32(Ctx);
       break;
     case wasm::WASM_DYLINK_NEEDED:
       Count = readVaruint32(Ctx);
       while (Count--) {
         DylinkInfo.Needed.push_back(readString(Ctx));
       }
       break;
+    case wasm::WASM_DYLINK_EXPORT_INFO: {
+      uint32_t Count = readVaruint32(Ctx);
+      while (Count--) {
+        DylinkInfo.ExportInfo.push_back({readString(Ctx), readVaruint32(Ctx)});
+      }
+      break;
+    }
     default:
       return make_error<GenericBinaryError>("unknown dylink.0 sub-section",
                                             object_error::parse_failed);
       Ctx.Ptr += Size;
       break;
     }
     if (Ctx.Ptr != Ctx.End) {
       return make_error<GenericBinaryError>(

llvm/lib/ObjectYAML/WasmYAML.cpp

 static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("MemorySize", Section.MemorySize);
   IO.mapRequired("MemoryAlignment", Section.MemoryAlignment);
   IO.mapRequired("TableSize", Section.TableSize);
   IO.mapRequired("TableAlignment", Section.TableAlignment);
   IO.mapRequired("Needed", Section.Needed);
+  IO.mapRequired("ExportInfo", Section.ExportInfo);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
   IO.mapOptional("GlobalNames", Section.GlobalNames);
   IO.mapOptional("DataSegmentNames", Section.DataSegmentNames);

 }
 
 void MappingTraits<WasmYAML::Tag>::mapping(IO &IO, WasmYAML::Tag &Tag) {
   IO.mapRequired("Index", Tag.Index);
   IO.mapRequired("Attribute", Tag.Attribute);
   IO.mapRequired("SigIndex", Tag.SigIndex);
 }
 
+void MappingTraits<WasmYAML::DylinkExport>::mapping(
+    IO &IO, WasmYAML::DylinkExport &Export) {
+  IO.mapRequired("Name", Export.Name);
+  IO.mapRequired("Flags", Export.Flags);
+}
+
 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
     IO &IO, WasmYAML::LimitFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(HAS_MAX);
   BCase(IS_SHARED);
   BCase(IS_64);
 #undef BCase
 }

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp

if (getSymRef(ErrorLoc, Inst, SymRef))
     return true;
   auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
   switch (WasmSym->getType().getValueOr(wasm::WASM_SYMBOL_TYPE_DATA)) {
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     Type = static_cast<wasm::ValType>(WasmSym->getGlobalType().Type);
     break;
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
   case wasm::WASM_SYMBOL_TYPE_DATA:
-    if (SymRef->getKind() == MCSymbolRefExpr::VK_GOT) {
+    switch (SymRef->getKind()) {
+    case MCSymbolRefExpr::VK_GOT:
+    case MCSymbolRefExpr::VK_WASM_GOT_TLS:
       Type = is64 ? wasm::ValType::I64 : wasm::ValType::I32;
+      return false;
+    default:
       break;
     }
     LLVM_FALLTHROUGH;
   default:
     return typeError(ErrorLoc, StringRef("symbol ") + WasmSym->getName() +
                                     " missing .globaltype");
   }
   return false;

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

enum TOF {
   MO_NO_FLAG = 0,
 
   // On a symbol operand this indicates that the immediate is a wasm global
   // index.  The value of the wasm global will be set to the symbol address at
   // runtime.  This adds a level of indirection similar to the GOT on native
   // platforms.
   MO_GOT,
 
+  // Same as MO_GOT but the address stored in the global is a TLS address.
+  MO_GOT_TLS,
+
   // On a symbol operand this indicates that the immediate is the symbol
   // address relative the __memory_base wasm global.
   // Only applicable to data symbols.
   MO_MEMORY_BASE_REL,
 
   // On a symbol operand this indicates that the immediate is the symbol
   // address relative the __tls_base wasm global.
   // Only applicable to data symbols.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

unsigned WebAssemblyWasmObjectWriter::getRelocType(
   const MCSymbolRefExpr *RefA = Target.getSymA();
   assert(RefA);
   auto& SymA = cast<MCSymbolWasm>(RefA->getSymbol());
 
   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 
   switch (Modifier) {
     case MCSymbolRefExpr::VK_GOT:
+    case MCSymbolRefExpr::VK_WASM_GOT_TLS:
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     case MCSymbolRefExpr::VK_WASM_TBREL:
       assert(SymA.isFunction());
       return is64Bit() ? wasm::R_WASM_TABLE_INDEX_REL_SLEB64
                        : wasm::R_WASM_TABLE_INDEX_REL_SLEB;
     case MCSymbolRefExpr::VK_WASM_TLSREL:
       return is64Bit() ? wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64
                        : wasm::R_WASM_MEMORY_ADDR_TLS_SLEB;
     case MCSymbolRefExpr::VK_WASM_MBREL:
       assert(SymA.isData());
       return is64Bit() ? wasm::R_WASM_MEMORY_ADDR_REL_SLEB64
                        : wasm::R_WASM_MEMORY_ADDR_REL_SLEB;
     case MCSymbolRefExpr::VK_WASM_TYPEINDEX:
       return wasm::R_WASM_TYPE_INDEX_LEB;
+    case MCSymbolRefExpr::VK_None:
+      break;
     default:
+      report_fatal_error("unknown VariantKind");
       break;
   }
 
   switch (unsigned(Fixup.getKind())) {
   case WebAssembly::fixup_sleb128_i32:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_SLEB;
     return wasm::R_WASM_MEMORY_ADDR_SLEB;

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

SDValue WebAssemblyTargetLowering::LowerFRAMEADDR(SDValue Op,
   return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(Op), FP, VT);
 }
 
 SDValue
 WebAssemblyTargetLowering::LowerGlobalTLSAddress(SDValue Op,
                                                  SelectionDAG &DAG) const {
   SDLoc DL(Op);
   const auto *GA = cast<GlobalAddressSDNode>(Op);
-  MVT PtrVT = getPointerTy(DAG.getDataLayout());
 
   MachineFunction &MF = DAG.getMachineFunction();
   if (!MF.getSubtarget<WebAssemblySubtarget>().hasBulkMemory())
     report_fatal_error("cannot use thread-local storage without bulk memory",
                        false);
 
   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()))

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 def : Pat<(i64 (WebAssemblyWrapperREL tglobaladdr:$addr)),
           (CONST_I64 tglobaladdr:$addr)>, Requires<[IsPIC, HasAddr64]>;
 
 def : Pat<(i32 (WebAssemblyWrapperREL tglobaltlsaddr:$addr)),
           (CONST_I32 tglobaltlsaddr:$addr)>, Requires<[HasAddr32]>;
 def : Pat<(i64 (WebAssemblyWrapperREL tglobaltlsaddr:$addr)),
           (CONST_I64 tglobaltlsaddr:$addr)>, Requires<[HasAddr64]>;
 
+def : Pat<(i32 (WebAssemblyWrapper tglobaltlsaddr:$addr)),
+          (GLOBAL_GET_I32 tglobaltlsaddr:$addr)>, Requires<[HasAddr32]>;
+def : Pat<(i64 (WebAssemblyWrapper tglobaltlsaddr:$addr)),
+          (GLOBAL_GET_I64 tglobaltlsaddr:$addr)>, Requires<[HasAddr64]>;
+
 def : Pat<(i32 (WebAssemblyWrapper texternalsym:$addr)),
           (GLOBAL_GET_I32 texternalsym:$addr)>, Requires<[IsPIC, HasAddr32]>;
 def : Pat<(i64 (WebAssemblyWrapper texternalsym:$addr)),
           (GLOBAL_GET_I64 texternalsym:$addr)>, Requires<[IsPIC, HasAddr64]>;
 
 def : Pat<(i32 (WebAssemblyWrapper texternalsym:$addr)),
           (CONST_I32 texternalsym:$addr)>, Requires<[IsNotPIC, HasAddr32]>;
 def : Pat<(i64 (WebAssemblyWrapper texternalsym:$addr)),

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

 MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
                                                      MCSymbol *Sym) const {
   MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
   unsigned TargetFlags = MO.getTargetFlags();
 
   switch (TargetFlags) {
     case WebAssemblyII::MO_NO_FLAG:
       break;
+    case WebAssemblyII::MO_GOT_TLS:
+      Kind = MCSymbolRefExpr::VK_WASM_GOT_TLS;
+      break;
     case WebAssemblyII::MO_GOT:
       Kind = MCSymbolRefExpr::VK_GOT;
       break;
     case WebAssemblyII::MO_MEMORY_BASE_REL:
       Kind = MCSymbolRefExpr::VK_WASM_MBREL;
       break;
     case WebAssemblyII::MO_TLS_BASE_REL:
       Kind = MCSymbolRefExpr::VK_WASM_TLSREL;

llvm/test/CodeGen/WebAssembly/tls-general-dynamic.ll

define i32 @address_of_tls() {
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: return
 
   ; NO-TLS-NEXT: i32.const tls
   ; NO-TLS-NEXT: return
   ret i32 ptrtoint(i32* @tls to i32)
 }
 
+; CHECK-LABEL: address_of_tls_external:
+; CHECK-NEXT: .functype  address_of_tls_external () -> (i32)
+define i32 @address_of_tls_external() {
+  ; TLS-DAG: global.get tls_external@GOT@TLS
+  ; TLS-NEXT: return
+
+  ; NO-TLS-NEXT: i32.const tls_external
+  ; NO-TLS-NEXT: return
+  ret i32 ptrtoint(i32* @tls_external to i32)
+}
+
 ; CHECK-LABEL: ptr_to_tls:
 ; CHECK-NEXT: .functype ptr_to_tls () -> (i32)
 define i32* @ptr_to_tls() {
   ; TLS-DAG: global.get __tls_base
   ; TLS-DAG: i32.const tls@TLSREL
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: return
 
   ; NO-TLS-NEXT: i32.const tls
   ; NO-TLS-NEXT: return
   ret i32* @tls
 }
 
+; CHECK-LABEL: ptr_to_tls_external:
+; CHECK-NEXT: .functype ptr_to_tls_external () -> (i32)
+define i32* @ptr_to_tls_external() {
+  ; TLS-DAG: global.get tls_external@GOT@TLS
+  ; TLS-NEXT: return
+
+  ; NO-TLS-NEXT: i32.const tls_external
+  ; NO-TLS-NEXT: return
+  ret i32* @tls_external
+}
+
 ; CHECK-LABEL: tls_load:
 ; CHECK-NEXT: .functype tls_load () -> (i32)
 define i32 @tls_load() {
   ; TLS-DAG: global.get __tls_base
   ; TLS-DAG: i32.const tls@TLSREL
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: i32.load 0
   ; TLS-NEXT: return
 
   ; NO-TLS-NEXT: i32.const 0
   ; NO-TLS-NEXT: i32.load tls
   ; NO-TLS-NEXT: return
   %tmp = load i32, i32* @tls, align 4
   ret i32 %tmp
 }
 
+; CHECK-LABEL: tls_load_external:
+; CHECK-NEXT: .functype tls_load_external () -> (i32)
+define i32 @tls_load_external() {
+  ; TLS-DAG: global.get tls_external@GOT@TLS
+  ; TLS-NEXT: i32.load 0
+  ; TLS-NEXT: return
+
+  ; NO-TLS-NEXT: i32.const 0
+  ; NO-TLS-NEXT: i32.load tls_external
+  ; NO-TLS-NEXT: return
+  %tmp = load i32, i32* @tls_external, align 4
+  ret i32 %tmp
+}
+
 ; CHECK-LABEL: tls_store:
 ; CHECK-NEXT: .functype tls_store (i32) -> ()
 define void @tls_store(i32 %x) {
   ; TLS-DAG: global.get __tls_base
   ; TLS-DAG: i32.const tls@TLSREL
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: i32.store 0
   ; TLS-NEXT: return
 
   ; NO-TLS-NEXT: i32.const 0
   ; NO-TLS-NEXT: i32.store tls
   ; NO-TLS-NEXT: return
   store i32 %x, i32* @tls, align 4
   ret void
 }
 
+; CHECK-LABEL: tls_store_external:
+; CHECK-NEXT: .functype tls_store_external (i32) -> ()
+define void @tls_store_external(i32 %x) {
+  ; TLS-DAG: global.get tls_external@GOT@TLS
+  ; TLS-NEXT: i32.store 0
+  ; TLS-NEXT: return
+
+  ; NO-TLS-NEXT: i32.const 0
+  ; NO-TLS-NEXT: i32.store tls_external
+  ; NO-TLS-NEXT: return
+  store i32 %x, i32* @tls_external, align 4
+  ret void
+}
+
 ; CHECK-LABEL: tls_size:
 ; CHECK-NEXT: .functype tls_size () -> (i32)
 define i32 @tls_size() {
 ; CHECK-NEXT: global.get __tls_size
 ; CHECK-NEXT: return
   %1 = call i32 @llvm.wasm.tls.size.i32()
   ret i32 %1
 }

 ; CHECK: .type tls,@object
 ; TLS-NEXT: .section .tbss.tls,"T",@
 ; NO-TLS-NEXT: .section .bss.tls,"",@
 ; CHECK-NEXT: .p2align 2
 ; CHECK-NEXT: tls:
 ; CHECK-NEXT: .int32 0
 @tls = internal thread_local global i32 0
 
+@tls_external = external thread_local global i32, align 4
+
 declare i32 @llvm.wasm.tls.size.i32()
 declare i32 @llvm.wasm.tls.align.i32()
 declare i8* @llvm.wasm.tls.base()

llvm/test/CodeGen/WebAssembly/tls-local-exec.ll

define i32 @address_of_tls() {
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: return
 
   ; NO-TLS-NEXT: i32.const tls
   ; NO-TLS-NEXT: return
   ret i32 ptrtoint(i32* @tls to i32)
 }
 
+; CHECK-LABEL: address_of_tls_external:
+; CHECK-NEXT: .functype  address_of_tls_external () -> (i32)
+define i32 @address_of_tls_external() {
+  ; TLS-DAG: global.get __tls_base
+  ; TLS-DAG: i32.const tls_external@TLSREL
+  ; TLS-NEXT: i32.add
+  ; TLS-NEXT: return
+
+  ; NO-TLS-NEXT: i32.const tls_external
+  ; NO-TLS-NEXT: return
+  ret i32 ptrtoint(i32* @tls_external to i32)
+}
+
 ; CHECK-LABEL: ptr_to_tls:
 ; CHECK-NEXT: .functype ptr_to_tls () -> (i32)
 define i32* @ptr_to_tls() {
   ; TLS-DAG: global.get __tls_base
   ; TLS-DAG: i32.const tls@TLSREL
   ; TLS-NEXT: i32.add
   ; TLS-NEXT: return
 

 ; CHECK: .type tls,@object
 ; TLS-NEXT: .section .tbss.tls,"T",@
 ; NO-TLS-NEXT: .section .bss.tls,"",@
 ; CHECK-NEXT: .p2align 2
 ; CHECK-NEXT: tls:
 ; CHECK-NEXT: .int32 0
 @tls = internal thread_local(localexec) global i32 0
 
+@tls_external = external thread_local(localexec) global i32, align 4
+
 declare i32 @llvm.wasm.tls.size.i32()

llvm/test/MC/WebAssembly/tls.s

tls_store:
   i32.const tls1@TLSREL
   i32.add
   local.get 0
   i32.store 0
   end_function
 
 tls_get_undefined:
   .functype tls_get_undefined (i32) -> (i32)
-  i32.const tls_undefined@TLSREL
+  global.get tls_undefined@GOT@TLS
   end_function
 
 .section .tls.foo,"T",@
 # CHECK: .tls.foo,"T",@
 tls1:
   .int32 42
   .size tls1, 4
 
 .section custom_tls,"T",@
 # CHECK: custom_tls,"T",@
 tls2:
   .int32 43
   .size tls2, 4
 
 #      CHECK-OBJ:  - Type:            CODE
 # CHECK-OBJ-NEXT:    Relocations:
 # CHECK-OBJ-NEXT:      - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-OBJ-NEXT:        Index:           1
 # CHECK-OBJ-NEXT:        Offset:          0x4
 # CHECK-OBJ-NEXT:      - Type:            R_WASM_MEMORY_ADDR_TLS_SLEB
 # CHECK-OBJ-NEXT:        Index:           2
 # CHECK-OBJ-NEXT:        Offset:          0xA
+# CHECK-OBJ-NEXT:      - Type:            R_WASM_GLOBAL_INDEX_LEB
+# CHECK-OBJ-NEXT:        Index:           4
+# CHECK-OBJ-NEXT:        Offset:          0x19
 
 #      CHECK-OBJ:  - Type:            CUSTOM
 # CHECK-OBJ-NEXT:    Name:            linking
 # CHECK-OBJ-NEXT:    Version:         2
 # CHECK-OBJ-NEXT:    SymbolTable:
 # CHECK-OBJ-NEXT:      - Index:           0
 # CHECK-OBJ-NEXT:        Kind:            FUNCTION
 # CHECK-OBJ-NEXT:        Name:            tls_store

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink" || WasmSec.Name == "dylink.0") {
     std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
         std::make_unique<WasmYAML::DylinkSection>();
     const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
     DylinkSec->MemorySize = Info.MemorySize;
     DylinkSec->MemoryAlignment = Info.MemoryAlignment;
     DylinkSec->TableSize = Info.TableSize;
     DylinkSec->TableAlignment = Info.TableAlignment;
     DylinkSec->Needed = Info.Needed;
+    for (const auto &Exp : Info.ExportInfo)
+      DylinkSec->ExportInfo.push_back({Exp.Name, Exp.Flags});
     CustomSec = std::move(DylinkSec);
   } else if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::NameSection> NameSec =
         std::make_unique<WasmYAML::NameSection>();
     for (const llvm::wasm::WasmDebugName &Name : Obj.debugNames()) {
       WasmYAML::NameEntry NameEntry;
       NameEntry.Name = Name.Name;
       NameEntry.Index = Name.Index;