More robust way to inline thread local var resolution

Author: cataphract

Cargo.lock

@@ -6,56 +6,8 @@ that external readers (e.g. the eBPF profiler) can discover.
 
 Currently Linux-only (x86-64 and aarch64).
 
-## Optimized build (cross-language inlining)
+## TLS
 
-The OTel thread-level context sharing specification requires the use of the
-TLSDESC dialect for the thread-local variable that holds the current context.
-Because (stable) `rustc` doesn't currently provide a way to control the TLS
-dialect, we need to use a small C shim that defines the variable and expose a
-one-line getter. This unfortunately adds one level of indirection (a function
-call) when attaching or detaching a context.
-
-With the right toolchain, it's possible to use Link-Time Optimization (LTO) to
-inline the C wrapper at link time. The requirements are:
-
-- `clang` is available to compile the C shim to LLVM IR (version requirements
-  aren't clear -- tested with clang18 and clang20, but ideally the version
-  should be the same or close to the LLVM version shipped with `rustc`)
-- Either the Rust toolchain ships `lld` or there's a system-wide `lld` install
-  (Rust has been shipping `rust-lld` for a long time now, something like since
-  1.53+, however some musl-based distro like Alpine might have the Rust
-  toolchain without `rust-lld`)
-- `lld` version is at least 18.1 (TLSDESC support)
-
-**If those requirements are met, setting the environment variables
-`CARGO_TARGET_<TARGET>_RUSTFLAGS=-Clinker-plugin-lto -Clinker=clang` and
-`LIBDD_OTEL_THREAD_CTX_INLINE=1` when calling to `cargo` will trigger the
-optimized build where the C shim is inlined.** Here, `<TARGET>` is the target
-triple in screaming snake case.
-
-External environment variables are needed because cross-language LTO requires
-two `rustc` codegen flags (`-Clinker-plugin-lto` and `-Clinker=clang`) that
-cannot be set from a Cargo build script: they must come from `RUSTFLAGS` or
-`.cargo/config.toml`, which can't be entirely automated from Rust only. We
-advise to set those flags via the target-scoped
-`CARGO_TARGET_<TARGET>_RUSTFLAGS` env var so they don't leak to build scripts
-or proc-macros if cross-compiling.
-
-### Build script
-
-The `build-optimized.sh` wrapper script is provided as a convenience and as an
-example.
-
-#### Usage
-
-```bash
-./build-optimized.sh
-```
-
-The script auto-detects the host triple. To cross-compile:
-
-```bash
-./build-optimized.sh --target aarch64-unknown-linux-gnu
-```
-
-Extra arguments are forwarded to `cargo build`.
+The thread-local variable `otel_thread_ctx_v1` and its TLSDESC accessor are
+implemented in pure Rust using `global_asm!` and `asm!` in the
+`libdd-otel-thread-ctx` crate.

libdd-otel-thread-ctx-ffi/README.md

@@ -3,70 +3,7 @@
 extern crate build_common;
 
 use build_common::{find_rust_lld_dir, generate_and_configure_header};
-use std::{env, fmt::Display, path::PathBuf, process::Command};
-
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
-struct LldVersion {
-    major: u32,
-    minor: u32,
-}
-
-impl Display for LldVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}.{}", self.major, self.minor)
-    }
-}
-
-/// Parse the major and minor version from `ld.lld --version` output.
-///
-/// Typical formats:
-///   "LLD 18.1.3 (compatible with GNU linkers)"
-///   "LLD 19.1.0"
-fn system_lld_version() -> Option<LldVersion> {
-    let output = Command::new("ld.lld").arg("--version").output().ok()?;
-    if !output.status.success() {
-        return None;
-    }
-    String::from_utf8_lossy(&output.stdout)
-        .split_whitespace()
-        .find_map(|tok| {
-            let mut splitted = tok.split('.');
-            let major = splitted.next()?.parse::<u32>().ok()?;
-            let minor = splitted.next()?.parse::<u32>().ok()?;
-
-            Some(LldVersion { major, minor })
-        })
-}
-
-/// TLSDESC is supported in LLD from version 18.1.
-const MIN_LLD_VERSION_FOR_TLSDESC: LldVersion = LldVersion {
-    major: 18,
-    minor: 1,
-};
-
-/// Validate that a suitable LLD is available for cross-language LTO.
-///
-/// Returns the rust-lld `gcc-ld/` directory if found; `None` means the system
-/// `ld.lld` will be used instead. Panics with a clear message when the
-/// requirements are not met.
-fn resolve_lld_for_inline(target_arch: &str) -> Option<PathBuf> {
-    if let Some(dir) = find_rust_lld_dir() {
-        return Some(dir);
-    }
-
-    match system_lld_version() {
-        Some(v) if target_arch != "x86_64" || v >= MIN_LLD_VERSION_FOR_TLSDESC => None,
-        Some(v) => panic!(
-            "LIBDD_OTEL_THREAD_CTX_INLINE requires LLD >= {MIN_LLD_VERSION_FOR_TLSDESC} on \
-             x86-64 (for -mllvm -enable-tlsdesc), but system ld.lld is version {v}. \
-             Install a newer LLD or use a Rust toolchain that bundles rust-lld."
-        ),
-        None => panic!(
-            "LIBDD_OTEL_THREAD_CTX_INLINE requires LLD for cross-language LTO, but neither \
-             rust-lld nor a system ld.lld was found."
-        ),
-    }
-}
+use std::env;
 
 fn main() {
     generate_and_configure_header("otel-thread-ctx.h");
@@ -76,11 +13,7 @@ fn main() {
         return;
     }
 
-    println!("cargo:rerun-if-env-changed=LIBDD_OTEL_THREAD_CTX_INLINE");
-
-    let inline_mode = env::var("LIBDD_OTEL_THREAD_CTX_INLINE").is_ok_and(|v| v == "1");
     let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
-    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
 
     // Export the TLSDESC thread-local variable to the dynamic symbol table so external readers
     // (e.g. the eBPF profiler) can discover it. Rust's cdylib linker applies a version script with
@@ -93,32 +26,10 @@ fn main() {
     // Merging multiple version scripts is not supported by GNU ld, so we need lld. We prefer the
     // toolchain's bundled rust-lld (LLD 19+ since Rust 1.84) over the system lld (if it even
     // exists). If rust-lld is not found we fall back to whatever `lld` the system provides.
-
-    // If `LIBDD_OTEL_THREAD_CTX_INLINE` is set to `1`, we try to inline the C shim. See the README
-    // for more details.
-    if inline_mode {
-        let rust_lld_dir = resolve_lld_for_inline(&target_arch);
-
-        // Emit link args for ALL link types (not just cdylib) so that test binaries also link
-        // correctly when RUSTFLAGS sets clang as the linker (in practice we should only build/care
-        // about the shared object file in inline mode).
-        if let Some(dir) = rust_lld_dir {
-            println!("cargo:rustc-link-arg=-B{}", dir.display());
-        }
-        println!("cargo:rustc-link-arg=-fuse-ld=lld");
-
-        // On x86-64, tell the LLVM backend to use TLSDESC during LTO codegen.
-        // On aarch64 TLSDESC is the default and the only model.
-        if target_arch == "x86_64" {
-            println!("cargo:rustc-link-arg=-Wl,-mllvm,-enable-tlsdesc");
-        }
-    } else {
-        // Default mode: only the cdylib needs lld (for the version script).
-        if let Some(gcc_ld_dir) = find_rust_lld_dir() {
-            println!("cargo:rustc-cdylib-link-arg=-B{}", gcc_ld_dir.display());
-        }
-        println!("cargo:rustc-cdylib-link-arg=-fuse-ld=lld");
+    if let Some(gcc_ld_dir) = find_rust_lld_dir() {
+        println!("cargo:rustc-cdylib-link-arg=-B{}", gcc_ld_dir.display());
     }
+    println!("cargo:rustc-cdylib-link-arg=-fuse-ld=lld");
 
     println!(
         "cargo:rustc-cdylib-link-arg=-Wl,--version-script={manifest_dir}/tls-dynamic-list.txt"

libdd-otel-thread-ctx-ffi/build-optimized.sh

@@ -16,6 +16,3 @@ publish = false
 crate-type = ["lib"]
 bench = false
 
-[build-dependencies]
-build_common = { path = "../build-common" }
-cc = "1.1.31"

libdd-otel-thread-ctx-ffi/build.rs

@@ -15,10 +15,10 @@ Linux only for now.
 
 ## TLS
 
-The C shim (`src/tls_shim.c`) is required because `rustc` does not yet support
-the TLSDESC TLS dialect required by the spec to export `otel_thread_ctx_v1`.
-Since the reader and the writer must agree on the TLS dialect/model, we rely on
-the C compiler to emit the right access pattern.
+The TLS symbol `otel_thread_ctx_v1` and its TLSDESC accessor are defined
+directly in Rust using `global_asm!` and `asm!` (both stable since Rust 1.65 /
+1.59). This avoids a C build dependency while guaranteeing the TLSDESC dialect
+on both x86-64 and aarch64 as required by the spec.
 
 ## Usage
 

libdd-otel-thread-ctx/Cargo.toml

@@ -1,17 +1,7 @@
 // Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
-extern crate build_common;
 
 use std::env;
-use std::process::Command;
-
-fn clang_is_available() -> bool {
-    Command::new("clang")
-        .arg("--version")
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false)
-}
 
 fn main() {
     let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
@@ -27,43 +17,4 @@ fn main() {
             target_arch
         )
     }
-
-    println!("cargo:rerun-if-env-changed=LIBDD_OTEL_THREAD_CTX_INLINE");
-    println!("cargo:rerun-if-changed=src/tls_shim.c");
-
-    // The otel-thread-ctx FFI crate has a special flag to inline the C shim inside the final
-    // library. This setup has additional requirements for the build of this crate, which are
-    // enforced below when the flag is set.
-    let inline_mode = env::var_os("LIBDD_OTEL_THREAD_CTX_INLINE").is_some_and(|v| v == "1");
-
-    let mut build = cc::Build::new();
-
-    if inline_mode {
-        assert!(
-            clang_is_available(),
-            "LIBDD_OTEL_THREAD_CTX_INLINE is set but `clang` was not found. \
-             Cross-language LTO requires clang as the C compiler."
-        );
-        build.compiler("clang");
-        build.flag("-flto=thin");
-
-        // Any binary linking this crate in inline mode (including test
-        // binaries) needs lld, because -Clinker-plugin-lto passes LTO plugin
-        // options that only lld understands.
-        if let Some(dir) = build_common::find_rust_lld_dir() {
-            println!("cargo:rustc-link-arg=-B{}", dir.display());
-        }
-        println!("cargo:rustc-link-arg=-fuse-ld=lld");
-
-        // Note: in the inline setup, TLS dialect selection is handled by the linker and is taken
-        // care of by the build script of otel-thread-ctx-ffi
-    } else if target_arch == "x86_64" {
-        // - On aarch64, TLSDESC is already the only dynamic TLS model so no flag is needed.
-        // - On x86-64, we use `-mtls-dialect=gnu2` (supported since GCC 4.4 and Clang 19+) to force
-        //   the use of TLSDESC as mandated by the spec. If it's not supported, this build will
-        //   fail.
-        build.flag("-mtls-dialect=gnu2");
-    }
-
-    build.file("src/tls_shim.c").compile("tls_shim");
 }