CODEWITHSUNDEEP
rust
Tim Harding
Tim Harding

Reputation: 308

Why are string constant pointers different across crates in Rust?

While working with a HashMap that uses &'static str as the key type, I created a newtype to hash by the pointer rather than by the string contents to reduce overhead.

pub struct StaticStr(&'static str);

impl Hash for StaticStr {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.as_ptr().hash(state)
    }
}

impl PartialEq for StaticStr {
    fn eq(&self, other: &Self) -> bool {
        self.0.as_ptr() == other.0.as_ptr()
    }
}

impl Eq for StaticStr {}

It turns out that this does not work consistently, as in the following example.

pub type MyMap = HashMap<StaticStr, u8>;
pub const A: &str = "A";

pub fn make_map() -> MyMap {
    let mut map = MyMap::new();
    map.insert(StaticStr(A), 1);
    map
}

pub fn get_value(control: &MyMap) -> Option<u8> {
    control.get(&StaticStr(A)).cloned()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    pub fn map_made_in_lib() {
        let map = make_map();
        assert_eq!(get_value(&map), Some(1));
    }

    #[test]
    pub fn map_made_in_test() {
        // Same as make_map()
        let mut map = MyMap::new();
        map.insert(StaticStr(A), 1);

        // This check fails
        assert_eq!(get_value(&map), Some(1));
    }
}

Notice that in the first test, the string constant A is only used directly in the lib crate. In the second test, A is used directly in both the lib crate and the test crate. I discovered that although both tests use the same string constant, the pointers are different depending on which crate refers to the string constant by name. This is demonstrated in the minimal reproduction I created. I would have expected that the string literal be included only once for the crate that defines it, or at least that the linker would be smart enough to deduplicate the string literals. Is there a reason for this behavior?

Upvotes: 3

Views: 202

Answers (1)

hkBst
hkBst

Reputation: 3360

Instead of a const try a static?

A constant item is an optionally named constant value which is not associated with a specific memory location in the program. Constants are essentially inlined wherever they are used, meaning that they are copied directly into the relevant context when used. This includes usage of constants from external crates, and non-Copy types. References to the same constant are not necessarily guaranteed to refer to the same memory address. -- The Rust Reference

A static item is similar to a constant, except that it represents a precise memory location in the program. All references to the static refer to the same memory location. Static items have the static lifetime, which outlives all other lifetimes in a Rust program. Static items do not call drop at the end of the program. -- The Rust Reference

Upvotes: 3

Related Questions