Private #[no_mangle] symbols are exported from a cdylib

[nxtn-staged]

In C++ (MSVC) un-mangling and exporting are controlled via extern "C" and __declspec(dllexport) respectively.

extern "C" {
    namespace to_export {
        __declspec(dllexport) int64_t foo() {
            int64_t bar();
            return bar();
        }
    }
    namespace not_to_export {
        int32_t bar() {
            return 42;
        }
    }
}

    00000000 characteristics
    FFFFFFFF time date stamp
        0.00 version
           1 ordinal base
           1 number of functions
           1 number of names

    ordinal hint RVA      name

          1    0 00001000 foo = foo

In Rust, however, all #[no_mangle] functions are exported from the final cdylib.

pub mod to_export {
    #[no_mangle]
    pub unsafe extern "system" fn foo() -> i64 {
        extern "system" {
            fn bar() -> i64;
        }
        bar()
    }
}
mod not_to_export {
    #[no_mangle]
    extern "system" fn bar() -> i32 {
        42
    }
}

    00000000 characteristics
    FFFFFFFF time date stamp
        0.00 version
           1 ordinal base
           2 number of functions
           2 number of names

    ordinal hint RVA      name

          1    0 00001000 bar = bar
          2    1 00001010 foo = foo

It seems that it is not possible to define an un-mangled and un-exported symbol in Rust.

[SkiFire13]

My guess is that this is related to #95604

[ehuss]

I believe exporting the symbol is intentional as documented here. There is also some more information at #54451. Can you say more about why you would want an unmangled symbol that isn't exported?

[nxtn-staged]

When building #![no_std] crates or linking static libraries, I'm able to fix unresolved external symbol errors with #[no_mangle] symbols, but I do not expect them to appear in the export list.

[ChrisDenton]

Yes, in general there is a difference between making a symbol for the linker to find and exporting it from the final binary. According to the no_mangle reference:

Additionally, the item will be publicly exported from the produced library or object file, similar to the used attribute.

And the used reference says (my bold):

This attribute forces the compiler to keep the variable in the output object file (.o, .rlib, etc. excluding final binaries) even if the variable is not used, or referenced, by any other item in the crate. However, the linker is still free to remove such an item.