[lld][WebAssembly] Disallow exporting of TLS symbols

[sbc100]

Summary

Cross module TLS is currently not supported by our ABI. This
change makes explicitly exporting a TLS symbol into an error
and prevents implicit exporting (via --export-all).

See https://github.com/emscripten-core/emscripten/issues/14120

[dschuff]

lld/test/wasm/tls-export.s

10

What is it that actually designates the symbol as TLS? Is it just the section name?
edit: ok yeah i just read the rest of the code. That's surprising; I guess in the object file (and eventually in dylibs) there's a flag in the symbol table, right? or is it still just based on the section name? is ELF like this too, or do they have a section or symbol flag?

17

Hm, you know, If we're going to be writing a lot of these asm tests with post-MVP features, maybe we actually do want to have an assembler directive for it at some point.

lld/wasm/InputChunks.h

121

I guess there doesn't need to be a .trodata because if it's read-only it can always be shared across threads....

lld/wasm/OutputSegment.h

35

I guess this is asymmetric with input chunks because BSS doesn't end up in any kind of segment or descriptor in the output file (it's just implicitly-zeroed space)?

[sbc100]

lld/test/wasm/tls-export.s

10

Currently in wasm its solely based on magic section names. I believe this is true for ELF too, which I did/do find surprising. I could also be wrong.

Symbols themselves are not ever TLS, but they can point into TLS sections. That is my understanding.

17

Indeed, that does seem like something we will need. (either that or some kind command line flag but I don't know if such flags for mc are a thing).

lld/wasm/InputChunks.h

121

Yes as far as I know that is not a thing.

lld/wasm/OutputSegment.h

35

We merge tdata and tbss when we create the output segments. I think the idea is that we want them
to share a single base address (__tls_base + offset should work for anything in any TLS section) avoiding
the need for a separate __tls_bss_base).

static StringRef getOutputDataSegmentName(StringRef name) {                      
  // 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";

[dschuff]

thanks, still LGTM

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`
+
+.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"

lld/wasm/InputChunks.h

public:
   uint32_t getInputSectionOffset() const override {
     return segment.SectionOffset;
   }
   uint64_t getVA(uint64_t offset = 0) const;
 
   const OutputSegment *outputSeg = nullptr;
   uint32_t outputSegmentOffset = 0;
   uint32_t alignment = 0;
+  bool isTLS() {
+    return getName().startswith(".tdata") || getName().startswith(".tbss");
+  }
 
 protected:
   ArrayRef<uint8_t> data() const override { return segment.Data.Content; }
 
   const WasmSegment &segment;
 };
 
 // Represents a single wasm function within and input file.  These are

lld/wasm/InputFiles.cpp

case R_WASM_MEMORY_ADDR_LOCREL_I32: {
     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")
+    if (D->segment && D->segment->outputSeg->isTLS())
       return D->getOutputSegmentOffset() + reloc.Addend;
 
     uint64_t value = D->getVA(reloc.Addend);
     if (reloc.Type == R_WASM_MEMORY_ADDR_LOCREL_I32) {
       const auto *segment = cast<InputSegment>(chunk);
       uint64_t p = segment->outputSeg->startVA + segment->outputSegmentOffset +
                    reloc.Offset - segment->getInputSectionOffset();
       value -= p;

lld/wasm/OutputSegment.h

void addInputSegment(InputSegment *inSeg) {
     alignment = std::max(alignment, segAlign);
     inputSegments.push_back(inSeg);
     size = llvm::alignTo(size, 1ULL << segAlign);
     inSeg->outputSeg = this;
     inSeg->outputSegmentOffset = size;
     size += inSeg->getSize();
   }
 
+  bool isTLS() const { return name == ".tdata"; }
+
   StringRef name;
   bool isBss = false;
   uint32_t index = 0;
   uint32_t initFlags = 0;
   uint32_t sectionOffset = 0;
   uint32_t alignment = 0;
   uint64_t startVA = 0;
   std::vector<InputSegment *> inputSegments;

lld/wasm/Relocations.cpp

case R_WASM_TABLE_INDEX_REL_SLEB:
       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") {
+        if (!D->segment->outputSeg->isTLS()) {
           error(toString(file) + ": relocation " +
                 relocTypeToString(reloc.Type) + " cannot be used against `" +
                 toString(*sym) +
                 "` in non-TLS section: " + D->segment->outputSeg->name);
         }
       }
       break;
     }

lld/wasm/Symbols.h

public:
 
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t index);
 
   WasmSymbolType getWasmType() const;
   bool isExported() const;
+  bool isExportedExplicit() const;
 
   // Indicates that the symbol is used in an __attribute__((used)) directive
   // or similar.
   bool isNoStrip() const;
 
   const WasmSignature* getSignature() const;
 
   uint32_t getGOTIndex() const {

lld/wasm/Symbols.cpp

void Symbol::setHidden(bool isHidden) {
   else
     flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }
 
 bool Symbol::isExported() const {
   if (!isDefined() || isLocal())
     return false;
 
-  if (forceExport || config->exportAll)
+  if (config->exportAll || (config->exportDynamic && !isHidden()))
     return true;
 
-  if (config->exportDynamic && !isHidden())
-    return true;
+  return isExportedExplicit();
+}
 
-  return flags & WASM_SYMBOL_EXPORTED;
+bool Symbol::isExportedExplicit() const {
+  return forceExport || flags & WASM_SYMBOL_EXPORTED;
 }
 
 bool Symbol::isNoStrip() const {
   return flags & WASM_SYMBOL_NO_STRIP;
 }
 
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *f = dyn_cast<DefinedFunction>(this))

lld/wasm/Writer.cpp

void Writer::layoutMemory() {
   out.dylinkSec->memAlign = 0;
   for (OutputSegment *seg : segments) {
     out.dylinkSec->memAlign = std::max(out.dylinkSec->memAlign, seg->alignment);
     memoryPtr = alignTo(memoryPtr, 1ULL << seg->alignment);
     seg->startVA = memoryPtr;
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", seg->name,
                 memoryPtr, seg->size, seg->alignment));
 
-    if (!config->relocatable && seg->name == ".tdata") {
+    if (!config->relocatable && seg->isTLS()) {
       if (config->sharedMemory) {
         auto *tlsSize = cast<DefinedGlobal>(WasmSym::tlsSize);
         setGlobalPtr(tlsSize, seg->size);
 
         auto *tlsAlign = cast<DefinedGlobal>(WasmSym::tlsAlign);
         setGlobalPtr(tlsAlign, int64_t{1} << seg->alignment);
       } else {
         auto *tlsBase = cast<DefinedGlobal>(WasmSym::tlsBase);
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 *e = dyn_cast<DefinedEvent>(sym)) {
       export_ = {name, WASM_EXTERNAL_EVENT, e->getEventIndex()};
     } else if (auto *d = dyn_cast<DefinedData>(sym)) {
+      if (d->segment && d->segment->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");
void Writer::combineOutputSegments() {
   // expressions available:
   // https://github.com/WebAssembly/extended-const
   assert(config->isPic);
   if (segments.size() <= 1)
     return;
   OutputSegment *combined = nullptr;
   std::vector<OutputSegment *> new_segments;
   for (OutputSegment *s : segments) {
-    if (s->name == ".tdata") {
+    if (s->isTLS()) {
       new_segments.push_back(s);
     } else {
       if (!combined) {
         combined = make<OutputSegment>(".data");
         combined->startVA = s->startVA;
         if (config->sharedMemory)
           combined->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
       }
std::string functionBody;
     os << bodyContent;
   }
   ArrayRef<uint8_t> body = arrayRefFromStringRef(saver.save(functionBody));
   cast<SyntheticFunction>(func->function)->setBody(body);
 }
 
 bool Writer::needsPassiveInitialization(const OutputSegment *segment) {
   return segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE &&
-         segment->name != ".tdata" && !segment->isBss;
+         !segment->isTLS() && !segment->isBss;
 }
 
 bool Writer::hasPassiveInitializedSegments() {
   return std::find_if(segments.begin(), segments.end(),
                       [this](const OutputSegment *s) {
                         return this->needsPassiveInitialization(s);
                       }) != segments.end();
 }