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/en/tc_cortex.html
Dado Sutter eafb837414 Content added 
Menu tree revised
Anchors refactored
Ongoing work
2009-02-15 22:24:34 +00:00

343 lines
13 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);"><div class="content">
<h3><a name="title" href="http://www.eluaproject.net/en/Building_GCC_for_Cortex" class="local">Building GCC for Cortex</a></h3><p>This tutorial explains how you can create a GCC+Newlib toolchain
that can be used to compile programs for the Cortex (Thumb2)
architecture, thus making it possible to use GCC to compile programs
for the increasingly number of Cortex CPUs out there (<a href="http://www.luminarymicro.com/">Luminary Micro</a>, <a href="http://www.st.com/mcu/inchtml-pages-stm32.html">ST</a>,
with new Cortex CPUs being announced by Atmel and other companies). I
am writing this tutorial because I needed to work on a Cortex CPU for
the eLua project and I couldn't find anywhere a complete set of
instructions for building GCC for this architecture. You'll need such a
toolchain if you want to compile eLua for Cortex-M3 CPUs.</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.eluaproject.net/en/Contact">contact us</a> and I'll make the necessary corrections. And of course, this tutorial comes without any guarantees whatsoever.</strong></p>
<h2>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. <strong>UPDATE</strong>: you MUST use the new binutils 2.19
distribution for the Cortex toolchain, since it fixes some assembler
issues. You won't be able to compile eLua 0.5 or higher if you don't
use binutils 2.19.</li><li>GCC: since support for Cortex (Thumb2)
was only introduced staring with version 4.3.0, you'll need to download
version 4.3.0 or newer. 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.
However, the CVS version contains some fixes for the Thumb2
architecture, some of them in very important functions (like
setjmp/longjmp), so you'll need to fetch the sources from CVS (this
will most likely change when a new official Newlib version is
released). So go to <a href="http://sourceware.org/newlib/download.html">http://sourceware.org/newlib/download.html</a> and follow the instructions there in order to get the latest sources from CVS.</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 build-essential</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-cortex 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-cortex</th>
</tr>
</tbody></table>
<h2>Step 1: binutils</h2>
<p>This is the easiest step: unpack, configure, build.</p>
<p><br></p>
<table class="table_cod">
<tbody><tr align="left">
<th>$ tar -xvjf binutils-2.19.tar.bz2</th>
</tr>
<tr align="left">
<th>$ cd binutils-2.19</th>
</tr>
<tr align="left">
<th>$ mkdir build</th>
</tr>
<tr align="left">
<th>$ cd build</th>
</tr>
<tr align="left">
<th>$
../configure --target=arm-elf --prefix=$TOOLPATH --enable-interwork
--enable-multilib --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 ARM "binutils" (assembler, linker, disassembler ...) in your PATH. They are fully capable of handling Thumb2.</p>
<h2>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>
<code># AC_LIBTOOL_DLOPEN<br></code>
<p>Save the modified file and exit the text editor</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th>$ autoconf</th>
</tr>
<tr>
<th style="text-align: left;">$ 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=arm-elf --prefix=$TOOLPATH --enable-interwork
--enable-multilib --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 style="width: 376px; height: 157px;" class="table_cod">
<tbody><tr>
<th>$ sudo -s -H</th>
</tr><tr><td align="undefined" valign="undefined"><code># export PATH=/usr/local/cross-cortex/bin:$PATH</code></td></tr><tr><td align="undefined" valign="undefined"><code># make install-gcc</code></td></tr><tr><td align="undefined" valign="undefined"><code># exit</code></td></tr>
</tbody></table>
<code><br><br><br></code>
<h2>Step 3: Newlib</h2>
<p>Again, some modifications are in order before we start compiling.
Because the CVS version of Newlib doesn't seem to have all the required
support for Thumb2 yet, we need to tell Newlib to skip some of its
libraries when compiling:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th>$ cd [directory where the newlib CVS is located]</th>
</tr>
<tr>
<th style="text-align: left;">$ joe configure.ac</th>
</tr>
</tbody></table>
<p> Find this fragment of code:</p>
<pre><code> arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )<br> noconfigdirs="$noconfigdirs target-libffi target-qthreads"<br> libgloss_dir=arm<br> ;;<br><br> And add "target-libgloss" to the "noconfigdirs" variable:<br><br> arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )<br> noconfigdirs="$noconfigdirs target-libffi target-qthreads target-libgloss"<br> libgloss_dir=arm<br> ;;<br><br> Save the modified file and exit the text editor<br> $ autoconf<br></code></pre>
<p>On one of the systems I ran the above sequence, it terminated with
errors, complaining that autoconf 2.59 was not found. I don't know why
that happens. 2.59 seems to be quite ancient, and the build ran equally
well with 2.61 (the version of autoconf on the system that gave the
error). If this happens to you, first execute autoconf --version to
find the actual version of your autoconf, then do this:</p>
<p><br></p>
<table class="table_cod">
<tbody><tr>
<th></th>
</tr>
</tbody></table>
<pre><code>$ joe config/override.m4<br><br> Look for this line:<br><br> [m4_define([_GCC_AUTOCONF_VERSION], [2.59])])<br><br> And replace [2.59] with your actual version ([2.61] in my case).<br> $ autoconf<br></code></pre>
<p>Once again, now we're ready to actually compile Newlib. But we need
to tell it to compile for Thumb2. As already specified, I'm not a
specialist when it comes to Newlib's build system, so I chosed the
quick, dirty and not so elegant solution of providing the compilation
flags directly from the command line. Also, as 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, 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>$ mkdir build</th>
</tr>
<tr align="left">
<th>$ cd build</th>
</tr>
<tr align="left">
<th>$
../configure --target=arm-elf --prefix=$TOOLPATH --enable-interwork
--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
-DPREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__ -Os -fomit-frame-pointer
-mcpu=cortex-m3 -mthumb -D__thumb2__ -D__BUFSIZ__=256"
CCASFLAGS="-mcpu=cortex-m3 -mthumb -D__thumb2__"</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>-DPREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__:</code> compile Newlib for size, not for speed (these are Newlib specific).</li><li><code>-mcpu=cortex-m3 -mthumb:</code> this tells GCC that you want to compile for Cortex. Note that you need both flags.</li><li><code>-D__thumb2__:</code> again, this is Newlib specific, and seems to be required when compiling Newlib for Cortex.</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>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, as long as you remember that we want to build our
compiler support libraries for the Cortex architecture:</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 CFLAGS="-mcpu=cortex-m3 -mthumb" CXXFLAGS="-mcpu=cortex-m3 -mthumb" LIBCXXFLAGS="-mcpu=cortex-m3 -mthumb" all</th>
</tr>
<tr align="left">
<th>$ sudo make install</th>
</tr>
</tbody></table>
<h2>All Done!</h2>
<p>Phew! That was quite a disturbing tutorial, with all that confusing
flags lurking in every single shell line :) But at this point you
should have a fully functional Cortex GCC toolchain, which seems to be
something very rare, so enjoy it with pride.
If you need further clarification, or if the above instructions didn't
work for you, feel free to <a href="http://www.eluaproject.net/en/Contact">contact us</a>.</p><p></p><p></p>
</div></body></html>
Reference in New Issue View Git Blame Copy Permalink