Easier cross-compilation in scope?

[npmccallum]

We have a use case for mustang. We currently have a client that needs to build an embedded binary (the shim) for all supported server platforms. So for example we might have a configuration like this (using the new artifact dependencies RFC):

• client(aarch64-apple-darwin) depends on shim(x86_64-unknown-linux-musl)

We'd like to be able to build this on macOS. But this, of course, depends on having a musl, as well as a whole linux toolchain to link against. So it isn't really trivially possible now.

But I'm wondering if mustang could help us. For example, if we did:

• client(aarch64-apple-darwin) depends on shim(x86_64-mustang-linux-gnu)

... in theory this would mean that we don't need to link against any system libraries. So as long as Rust can emit x86_64 ELF, it should be able to build this frankenbinary on macOS.

Is this in scope for mustang?

[bjorn3]

The macOS linker doesn't support creating ELF binaries as required to run on Linux. Lld does support it though.

Do you depend on any system libraries other than libc? What does ldd path/to/client show?

Rustc should already be able to easily cross-compile to linux+musl from other platforms when you use lld as linker and don't use any system libraries other than libc. The musl target ships with a full copy of musl to statically link to. Just do rustup target add x86_64-unknown-linux-musl to get the right libstd and then pass --target x86_64-unknown-linux-musl to cargo.

[npmccallum]

Do you depend on any system libraries other than libc? What does ldd path/to/client show?

I'm not sure what you're getting at. We aren't trying to build client for x86_64-unknown-linux-musl. The client binary is just a normal portable application. It should compile for whatever the host target is.

Rustc should already be able to easily cross-compile to linux+musl from other platforms when you use lld as linker and don't use any system libraries other than libc. The musl target ships with a full copy of musl to statically link to. Just do rustup target add x86_64-unknown-linux-musl to get the right libstd and then pass --target x86_64-unknown-linux-musl to cargo.

I already have the target installed. But I get this:

$ cargo new --bin foo
$ cd foo
$ $ cargo build --target=x86_64-unknown-linux-musl
   Compiling foo v0.1.0 (/Users/nathaniel/foo)
error: linking with `cc` failed: exit status: 1
  |
...
  = note: clang: warning: argument unused during compilation: '-static-pie' [-Wunused-command-line-argument]
          ld: unknown option: --as-needed
          clang: error: linker command failed with exit code 1 (use -v to see invocation)

[npmccallum]

$ clang --version
Apple clang version 12.0.5 (clang-1205.0.22.9)
Target: arm64-apple-darwin21.1.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin

[bjorn3]

I'm not sure what you're getting at. We aren't trying to build client for x86_64-unknown-linux-musl. The client binary is just a normal portable application. It should compile for whatever the host target is.

I misunderstood which application you need to cross compile. You can replace "client" with the application you need to cross compile when reading my reply.

I already have the target installed. But I get this:

You need to use lld as linker. Rustc defaults to the system linker, which on macOS is unable to produce linux executables. Adding aomething like the following to a .cargo/config.toml file may work after you installed lld:

[target.x86_64-unknown-linux-musl]
rustflags = ["-fuse-ld=lld"]

Edit: fix linker selection snippet

[sunfishcode]

Assuming there's an answer for the linker part of the question, then yes, in theory this should work. All the code for mustang is on crates.io. It doesn't use any system libraries.