rand is not seeded, causing duplicated symbol names if two crates use gdext

[0x53A]

I got this in my latest wasm build:

  = note: emcc: warning: you no longer need to pass DISABLE_EXCEPTION_CATCHING or DISABLE_EXCEPTION_THROWING when using Wasm exceptions [-Wemcc]
          emcc: warning: -sSIDE_MODULE + pthreads is experimental [-Wexperimental]
          wasm-ld: error: duplicate symbol: __godot_rust_registrant_1804289383_846930886
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/rustato_lib.rustato_lib.2a01942f4ef8670f-cgu.10.rcgu.o
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/libgdext_coroutines-2531917a701074db.rlib(gdext_coroutines-2531917a701074db.gdext_coroutines.79646587b8d7f0e1-cgu.0.rcgu.o)
          
          wasm-ld: error: duplicate symbol: __godot_rust_registrant_1681692777_1714636915
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/rustato_lib.rustato_lib.2a01942f4ef8670f-cgu.10.rcgu.o
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/libgdext_coroutines-2531917a701074db.rlib(gdext_coroutines-2531917a701074db.gdext_coroutines.79646587b8d7f0e1-cgu.0.rcgu.o)
          
          wasm-ld: error: duplicate symbol: __godot_rust_registrant_1957747793_424238335
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/rustato_lib.rustato_lib.2a01942f4ef8670f-cgu.10.rcgu.o
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/libgdext_coroutines-2531917a701074db.rlib(gdext_coroutines-2531917a701074db.gdext_coroutines.79646587b8d7f0e1-cgu.0.rcgu.o)
          
          wasm-ld: error: duplicate symbol: __godot_rust_registrant_719885386_1649760492
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/rustato_lib.rustato_lib.2a01942f4ef8670f-cgu.10.rcgu.o
          >>> defined in /__w/RustedArmor/RustedArmor/rust/target/wasm32-unknown-emscripten/release/deps/libgdext_coroutines-2531917a701074db.rlib(gdext_coroutines-2531917a701074db.gdext_coroutines.79646587b8d7f0e1-cgu.0.rcgu.o)
          emcc: error: '/emsdk/upstream/bin/wasm-ld @/tmp/emscripten_7at1a7qg.rsp.utf-8' failed (returned 1)

(I am using https://github.com/0x53A/gdext_coroutines/tree/dev)

Looking at where __godot_rust_registrant comes from, I found this:

https://github.com/godot-rust/gdext/blame/551c16496d07430dd762cf26d4f4fdc72bf08c06/godot-macros/src/ffi_macros.rs#L22-L31

    // Create sufficiently unique identifier without entire `uuid` (let alone `rand`) crate dependency.
    let a = unsafe { libc::rand() };
    let b = unsafe { libc::rand() };

    let function_name = format_ident!("__godot_rust_registrant_{a}_{b}");

According to the man pages, rand must be explicitly seeded before use:

       The srand() function sets its argument as the seed for a new
       sequence of pseudo-random integers to be returned by rand().
       These sequences are repeatable by calling srand() with the same
       seed value.

       If no seed value is provided, the rand() function is automatically
       seeded with a value of 1.

So, two crates are using gdext, rand is not seeded and therefore deterministic, they both generate the same constant name.

This can be further confirmed by googling for "1804289383" (the first number of the first conflict, which leads to https://stackoverflow.com/questions/66181627/what-is-default-seed

glibc's PRNG also happens to turn a seed of 1 into a next value of 1804289383.

[0x53A]

With RustedArmor@6f3112a it works. Please don't neccessarily wait for me to open a PR, though, I have to go

[Bromeon]

Would seeding with the hash of the crate name not be sufficient?
It would make life easier for people valuing reproducible builds 🤔

[0x53A]

that's a good point. Technically you can have duplicated crates in your dependency tree but that's more about extremely lowlevel crates, not gdext & co.

So yeah I'd be in favor of doing that.

[0x53A]

Is it guaranteed that there will be one rustc process per crate? Or can the toolchain reuse a running process for multiple crates, "compiler server"?

[0x53A]

counter proposal, why so complicated, why not just "__godot_rust_registrant_{crate_name}_{index}"?

[0x53A]

I did ask Copilot to spit me out a simple custom rng implementation, which is here:

use crate::util::bail;
use crate::ParseResult;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use std::env;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};

static RNG: OnceLock<Arc<Mutex<TrivialRng>>> = OnceLock::new();

struct TrivialRng {
    state: u32,
}

impl TrivialRng {
    fn new(seed: u32) -> Self {
        assert!(seed != 0, "Seed must not be zero");
        Self { state: seed }
    }

    // Helper function to generate a u32 hash from a string (e.g., crate name).
    // Using FNV-1a hash algorithm for simplicity and good distribution.
    fn string_to_u32_seed(s: &str) -> u32 {
        const FNV_PRIME: u32 = 16777619;
        const FNV_OFFSET_BASIS: u32 = 2166136261;

        let mut hash = FNV_OFFSET_BASIS;
        for byte in s.as_bytes() {
            hash ^= *byte as u32;
            hash = hash.wrapping_mul(FNV_PRIME);
        }
        hash
    }

    fn next(&mut self) -> u32 {
        // Linear Congruential Generator (same constants as glibc)
        // Formula: next = (a * current + c) mod m
        // Where m = 2^32 (implicit due to u32 overflow)
        const A: u32 = 1103515245;
        const C: u32 = 12345;
        
        self.state = self.state.wrapping_mul(A).wrapping_add(C);
        self.state
    }

    fn rand() -> u32 {
        let rng = RNG.get_or_init(|| {
            let crate_name = env::var("CARGO_PKG_NAME")
                .expect("CARGO_PKG_NAME env var not found. This macro must be run by Cargo.");
            let seed = Self::string_to_u32_seed(&crate_name);
            Arc::new(Mutex::new(TrivialRng::new(seed)))
        });

        rng.lock().unwrap().next()
    }
}

pub(super) fn wasm_declare_init_fn(input: TokenStream) -> ParseResult<TokenStream> {
    if !input.is_empty() {
        return bail!(input, "macro expects no arguments");
    }

    let a = TrivialRng::rand();
    let b = TrivialRng::rand();

    // Rust presently requires that statics with a custom `#[link_section]` must be a simple
    // list of bytes on the Wasm target (with no extra levels of indirection such as references).
    //
    // As such, instead we export a function with a random name of known prefix to be used by the embedder.
    // This prefix is queried at load time, see godot-macros/src/gdextension.rs.
    let function_name = format_ident!("__godot_rust_registrant_{a}_{b}");

    let code = quote! {
        #[cfg(target_family = "wasm")] // Strictly speaking not necessary, as this macro is only invoked for Wasm.
        #[no_mangle]
        extern "C" fn #function_name() {
            __init();
        }
    };

    Ok(code)
}

alternatively, I would actually prefer the crate name based implementation:

use crate::util::bail;
use crate::ParseResult;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use std::env;

use std::sync::atomic::{AtomicU32, Ordering};

static FUNCTION_COUNTER: AtomicU32 = AtomicU32::new(0);

pub(super) fn wasm_declare_init_fn(input: TokenStream) -> ParseResult<TokenStream> {
    if !input.is_empty() {
        return bail!(input, "macro expects no arguments");
    }

    let crate_name = env::var("CARGO_PKG_NAME")
        .expect("CARGO_PKG_NAME env var not found. This macro must be run by Cargo.")
        .replace('-', "_"); // crate names may contain hyphens, but Rust identifiers must not.

    let index = FUNCTION_COUNTER.fetch_add(1, Ordering::Relaxed);

    // Rust presently requires that statics with a custom `#[link_section]` must be a simple
    // list of bytes on the Wasm target (with no extra levels of indirection such as references).
    //
    // As such, instead we export a function with a known prefix to be used by the embedder.
    // This prefix is queried at load time, see godot-macros/src/gdextension.rs.
    let function_name = format_ident!("__godot_rust_registrant_{}_{}", crate_name, index);

    let code = quote! {
        #[cfg(target_family = "wasm")] // Strictly speaking not necessary, as this macro is only invoked for Wasm.
        #[no_mangle]
        extern "C" fn #function_name() {
            __init();
        }
    };

    Ok(code)
}

[Bromeon]

I'd rather not have AI-generated PRNGs if simply including the crate name solves the issue as well 😀

Great point with the string concatenation of the crate name! I'd say we go with that, if people report problems we can always rethink it, but I wouldn't overengineer this 🙂