`#[used(compiler)]` and `#[used(linker)]` should work on functions.

[AzureMarker]

Related to #93798
cc @cynecx since you did the implementation.
cc @Meziu and @ian-h-chamberlain

The #[used(compiler)] and #[used(linker)] should work on functions. They weren't explicitly one of the main motivating use cases brought up in #47384, but expanding them to support functions would be very beneficial. For example, in https://github.com/Meziu/pthread-3ds and https://github.com/Meziu/rust-linker-fix-3ds we have to have an empty "init" function just so the exported functions don't get thrown out.

I was expecting these annotations to fix our problem, so I was excited to try them out when I heard they hit nightly. However, the following fails to compile:

#![feature(used_with_arg)]

#[used(compiler)]
#[no_mangle]
pub unsafe extern "C" fn foo() {}

playground link

error: attribute must be applied to a `static` variable
 --> src/lib.rs:3:1
  |
3 | #[used(compiler)]
  | ^^^^^^^^^^^^^^^^^

Interestingly, changing to #[used(linker)] results in an extra message (Edit: fixed by #94377):

error: `used(compiler)` and `used(linker)` can't be used together
 --> src/lib.rs:3:1
  |
3 | #[used(linker)]
  | ^^^^^^^^^^^^^^^
4 | #[no_mangle]
  | ^^^^^^^^^^^^

Does no_mangle imply used(compiler)?

[cynecx]

Does no_mangle imply used(compiler)?

no_mangle should not imply used(compiler). This is a diagnostics issue and an oversight. #94377 will fix that.

I think supporting used on functions should be possible, however someone will have to do the impl work (Unfortunately, I don't have much time to work on this).

[cynecx]

For example, in https://github.com/Meziu/pthread-3ds and https://github.com/Meziu/rust-linker-fix-3ds we have to have an empty "init" function just so the exported functions don't get thrown out.

I might be wrong but I'd imagine something like this should work as a workaround?

#![feature(used_with_arg)]

#[used(compiler)]
pub static _FOO: unsafe extern "C" fn() -> () = foo;

#[no_mangle]
pub unsafe extern "C" fn foo() {}

[nikic]

Agree that supporting #[used] on functions makes sense, and I'd expect that this would mostly "just work" if the restriction to statics is dropped. This applies to #[used] in general though, not really related to the linker/compiler argument.

[AzureMarker]

I might be wrong but I'd imagine something like this should work as a workaround?

Unfortunately that doesn't work because we need the actual functions to be exported. We're polyfilling/implementing well known APIs like pthread. Unless of course that workaround also lets the function symbol stay around, but I assume it only keeps the static's symbol.

[AzureMarker]

I tested the static workaround and it doesn't seem to work (with used(compiler) or used(linker)).

[carbotaniuman]

@AzureMarker Ok I think I figured it out, and I was kinda XYed. Rust will just ignore your crate if you put it in the dependency list, but don't make another reference to it. Even with the used(compiler)/used(linker) I just implemented. You'd need to add an extern crate xxx to whatever code expects the code to be linked. The used is somewhat of a red herring honestly.

[AzureMarker]

Huh, I thought I already tested that. I'll check again just to make sure.

[carbotaniuman]

As bjorn3 said, #[no_mangle] (and also #[link_name]) already do the right thing. Anybody who needs this is likely running into #47384. I'm not sure if there's any use case for exporting a function with a Rust mangled name, so I've closed my PR, but if anyone has any use cases please let me know.

[AzureMarker]

@carbotaniuman I tested this again with extern crate and commenting out my empty init call (to force the crate/module to be "reachable"), and it has linking errors. So just adding an extern crate doesn't solve it.

The issue I'm seeing is #47384 like you said, but this comment suggested to me that the problem would be fixed by #[used(linker)]. The goal is to get the function not stripped out by the linker. It's already in the compiled object (ex. from #[no_mangle]), but the linker doesn't think it's needed at first, and then fails later when it is needed.