macos cross compiler
1.0.0
Cuidado
Se você estiver usando isso para um caso de uso de produção, você deve espalhar este projeto e construir a imagem
Este projeto permite que você faça um código de compile cruzado no Linux que será executado no macOS. Isso pode ser muito útil para ambientes de IC, onde você deseja criar para o MacOS, mas não deseja enfrentar o problema (e o custo) da configuração de um ambiente MacOS.
Ele suporta:
O suporte ao objetivo C e o C ++ objetivo pode funcionar pronto para uso, mas isso não é testado.
Observação
Este projeto está focado em apoiar versões mais recentes de MacOS e C, C ++, Fortran e Rust. As versões mais antigas que o MacOS 13 (Ventura) não são bem testadas, embora devam funcionar bem.
Bibliotecas e cabeçalhos do sistema MacOS são fornecidos com a imagem do Docker. Isso deve ser adequado para compilar programas de macOS independentes e possivelmente aplicativos nativos do macOS.
Os compiladores cruzados estão disponíveis como uma imagem do Docker. Essa é a maneira mais fácil de distribuir o projeto, pois existem muitas dependências do host. Se você estiver interessado em usá -lo sem o Docker, veja o Osxcross, que forma a base deste projeto.
A imagem do docker está disponível em ghcr.io/shepherdjerred/macos-cross-compiler.
Instale os requisitos abaixo e siga as instruções na seção de uso.
Importante
A imagem do Docker é bastante grande. Inclui vários compiladores e o MacOS SDK.
# 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-darwinO suporte à ferrugem requer um pouco de configuração do projeto.
# .cargo/config.toml
[ build ]
[ target . aarch64-apple-darwin ]
linker = " zig-cc-aarch64-macos "
[ target . x86_64-apple-darwin ]
linker = " zig-cc-x86_64-macos " Uma vez configurado, você pode executar cargo depois de definir a variável 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-darwinA tabela abaixo mostra o nome do executável para cada par de arquitetura/compilador.
Observação
A versão do kernel alvo é darwin24 . Você precisará criar uma nova imagem do Docker se quiser suportar uma versão diferente do kernel.
| AARCH64 | |
|---|---|
| Clang | AARCH64-APPLE-DARWIN24-CLANG |
| Clang ++ | AARCH64-APPLE-DARWIN24-CLANG ++ |
| GCC | AARCH64-APPLE-DARWIN24-GCC |
| g ++ | AARCH64-APPLE-DARWIN24-G ++ |
| GFORTRAN | AARCH64-APPLE-DARWIN24-GFORTRAN |
Os compiladores relevantes estão localizados em /osxcross/bin e /gcc/bin . Ambos os diretórios já estão no PATH do contêiner do Docker.
Este projeto compila o CCTools, que é a versão da Apple do Binutils. Esses programas são utilitários de baixo nível usados pelos compiladores, como o Archiver ar , o carregador ld e o assembler as .
Você provavelmente não precisa executar esses programas diretamente, mas se eles estão localizados em /cctools/bin , e eles também estão no PATH .
Lista de ferramentas completa:
A assinatura de código (mas não reconheciona) deve ser possível com este projeto, mas não é testado. A construção de binários universais também deve ser possível, mas, novamente, isso não é testado.
O RCODesign foi recomendado como uma maneira de assinar e notarizar binários para MacOS.
Este projeto pode construir para o MacOS nas arquiteturas X86_64 e AARCH64, independentemente da arquitetura do host.
| Linux x86_64 | Linux ARM64 | |
|---|---|---|
| MacOS x86_64 | ✅ | ✅ |
| MacOS Aarch64 | ✅ | ✅ |
Observação
Aarch64 é o nome interno da Apple para o ARM64. Eles são usados de forma intercambiável, mas o AARCH64 é mais correto ao se referir ao macOS no ARM64.
Este projeto suporta os seguintes idiomas:
Este projeto suporta as seguintes versões do macOS:
O suporte ao MacOS 15 seqouia não foi extensivamente testado. A imagem do Docker usa o 15.0 SDK por padrão.
Importante
Este projeto é testado nas verisões modernas de MacOS, Clang e GCC. Não foi testado com versões mais antigas desses softwares. Se você precisar do Compatabiltiy com versões mais antigas, consulte o projeto OSXCROSS.
Esta imagem do docker agrupa o Xcode SDK de Joseluisq/Macosx-SDKs. Familiarize -se com os termos de serviço do SDK.
Este repositório é essencialmente um invólucro em torno dos seguintes projetos:
Esses recursos foram úteis ao trabalhar neste projeto:
A porção em zig e ferrugem foi informada por esses recursos:
As imagens do Docker para este repositório são construídas com terreno.
Dica
A construção do GCC é de computação e memória intensa. Você pode ajustar o número de tarefas paralelas passando um argumento de --cores=<number> para qualquer comando, por exemplo, earthly +image --cores=4 . Na minha experiência, você precisará de muita memória se quiser usar todos os seus núcleos. Tive sucesso ao definir esse valor para cerca da metade do número de núcleos que minha CPU. Você deve diminuir o valor se a sua máquina parar.
# 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 +validateEste projeto não teria sido possível sem o projeto OSXCross.
