[LV-tools-commit] toolchain/scripts build_toolchain.sh,NONE,1.1 README,1.7,1.8

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/linux-vax/toolchain/scripts
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32371

Modified Files:
	README 
Added Files:
	build_toolchain.sh 
Log Message:
- The build script and documentation.


Index: README
===================================================================
RCS file: /cvsroot/linux-vax/toolchain/scripts/README,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8

--- README	14 Apr 2005 21:30:37 -0000	1.7
+++ README	15 Apr 2005 08:27:10 -0000	1.8
@@ -53,6 +53,21 @@
 	  mailing lists and coding standards there are *really* high.
 
 
+build_toolchain.sh
+~~~~~~~~~~~~~~~~~~
+This is the work horse. It'll (try to) build a toolchain. This is done by:
+
+	- Copy current CVS repos
+	- Update the local copies if a timestamp was specified
+	- Apply patches if you didn't ask for omitting this step
+	- configure & build & check & install binutils
+	- configure & build & check & install first-stage GCC
+
+This script knows quite some command line arguments. Maybe call it once with
+--help...  The last argument is the target to build for, which defaults to
+vax-linux.
+
+
 update_upstream_cvs_sandboxes.sh
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 This script will update all your checked-out upstream CVS sandboxes to

--- NEW FILE: build_toolchain.sh ---
#!/bin/sh

set -e

REPO_BASE_PATH=/home/jbglaw/vax-linux/scm/cvs-repos

if [ ! -d "${VAX_PATCHES_PATH}" ]; then
	echo "\$VAX_PATCHES_PATH isn't set--please source vax_toolchain_config" >&2
	exit 1
fi
if [ ! -d "${BUILD_BASE_DIR}" ]; then
	echo "\$BUILD_BASE_DIR isn't set--please source vax_toolchain_config" >&2
	exit 1
fi
if [ ! -d "${UPSTREAM_SANDBOXES_PATH}" ]; then
	echo "\$UPSTREAM_SANDBOXES_PATH isn't set--please source vax_toolchain_config" >&2
	exit 1
fi


#
# -Werror behavior
#
WERROR="--disable-werror"
# WERROR=""

#
# Flags for make.
#
# MAKEFLAGS="-j2"

#
# Default target (if it's not given on command line)
#
TARGET="vax-linux"

#
# General configuration
#
NOW="`date -u '+%Y%m%d-%H%M%S'`"
DO_TIMESTAMP_BINUTILS=0
DO_TIMESTAMP_GCC=0
DO_TIMESTAMP_GLIBC=0
DO_TIMESTAMP_PORTS=0
DO_PATCHES_BINUTILS=1
DO_PATCHES_GCC=1
DO_PATCHES_GLIBC=1
DO_PATCHES_PORTS=1
DO_CHECKS_BINUTILS=1
DO_CHECKS_GCC=1
DO_CHECKS_GLIBC=1

#
#
# Parsing all Arguments
#
#
while [ "$#" -gt 0 ]; do
	case "${1}" in
		--timestamp)
			shift
			TIMESTAMP_BINUTILS="${1}"
			TIMESTAMP_GCC="${1}"
			TIMESTAMP_GLIBC="${1}"
			TIMESTAMP_PORTS="${1}"
			DO_TIMESTAMP_BINUTILS=1
			DO_TIMESTAMP_GCC=1
			DO_TIMESTAMP_GLIBC=1
			shift
			;;
		--binutils-timestamp)
			shift
			TIMESTAMP_BINUTILS="${1}"
			DO_TIMESTAMP_BINUTILS=1
			shift
			;;
		--gcc-timestamp)
			shift
			TIMESTAMP_GCC="${1}"
			DO_TIMESTAMP_GCC=1
			shift
			;;
		--glibc-timestamp)
			shift
			TIMESTAMP_GLIBC="${1}"
			DO_TIMESTAMP_GLIBC=1
			shift
			;;
		--omit-patches)
			shift
			DO_PATCHES_BINUTILS=0
			DO_PATCHES_GCC=0
			DO_PATCHES_GLIBC=0
			DO_PATCHES_PORTS=0
			;;
		--omit-binutils-patches)
			shift
			DO_PATCHES_BINUTILS=0
			;;
		--omit-gcc-patches)
			shift
			DO_PATCHES_GCC=0
			;;
		--omit-glibc-patches)
			shift
			DO_PATCHES_GLIBC=0
			;;
		--omit-ports-patches)
			shift
			DO_PATCHES_PORTS=0
			;;
		--omit-checks)
			shift
			DO_CHECKS_BINUTILS=0
			DO_CHECKS_GCC=0
			DO_CHECKS_GLIBC=0
			;;
		--omit-binutils-checks)
			shift
			DO_CHECKS_BINUTILS=0
			;;
		--omit-gcc-checks)
			shift
			DO_CHECKS_GCC=0
			;;
		--omit-glibc-checks)
			shift
			DO_CHECKS_GLIBC=0
			;;
		-*)
			shift
			echo "$0 [--timestamp | --{binutils,glibc,gcc}-timestamp | --omit-patches | --omit-{gcc,glibc,binutils,ports}-patches | --omit-checks | --omit-{binutils,gcc,glibc}-checks] <target>" >&2
			echo "Target defaults to: ${TARGET}" >&2
			exit 1
			;;
		*)
			TARGET="${1}"
			shift
			;;
	esac
done

#
# Echo configuration
#
					echo "	Target:			${TARGET}"
[ "${DO_TIMESTAMP_BINUTILS}" -ne 0 ] &&	echo "	Binutils timestamp:	${TIMESTAMP_BINUTILS}"
[ "${DO_TIMESTAMP_BINUTILS}" -eq 0 ] &&	echo "	Binutils timestamp:	last known"
[ "${DO_TIMESTAMP_GCC}" -ne 0 ] &&	echo "	GCC timestamp:		${TIMESTAMP_GCC}"
[ "${DO_TIMESTAMP_GCC}" -eq 0 ] &&	echo "	GCC timestamp:		last known"
[ "${DO_TIMESTAMP_GLIBC}" -ne 0 ] &&	echo "	Glibc timestamp:	${TIMESTAMP_GLIBC}"
[ "${DO_TIMESTAMP_GLIBC}" -eq 0 ] &&	echo "	Glibc timestamp:	last known"
[ "${DO_PATCHES_BINUTILS}" -ne 0 ] &&	echo "	Patch Binutils:		yes"
[ "${DO_PATCHES_BINUTILS}" -eq 0 ] &&	echo "	Patch Binutils:		no"
[ "${DO_PATCHES_GCC}" -ne 0 ] &&	echo "	Patch Gcc:		yes"
[ "${DO_PATCHES_GCC}" -eq 0 ] &&	echo "	Patch Gcc:		no"
[ "${DO_PATCHES_GLIBC}" -ne 0 ] &&	echo "	Patch Glibc:		yes"
[ "${DO_PATCHES_GLIBC}" -eq 0 ] &&	echo "	Patch Glibc:		no"
[ "${DO_PATCHES_PORTS}" -ne 0 ] &&	echo "	Patch Glibc-Ports:	yes"
[ "${DO_PATCHES_PORTS}" -eq 0 ] &&	echo "	Patch Glibc-Ports:	no"
[ "${DO_CHECKS_BINUTILS}" -ne 0 ] &&	echo "	Check Binutils:		yes"
[ "${DO_CHECKS_BINUTILS}" -eq 0 ] &&	echo "	Check Binutils:		no"
[ "${DO_CHECKS_GCC}" -ne 0 ] &&		echo "	Check GCC:		yes"
[ "${DO_CHECKS_GCC}" -eq 0 ] &&		echo "	Check GCC:		no"
[ "${DO_CHECKS_GLIBC}" -ne 0 ] &&	echo "	Check GNU libc:		yes"
[ "${DO_CHECKS_GLIBC}" -eq 0 ] &&	echo "	Check GNU libc:		no"


#
# Some housekeeping
#
BUILD_BINUTILS=1
BUILD_GAS=1
BUILD_LD=1
BUILD_GCC1=1
BUILD_GCC2=1
GCC1_EXTRA_LANGUAGES=
case "${TARGET}" in
	vax*ultrix)
		GCC1_EXTRA_LANGUAGES=",c++"
		;;
	vax*linux)
		;;
	vax*netbsd)
		;;
	vax*netbsdelf)
		;;
	vax*openbsd)
		BUILD_LD=0
		;;
	*)
		echo "Configuration \"${TARGET}\" unknown..." >&2
		false
esac


#
# $1... - command (with its arguments) to execute
#
function execute() {
	local RETVAL

	echo "#"
	echo "#"
	echo "# Executing in `pwd`:"
	echo "# $*"
	echo "#"
	echo "#"

	"$@"
	RETVAL=$?

	echo "#"
	echo "# End of: $*"
	echo "#"
	echo

	return "${RETVAL}"
}



#
# $1 - A path which will be cleaned up (remove /../, ...)
#
function check_path() {
	( cd "$1" && pwd; )
}



#
# $1 - "0" (don't build) or anything else (build)
#
function build() {
	if [ "$1" == "0" ]; then
		return 1
	else
		return 0
	fi
}


BINUTILS_CVS="${UPSTREAM_SANDBOXES_PATH}/binutils/binutils-upstream-HEAD"
GLIBC_CVS="${UPSTREAM_SANDBOXES_PATH}/glibc/libc-upstream-HEAD"
GLIBC_PORTS_CVS="${UPSTREAM_SANDBOXES_PATH}/glibc/ports-upstream-HEAD"
GCC_CVS="${UPSTREAM_SANDBOXES_PATH}/gcc/gcc-upstream-HEAD"

#
#
# Prepare sources
#
#

#
# Set some variables
#
ALL_BASE="${BUILD_BASE_DIR}/build-${NOW}-${TARGET}"
SRC_BASE="${ALL_BASE}/src"
BUILD_BASE="${ALL_BASE}/build"
INSTALL_BASE="${ALL_BASE}/install"

BINUTILS_SRC="${SRC_BASE}/binutils"
GLIBC_SRC="${SRC_BASE}/glibc"
GCC_SRC="${SRC_BASE}/gcc"

BINUTILS_BUILD="${BUILD_BASE}/binutils"
GCC1_BUILD="${BUILD_BASE}/gcc1"
GLIBC_BUILD="${BUILD_BASE}/glibc"
GCC2_BUILD="${BUILD_BASE}/gcc2"

#
# Create all the directories
#
mkdir "${ALL_BASE}";		ALL_BASE="`check_path "${ALL_BASE}"`"
mkdir "${SRC_BASE}";		SRC_BASE="`check_path "${SRC_BASE}"`"
mkdir "${BUILD_BASE}";		BUILD_BASE="`check_path "${BUILD_BASE}"`"
mkdir "${INSTALL_BASE}";	INSTALL_BASE="`check_path "${INSTALL_BASE}"`"
mkdir "${BINUTILS_SRC}";	BINUTILS_SRC="`check_path "${BINUTILS_SRC}"`"
mkdir "${GLIBC_SRC}";		GLIBC_SRC="`check_path "${GLIBC_SRC}"`"
mkdir "${GCC_SRC}";		GCC_SRC="`check_path "${GCC_SRC}"`"
mkdir "${BINUTILS_BUILD}";	BINUTILS_BUILD="`check_path "${BINUTILS_BUILD}"`"
mkdir "${GCC1_BUILD}";		GCC1_BUILD="`check_path "${GCC1_BUILD}"`"
mkdir "${GLIBC_BUILD}";		GLIBC_BUILD="`check_path "${GLIBC_BUILD}"`"
mkdir "${GCC2_BUILD}";		GCC2_BUILD="`check_path "${GCC2_BUILD}"`"

#
# Copy pristine sources
#
n_copy_directory.sh "${BINUTILS_CVS}"	 "${BINUTILS_SRC}"
n_copy_directory.sh "${GLIBC_CVS}"	 "${GLIBC_SRC}"
n_copy_directory.sh "${GLIBC_PORTS_CVS}" "${GLIBC_SRC}"
n_copy_directory.sh "${GCC_CVS}"	 "${GCC_SRC}"

#
# Possibly force specific CVS timestamps
#
if [ "${DO_TIMESTAMP_BINUTILS}" -ne 0 ]; then
	pushd "${BINUTILS_SRC}"
		execute cvs -z9 update -d -P -D "${TIMESTAMP_BINUTILS}"
	popd
fi
if [ "${DO_TIMESTAMP_GCC}" -ne 0 ]; then
	pushd "${GCC_SRC}"
		execute cvs -z9 update -d -P -D "${TIMESTAMP_GCC}"
	popd
fi
if [ "${DO_TIMESTAMP_GLIBC}" -ne 0 ]; then
	pushd "${GLIBC_SRC}"
		execute cvs -z9 update -d -P -D "${TIMESTAMP_GLIBC}"
	popd
fi
#
# Patch sources with our local patches
#
[ "${DO_PATCHES_BINUTILS}" -ne 0 ] && execute n_try_patches.sh "binutils" "${BINUTILS_SRC}" "${VAX_PATCHES_PATH}"
[ "${DO_PATCHES_GCC}" -ne 0 ] &&      execute n_try_patches.sh "gcc"	  "${GCC_SRC}"	    "${VAX_PATCHES_PATH}"
[ "${DO_PATCHES_GLIBC}" -ne 0 ] &&    execute n_try_patches.sh "glibc"	  "${GLIBC_SRC}"    "${VAX_PATCHES_PATH}"
[ "${DO_PATCHES_PORTS}" -ne 0 ] &&    execute n_try_patches.sh "ports"	  "${GLIBC_SRC}"    "${VAX_PATCHES_PATH}"


#
#
# Start to bulid all the stuff
#
#

#
# Build binutils
#
pushd "${BINUTILS_BUILD}"
	# Configure
	execute "${BINUTILS_SRC}/configure"		\
			--target="${TARGET}"		\
			--prefix="${INSTALL_BASE}/usr"	\
			${WERROR}

	# Build
	build "${BUILD_BINUTILS}" &&	execute make ${MAKEFLAGS} all-binutils
	build "${BUILD_LD}" &&		execute make ${MAKEFLAGS} all-ld
	build "${BUILD_GAS}" &&		execute make ${MAKEFLAGS} all-gas

	# Check. We check twice because (of unknown reasons), the first
	# run occassionally fails on my box (either some script just before
	# expect is startet crashes, or expect hangs (burning CPU cycles)
	# after one run is done). So this is a FIXME.
	build "${BUILD_BINUTILS}" &&			\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-binutils || true
	build "${BUILD_BINUTILS}" &&			\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-binutils || true
	build "${BUILD_LD}" &&				\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-ld || true
	build "${BUILD_LD}" &&				\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-ld || true
	build "${BUILD_GAS}" &&				\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-gas || true
	build "${BUILD_GAS}" &&				\
		build "${DO_CHECKS_BINUTILS}" &&	\
		execute make ${MAKEFLAGS} check-gas || true

	# Install
	build "${BUILD_BINUTILS}" &&	execute make ${MAKEFLAGS} install-binutils
	build "${BUILD_LD}" &&		execute make ${MAKEFLAGS} install-ld
	build "${BUILD_GAS}" &&		execute make ${MAKEFLAGS} install-gas
popd

export PATH="$PATH:${INSTALL_BASE}/usr/bin"

#
# Build GCC, Part 1
#
pushd "${GCC1_BUILD}"
	# Update configure files
	pushd "${GCC_SRC}"
		execute autoconf
	popd
	pushd "${GCC_SRC}/gcc"
		execute autoconf
	popd

	# Configure
	execute "${GCC_SRC}/configure"					\
			--disable-multilib				\
			--with-newlib					\
			--disable-nls					\
			--enable-threads=no				\
			--disable-threads				\
			--enable-symvers=gnu				\
			--enable-__cxa_atexit				\
			--disable-shared				\
			--target="${TARGET}"				\
			--prefix="${INSTALL_BASE}/usr"			\
			--enable-languages="c${GCC1_EXTRA_LANGUAGES}"	\
			${WERROR}

			#--without-headers

	# Build
	build "${BUILD_GCC1}" &&	execute make ${MAKEFLAGS} all-gcc

	# Check
	build "${BUILD_GCC1}" &&		\
		build "${DO_CHECKS_GCC}" &&	\
		execute make ${MAKEFLAGS} check-gcc || true

	# Install
	build "${BUILD_GCC1}" &&	execute make ${MAKEFLAGS} install-gcc
popd




