compilador edifício ARM GNU Cruz

Question

A similiar (menos descritiva) post é aqui .

Eu estou tentando fazer a minha própria cadeia de ferramentas usando lançamentos recentes sobre Ubuntu e estava esperando que houvesse o suficiente de uma comunidade Linux aqui que eu pudesse obter conselhos específicos sobre determinados problemas que vão aparecendo.

Com a ajuda de todos que eu gostaria de ver neste turno em uma referência útil eventualmente.

Primeiro off " Crosstool " ao qual quase todos se referem é um pouco (2006) fora da data e " Crosstool-NG ", que parece agora estar carregando a tocha falhar na minha máquina. Eu prefiro depurar o processo em si do que um script (que parece me obriga a compreender o processo).

A seguir estão os passos básicos do que eu tenho funcionando até agora; No momento eu estou preso tentando compilar o primeiro GCC passagem.

Onde está falhando ...

Ele está falhando porque a biblioteca compilada cruz contendo "crti.o" está faltando:

# ./gcc-4.4.1/configure --target=arm-linux --disable-thread --enable-langauges=c 
/bin/bash ../../../gcc-4.4.1/libgcc/../mkinstalldirs .
/usr/src/gnu-4.4.1-build/./gcc/xgcc -B ........
/usr/local/arm-linux/bin/ld: crti.o No such file: No such file or directory
collect2: ld returned 1 exit status
make[2]: *** [libgcc_s.so] Error 1
make[2]: Leaving directory `/usr/src/gnu/gcc-4.4.1-build/arm-linux/libgcc'
make[1]: *** [all-target-libgcc] Error 2
make[1]: Leaving directory `/usr/src/gnu/gcc-4.4.1-build'
make: *** [all] Error 2

etapas de construção

Em uma instalação 'fresco' configurado Ubuntu 9.04, aqui estão os passos que eu fiz até agora:

#New configuration of Ubuntu 9.04
sudo updatedb
sudo apt-get install build-essential subversion
# For kernel configuration
sudo apt-get install libncurses5-dev
# For building GCC
sudo apt-get install libgmp3-dev libmpfr-dev

#Get Linux Headers for GCC/GLIBC compilations
# I use a hacked Linux from Artilla, 
pushd ~ && svn co http://.../linux m501-linux && cd !$
make ARCH=arm m501_defconfig
make ARCH=arm menuconfig
sudo mkdir /usr/local/arm-linux/include
sudo cp -dR include/asm-arm /usr/local/arm-linux/include/asm
sudo cp -dR include/linux /usr/local/arm-linux/include/linux
cd /usr/local/arm-linux/
sudo ln -s include sys-include
popd

#Get sources:
cd /usr/src/
sudo su root
mkdir gnu
ftp ftp.gnu.org
# get gnu/binutils/binutils-2.19.1.tar.bz2
# get gnu/gcc/gcc-4.4.1/gcc-4.4.1.tar.bz2
# get gnu/glibc/glibc-2.10.1.tar.bz2
# get gnu/gdb/gdb-6.8.tar.bz2

#Build Binutils
bzcat binutils-2.19.1.tar.bz2 | tar -xv
mkdir binutils-2.19.1-build && cd !$
cp ../binutils-2.19.1/gas/config/tc-arm.c ./tc-arm.c 
sed -r 's/(as_bad[ \t]*\()(.+\[.+\]\))/\1\"%s\",\2/' < ./tc-arm.c > ../binutils-2.19.1/gas/config/tc-arm.c 
rm ./tc-arm.c    
../binutils-2.19.1/configure --target=arm-linux
make && make install && cd ..

#Build GCC
bzcat gcc-4.4.1.tar.bz2 | tar -xv
mkdir gcc-4.4.1-build && cd !$
../gcc-4.4.1/configure --target=arm-linux --disable-thread --enable-langauges=c -with-headers=/usr/local/arm-linux/include
make

Answer 1

Este foi um pouco de vermelho-arenque. Aparentemente cross-compling uma cadeia de ferramenta para um sistema existente com um GLIBC trabalho não requer a recompilação de glibc. Eu honestamente não sei como eu ignorado este fato.

Assim, embora eu ainda não sei como atravessar GCC compilação e GLIBC, como eu só precisa GCC Vou marcar este como fechada.

Se eu puder, eu vou voltar a este post e marca o que eu finalmente fez.

EDIT:

este .

Answer 2

Welcome , você não está sozinho.

A história

Eu não sei porque ARM compilação cruzada é um pesadelo. Não é a minha opinião, vamos ver, o que os outros dizem ...

A construção de uma gcc / glibc cross-toolchain para uso em sistemas embarcados desenvolvimento costumava ser um assustador perspectiva, exigindo vontade de ferro, dias se não semanas de esforço, muita Unix e Gnu Lore, e às vezes vontade de tomar atalhos desonestos. ( http://www.kegel.com/crosstool/ )

Meu computador ARM (GuruPlug) está em execução no Debian, então eu só preciso de um compilador padrão G ++, sem quaisquer ajustes.

Eu estou usando 32-bit Ubuntu no meu notebook. Há pacotes deb para AVR cross-compilador, ou mesmo para Z80, mas nenhum para ARM - por quê? OK, temos que compilar um. Vamos. O processo de compilação do conjunto de ferramentas é um pouco confuso para mim. 14k longas filas Makefile, obrigado.

Depois de alguns dias (e noites) eu falhei.

A solução

Finalmente, eu encontrei um soluion out-of-the box. I acabou de baixar a edição Lite deste material: http://www.codesourcery.com/ sgpp / lite_edition.html e agora estou feliz. Ele tem um instalador feio, mas funciona. Diz: braço-nenhum-linux-gnueabi-g ++ (Sourcery G ++ Lite 2010q1-202) 4.4.1 , que é uma versão up-to-date G ++.

(Meu amigo tem um Mac, e ele também não conseguiu compilar o conjunto de ferramentas depois de lutar com ele por uma semana. Ele agora está usando este compilador em uma máquina virtual rodando Ubuntu.)

Answer 3

Você realmente deve ter feito um maior esforço com o uso crosstool-NG, uma vez que a lista crosstool de discussão é muito reativo. Desde a compreensão de todo o processo é uma tarefa enorme, a compreensão de como usar uma ferramenta que você pode reutilizar é IMHO mais interessante.

Answer 4

Aqui está a href="http://helenos.org" rel="nofollow script de instalação helenos braço-32 toolchain, isso deve fazer o que quiser com muito pouco mexer. Eu estou usando-o no Ubuntu agora (eu sou um dos desenvolvedores helenos). Ele foi escrito por Martin Decky:

#!/bin/bash

# Cross-Compiler Toolchain for ${PLATFORM}
#  by Martin Decky <martin@decky.cz>
#
#  GPL'ed, copyleft
#


check_error() {
    if [ "$1" -ne "0" ]; then
        echo
        echo "Script failed: $2"
        exit
    fi
}

if [ -z "${CROSS_PREFIX}" ] ; then
    CROSS_PREFIX="/usr/local"
fi

BINUTILS_VERSION="2.19.1"
GCC_VERSION="4.3.3"

BINUTILS="binutils-${BINUTILS_VERSION}.tar.gz"
GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
GCC_CPP="gcc-g++-${GCC_VERSION}.tar.bz2"

BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"

PLATFORM="arm"
WORKDIR=`pwd`
TARGET="${PLATFORM}-linux-gnu"
PREFIX="${CROSS_PREFIX}/${PLATFORM}"
BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
OBJDIR="${WORKDIR}/gcc-obj"

echo ">>> Downloading tarballs"

if [ ! -f "${BINUTILS}" ]; then
    wget -c "${BINUTILS_SOURCE}${BINUTILS}"
    check_error $? "Error downloading binutils."
fi
if [ ! -f "${GCC_CORE}" ]; then
    wget -c "${GCC_SOURCE}${GCC_CORE}"
    check_error $? "Error downloading GCC Core."
fi
if [ ! -f "${GCC_OBJC}" ]; then
    wget -c "${GCC_SOURCE}${GCC_OBJC}"
    check_error $? "Error downloading GCC Objective C."
fi
if [ ! -f "${GCC_CPP}" ]; then
    wget -c "${GCC_SOURCE}${GCC_CPP}"
    check_error $? "Error downloading GCC C++."
fi

echo ">>> Creating destionation directory"
if [ ! -d "${PREFIX}" ]; then
    mkdir -p "${PREFIX}"
    test -d "${PREFIX}"
    check_error $? "Unable to create ${PREFIX}."
fi

echo ">>> Creating GCC work directory"
if [ ! -d "${OBJDIR}" ]; then
    mkdir -p "${OBJDIR}"
    test -d "${OBJDIR}"
    check_error $? "Unable to create ${OBJDIR}."
fi

echo ">>> Unpacking tarballs"
tar -xvzf "${BINUTILS}"
check_error $? "Error unpacking binutils."
tar -xvjf "${GCC_CORE}"
check_error $? "Error unpacking GCC Core."
tar -xvjf "${GCC_OBJC}"
check_error $? "Error unpacking GCC Objective C."
tar -xvjf "${GCC_CPP}"
check_error $? "Error unpacking GCC C++."

echo ">>> Compiling and installing binutils"
cd "${BINUTILSDIR}"
check_error $? "Change directory failed."
./configure "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" "--disable-nls"
check_error $? "Error configuring binutils."
make all install
check_error $? "Error compiling/installing binutils."

echo ">>> Compiling and installing GCC"
cd "${OBJDIR}"
check_error $? "Change directory failed."
"${GCCDIR}/configure" "--target=${TARGET}" "--prefix=${PREFIX}" "--program-prefix=${TARGET}-" --with-gnu-as --with-gnu-ld --disable-nls --disable-threads --enable-languages=c,objc,c++,obj-c++ --disable-multilib --disable-libgcj --without-headers --disable-shared
check_error $? "Error configuring GCC."
PATH="${PATH}:${PREFIX}/bin" make all-gcc install-gcc
check_error $? "Error compiling/installing GCC."

echo
echo ">>> Cross-compiler for ${TARGET} installed."

Desculpe por qualquer quebra de linha, deve ser fácil de corrigir. Se você quer um pastebin ou http link para obtê-lo, basta deixar um comentário.

Answer 5

Se você está realmente deseja construir toda toolchain para si mesmo:
http://frank.harvard.edu/~coldwell/toolchain/
http: //ftp.snapgear. org / pub / SnapGear / ferramentas / braço-linux / build-braço-linux-3.4.4
Tome-se, porém, como você deve procurar toolchain compatibilty matriz ou você pode executar em erros de compilação estranhos.

Se você ainda tem a opção para crosstool-ng, é isso que eu estou estava trabalhando para últimos dias:
http://blog.stranadurakov.com/2009/08 / 04 / how-to-braço-linux /
Aqui você vai encontrar o meu arquivo de configuração-ng crosstool, que tinha trabalhado para mim.

Answer 6

Eu recentemente construído um conjunto de ferramentas GNU para ARM usando crosstool-ng. Demorou um pouco de tentativa e erro para descobrir quais versões dos componentes toolchain iria jogar bonito juntos, mas eu finalmente tenho que trabalhar com as seguintes versões:

• binutils 2.19.1
• gcc 4.3.2
• gmp 4.2.2
• Linux Kernel 2.6.29.1
• mpfr 2.3.1
• uClibc 0.9.30.1

Veja se esses trabalhos para você também.

Além disso, OpenWrt como uma parte dela do processo de compilação cria um conjunto de ferramentas cross-compilação. Você pode querer tentar isso, a seleção de uma das placas baseados em ARM como um alvo, mesmo se você não está interessado em fazer um roteador sem fio.

Answer 7

Eu tive sorte usando BuildRoot para toolchains construção e bibliotecas para Linux cross-compilação. Buildroot usa a biblioteca leve uClibc C em vez de glibc, por isso não pode funcionar para seus propósitos. (E ficando o conjunto de ferramentas desta forma pode não ser tão emocionante e compilá-lo você mesmo.)