Howto Building GNU Toolchains

[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)