Cross-compiling is compiling for a different architecture than the one you are currently working on. If it’s your first time doing that kind of work, it can rapidly become frustrating since there is no “silver bullet” method. In this post, I will try to explain a method that should work for most embedded device provided that the manufacturer has a toolchain readily available.

What you will need:

• A computer with a Linux distribution (I used Fedora 7 [it's old but it worked] )
• A compiler and the necessary libraries
• The toolchain for the processor
• Not necessary but will make you  life easier: a development environment (such as Eclipse)

Let’s take a look at the 4 items previously listed. First, the Linux distribution; it’s not 100% required but it will make your life a lot easier since most toolchains (patience, we’ll get to what it is soon) are compiled for Linux.

The compiler that is most often used is GCC, a great compiler, free (free as in speech and free as in beer) and readily available of all (or almost) Linux distributions. You can get the Tarballs off their website at http://gcc.gnu.org/ or just use the package manager in you environment. I would suggest installing the required libraries for the code you are compiling at this point if it’s not already done.

Toolchains, what are they? Toolchains are simply a set of compilers and libraries build to run on a certain architecture and compile for another. You will usually be able to get them from the manufacturer’s website or from the community. You will most likely find them packaged in Tarballs.

Finally, the development environment is useful because it let’s you consolidate and organize your code into neat folders and let’s you easily manage build options. With some addons, Eclipse will even let you sync a project directly from a SVN!

Architecture, what’s that?

Throughout this article, I will often refer to the ARM architecture and the x86 (also known as i386 or i486 or i686). The architecture simply refers to the CPU “design” and it’s a quick way of knowing what compiled code will work with which CPUs. The differences between each architecture and the reason for such differences is way beyond the scope of this article. Just keep in mind that when you select a compiler, an application or Linux distribution for you computer, you’ll probably be looking for the i386 (most Linux distributions will but different versions for i386 and i686, newer PCs run with i386) or the x86_64 (or x64) if you have a 64 bit processor. Note that i386 will work on 64 bit processor the the opposite is not true!

Let’s get started

First let’s assume that you have you environment set up, that you have some basic knowledge of Linux and that your code compiles on you current processor. Let’s also assume you’re not using some obscure libraries that you don’t have the source code for. Finally, I’ll assume that you have ROOT privileges on your system.

First step of the cross-compiling process is to locate the toolchain and download it to your home directory.

Next step is to extract it. If it’s a tarball, just execute the following command:

tar -xzf crosstool.tar

Once you have the content of the toolchain in a folder somewhere, we need to make it usable. This is where most people go their own ways. I found a very simple and effective way of using the toolchain and I’m sharing it because I think the other methods are more trouble than they are worth.

To get the toolchain working, let’s start by making a backup or our compilers. Execute the following commands in the console:

cp /usr/bin/gcc /usr/bin/gcc.bak

cp /usr/bin/g++ /usr/bin/g++.bak

Now that we have the backup done, we’ll remove the originals by running the following commands:

rm /usr/bin/gcc

rm /usr/bin/g++

And finally, we need a way of letting the OS think that we still have the compilers there, so we’ll add two symbolic links that will point to the toolchain’s compilers

ln -s /path/to/crosstool/bin/crosstool-name-gcc /usr/bin/gcc      
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gcc /usr/bin/gcc

ln -s /path/to/crosstool/bin/crosstool-name-gpp /usr/bin/gpp               
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gpp /usr/bin/gpp

Now that, we have some shinny new compilers, let’s test them with something simple. We’ll make a short “Hello World” program and compile it for your embedded device architecture. Type into a new file somewhere:

#include <stdio.h>

int main(void) {

       printf("Hello World!\n");

       return 0;

}

and save it as hello.c.

To compile, you can simply type the following command (assuming that you are executing that command from the same folder that contains the file):

gcc hello.c -o hello.arm

You should look for errors here, if it succeeds, you should not get anything back and you will be able to see the file in your current folder.

Finally, to confirm that you have a working environment, we will look at the file properties by executing the command:

file hello.arm

if the output specifies the embedded device’s processor, you should be fine. It should look like:

hello.arm: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.4.17, not stripped

In part two of this tutorial, we will look at getting the original compilers back in and some advanced method for larger application compiling. Even though I am not an expert on the subjet, feel free to post your issues and questions and I will do my best to find and provide answers!