Implement new handling of TLS base/symbols (bytecodealliance#2590)

* Implement new handling of TLS base/symbols

This commit is the wasm-tools half of the implementation of
WebAssembly/wasi-libc#857. More information can be found in the writeup
of that issue itself, but the general goal here is adjusting linking
conventions for wasip3 modules, in particular around dynamic libraries,
to ensure that TLS works everywhere.

* Fix warnings on nightly

Author: alexcrichton

.github/workflows/main.yml

@@ -244,7 +244,7 @@ jobs:
         submodules: true
     - uses: ./.github/actions/install-rust
       with:
-        toolchain: nightly
+        toolchain: nightly-2026-08-10
     - run: cargo install cargo-fuzz
     - run: cargo fuzz build --dev -s none
     - run: cargo fuzz build --dev --features wasmtime -s none

Cargo.toml

@@ -51,20 +51,20 @@ unsafe_code = "deny"
 unused_extern_crates = 'warn'
 unstable_features = 'warn'
 unused_import_braces = 'warn'
-unused-lifetimes = 'warn'
-unused-macro-rules = 'warn'
+unused_lifetimes = 'warn'
+unused_macro_rules = 'warn'
 
-# Lints that are part of the `rust-2024-compatibility` group. This group is a
+# Lints that are part of the `rust_2024_compatibility` group. This group is a
 # bit too noisy to enable wholesale but some selective items are ones we want to
-# opt-in to.
+# opt_in to.
 keyword_idents_2024 = 'warn'
-unsafe-attr-outside-unsafe = 'warn'
-deprecated-safe-2024 = 'warn'
-rust-2024-guarded-string-incompatible-syntax = 'warn'
-rust-2024-prelude-collisions = 'warn'
-rust-2024-incompatible-pat = 'warn'
-missing-unsafe-on-extern = 'warn'
-unsafe-op-in-unsafe-fn = 'warn'
+unsafe_attr_outside_unsafe = 'warn'
+deprecated_safe_2024 = 'warn'
+rust_2024_guarded_string_incompatible_syntax = 'warn'
+rust_2024_prelude_collisions = 'warn'
+rust_2024_incompatible_pat = 'warn'
+missing_unsafe_on_extern = 'warn'
+unsafe_op_in_unsafe_fn = 'warn'
 
 unexpected_cfgs = { level = 'warn', check-cfg = ['cfg(fuzzing)', 'cfg(debug_check_try_op)'] }
 

crates/fuzz-stats/src/bin/failed-instantiations.rs

@@ -42,7 +42,7 @@ impl State {
             engine: Engine::default(),
             print: true,
             total: AtomicUsize::new(0),
-            remaining: AtomicIsize::new(isize::max_value()),
+            remaining: AtomicIsize::new(isize::MAX),
             instantiate_trap: AtomicUsize::new(0),
             instantiate_oom: AtomicUsize::new(0),
         }

crates/wasm-encoder/src/lib.rs

@@ -129,7 +129,7 @@ impl Encode for str {
 
 impl Encode for usize {
     fn encode(&self, sink: &mut Vec<u8>) {
-        assert!(*self <= u32::max_value() as usize);
+        assert!(*self <= u32::MAX as usize);
         (*self as u32).encode(sink)
     }
 }

crates/wasm-smith/src/core.rs

@@ -1796,7 +1796,7 @@ impl Module {
             ExportKind::Table => EntityType::Table(self.tables[index as usize]),
             ExportKind::Func => {
                 let (_idx, ty) = &self.funcs[index as usize];
-                EntityType::Func(u32::max_value(), ty.clone())
+                EntityType::Func(u32::MAX, ty.clone())
             }
             ExportKind::Tag => EntityType::Tag(self.tags[index as usize].clone()),
         }

crates/wasm-wave/tests/nan.rs

@@ -19,7 +19,7 @@ fn nan() {
         0xffffffff,
         0x7fff0f0f,
         0x8f800000,
-        f32::NAN.to_bits(),
+        <f32>::NAN.to_bits(),
     ] {
         let val = f32::from_bits(bits);
         let expected = if val.is_nan() { 0x7fc00000 } else { bits };
@@ -38,7 +38,7 @@ fn nan() {
         0xffffffffffffffff,
         0x7fff0f0f0f0f0f0f,
         0x8ff0000000000000,
-        f64::NAN.to_bits(),
+        <f64>::NAN.to_bits(),
     ] {
         let val = f64::from_bits(bits);
         let expected = if val.is_nan() {

crates/wast/src/encode.rs

@@ -38,7 +38,7 @@ impl Encode for str {
 
 impl Encode for usize {
     fn encode(&self, e: &mut Vec<u8>) {
-        assert!(*self <= u32::max_value() as usize);
+        assert!(*self <= u32::MAX as usize);
         (*self as u32).encode(e)
     }
 }

crates/wast/src/parser.rs

@@ -70,7 +70,6 @@ use std::borrow::Cow;
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::fmt;
-use std::usize;
 
 /// The maximum recursive depth of parens to parse.
 ///

crates/wit-component/src/encoding.rs

@@ -422,8 +422,21 @@ pub struct EncodingState<'a> {
     /// Maps from original export name to task initialization wrapper function index.
     /// Used to wrap exports with __wasm_init_(async_)task calls.
     export_task_initialization_wrappers: HashMap<String, u32>,
+
+    /// The index of the instance of the synthesized module which stores the TLS
+    /// base pointer in a `global`.
+    ///
+    /// This is only used, and only created, when a module imports
+    /// `__wasm_{get,set}_tls_base` but the program doesn't use cooperative
+    /// threading. See `materialize_tls_base_import`.
+    tls_base_instance_index: Option<(u32, ValType)>,
 }
 
+/// Name of the export of the synthesized TLS-base module which reads the base.
+const TLS_BASE_GET: &str = "get";
+/// Name of the export of the synthesized TLS-base module which writes the base.
+const TLS_BASE_SET: &str = "set";
+
 impl<'a> EncodingState<'a> {
     fn encode_core_modules(&mut self) {
         assert!(self.module_index.is_none());
@@ -1991,6 +2004,14 @@ impl<'a> EncodingState<'a> {
                 let index = self.component.context_set((*ty).try_into()?, *slot);
                 Ok((ExportKind::Func, index))
             }
+            Import::TlsBaseGet { ty } => Ok((
+                ExportKind::Func,
+                self.materialize_tls_base_import(false, (*ty).try_into()?),
+            )),
+            Import::TlsBaseSet { ty } => Ok((
+                ExportKind::Func,
+                self.materialize_tls_base_import(true, (*ty).try_into()?),
+            )),
             Import::ExportedTaskCancel => {
                 let index = self.component.task_cancel();
                 Ok((ExportKind::Func, index))
@@ -2037,6 +2058,93 @@ impl<'a> EncodingState<'a> {
         }
     }
 
+    /// Helper to satisfy `__wasm_{get,set}_tls_base` imports.
+    ///
+    /// For more information on this see WebAssembly/wasi-libc#857
+    fn materialize_tls_base_import(&mut self, set: bool, ty: ValType) -> u32 {
+        if self.info.uses_cooperative_threading() {
+            return if set {
+                self.component.context_set(ty, 1)
+            } else {
+                self.component.context_get(ty, 1)
+            };
+        }
+
+        let instance = match self.tls_base_instance_index {
+            Some((index, prev_ty)) => {
+                assert_eq!(prev_ty, ty, "conflicting TLS base pointer types");
+                index
+            }
+            None => {
+                let index = self.encode_tls_base_module(ty);
+                self.tls_base_instance_index = Some((index, ty));
+                index
+            }
+        };
+        let name = if set { TLS_BASE_SET } else { TLS_BASE_GET };
+        self.core_alias_export(
+            Some(&format!("tls-base-{name}")),
+            instance,
+            name,
+            ExportKind::Func,
+        )
+    }
+
+    /// Synthesizes and instantiates a module which stores the TLS base pointer
+    /// in a mutable `global`, exporting accessors for it.
+    fn encode_tls_base_module(&mut self, ty: ValType) -> u32 {
+        let mut types = TypeSection::new();
+        types.ty().function([], [ty]);
+        types.ty().function([ty], []);
+
+        let mut globals = GlobalSection::new();
+        globals.global(
+            wasm_encoder::GlobalType {
+                val_type: ty,
+                mutable: true,
+                shared: false,
+            },
+            &match ty {
+                ValType::I64 => ConstExpr::i64_const(0),
+                ValType::I32 => ConstExpr::i32_const(0),
+                _ => unreachable!(),
+            },
+        );
+
+        let mut functions = FunctionSection::new();
+        let mut code = CodeSection::new();
+
+        functions.function(0);
+        let mut get = wasm_encoder::Function::new([]);
+        get.instruction(&Instruction::GlobalGet(0));
+        get.instruction(&Instruction::End);
+        code.function(&get);
+
+        functions.function(1);
+        let mut set = wasm_encoder::Function::new([]);
+        set.instruction(&Instruction::LocalGet(0));
+        set.instruction(&Instruction::GlobalSet(0));
+        set.instruction(&Instruction::End);
+        code.function(&set);
+
+        let mut exports = ExportSection::new();
+        exports.export(TLS_BASE_GET, ExportKind::Func, 0);
+        exports.export(TLS_BASE_SET, ExportKind::Func, 1);
+
+        let mut module = Module::new();
+        module.section(&types);
+        module.section(&functions);
+        module.section(&globals);
+        module.section(&exports);
+        module.section(&code);
+
+        let module_index = self
+            .component
+            .core_module(Some("wit-component:tls-base"), &module);
+        self.component
+            .core_instantiate(Some("wit-component:tls-base"), module_index, [])
+    }
+
     /// Helper for `materialize_import` above for materializing functions that
     /// are part of the "shim module" generated.
     fn materialize_shim_import(&mut self, shims: &Shims<'_>, kind: &ShimKind) -> (ExportKind, u32) {
@@ -2686,6 +2794,8 @@ impl<'a> Shims<'a> {
                 | Import::WaitableJoin
                 | Import::ContextGet { .. }
                 | Import::ContextSet { .. }
+                | Import::TlsBaseGet { .. }
+                | Import::TlsBaseSet { .. }
                 | Import::ThreadIndex
                 | Import::ThreadResumeLater
                 | Import::ThreadSuspend { .. }
@@ -3411,6 +3521,7 @@ impl ComponentEncoder {
             aliased_core_items: Default::default(),
             info: &world,
             export_task_initialization_wrappers: HashMap::new(),
+            tls_base_instance_index: None,
         };
         state.encode_imports(&self.import_name_map)?;
         state.encode_core_modules();

crates/wit-component/src/encoding/world.rs

@@ -85,6 +85,21 @@ impl<'a> ComponentWorld<'a> {
         Ok(ret)
     }
 
+    /// Returns whether any module in this component may spawn a thread, and
+    /// thus whether the program is using cooperative threading.
+    ///
+    /// This is a heuristic which should go away once component-model-threading
+    /// has been stable for awhile and the return value of this function should
+    /// be const-propagated as `true`.
+    pub fn uses_cooperative_threading(&self) -> bool {
+        let uses = |info: &ValidatedModule| {
+            info.imports
+                .imports()
+                .any(|(_, _, import)| matches!(import, Import::ThreadNewIndirect))
+        };
+        uses(&self.info) || self.adapters.values().any(|a| uses(&a.info))
+    }
+
     /// Process adapters which are required here. Iterate over all
     /// adapters and figure out what functions are required from the
     /// adapter itself, either because the functions are imported by the
@@ -432,6 +447,8 @@ impl<'a> ComponentWorld<'a> {
                 | Import::Item(_)
                 | Import::ContextGet { .. }
                 | Import::ContextSet { .. }
+                | Import::TlsBaseGet { .. }
+                | Import::TlsBaseSet { .. }
                 | Import::BackpressureInc
                 | Import::BackpressureDec
                 | Import::WaitableSetNew