elua/doc/pt/tc_arm.html

$$HEADER$$
<p> Esse tutorial explica como criar um toolchain com GCC+Newlib para ser usado na compila&ccedil;&atilde;o de programas usando a arquitetura ARM, tornando assim poss&iacute;vel a compila&ccedil;&atilde;o de programas para um grande n&uacute;mero de CPUs com arquitetura ARM. Voc&ecirc; precisar&aacute; desse recurso se pretende compilar eLua para as CPUs com arquitetura ARM. Esse tutorial &eacute; semelhante a muitos outros encontrados na Internet (particularmente o <a href="http://www.gnuarm.com/">gnuarm</a>, que serviu de base para esse tutorial), no entanto, este possui um maior detalhamento e mostra alguns "dicas" que voc&ecirc; poder&aacute; utilizar quando estiver compilando a Newlib.</p>

<p><strong>AVISO: Eu n&atilde;o sou um especialista no processo de montagem de CGC/newlib/binutils. Tenho certeza de que existem melhores formas de realizar o que estou descrevendo aqui, no entanto, apresento apenas uma maneira r&aacute;pida de construir um toolchain, n&atilde;o tenho nenhuma inten&ccedil;&atilde;o de me aprofundar no processo de montagem. Se voc&ecirc; encontrar algum erro, por favor entre em <a href="http://www.eluaproject.net/en/Contact">contato comigo</a> e farei as corre&ccedil;&otilde;es necess&aacute;rias. Acrescento ainda, que esse tutorial n&atilde;o possui nenhum tipo de garantia.</strong></p>

<h2>Pr&eacute;-requisitos</h2>
<p>Para construir seu toolchain voc&ecirc; precisar&aacute; de:</p>

<ul>
<li>Um computador rodando Linux: Eu uso Ubuntu 8.04, mas qualquer Linux ir&aacute; fazer, desde que voc&ecirc; saiba como encontrar o equivalente do "apt-get" para a sua distribui&ccedil;&atilde;o. N&atilde;o entrarei em detalhes sobre isso, pesquise no Google e voc&ecirc; encontrar&aacute; o que precisa. Assumimos tamb&eacute;m que o Linux j&aacute; tem uma "base" nativa toolchain instalada (gcc/make e afins). Isto &eacute; verdadeiro para o Ubuntu depois da instala&ccedil;&atilde;o. No entanto, voc&ecirc; precisa verificar a sua distribui&ccedil;&atilde;o espec&iacute;fica.</li>
<li>GNU binutils: fa&ccedil;a o download <a href="http://ftp.gnu.org/gnu/binutils/">aqui</a>. No momento em que elaborava este tutorial, as vers&otilde;es mais recentes eram 2.18, que por algum motivo desconhecido n&atilde;o compilava no meu sistema, por isso estou usando a vers&atilde;o 2,17.</li>
<li>GCC: vers&atilde;o 4.3.0 ou superior &eacute; recomendada. No momento em que escrevia este tutorial, a vers&atilde;o mais recente era a 4.3.1, a qual usarei para este tutorial. Fa&ccedil;a o download <a href="http://gcc.gnu.org/mirrors.html">aqui</a> depois de escolher um bom servidor de mirror.</li>
<li>Newlib: enquanto preparava este tutorial, a vers&atilde;o mais recentes era a 1.16.0. Fa&ccedil;a o download do <a href="ftp://sources.redhat.com/pub/newlib/index.html">diret&oacute;rio FTP Newlib</a>.</li>
<li>Al&eacute;m disso, o tutorial assume que voc&ecirc; esteja usando o bash como seu shell. Se voc&ecirc; usar qualquer outra coisa, talvez voc&ecirc; precise ajustar alguns comandos do shell espec&iacute;fico.</li>
</ul>

<p>Voc&ecirc; ainda precisar&aacute; de outros programas e bibliotecas a fim de montar o toolchain. Para instal&aacute;-los:</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>Em seguida, defina onde pretende instalar o seu toolchain. Eles geralmente s&atilde;o instalados no diret&oacute;rio /usr/local/, logo, assumiremos o diret&oacute;rio /usr/local/cross-arm para este tutorial. Para agilizar a digita&ccedil;&atilde;o, defina este caminho como padr&atilde;o na vari&aacute;vel de ambiente:</p>

<p><br></p>

<table class="table_cod">
     <tbody><tr>
        <th>$ export TOOLPATH=/usr/local/cross-arm</th>
     </tr>
</tbody></table>


<h2>&#8250; Passo 1: binutils</h2>
<p>Este &eacute; o passo mais f&aacute;cil: descompactar, configurar, compilar.</p>

<p><br></p>

<table class="table_cod">
     <tbody><tr>
        <th>$ tar -xvjf binutils-2.17.tar.bz2</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ cd binutils-2.17</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ mkdir build</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ cd build</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th style="text-align: left;">$ ../configure --target=arm-elf --prefix=$TOOLPATH --enable-interwork --enable-multilib--with-gnu-as --with-gnu-ld --disable-nls</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ make all</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ sudo make install</th>
     </tr>
</tbody></table>


<table class="table_cod">
     <tbody><tr>
        <th>$ export PATH=${TOOLPATH}/bin:$PATH</th>
     </tr>
</tbody></table>   


<p>Agora voc&ecirc; tem os "binutils" da CPU ARM(assembler, linker, disassembler ...) em seu PATH.</p>

<h2>Passo 2: basic GCC</h2>

<p>Nesta etapa vamos montar uma "base" GCC (ou seja, uma GCC sem nenhuma lib, a qual usaremos, a fim de criar todas as bibliotecas para o nosso objetivo). Mas primeiro temos que fazer uma r&aacute;pida modifica&ccedil;&atilde;o nos arquivos de configura&ccedil;&atilde;o. Fora desse ambiente, o pacote GCC 4.3.1/newlib n&atilde;o compilar&aacute; corretamente, dando um erro muito estranho "Link tests are not allowed after GCCNOEXECUTABLES". Ap&oacute;s uma procura no google, encontrei a solu&ccedil;&atilde;o para isso:</p>

<p><br></p>

<table class="table_cod">
     <tbody><tr>
        <th>$ tar -xvjf gcc-4.3.1.tar.bz2</th>
     </tr>
     <tr>
        <th>$ cd gcc-4.3.1/libstdc++-v3</th>
     </tr>
     <tr>
        <th style="text-align: left;">$ joe configure.ac</th>
     </tr>
</tbody></table>


<p> Estou usando "joe" aqui, como meu editor de texto Linux favorito, voc&ecirc; pode usar qualquer outro editor de texto. Agora encontre a linha que tenha o string "AC_LIBTOOL_DLOPEN" e adicione um "#" no inicio da linha:</p>

<p><code># AC_LIBTOOL_DLOPEN</code></p>

<p>Salve o arquivo alterado e saia do 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>&Oacute;timo, agora sabemos que podemos compilar, ent&atilde;o vamos em frente:</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>No meu sistema, a &uacute;ltima linha acima (sudo make install-gcc) termina com erros, devido a impossibilidade de encontrar a binutils recentemente compilada. Se isso acontece para qualquer tipo de comando "make install", aqui est&aacute; uma maneira r&aacute;pida de resolver isso:</p>

<p style="text-align: left;"><br></p><div style="text-align: left;"></div>
<table class="table_cod">
     <tbody><tr align="left">
        <th>$ sudo -s -H</th>
     </tr>
     <tr align="left">
        <th># export PATH=/usr/local/cross-arm/bin:$PATH</th>
     </tr>
     <tr align="left">
        <th># make install-gcc</th>
     </tr>
     <tr>
        <th style="text-align: left;"># exit</th>
     </tr>
</tbody></table>




<h2>Passo 3: Newlib</h2>

<p>Mais uma vez, este etapa &eacute; t&atilde;o f&aacute;cil quanto descompactar, configurar, compilar. Mas eu preciso que a minha biblioteca seja do menor tamanho poss&iacute;vel (em contraposi&ccedil;&atilde;o, t&atilde;o r&aacute;pida quanto poss&iacute;vel) e eu s&oacute; queria manter o que &eacute; necess&aacute;rio no execut&aacute;vel, por isso, acrescentei os flags "-ffunction-sections -fdata-sections" para permitir que o linker execute "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=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
-D__BUFSIZ__=256"</th>
     </tr>
     <tr align="left">
        <th>$ sudo make install</th>
     </tr>
</tbody></table>



<p>Algumas observa&ccedil;&otilde;es sobre os flags usados na sequ&ecirc;ncia acima:</p>

<ul>
<li><code>--disable-newlib-supplied-syscalls</code>: isto merece uma p&aacute;gina pr&oacute;pria, mas n&atilde;o vou faz&ecirc;-lo aqui. Para uma explica&ccedil;&atilde;o, por exemplo, ver <a href="http://openhardware.net/Embedded_ARM/NewLib_Stubs/">esta p&aacute;gina</a></li>
<li><code>-DPREFER_SIZE_OVER_SPEED -D__OPTIMIZE_SIZE__</code>: compila Newlib otimizando o tamanho, n&atilde;o a performance (estes s&atilde;o espec&iacute;ficos da Newlib).</li>
<li><code>-Os -fomit-frame-pointer</code>: indica para GCC otimizar o tamnho, n&atilde;o a velocidade.</li>
<li><code>-D__BUFSIZ__=256</code>:
novamente espec&iacute;fico da Newlib, este &eacute; o tamanho default do buffer alocado para arquivos abertos via fopen(). O padr&atilde;o &eacute; 1024, cujo tamanho considerei muito para eLua, logo estou usando 256 aqui. Certamente, voc&ecirc; pode mudar este valor.</li>
</ul>


<h2>Passo 4: full GCC</h2>

<p>Finalmente, no &uacute;ltimo passo deste tutorial, completamos a constru&ccedil;&atilde;o do GCC. Nesta etapa, v&aacute;rias bibliotecas de suporte do compilador s&atilde;o montadas (sendo a mais importante a libgcc.a). Felizmente este &aacute; o mais simples dos passos de compila&ccedil;&atilde;o da NewLib:</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>Passo 5: Tudo pronto!</h2>

<p>
Agora voc&ecirc; pode finalmente desfrutar do seu toolchain para ARM, e compile eLua com ele :) Se voc&ecirc; precisar de mais explica&ccedil;&otilde;es, ou se as instru&ccedil;&otilde;es acima n&atilde;o funcionaram para voc&ecirc;, sinta-se a vontade para entrar em <a href="http://www.eluaproject.net/en/Contact">contato comigo.</a>.</p>
$$FOOTER$$