[WebAssembly] Add TLS data segment flag: WASM_SEG_FLAG_TLS

[sbc100]

Summary

Previously the linker was relying solely on the name of the segment
to imply TLS.

[sbc100]

• tests

[dschuff]

lld/test/wasm/tls.s

135

I know this is just an explanatory comment, but should these names match the names above?

[sbc100]

lld/test/wasm/tls.s

135

Good catch. The names don't matter to the test because we are testing that they get merged, but yes that is a typo.

[sbc100]

• feedback

[sbc100]

• rebase

lld/test/wasm/tls.s

 
 .section  .bss.no_tls,"",@
 .globl  no_tls
 .p2align  2
 no_tls:
   .int32  0
   .size no_tls, 4
 
+// Older versions of LLVM did not use the "T" flag so we need to support
+// infering TLS from the name alone.
 .section  .tdata.tls1,"",@
 .globl  tls1
 .p2align  2
 tls1:
   .int32  1
   .size tls1, 4
 
-.section  .tdata.tls2,"",@
+.section  sec_tls1,"T",@
 .globl  tls2
 .p2align  2
 tls2:
   .int32  1
   .size tls2, 4
 
-.section  .tbss.tls3,"",@
+.section  sec_tls2,"T",@
 .globl  tls3
 .p2align  2
 tls3:
   .int32  0
   .size tls3, 4
 
 .section  .custom_section.target_features,"",@
   .int8 2

 #   i32.const 12
 #   memory.init 1, 0
 #   end
 
 # CHECK-NEXT:     - Index:           2
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2381808080004180808080006A0B
 
 # Expected body of tls1_addr:
 #   global.get 1
 #   i32.const 0
 #   i32.add
 #   end
 
 # CHECK-NEXT:     - Index:           3
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2381808080004184808080006A0B

lld/wasm/InputChunks.h

public:
   }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t offset) const;
 
   uint64_t getVA(uint64_t offset = 0) const;
 
-  bool isTLS() {
-    return getName().startswith(".tdata") || getName().startswith(".tbss");
+  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 ||
+           getName().startswith(".tdata") || getName().startswith(".tbss");
   }
 
   const OutputSegment *outputSeg = nullptr;
   uint32_t outputSegmentOffset = 0;
   uint32_t alignment = 0;
   uint32_t flags = 0;
 
 protected:

lld/wasm/Writer.cpp

for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
       default:
         error("Unrecognized feature policy prefix " +
               std::to_string(feature.Prefix));
       }
     }
 
     // Find TLS data segments
     auto isTLS = [](InputSegment *segment) {
-      StringRef name = segment->getName();
-      return segment->live &&
-             (name.startswith(".tdata") || name.startswith(".tbss"));
+      return segment->live && segment->isTLS();
     };
     tlsUsed = tlsUsed ||
               std::any_of(file->segments.begin(), file->segments.end(), isTLS);
   }
 
   if (inferFeatures)
     for (const auto &key : used.keys())
       allowed.insert(std::string(key));
void Writer::assignIndexes() {
 
   for (InputTable *table : symtab->syntheticTables)
     out.tableSec->addTable(table);
 
   out.globalSec->assignIndexes();
   out.tableSec->assignIndexes();
 }
 
-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"))
+static StringRef getOutputDataSegmentName(const InputSegment &seg) {
+  // We always merge .tbss and .tdata into a single TLS segment so all TLS
+  // symbols are be relative to single __tls_base.
+  if (seg.isTLS())
     return ".tdata";
+  StringRef name = seg.getName();
   if (!config->mergeDataSegments)
     return name;
   if (name.startswith(".text."))
     return ".text";
   if (name.startswith(".data."))
     return ".data";
   if (name.startswith(".bss."))
     return ".bss";
OutputSegment *Writer::createOutputSegment(StringRef name) {
   return s;
 }
 
 void Writer::createOutputSegments() {
   for (ObjFile *file : symtab->objectFiles) {
     for (InputSegment *segment : file->segments) {
       if (!segment->live)
         continue;
-      StringRef name = getOutputDataSegmentName(segment->getName());
+      StringRef name = getOutputDataSegmentName(*segment);
       OutputSegment *s = nullptr;
       // When running in relocatable mode we can't merge segments that are part
       // of comdat groups since the ultimate linker needs to be able exclude or
       // include them individually.
       if (config->relocatable && !segment->getComdatName().empty()) {
         s = createOutputSegment(name);
       } else {
         if (segmentMap.count(name) == 0)

llvm/include/llvm/BinaryFormat/Wasm.h

enum WasmSymbolType : unsigned {
   WASM_SYMBOL_TYPE_GLOBAL = 0x2,
   WASM_SYMBOL_TYPE_SECTION = 0x3,
   WASM_SYMBOL_TYPE_EVENT = 0x4,
   WASM_SYMBOL_TYPE_TABLE = 0x5,
 };
 
 enum WasmSegmentFlag : unsigned {
   WASM_SEG_FLAG_STRINGS = 0x1,
+  WASM_SEG_FLAG_TLS = 0x2,
 };
 
 // Kinds of event attributes.
 enum WasmEventAttribute : unsigned {
   WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

report_fatal_error("WebAssembly COMDATs only support "
                        "lowered.");
 
   return C;
 }
 
 static unsigned getWasmSectionFlags(SectionKind K) {
   unsigned Flags = 0;
 
-  // TODO(sbc): Add suport for K.isMergeableConst()
+  if (K.isThreadLocal())
+    Flags |= wasm::WASM_SEG_FLAG_TLS;
 
   if (K.isMergeableCString())
     Flags |= wasm::WASM_SEG_FLAG_STRINGS;
 
+  // TODO(sbc): Add suport for K.isMergeableConst()
+
   return Flags;
 }
 
 MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // We don't support explict section names for functions in the wasm object
   // format.  Each function has to be in its own unique section.
   if (isa<Function>(GO)) {

llvm/lib/MC/MCParser/WasmAsmParser.cpp

uint32_t parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
     for (char C : FlagStr) {
       switch (C) {
       case 'p':
         Passive = true;
         break;
       case 'G':
         Group = true;
         break;
+      case 'T':
+        flags |= wasm::WASM_SEG_FLAG_TLS;
+        break;
       case 'S':
         flags |= wasm::WASM_SEG_FLAG_STRINGS;
         break;
       default:
         return -1U;
       }
     }
     return flags;

llvm/lib/MC/MCSectionWasm.cpp

void MCSectionWasm::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   OS << ",\"";
 
   if (IsPassive)
     OS << 'p';
   if (Group)
     OS << 'G';
   if (SegmentFlags & wasm::WASM_SEG_FLAG_STRINGS)
     OS << 'S';
+  if (SegmentFlags & wasm::WASM_SEG_FLAG_TLS)
+    OS << 'T';
 
   OS << '"';
 
   OS << ',';
 
   // If comment string is '@', e.g. as on ARM - use '%' instead
   if (MAI.getCommentString()[0] == '@')
     OS << '%';

llvm/lib/ObjectYAML/WasmYAML.cpp

#define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(IS_64);
 #undef BCase
 }
 
 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset(
     IO &IO, WasmYAML::SegmentFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_SEG_FLAG_##X)
   BCase(STRINGS);
+  BCase(TLS);
 #undef BCase
 }
 
 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset(
     IO &IO, WasmYAML::SymbolFlags &Value) {
 #define BCaseMask(M, X)                                                        \
   IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
   // BCaseMask(BINDING_MASK, BINDING_GLOBAL);

llvm/test/CodeGen/WebAssembly/target-features-tls.ll

 ; NO-BULK-MEM-NEXT: .bss.foo,"",@
 
 ; +bulk-memory
 ; BULK-MEM-LABEL: .custom_section.target_features,"",@
 ; BULK-MEM-NEXT: .int8 1
 ; BULK-MEM-NEXT: .int8 43
 ; BULK-MEM-NEXT: .int8 11
 ; BULK-MEM-NEXT: .ascii "bulk-memory"
-; BULK-MEM-NEXT: .tbss.foo,"",@
+; BULK-MEM-NEXT: .tbss.foo,"T",@

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

 ; CHECK-NEXT: i32.store 0
 ; CHECK-NEXT: return
   %1 = call i8* @llvm.wasm.tls.base()
   store i8* %1, i8** %output
   ret void
 }
 
 ; CHECK: .type tls,@object
-; TLS-NEXT: .section .tbss.tls,"",@
+; 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
 
 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 @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,"",@
+; 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
 
 declare i32 @llvm.wasm.tls.size.i32()

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.const tls1@TLSREL
   # CHECK-NEXT: i32.add
   # CHECK-NEXT: i32.store 0
   global.get __tls_base
-  i32.const tls@TLSREL
+  i32.const tls1@TLSREL
   i32.add
   i32.store 0
   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_MEMORY_ADDR_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:        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 ]
+# CHECK-OBJ-NEXT:        Name:            tls1
+# CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
+# 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:        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 ]