Harald: Created page with "
= Building a GNU Toolchain for ARM on Linux = The GNU toolchain is a collection of free programming tools, which allows to create executables for a large..."

2017-07-13T07:14:22Z

Created page with "<div id="content"> = Building a GNU Toolchain for ARM on Linux = The GNU toolchain is a collection of free programming tools, which allows to create executables for a large..."

New page

<div id="content">

= Building a GNU Toolchain for ARM on Linux =

The GNU toolchain is a collection of free programming tools, which allows to create executables for a large number of target systems, using several different programming languages. It is further capable of creating executables for a platform other than the development environment. This is called cross compiling.

Generally there are two ways of installing an executable toolchain:

* Using a package manager to install the executables.
* Building the executables from source code.

This document describes, how to build a C/C++ cross compiler toolchain for the ARM CPU. It will be build from source code on a Linux PC running Debian Etch.

== Prerequisites ==

Depending on your environment, the build procedure may fail at various stages. In such cases some basic knowledge about installing, updating or replacing Debian packages will be required.

The following tool version had been used here

<pre class="coding">$ gcc --version
gcc (GCC) 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)

$ make --version
GNU Make 3.81

$ autoconf --version
autoconf (GNU Autoconf) 2.61

$ automake --version
automake (GNU automake) 1.10

$ bison --version
bison (GNU Bison) 2.3
</pre>
Further, the following relevant packages and libraries had been installed, among many others of course.
* libc6-dev 2.3.6.ds1-13
* libncurses5-dev 5.5-5
* binutils 2.17-3

Note, that earlier and later releases of these tools and libraries may or may not work.
== Getting the Source Archives ==

'''binutils-2.17.tar.bz2'''<br />
GNU binary utilities, a set of tools to manipulate binary objects.<br />
Available at [http://www.gnu.org/software/binutils/ www.gnu.org/software/binutils]

'''gcc-4.1.2.tar.bz2'''<br />
GNU compiler collection.<br />
Available at [http://gcc.gnu.org/ gcc.gnu.org]

'''newlib-1.14.0.tar.gz'''<br />
Standard C library for embedded systems.<br />
Available at [http://www.sourceware.org/newlib/ www.sourceware.org/newlib]

'''insight-6.5.tar.bz2'''<br />
Graphical user interface for and including GDB, the GNU debugger.<br />
Available at [http://sourceware.org/insight/ www.sourceware.org/insight]

== Unpacking the Source Archives ==

Move all archives to a directory of your choice. We will call this our top build directory. Change to this directory and expand all archives by using the following command sequence:

<pre class="coding">$ tar xjf binutils-2.17.tar.bz2
$ tar xjf gcc-4.1.2.tar.bz2
$ tar xzf newlib-1.14.0.tar.gz
$ tar xjf insight-6.5.tar.bz2</pre>
The archives are no longer needed and may be moved to a separate directory.

<pre class="coding">$ mkdir ~/sources
$ mv *.tar.bz2 ~/sources/
$ mv *.tar.gz ~/sources/</pre>
== Building binutils ==

Although possible, we will not build the packages directly in their source directories. Instead we will create specific directories for building the executables.

<pre class="coding">$ mkdir binutils-arm-build</pre>
Change to the build directory and configure binutils for our target.
<pre class="coding">$ cd binutils-arm-build
$ ../binutils-2.17/configure --target=arm-elf --prefix=/usr \
--enable-interwork --enable-multilib --disable-nls --disable-shared \
--disable-threads --mandir=/usr/share/man --infodir=/usr/share/info</pre>
Start building with make.
<pre class="coding">$ make</pre>
If everything went fine, install binutils by calling make install as root.
<pre class="coding"># make install</pre>
Finally return to the top build directory as a normal user.
<pre class="coding">$ cd ..</pre>
== Building a Limited Compiler ==

Two steps are required to build the GNU compiler. We will first build a limited version, which is capable of compiling the standard libraries. Create a specific build directory first.

<pre class="coding">$ mkdir gcc-arm-build
$ cd gcc-arm-build</pre>
Configuring the compiler requires root access.
<pre class="coding"># ../gcc-4.1.2/configure --target=arm-elf --prefix=/usr --disable-nls \
--disable-shared --disable-threads --with-gcc --with-gnu-ld --with-gnu-as \
--with-stabs --enable-interwork --enable-multilib --enable-languages="c,c++" \
--with-newlib --with-headers=../newlib-1.14.0/newlib/libc/include \
--disable-libssp --disable-libstdcxx-pch --disable-libmudflap \
--mandir=/usr/share/man --infodir=/usr/share/info
# make all-gcc
# make install-gcc</pre>
Return to the top build directory when done.
<pre class="coding">$ cd ..</pre>
== Building newlib ==

We will now use limited compiler to build the libraries in a dedicated build directory.

<pre class="coding">$ mkdir newlib-arm-build
$ cd newlib-arm-build</pre>
Not sure if we need root access for configuration and building. At least it is required for the installation process.
<pre class="coding"># ../newlib-1.14.0/configure --target=arm-elf --prefix=/usr --enable-interwork \
--enable-multilib --with-float=soft --mandir=/usr/share/man --infodir=/usr/share/info
# make
# make install</pre>
Finally go back to the top build directory.
<pre class="coding">$ cd ..</pre>
== Building the Final GCC ==

After having build the libraries, we are now able to build the full compiler. Change to the GCC build directory.

<pre class="coding">$ cd gcc-arm-build</pre>
Start the build process as root.
<pre class="coding"># make all
# make install</pre>
Leave the GCC build directory.
<pre class="coding">$ cd ..</pre>
== Building Insight ==

Configure and build Insight including GDB.

<pre class="coding">$ mkdir insight-arm-build
$ cd insight-arm-build
$ ../insight-6.5/configure --target=arm-elf --prefix=/usr \
--enable-interwork --enable-multilib --disable-nls \
--mandir=/usr/share/man --infodir=/usr/share/info
$ make</pre>
<pre class="coding"> We need root access to install the executables.
# make install</pre>
Once again, return to the top build directory.
<pre class="coding">$ cd ..</pre>

</div>

Documents/ARM ELF Toolchain Build - Revision history

Harald: Created page with " = Building a GNU Toolchain for ARM on Linux = The GNU toolchain is a collection of free programming tools, which allows to create executables for a large..."

Harald: Created page with "
= Building a GNU Toolchain for ARM on Linux = The GNU toolchain is a collection of free programming tools, which allows to create executables for a large..."