[WebAssembly] Add explict TLS symbol flag

[sbc100]

Summary

As before we maintain backwards compat with older object files
by also infering the TLS flag based on the name of the segment.

This change is was split out from https://reviews.llvm.org/D108877.

[sbc100]

• remove debugging

[tlively]

I have to say that I don't quite understand all the MCStreamer stuff, especially what fixSymbolsInTLSFixups is for, but the code looks good to me. Do we have a plan for when we will be able to remove the name-based implicit TLS?

[sbc100]

In D109426#2990483, @tlively wrote:

I have to say that I don't quite understand all the MCStreamer stuff, especially what fixSymbolsInTLSFixups is for, but the code looks good to me. Do we have a plan for when we will be able to remove the name-based implicit TLS?

No plan as yet. I imagine we can do it fairly safely since I won't think anyone outside of emscripten is using WebAssembly + threads yet and emscripten does not provide any object file compatibility between releases.

[sbc100]

In D109426#2990483, @tlively wrote:

I have to say that I don't quite understand all the MCStreamer stuff, especially what fixSymbolsInTLSFixups is for, but the code looks good to me. Do we have a plan for when we will be able to remove the name-based implicit TLS?

I should have mentioned that this code is lifted fairly directly from MCELFStreamer.cpp, at least the pattern:

https://github.com/llvm/llvm-project/blob/9d4896f50e441ea5b9e8ae78ebe328e006cb6b67/llvm/lib/MC/MCELFStreamer.cpp#L395

lld/wasm/InputChunks.h

public:
   uint32_t getComdat() const { return comdat; }
   StringRef getComdatName() const;
   uint32_t getInputSectionOffset() const { return inputSectionOffset; }
 
   size_t getNumRelocations() const { return relocations.size(); }
   void writeRelocations(llvm::raw_ostream &os) const;
   void generateRelocationCode(raw_ostream &os) const;
 
-  bool isTLS() const {
-    // Older object files don't include WASM_SEG_FLAG_TLS and instead
-    // relied on the naming convention.
-    return flags & llvm::wasm::WASM_SEG_FLAG_TLS || name.startswith(".tdata") ||
-           name.startswith(".tbss");
-  }
+  bool isTLS() const { return flags & llvm::wasm::WASM_SEG_FLAG_TLS; }
 
   ObjFile *file;
   OutputSection *outputSec = nullptr;
   uint32_t comdat = UINT32_MAX;
   uint32_t inputSectionOffset = 0;
   uint32_t alignment;
   uint32_t flags;
 
public:
   // Signals that the section is part of the output.  The garbage collector,
   // and COMDAT handling can set a sections' Live bit.
   // If GC is disabled, all sections start out as live by default.
   unsigned live : 1;
 
   // Signals the chunk was discarded by COMDAT handling.
   unsigned discarded : 1;
 
+  // Signals that the chuck was implicitly marked as TLS based on its name
+  // alone. This is a compatibility mechanism to support older object files.
+  unsigned implicitTLS : 1;
+
 protected:
   InputChunk(ObjFile *f, Kind k, StringRef name, uint32_t alignment = 0,
              uint32_t flags = 0)
       : name(name), file(f), alignment(alignment), flags(flags), sectionKind(k),
-        live(!config->gcSections), discarded(false) {}
+        live(!config->gcSections), discarded(false), implicitTLS(false) {}
   ArrayRef<uint8_t> data() const { return rawData; }
   uint64_t getTombstone() const;
 
   ArrayRef<WasmRelocation> relocations;
   ArrayRef<uint8_t> rawData;
 };
 
 // Represents a WebAssembly data segment which can be included as part of

lld/wasm/InputFiles.cpp

void ObjFile::parse(bool ignoreComdats) {
   // Populate `Segments`.
   for (const WasmSegment &s : wasmObj->dataSegments()) {
     InputChunk *seg;
     if (shouldMerge(s)) {
       seg = make<MergeInputChunk>(s, this);
     } else
       seg = make<InputSegment>(s, this);
     seg->discarded = isExcludedByComdat(seg);
-
+    // Older object files did not include WASM_SEG_FLAG_TLS and instead
+    // relied on the naming convention.  To maintain compat with such objects
+    // we still imply the TLS flag based on the name of the segment.
+    if (!seg->isTLS() &&
+        (seg->name.startswith(".tdata") || seg->name.startswith(".tbss"))) {
+      seg->flags |= WASM_SEG_FLAG_TLS;
+      seg->implicitTLS = true;
+    }
     segments.emplace_back(seg);
   }
   setRelocs(segments, dataSection);
 
   // Populate `Functions`.
   ArrayRef<WasmFunction> funcs = wasmObj->functions();
   ArrayRef<uint32_t> funcTypes = wasmObj->functionTypes();
   ArrayRef<WasmSignature> types = wasmObj->types();
case WASM_SYMBOL_TYPE_FUNCTION: {
     if (func->discarded)
       return nullptr;
     return symtab->addDefinedFunction(name, flags, this, func);
   }
   case WASM_SYMBOL_TYPE_DATA: {
     InputChunk *seg = segments[sym.Info.DataRef.Segment];
     auto offset = sym.Info.DataRef.Offset;
     auto size = sym.Info.DataRef.Size;
+    if (seg->implicitTLS) {
+      flags |= WASM_SYMBOL_TLS;
+    }
     if (sym.isBindingLocal())
       return make<DefinedData>(name, flags, this, seg, offset, size);
     if (seg->discarded)
       return nullptr;
     return symtab->addDefinedData(name, flags, this, seg, offset, size);
   }
   case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *global =

lld/wasm/Relocations.cpp

case R_WASM_GLOBAL_INDEX_I32:
         addGOTEntry(sym);
       break;
     case R_WASM_MEMORY_ADDR_TLS_SLEB:
     case R_WASM_MEMORY_ADDR_TLS_SLEB64:
       // In single-threaded builds TLS is lowered away and TLS data can be
       // merged with normal data and allowing TLS relocation in non-TLS
       // segments.
       if (config->sharedMemory) {
+        if (!sym->isTLS()) {
+          error(toString(file) + ": relocation " +
+                relocTypeToString(reloc.Type) +
+                " cannot be used against non-TLS symbol `" + toString(*sym) +
+                "`");
+        }
         if (auto *D = dyn_cast<DefinedData>(sym)) {
           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;
     }
 
     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,
         // since they would require absolute symbol addresses at link time.
         error(toString(file) + ": relocation " + relocTypeToString(reloc.Type) +
               " cannot be used against symbol " + toString(*sym) +
               "; recompile with -fPIC");
         break;
-      case R_WASM_MEMORY_ADDR_TLS_SLEB:
-      case R_WASM_MEMORY_ADDR_TLS_SLEB64:
-        if (!sym->isDefined()) {
-          error(toString(file) +
-                ": TLS symbol is undefined, but TLS symbols cannot yet be "
-                "imported: `" +
-                toString(*sym) + "`");
-        }
-        break;
       case R_WASM_TABLE_INDEX_I32:
       case R_WASM_TABLE_INDEX_I64:
       case R_WASM_MEMORY_ADDR_I32:
       case R_WASM_MEMORY_ADDR_I64:
         // These relocation types are only present in the data section and
         // will be converted into code by `generateRelocationCode`.  This code
         // requires the symbols to have GOT entires.
         if (requiresGOTAccess(sym))

lld/wasm/Symbols.h

return symbolKind == UndefinedFunctionKind ||
            symbolKind == UndefinedTableKind;
   }
 
   bool isLazy() const { return symbolKind == LazyKind; }
 
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
+  bool isTLS() const;
 
   // Returns true if this symbol exists in a discarded (due to COMDAT) section
   bool isDiscarded() const;
 
   // True if this is an undefined weak symbol. This only works once
   // all input files have been added.
   bool isUndefWeak() const {
     // See comment on lazy symbols for details.

lld/wasm/Symbols.cpp

 bool Symbol::isLocal() const {
   return (flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
 }
 
 bool Symbol::isHidden() const {
   return (flags & WASM_SYMBOL_VISIBILITY_MASK) == WASM_SYMBOL_VISIBILITY_HIDDEN;
 }
 
+bool Symbol::isTLS() const { return flags & WASM_SYMBOL_TLS; }
+
 void Symbol::setHidden(bool isHidden) {
   LLVM_DEBUG(dbgs() << "setHidden: " << name << " -> " << isHidden << "\n");
   flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
   if (isHidden)
     flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   else
     flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }

lld/wasm/Writer.cpp

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 (d->segment && d->segment->isTLS()) {
+      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 {

llvm/include/llvm/BinaryFormat/Wasm.h

 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
 const unsigned WASM_SYMBOL_EXPORTED = 0x20;
 const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;
 const unsigned WASM_SYMBOL_NO_STRIP = 0x80;
+const unsigned WASM_SYMBOL_TLS = 0x100;
 
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {
 #include "WasmRelocs.def"
 };
 
 #undef WASM_RELOC

llvm/include/llvm/MC/MCSymbolWasm.h

public:
 
   bool isNoStrip() const {
     return getFlags() & wasm::WASM_SYMBOL_NO_STRIP;
   }
   void setNoStrip() const {
     modifyFlags(wasm::WASM_SYMBOL_NO_STRIP, wasm::WASM_SYMBOL_NO_STRIP);
   }
 
+  bool isTLS() const { return getFlags() & wasm::WASM_SYMBOL_TLS; }
+  void setTLS() const {
+    modifyFlags(wasm::WASM_SYMBOL_TLS, wasm::WASM_SYMBOL_TLS);
+  }
+
   bool isWeak() const { return IsWeak; }
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
   bool isHidden() const { return IsHidden; }
   void setHidden(bool isHidden) { IsHidden = isHidden; }
 
   bool isComdat() const { return IsComdat; }
   void setComdat(bool isComdat) { IsComdat = isComdat; }

llvm/include/llvm/MC/MCWasmStreamer.h

void reset() override {
     SeenIdent = false;
     MCObjectStreamer::reset();
   }
 
   /// \name MCStreamer Interface
   /// @{
 
   void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+  void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
+                      uint64_t Offset) override;
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitThumbFunc(MCSymbol *Func) override;
   void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
   bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
public:
   void emitIdent(StringRef IdentString) override;
 
   void finishImpl() override;
 
 private:
   void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
+  void fixSymbolsInTLSFixups(const MCExpr *expr);
+
   /// Merge the content of the fragment \p EF into the fragment \p DF.
   void mergeFragment(MCDataFragment *, MCDataFragment *);
 
   bool SeenIdent;
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/MC/MCWasmStreamer.cpp

EF->getFixups()[I].setOffset(EF->getFixups()[I].getOffset() +
                                  DF->getContents().size());
     DF->getFixups().push_back(EF->getFixups()[I]);
   }
   if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
     DF->setHasInstructions(*EF->getSubtargetInfo());
   DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
 }
 
+void MCWasmStreamer::emitLabel(MCSymbol *S, SMLoc Loc) {
+  auto *Symbol = cast<MCSymbolWasm>(S);
+  MCObjectStreamer::emitLabel(Symbol, Loc);
+
+  llvm::dbgs() << "emitLabel\n";
+  const MCSectionWasm &Section =
+      static_cast<const MCSectionWasm &>(*getCurrentSectionOnly());
+  if (Section.getSegmentFlags() & wasm::WASM_SEG_FLAG_TLS) {
+    llvm::dbgs() << "emitLabel TLS: " << *Symbol << "\n";
+    Symbol->setTLS();
+  }
+}
+
+void MCWasmStreamer::emitLabelAtPos(MCSymbol *S, SMLoc Loc, MCFragment *F,
+                                    uint64_t Offset) {
+  auto *Symbol = cast<MCSymbolWasm>(S);
+  MCObjectStreamer::emitLabelAtPos(Symbol, Loc, F, Offset);
+
+  llvm::dbgs() << "emitLabelAtPos\n";
+  const MCSectionWasm &Section =
+      static_cast<const MCSectionWasm &>(*getCurrentSectionOnly());
+  if (Section.getSegmentFlags() & wasm::WASM_SEG_FLAG_TLS) {
+    llvm::dbgs() << "emitLabelAtPos TLS\n";
+    Symbol->setTLS();
+  }
+}
+
 void MCWasmStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
   // Let the target do whatever target specific stuff it needs to do.
   getAssembler().getBackend().handleAssemblerFlag(Flag);
 
   // Do any generic stuff we need to do.
   llvm_unreachable("invalid assembler flag!");
 }
 
bool MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_Global:
     Symbol->setExternal(true);
     break;
 
   case MCSA_ELF_TypeFunction:
     Symbol->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
     break;
 
+  case MCSA_ELF_TypeTLS:
+    Symbol->setTLS();
+    break;
+
   case MCSA_ELF_TypeObject:
   case MCSA_Cold:
     break;
 
   case MCSA_NoDeadStrip:
     Symbol->setNoStrip();
     break;
 

 void MCWasmStreamer::emitIdent(StringRef IdentString) {
   // TODO(sbc): Add the ident section once we support mergable strings
   // sections in the object format
 }
 
 void MCWasmStreamer::emitInstToFragment(const MCInst &Inst,
                                         const MCSubtargetInfo &STI) {
   this->MCObjectStreamer::emitInstToFragment(Inst, STI);
+  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
+
+  for (auto &Fixup : F.getFixups())
+    fixSymbolsInTLSFixups(Fixup.getValue());
 }
 
 void MCWasmStreamer::emitInstToData(const MCInst &Inst,
                                     const MCSubtargetInfo &STI) {
   MCAssembler &Assembler = getAssembler();
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   raw_svector_ostream VecOS(Code);
   Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
 
+  for (auto &Fixup : Fixups)
+    fixSymbolsInTLSFixups(Fixup.getValue());
+
   // Append the encoded instruction to the current data fragment (or create a
   // new such fragment if the current fragment is not a data fragment).
   MCDataFragment *DF = getOrCreateDataFragment();
 
   // Add the fixups and data.
   for (unsigned I = 0, E = Fixups.size(); I != E; ++I) {
     Fixups[I].setOffset(Fixups[I].getOffset() + DF->getContents().size());
     DF->getFixups().push_back(Fixups[I]);
   }
   DF->setHasInstructions(STI);
   DF->getContents().append(Code.begin(), Code.end());
 }
 
 void MCWasmStreamer::finishImpl() {
   emitFrames(nullptr);
 
   this->MCObjectStreamer::finishImpl();
 }
 
-MCStreamer *llvm::createWasmStreamer(MCContext &Context,
-                                     std::unique_ptr<MCAsmBackend> &&MAB,
-                                     std::unique_ptr<MCObjectWriter> &&OW,
-                                     std::unique_ptr<MCCodeEmitter> &&CE,
-                                     bool RelaxAll) {
-  MCWasmStreamer *S =
-      new MCWasmStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
-  if (RelaxAll)
-    S->getAssembler().setRelaxAll(true);
-  return S;
+void MCWasmStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
+  switch (expr->getKind()) {
+  case MCExpr::Target:
+  case MCExpr::Constant:
+    break;
+
+  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) {
+      getAssembler().registerSymbol(symRef.getSymbol());
+      cast<MCSymbolWasm>(symRef.getSymbol()).setTLS();
+    }
+    break;
+  }
+
+  case MCExpr::Unary:
+    fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
+    break;
+  }
 }
 
 void MCWasmStreamer::emitThumbFunc(MCSymbol *Func) {
   llvm_unreachable("Generic Wasm doesn't support this directive");
 }
 
 void MCWasmStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
   llvm_unreachable("Wasm doesn't support this directive");
 }
 
 void MCWasmStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
                                   uint64_t Size, unsigned ByteAlignment,
                                   SMLoc Loc) {
   llvm_unreachable("Wasm doesn't support this directive");
 }
 
 void MCWasmStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                                     uint64_t Size, unsigned ByteAlignment) {
   llvm_unreachable("Wasm doesn't support this directive");
 }
+
+MCStreamer *llvm::createWasmStreamer(MCContext &Context,
+                                     std::unique_ptr<MCAsmBackend> &&MAB,
+                                     std::unique_ptr<MCObjectWriter> &&OW,
+                                     std::unique_ptr<MCCodeEmitter> &&CE,
+                                     bool RelaxAll) {
+  MCWasmStreamer *S =
+      new MCWasmStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
+  if (RelaxAll)
+    S->getAssembler().setRelaxAll(true);
+  return S;
+}

llvm/lib/MC/WasmObjectWriter.cpp

if (WS.isNoStrip()) {
       if (isEmscripten()) {
         Flags |= wasm::WASM_SYMBOL_EXPORTED;
       }
     }
     if (WS.hasImportName())
       Flags |= wasm::WASM_SYMBOL_EXPLICIT_NAME;
     if (WS.hasExportName())
       Flags |= wasm::WASM_SYMBOL_EXPORTED;
+    if (WS.isTLS())
+      Flags |= wasm::WASM_SYMBOL_TLS;
 
     wasm::WasmSymbolInfo Info;
     Info.Name = WS.getName();
     Info.Kind = WS.getType().getValueOr(wasm::WASM_SYMBOL_TYPE_DATA);
     Info.Flags = Flags;
     if (!WS.isData()) {
       assert(WasmIndices.count(&WS) > 0);
       Info.ElementIndex = WasmIndices.find(&WS)->second;

llvm/lib/ObjectYAML/WasmYAML.cpp

#define BCaseMask(M, X)                                                        \
   BCaseMask(BINDING_MASK, BINDING_WEAK);
   BCaseMask(BINDING_MASK, BINDING_LOCAL);
   // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
   BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
   BCaseMask(UNDEFINED, UNDEFINED);
   BCaseMask(EXPORTED, EXPORTED);
   BCaseMask(EXPLICIT_NAME, EXPLICIT_NAME);
   BCaseMask(NO_STRIP, NO_STRIP);
+  BCaseMask(TLS, TLS);
 #undef BCaseMask
 }
 
 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
     IO &IO, WasmYAML::SymbolKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
   ECase(FUNCTION);
   ECase(DATA);

llvm/test/MC/WebAssembly/tls.s

tls_store:
   # CHECK-NEXT: i32.store 0
   global.get __tls_base
   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
+  end_function
+
 .section .tls.foo,"T",@
 # CHECK: .tls.foo,"T",@
 tls1:
   .int32 42
   .size tls1, 4
 
 .section custom_tls,"T",@
 # CHECK: custom_tls,"T",@

 # CHECK-OBJ-NEXT:      - Index:           1
 # CHECK-OBJ-NEXT:        Kind:            GLOBAL
 # CHECK-OBJ-NEXT:        Name:            __tls_base
 # CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED ]
 # CHECK-OBJ-NEXT:        Global:          0
 # CHECK-OBJ-NEXT:      - Index:           2
 # CHECK-OBJ-NEXT:        Kind:            DATA
 # CHECK-OBJ-NEXT:        Name:            tls1
-# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL, TLS ]
 # CHECK-OBJ-NEXT:        Segment:         0
 # CHECK-OBJ-NEXT:        Size:            4
 # CHECK-OBJ-NEXT:      - Index:           3
+# CHECK-OBJ-NEXT:        Kind:            FUNCTION
+# CHECK-OBJ-NEXT:        Name:            tls_get_undefined
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Function:        1
+# CHECK-OBJ-NEXT:      - Index:           4
+# CHECK-OBJ-NEXT:        Kind:            DATA
+# CHECK-OBJ-NEXT:        Name:            tls_undefined
+# CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED, TLS ]
+# CHECK-OBJ-NEXT:      - Index:           5
 # CHECK-OBJ-NEXT:        Kind:            DATA
 # CHECK-OBJ-NEXT:        Name:            tls2
-# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL, TLS ]
 # CHECK-OBJ-NEXT:        Segment:         1
 # CHECK-OBJ-NEXT:        Size:            4
 # CHECK-OBJ-NEXT:    SegmentInfo:
 # CHECK-OBJ-NEXT:      - Index:           0
 # CHECK-OBJ-NEXT:        Name:            .tls.foo
 # CHECK-OBJ-NEXT:        Alignment:       0
 # CHECK-OBJ-NEXT:        Flags:           [ TLS ]
 # CHECK-OBJ-NEXT:      - Index:           1
 # CHECK-OBJ-NEXT:        Name:            custom_tls
 # CHECK-OBJ-NEXT:        Alignment:       0
 # CHECK-OBJ-NEXT:        Flags:           [ TLS ]

llvm/test/MC/WebAssembly/tls64.s

 # CHECK-OBJ-NEXT:      - Index:           1
 # CHECK-OBJ-NEXT:        Kind:            GLOBAL
 # CHECK-OBJ-NEXT:        Name:            __tls_base
 # CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED ]
 # CHECK-OBJ-NEXT:        Global:          0
 # CHECK-OBJ-NEXT:      - Index:           2
 # CHECK-OBJ-NEXT:        Kind:            DATA
 # CHECK-OBJ-NEXT:        Name:            tls1
-# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL, TLS ]
 # CHECK-OBJ-NEXT:        Segment:         0
 # CHECK-OBJ-NEXT:        Size:            4
 # CHECK-OBJ-NEXT:      - Index:           3
 # CHECK-OBJ-NEXT:        Kind:            DATA
 # CHECK-OBJ-NEXT:        Name:            tls2
-# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL, TLS ]
 # CHECK-OBJ-NEXT:        Segment:         1
 # CHECK-OBJ-NEXT:        Size:            4
 # CHECK-OBJ-NEXT:    SegmentInfo:
 # CHECK-OBJ-NEXT:      - Index:           0
 # CHECK-OBJ-NEXT:        Name:            .tls.foo
 # CHECK-OBJ-NEXT:        Alignment:       0
 # CHECK-OBJ-NEXT:        Flags:           [ TLS ]
 # CHECK-OBJ-NEXT:      - Index:           1
 # CHECK-OBJ-NEXT:        Name:            custom_tls
 # CHECK-OBJ-NEXT:        Alignment:       0
 # CHECK-OBJ-NEXT:        Flags:           [ TLS ]