Attempting to create a rustc target for Retro68

[kmeisthax]

So, because I apparently don't have enough spare time projects in my life, and perhaps taking this blog post as a challenge, I decided to try and tell Rust how to use the Retro68 toolchain to build classic Mac OS apps.

So far, I've managed to get it to spit out PPC objects using the following target file:

{
  "arch": "powerpc",
  "data-layout": "E-m:e-p:32:32-i64:64-n32",
  "executables": true,
  "dynamic-linking": false,
  "llvm-target": "powerpc-unknown-unknown",
  "max-atomic-width": 32,
  "os": "macosclassic",
  "vendor": "apple",
  "relro-level": "off",
  "target-endian": "big",
  "target-pointer-width": "32",
  "linker": "powerpc-apple-macos-gcc",
  "linker-flavor": "gcc",
  "linker-is-gnu": true,
  "eh-frame-header": false,
  "requires-lto": false,
  "no-builtins": true,
  "has-elf-tls": false,
  "relocation-model": "static",
  "merge-functions": "disabled"
}

(Ignore everything after eh-frame-header, that is me flipping random switches as a debugging mechanism)

The linker parameter in this case specifically refers to the resulting binary I got after building the Retro68 toolchain under WSL (which I've put in my PATH). I also have a bare-minimum no_std project just to verify that the build system is working (I'll have to write Toolbox bindings later on for this to actually be useful). When I build that bare-minimum project, I get this error out of cargo:

  = note: "powerpc-apple-macos-gcc" "-L" "/home/kmeisthax/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/powerpc-apple-macosclassic/lib" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/app.5clnpp69kca2lb70.rcgu.o" "-o" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/app" "-Wl,--gc-sections" "-no-pie" "-Wl,-znorelro" "-nodefaultlibs" "-L" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps" "-L" "/mnt/i/Code/macos_classic_rust/app/target/debug/deps" "-L" "/home/kmeisthax/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/powerpc-apple-macosclassic/lib" "-Wl,-Bstatic" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/librustc_std_workspace_core-9a238e6ea974e882.rlib" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/libcore-3ebae3b99b1fe435.rlib" "/mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/libcompiler_builtins-e6f766a1b85dbfbb.rlib" "-Wl,-Bdynamic"
  = note: /mnt/i/Code/macos_classic_rust/app/target/powerpc-apple-macosclassic/debug/deps/app.5clnpp69kca2lb70.rcgu.o: file not recognized: file format not recognized
          collect2: error: ld returned 1 exit status

As far as I can tell, the file being complained about is a valid ELF file (I checked with readelf), and contains code for the given architecture... but I've no idea if the linker is even supposed to accept ELF files at this stage. There's this makefile in one of the sample applications that seemed to indicate that I was on the right track (and Grand Star, the Wii Homebrew port of Rust, does something similar).

However, it turns out that said Makefile isn't actually in use, as the rest of the project uses CMake, and I can't seem to find the actual loader configuration in there. Peeking into the actual compiled example programs, they also have PEF and XCOFF files, which are the native executable formats PowerPC Macs want to work with. The way I was assuming this all went together was:

    C source files -> gcc compilation -> gcc linking -> Elf2Mac/PEFTools/etc
                                                               |
                                                               V
                                     Resource source files -> Rez -> APPL

and that with some clever target file and Cargo configuration I could change that to

    Rust source files -> rustc -> gcc linking -> Elf2Mac/PEFTools/etc
                                                               |
                                                               V
                                     Resource source files -> Rez -> APPL

For the record, using gcc's linker with rustc is a supported configuration, as far as I could tell. However, the Retro86 GCC doesn't seem to like rustc's object files, for one of two possible reasons:

1. I've horribly misconfigured rustc (even though it's a valid ELF file?)
2. Retro86's GCC linker somehow takes objects other than ELF format?

I'm not sure which is which, so I figured I'd bring up my progress here and ask if I'm anywhere close to the right track.

[autc04]

2. Retro86's GCC linker somehow takes objects other than ELF format?

Unfortunately, this is exactly what's going on here. It uses XCOFF instead of ELF.
Getting rustc to interoperate with Retro68's gcc will need some work on LLVM.

When classic MacOS was first ported to PowerPC, Apple used the compiler toolchain from IBM's AIX operating system, which uses the XCOFF object format instead of ELF. Then they added the PEF format on top of that. So .o files and static libraries were always in XCOFF format, and then Apple supplied a tool for converting that to PEF, which actually gets executed by MacOS. Based on the AIX support in GCC and binutils, I've basically duplicated this setup.

And even more unfortunately, the solution is not a simple file format conversion, the ABI is different, as well. In fact, the classic MacOS ABI and the 32-bit AIX ABI are very similar to the 64bit ELF ABI, but quite different from what is usually in 32bit ELF files.

IBM seems to have recently contributed XCOFF support to LLVM. I haven't checked yet, but I assume that's only for 64bit mode so far.

It might also be possible to implement an ELF loader for classic MacOS instead....

[autc04]

At first glance, this looks like this function should be implemented at some point. Querying symbol flags looks like a pretty basic thing, I'm not sure yet how the powerpc-ibm-aix target gets away with not implementing this function.

Can you get rustc to emit assembly to be parsed by Retro68's GNU as, or does it insist on generating .o files directly via llvm? Clang has -integrated-as / -no-integrated-as flags to control this behavior. Maybe they're always going that route on AIX.

[wezm]

Did you make any further progress on this @kmeisthax? Looking at the LLVM code now it seems like getSymbolFlags has been filled in.

The gcc backend for Rust has also come a long way and I'm wondering if it might be possible to build libgccjit from within Retro68 and have rustc_codegen_gcc use it. First issue I need to investigate is how far current gccjit has diverged from the gcc9.1 snapshot on Retro68. I'll try to look into this soon.

[IoIxD]

Rust does support powerpc64-ibm-aix. Could that work, even though it's for 64-bit PPC?

[autc04]

I don't think it will work directly, but it would probably be a lot easier to create a powerpc-ibm-aix target based on that, or a hypothetical elf-based powerpc-apple-macoself. Still probably not an easy hack.

[wezm]

Yes the powerpc-ibm-aix does work. I detailed using it in this post: https://www.wezm.net/v2/posts/2023/rust-classic-mac-os-app/ the code is here: https://github.com/wezm/ferris-weather

[d5364t54ytfr4]

Any updates? There seem to be a lot of Rust GCC compilers on Github now.

[autc04]

I'm only aware of https://rust-gcc.github.io/ .
It would probably already be interesting to experiment with, but of I'm not mistaken it is not yet at a stage in its development where it's ready to be used as a "real" Rust compiler on any platform.

[wezm]

I tried to use rustc_codegen_gcc with Retro68 last year: https://www.wezm.net/v2/posts/2023/rust-on-ppc-classic-mac-os/#rustc-codegen-gcc

I wasn't able to get it to work because rustc_codegen_gcc assumes a very new version of GCC—newer than the 9.x version Retro68 was based on as well as the 12.2 branch.