build

#!/bin/sh
#
# The Main Script for Building GNU Toolchain
#
# Conke Hu <conke.hu@gmail.com>
# Rouchel Yan <rouchel.yan@maxwit.com>
#
# http://www.maxwit.com
#


MWT_TOP=`dirname $0`
cd ${MWT_TOP}
MWT_TOP=${PWD}

[ -e .config ] || \
{
	echo ".config does NOT exist! using default configuration:"
	cp defconfig .config || exit 1
	cat .config
	echo
}

# fixme
sed -i 's/ //g' .config
. ./.config || exit 1

 if [ -z "${CONFIG_BINUTILS}" -o \
	-z "${CONFIG_GCC}" -o \
	-z "${CONFIG_LIBC}" -o \
	-z "${CONFIG_LINUX}" -o \
	-z "${CONFIG_CPU}" ]; then
	echo "missing configuration, pls check the .config file!"
	exit 1
fi

case "${CONFIG_CPU}" in
	armv4t)
		TARGET_ARCH="arm"
		TARGET_PLAT="arm-maxwit-linux-gnueabi"
		BU_CPU_OPT="--with-float=soft"
		GCC_CPU_OPT="--with-float=soft --with-arch=armv4t"
		;;

	armv6zk)
		TARGET_ARCH="arm"
		TARGET_PLAT="arm-maxwit-linux-gnueabi"
		GCC_CPU_OPT="--with-arch=armv6zk"
		;;

	armv5te)
		TARGET_ARCH="arm"
		TARGET_PLAT="arm-maxwit-linux-gnueabi"
		BU_CPU_OPT="--with-float=soft"
		GCC_CPU_OPT="--with-float=soft --with-arch=armv5te"
		;;

	# fixme
	xscale)
		TARGET_ARCH="arm"
		TARGET_PLAT="arm-maxwit-linux-gnueabi"
		BU_CPU_OPT="--with-float=soft"
		GCC_CPU_OPT="--with-float=soft --with-arch=armv5te"
		;;

	armv7-a)
		TARGET_ARCH="arm"
		TARGET_PLAT="arm-maxwit-linux-gnueabi"
		BU_CPU_OPT="--with-float=hard"
		GCC_CPU_OPT="--with-fpu=vfp --with-float=hard --with-arch=armv7-a"
		;;

	# fixme
	mips32)
		TARGET_ARCH="mips"
		QEMU_ARCH="mipsel"
		TARGET_PLAT="mipsel-maxwit-linux-gnu"
		GCC_CPU_OPT="--with-abi=32 --with-tune=mips32r2"
		;;

	loongson2f)
		TARGET_ARCH="mips"
		QEMU_ARCH="mips64el"
		TARGET_PLAT="mips64el-maxwit-linux-gnu"
		GCC_CPU_OPT="--with-abi=64 --with-tune=loongson2f"
		BU_CPU_OPT="--enable-64-bit-bfd"
		;;

	*)
		echo "No Target CPU Specified!"
		exit 1
		;;
esac

# fixme: be configurable
MAXWIT_TOP=/maxwit
SRC_PATH=${MAXWIT_TOP}/source
BUILD_PATH=${MAXWIT_TOP}/build/toolchain
TARGET_TOP=/maxwit/toolchain/${CONFIG_CPU}
ROOTFS_PATH=${MAXWIT_TOP}/image/rootfs
#TOOLCHAIN_PATH=${TARGET_TOP}/toolchain
#ROOTFS_PATH=${TARGET_TOP}
TOOLCHAIN_PATH=${TARGET_TOP}

BUILD_PLAT=`gcc -dumpmachine`

for path in ${TOOLCHAIN_PATH} ${ROOTFS_PATH} ${SRC_PATH} ${BUILD_PATH}
do
	mkdir -vp ${path} || \
	{
		echo "Fail to create directory \"${path}\"!"
		exit 1
	}
done

export ROOTFS_PATH TOOLCHAIN_PATH BU_CPU_OPT GCC_CPU_OPT

# fixme
[ -z "${QEMU_ARCH}" ] && QEMU_ARCH=${TARGET_ARCH}

# $1 = package name
# $2 = /directory/of/the/url/file/
download()
{
	local pkg=${1}
	local dir=${2}

	for ext in tar.xz tar.bz2 tar.gz tgz
	do
		if [ -f ${SRC_PATH}/${pkg}.${ext} ]; then
			return 0
		fi
	done

	if [ -x ${dir}/fetch.sh ]; then
		${dir}/fetch.sh ${pkg} ${SRC_PATH} || exit 1
	elif [ -e ${dir}/url ]; then
		url=`grep "^\s*url\s*=" ${dir}/url | sed 's/^\s*url\s*=\s*//'`
		ext=`grep "^\s*ext\s*=" ${dir}/url | sed 's/^\s*ext\s*=\s*//'`
		wget ${url}/${pkg}.${ext} -P ${SRC_PATH} || exit 1
	else
		echo "\"${pkg} cannot be downloaded!"
		exit 1
	fi

	return 0
}

# $1: package name
extract()
{
	local opkg="${1}"
	local upkg="${opkg}"
	local pkg_ver=${opkg##*-}

	cd ${BUILD_PATH}

	case ${opkg} in
	binutils-* | gcc-* | glibc-* | eglibc-*)
		upkg=${opkg}-build${2}
		# rm -rf ${upkg}
		mkdir -p ${upkg}
		;;
	esac

	# fixme
	if [ -e ${opkg}/.__maxwit_extract ]; then
		echo "package \"${opkg}\" exists, skipped"
		cd ${upkg}
		return 0
	fi

	echo -n "Extracting \"${opkg}\" "

	if [ -z "${opkg}" ]; then
		echo "target dir NOT specified!"
		exit 1
	fi

	echo -n "."

	pkg_exist=0
	for ext in tar.xz tar.bz2 tar.gz tgz
	do
		if [ -f ${SRC_PATH}/${opkg}.${ext} ]; then
			pkg_exist=1
			break
		fi
	done

	if [ pkg_exist = 0 ]; then
		echo "\"${SRC_PATH}/${opkg}\" does NOT exist!"
		exit 1
	fi

	tar xf ${SRC_PATH}/${opkg}.${ext} || exit 1

	echo -n "."

	case "${opkg}" in
	glibc-* | eglibc-*)
		glibc_ports=`echo $CONFIG_LIBC | sed 's/glibc-/glibc-ports-/'`
		rm -rf ${glibc_ports}
		tar xf ${SRC_PATH}/${glibc_ports}.tar.* || exit 1
		mv ${glibc_ports} ${CONFIG_LIBC}/ports
		;;
	esac

	echo " OK."

	cd ${opkg} || exit 1

	# make sure ``patch'' is installed
	# before applying all available patches
	for fpatch in `ls ${MWT_TOP}/${opkg%-*}/${pkg_ver}/*.patch 2>/dev/null`
	do
		patch -p1 < ${fpatch} || exit 1
	done

	touch .__maxwit_extract

	if [ "${opkg}" != "${upkg}" ]; then
		cd ../${upkg}
	fi
}

# $1 = package
# $2 for gcc only
build_package()
{
	local pkg=${1}
	local pkg_dir=${pkg%%-[\.0-9]*}
	local version=${pkg##${pkg_dir}-}
	local build="build${2}.sh"

	pkg_dir="${MWT_TOP}/${pkg_dir}"

	if [ -f "${BUILD_PATH}/${pkg}/.__maxwit_built${2}" ]; then
		echo "\"${1}\" has been built."
		echo
		return 0
	fi

	download ${pkg} ${pkg_dir}
	echo

	extract ${pkg} $2
	echo

	echo "Building \"${pkg}\" ..."

	# fixme
	if test -x ${pkg_dir}/${version}/${build}; then
		build=${pkg_dir}/${version}/${build}
	elif test -x ${pkg_dir}/${build}; then
		build=${pkg_dir}/${build}
	else
		echo "No ${build} found in ${pkg_dir}!"
		exit 1
	fi

	${build} ${pkg} ${BUILD_PLAT} ${TARGET_PLAT} || exit 1

	touch ${BUILD_PATH}/${pkg}/.__maxwit_built${2}
	echo

	return 0
}

# export PATH
grep "${TOOLCHAIN_PATH}" ~/.bashrc > /dev/null \
	|| echo "export PATH=\${PATH}:${TOOLCHAIN_PATH}/usr/bin" >> ~/.bashrc

echo ${PATH} | grep "${TOOLCHAIN_PATH}" > /dev/null \
	|| export PATH=${PATH}:${TOOLCHAIN_PATH}/usr/bin

build_package ${CONFIG_LINUX}

build_package ${CONFIG_BINUTILS}

build_package ${CONFIG_GCC} 1

build_package ${CONFIG_LIBC}

build_package ${CONFIG_GCC} 2

# create symbolic links
[ -L ${TOOLCHAIN_PATH}/usr/bin/${TARGET_ARCH}-linux-gcc ] || \
{
	cd ${TOOLCHAIN_PATH}/usr/bin
	for file in `ls ${TARGET_PLAT}-*`
	do
		ln -vs ${file} ${TARGET_ARCH}-linux${file##${TARGET_PLAT}}
	done

	#ln -vs ${TARGET_PLAT}-gcc ${TARGET_PLAT}-cc
}

# backup
echo -n "Archive GNU Toolchain ..." # rootfs

cd ${TOOLCHAIN_PATH}/../
TC_BIN=`basename ${TOOLCHAIN_PATH}`
tar cJvf toolchain-${CONFIG_CPU}.tar.xz ${TC_BIN}
echo