Embedded/elua
1
0
Fork 0
mirror of https://github.com/elua/elua.git synced 2025-01-08 20:56:17 +08:00
Code Issues Projects Releases Wiki Activity
elua/doc/pt/tc_386.html
Dado Sutter 80513aaf52 i386 toolchain build tutorial edited to include John Hind fix 
SConstruct edited just to leave group/files definitions close to the platform/groups.
Doc content files mirroed to pt, to ease the portuguese version initial migration
2009-02-21 23:02:39 +00:00

281 lines
9.8 KiB
HTML
Raw Blame History

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Strict//EN">
<html><head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<meta http-equiv="Content-Language" content="en-us"><title>Product</title>
<link rel="stylesheet" type="text/css" href="../style.css"></head>
<body style="background-color: rgb(255, 255, 255);"><h3><a name="title" href="http://www.eluaproject.net/en/Building_GCC_for_i386" class="local">Building GCC for i386</a></h3>
<div class="content">
<p>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 misterious ways
with the operating system it's running on (see for example <a href="http://wiki.osdev.org/GCC_Cross-Compiler">this page</a>
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.</p>
<p><strong>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, innacurate, or simply outrageously ugly, feel free to <a href="http://www.giga.puc-rio.br/cgi-bin/elua.cgi?p=Contact">contact me</a> and I'll make the necessary corrections. And of course, this tutorial comes without any guarantees whatsoever.</strong></p>
<h2>&#8250; Prerequisites</h2>
<p>To build your toolchain you'll need:</p>
<ul><li>a computer running Linux: I use Ubuntu 8.04, but any Linux
will do as long as you know how to find the equivalent of "apt-get" for
your distribution. I won't be going into details about this, google it
and you'll sure find what you need. It is also assumed that the Linux
system already has a "basic" native toolchain installed (gcc/make and
related). This is true for Ubuntu after installation. Again, you might
need to check your specific distribution.</li><li>GNU binutils: get it from <a href="http://ftp.gnu.org/gnu/binutils/">here</a>.
At the moment of writing this, the latest versions is 2.18, which for
some weird reason refuses to compile on my system, so I'm using 2.17
instead.</li><li>GCC: version 4.3.0 or newer is recommended. As
I'm writing this, the latest GCC version is 4.3.1 which I'll be using
for this tutorial. Download it from <a href="http://gcc.gnu.org/mirrors.html">here</a> after choosing a suitable mirror.</li><li>Newlib: as I'm writing this, the latest official Newlib version is 1.16.0. Download it from the <a href="ftp://sources.redhat.com/pub/newlib/index.html">Newlib FTP directory</a>.</li><li>Also,
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. </li></ul>
<p>Also, you need some support programs/libraries in order to compile the toolchain. To install them:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th>$ sudo apt-get install flex bison libgmp3-dev libmpfr-dev autoconf texinfo</th>
</tr>
</tbody></table>
<p>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:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th>$ export TOOLPATH=/usr/local/cross-i686</th>
</tr>
</tbody></table>
<h2>&#8250; Step 1: binutils</h2>
<p>This is the easiest step: unpack, configure, build.</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th style="text-align: left;">$ tar -xvjf binutils-2.17.tar.bz2</th>
</tr>
<tr align="left">
<th>$ cd binutils-2.17</th>
</tr>
<tr align="left">
<th>$ mkdir build</th>
</tr>
<tr align="left">
<th>$ cd build</th>
</tr>
<tr align="left">
<th>$ ../configure --target=i686-elf --prefix=$TOOLPATH --with-gnu-as --with-gnu-ld --disable-nls</th>
</tr>
<tr align="left">
<th>$ make all</th>
</tr>
<tr align="left">
<th>$ sudo make install</th>
</tr>
<tr align="left">
<th>$ export PATH=${TOOLPATH}/bin:$PATH</th>
</tr>
</tbody></table>
<p>Now you have your i386 "binutils" (assembler, linker, disassembler ...) in your PATH.</p>
<h2>&#8250; Step 2: basic GCC</h2>
<p>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). But first we need to make a slight modification in the
configuration files. Out of the box, the GCC 4.3.1/newlib combo won't
compile properly, giving a very weird "Link tests are not allowed after
GCC_NO_EXECUTABLES" error. After a bit of googling, I found the
solution for this:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ tar -xvjf gcc-4.3.1.tar.bz2</th>
</tr>
<tr align="left">
<th>$ cd gcc-4.3.1/libstdc++-v3</th>
</tr>
<tr align="left">
<th>$ joe configure.ac</th>
</tr>
</tbody></table>
<p>I'm using "joe" here as it's my favourite Linux text mode editor,
you can use any other text editor. Now find the line which says
"AC_LIBTOOL_DLOPEN" and comment it out by adding a "#" before it: </p>
<pre><code> # AC_LIBTOOL_DLOPEN<br></code></pre>
<p>Save the modified file and exit the text editor</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ autoconf</th>
</tr>
<tr align="left">
<th>$ cd ..</th>
</tr>
</tbody></table>
<p>Great, now we know it will compile, so let's do it:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ mkdir build</th>
</tr>
<tr align="left">
<th>$ cd build</th>
</tr>
<tr align="left">
<th>$
../configure --target=i686-elf --prefix=$TOOLPATH
--enable-languages="c,c++" --with-newlib --without-headers
--disable-shared --with-gnu-as --with-gnu-ld
</th>
</tr>
<tr align="left">
<th>$ make all-gcc</th>
</tr>
<tr align="left">
<th>$ sudo make install-gcc</th>
</tr>
</tbody></table>
<p>On my system, the last line above (sudo make install-gcc) terminated
with errors, because it was unable to find our newly compiled binutils.
If this happens for any kind of "make install" command, this is a quick
way to solve it:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th>$ sudo -s -H</th>
</tr>
</tbody></table>
<pre><code> # export PATH=/usr/local/cross-i686/bin:$PATH<br> # make install-gcc<br> # exit<br></code></pre>
<h2>&#8250; Step 3: Newlib</h2>
<p>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:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ tar xvfz newlib-1.16.0.tar.gz</th>
</tr>
<tr align="left">
<th>$ cd newlib-1.16.0</th>
</tr>
<tr align="left">
<th>$ mkdir build</th>
</tr>
<tr align="left">
<th>$ cd build</th>
</tr>
<tr align="left">
<th>$
../configure --target=i686-elf --prefix=$TOOLPATH
--disable-newlib-supplied-syscalls --with-gnu-ld --with-gnu-as
--disable-shared</th>
</tr>
<tr align="left">
<th>$ make
CFLAGS_FOR_TARGET="-ffunction-sections
-fdata-sections -D__PREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__ -Os
-fomit-frame-pointer -D__BUFSIZ__=256"</th>
</tr>
<tr align="left">
<th>$ sudo make install</th>
</tr>
</tbody></table>
<p>Some notes about the flags used in the above sequence:</p>
<ul><li><code>--disable-newlib-supplied-syscalls:</code> this deserves a page of its own, but I won't cover it here. For an explanation, see for example <a href="http://openhardware.net/Embedded_ARM/NewLib_Stubs/">this page</a>.</li><li><code>-D__PREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__:</code> compile Newlib for size, not for speed (these are Newlib specific).</li><li><code>-Os -fomit-frame-pointer:</code> tell GCC to optimize for size, not for speed.</li><li><code>-D__BUFSIZ__=256:</code>
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 an eLua, so I'm using 256 here. Of course, you can change this
value.</li></ul>
<h2>&#8250; Step 4: full GCC</h2>
<p>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:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ cd gcc-4.3.1/build</th>
</tr>
<tr align="left">
<th>$ make all</th>
</tr>
<tr align="left">
<th>$ sudo make install</th>
</tr>
</tbody></table>
<h2>&#8250; Step 5: all done!</h2>
<p>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 <a href="http://www.giga.puc-rio.br/cgi-bin/elua.cgi?p=Booting_your_PC_in_eLua">here</a>, 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 <a href="http://www.giga.puc-rio.br/cgi-bin/elua.cgi?p=Contact">contact me</a>.</p>
</div></body></html>
Reference in New Issue View Git Blame Copy Permalink