Subversion Repositories openrisc_me

#!/bin/bash

# Copyright (C) 2009, 2010 Embecosm Limited

# Copyright (C) 2010 ORSoC AB

# Contributor Joern Rennecke <joern.rennecke@embecosm.com>

# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

# Contributor Julius Baxter <julius.baxter@orsoc.se>

# This file is a script to build key elements of the OpenRISC tool chain

# This program is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License as published by the Free

# Software Foundation; either version 3 of the License, or (at your option)

# any later version.

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

# more details.

# You should have received a copy of the GNU General Public License along

# with this program.  If not, see <http://www.gnu.org/licenses/>.

# ------------------------------------------------------------------------------

# This script builds two GNU C/C++ tool chains:

# 1. With target or32-elf (fully or32-unknown-elf-newlib) for use on bare

#    metal targets

# 2. With target or32-linux (fully or32-unknown-linux-uclibc) for use with

#    OpenRISC linux.

# In both cases the binutils, gcc and C/C++ libraries are built using a

# unified source directory created by linking the top level directories from

# binutils and gcc. For the first tool chain, newlib and libgloss are also

# linked into the unified source directory.

# GDB 7.2 does not have fully compatible binutils directories, so is built

# separately.

# For the or32-linux tool chain, the system headers are needed to bootstrap

# the building of libgcc. This is achieved by a 2 stage process

# 1. Configure, build and install gcc for C only for or32-linux using the host

#    system's headers, installing into a temporary prefix.

# 2. Clean the gcc build directory and reconfigure, build and install gcc for

#    C and C++ using the headers from the temporary prefix.

# Once this is complete, the Linux headers are installed and uClibc can be

# built.

# The following arguments control how the script runs:

# --force

#     Ensure the unified source directory and build directories are

#     recreated. Only build directories of targets being built are removed.

# --languages <str>

#     Specify the languages to be built (default c,c++).

# --prefix <dir>

#     Specify the install directory (default /opt/or32-new)

# --prefix-tmp <dir>

#     Specify the temporary install directory (default /tmp/or32-tmp-${USER}).

#     Incorporating the user name avoid name clashes with other users

# --unisrc-dir <dir>

#     Specify the unified source directory (default unisrc)

# --build-dir-elf <dir>

#     Specify the build directory for the newlib (or32-elf) tool chain

#     (default bd-elf).

# --build-dir-elf-gdb <dir>

#     Specify the build directory for the newlib (or32-elf) GDB (default

#     bd-elf-gdb).

# --build-dir-linux <dir>

#     Specify the build directory for the uClibc (or32-linux) tool chain

#     (default bd-linux)

# --build-dir-linux-gdb <dir>

#     Specify the build directory for the uClibc (or32-linux) GDB (default

#     bd-linux-gdb)

# --or1ksim-dir <dir>

#     Specify the Or1ksim installation directory. Used by GDB, which links in

#     the Or1ksim simulator (default /opt/or1ksim-new)

# --binutils-dir

#     Source directory for binutils (default binutils-2.20.1)

# --gcc-dir

#     Source directory for gcc (default gcc-4.5.1')

# --newlib-dir

#     Source directory for newlib (default newlib-1.18.0)

# --uclibc-dir

#     Source directory for uClibc (default uclibc-0.9.31)

# --gdb-dir

#     Source directory for gdb (default  gdb-7.2)

# --linux-dir

#     Source directory for Linux (default linux-2.6.35)

# --no-or32-elf

#     Don't configure, build and install the newlib (or32-elf) tool chain.

# --no-or32-linux

#     Don't configure, build and install the uClibc (or32-linux) tool chain.

# --nolink

#     Don't build the unified source directory (default is to build it)

# --noconfig

#     Don't run configure. Note that this will break the two stage build of

#     gcc for Linux, so it should only be used if at least one of the uClibc

#     stages is being omitted (default is to configure)

# --nobuild

#     Don't build any tools. Useful just to reinstall stuff (default is to

#     build).

# --check

#     Run DejaGnu tests using the or32-elf tool chain (default do not run).

# --noinstall

#     Don't run install. Beware that this will omit the installation of Linux

#     headers, required for uClibc building and the installation of headers

#     from stage1 of gcc for Linux, required for stage2 of gcc for Linux. So

#     only use if at least one of the uClibc stages is being omitted (default

#     is to install).

# --no-newlib

#     Don't build newlib (default is to build newlib)

# --no-uclibc

#     Don't build uClibc (default is to build uClibc)

# --no-uclibc-stage1

#     Don't do the stage1 build of gcc for Linux (default is to build stage1).

# --no-uclibc-stage2

#     Don't do the stage2 build of gcc for Linux (default is to build stage2).

# --make-load <number>

#     Set make load for make to <number>

# --help

#     List these options and exit

# In general global variables track each of these options. In addition the

# following global variables are used:

# target - the current target (or32-elf or or32-linux).

# ------------------------------------------------------------------------------

# Set the default values of all parameters

function set_defaults {

    # Public params

    force_flag="false"

    languages="c,c++"

    prefix="/opt/or32-new"

    prefix_tmp="/tmp/or32-tmp-${USER}"

    unisrc_dir="unisrc"

    bd_elf="bd-elf"

    bd_elf_gdb="bd-elf-gdb"

    bd_linux="bd-linux"

    bd_linux_gdb="bd-linux-gdb"

    or1ksim_dir="/opt/or1ksim-new"

    binutils_dir="binutils-2.20.1"

    gcc_dir="gcc-4.5.1"

    newlib_dir="newlib-1.18.0"

    uclibc_dir="uclibc-0.9.31"

    gdb_dir="gdb-7.2"

    linux_dir="linux-2.6.36"

    or32_elf_flag="true"

    or32_linux_flag="true"

    link_flag="true"

    config_flag="true"

    build_flag="true"

    check_flag="false"

    install_flag="true"

    newlib_flag="true"

    uclibc_flag="true"

    uclibc_stage1_flag="true"

    uclibc_stage2_flag="true"

    # Consequential params

    newlib_config="--with-newlib"

    newlib_build="all-target-newlib all-target-libgloss"

    newlib_check="check-target-newlib check-target-libgloss"

    newlib_install="install-target-newlib install-target-libgloss"

    # Determine how many processes to use in parallel building. If

    # /proc/cpuinfo is avaliable, limit load to launch extra jobs to number of

    # processors + 1. If /proc/cpuinfo is not available, we use a constant of

    # 2.

    make_n_jobs=`(echo processor;cat /proc/cpuinfo 2>/dev/null || \

        echo processor) | grep -c processor`

    make_load="-j $make_n_jobs -l $make_n_jobs"

    unset make_n_jobs

}       # set_defaults ()

# ------------------------------------------------------------------------------

# Parse the arguments

function parse_args {

    until

    opt=$1

    case ${opt}

        in

        --force)

            force_flag="true";

            ;;

        --languages)

            languages=$2;

            shift;

            ;;

        --prefix)

            prefix=$2;

            shift;

            ;;

        --prefix-tmp)

            prefix_tmp=$2;

            shift;

            ;;

        --unisrc_dir)

            unisrc_dir=$2;

            shift;

            ;;

        --bd-elf)

            bd_elf=$2;

            shift;

            ;;

        --bd-elf-gdb)

            bd_elf_gdb=$2;

            shift;

            ;;

        --bd-linux)

            bd_linux=$2;

            shift;

            ;;

        --bd-linux-gdb)

            bd_linux_gdb=$2;

            shift;

            ;;

        --or1ksim-dir)

            or1ksim_dir=$2;

            shift;

            ;;

        --binutils-dir)

            binutils_dir=$2;

            shift;

            ;;

        --gcc-dir)

            gcc_dir=$2;

            shift;

            ;;

        --newlib-dir)

            newlib_dir=$2;

            shift;

            ;;

        --uclibc-dir)

            uclibc_dir=$2;

            shift;

            ;;

        --gdb-dir)

            gdb_dir=$2;

            shift;

            ;;

        --linux-dir)

            linux_dir=$2;

            shift;

            ;;

        --no-or32-elf)

            or32_elf_flag="false"

            ;;

        --no-or32-linux)

            or32_linux_flag="false"

            ;;

        --nolink)

            link_flag="false";

            ;;

        --noconfig)

            config_flag="false";

            ;;

        --nobuild)

            build_flag="false";

            ;;

        --check)

            check_flag="true";

            ;;

        --noinstall)

            install_flag="false";

            ;;

        --no-newlib)

            newlib_flag="false";

            newlib_config="";

            newlib_build="";

            newlib_check="";

            newlib_install="";

            ;;

        --no-uclibc)

            uclibc_flag="false";

            ;;

        --no-uclibc-stage1)

            uclibc_stage1_flag="false";

            ;;

        --no-uclibc-stage2)

            uclibc_stage2_flag="false";

            ;;

        --make-load)

            make_load="-j $2 -l $2";

            shift;

            ;;

        --help)

            cat <<EOF;

--force

    Ensure the unified source directory and build directories are

    recreated. Only build directories of targets being built are removed.

--languages <str>

    Specify the languages to be built (default ${languages})

--prefix <dir>

    Specify the install directory (default ${prefix})

--prefix-tmp <dir>

    Specify the temporary install directory (default ${prefix_tmp})

    Incorporating the user name avoid name clashes with other users

--unisrc-dir <dir>

    Specify the unified source directory (default ${unisrc_dir})

--build-dir-elf <dir>

    Specify the build directory for the newlib (or32-elf) tool chain

    (default ${bd_elf}).

--build-dir-elf-gdb <dir>

    Specify the build directory for the newlib (or32-elf) GDB (default

    ${bd_elf_gdb}).

--build-dir-linux <dir>

    Specify the build directory for the uClibc (or32-linux) tool chain

    (default ${bd_linux})

--build-dir-linux-gdb <dir>

    Specify the build directory for the uClibc (or32-linux) GDB (default

    ${bd_linux_gdb})

--or1ksim-dir <dir>

    Specify the Or1ksim installation directory. Used by GDB, which links in

    the Or1ksim simulator (default ${or1ksim_dir})

--binutils-dir

    Source directory for binutils (default ${binutils_dir})

--gcc-dir

    Source directory for gcc (default ${gcc_dir})

--newlib-dir

    Source directory for newlib (default ${newlib_dir})

--uclibc-dir

    Source directory for uClibc (default ${uclibc_dir})

--gdb-dir

    Source directory for gdb (default  ${gdb_dir})

--linux-dir

    Source directory for Linux (default $linux_dir))

--no-or32-elf

    Don't configure, build and install the newlib (or32-elf) tool chain.

--no-or32-linux

    Don't configure, build and install the uClibc (or32-linux) tool chain.

--nolink

    Don't build the unified source directory (default is to build it)

--noconfig

    Don't run configure. Note that this will break the two stage build of

    gcc for Linux, so it should only be used if at least one of the uClibc

    stages is being omitted (default is to configure)

--nobuild

    Don't build any tools. Useful just to reinstall stuff (default is to

    build).

--check

    Run DejaGnu tests using the or32-elf tool chain (default do not run).

--noinstall

    Don't run install. Beware that this will omit the installation of Linux

    headers, required for uClibc building and the installation of headers

    from stage1 of gcc for Linux, required for stage2 of gcc for Linux. So

    only use if at least one of the uClibc stages is being omitted (default

    is to install).

--no-newlib

    Don't build newlib (default is to build newlib)

--no-uclibc

    Don't build uClibc (default is to build uClibc)

--no-uclibc-stage1

    Don't do the stage1 build of gcc for Linux (default is to build stage1).

--no-uclibc-stage2

    Don't do the stage2 build of gcc for Linux (default is to build stage2).

--make-load <num>

    Set make load passed with -j and -l options when calling make. Default

    is set to number of processors as detected via /proc/cpuinfo

--help

    List these options and exit

EOF

            exit 0

            ;;

        --*)

            echo "unrecognized option \"$1\""

            exit 1

            ;;

        *)

            opt=""

            ;;

    esac;

    [ -z "${opt}" ]

    do

        shift

    done

}       # parse_args

# ------------------------------------------------------------------------------

# Sanity check argument values

function sanity_check {

    # Check unified source directory is meaningful if we are linking and that

    # we can create it.

    if [ "true" == "${link_flag}" ]

    then

        # Is it meaninful

        case ${unisrc_dir}

            in

            "")

                unisrc_prefix='.'

                ;;

            */*)

                echo "/ in unified source directory not implemented"

                exit 1

                ;;

            *..*)

                echo ".. in unified source directory not implemented"

                exit 1

                ;;

            *)

                unisrc_prefix='..'

                ;;

        esac

        # Check it's a directory, and if it doesn't exist that we can create

        # it.

        if [ -n "${unisrc_dir}" ]

        then

            if [ ! -d ${unisrc_dir} ]

            then

                if [ -e ${unisrc_dir} ]

                then

                    echo "${unisrc_dir} is not a directory";

                    exit 1

                fi

                mkdir ${unisrc_dir}

            fi

        fi

    fi

}       # sanity_check

# ------------------------------------------------------------------------------

# Conditionally build the unified source directory. We know by now it's a

# viable and extant directory.

function link_unified {

    if [ "true" == "${link_flag}" ]

    then

        mkdir -p ${unisrc_dir}

        cd ${unisrc_dir}

        ignore_list=". .. CVS .svn"

        component_dirs="${binutils_dir} ${gcc_dir} ${newlib_dir}"

        for srcdir in ${component_dirs}

        do

            echo "Component: $srcdir"

            case srcdir

                in

                /* | [A-Za-z]:[\\/]*)

                    ;;

                *)

                    srcdir="${unisrc_prefix}/${srcdir}"

                    ;;

            esac

            files=`ls -a ${srcdir}`

            for f in ${files}

            do

                found=

                for i in ${ignore_list}

                do

                    if [ "$f" = "$i" ]

                    then

                        found=yes

                    fi

                done

                if [ -z "${found}" ]

                then

                    echo "$f            ..linked"

                    ln -s ${srcdir}/$f .

                fi

            done

            ignore_list="${ignore_list} ${files}"

        done

        if [ $? != 0 ]

        then

            echo "failed to create ${unisrc_dir}"

            exit 1

        fi

        unset component_dirs

        unset ignore_list

        cd -

    fi

}       # link_unified

# ------------------------------------------------------------------------------

# Conditionally configure a GNU source directory (could be the unified

# directory, or GDB)

# @param[in] $1       "true" if we should execute this function

# @param[in] $2       The prefix to use for installation.

# @param[in] $3       The build directory to configure in.

# @param[in] $4       The source directory containing configure (relative to $1)

# @param[in] $5       The languages to configure for.

# @param[in] $6, ...  Additional configure args.

function gnu_config {

    cond=$1

    shift

    if [ "true" == ${cond} ]

    then

        this_prefix=$1

        shift

        top_builddir=$1

        shift

        top_srcdir=$1

        shift

        langs=$1

        shift

        echo -n "bld-all.sh: gnu_config ${this_prefix} ${top_builddir} "

        echo    "${top_srcdir} ${langs} $*"

        verstr="OpenRISC 32-bit toolchain for ${target} (built `date +%Y%m%d`)"

        mkdir -p ${top_builddir} &&                                   \

            cd ${top_builddir} &&                                     \

            ${top_srcdir}/configure --target=${target}                \

                --with-pkgversion="${verstr}" --disable-shared        \

                --with-bugurl=http://www.opencores.org/               \

                --with-or1ksim=${or1ksim_dir}                         \

                --enable-fast-install=N/A --disable-libssp            \

                --enable-languages=${langs} --prefix=${this_prefix} $*

        if [ $? != 0 ]

        then

            echo "configure failed."

            exit 1

        fi

        cd -

        unset verstr

        unset langs

        unset top_srcdir

        unset top_builddir

        unset this_prefix

    fi

    unset cond

}       # gnu_config

# ------------------------------------------------------------------------------

# Conditionally run make and check the result.

# @param[in] $1       "true" if we should execute this function

# @param[in] $2      The build directory to make in

# @param[in] $3, ... The targets to make

function gnu_make {

    cond=$1

    shift

    if [ "true" == ${cond} ]

    then

        echo "bld-all.sh: gnu_make $*"

        cd $1

        shift

        make $make_load $*

        if [ $? != 0 ]

        then

            echo "make ($*) failed."

            exit 1

        fi

        cd -

    fi

    unset cond

}       # gnu_make

# ------------------------------------------------------------------------------

# Conditionally configure and install the Linux headers

# @param[in] $1       The prefix to use for installation.

function install_linux_headers {

    this_prefix=$1

    cd $linux_dir

    if [ "true" == "${config_flag}" ]

    then

        echo "bld-all.sh: Configuring Linux headers"

        make ARCH=openrisc defconfig

        if [ $? != 0 ];

        then

            echo "Linux configure failed"

            exit 1

        fi

    fi

    # This is a bit iffy. We do rely on the headers being installed for uClibc

    # to build, so not installing the first time would be a bit dodgy.

    if [ "true" == "${install_flag}" ]

    then

        echo "bld-all.sh: Installing Linux headers"

        make INSTALL_HDR_PATH=${this_prefix}/or32-linux headers_install

        if [ $? != 0 ];

        then

            echo "Linux header installation failed"

            exit 1

        fi

        unset this_prefix

    fi

    cd -

}       # install_linux_headers

# ------------------------------------------------------------------------------

# Conditionally configure uClibc. Clean before configuring.

# @param[in] $1       The prefix to use for installation.

function uclibc_config {

    if [ "true" == "${config_flag}" ]

    then

        this_prefix=$1

        echo "bld-all.sh: Configuring uClibc"

        cd ${uclibc_dir}

        kheaders="KERNEL_HEADERS=\\\"${this_prefix}\\/or32-linux\\/include\\\""

        devprefix="DEVEL_PREFIX=\\\"${this_prefix}\\/or32-linux\\\""

        ccprefix="CROSS_COMPILER_PREFIX=\\\"or32-linux-\\\""

        sed -i extra/Configs/defconfigs/or32     \

            -e "s|KERNEL_HEADERS.*|${kheaders}|g"  \

            -e "s|DEVEL_PREFIX.*|${devprefix}|g" \

            -e "s|CROSS_COMPILER_PREFIX.*|${ccprefix}|g"

        if [ $? != 0 ];

        then

            echo "uClibc sed failed"

            exit 1

        fi

        make ARCH=or32 clean

        if [ $? != 0 ];

        then

            echo "uClibc clean failed"

            exit 1

        fi

        make ARCH=or32 defconfig

        if [ $? != 0 ];

        then

            echo "uClibc configure failed"

            exit 1

        fi

        unset this_prefix

        unset ccprefix

        unset devprefix

        unset kheaders

        cd -

    fi

}       # uclibc_config

# ------------------------------------------------------------------------------

# Conditionally build and install uClibc

function uclibc_build_install {

    cd ${uclibc_dir}

    if [ "true" == "${build_flag}" ]

    then

        echo "bld-all.sh: Building uClibc"

        make ARCH=or32 all

        if [ $? != 0 ];

        then

            echo "uClibc build failed"

            exit 1

        fi

    fi

    if [ "true" == "${install_flag}" ]

    then

        echo "bld-all.sh: Installing uClibc"

        make ARCH=or32 install

        if [ $? != 0 ];

        then

            echo "uClibc install failed"

            exit 1

        fi

    fi

    cd -

}       # uclibc_build_install

# ------------------------------------------------------------------------------

# Main program

set_defaults

parse_args $*

sanity_check

# --force always blows away the link directory. It only blows away build

# directories we are actually building (see below).

if [ "true" == "${force_flag}" ]

then

    echo "bld-all.sh: removing ${unisrc_dir}"

    rm -rf ${unisrc_dir}

fi

link_unified

# Build the newlib (or32-elf) tool chain.

if [ "true" == "${or32_elf_flag}" ]

then

    target="or32-elf"

    echo "bld-all.sh: or32-elf toolchain"

    # --force only applies to build directories we are using!

    if [ "true" == "${force_flag}" ]

    then

        echo "bld-all.sh: removing ${bd_elf} ${bd_elf_gdb}"

        rm -rf ${bd_elf} ${bd_elf_gdb}

    fi

    # Configure all

    gnu_config ${config_flag} ${prefix} ${bd_elf} ../${unisrc_dir} \

        "${languages}" "${newlib_config}"

    gnu_config ${config_flag} ${prefix} ${bd_elf_gdb} ../${gdb_dir} \

        "${languages}"

    # Build all

    gnu_make ${build_flag} ${bd_elf} all-build all-binutils all-gas all-ld

    gnu_make ${build_flag} ${bd_elf} all-gcc

    gnu_make ${build_flag} ${bd_elf} all-target-libgcc all-target-libstdc++-v3 \

        ${newlib_build}

    gnu_make ${build_flag} ${bd_elf_gdb} all-build all-sim all-gdb

    # Check all

    gnu_make ${check_flag} ${bd_elf} check-binutils check-gas check-ld \

        check-gcc check-target-libgcc check-target-libstdc++-v3 ${newlib_check}

    gnu_make ${check_flag} ${bd_elf_gdb} check-sim check-gdb

    # Install all

    gnu_make ${install_flag} ${bd_elf} install-binutils install-gas install-ld \

        install-gcc install-target-libgcc install-target-libstdc++-v3 \

        ${newlib_install}

    gnu_make ${install_flag} ${bd_elf_gdb} install-sim install-gdb

fi

# Build the uClibc (or32-linux) tool chain

if [ "true" == "${or32_linux_flag}" ]

then

    target="or32-linux"

    echo "bld-all.sh: or32-linux toolchain"

    # --force only applies to build directories we are using!

    if [ "true" == "${force_flag}" ]

    then

        echo "bld-all.sh: removing ${bd_linux} ${bd_linux_gdb}"

        rm -rf ${bd_linux} ${bd_linux_gdb}

    fi

    # Stage 1 binutils/GCC build uses no headers and only C

    # language. This is just to create the libc headers, which we put in the

    # temporary prefix directory.

    if [ "true" == "${uclibc_stage1_flag}" ]

    then

        echo "bld-all.sh: uClibc GCC stage 1"

        # Make a clean temporary install directory.

        rm -rf ${prefix_tmp}

        mkdir ${prefix_tmp}

        # For header building we use just single threads, or we don't find

        # pthread.h.

        thread_config="--enable-threads=single --disable-tls"

        # To create the headers we only use C

        gnu_config ${config_flag} ${prefix_tmp} ${bd_linux} ../${unisrc_dir} \

            "c" "--without-headers ${thread_config}"

        gnu_make ${build_flag} ${bd_linux} all-build all-binutils all-gas all-ld

        gnu_make ${build_flag} ${bd_linux} all-gcc

        gnu_make ${build_flag} ${bd_linux} all-target-libgcc

        gnu_make ${install_flag} ${bd_linux} install-binutils install-gas \

            install-ld

        gnu_make ${install_flag} ${bd_linux} install-gcc install-target-libgcc

        # Create the headers using our temporary tool chain

        save_path="${PATH}"

        export PATH="${prefix_tmp}/bin:${PATH}"

        install_linux_headers ${prefix_tmp}

        uclibc_config ${prefix_tmp}

        uclibc_build_install

        PATH="${save_path}"

        unset save_path

    fi

    # If we are doing both stage 1 and stage 2, then we need to completely

    # clean gcc and target libraries. Just blow the entire directory away.

    if [ "truetrue" == "${uclibc_stage1_flag}${uclibc_stage2_flag}" ]

    then

        echo "bld-all.sh: uClibc GCC inter-stage cleaning"

        rm -rf ${bd_linux}/gcc ${bd_linux}/or32-linux

    fi

    # Stage 2 GCC uses the headers installed from stage 1.

    if [ "true" == "${uclibc_stage2_flag}" ]

    then

        echo "bld-all.sh: uClibc GCC stage 2"