path: root/eclass/gnatbuild.eclass

# Copyright 1999-2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/gnatbuild.eclass,v 1.6 2006/03/20 14:57:41 george Exp $

# ATTN!
# set HOMEPAGE and LICENSE in appropriate ebuild, as we have
# gnat developed at two locations now.

inherit versionator toolchain-funcs flag-o-matic multilib

EXPORT_FUNCTIONS pkg_setup pkg_postinst pkg_prerm src_unpack src_compile src_install

DESCRIPTION="Based on the ${ECLASS} eclass"

IUSE="nls multilib"

RDEPEND="app-admin/eselect-gnat"

#---->> globals and SLOT <<----

# just a check, this location seems to vary too much, easier to track it in
# ebuild
#[ -z "${GNATSOURCE}" ] && die "please set GNATSOURCE in ebuild! (before inherit)"

# versioning
# because of gnatpro/gnatgpl we need to track both gcc and gnat versions

# these simply default to $PV
GNATMAJOR=$(get_version_component_range 1)
GNATMINOR=$(get_version_component_range 2)
GNATBRANCH=$(get_version_component_range 1-2)
GNATRELEASE=$(get_version_component_range 1-3)

# GCCVER and SLOT logic
#
# I better define vars for package names, as there was discussion on proper
# naming and it may change
PN_GnatGCC="gnat-gcc"
PN_GnatGpl="gnat-gpl"
PN_GnatPro="gnat-pro"

# ATTN! GCCVER stands for the provided backend gcc, not the one on the system
# so tc-* functions are of no use here
#
# GCCVER can be set in the ebuild, but then care will have to be taken
# to set it before inheriting, which is easy to forget
# so set it here for what we can..
if   [[ ${PN} == "${PN_GnatGCC}" ]] ; then
	GCCVER="${PV}"
elif [[ ${PN} == "${PN_GnatGpl}" ]] ; then
	GCCVER="${GNATRELEASE}"
elif [[ ${PN} == "${PN_GnatPro}" ]] ; then
# Ada Core provided stuff is really conservative and changes backends rarely
	case "${GNATMAJOR}" in
		"3")    GCCVER="2.8.1" ;;
		"2005") GCCVER="3.4.5" ;;
	esac
else
	# gpc, gdc and possibly others will use a lot of common logic, I'll try to
	# provide some support for them via this eclass
	die "no support for other gcc frontends so far. Sorry."
fi

# finally extract GCC version strings
GCCMAJOR=$(get_version_component_range 1 "${GCCVER}")
GCCMINOR=$(get_version_component_range 2 "${GCCVER}")
GCCBRANCH=$(get_version_component_range 1-2 "${GCCVER}")
GCCRELEASE=$(get_version_component_range 1-3 "${GCCVER}")

# SLOT logic, make it represent gcc backend, as this is what matters most
SLOT="${GCCBRANCH}"

# possible future crosscompilation support
export CTARGET=${CTARGET:-${CHOST}}

is_crosscompile() {
	[[ ${CHOST} != ${CTARGET} ]]
}


# set our install locations
PREFIX=${GNATBUILD_PREFIX:-/usr} # not sure we need this hook, but may be..
LIBPATH=${PREFIX}/lib/${PN}/${CTARGET}/${SLOT}
LIBEXECPATH=${PREFIX}/libexec/${PN}/${CTARGET}/${SLOT}
INCLUDEPATH=${LIBPATH}/include
BINPATH=${PREFIX}/${CTARGET}/${PN}-bin/${SLOT}
DATAPATH=${PREFIX}/share/${PN}-data/${CTARGET}/${SLOT}

# ebuild globals
if [[ ${PN} == "${PN_GnatPro}" ]] && [[ ${GNATMAJOR} == "3" ]]; then
		DEPEND="x86? ( >=app-shells/tcsh-6.0 )"
fi
S="${WORKDIR}/gcc-${GCCVER}"

# bootstrap globals, common to src_unpack and src_compile
case $(tc-arch) in
	ppc)
		GNATBOOT="${WORKDIR}/gnat-3.15p-powerpc-unknown-linux-gnu"
		GNATBOOTINST="${GNATBOOT}"
		GCC_EXEC_BASE="${GNATBOOT}/lib/gcc-lib"
		;;
	amd64 | x86)
		GNATBOOT="${WORKDIR}/usr"
		;;
esac

# some buildtime globals
GNATBUILD="${WORKDIR}/build"

# necessary for detecting lib locations and creating env.d entry
#XGCC="${GNATBUILD}/gcc/xgcc -B${GNATBUILD}/gcc"

#----<< globals and SLOT >>----

# set SRC_URI's in ebuilds for now

#----<< support checks >>----
# skipping this section - do not care about hardened/multilib for now

#---->> specs + env.d logic <<----
# TODO!!!
# set MANPATH, etc..
#----<< specs + env.d logic >>----


#---->> some helper functions <<----
is_multilib() {
	[[ ${GCCMAJOR} < 3 ]] && return 1
	case ${CTARGET} in
		mips64*|powerpc64*|s390x*|sparc64*|x86_64*)
			has_multilib_profile || use multilib ;;
		*)  false ;;
	esac
}

# adapted from toolchain,
# left only basic multilib functionality and cut off mips stuff
create_gnat_env_entry() {
	dodir /etc/env.d/gnat
	local gnat_envd_base="/etc/env.d/gnat/${CTARGET}-${PN}-${SLOT}"

	gnat_envd_file="${D}${gnat_envd_base}"
#	gnat_specs_file=""

	echo "PATH=\"${BINPATH}:${LIBEXECPATH}\"" > ${gnat_envd_file}

	LDPATH="${LIBPATH}"
	for path in 32 64 o32 ; do
		[[ -d ${LIBPATH}/${path} ]] && LDPATH="${LDPATH}:${LIBPATH}/${path}"
	done
	echo "LDPATH=\"${LDPATH}\"" >> ${gnat_envd_file}

	echo "MANPATH=\"${DATAPATH}/man\"" >> ${gnat_envd_file}
	echo "INFOPATH=\"${DATAPATH}/info\"" >> ${gnat_envd_file}

	is_crosscompile && echo "CTARGET=${CTARGET}" >> ${gnat_envd_file}

	# Set which specs file to use
#	[[ -n ${gnat_specs_file} ]] && echo "GCC_SPECS=\"${gnat_specs_file}\"" >> ${gnat_envd_file}
}

# eselect stuff taken straight from toolchain.eclass and greatly simplified
add_profile_eselect_conf() {
	local gnat_config_file=$1
	local abi=$2
	local var

	echo >> ${gnat_config_file}
	if ! is_multilib ; then
		echo "  ctarget=${CTARGET}" >> ${gnat_config_file}
	else
		echo "[${abi}]" >> ${gnat_config_file}
		var="CTARGET_${abi}"
		if [[ -n ${!var} ]] ; then
			echo "  ctarget=${!var}" >> ${gnat_config_file}
		else
			var="CHOST_${abi}"
			if [[ -n ${!var} ]] ; then
				echo "  ctarget=${!var}" >> ${gnat_config_file}
			else
				echo "  ctarget=${CTARGET}" >> ${gnat_config_file}
			fi
		fi
	fi

	var="CFLAGS_${abi}"
	if [[ -n ${!var} ]] ; then
		echo "  cflags=${!var}" >> ${gnat_config_file}
	fi
}


create_eselect_conf() {
	# it would be good to source gnat.eselect module here too,
	# but we only need one path
	local config_dir="/usr/share/gnat/eselect"
	local gnat_config_file="${D}/${config_dir}/${CTARGET}-${PN}-${SLOT}"
	local abi

	dodir ${config_dir}

	echo "[global]" > ${gnat_config_file}
	echo "  version=${CTARGET}-${SLOT}" >> ${gnat_config_file}
	echo "  binpath=${BINPATH}" >> ${gnat_config_file}
	echo "  libexecpath=${LIBEXECPATH}" >> ${gnat_config_file}
	echo "  ldpath=${LIBPATH}" >> ${gnat_config_file}
	echo "  manpath=${DATAPATH}/man" >> ${gnat_config_file}
	echo "  infopath=${DATAPATH}/info" >> ${gnat_config_file}
#     echo "  alias_cc=gcc" >> ${compiler_config_file}
#     echo "  stdcxx_incdir=${STDCXX_INCDIR##*/}" >> ${compiler_config_file}
	echo "  bin_prefix=${CTARGET}" >> ${gnat_config_file}

	for abi in $(get_all_abis) ; do
		add_profile_eselect_conf "${gnat_config_file}" "${abi}"
	done
}


# active compiler selection, called from pkg_postinst
do_gnat_config() {
	eselect gnat set ${CTARGET}-${PN}-${SLOT} &> /dev/null

	einfo "The following gnat profile has been activated:"
	einfo "${CTARGET}-${PN}-${SLOT}"
	einfo ""
	einfo "The compiler has been installed as gnatgcc, and the coverage testing"
	einfo "tool as gnatgcov."
}

#---->> pkg_* <<----
gnatbuild_pkg_setup() {
	debug-print-function ${FUNCNAME} $@

	# Setup variables which would normally be in the profile
	if is_crosscompile ; then
		multilib_env ${CTARGET}
		if ! use multilib ; then
			MULTILIB_ABIS=${DEFAULT_ABI}
		fi
	fi

	# we dont want to use the installed compiler's specs to build gnat!
	unset GCC_SPECS
}

gnatbuild_pkg_postinst() {
	do_gnat_config
}

# eselect-gnat can be unmerged together with gnat-*, so we better do this before
# actual removal takes place, rather than in postrm, like toolchain does
gnatbuild_pkg_prerm() {
	# files for eselect module are left behind, so we need to cleanup.
	if [ ! -f /usr/share/eselect/modules/gnat.eselect ] ; then
		eerror "eselect-gnat was prematurely unmerged!"
		eerror "You will have to manually remove unnecessary files"
		eerror "under /etc/eselect/gnat and /etc/env.d/55gnat-xxx"
		exit # should *not* die, as this will stop unmerge!
	fi

	# this copying/modifying and then sourcing of a gnat.eselect is a hack,
	# but having a duplicate functionality is really bad - gnat.eselect module
	# might change..
	cat /usr/share/eselect/modules/gnat.eselect | \
		grep -v "svn_date_to_version" | \
		grep -v "DESCRIPTION" \
		> ${WORKDIR}/gnat.esel
	. ${WORKDIR}/gnat.esel

	# see if we need to unset gnat
	if [[ $(get_current_gnat) == "${CTARGET}-${PN}-${SLOT}" ]] ; then
		eselect gnat unset &> /dev/null
	fi
}
#---->> pkg_* <<----

#---->> src_* <<----

# common unpack stuff
gnatbuild_src_unpack() {
	debug-print-function ${FUNCNAME} $@
	[ -z "$1" ] &&  gnatbuild_src_unpack all

	while [ "$1" ]; do
	case $1 in
		base_unpack)
			unpack ${A}
		;;

		common_prep)
			# Prepare the gcc source directory
			if [ "2.8.1" == "${GCCVER}" ] ; then
				cd "${S}"
			else
				cd "${S}/gcc"
			fi
			touch cstamp-h.in
			touch ada/[es]info.h
			touch ada/nmake.ad[bs]
			# set the compiler name to gnatgcc
			for i in `find ada/ -name '*.ad[sb]'`; do \
				sed -i -e "s/\"gcc\"/\"gnatgcc\"/g" ${i}; \
			done
			# add -fPIC flag to shared libs
			cd ada
			patch Make-lang.in < ${FILESDIR}/gnat-Make-lang.in.patch

			mkdir -p "${GNATBUILD}"
		;;

		all)
			gnatbuild_src_unpack base_unpack common_prep
		;;
	esac
	shift
	done
}

# it would be nice to split configure and make steps
# but both need to operate inside specially tuned evironment
# so just do sections for now (as in eclass section of handbook)
# sections are: configure, make-tools, bootstrap,
#  gnatlib_and_tools, gnatlib-shared
gnatbuild_src_compile() {
	debug-print-function ${FUNCNAME} $@
	if [[ -z "$1" ]]; then
		gnatbuild_src_compile all
		return $?
	fi

	if [ "all" == "$1" ]
	then # specialcasing "all" to avoid scanning sources unnecessarily
		gnatbuild_src_compile configure make-tools \
			bootstrap gnatlib_and_tools gnatlib-shared

	else
		# Set some paths to our bootstrap compiler.
		export PATH="${GNATBOOT}/bin:${PATH}"
		if [ "${PN_GnatPro}-3.15p" == "${P}" ]; then
			GNATLIB="${GNATBOOT}/lib/gcc-lib/${CTARGET}/${SLOT}"
		else
			GNATLIB="${GNATBOOT}/lib/gnatgcc/${CTARGET}/${SLOT}"
		fi

		export CC="${GNATBOOT}/bin/gnatgcc"
		export INCLUDE_DIR="${GNATLIB}/include"
		export LIB_DIR="${GNATLIB}"
		export LDFLAGS="-L${GNATLIB}"

		# additional vars from gnuada and elsewhere
		export LD_RUN_PATH="${LIBPATH}"
		export LIBRARY_PATH="${GNATLIB}"
		export LD_LIBRARY_PATH="${GNATLIB}"
		export COMPILER_PATH="${GNATBOOT}/bin/"

		export ADA_OBJECTS_PATH="${GNATLIB}/adalib"
		export ADA_INCLUDE_PATH="${GNATLIB}/adainclude"

#		if [ "2.8.1" == ${GCCVER} ]; then
#			export BINUTILS_ROOT="${GNATBOOT}"
#		fi

		#einfo "CC=${CC},  ADA_INCLUDE_PATH=${ADA_INCLUDE_PATH},	LDFLAGS=${LDFLAGS}"

		while [ "$1" ]; do
		case $1 in
			configure)
				debug-print-section configure
				# Configure gcc
				local confgcc

				# some cross-compile logic from toolchain
				confgcc="${confgcc} --host=${CHOST}"
				if is_crosscompile || tc-is-cross-compiler ; then
					confgcc="${confgcc} --target=${CTARGET}"
				fi
				[[ -n ${CBUILD} ]] && confgcc="${confgcc} --build=${CBUILD}"

				# Native Language Support
				if use nls ; then
					confgcc="${confgcc} --enable-nls --without-included-gettext"
				else
					confgcc="${confgcc} --disable-nls"
				fi

				# reasonably sane globals (from toolchain)
				confgcc="${confgcc} \
					--with-system-zlib \
					--disable-checking \
					--disable-werror \
					--disable-libunwind-exceptions"

				cd "${GNATBUILD}"
				CFLAGS="${CFLAGS}" CXXFLAGS="${CXXFLAGS}" "${S}"/configure \
					--prefix=${PREFIX} \
					--bindir=${BINPATH} \
					--includedir=${INCLUDEPATH} \
					--libdir="${LIBPATH}" \
					--libexecdir="${LIBEXECPATH}" \
					--datadir=${DATAPATH} \
					--mandir=${DATAPATH}/man \
					--infodir=${DATAPATH}/info \
					--program-prefix=gnat \
					--enable-languages="c,ada" \
					--enable-libada \
					--with-gcc \
					--enable-threads=posix \
					--enable-shared \
					--with-system-zlib \
					--disable-nls \
					${confgcc} || die "configure failed"
			;;

			make-tools)
				debug-print-section make-tools
				# Compile helper tools
				cd "${GNATBOOT}"
				cp ${S}/gcc/ada/xtreeprs.adb .
				cp ${S}/gcc/ada/xsinfo.adb .
				cp ${S}/gcc/ada/xeinfo.adb .
				cp ${S}/gcc/ada/xnmake.adb .
				gnatmake xtreeprs && \
					gnatmake xsinfo && \
					gnatmake xeinfo && \
					gnatmake xnmake || die "building helper tools"
			;;

			bootstrap)
				debug-print-section bootstrap
				# and, finally, the build itself
				cd "${GNATBUILD}"
				emake bootstrap || die "bootstrap failed"
			;;

			gnatlib_and_tools)
				debug-print-section gnatlib_and_tools
				einfo "building gnatlib_and_tools"
				cd "${GNATBUILD}"
				emake -j1 -C gcc gnatlib_and_tools || \
					die "gnatlib_and_tools failed"
			;;

			gnatlib-shared)
				debug-print-section gnatlib-shared
				einfo "building shared lib"
				cd "${GNATBUILD}"
				rm -f gcc/ada/rts/*.{o,ali} || die
				#otherwise make tries to reuse already compiled (without -fPIC) objs..
				emake -j1 -C gcc gnatlib-shared LIBRARY_VERSION="${GCCBRANCH}" || \
					die "gnatlib-shared failed"
			;;
		esac
		shift
		done # while
	fi   # "all" == "$1"
}


gnatbuild_src_install() {
	debug-print-function ${FUNCNAME} $@

	if [[ -z "$1" ]] ; then
		gnatbuild_src_install all
		return $?
	fi

	while [ "$1" ]; do
	case $1 in
	install) # runs provided make install
		debug-print-section install
		# Do not allow symlinks in /usr/lib/gcc/${CHOST}/${MY_PV}/include as
		# this can break the build.
		for x in "${GNATBUILD}"/gcc/include/* ; do
			if [ -L ${x} ] ; then
				rm -f ${x}
			fi
		done
		# Remove generated headers, as they can cause things to break
		# (ncurses, openssl, etc). (from toolchain.eclass)
		for x in $(find "${WORKDIR}"/build/gcc/include/ -name '*.h') ; do
			grep -q 'It has been auto-edited by fixincludes from' "${x}" \
				&& rm -f "${x}"
		done


		# Install gnatgcc, tools and native threads library
		cd "${GNATBUILD}"
		if [ "${PN_GnatGpl}-3.4.5.1" != "${P}" ]; then # this one is strange
			make DESTDIR=${D} install || die
			#make a convenience info link
			dosym ${DATAPATH}/info/gnat_ugn_unw.info ${DATAPATH}/info/gnat.info
		fi
		;;

	move_libs)
		debug-print-section move_libs
		# gcc insists on installing libs in its own place
		mv "${D}${LIBPATH}/gcc/${CTARGET}/${GCCRELEASE}"/* "${D}${LIBPATH}"
		if [ "${ARCH}" == "amd64" ]; then
			# ATTN! this may in fact be related to multilib, rather than amd64
			mv "${D}${LIBPATH}"/../lib64/libgcc_s* "${D}${LIBPATH}"
			mv "${D}${LIBPATH}"/../lib/libgcc_s* "${D}${LIBPATH}"/32/
		fi
		mv "${D}${LIBEXECPATH}/gcc/${CTARGET}/${GCCRELEASE}"/* "${D}${LIBEXECPATH}"

		# set the rts libs
		cd "${D}${LIBPATH}"
		mkdir rts-native
		mv adalib adainclude rts-native
		ln -s rts-native/adalib adalib
		ln -s rts-native/adainclude adainclude

		# force gnatgcc to use its own specs - when installed it reads specs
		# from system gcc location. Do the simple wrapper trick for now
		# !ATTN! change this if eselect-gnat starts to follow eselect-compiler
		cd "${D}${BINPATH}"
		mv gnatgcc gnatgcc_2wrap
		cat > gnatgcc << EOF
#! /bin/bash
# wrapper to cause gnatgcc read appropriate specs
BINDIR=\$(dirname \$0)
\${BINDIR}/gnatgcc_2wrap -specs="${LIBPATH}/specs" \$@
EOF
		chmod a+x gnatgcc

		# use gid of 0 because some stupid ports don't have
		# the group 'root' set to gid 0 (toolchain.eclass)
		chown -R root:0 "${D}${LIBPATH}"
		;;

	cleanup)
		debug-print-section cleanup

		rm -rf "${D}${LIBPATH}"/../li{b,b64}
		rm -rf "${D}${LIBPATH}/gcc"
		rm -rf "${D}${LIBEXECPATH}/gcc"
		rm -f "${D}${LIBPATH}"/libiberty.a # this one comes with binutils
		rmdir "${D}${LIBPATH}"/include/    # should be empty

		rm -rf "${D}${LIBEXECPATH}"/install-tools/

		# this one is installed by gcc and is a duplicate even here anyway
		rm -f "${D}${BINPATH}/${CTARGET}-gcc-${GCCRELEASE}"

		# remove duplicate docs
		cd "${D}${DATAPATH}"
		has noinfo ${FEATURES} \
			&& rm -rf info \
			|| rm -f info/{dir,gcc,cpp}*
		has noman  ${FEATURES} \
			&& rm -rf man \
			|| rm -rf man/man7/
		;;

	prep_env)
		#dodir /etc/env.d/gnat
		#create_gnat_env_entry
		# instead of putting junk under /etc/env.d/gnat we recreate env files as
		# needed with eselect
		create_eselect_conf
		;;

	all)
		gnatbuild_src_install install move_libs cleanup prep_env
		;;
	esac
	shift
	done # while
}