[WebAssembly] Add new relocation types for TLS data symbols

[sbc100]

Summary

These relocations represent offsets from the __tls_base symbol.

Previously we were just using normal MEMORY_ADDR relocations and relying
on the linker to select a segment-offset rather and absolute value in
Symbol::getVirtualAddress(). Using an explicit relocation type allows
allow us to clearly distingish absolute from relative relocations based
on the relocation information alone.

One place this is usefull is being able to reject absolute relocation in
the PIC case, but still accept TLS relocations.

[sbc100]

typos

[tlively]

Why are there separate versions of the new relocation for both i32 and sleb128? Do we use both of them?

lld/test/wasm/tls.s

10

Was the previous direct addressing relocation implicit in i32.const tls1 because it used a symbol name in place of a number literal?

lld/wasm/InputFiles.cpp

241

What about .tbss? Are there other possible thread-local section names? Same question down in scanRelocations and elsewhere.

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

246 ↗

(On Diff #304546)

What is this function used for?

[sbc100]

Ah yes, I forgot about the I32 relocation type. I looks like we don't actually need that since you can't have thread local address in global data... great!

# cat test.c
_Thread_local int bar;
int* a = &bar;
$ gcc test.c
test.c:2:10: error: initializer element is not constant
    2 | int* a = &bar;
      |          ^

lld/test/wasm/tls.s

10

Yes. This is basically the bug I'm trying to fix here.

i32.const tls1 is a "normal" relocation against the symbol tls1. However, as you can see from the comments in the lld changes here we had special handling of "normal" relocations in the linker when the target symbol happened to be in a TLS area.

This new mode is more explicit and also allows us to catch bugs (e.g. @tls relocation against non-tls symbols and vice versa).

lld/wasm/InputFiles.cpp

241

We currently combine all tls data into a single .tdata section here in the linker. So there is always exactly one output TLS segment.

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

246 ↗

(On Diff #304546)

Good question :) Maybe I should revert this part.. I noticed that other platforms implement this but we were missing it. I'm guessing its for debugging of MIR or some thing like that?

[sbc100]

• remove I32 version

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

246 ↗

(On Diff #304546)

Yeah, I think that would be best until figure out what this is for and how we can test it.

lld/test/wasm/relocation-bad-tls.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+# RUN: not wasm-ld %t.o -o out.wasm 2>&1 | FileCheck %s
+
+.globl _start
+_start:
+  .functype _start () -> ()
+  i32.const foo@TLSREL
+  i32.const bar@TLSREL
+  end_function
+
+.section  .data,"",@
+.globl  foo
+foo:
+  .int32  0
+  .size foo, 4
+
+.section  .bss,"",@
+.globl  bar
+bar:
+  .int32  0
+  .size bar, 4
+
+# CHECK: relocation R_WASM_MEMORY_ADDR_TLS_SLEB cannot be used against `foo` in non-TLS section: .data
+# CHECK: relocation R_WASM_MEMORY_ADDR_TLS_SLEB cannot be used against `bar` in non-TLS section: .bss

lld/test/wasm/tls.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 
 .globaltype __tls_base, i32
 .globaltype __tls_align, i32, immutable
 
 .globl tls1_addr
 tls1_addr:
   .functype tls1_addr () -> (i32)
   global.get __tls_base
-  i32.const tls1
+  i32.const tls1@TLSREL
   i32.add
   end_function
 
 .globl tls2_addr
 tls2_addr:
   .functype tls2_addr () -> (i32)
   global.get __tls_base
-  i32.const tls2
+  i32.const tls2@TLSREL
   i32.add
   end_function
 
 .globl tls3_addr
 tls3_addr:
   .functype tls3_addr () -> (i32)
   global.get __tls_base
   i32.const tls3

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     case R_WASM_MEMORY_ADDR_LEB64:
       existingValue = decodeULEB128(loc, &bytesRead);
       paddedLEBWidth = 10;
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
+    case R_WASM_MEMORY_ADDR_TLS_SLEB:
       existingValue = static_cast<uint64_t>(decodeSLEB128(loc, &bytesRead));
       break;
     case R_WASM_TABLE_INDEX_SLEB64:
     case R_WASM_MEMORY_ADDR_SLEB64:
     case R_WASM_MEMORY_ADDR_REL_SLEB64:
       existingValue = static_cast<uint64_t>(decodeSLEB128(loc, &bytesRead));
       paddedLEBWidth = 10;
       break;
case R_WASM_MEMORY_ADDR_LEB:
       break;
     case R_WASM_MEMORY_ADDR_LEB64:
       encodeULEB128(value, loc, 10);
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
+    case R_WASM_MEMORY_ADDR_TLS_SLEB:
       encodeSLEB128(static_cast<int32_t>(value), loc, 5);
       break;
     case R_WASM_TABLE_INDEX_SLEB64:
     case R_WASM_MEMORY_ADDR_SLEB64:
     case R_WASM_MEMORY_ADDR_REL_SLEB64:
       encodeSLEB128(static_cast<int64_t>(value), loc, 10);
       break;
     case R_WASM_TABLE_INDEX_I32:

lld/wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/raw_ostream.h"
uint64_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
   }
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
-  case R_WASM_MEMORY_ADDR_I64: {
+  case R_WASM_MEMORY_ADDR_I64:
+  case R_WASM_MEMORY_ADDR_TLS_SLEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     if (sym.isUndefined())
       return 0;
     const WasmSegment &segment =
         wasmObj->dataSegments()[sym.Info.DataRef.Segment];
     if (segment.Data.Offset.Opcode == WASM_OPCODE_I32_CONST)
       return segment.Data.Offset.Value.Int32 + sym.Info.DataRef.Offset +
              reloc.Addend;
uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc) const {
   }
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
-  case R_WASM_MEMORY_ADDR_I64:
+  case R_WASM_MEMORY_ADDR_I64: {
+    if (isa<UndefinedData>(sym) || sym->isUndefWeak())
+      return 0;
+    auto D = cast<DefinedData>(sym);
+    // Treat non-TLS relocation against symbols that live in the TLS segment
+    // like TLS relocations.  This beaviour exists to support older object
+    // files created before we introduced TLS relocations.
+    // TODO(sbc): Remove this legacy behaviour one day.  This will break
+    // backward compat with old object files built with `-fPIC`.
+    if (D->segment && D->segment->outputSeg->name == ".tdata")
+      return D->getOutputSegmentOffset() + reloc.Addend;
+    return D->getVirtualAddress() + reloc.Addend;
+  }
+  case R_WASM_MEMORY_ADDR_TLS_SLEB:
     if (isa<UndefinedData>(sym) || sym->isUndefWeak())
       return 0;
-    return cast<DefinedData>(sym)->getVirtualAddress() + reloc.Addend;
+    // TLS relocations are relative to the start of the TLS output segment
+    return cast<DefinedData>(sym)->getOutputSegmentOffset() + reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return typeMap[reloc.Index];
   case R_WASM_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(reloc.Index)->getFunctionIndex();
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_I32:
     if (auto gs = dyn_cast<GlobalSymbol>(sym))
       return gs->getGlobalIndex();

lld/wasm/OutputSections.cpp

 }
 
 void DataSection::finalizeContents() {
   raw_string_ostream os(dataSectionHeader);
   unsigned segmentCount =
       std::count_if(segments.begin(), segments.end(),
                     [](OutputSegment *segment) { return !segment->isBss; });
 
+#ifndef NDEBUG
+  unsigned activeCount = std::count_if(
+      segments.begin(), segments.end(), [](OutputSegment *segment) {
+        return (segment->initFlags & WASM_SEGMENT_IS_PASSIVE) == 0;
+      });
+#endif
+
+  assert((!config->isPic || activeCount <= 1) &&
+         "Currenly only a single data segment is supported in PIC mode");
+
   writeUleb128(os, segmentCount, "data segment count");
   os.flush();
   bodySize = dataSectionHeader.size();
 
-  assert((!config->isPic || segments.size() <= 1) &&
-         "Currenly only a single data segment is supported in PIC mode");
-
   for (OutputSegment *segment : segments) {
     if (segment->isBss)
       continue;
     raw_string_ostream os(segment->header);
     writeUleb128(os, segment->initFlags, "init flags");
     if (segment->initFlags & WASM_SEGMENT_HAS_MEMINDEX)
       writeUleb128(os, 0, "memory index");
     if ((segment->initFlags & WASM_SEGMENT_IS_PASSIVE) == 0) {

lld/wasm/Relocations.cpp

 //===- Relocations.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Relocations.h"
 
 #include "InputChunks.h"
+#include "OutputSegment.h"
 #include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
 namespace wasm {
 
case R_WASM_TABLE_INDEX_REL_SLEB:
         break;
       out.elemSec->addEntry(cast<FunctionSymbol>(sym));
       break;
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_I32:
       if (!isa<GlobalSymbol>(sym))
         addGOTEntry(sym);
       break;
+    case R_WASM_MEMORY_ADDR_TLS_SLEB:
+      if (auto *D = dyn_cast<DefinedData>(sym)) {
+        if (D->segment->outputSeg->name != ".tdata") {
+          error(toString(file) + ": relocation " +
+                relocTypeToString(reloc.Type) + " cannot be used against `" +
+                toString(*sym) +
+                "` in non-TLS section: " + D->segment->outputSeg->name);
+        }
+      }
+      break;
     }
 
     if (config->isPic) {
       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:

lld/wasm/Symbols.cpp

 DefinedFunction::DefinedFunction(StringRef name, uint32_t flags, InputFile *f,
                                  InputFunction *function)
     : FunctionSymbol(name, DefinedFunctionKind, flags, f,
                      function ? &function->signature : nullptr),
       function(function) {}
 
 uint64_t DefinedData::getVirtualAddress() const {
   LLVM_DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
-  if (segment) {
-    // For thread local data, the symbol location is relative to the start of
-    // the .tdata section, since they are used as offsets from __tls_base.
-    // Hence, we do not add in segment->outputSeg->startVA.
-    if (segment->outputSeg->name == ".tdata")
-      return segment->outputSegmentOffset + offset;
+  if (segment)
     return segment->outputSeg->startVA + segment->outputSegmentOffset + offset;
-  }
   return offset;
 }
 
 void DefinedData::setVirtualAddress(uint64_t value) {
   LLVM_DEBUG(dbgs() << "setVirtualAddress " << name << " -> " << value << "\n");
   assert(!segment);
   offset = value;
 }

lld/wasm/Writer.cpp

for (ObjFile *file : symtab->objectFiles) {
     for (InputEvent *event : file->events)
       out.eventSec->addEvent(event);
   }
 
   out.globalSec->assignIndexes();
 }
 
 static StringRef getOutputDataSegmentName(StringRef name) {
-  // With PIC code we currently only support a single data segment since
-  // we only have a single __memory_base to use as our base address.
-  if (config->isPic)
-    return ".data";
   // We only support one thread-local segment, so we must merge the segments
   // despite --no-merge-data-segments.
   // We also need to merge .tbss into .tdata so they share the same offsets.
   if (name.startswith(".tdata") || name.startswith(".tbss"))
     return ".tdata";
+  // With PIC code we currently only support a single data segment since
+  // we only have a single __memory_base to use as our base address.
+  if (config->isPic)
+    return ".data";
   if (!config->mergeDataSegments)
     return name;
   if (name.startswith(".text."))
     return ".text";
   if (name.startswith(".data."))
     return ".data";
   if (name.startswith(".bss."))
     return ".bss";
void Writer::run() {
   scanRelocations();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
 
   if (!config->relocatable) {
     // Create linker synthesized functions
-    if (config->sharedMemory)
-      createInitMemoryFunction();
     if (config->isPic)
       createApplyRelocationsFunction();
+    else if (config->sharedMemory)
+      createInitMemoryFunction();
     createCallCtorsFunction();
 
     // Create export wrappers for commands if needed.
     //
     // If the input contains a call to `__wasm_call_ctors`, either in one of
     // the input objects or an explicit export from the command-line, we
     // assume ctors and dtors are taken care of already.
     if (!config->relocatable && !config->isPic &&

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,       13)
 WASM_RELOC(R_WASM_MEMORY_ADDR_LEB64,      14)
 WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB64,     15)
 WASM_RELOC(R_WASM_MEMORY_ADDR_I64,        16)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB64, 17)
 WASM_RELOC(R_WASM_TABLE_INDEX_SLEB64,     18)
 WASM_RELOC(R_WASM_TABLE_INDEX_I64,        19)
 WASM_RELOC(R_WASM_TABLE_NUMBER_LEB,       20)
+WASM_RELOC(R_WASM_MEMORY_ADDR_TLS_SLEB,   21)

llvm/include/llvm/MC/MCExpr.h

enum VariantKind : uint16_t {
     VK_Hexagon_GD_GOT,
     VK_Hexagon_LD_GOT,
     VK_Hexagon_GD_PLT,
     VK_Hexagon_LD_PLT,
     VK_Hexagon_IE,
     VK_Hexagon_IE_GOT,
 
     VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
-    VK_WASM_MBREL,     // Memory address relative to memory base
-    VK_WASM_TBREL,     // Table index relative to table bare
+    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_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/lib/BinaryFormat/Wasm.cpp

bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
   case R_WASM_MEMORY_ADDR_I64:
+  case R_WASM_MEMORY_ADDR_TLS_SLEB:
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_SECTION_OFFSET_I32:
     return true;
   default:
     return false;
   }
 }

llvm/lib/MC/MCExpr.cpp

StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_Hexagon_GD_GOT: return "GDGOT";
   case VK_Hexagon_LD_GOT: return "LDGOT";
   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_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";
return StringSwitch<VariantKind>(Name.lower())
     .Case("sbrel", VK_ARM_SBREL)
     .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("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/WasmObjectWriter.cpp

WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   }
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_LEB64:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_I32:
-  case wasm::R_WASM_MEMORY_ADDR_I64: {
+  case wasm::R_WASM_MEMORY_ADDR_I64:
+  case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB: {
     // Provisional value is address of the global plus the offset
     const MCSymbolWasm *Base =
         cast<MCSymbolWasm>(Layout.getBaseSymbol(*RelEntry.Symbol));
     // For undefined symbols, use zero
     if (!Base->isDefined())
       return 0;
     const wasm::WasmDataReference &BaseRef = DataLocations[Base],
                                   &SymRef = DataLocations[RelEntry.Symbol];
for (const WasmRelocationEntry &RelEntry : Relocations) {
     case wasm::R_WASM_TABLE_INDEX_I64:
     case wasm::R_WASM_MEMORY_ADDR_I64:
       patchI64(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
       writePatchableSLEB<5>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
       writePatchableSLEB<10>(Stream, Value, Offset);
       break;
     default:

llvm/lib/Object/WasmObjectFile.cpp

case wasm::R_WASM_EVENT_INDEX_LEB:
       if (!isValidEventSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation event index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB64:
     case wasm::R_WASM_MEMORY_ADDR_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_I64:

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

enum TOF {
   MO_GOT,
 
   // 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.
+  MO_TLS_BASE_REL,
+
+  // On a symbol operand this indicates that the immediate is the symbol
   // address relative the __table_base wasm global.
   // Only applicable to function symbols.
   MO_TABLE_BASE_REL,
 };
 
 } // end namespace WebAssemblyII
 
 } // end namespace llvm

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

unsigned WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 
   switch (Modifier) {
     case MCSymbolRefExpr::VK_GOT:
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     case MCSymbolRefExpr::VK_WASM_TBREL:
       assert(SymA.isFunction());
       return wasm::R_WASM_TABLE_INDEX_REL_SLEB;
+    case MCSymbolRefExpr::VK_WASM_TLSREL:
+      return 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;
     default:
       break;

llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

if (GA->getGlobal()->getThreadLocalMode() !=
       report_fatal_error("only -ftls-model=local-exec is supported for now on "
                          "non-Emscripten OSes: variable " +
                              GA->getGlobal()->getName(),
                          false);
     }
 
     SDValue TLSBaseSym = CurDAG->getTargetExternalSymbol("__tls_base", PtrVT);
     SDValue TLSOffsetSym = CurDAG->getTargetGlobalAddress(
-        GA->getGlobal(), DL, PtrVT, GA->getOffset(), 0);
+        GA->getGlobal(), DL, PtrVT, GA->getOffset(),
+        WebAssemblyII::MO_TLS_BASE_REL);
 
     MachineSDNode *TLSBase =
         CurDAG->getMachineNode(GlobalGetIns, DL, PtrVT, TLSBaseSym);
     MachineSDNode *TLSOffset =
         CurDAG->getMachineNode(ConstIns, DL, PtrVT, TLSOffsetSym);
     MachineSDNode *TLSAddress = CurDAG->getMachineNode(
         AddIns, DL, PtrVT, SDValue(TLSBase, 0), SDValue(TLSOffset, 0));
     ReplaceNode(Node, TLSAddress);

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h

private:
   }
 
   // Custom lowering hooks.
   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
   SDValue LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerCopyToReg(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerIntrinsic(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

switch (TargetFlags) {
     case WebAssemblyII::MO_NO_FLAG:
       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;
+      break;
     case WebAssemblyII::MO_TABLE_BASE_REL:
       Kind = MCSymbolRefExpr::VK_WASM_TBREL;
       break;
     default:
       llvm_unreachable("Unknown target flag on GV operand");
   }
 
   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Kind, Ctx);

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

for (auto &F : M)
       Lowerer.run(F, FAM);
 
     return true;
   }
 
   bool stripThreadLocals(Module &M) {
     bool Stripped = false;
     for (auto &GV : M.globals()) {
-      if (GV.getThreadLocalMode() !=
-          GlobalValue::ThreadLocalMode::NotThreadLocal) {
+      if (GV.isThreadLocal()) {
         Stripped = true;
-        GV.setThreadLocalMode(GlobalValue::ThreadLocalMode::NotThreadLocal);
+        GV.setThreadLocal(false);
       }
     }
     return Stripped;
   }
 
   void recordFeatures(Module &M, const FeatureBitset &Features, bool Stripped) {
     for (const SubtargetFeatureKV &KV : WebAssemblyFeatureKV) {
       if (Features[KV.Value]) {

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

 ; RUN: not --crash llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory 2>&1 | FileCheck %s --check-prefix=ERROR
 ; RUN: not --crash llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory -fast-isel 2>&1 | FileCheck %s --check-prefix=ERROR
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory --mtriple wasm32-unknown-emscripten | FileCheck %s --check-prefixes=CHECK,TLS
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory --mtriple wasm32-unknown-emscripten -fast-isel | FileCheck %s --check-prefixes=CHECK,TLS
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=-bulk-memory | FileCheck %s --check-prefixes=CHECK,NO-TLS
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; ERROR: LLVM ERROR: only -ftls-model=local-exec is supported for now on non-Emscripten OSes: variable tls
 
 ; CHECK-LABEL: address_of_tls:
 ; CHECK-NEXT: .functype  address_of_tls () -> (i32)
 define i32 @address_of_tls() {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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 ptrtoint(i32* @tls 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
+  ; 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: tls_load:
 ; CHECK-NEXT: .functype tls_load () -> (i32)
 define i32 @tls_load() {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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_store:
 ; CHECK-NEXT: .functype tls_store (i32) -> ()
 define void @tls_store(i32 %x) {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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

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

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory | FileCheck %s --check-prefixes=CHECK,TLS
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=+bulk-memory -fast-isel | FileCheck %s --check-prefixes=CHECK,TLS
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -mattr=-bulk-memory | FileCheck %s --check-prefixes=CHECK,NO-TLS
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: address_of_tls:
 ; CHECK-NEXT: .functype  address_of_tls () -> (i32)
 define i32 @address_of_tls() {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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 ptrtoint(i32* @tls 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
+  ; 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: tls_load:
 ; CHECK-NEXT: .functype tls_load () -> (i32)
 define i32 @tls_load() {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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_store:
 ; CHECK-NEXT: .functype tls_store (i32) -> ()
 define void @tls_store(i32 %x) {
   ; TLS-DAG: global.get __tls_base
-  ; TLS-DAG: i32.const tls
+  ; 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

llvm/test/MC/WebAssembly/tls.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o < %s
+# RUN: obj2yaml %t.o | FileCheck %s --check-prefix=CHECK-OBJ
+
+tls_store:
+  .functype tls_store (i32) -> ()
+  # CHECK: global.get __tls_base
+  # CHECK-NEXT: i32.const tls@TLSREL
+  # CHECK-NEXT: i32.add
+  # CHECK-NEXT: i32.store 0
+  global.get __tls_base
+  i32.const tls@TLSREL
+  i32.add
+  i32.store 0
+  end_function
+
+
+#      CHECK-OBJ:  - Type:            CODE
+# CHECK-OBJ-NEXT:    Relocations:
+# CHECK-OBJ-NEXT:      - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-OBJ-NEXT:        Index:           1
+# CHECK-OBJ-NEXT:        Offset:          0x00000004
+# CHECK-OBJ-NEXT:      - Type:            R_WASM_MEMORY_ADDR_TLS_SLEB
+# CHECK-OBJ-NEXT:        Index:           2
+# CHECK-OBJ-NEXT:        Offset:          0x0000000A
+
+#      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
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Function:        0
+# CHECK-OBJ-NEXT:      - Index:           1
+# CHECK-OBJ-NEXT:        Kind:            DATA
+# CHECK-OBJ-NEXT:        Name:            __tls_base
+# CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED ]
+# CHECK-OBJ-NEXT:      - Index:           2
+# CHECK-OBJ-NEXT:        Kind:            DATA
+# CHECK-OBJ-NEXT:        Name:            tls
+# CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED ]