Building ARM GNU Cross compiler

Question

Un post simile (meno descrittivo) è here.

Sto provando a rollare la mia catena di strumenti utilizzando le versioni recenti di Ubuntu e speravo che ci fosse abbastanza di una comunità Linux qui che avrei potuto ottenere consigli specifici su alcuni problemi che si presentano.

Con l'aiuto di tutti mi piacerebbe vedere questa svolta in un utile riferimento alla fine.

Prima di tutto "Crosstool" a cui quasi tutti si riferiscono è un po '(2006) obsoleto e "Crosstool-NG" che sembra ora sta portando la torcia non riesce sulla mia macchina. Preferisco eseguire il debug del processo stesso piuttosto che uno script (che sembrerebbe richiedere che io capisca il processo).

Di seguito sono riportati i passaggi di base su ciò che ho lavorato finora; al momento sono bloccato cercando di compilare il primo passaggio GCC.

dove è mancato ...

E 'in mancanza perché la croce compilato libreria contenente "crti.o" manca:

# ./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 

istruzioni di generazione

On un'installazione di Ubuntu 9.04 configurata "appena", ecco i passi che ho fatto fino ad ora:

#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

Questo era un po 'di aringa rossa. Apparentemente il cross-compling di una catena di strumenti per un sistema esistente con un GLIBC funzionante non richiede la ricompilazione di GLIBC. Onestamente non so come ho ignorato questo fatto.

Quindi, anche se io ancora non so come attraversare compilare GCC e GLIBC, come ho solo bisogno di GCC ho intenzione di celebrare questo come chiuso.

Se posso, tornerò su questo post e segnerò ciò che alla fine ho fatto.

EDIT:

Checkout this.

Answer 2

Se sei veramente vuole costruire tutta la toolchain per te:
http://frank.harvard.edu/~coldwell/toolchain/
http://ftp.snapgear.org/pub/snapgear/tools/arm-linux/build-arm-linux-3.4.4
Prendere in mente, anche se, come si dovrebbe cercare di matrice compatibilità toolchain o si può incorrere in errori di compilazione strani.

Se avete ancora la possibilità per CrossTool-ng, questo è quello che sto stavo lavorando per ultimi giorni:
http://blog.stranadurakov.com/2009/08/04/how-to-arm-linux/
Qui troverete il mio file di configurazione CrossTool-ng, che aveva lavorato per me .

Answer 3

Ecco lo script di installazione di toolchain arm-32 HelenOS, questo dovrebbe fare ciò che si desidera con pochissimo giochetto. Lo sto usando su Ubuntu ora (sono uno degli sviluppatori di HelenOS). È stato scritto da 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." 

Ci scusiamo per qualsiasi linea di avvolgimento, dovrebbe essere facile da risolvere. Se vuoi un collegamento pastebin o http per averlo, lascia un commento.

Answer 4

Ho recentemente creato una toolchain GNU per ARM utilizzando crosstool-ng. C'è voluto un po 'di tentativi ed errori per capire quali versioni dei componenti toolchain sarebbe bello giocare insieme, ma finalmente ho potuto farlo funzionare con le seguenti versioni:

• binutils 2.19.1
• gcc 4.3.2
• gmp 4.2.2
• kernel Linux 2.6.29.1
• MPFR 2.3.1
• uClibc 0.9.30.1

vedere se questi lavori anche per te.

Inoltre, OpenWrt come parte del processo di generazione crea una toolchain di compenetrazione incrociata. Potresti provare questo, selezionando una delle schede basate su ARM come destinazione, anche se non sei interessato a creare un router wireless.

Answer 5

Ho avuto fortuna utilizzando buildroot per creare toolchain e librerie per la compilazione incrociata di Linux. Buildroot utilizza la libreria C uclibc leggera piuttosto che glibc, quindi potrebbe non funzionare per i propri scopi. (E ottenere la toolchain in questo modo potrebbe non essere altrettanto eccitante e compilarlo da solo.)

Answer 6

Benvenuto, non sei solo.

La storia

Non so il motivo per cui ARM cross-compiling è un tale incubo. Non è il mio parere, vediamo, quello che gli altri dicono ...

Costruire un gcc/glibc cross-toolchain per l'impiego in sistemi embedded sviluppo usato per essere una spaventosa prospettiva, che richiede volontà di ferro, giorni se non settimane di sforzi, un sacco di conoscenze su Unix e Gnu, e a volte la disponibilità a prendere scorciatoie dubbia. (http://www.kegel.com/crosstool/)

Il mio computer ARM (GuruPlug) è in esecuzione su Debian, quindi ho solo bisogno di un compilatore standard G ++, senza ritocchi.

Io uso Ubuntu a 32 bit sul mio notebook. Ci sono pacchetti deb per cross-compiler AVR, o anche per Z80, ma nessuno per ARM - perché? OK, dobbiamo compilare uno. Andiamo. Il processo di compilazione della toolchain è un po 'confuso per me. Lungo 14k linee Makefile, grazie.

Dopo alcuni giorni (e notti) ho fallito.

La soluzione

Infine, ho trovato un soluion out-of-box. Ho appena scaricato la versione lite di questa roba: http://www.codesourcery.com/sgpp/lite_edition.html e ora sono felice. Ha un brutto programma di installazione, ma funziona.Dice: arm-none-linux-gnueabi-g ++ (Sourcery G ++ Lite 2010q1-202) 4.4.1, che è una versione aggiornata di G ++.

(Il mio amico ha un Mac, e lui ha anche omesso di compilare il toolchain dopo aver combattuto con lui per una settimana. Si sta ora utilizzando questo compilatore su una macchina virtuale in esecuzione Ubuntu.)

Answer 7

si dovrebbe davvero hanno messo più sforzo con l'utilizzo di crosstool-NG, dal momento che la mailing list crosstool è molto reattiva. Dal momento che la comprensione dell'intero processo è un compito enorme, capire come utilizzare uno strumento che potresti riutilizzare è IMHO più interessante.