macos cross compiler
1.0.0
Prudence
Si vous utilisez ceci pour un cas d'utilisation de production, vous devez débarquer ce projet et construire l'image vous-même
Ce projet vous permet de compiler le code sur Linux qui sera exécuté sur macOS. Cela peut être très utile pour les environnements CI où vous souhaitez construire pour les macOS, mais vous ne voulez pas passer par le problème (et le coût) de la mise en place d'un environnement macOS.
Il prend en charge:
La prise en charge de l'objectif C et l'objectif C ++ peuvent fonctionner prêts à l'emploi, mais cela n'est pas testé.
Note
Ce projet est axé sur la prise en charge de nouvelles versions de macOS et C, C ++, Fortran et Rust. Les versions plus anciennes que MacOS 13 (Ventura) ne sont pas bien testées, bien qu'elles devraient bien fonctionner.
Les bibliothèques et les en-têtes du système macOS sont fournis avec l'image Docker. Cela devrait être adapté pour compiler les programmes macOS autonomes et éventuellement les applications macOS natives.
Les compilateurs croisés sont disponibles sous forme d'image Docker. C'est un moyen le plus simple de distribuer le projet car il y a tellement de dépendances hôtes. Si vous êtes intéressé à l'utiliser sans Docker, vous devriez jeter un œil à Osxcross qui forme la base de ce projet.
L'image Docker est disponible sur ghcr.io/shepherdjerred/macos-cross-compiler.
Installez les exigences ci-dessous, puis suivez les instructions dans la section d'utilisation.
Important
L'image Docker est assez grande. Il comprend plusieurs compilateurs et le SDK macOS.
# Start a Docker container using the Docker image.
# Replace `$PWD/samples` with the path to the source you want to compile.
$ docker run --platform=linux/amd64
-v $PWD /samples:/workspace
--rm
-it
ghcr.io/shepherdjerred/macos-cross-compiler:latest
/bin/bash
# Now that you're inside of the Docker container, you can run the compilers.
# Compile using gcc
# # targeting darwin arm64
$ aarch64-apple-darwin24-gcc hello.c -o hello
$ aarch64-apple-darwin24-g++ hello.cpp -o hello
# # targeting darwin x86_64
$ x86_64-apple-darwin24-gcc hello.c -o hello
$ x86_64-apple-darwin24-g++ hello.cpp -o hello
# Compile using clang
# # for darwin arm64
$ aarch64-apple-darwin24-clang --target=aarch64-apple-darwin24 hello.c -o hello
$ aarch64-apple-darwin24-clang++ --target=aarch64-apple-darwin24 hello.cpp -o hello
# # for darwin x86_64
$ x86_64-apple-darwin24-clang --target=x86_64-apple-darwin24 hello.c -o hello
$ x86_64-apple-darwin24-clang++ --target=x86_64-apple-darwin24 hello.cpp -o hello
# Compile using gfortran
# # for darwin arm64
$ aarch64-apple-darwin24-gfortran hello.f90 -o hello
# # for darwin x86_64
$ x86_64-apple-darwin24-gfortran hello.f90 -o hello
# Compile using Zig
# # C targeting darwin arm64 (change aarch64 -> x86_64 to target amd64)
$ zig cc
-target aarch64-macos
--sysroot=/sdk
-I/sdk/usr/include
-L/sdk/usr/lib
-F/sdk/System/Library/Frameworks
-framework CoreFoundation
-o hello hello.c
# # Rust targeting darwin arm64 (change aarch64 -> x86_64 to target amd64)
$ export CC=zig-cc-aarch64-macos
$ cd rust && cargo build --target aarch64-apple-darwinLa prise en charge de la rouille nécessite un peu de configuration de projet.
# .cargo/config.toml
[ build ]
[ target . aarch64-apple-darwin ]
linker = " zig-cc-aarch64-macos "
[ target . x86_64-apple-darwin ]
linker = " zig-cc-x86_64-macos " Une fois configuré, vous pouvez exécuter cargo après la définition de la variable CC :
export CC= " zig-cc-x86_64-macos "
cargo build --target x86_64-apple-darwin
export CC= " zig-cc-aarch64-macos "
cargo build --target aarch64-apple-darwinLe tableau ci-dessous montre le nom de l'exécutable pour chaque paire d'architecture / compilateur.
Note
La version du noyau cible est darwin24 . Vous devrez créer une nouvelle image Docker si vous souhaitez prendre en charge une version du noyau différente.
| AARCH64 | |
|---|---|
| bruit | AARCH64-Apple-Darwin24-Clang |
| Clang ++ | aarch64-papple-darwin24-clang ++ |
| GCC | AARCH64-APPLE-DARWIN24-GCC |
| G ++ | aarch64-ple-darwin24-g ++ |
| gertran | aarch64-ple-darwin24-gfertran |
Les compilateurs pertinents sont situés sur /osxcross/bin et /gcc/bin . Ces deux répertoires sont déjà sur le PATH dans le conteneur Docker.
Ce projet compile Cctools, qui est la version d'Apple de binutils. Ces programmes sont des services publics de bas niveau qui sont utilisés par les compilateurs, tels que l'archiver ar , le chargeur ld et l'assembleur as .
Vous n'avez probablement pas besoin d'exécuter ces programmes directement, mais si vous le faites, ils sont situés sur /cctools/bin , et ils sont également sur le PATH .
Liste complète des outils:
La signature de code (mais pas le notariation) devrait être possible avec ce projet, mais elle n'est pas testée. La construction de binaires universels devrait également être possible, mais encore une fois, cela n'est pas testé.
Le RCODESIGN a été recommandé comme un moyen de signer et de notoriser des binaires pour macOS.
Ce projet peut construire pour les macOS sur les archives X86_64 et Aarch64, quelle que soit l'architecture hôte.
| Linux x86_64 | Linux arm64 | |
|---|---|---|
| macOS x86_64 | ✅ | ✅ |
| macOS Aarch64 | ✅ | ✅ |
Note
Aarch64 est le nom interne d'Apple pour ARM64. Ils sont utilisés de manière interchangeable, mais AARCH64 est plus correct lorsqu'il fait référence à MacOS sur ARM64.
Ce projet prend en charge les langues suivantes:
Ce projet prend en charge les versions suivantes de macOS:
La prise en charge de MacOS 15 Seqouia n'a pas été très testée. L'image Docker utilise le SDK 15.0 par défaut.
Important
Ce projet est testé sur des verisons modernes de MacOS, Clang et GCC. Il n'a pas été testé avec des versions plus anciennes de ces logiciels. Si vous avez besoin de compatabiltiy avec des versions plus anciennes, consultez le projet Osxcross.
Cette image Docker regroupe le SDK Xcode de Joseluisq / MacOSX-SDKS. Veuillez vous familiariser avec les conditions d'utilisation du SDK.
Ce référentiel est essentiellement un emballage autour des projets suivants:
Ces ressources ont été utiles lorsque vous travaillez sur ce projet:
La portion de zig et de rouille a été informée par ces ressources:
Les images Docker pour ce référentiel sont construites avec terre.
Conseil
Le bâtiment GCC est en calcul et une mémoire intense. Vous pouvez ajuster le nombre de tâches parallèles en passant un argument --cores=<number> à n'importe quelle commande, par exemple, earthly +image --cores=4 . D'après mon expérience, vous aurez besoin de beaucoup de mémoire si vous souhaitez utiliser tous vos cœurs. J'ai réussi en définissant cette valeur à environ la moitié autant de cœurs que mon CPU. Vous devez réduire la valeur si votre machine cale.
# Create a Docker image tagged as `shepherdjerred/macos-cross-compiler`
# The first run will take ~20 minutes on an M1 MacBook.
# Subsequent runs are faster.
earthly +image
# Verify that the compilers work correctly
earthly +test
# If you're on macOS, try actually running the binaries
earthly +validateCe projet n'aurait pas été possible sans le projet OSXCross.
