Fix TLS alignment over 16 in wasm workers (#19570)

Fixes: #19540

Author: sbc100

system/lib/wasm_worker/library_wasm_worker.c

@@ -5,6 +5,7 @@
 #include <emscripten/stack.h>
 #include <emscripten/console.h>
 #include <malloc.h>
+#include <sys/param.h> // For MAX()
 
 #include "emscripten_internal.h"
 
@@ -13,6 +14,8 @@
 #endif
 
 #define ROUND_UP(x, ALIGNMENT) (((x)+ALIGNMENT-1)&-ALIGNMENT)
+#define SBRK_ALIGN (__alignof__(max_align_t))
+#define STACK_ALIGN 16
 
 // Options:
 // #define STACK_OVERFLOW_CHECK 0/1/2 : set to the current stack overflow check mode
@@ -22,42 +25,53 @@ void __wasm_init_tls(void *memory);
 __attribute__((constructor(48)))
 static void emscripten_wasm_worker_main_thread_initialize() {
 	uintptr_t* sbrk_ptr = emscripten_get_sbrk_ptr();
-	assert((*sbrk_ptr & 15) == 0);
-	assert(__builtin_wasm_tls_align() <= 16);
+	assert((*sbrk_ptr % STACK_ALIGN) == 0);
+	if (__builtin_wasm_tls_align() > STACK_ALIGN) {
+		*sbrk_ptr = ROUND_UP(*sbrk_ptr, __builtin_wasm_tls_align());
+	}
 	__wasm_init_tls((void*)*sbrk_ptr);
-	*sbrk_ptr += ROUND_UP(__builtin_wasm_tls_size(), 16);
+	*sbrk_ptr += ROUND_UP(__builtin_wasm_tls_size(), SBRK_ALIGN);
 }
 
 emscripten_wasm_worker_t emscripten_create_wasm_worker(void *stackPlusTLSAddress, size_t stackPlusTLSSize)
 {
 	assert(stackPlusTLSAddress != 0);
-	assert((uintptr_t)stackPlusTLSAddress % 16 == 0);
+	assert((uintptr_t)stackPlusTLSAddress % STACK_ALIGN == 0);
 	assert(stackPlusTLSSize > 0);
-	assert(stackPlusTLSSize % 16 == 0);
+	assert(stackPlusTLSSize % STACK_ALIGN == 0);
 
 	// Guard against a programming oopsie: The target Worker's stack cannot be part of the calling
 	// thread's stack.
 	assert(emscripten_stack_get_base() <= (uintptr_t)stackPlusTLSAddress || emscripten_stack_get_end() >= (uintptr_t)stackPlusTLSAddress + stackPlusTLSSize
 		&& "When creating a Wasm Worker, its stack should be located either in global data or on the heap, not on the calling thread's own stack!");
 
-	// We expect TLS area to need to be at most 16 bytes aligned
-	assert(__builtin_wasm_tls_align() == 0 || 16 % __builtin_wasm_tls_align() == 0);
-
 #ifndef NDEBUG
 	// The Worker's TLS area will be spliced off from the stack region, so the
 	// stack needs to be at least as large as the TLS region.
-	uint32_t tlsSize = ROUND_UP(__builtin_wasm_tls_size(), 16);
+	uint32_t tlsSize = ROUND_UP(__builtin_wasm_tls_size(), __builtin_wasm_tls_align());
 	assert(stackPlusTLSSize > tlsSize);
 #endif
+	// The TLS region lives at the start of the stack region (the lowest address
+	// of the stack).  Since the TLS data alignment may be larger than stack
+	// alignment, we may need to round up the lowest stack address to meet this
+	// requirment.
+	if (__builtin_wasm_tls_align() > STACK_ALIGN) {
+		uintptr_t tlsBase = (uintptr_t)stackPlusTLSAddress;
+		tlsBase = ROUND_UP(tlsBase, __builtin_wasm_tls_align());
+		size_t padding = tlsBase - (uintptr_t)stackPlusTLSAddress;
+		stackPlusTLSAddress = (void*)tlsBase;
+		stackPlusTLSSize -= padding;
+	}
 	return _emscripten_create_wasm_worker(stackPlusTLSAddress, stackPlusTLSSize);
 }
 
 emscripten_wasm_worker_t emscripten_malloc_wasm_worker(size_t stackSize)
 {
 	// Add the TLS size to the provided stackSize so that the allocation
 	// will always be large enough to hold the worker TLS data.
-	stackSize += ROUND_UP(__builtin_wasm_tls_size(), 16);
-	return emscripten_create_wasm_worker(emscripten_builtin_memalign(16, stackSize), stackSize);
+	stackSize += ROUND_UP(__builtin_wasm_tls_size(), STACK_ALIGN);
+	void* stackPlusTLSAddress = emscripten_builtin_memalign(MAX(__builtin_wasm_tls_align(), STACK_ALIGN), stackSize);
+	return emscripten_create_wasm_worker(stackPlusTLSAddress, stackSize);
 }
 
 void emscripten_wasm_worker_sleep(int64_t nsecs)

test/wasm_worker/c11__Thread_local.c

@@ -3,7 +3,7 @@
 #include <assert.h>
 #include <threads.h>
 
-_Thread_local int tls = 1;
+_Thread_local int __attribute__((aligned(64))) tls = 1;
 
 void main_thread_func()
 {
@@ -17,6 +17,7 @@ void main_thread_func()
 void worker_main()
 {
   assert(emscripten_current_thread_is_wasm_worker());
+  assert(((intptr_t)&tls % 64) == 0);
   assert(tls != 42);
   assert(tls != 0);
   assert(tls == 1);
@@ -29,6 +30,7 @@ char stack[1024];
 int main()
 {
   EM_ASM(console.log($0), tls);
+  assert(((intptr_t)&tls % 64) == 0);
   assert(!emscripten_current_thread_is_wasm_worker());
   tls = 42;
   emscripten_wasm_worker_t worker = emscripten_create_wasm_worker(stack, sizeof(stack));