[REF: https://wiki.linaro.org/WorkingGroups/ToolChain/BuildingGNUToolchains]
This page is a work in progress.
The following topics are not yet explained (highest priority items at the top)
- building using a pre-existing sysroot
- setting default target architecture and default cpu tuning
- multilib
- multiarch
- *-unknown-elf-* configurations (newlib)
- building canadian cross
Introduction
Currently, only linux cross compilers are explained. Building a bare metal cross compiler is similar, but glibc is not used, and another C library (eg newlib) is used in its place.
To build a cross compiler without a pre-existing sysroot, the following process is followed:
- build binutils
- build a minimal GCC C compiler, which is suitable for building the C library
- install kernel header files
- build C library
- build a full GCC
Environment variables
Shell commands in following sections assume the following environment variables have been set up. These have no special meaning other than that they are used in the commands in this document.
Example values are shown
# configure the build
TRIPLET=arm-unknown-linux-gnueabi # or aarch64-unknown-linux-gnu
LINUX_ARCH=arm # use arm64 if building for an aarch64 target
CPUS=8 # set the number of CPUs for parallel builds
# set paths
WORK=$HOME/work
TOOLS_PATH=$HOME/tools
SYSROOT_PATH="$HOME/sysroot-$TRIPLET" # or path of existing sysroot if you are using a prebuilt one
GCC Configure options
Other gcc configure options may be selected. If building arm-unknown-linux-gnueabihf, then additional options are required to set the default behaviour of the compiler to use the hard float ABI:
The commands below use the GCC_CONF shell variable to set the additional configuration options
GCC_CONF="--with-arch=armv7-a --with-tune=cortex-a9 --with-fpu=vfpv3-d16 --with-float=hard"
This sets the default target architecture and tuning and hard floating point ABI.
Build dependencies
!!! TODO explain how to get and build gmp etc
Install gcc build dependencies, including but not limited to: gmp-devel libmpc-devel mpfr-devel flex byacc bison. With a recent Linux distribution, installing the provided packages may be sufficient (eg apt-get build-dep gcc)
Downloading sources
Source code for gcc, binutils and glibc may be obtained from your favourite place. I used:
!!! TODO link to tarballs of released versions here
It helps to download each of these into their own subdirectory, eg
WORK=$HOME/work
mkdir -p "$WORK/binutils" "$WORK/gcc" "$WORK/glibc/" "$WORK/kernel"
cd $WORK/binutils; git clone git://git.linaro.org/toolchain/binutils.git
cd $WORK/gcc; svn co svn://gcc.gnu.org/svn/gcc/branches/linaro/gcc-4_8-branch
cd "$WORK/glibc"; git clone git://git.linaro.org/toolchain/glibc.git)&
cd "$WORK/kernel"; git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
Building binutils
Binutils is configured for the target platform, and we specify the path to the sysroot, even though we haven't build the sysroot yet. This doesn't matter, as we won't do anything which needs the sysroot until we build the 2nd stage gcc.
cd "$WORK/binutils"
rm -Rf build
mkdir build
cd build
../binutils/configure --prefix=$TOOLS_PATH --target=$TRIPLET --with-sysroot=$SYSROOT_PATH
make -j${CPUS:-1}
make -j${CPUS:-1} install
Preparing a sysroot (eglibc or glibc)
If you have an existing sysroot, then you should extract it and set SYSROOT_PATH to point to it. You can then skip the remainder of this section.
If you don't have an existing sysroot, then you must build one. This is done with the following steps:
BUILDING 1ST STAGE GCC
The purpose of the 1st stage gcc is to create a minimal compiler which is capable of building glibc. A full build of gcc depends on the C library, but we can't build the C library until we have a C compiler, so we have to build this simplified compiler to break the circular dependency.
The important parts of the configure line are --enable-languages=c (we just need a C compiler for now, and will build other languages at stage 2) and --without-headers which configures the compiler so that it does not need the C library. --disable-threads is needed to work around a bug/problem which means the build process still looks for pthread.h even if --without-headers is used. A variety of other --disable-* options are used to disable other features which are not appropriate for a stage 1 compiler.
The configure and make steps have to be run with the binutils tools on the path, hence the PATH=... part of the command lines below.
cd "$WORK/gcc"
rm -Rf build
mkdir build
cd build
PATH=$TOOLS_PATH/bin:$PATH ../gcc-4_8-branch/configure --prefix=$TOOLS_PATH --enable-languages=c --without-headers --target=$TRIPLET --disable-libmudflap -disable-libatomic --disable-threads --disable-shared --enable-static --disable-decimal-float --disable-libgomp --disable-libitm --disable-libmudflap --disable-libquadmath --disable-libsanitizer --disable-libssp $GCC_CONF
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1}
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1} install
INSTALLING KERNEL HEADERS
Before we can build glibc, we need to install the Linux kernel headers. These define the ABI for the Linux syscalls which glibc uses. This step only needs to know which target platform and where to put the header files.
cd "$WORK/kernel/linux-2.6"
make headers_install ARCH=$LINUX_ARCH INSTALL_HDR_PATH=$SYSROOT_PATH/usr/
BUILDING GLIBC
When configuring glibc it is required to use --prefix=/usr, as this is handled specially in the build system, so that the correct linux filesystem layout is produced. (reference: http://www.eglibc.org/archives/patches/msg00078.html)
Other options are required so that the build finds the kernel headers we installed. !!! TODO explain difference between --host and --target
cd "$WORK/glibc"
rm -Rf build
mkdir build
cd build
# http://www.eglibc.org/archives/patches/msg00078.html
PATH=$TOOLS_PATH/bin:$PATH ../glibc/configure --prefix=/usr --build=x86_64-unknown-linux-gnu --host=$TRIPLET --target=$TRIPLET --with-headers=$SYSROOT_PATH/usr/include --includedir=/usr/include
Then we build and install glibc. Note that install_root must be set, as we set the prefix to /usr in the configure step, but we want to install into our new sysroot not into the system /usr directory.
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1}
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1} install install_root="$SYSROOT_PATH"
On aarch64, the make install step doesn't create a directory called /usr/lib inside the sysroot. However, if this directory doesn't exist, then gcc won't look for libraries in /usr/lib64, which means no program can be linked. (This causes libgcc to fail to build during the 2nd stage gcc compile, with "cannot find crti.o: No such file or directory")
mkdir -p "$SYSROOT_PATH/usr/lib"
Building 2nd stage gcc
Now, we can build the final gcc.
cd "$WORK/gcc"
rm -Rf build2
mkdir build2
cd build2
PATH=$TOOLS_PATH/bin:$PATH ../gcc-4_8-branch/configure --prefix=$TOOLS_PATH --enable-languages=c,c++,fortran --target=$TRIPLET --with-sysroot=$SYSROOT_PATH $GCC_CONF
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1}
PATH=$TOOLS_PATH/bin:$PATH make -j${CPUS:-1} install
Testing
You should now be able to use $TOOLS_PATH/bin/$TRIPLET-gcc to create new binaries.
!!! TODO how do we run make check on a cross compiler?
WorkingGroups/ToolChain/BuildingGNUToolchains (最后修改时间 2013-09-12 20:50:27)