How to Build Own Toolchain?

2012-05-04    Piotr Romaniuk, Ph.D.

Contents

Introduction about Cross-compilation
What is a Toolchain?
Building the Toolchaina
Toolchain Configuration Options
How to Use Toolchain?
How to Build Toolchain under Cygwin?

Introduction about Cross-compilation
Devices (target) that are embedded systems have limited cpu power, hence they are not suitable platform for building their firmware. Because of that the firmware is built on faster machine (host) that is PC or laptop. Although host and target have processors with different architecture (host is mostly x86 and target can use ARM) this is not an obstacle, the source files are compiled from sources to executables with opcodes specific to target device. In order to do that special type of compiler is needed, so called cross-compiler.
The firmware for embedded systems is mostly written in C language (also C++, assembler parts or sometimes Java are used), so C cross-compiler is required together with a few tools (like linker, etc.). To build programs one need the standard C library as well. The library contains methods for memory allocation, file access, standard string operations, mathematical functions, etc. Although commercial environments for that purpose can be bought, it is worth to consider GNU tools (including GCC: GNU Compiler Colection). The GNU tools can be chosen because:

• support for many architectures,
• common usage by many programmers (broadly tested and developed by many people),
• standard form (architecture independent),
• possible further use for Linux system build,
• public and open source code,
• available for free of charge.

If you want to learn more about building toolchain please read first chapters of: Cross Linux From Scratch. This project deals with building the whole firmware image, including Linux kernel, filesystem preparation, bootloader and instalation details. The first part is there making the toolchain, that is later used for building further components. Although all phases are well described, this is hard way, because of lack of automatic methods (if you need to modify something you need to repeat the sequence manually). You must remember that the goal of Cross Linux From Scratch project is presenting a reference, but not an environment for building.

Building the Toolchain
In order to build own toolchain I advise to use ready environment intended to that purpose, e.g. crosstool-NG. In this case, building a toolchain consists in setting configurations and starting build process that will continue automatically. Because of the complexity of this process you can expect that this take some time (usually tens of minutes).
Depending on operating system that you have on target machine, you can build under Linux (recommended) or under Windows using Cygwin. Be aware of extra requirements when you work with Cygwin. Below on this page you may find a description.

According to manual from crosstool-NG site you need:

I. download selected version of package crosstool-NG from its site, e.g. crosstool-ng-1.14.1.tar.bz2
II. decompress the sources and enter that folder:

tar -xjf crosstool-ng-1.14.1.tar.bz2
cd crosstool-ng-1.14.1

III. configure package:

./configure --prefix=/some/folder/ctng-bin

where: prefix is a path selected by you, where crosstool-NG tool will be built (NOTE: this is not a toolchain yet)
  If you receive during configuration a message that some package is missing, you need install it and start configuration again. (Cygwin required closing its console window while I was installing some packages).

IV. Build and installation crosstool-ng tool:

make
make install

V. add to system path crosstool-ng

export PATH="${PATH}:/some/folder/ctng-bin/bin

VI. enter the folder where toolchain will be built and its configuration will be stored:

cd /some/folder/development

When you complete above steps, crosstool-NG is ready for configuration the toolchain and staring the build after that.
In order to configure toolchain you need to execute:

ct-ng menuconfig

This will cause opening configuration menu:

Using that interface you should set toolchain options and save it on exit (by default it is written in .config file). When you finish configuration you can start building by a command:

ct-ng build

Building process takes a lot of time, on my computer it took about 40 min. under Linux and 2h under Windows/Cygwin. If you do not disable debug information in configuration options, the messages reporting completed phases will appear on console, as well as progress indicator in a form of rotating bar. Be aware that Crosstool-NG will download proper versions of packages, uncompress them, makes patching and compiles them.

Toolchain Configuration Options
Full set of options is very large, I will not explain them all, but only the most important:

   C library - type of standard C library ( size, speed vs. functionality )
     - uClibc - limited functionality, small size,
     - glibc - full GNU C Library - large, full functionality,
     - eglibc - version GNU C Library for embedded systems.

Hwo to Use Toolchain?
When the build process is finished, the toolchain is located in folder ${HOME}/x-tools/arch-vendor-kernel-system if you did not change it in configuration. In order to use cross compiler you need to add it to system path, e.g.:

How to Build Toolchain under Cygwin?

When I was building crosstool-NG (1.14.1) and the toolchain I experienced following issues:
1. crosstool-NG requires case sensitive filesystem.

aconring to   (1) Cygwin FAQ 4.30: Is Cygwin case-sensitive?
and:     (2) Using Cygwin, rozdział "Case sensitive filenames"

Warning:
You need to remember that this changes behavior not only files under Cygwin but whole filesystem. It is possible that some software is assuming the case insensitivity, that will be not true after the change. In this case it can work strange. In [2] there is a warning that you do this on your risk. The warning seems to be exaggerated. I change it permanently in my Windows 7 and I do not see any problems. Nevertheless remember it.

2. Unnecessary elements in system path

When you start Cygwin console Windows system path (%PATH%) is copied to $PATH. Because it may point to other programs that use another binary versions of Cygwin or MinGW, they will be detected by ./configure script. In order to avoid this issue, you need to shorten the path in Cygwin. I advise to check it and then cut to necessary minimum part:

echo $PATH
export PATH=/usr/local/bin:/usr/bin

3. ncurses headers problem

Although ncurses headers are detected properly by configuration script, during the build you receive the message that they are missing.
Adding the path in kconfig/Makefile solve the problem:

# Build flags
CFLAGS = -DCONFIG_=\"CT_\" -DPACKAGE="\"crosstool-NG $(VERSION)\"" -I/usr/include/ncurses

4. Missing libintl library

Add library in kconfig/Makefile:

# Build flags
...
LDFLAGS = -lintl

5. ESCDELAY issue

The symbol seems to be undefined for ncurses in Cygwinie [?].
When I commented it in kconfig/nconf.c@1518 it stopped complaining:

notimeout(stdscr, FALSE);
/*ESCDELAY = 1;*/

6. Make in version newer than 3.81

In newer Make version (Cygwin can install package Make-v.3.82) small change has been introduced in makefiles interpretation. It fixed some problem, that was previously ignored (it concerns how to Make behaves for mixed rules). Although the correction is right, it cause the problem with build, For now, I advise to install in Cygwin older version of Make, i.e. version 3.81 (you can select version in GUI setup.exe).

7. Much longer time of build than under Linux

Unfortunatelly, there is not much to do, you must be patient. You are not building the toolchain every day ;) This issue is caused by extra load of open-file methods and fork in Cygwin according to Linux operations. You need to remember that Cygwin is only some kind of envelope that provides a way for starting programs under Windows system in quasi Linux environment.