How can I build a bare metal rust program with buck2?

[theoparis]

I'm trying to pass linker_flags to rust_binary with -Tsome/linker/script.ld. Attempting to use rustc_target_triple = "aarch64-unknown-none", with system_rust_toolchain seems to give

  = note: clang++: error: unknown argument: '-flavor'
          clang++: error: unknown argument: '--fix-cortex-a53-843419'
          clang++: error: unknown argument: '--as-needed'
          clang++: error: unknown argument: '--eh-frame-hdr'
          clang++: error: unknown argument: '--gc-sections'
          clang++: error: no such file or directory: 'gnu'
error: aborting due to 1 previous error

I can't seem to set it to use ld.lld directly because that causes

note: ld.lld: error: unknown argument '-fuse-ld=lld'
          ld.lld: error: unknown argument '-flavor'
          ld.lld: error: cannot open gnu: No such file or directory

I also had to add

    rustc_flags = [
        "-Cpanic=abort",
    ],

[cormacrelf]

This is basically because rustc is a full-on compiler driver like Clang is, that also calls the linker, but has a lot of hardcoded linker flags. The exact same thing happens with the target wasm32-unknown-unknown. In that configuration rustc only knows how to call one linker, that being its bundled build of LLD, rust-lld. And when it does, it tells LLD which linker its command line should emulate, using -flavor. Setting the linker using rustc command line flags cannot change this -- all the flags are basically hardcoded for these targets, as nobody has bothered to make it work any other way. You can't even tell it to use a wasm-ld binary, which is exactly what rust-lld -flavor wasm is, because wasm-ld doesn't accept the -flavor arg. The definitive answer to "what flags will rustc attach for a given bare metal target?" is to set your linker to a shell script that echoes the arguments and exits with failure. Or read the rustc source code.

So to make rustc happy, you need to change the linker. With Buck, the linker is set on the cxx toolchain.. You can either have the cxx toolchain's linker be plain LLD (or whatever else rustc wants you to use), or a shell script that rewrites args. In your case plain LLD is probably the go. This is different from ld.lld; ld.lld is equivalent to lld -flavor gnu. You need really plain LLD. There is a copy of LLD in all rust distributions, in some libexec folder, called rust-lld. The problem now is to tell the CXX toolchain about it.

There isn't a way to configure the system_cxx_toolchain to do this, but if you copy and paste the definition of that rule, or use one of the newer cxx toolchain with overrides etc etc things that Meta has added in the last few months, then you can configure a custom linker. I don't know how to use these but there are toolchain rules in the prelude for this kind of thing. Read the bzl files I guess.

Please note that you will need to configure the linker using a select() so that you can use clang++ as the linker most of the time, and raw LLD only in configurations where it is needed. That will look something like this:

my_custom_cxx_toolchain_rule(
    name = "cxx",
    linker = select({
        "config//os:none": select({
            "config//cpu:arm64": "/path/to/rust-lld",
        }),
        "DEFAULT": "clang++",
    }),
)

This way Buck will e.g. link proc-macros for your dev machine using clang++, and then link final binaries for this target using rust-lld.

[cormacrelf]

It is probably a bit annoying if you are also trying to link C/C++ binaries with Buck. In that case you want C binaries to be linked using clang++ and probably a couple of -Wl flags, but you also want Buck's rust rules to see bare LLD.

The only real solution to this, I think I concluded last time I dealt with it, is changing Rustc to let us say "we have got this, our linker code is better than yours, please turn off everything you think you know about linking and just pass a list of object files". Most of the time people just add another layer of shell scripts wrapping other linkers.