i386

Building GCC for i386

NOTE: these instructions are obsolete. Most likely, they are not applicable to newer versions of the various components (binutils, gcc, newlib). If you need an i386 toolchain, there is rarely a need to build one yourself. Instead, get a pre-built one, for example from Mentor Graphics.

At first, the idea of an i386 "cross" compiler under Linux seems strange. After all, you're already running Linux on a i386 compatible architecture. But the compiler is sometimes tied in mysterious ways with the operating system it's running on (see for example this page for some possible symptoms). And after all, you want to use Newlib, not libc, and to customize your development environment as much as possible. This tutorial will show you how to do that.

DISCLAIMER: I'm by no means a specialist in the GCC/newlib/binutils compilation process. I'm sure that there are better ways to accomplish what I'm describing here, however I just wanted a quick and dirty way to build a toolchain, I have no intention in becoming too intimate with the build process. If you think that what I did is wrong, inaccurate, or simply outrageously ugly, feel free to contact us and I'll make the necessary corrections. And of course, this tutorial comes without any guarantees whatsoever.

Prerequisites

To build your toolchain you'll need:

GNU binutils: as I'm writing this, the latest binutils version is 2.19.1, which I'll be using in this tutorial. get it from here.
GCC:as I'm writing this, the latest GCC version is 4.3.3, which I'll be using for this tutorial. Download it from here after choosing a suitable mirror.
Newlib: as I'm writing this, the latest official Newlib version is 1.17.0, which I'll be using for this tutorial. Download it from here.
The tutorial assumes that you're using bash as your shell. If you use something else, you might need to adjust some shell-specific commands.

You need some support programs/libraries in order to compile the toolchain. To install them:

$ sudo apt-get install flex bison libgmp3-dev libmpfr-dev autoconf texinfo build-essential

Next, decide where you want to install your toolchain. They generally go in /usr/local/, so I'm going to assume /usr/local/cross-i686 for this tutorial. To save yourself some typing, set this path into a shell variable:

$ export TOOLPATH=/usr/local/cross-i686

Step 1: binutils

This is the easiest step: unpack, configure, build.

$ tar -xvjf binutils-2.19.1.tar.bz2
$ cd binutils-2.19.1
$ mkdir build
$ cd build
$ ../configure --target=i686-elf --prefix=$TOOLPATH --with-gnu-as --with-gnu-ld --disable-nls
$ make all
$ sudo make install
$ export PATH=${TOOLPATH}/bin:$PATH
$ cd ../..

Now you have your i386 "binutils" (assembler, linker, disassembler ...) in your PATH.

Step 2: basic GCC

In this step we build a "basic" GCC (that is, a GCC without any support libs, which we'll use in order to build all the libraries for our target). Let's compile it (and note that the install step is a bit different from Newlib's):

$ tar -xvjf gcc-4.3.3.tar.bz2
$ cd gcc-4.3.3
$ mkdir build
$ cd build
$ ../configure --target=i686-elf --prefix=$TOOLPATH --enable-languages="c,c++" --with-newlib --without-headers --disable-shared --with-gnu-as --with-gnu-ld
$ make all-gcc
$ sudo -s -H
# export PATH=/usr/local/cross-i686/bin:$PATH
# make install-gcc
# exit
$ cd ../..

Step 3: Newlib

Once again, Newlib is as easy as unpack, configure, build. But I wanted my library to be as small as possible (as opposed to as fast as possible) and I only wanted to keep what's needed from it in the final executable, so I added the "-ffunction-sections -fdata-sections" flags to allow the linker to perform dead code stripping:

$ tar -xvzf newlib-1.17.0.tar.gz
$ cd newlib-1.17.0
$ mkdir build
$ cd build
$ ../configure --target=i686-elf --prefix=$TOOLPATH --disable-newlib-supplied-syscalls --with-gnu-ld --with-gnu-as --disable-shared
$ make CFLAGS_FOR_TARGET="-ffunction-sections -fdata-sections -DPREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__ -Os -fomit-frame-pointer -D__BUFSIZ__=256"
$ sudo -s -H
# export PATH=/usr/local/cross-i686/bin:$PATH
# make install
# exit 
$ cd ../..

Some notes about the flags used in the above sequence:

--disable-newlib-supplied-syscalls: this deserves a page of its own, but I won't cover it here. For an explanation, see for example this page
-DPREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__: compile Newlib for size, not for speed (these are Newlib specific).
-Os -fomit-frame-pointer: tell GCC to optimize for size, not for speed.
-D__BUFSIZ__=256: again Newlib specific, this is the buffer size allocated by default for files opened via fopen(). The default is 1024, which I find too much for eLua, so I'm using 256 here. Of course, you can change this value.

Step 4: full GCC

Finally, in the last step of our tutorial, we complete the GCC build. In this stage, a number of compiler support libraries are built (most notably libgcc.a). Fortunately this is simpler that the Newlib compilation step:

$ cd gcc-4.3.3/build
$ make all
$ sudo make install

Step 5: all done!

Now you can finally enjoy your i386 toolchain, and compile eLua with it :) After you do, you'll be able to boot eLua directly on your PC, as described here, but you won't need to download the ELF file from the eLua project page, since you just generated it using your own toolchain! If you need further clarification, or if the above instructions didn't work for you, feel free to contact us.

eLua Doc