How to cross compile for a non-standard platform in Bazel

Question

I wish to build disk images for an esoteric computing platform (CP/M, if you're interested!) with bazel.

Having looked at the documentation for doing cross-compilation with bazel, it looks like it's set up for the case where the project can compile for any platform, and you don't know what platform you're compiling on until you invoke bazel (the platform is passed in on the command line).

I don't have this situation. My code can only build for this platform, and I cannot cross-compile normal code on it. It needs a single very specific toolchain which is not at all gcc-like. This makes, as far as I can tell, most of bazel's toolchain selection logic useless to me. I should be able to do something with Skylark transition rules, but I'm finding the documentation very heavy going.

What I desperately want to do is this:

cc_binary(
  name = "some_host_binary",
  srcs = [...]
)

cc_binary(
  name = "some_target_binary",
  srcs = [...],
  ...some property here to generate a target binary...
)

genrule(
  name = "output_artifact",
  data = [":some_host_binary", ":some_target_binary"]
)

Confusingly, the page on toolchains describes a compiler attribute on cc_binary which looks like it's precisely what I want, but it seems that this doesn't actually exist and is only there as an example?

If, instead, I want to rely on bazel's automatic toolchain resolution, then I think that I need to be able to specify the platform for some_target_binary to force it to pick the right toolchain; but I feel like this would just cause a build failure as the genrule can't tell that I want the two dependencies to be binaries for different architectures.

I'm beginning to feel that I'm grossly overthinking this. Any suggestions, and preferably examples?

Answer 1

Binaries used with genrule.tools will be built for the host platform, and genrule.data will be built for the target platform. I think that is the biggest piece you're looking for. Write it like this:

genrule(
  name = "output_artifact",
  tools = [":some_host_binary"],
  data = [":some_target_binary"],
  outs = ["x"],
  cmd = "$(location :some_host_binary) -in $(location :some_target_binary) -out $(location x)",
)

You can set the target platform on the command line with --platforms flag. Putting this as build --platforms=//my:target in the project-level .bazelrc will set it automatically when building.

If you ever build with a wildcard (like //...), you'll want to avoid including some_host_binary or bazel will try building it for the target platform (in addition to the host platform if that's necessary to build other targets for the target platform). Specifying target_compatible_with on all the host-only targets will automatically skip building them for the target platform, incompatible target skipping has details.

If you want to write tests that execute on the build system (for example), you'll also need to specify target_compatible_with for target-only things to skip them. If you never build without --platforms=//my:target, then letting Bazel think it can build target binaries for any platform (the default without a target_compatible_with) is harmless, because it will never do that unless you ask it to.

The Platforms documentation page has more details.

The more general form of what genrule is doing for the host binaries is called a transition. The documentation on user-defined transitions has some details on ways to do fancier things in custom rules.

cc_binary.compiler is for the old pre-platforms C++-only target selection, which is not where you should start for a new project. It's still supported for backwards compatibility, but actively being moved away from. You'd want to change --cpu anyways.