brain-hackers_pepepper-mirror
/
cegcc-build
mirror of https://github.com/brain-hackers/cegcc-build.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
cegcc-build/build.sh

505 lines
12 KiB
Bash
Executable File
Raw Permalink Blame History

#! /usr/bin/env bash
set -e
BASE_DIRECTORY=`dirname $0`
BASE_DIRECTORY=`(cd ${BASE_DIRECTORY}; pwd)`
ME=`basename $0`
# FIXME: some components need this (mingwdll), but they shouldn't.
export BASE_DIRECTORY
#
# Initializations.
#
export BUILD_DIR=`pwd`
ac_default_prefix="/opt/cegcc"
# The list of components, in build order. There's a build_FOO
# function for each of these components
COMPONENTS=( binutils bootstrap_gcc mingw w32api gcc )
#profile docs
COMPONENTS_NUM=${#COMPONENTS[*]}
# Build comma separated list of components, for user display.
for ((i=0;i<$COMPONENTS_NUM;i++)); do
if [ $i = 0 ]; then
COMPONENTS_COMMA_LIST=${COMPONENTS[${i}]}
else
COMPONENTS_COMMA_LIST="${COMPONENTS_COMMA_LIST}, ${COMPONENTS[${i}]}"
fi
done
usage()
{
cat << _ACEOF
$ME builds the mingw32ce toolchain.
Usage: $0 [OPTIONS] ...
-h, --help print this help, then exit
--prefix=PREFIX install toolchain in PREFIX
[$ac_default_prefix]
--host=HOST host on which the toolchain will run [BUILD]
--target=TARGET configure for building compilers for TARGET [arm-mingw32ce]
-j, --parallelism PARALLELISM Pass PARALLELISM as -jPARALLELISM
to make invocations.
--components=LIST specify which components to build
valid components are: ${COMPONENTS_COMMA_LIST}
[all]
--incremental do an incremental build
Report bugs to <cegcc-devel@lists.sourceforge.net>.
_ACEOF
}
ac_prev=
for ac_option
do
# If the previous option needs an argument, assign it.
if test -n "$ac_prev"; then
eval "$ac_prev=\$ac_option"
ac_prev=
continue
fi
ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)' ||true`
case $ac_option in
-help | --help | --hel | --he | -h)
usage; exit 0 ;;
-j | --parallelism | --parallelis | --paralleli | --parallel \
| --paralle | --parall | --paral | --para | --par \
| --pa)
ac_prev=parallelism ;;
-j=* | --parallelism=* | --parallelis=* | --paralleli=* | --parallel=* \
| --paralle=* | --parall=* | --paral=* | --para=* | --par=* \
| --pa=*)
parallelism=$ac_optarg ;;
-j*)
parallelism=`echo $ac_option | sed 's/-j//'` ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
ac_prev=prefix ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix=$ac_optarg ;;
-components | --components | --component | --componen | \
--compone | --compon | --compo | --comp | --com \
| --co | --c)
ac_prev=components ;;
-components=* | --components=* | --component=* | --componen=* \
| --compone=* | --compon=* | --compo=* | --comp=* | --com=* \
| --co=* | --c=*)
components=$ac_optarg ;;
--host)
ac_prev=host ;;
--host=*)
host=$ac_optarg ;;
--target)
ac_prev=target ;;
--target=*)
target=$ac_optarg ;;
--incremental)
incremental=yes ;;
-*) { echo "$as_me: error: unrecognized option: $ac_option
Try \`$0 --help' for more information." >&2
{ (exit 1); exit 1; }; }
;;
*=*)
ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
# Reject names that are not valid shell variable names.
expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
{ echo "$as_me: error: invalid variable name: $ac_envvar" >&2
{ (exit 1); exit 1; }; }
ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
eval "$ac_envvar='$ac_optarg'"
export $ac_envvar ;;
*)
;;
esac
done
# We don't want no errors from here on.
set -e
if test -n "$ac_prev"; then
ac_option=--`echo $ac_prev | sed 's/_/-/g'`
{ echo "$as_me: error: missing argument to $ac_option" >&2
{ (exit 1); exit 1; }; }
fi
# Be sure to have absolute paths.
for ac_var in prefix
do
eval ac_val=$`echo $ac_var`
case $ac_val in
[\\/$]* | ?:[\\/]* | NONE | '' ) ;;
*) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
{ (exit 1); exit 1; }; };;
esac
done
if [ "x${prefix}" != "x" ]; then
export PREFIX="${prefix}"
else
export PREFIX=${ac_default_prefix}
fi
# Figure out what components where requested to be built.
if test x"${components+set}" != xset; then
components=all
else
if test x"${components}" = x ||
test x"${components}" = xyes;
then
echo --components needs at least one argument 1>&2
exit 1
fi
fi
if [ "x${parallelism}" != "x" ]; then
PARALLELISM="-j${parallelism}"
else
PARALLELISM=
fi
# embedded tabs in the sed below -- do not untabify
components=`echo "${components}" | sed -e 's/[ ,][ ,]*/,/g' -e 's/,$//'`
# Don't build in source directory, it will clobber things and cleanup is hard.
if [ -d ${BUILD_DIR}/.git ]; then
echo "Don't build in a source directory, please create an empty directory and build there."
echo "Example :"
echo " mkdir /tmp/cegcc-output"
echo " cd /tmp/cegcc-output"
echo " \$OLDPWD/build.sh $@"
exit 1
fi
# configure_module MODULE SUBDIR [configure-arguments ...]
function configure_module()
{
local module="$1"
local subdir="$2"
shift 2
src="${BASE_DIRECTORY}/${module}"
mkdir -p $subdir
cd $subdir
if [ "$incremental" = "yes" \
-a Makefile -nt $src/configure \
-a Makefile -nt $src/Makefile.in ]; then
# Makefile is fresh, don't need to reconfigure
return
fi
$src/configure \
--prefix=${PREFIX} \
--build=${BUILD} \
"$@"
}
function configure_host_module()
{
configure_module "$@" \
--build=$(gcc -dumpmachine) \
--host=${HOST} \
--target=${TARGET}
}
function configure_target_module()
{
configure_module "$@" \
--host=${TARGET} \
--target=${TARGET}
}
build_binutils()
{
echo ""
echo "BUILDING BINUTILS --------------------------"
echo ""
echo ""
configure_host_module binutils binutils \
--disable-unit-tests \
--disable-nls \
--disable-werror
make ${PARALLELISM}
make install
cd ${BUILD_DIR}
}
build_bootstrap_gcc()
{
configure_host_module gcc gcc-bootstrap \
--with-gcc \
--with-gnu-ld \
--with-gnu-as \
--disable-threads \
--disable-nls \
--enable-languages=c \
--disable-win32-registry \
--disable-multilib \
--disable-shared \
--disable-interwork \
--without-newlib \
--enable-checking
make ${PARALLELISM} all-gcc
make configure-target-libgcc
make install-gcc
gcc_version=`${PREFIX}/bin/${TARGET}-gcc -dumpversion`
cd ${TARGET}/libgcc
make ${PARALLELISM} libgcc.a
/usr/bin/install -c -m 644 libgcc.a ${PREFIX}/lib/gcc/${TARGET}/${gcc_version}
cd ${BUILD_DIR}
}
build_w32api()
{
configure_target_module w32api w32api
make ${PARALLELISM}
make install
#
# Create a cegcc.h file with some sensible input
# Code is copied from the scripts/make_release.sh script.
# This will probably always have "old" numbers
#
# CEGCC_VERSION_MAJOR=`echo $VERSION | awk -F. '{print $1}'`
# CEGCC_VERSION_MINOR=`echo $VERSION | awk -F. '{print $2}'`
# CEGCC_VERSION_PATCHLEVEL=`echo $VERSION | awk -F. '{print $3}'`
#
# Version patchlevel 999 refers to SVN from now on :-)
#
CEGCC_VERSION_MAJOR=0
CEGCC_VERSION_MINOR=55
CEGCC_VERSION_PATCHLEVEL=999
#
INCFILE=${BASE_DIRECTORY}/w32api/include/cegcc.h.in
DESTFILE=${PREFIX}/${TARGET}/include/cegcc.h
#
L1=`grep -s -n "Automatic changes below" ${INCFILE} | awk -F: '{print $1}'`
L2=`grep -s -n "Automatic changes above" ${INCFILE} | awk -F: '{print $1}'`
head -$L1 ${INCFILE} >${DESTFILE}
echo "#define __CEGCC_VERSION_MAJOR__ " $CEGCC_VERSION_MAJOR >> ${DESTFILE}
echo "#define __CEGCC_VERSION_MINOR__ " $CEGCC_VERSION_MINOR >> ${DESTFILE}
echo "#define __CEGCC_VERSION_PATCHLEVEL__ " $CEGCC_VERSION_PATCHLEVEL >> ${DESTFILE}
echo "#define __CEGCC_BUILD_DATE__" `date +%Y%m%d` >> ${DESTFILE}
tail -n +$L2 ${INCFILE} >>${DESTFILE}
cd ${BUILD_DIR}
}
build_mingw()
{
configure_target_module mingw mingw
make ${PARALLELISM}
make install
cd ${BUILD_DIR}
}
build_gcc()
{
configure_host_module gcc gcc \
--with-gcc \
--with-gnu-ld \
--with-gnu-as \
--enable-threads=win32 \
--disable-nls \
--enable-languages=c,c++ \
--disable-win32-registry \
--disable-multilib \
--disable-interwork \
--without-newlib \
--enable-checking \
--with-headers \
--disable-__cxa_atexit
# we build libstdc++ as dll, so we don't need this.
# --enable-fully-dynamic-string \
# --enable-sjlj-exceptions \
# --disable-clocale \
make ${PARALLELISM}
make install
#
# Clean up one file
#
cd ${BUILD_DIR}
}
build_gdb()
{
echo ""
echo "BUILDING GDB --------------------------"
echo ""
echo ""
configure_host_module gdb gdb \
--with-gcc \
--with-gnu-ld \
--with-gnu-as \
--disable-nls \
--disable-win32-registry \
--disable-multilib \
--disable-interwork \
--enable-checking
export CFLAGS=${PREV_CFLAGS}
make ${PARALLELISM}
make install
cd ${BUILD_DIR}
}
build_gdbserver()
{
echo ""
echo "BUILDING gdbserver --------------------------"
echo ""
echo ""
configure_target_module gdb/gdbserver gdbserver
make ${PARALLELISM}
make install
cd ${BUILD_DIR}
}
build_docs()
{
echo ""
echo "INSTALLING documentation --------------------------"
echo ""
echo ""
mkdir -p ${PREFIX}/share/docs
mkdir -p ${PREFIX}/share/images
cd ${BASE_DIRECTORY}/../docs
tar cf - . | (cd ${PREFIX}/share/docs; tar xf -)
cd ${BASE_DIRECTORY}/../website
tar cf - images | (cd ${PREFIX}/share; tar xf -)
cd ${BASE_DIRECTORY}/..
cp NEWS README ${PREFIX}
cp src/binutils/COPYING ${PREFIX}
cp src/binutils/COPYING.LIB ${PREFIX}
cp src/newlib/COPYING.NEWLIB ${PREFIX}
cd ${BUILD_DIR}
}
build_profile()
{
echo ""
echo "BUILDING profiling libraries --------------------------"
echo ""
echo ""
mkdir -p profile
cd profile
configure_target_module profile profile
make ${PARALLELISM}
make install
cd ${BUILD_DIR}
}
build_all()
{
for ((i=0;i<$COMPONENTS_NUM;i++)); do
comp=${COMPONENTS[${i}]}
build_$comp
done
}
split_components=`echo "${components}" | sed -e 's/,/ /g'`
# check for valid options before trying to build them all.
eval "set -- $split_components"
while [ -n "$1" ]; do
if [ "$1" != "all" ]; then
found=false
for ((i=0;i<$COMPONENTS_NUM;i++)); do
if [ "${COMPONENTS[${i}]}" = "$1" ]; then
found=true
fi
done
if [ $found = false ] ; then
echo "Please enter a valid build option."
exit 1
fi
fi
shift
done
if [ "x${target}" != "x" ]; then
export TARGET="${target}"
else
export TARGET="arm-mingw32ce"
fi
export BUILD=`sh ${BASE_DIRECTORY}/gcc/config.guess`
if [ "x${host}" != "x" ]; then
export HOST="${host}"
else
export HOST=${BUILD}
fi
export PATH=${PREFIX}/bin:${PATH}
echo "Building mingw32ce:"
echo "source: ${BASE_DIRECTORY}"
echo "building in: ${BUILD_DIR}"
echo "prefix: ${PREFIX}"
echo "components: ${components}"
echo "Build: ${BUILD}"
echo "Host: ${HOST}"
echo "Target: ${TARGET}"
mkdir -p ${BUILD_DIR}
mkdir -p ${PREFIX}
# Now actually build them.
eval "set -- $split_components"
while [ -n "$1" ]; do
build_${1}
shift
done
echo ""
echo "DONE --------------------------"
echo ""
echo ""
Reference in New Issue View Git Blame Copy Permalink