Hi I am using the Macbook air with the latest m1 chip and want to ask if it's possible to cross compile arm to X86. I am running Ubuntu (arm version) on paralles and need to compile some programs to X86 for uni. Is this even possible
It is a hard but doable task.
It depends on what ARM series you are compiling against. On many systems you find a Cortex-A (armv7-a or higher) or ARM11 (armv6) processor running a "mini Linux distribution", this is the case for many POS (Point of Sale) devices. In such a case your target can be one of the following:
- arm-linux-gnueabi
- arm-linux-gnueabihf
Where hf stands for hard-float, meaning that the CPU has a FPU (floating-point unit), all Cortex-A support this, but also depends on the underlying OS. It is also very important to know the version of the glibc on the embedded Linux, because if versions are not the same between compiler and OS, unexpected behavior may occur.
If you are compiling against an ARM processor without MMU (Memory Magament Unit) like the Cortex-R or Cortex-M series, and that by consequence do not support Linux (only microkernels like FreeRTOS) your target would be (also known as bare-metal):
- arm-none-eabi
ARM now distributes the binaries of GCC:
https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads
Previously it was Linaro. Yet they keep GCC 7.x for arm-linu-gnueabi (soft-float) if you need it.
https://releases.linaro.org/components/toolchain/binaries/latest-7/
Linaro also used a build system known as ABE, I have not found much documentation on it, but they used it to configure and build the toolchains distributed by them.
If none of the above works for you, you can still build your own toolchain, for that task I suggest using crosstool-ng: https://crosstool-ng.github.io/
Works best under a Linux OS like Ubuntu (you can still try to use Cygwin to build it on Windows, but it may take more time). Note that you do not need to compile it in the machine you want to run it, meaning that you can compile on Ubuntu the GCC that will run on Windows which will produce programs that run on ARM processor, this is known as Canadian Cross.
I recommend getting a cross-compiler binary. On a Linux distribution it is often already packaged.
However, if you insist on building GCC from source (but beware of dependencies), read about Installing GCC and about Configuring GCC. You should build it outside of the source tree, and you want to pass some particular --target= option. I also recommend something like --program-suffix=_my
(I have no idea what --target is relevant for your particular configuration & board; you need to find out)
Notice that a target is not only a CPU, but also an OS....
linux kernel - Cross compiling for arm from x86 - Stack Overflow
c++ - How to cross compile linux arm to x86 - Stack Overflow
Arch Linux ARM • View topic - How to effectively cross compile from x86 for aarch64
Cross-compilation of MLIR runner libraries to ARM on X86 host
Videos
Install gcc-arm-linux-gnueabi and binutils-arm-linux-gnueabi packages, and then just use arm-linux-gnueabi-gcc instead of gcc for compilation.
You need to be careful on what flavour of linux and binutils you have on your target system. The newest stuff is hardfloat, in this case you would do:
sudo apt-get install gcc-arm-linux-gnueabihf
This brings in the complete cross-compile environment, including binutils.
For using this GCC in the build process write:
CC=arm-linux-gnueabihf-gcc make
64-bit ARM
For 64-bit ARM, the toolchain prefix is aarch64 and usage is:
sudo apt install gcc-aarch64-linux-gnu
aarch64-linux-gnu-gcc -o main.out main.c
You can try it out on this C hello world with QEMU:
main.c
#include <stdio.h>
int main(void) {
puts("hello");
}
and then:
sudo apt install qemu-user
qemu-aarch64 main.out
will output:
hello
Then a few fun things you can do to quickly see that ARM is actually running under the hood:
- GDB step debug it: https://stackoverflow.com/questions/20590155/how-to-single-step-arm-assembly-in-gdb-on-qemu/51310791#51310791
- log the executed ARM instructions with:
qemu-aarch64 -d in_asm,out_asm main.outhttps://stackoverflow.com/questions/13005303/how-does-native-android-code-written-for-arm-run-on-x86/44505097#44505097
Tested in Ubuntu 19.10.
For reliability in serious applications, the disk image provider must also provide a compatible cross compiler
Although you can install a cross compiler with apt conveniently, I must warn you that this is not necessarily reliable unless explicitly supported by the image provider.
If you pick the cross compiler wrongly, the following may happen:
- the dynamic linker is at the wrong path: https://stackoverflow.com/questions/31929092/trying-to-run-a-cross-compiled-executable-on-target-device-fails-with-no-such-f/49993116#49993116
- binary incompatibility with the glibc and any other libraries you link against: https://stackoverflow.com/questions/11107263/how-compatible-are-different-versions-of-glibc
Raspberry PI cross compilation
For RPI in particular, the provided cross compilers are available at: https://github.com/raspberrypi/tools and can be used as explained at: https://raspberrypi.stackexchange.com/questions/64273/installing-raspberry-pi-cross-compiler/83215#83215
git clone https://github.com/raspberrypi/tools
export PATH="$(pwd)/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin:${PATH}"
printf '#include <stdio.h>\nint main() { puts("hello world"); }\n' > hello_world.c
printf '#include <iostream>\nint main() { std::cout << "hello world" << std::endl; }\n' > hello_world.cpp
arm-linux-gnueabihf-gcc -std=c99 -o hello_world_c hello_world.c
arm-linux-gnueabihf-g++ -std=c++11 -o hello_world_cpp hello_world.cpp
Ubuntu cross compilation
If you want to cross compile for Ubuntu arm64, I have never been able to find a clear reference on which cross compilers support which distro version: What are the officially supported cross compilers for Ubuntu server alternative architectures like ARM?
Buildroot
My favorite alternative is to build your own image with Buildroot: https://stackoverflow.com/questions/47557262/how-to-download-the-torvalds-linux-kernel-master-recompile-it-and-boot-it-wi/49349237#49349237
This builds everything from source, including the toolchain and the image, and ensures that everything is compatible.
For that you need to download the ARM compilers first. I suggest you download the compiler from http://www.linaro.org/downloads/ then set the CROSS_COMPILE environment variable to arm-linux-gcc.
set the bin directory path in PATH variable.You can do it by export PATH=$PATH:/path/to/arm/binaries/
Finally compile the code then run in ARM.
use file <filename> whether it is ARM executable or not.
For this you have to do the following steps.
Check you have cross compiler tool chain or not. If you don't have cross compiler tool chain you can download from one of the free ARM cross compiler from net. You can generate your own cross tool chain using Buildroot tool. below you can get the link of Buildroot user manual. http://buildroot.uclibc.org/downloads/manual/manual.html#_using_buildroot
Install cross tool chain in your host PC.
Export the cross tool chain path in your host PC using export command.
Change the make file of the kernel module to set the compiler as CROSS_COMPILE.
Do make.
Move the
.kofile to target and insert it.
On Ubuntu, I would suggest an apt install gcc-x86-64-linux-gnu g++-x86-64-linux-gnu, and then invoking the installed compiler with the x86-64-linux-gnu prefix (for gcc, x86-64-linux-gnu-gcc) to create x86_64 binaries.
Do note that if you target x86_64 you won't be able to run the programs you build natively, but you should be able to package the binaries created for execution on an x86_64 machine.
Install docker-desktop on your mac and run this docker container with the command:
docker container run --platform=linux/amd64 -it -p 6080:6080 -e WIDTH=1920 -e HEIGHT=1080 yoas1/xubuntu-desktop:1.0
Don't forget to create volume to the code directory.
In your browser go to: http://localhost:6080/vnc.html to access the xubuntu desktop
Image on Dockerhub
Hi I am using the Macbook air with the latest m1 chip and want to ask if it's possible to cross compile arm to X86. I am running Ubuntu on paralles and need to compile some programs to X86 for uni. Is this even possible?
Yes, but you don't want a -march machine. You want to build or install a cross compiler with arm as the host architecture and x86 as the target architecture. Typically (assuming a linux os) you might get binaries like x86_64-linux-gnu-gcc for the compiler and x86_64-linux-gnu-g++ for the C++ compiler.
Building Gcc cross compilers is a bit of an art, but the gcc documentation is reasonably good.
No. Its because cross compiler(including clang) can generate binaries from host gcc for a target. There is no compiler which can generate x86 instructions from arm.
A minimal and deterministic procedure for assembling a .S file targeting the T32 instruction set on an Ubuntu 22.04 x86_64 machine could be to install the latest Arm toolchain for arm-none-eabi
if you don't have wget installed, just execute:
sudo apt-get install wget, or download arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi.tar.xz using a WEB browser into you home directory.
Once done:
cd ${HOME}
# Skip the wget command hereafter if arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi.tar.xz was already downloaded into your home directory.
wget "https://developer.arm.com/-/media/Files/downloads/gnu/11.3.rel1/binrel/arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi.tar.xz?rev=95edb5e17b9d43f28c74ce824f9c6f10&hash=176C4D884DBABB657ADC2AC886C8C095409547C4" -O arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi.tar.xz
tar Jxf arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi.tar.xz
You can now assemble your program using the command:
${HOME}/arm-gnu-toolchain-11.3.rel1-x86_64-arm-none-eabi/bin/arm-none-eabi-gcc -c -mthumb foo.S -o foo.o
Please note that a file with the .S extension usually requires to be processed using cpp, the C preprocessor - this is why the command is using arm-none-eabi-gcc, and not arm-none-eabi-as.
run
sudo sh -c 'apt update;apt install binutils-arm-none-eabi;'
then the code can be compiled with
arm-none-eabi-as -mthumb foo.S -o foo.o
example:
$ echo nop > foo.S
$ arm-none-eabi-as -mthumb foo.S -o foo.o
$ echo $?
0
$ file foo.o
foo.o: ELF 32-bit LSB relocatable, ARM, EABI5 version 1 (SYSV), not stripped
- i gathered this from @Nate Eldredge and @old_timer in the comments.