compilatore costruzione ARM GNU Croce

Question

Un simile (meno descrittivo) post è qui .

Sto cercando di rotolare il mio tool chain usando recenti uscite su Ubuntu e speravo ci fosse abbastanza di una comunità Linux qui che ho potuto ottenere consigli specifici su alcuni problemi come si presentano.

Con l'aiuto di tutti quelli che piacerebbe vedere in questo turno in un utile riferimento alla fine.

Prima di tutto " CrossTool " per cui quasi tutti si riferisce è un po '(2006) di data e " CrossTool-NG ", che sembra ora essere che porta la torcia non riesce sulla mia macchina. Preferirei il debug del processo stesso di uno script (che sembrerebbe richiede me per capire il processo).

Di seguito sono passaggi fondamentali di quello che ho a lavorare fino ad ora; al momento mi sono bloccato cercando di compilare il primo passaggio di GCC.

dove è mancato ...

E 'venendo a mancare perché la libreria multi compilato contenente "crti.o" è mancante:

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

Crea passaggi

In un'installazione di Ubuntu 9.04 'fresco' configurato, qui sono i passi che ho fatto finora:

#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

Questa è stata un po 'di rosso-aringhe. Apparentemente trasversale compling una catena strumento per un sistema esistente con un GLIBC di lavoro non richiede la ricompilazione di glibc. Onestamente non so come ho ignorato questo fatto.

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

Se posso, tornerò a questo post e segnare quello che alla fine ho fatto.

EDIT:

questo .

Answer 2

Welcome , non siete soli.

La storia

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

  

Costruire un gcc / glibc cross-toolchain   per l'impiego in sistemi embedded   sviluppo usato per essere uno spaventoso   prospettiva, richiede ferro volontà, se giorni   non settimane di sforzi, un sacco di Unix e   Gnu lore, e qualche volta la volontà di   prendere scorciatoie ingannevoli. ( 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.

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

Dopo alcuni giorni (e notti) Ho fallito.

La soluzione

Infine, ho trovato un soluion out-of-box. Ho appena scaricato l'edizione 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: braccio-nessuno-linux-gnueabi-g ++ (Sourcery G ++ Lite 2010q1-202) 4.4.1 , che è una versione up-to-date 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 3

Si dovrebbe davvero avete messo più impegno con l'utilizzo di CrossTool-NG, dal momento che il CrossTool mailing list è molto reattivo. Dal momento che la comprensione l'intero processo è un compito enorme, capire come utilizzare uno strumento che si potrebbe riutilizzare è IMHO più interessante.

Answer 4

Questa è la href="http://helenos.org" rel="nofollow noreferrer"> braccio-32 script di installazione toolchain, questo dovrebbe fare quello che vuoi con poco giocherellare. Lo sto usando su Ubuntu ora (io sono uno degli sviluppatori 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 confezionamento, dovrebbe essere facile da risolvere. Se si desidera un collegamento pastebin o http per farlo, basta lasciare un commento.

Answer 5

Se siete 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 6

Recentemente ho costruito un 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 una parte di esso è processo di generazione crea una toolchain di cross-compilazione. Si consiglia di provare che, selezionando una delle schede ARM-based come un bersaglio, anche se non siete interessati a fare un router wireless.

Answer 7

Ho avuto la fortuna utilizzando buildroot per costruire toolchain e librerie per il cross-compilazione Linux. Buildroot utilizza la libreria leggero uClibc C piuttosto che glibc, quindi potrebbe non funzionare per i vostri scopi. (E ricevendo il toolchain in questo modo potrebbe non essere altrettanto eccitante e compilare da soli.)