Windows cross compile raspberry

Introduction

The one line description explains most of it: I have a Raspberry PI 3B for which I have wanted to build some C/C++ projects. Oddly enough, how to do that from a Windows (10) host to do the cross compilation/ build and also do remote debugging from the host computer is very hard to find. There is lots of info out there but no summary of how to set up things to make an example «Hello world» from a Windows host on a remote Raspberry target. I think the main reason for that is that «C/C++» is not very popular on the Raspberry PI, Python appears to be much more popular.

As I have been able to assemble all the necessary stuff to pull it off, I decided to make the summary myself. My Raspberry PI is running the Raspbian Linux distro so it is probably not a bad example on how to set things up on other development boards running various Linux distros as well

Background

The last couple of years, I have done quite a lot of software cross development using a combination of Eclipse and various gcc/g++ development toolchains on multiple platforms (Bare metal/FreeRTOS/Linux on all sorts of processors: ARMcortex M0+…dual core ARM9, ESP32, Power5,…) so I do have a basic knowledge on how these things work.

Then, I recently went from an Eclipse/ESP32 toolchain combination to a Visual Studio Code/ESP32 toolchain which turned out to be much easier to set up than the Eclipse/ESP32 toolchain one. At the time, I had some ESP32 hardware available so I could test that setup on a Windows(10), Linux and an OSX host machine and it worked on all platforms.

As I now have only a Window 10 host and a RaspBerry PI3B running Raspbian as target, I have tried and managed to get it working from my Windows 10 host but all in all, it should be pretty much platform independent as a lot of the scripting relies on Environment variables which need a slightly different setup on the various platforms but they are common to all the possible platforms, particularly because I use the Mingw32 shell on my Windows machine. 

Using the Code

The ZIP file contains the entire project and consists of very few files. Just put it anywhere you like. Note; once you unzip it, you will find that there is a subdirectory under subdirectory main with the name test and a file test.c in it, the latter two can be ignored as they are only there to test if files in subdirectories would build as well; they do.

To build the project, various tools need to be installed first so here is what needs to installed:

MSYS2

This provides Linux like terminal shell operation. Typically, it installs in directory C:\msys32.

Run Mingw32.exe in that directory to start a shell. The install can be found at https://www.msys2.org/.

arm-linux-gnueabihf toolchain

This is the required toolchain to build C/C++ projects for the raspberry PI. If you want to build for the latest, at the time of writing, «full stretch» edition of Raspbian, you need version 6.0.3 of it. Prebuilt versions of it can be found for Linux, OSX and Windows. The one I used can be found here: http://gnutoolchains.com/raspberry/. I installed it here: C:\msys32\home\RPI\SysGCC.

Once installed, add a script file called RPI-gcc_toolchain.sh in directory C:\msys32\etc\profile.d. The content should look something like this:

export PATH="$PATH:/c/msys32/home/RPI/SysGCC/bin"
export RPI_IP="192.168.0.144"
export RPI_USER="pi"
export RPI_PASSWORD="my_Pi_password"

Of course, the IP address depends on what your local router provides, setting it up to always provide the same IP address for your RPI’s MAC address is definitely a good idea. Once done, the extended PATH data and the extra environment variables will be defined each time you run a mingw32 shell.

Extra Environment Variable

To enable some features used by VSCODE and the makefile in the example project, add environment variable RPIDEV_LOC to your Windows setup and set it to c:/msys32/home/RPI/SysGCC (Using Control Panel-> System->Advanced settings->Environment variables).

Command Line Build Test

Once the above is done, you should be able to test building the project:

• Start a mingw32 shell and navigate to the root directory of the example project.
• Type make to start the cross compile/build and you should see it building files hello_world_main.c and test.c.
• If all is well, the final action is that it will produce the Hello_world_c file which is an ELF file that can run on the Raspberry PI. If that works, we can get going with Visual Studio code.

Installing Visual Studio Code and Extensions

For those who have not got Visual Studio Code yet, you need to install various items:

• Visual Studio code itself, to be found at https://code.visualstudio.com/
• Extension C/C++ by Microsoft to get C/C++ support intellisense, etc.
• Extension Native-Debug to get Cross platform GDB debug support

Using Visual Studio Code to Build and Debug  the Example Code

Once Visual Studio Code and the extensions are installed, you can start by opening the project’s folder. Within that folder, there is .vscode folder, in it are all the necessary JSON configuration files which provide all of the necessary build tools, etc. the build tool list pops up by pressing Ctrl+Shift+B.

The number of build commands is not long, apart from the usual clean, build and fast build tools the most important one is the Transfer… tool which transfers the file to execute to the RPI and starts the GDBSERVER on that unit with it

Actual debugging is started by pressing F5 which will attempt to connect to the RPI’s Recently started GDBSERVER. From that point on, you can do complete debugging; setting breakpoints, investigating variables, etc. just as if the application was running on your host system itself.

So, that’s it. I have done quite a bit of CLI development work in the pre GUI days. Some embedded Linux applications work, some windows development work and tons of other embedded work, with or without some form of OS. I really liked doing this as it ties a lot of stuff neatly together. I just hope this can be of use to someone who needs a solution without having to do all the digging personally.

History

• 22^nd March, 2019: Initial version

Updated Feb 26, 2014 because I’m dumb.

Cross-Compiling shouldn’t be so Hard

I’m creating this post in the off-chance that someone else with a Raspberry Pi who can’t figure out how to cross-compile from Windows will find this useful (or find it at all).

I have been working on and off on a project that will run on Windows, x86 Linux, and ARM Linux.  Problem is, my Linux machines are a little slow.  My x86 Linux is running on an Everex Cloudbook sporting a 1500MHz VIA C7-M processor with 512MB of memory. My ARM Linux is running on a Rapsberry Pi with an ARM11 CPU clocked at 700MHz with 512MB of RAM.  Compiling on my Windows PC is much faster (even if MinGW make won’t run multiple threads at once).  Cross-compiling for x86 Linux isn’t really fruitful, as it’s not my main target.  However, cross-compiling for my Raspberry Pi would be tremendously beneficial (a 30-second compile on my PC takes 5-10 minutes on the RPi).

Find a Working Cross Compiler

Now, most websites online talk about cross-compiling from x86 Linux to ARM Linux.  The RPi creators even have their own cross-compiler available.  There are, however, 2 problems with this.  First, I don’t want to install Linux on my PC, virtual or otherwise.  Second, their GCC cross-compiler is only at version 4.6, and I need C++11 features only available in GCC 4.7+.  My solution was to start with a pre-built GCC 4.7 ARM-Linux cross-compiler and modify things until I got something working on my RPi.  Below are the steps I had to take to finally get it working.

1) Find a x86 Windows to ARM Linux cross-compiler.  This was fairly simple.  A quick google search led me to http://linaro.org.  They have GCC 4.7 and GCC 4.8 ARM Linux cross-compiler binaries for Windows.

2) Find the compiler options I would need to tell Linaro GCC to compile specifically for the Raspberry Pi.  This wasn’t too difficult.  Linaro is pre-built to target ARMv7 instructions and a Cortex-9 CPU, but the following compiler flags take care that issue.  These commands (some of which may not actually be necessary) tell the compiler to target the RPi hardware.

3) Make the compiler link against the RPi static libraries.  This was the hardest part.  Using steps 1 and 2 I was able to get a file to compile for the RPi, but the problem is that Linaro is built against version 2.6.32 of the Linux Kernel, while the Raspbian image I am using is based on 2.6.26.  This meant the generated executable was incompatible.  The solution was to copy the static libraries from my RPi to my Windows PC and make the linker use them.  This was a two-step process.  Note that it took much trial and error, so some of this might be unneeded, but this is the process I got working on my machine.

3a) Copy the libraries:  This involved tar-ing the following directories and using SCP to get them off the RPi (I tar-ed instead of “zipping” because data transfer was faster than trying to get the RPi to compress the data).  Also note that you must tell tar to follow both symlinks and hardlinks, as both methods are in use.  This doubles/triples the size, but you cannot preserve Linux links on a Windows file system.

• /usr/lib/arm-linux-gneuabihf
• /usr/lib/gcc/arm-linux-gneaubihf/4.7/*
• /opt/vc/lib
• /lib/arm-linux-gneaubihf

3b) Remove all libraries that came with Linaro and replace them with the RPi libraries.  This is necessary because Linaro was built against a different version of the Linux Kernel than my version of Raspbian. This was not apparent at first, and the seg-faults I was getting on RPi were of no help.  What was a help was doing “
file <executable> ” from the RPi, which showed that my executable was linked against 2.6.32, while the RPi is only 2.6.26.  I then had to delete the following files from my Linaro Installation:

• <install>\lib\gcc\arm-linux-gnueabihf\4.7.3\*.o|*.a
• <install>\lib\gcc\arm-linux-gnueabihf\4.7.3\arm-linux-gnueabihf
• <install>\arm-linux-gnueabihf\lib
• <install>\arm-linux-gnueabihf\libc\lib
• <install>\arm-linux-gnueabihf\libc\usr\lib

(don’t get me started on how idiotic this layout is. There is actually a “arm-linux-gneaubihf\libc\usr\lib\arm-linux-gneaubihf\usr\lib” directory!?!)

UPDATE:  I did NOT need to copy the files in this step (see step 3c) I then placed the RPi libraries as follows:

• /lib/arm-linux-gneaubihf became <install>\arm-linux-gneaubihf\libc\lib\arm-linux-gneaubihf
• /usr/lib/gcc/arm-linux-gneaubihf/4.7/* were copied to the new <install>\arm-linux-gneaubihf\libc\lib directory
• /usr/lib/arm-linux-gneaubihf became <install>\arm-linux-gneaubihf\libc\usr\lib\arm-linux-gneaubihf
• /opt/vc/lib wasn’t copied, I guess I didn’t need it after all.  It might be needed later.

3c) UPDATE:  Turns out that in my repeated trial and error, I skipped a step that had been working previously.  Instead of copying the RPi libraries to Linaro, I actually just needed to specify the locations by passing the following lines to G++ (D:\rpi-libs is my Windows-local copy of the RPi static libraris):

3d) UPDATE: One final problem is that every .o file must be passed to the linker IF that file does not exist in a location that was specified in the configuration when the linker was built.  As such, I found I needed to copy the following files to my SOURCE directory because they were HARD CODED into the linker.  I could NOT pass these in as object to the compiler, because then they would be listed twice (again, they were HARD CODED), and then the compiler still wouldn’t be able to find the file (I would pass it a /path/to/crt1.o, but it would still look for crt1.o):

Of course, via my make file, I can copy these files before compilation, then delete them afterwards and I’m none the wiser.  Still, it’s a terrible hack that I can only work around by a) copying my files to the predefined paths built into the Linaro GNU linker or b) building my own linker.  I’m lazy, and this solution works.

Finally, Success

Once I had performed the above steps, I was able to build my executable and SCP it to my RPi.  A quick “file <executable>” showed that it had been linked against the proper libraries.  A quicker “chmod +x” and my executable was chugging away (or actually, waiting for a connection, but still, success!!).  Now when I make changes from my Windows PC, I can quickly compile them for my Raspberry Pi.  No more waiting for the little ARM processor to chug-away.

What I Learned

First of all, I learned no one seems to cross-compile FROM Windows.  In fact, searching “windows linux cross compiler”, “linux cross compiler windows binaries”, etc.. all turn up links for people wanting to “Build Windows applications from Linux”.  I still don’t have an x86 cross-compiler, and I refuse to install Cygwin.  How is there not a native Windows executable for an x86 Linux cross-compiler?  Maybe there is and it’s buried under the Linux to Windows links?

Second, GNU Linker is hard-coded to search library paths, and there is no command-line option to fix this.  If I was on Linux, supposedly setting the LIBARY_PATH environment variable would have worked, but that’s a hack.  You should be able to directly tell the linker what you want to do.

Finally, it seems no one is bothered by the fact that the default solution seems to be “make your own cross-compiler”.  Why would thousands of individual developers each need to create their own cross-compiler.  It is nice that the Raspberry Pi creators have a cross-compiler, but it’s stuck at GCC 4.6 and only works under Linux.  It would be nice if they at least had GCC 4.7 and GCC 4.8, then maybe I could have been motivated to install a Linux VM.

My Linaro GCC 4.7 Raspbian Linux 2.6.26 Cross-Compiler Windows Binaries (whew)

UPDATE:  These files still work, but I think I updated my steps above with a more portable solution.  I have uploaded my files here: http://svn.hellwig.us/binaries/Linaro/linaro-14.01-gcc-4.7-arm-RPi-raspbian-2.6.26.zip.  Simply unzip this directory somewhere to your computer.  Point your makefile or environment to the “<install>\bin” directory, and you should be good to go building RPi executables from your Windows PC.  I did not modify any of the Linaro executables or header files (header files might cause some problems down the line,but hopefully not many).  I did not modify any of the Raspbian static library files.  I simply merged the Linaro toolchain with the Raspbian libraies and viola, a cross-compiler was born.  Don’t forget, if you use this, that you’ll need to specify certain compiler options to target the RPi hardware specifically.

In this post I will go through how to install and configure a Rust cross-compilation environment from Windows to the Raspberry Pi 4 running Raspbian. I am assuming that Rust is installed in the Windows system following these instructions and that a Raspberry Pi 4 machine is running with the name raspberrypi and accessible by ssh.

The first step is to install a C/C++ toolchain for the Raspberry Pi. I typically use the one provided by SysGCC but I am sure there are others available. To test that the cross-compiler is working you can write a simple main.c file such as

#include <stdio.h>

int main()
{
    printf("Hello World\n");
    return 0;
}

Then run the following commands on a PowerShell to compile and run the executable on the remote Raspberry Pi.

    arm-linux-gnueabihf-gcc-8.exe .\main.c -o mytest
    scp .\mytest pi@raspberrypi:/home/pi
    ssh pi@raspberrypi chmod +x /home/pi/mytest
    ssh pi@raspberrypi /home/pi/mytest

If you see the Hello World output on your PowerShell terminal then the cross-compilation went well and everything is working.

Prepare the Rust environment

Now it is time to get the Rust environment ready for cross-compilation. First start by installing the target using the PowerShell.

rustup target add armv7-unknown-linux-gnueabihf

Then edit (or create) the file *C:\Users\\\.cargo\\config* by adding the line

[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc-8.exe"

This line configures the linker to be used for creating the executable. If this is not done, a error: linker cc not found message shows up when trying to compile an executable for that target.

Cross-compiling Rust hello world

To create a Rust “Hello World” program, simply make a new folder (in this case I call it rs-hello) and let cargo do the rest of the work for you.

cargo init
cargo build --target=armv7-unknown-linux-gnueabihf

Now there is an executable that can be copied and executed on the remote Raspberry Pi.

scp .\target\armv7-unknown-linux-gnueabihf\debug\rs-hello pi@raspberrypi:/home/pi
ssh pi@raspberrypi chmod +x /home/pi/rs-hello
ssh pi@raspberrypi /home/pi/rs-hello

If you see the Hello, world! output on your PowerShell terminal then the cross-compilation went well and you can now create Rust programs to run on your Raspberry Pi.