[WebAssembly] Compute and export TLS block alignment

[quantum]

Summary

Add immutable WASM global __tls_align which stores the alignment
requirements of the TLS segment.

Add __builtin_wasm_tls_align() intrinsic to get this alignment in Clang.

The expected usage has now changed to:

__wasm_init_tls(memalign(__builtin_wasm_tls_align(),
                         __builtin_wasm_tls_size()));

[tlively]

Nice

[sbc100]

lld/trunk/wasm/Symbols.h

438

__tls_align

439

Is this stored as power of 2?

cfe/trunk/include/clang/Basic/BuiltinsWebAssembly.def

 BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n")
 
 // Bulk memory builtins
 TARGET_BUILTIN(__builtin_wasm_memory_init, "vIUiIUiv*UiUi", "", "bulk-memory")
 TARGET_BUILTIN(__builtin_wasm_data_drop, "vIUi", "", "bulk-memory")
 
 // Thread-local storage
 TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory")
+TARGET_BUILTIN(__builtin_wasm_tls_align, "z", "nc", "bulk-memory")
 TARGET_BUILTIN(__builtin_wasm_tls_base, "v*", "nU", "bulk-memory")
 
 // Floating point min/max
 BUILTIN(__builtin_wasm_min_f32, "fff", "nc")
 BUILTIN(__builtin_wasm_max_f32, "fff", "nc")
 BUILTIN(__builtin_wasm_min_f64, "ddd", "nc")
 BUILTIN(__builtin_wasm_max_f64, "ddd", "nc")
 

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

case WebAssembly::BI__builtin_wasm_data_drop: {
     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_data_drop);
     return Builder.CreateCall(Callee, {Arg});
   }
   case WebAssembly::BI__builtin_wasm_tls_size: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_size, ResultType);
     return Builder.CreateCall(Callee);
   }
+  case WebAssembly::BI__builtin_wasm_tls_align: {
+    llvm::Type *ResultType = ConvertType(E->getType());
+    Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_align, ResultType);
+    return Builder.CreateCall(Callee);
+  }
   case WebAssembly::BI__builtin_wasm_tls_base: {
     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_base);
     return Builder.CreateCall(Callee);
   }
   case WebAssembly::BI__builtin_wasm_throw: {
     Value *Tag = EmitScalarExpr(E->getArg(0));
     Value *Obj = EmitScalarExpr(E->getArg(1));
     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_throw);

cfe/trunk/test/CodeGen/builtins-wasm.c

 }
 
 __SIZE_TYPE__ tls_size() {
   return __builtin_wasm_tls_size();
   // WEBASSEMBLY32: call i32 @llvm.wasm.tls.size.i32()
   // WEBASSEMBLY64: call i64 @llvm.wasm.tls.size.i64()
 }
 
+__SIZE_TYPE__ tls_align() {
+  return __builtin_wasm_tls_align();
+  // WEBASSEMBLY32: call i32 @llvm.wasm.tls.align.i32()
+  // WEBASSEMBLY64: call i64 @llvm.wasm.tls.align.i64()
+}
+
 void *tls_base() {
   return __builtin_wasm_tls_base();
   // WEBASSEMBLY: call i8* @llvm.wasm.tls.base()
 }
 
 void throw(void *obj) {
   return __builtin_wasm_throw(0, obj);
   // WEBASSEMBLY32: call void @llvm.wasm.throw(i32 0, i8* %{{.*}})

lld/trunk/test/wasm/tls-align.ll

+; RUN: llc -mattr=+bulk-memory -filetype=obj %s -o %t.o
+
+target triple = "wasm32-unknown-unknown"
+
+@no_tls = global i32 0, align 4
+@tls1 = thread_local(localexec) global i32 1, align 4
+@tls2 = thread_local(localexec) global i32 1, align 16
+
+define i32* @tls1_addr() {
+  ret i32* @tls1
+}
+
+define i32* @tls2_addr() {
+  ret i32* @tls2
+}
+
+; RUN: wasm-ld -no-gc-sections --shared-memory --max-memory=131072 --no-entry -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; CHECK:      - Type:            GLOBAL
+; CHECK-NEXT:   Globals:
+; CHECK-NEXT:     - Index:           0
+; CHECK-NEXT:       Type:            I32
+; CHECK-NEXT:       Mutable:         true
+; CHECK-NEXT:       InitExpr:
+; CHECK-NEXT:         Opcode:          I32_CONST
+; CHECK-NEXT:         Value:           66608
+
+; __tls_base
+; CHECK-NEXT:     - Index:           1
+; CHECK-NEXT:       Type:            I32
+; CHECK-NEXT:       Mutable:         true
+; CHECK-NEXT:       InitExpr:
+; CHECK-NEXT:         Opcode:          I32_CONST
+; CHECK-NEXT:         Value:           0
+
+; __tls_size
+; CHECK-NEXT:     - Index:           2
+; CHECK-NEXT:       Type:            I32
+; CHECK-NEXT:       Mutable:         false
+; CHECK-NEXT:       InitExpr:
+; CHECK-NEXT:         Opcode:          I32_CONST
+; CHECK-NEXT:         Value:           20
+
+; __tls_align
+; CHECK-NEXT:     - Index:           3
+; CHECK-NEXT:       Type:            I32
+; CHECK-NEXT:       Mutable:         false
+; CHECK-NEXT:       InitExpr:
+; CHECK-NEXT:         Opcode:          I32_CONST
+; CHECK-NEXT:         Value:           16

lld/trunk/test/wasm/tls.ll

 ; RUN: llc -mattr=+bulk-memory -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown"
 
 @no_tls = global i32 0, align 4
 @tls1 = thread_local(localexec) global i32 1, align 4
 @tls2 = thread_local(localexec) global i32 1, align 4
 
 define i32* @tls1_addr() {
   ret i32* @tls1
 }
 
 define i32* @tls2_addr() {
   ret i32* @tls2
 }
 
+define i32 @tls_align() {
+  %1 = call i32 @llvm.wasm.tls.align.i32()
+  ret i32 %1
+}
+
+declare i32 @llvm.wasm.tls.align.i32()
+
 ; RUN: wasm-ld -no-gc-sections --shared-memory --max-memory=131072 --no-entry -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; RUN: wasm-ld -no-gc-sections --shared-memory --max-memory=131072 --no-merge-data-segments --no-entry -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:      - Type:            GLOBAL
 ; CHECK-NEXT:   Globals:
 ; CHECK-NEXT:     - Index:           0
 ; CHECK-NEXT:       Type:            I32
 ; CHECK-NEXT:       Mutable:         true
 ; CHECK-NEXT:       InitExpr:
 ; CHECK-NEXT:         Opcode:          I32_CONST
 ; CHECK-NEXT:         Value:           66576
+
+; __tls_base
 ; CHECK-NEXT:     - Index:           1
 ; CHECK-NEXT:       Type:            I32
 ; CHECK-NEXT:       Mutable:         true
 ; CHECK-NEXT:       InitExpr:
 ; CHECK-NEXT:         Opcode:          I32_CONST
 ; CHECK-NEXT:         Value:           0
+
+; __tls_size
 ; CHECK-NEXT:     - Index:           2
 ; CHECK-NEXT:       Type:            I32
 ; CHECK-NEXT:       Mutable:         false
 ; CHECK-NEXT:       InitExpr:
 ; CHECK-NEXT:         Opcode:          I32_CONST
 ; CHECK-NEXT:         Value:           8
 
+; __tls_align
+; CHECK-NEXT:     - Index:           3
+; CHECK-NEXT:       Type:            I32
+; CHECK-NEXT:       Mutable:         false
+; CHECK-NEXT:       InitExpr:
+; CHECK-NEXT:         Opcode:          I32_CONST
+; CHECK-NEXT:         Value:           4
+
 
 ; CHECK:      - Type:            CODE
 ; CHECK-NEXT:   Functions:
 ; Skip __wasm_call_ctors and __wasm_init_memory
 ; CHECK:          - Index:           2
 ; CHECK-NEXT:       Locals:          []
 ; CHECK-NEXT:       Body:            20002401200041004108FC0801000B
 

 ; CHECK-NEXT:       Locals:          []
 ; CHECK-NEXT:       Body:            2381808080004184808080006A0B
 
 ; Expected body of tls1_addr:
 ;   global.get 1
 ;   i32.const 4
 ;   i32.add
 ;   end
+
+; CHECK-NEXT:     - Index:           5
+; CHECK-NEXT:       Locals:          []
+; CHECK-NEXT:       Body:            2383808080000B
+
+; Expected body of tls1_addr:
+;   global.get 3
+;   end

lld/trunk/wasm/Driver.cpp

auto *sym =
       cast<UndefinedGlobal>(symtab->addUndefinedGlobal(name, name,
                                                        defaultModule, 0,
                                                        nullptr, type));
   config->allowUndefinedSymbols.insert(sym->getName());
   sym->isUsedInRegularObj = true;
   return sym;
 }
 
+static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable) {
+  llvm::wasm::WasmGlobal wasmGlobal;
+  wasmGlobal.Type = {WASM_TYPE_I32, isMutable};
+  wasmGlobal.InitExpr.Value.Int32 = 0;
+  wasmGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+  wasmGlobal.SymbolName = name;
+  return symtab->addSyntheticGlobal(name, WASM_SYMBOL_VISIBILITY_HIDDEN,
+                                    make<InputGlobal>(wasmGlobal, nullptr));
+}
+
 // Create ABI-defined synthetic symbols
 static void createSyntheticSymbols() {
   static WasmSignature nullSignature = {{}, {}};
   static WasmSignature i32ArgSignature = {{}, {ValType::I32}};
   static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
   static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
                                                             true};
 
if (config->isPic) {
     // See: https://github.com/WebAssembly/mutable-global
     WasmSym::stackPointer = symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, stackPointer);
     WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
     WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
   }
 
   if (config->sharedMemory && !config->shared) {
-    llvm::wasm::WasmGlobal tlsBaseGlobal;
-    tlsBaseGlobal.Type = {WASM_TYPE_I32, true};
-    tlsBaseGlobal.InitExpr.Value.Int32 = 0;
-    tlsBaseGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-    tlsBaseGlobal.SymbolName = "__tls_base";
-    WasmSym::tlsBase =
-        symtab->addSyntheticGlobal("__tls_base", WASM_SYMBOL_VISIBILITY_HIDDEN,
-                                   make<InputGlobal>(tlsBaseGlobal, nullptr));
-
-    llvm::wasm::WasmGlobal tlsSizeGlobal;
-    tlsSizeGlobal.Type = {WASM_TYPE_I32, false};
-    tlsSizeGlobal.InitExpr.Value.Int32 = 0;
-    tlsSizeGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-    tlsSizeGlobal.SymbolName = "__tls_size";
-    WasmSym::tlsSize =
-        symtab->addSyntheticGlobal("__tls_size", WASM_SYMBOL_VISIBILITY_HIDDEN,
-                                   make<InputGlobal>(tlsSizeGlobal, nullptr));
-
+    WasmSym::tlsBase = createGlobalVariable("__tls_base", true);
+    WasmSym::tlsSize = createGlobalVariable("__tls_size", false);
+    WasmSym::tlsAlign = createGlobalVariable("__tls_align", false);
     WasmSym::initTLS = symtab->addSyntheticFunction(
         "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(i32ArgSignature, "__wasm_init_tls"));
   }
 
   WasmSym::dsoHandle = symtab->addSyntheticDataSymbol(
       "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
 }

lld/trunk/wasm/Symbols.h

struct WasmSym {
   // Global that holds the address of the base of the current thread's
   // TLS block.
   static GlobalSymbol *tlsBase;
 
   // __tls_size
   // Symbol whose value is the size of the TLS block.
   static GlobalSymbol *tlsSize;
 
+  // __tls_size
+  // Symbol whose value is the alignment of the TLS block.
+  static GlobalSymbol *tlsAlign;
+
   // __data_end
   // Symbol marking the end of the data and bss.
   static DefinedData *dataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.

lld/trunk/wasm/Symbols.cpp

 DefinedFunction *WasmSym::initTLS;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 GlobalSymbol *WasmSym::stackPointer;
 GlobalSymbol *WasmSym::tlsBase;
 GlobalSymbol *WasmSym::tlsSize;
+GlobalSymbol *WasmSym::tlsAlign;
 UndefinedGlobal *WasmSym::tableBase;
 UndefinedGlobal *WasmSym::memoryBase;
 
 WasmSymbolType Symbol::getWasmType() const {
   if (isa<FunctionSymbol>(this))
     return WASM_SYMBOL_TYPE_FUNCTION;
   if (isa<DataSymbol>(this))
     return WASM_SYMBOL_TYPE_DATA;

lld/trunk/wasm/Writer.cpp

for (OutputSegment *seg : segments) {
     seg->startVA = memoryPtr;
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", seg->name,
                 memoryPtr, seg->size, seg->alignment));
     memoryPtr += seg->size;
 
     if (WasmSym::tlsSize && seg->name == ".tdata") {
       auto *tlsSize = cast<DefinedGlobal>(WasmSym::tlsSize);
       tlsSize->global->global.InitExpr.Value.Int32 = seg->size;
+
+      auto *tlsAlign = cast<DefinedGlobal>(WasmSym::tlsAlign);
+      tlsAlign->global->global.InitExpr.Value.Int32 = 1U << seg->alignment;
     }
   }
 
   // TODO: Add .bss space here.
   if (WasmSym::dataEnd)
     WasmSym::dataEnd->setVirtualAddress(memoryPtr);
 
   log("mem: static data = " + Twine(memoryPtr - dataStart));

llvm/trunk/include/llvm/IR/IntrinsicsWebAssembly.td

 // Thread-local storage intrinsics
 //===----------------------------------------------------------------------===//
 
 def int_wasm_tls_size :
   Intrinsic<[llvm_anyint_ty],
             [],
             [IntrNoMem, IntrSpeculatable]>;
 
+def int_wasm_tls_align :
+  Intrinsic<[llvm_anyint_ty],
+            [],
+            [IntrNoMem, IntrSpeculatable]>;
+
 def int_wasm_tls_base :
   Intrinsic<[llvm_ptr_ty],
             [],
             [IntrReadMem]>;
 
 } // TargetPrefix = "wasm"

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

case Intrinsic::wasm_tls_size: {
       assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
 
       MachineSDNode *TLSSize = CurDAG->getMachineNode(
           WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
           CurDAG->getTargetExternalSymbol("__tls_size", MVT::i32));
       ReplaceNode(Node, TLSSize);
       return;
     }
+    case Intrinsic::wasm_tls_align: {
+      MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
+      assert(PtrVT == MVT::i32 && "only wasm32 is supported for now");
+
+      MachineSDNode *TLSAlign = CurDAG->getMachineNode(
+          WebAssembly::GLOBAL_GET_I32, DL, PtrVT,
+          CurDAG->getTargetExternalSymbol("__tls_align", MVT::i32));
+      ReplaceNode(Node, TLSAlign);
+      return;
+    }
     }
     break;
   }
   case ISD::INTRINSIC_W_CHAIN: {
     unsigned IntNo = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
     switch (IntNo) {
     case Intrinsic::wasm_tls_base: {
       MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());

llvm/trunk/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
   // Except for certain known symbols, all symbols used by CodeGen are
   // functions. It's OK to hardcode knowledge of specific symbols here; this
   // method is precisely there for fetching the signatures of known
   // Clang-provided symbols.
   if (strcmp(Name, "__stack_pointer") == 0 || strcmp(Name, "__tls_base") == 0 ||
       strcmp(Name, "__memory_base") == 0 || strcmp(Name, "__table_base") == 0 ||
-      strcmp(Name, "__tls_size") == 0) {
+      strcmp(Name, "__tls_size") == 0 || strcmp(Name, "__tls_align") == 0) {
     bool Mutable =
         strcmp(Name, "__stack_pointer") == 0 || strcmp(Name, "__tls_base") == 0;
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     WasmSym->setGlobalType(wasm::WasmGlobalType{
         uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
                                       : wasm::WASM_TYPE_I32),
         Mutable});
     return WasmSym;

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

 ; 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-LABEL: tls_align:
+; CHECK-NEXT: .functype tls_align () -> (i32)
+define i32 @tls_align() {
+; CHECK-NEXT: global.get __tls_align
+; CHECK-NEXT: return
+  %1 = call i32 @llvm.wasm.tls.align.i32()
+  ret i32 %1
+}
+
 ; CHECK-LABEL: tls_base:
 ; CHECK-NEXT: .functype tls_base () -> (i32)
 define i8* @tls_base() {
 ; CHECK-NEXT: global.get __tls_base
 ; CHECK-NEXT: return
   %1 = call i8* @llvm.wasm.tls.base()
   ret i8* %1
 }

 ; TLS-NEXT: .section .tbss.tls,"",@
 ; 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()