commit: b646a6bbe391980e38b851699291bb6c224bc3c5
Author: Stephen L Arnold <nerdboy <AT> gentoo <DOT> org>
AuthorDate: Sat Jun 4 02:44:44 2016 +0000
Commit: Steve Arnold <nerdboy <AT> gentoo <DOT> org>
CommitDate: Sat Jun 4 04:04:41 2016 +0000
URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=b646a6bb
gnatbuild-r1.eclass: version bump to r1
New version for updated gnat-gcc-4.9 and future releases. Supports new
bootstrap compilers, upstream config. Other arches in progress.
eclass/gnatbuild-r1.eclass | 1104 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 1104 insertions(+)
diff --git a/eclass/gnatbuild-r1.eclass b/eclass/gnatbuild-r1.eclass
new file mode 100644
index 0000000..0a53043
--- /dev/null
+++ b/eclass/gnatbuild-r1.eclass
@@ -0,0 +1,1104 @@
+# Copyright 1999-2016 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Id$
+#
+# Author: George Shapovalov <geo...@gentoo.org>
+# Author: Steve Arnold <nerd...@gentoo.org>
+# Belongs to: ada project <a...@gentoo.org>
+#
+# Notes:
+# HOMEPAGE and LICENSE are set in appropriate ebuild, as
+# gnat is developed by FSF and AdaCore "in parallel"
+#
+# The following vars can be set in ebuild before inheriting this eclass. They
+# will be respected:
+# SLOT
+# BOOT_SLOT - where old bootstrap is used as it works fine for 4.4 - 4.6
+
+#WANT_AUTOMAKE="1.8"
+#WANT_AUTOCONF="2.1"
+
+inherit eutils fixheadtails flag-o-matic gnuconfig libtool multilib pax-utils
toolchain-funcs versionator
+
+FEATURES=${FEATURES/multilib-strict/}
+
+EXPORTED_FUNCTIONS="pkg_setup pkg_postinst pkg_postrm src_unpack src_configure
src_compile src_install"
+
+EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS}
+
+IUSE="nls openmp hardened multilib"
+# multilib is supported via profiles now, multilib usevar is deprecated
+
+RDEPEND="virtual/libiconv
+ nls? ( virtual/libintl )"
+
+DEPEND="${RDEPEND}
+ >=app-eselect/eselect-gnat-1.5
+ >=sys-libs/glibc-2.12
+ >=sys-devel/binutils-2.23
+ sys-devel/bc
+ >=sys-devel/bison-1.875
+ >=sys-devel/flex-2.5.4
+ nls? ( sys-devel/gettext )"
+
+# Note!
+# It may not be safe to source this at top level. Only source inside local
+# functions!
+GnatCommon="/usr/share/gnat/lib/gnat-common.bash"
+
+#---->> 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)
+# this one is for the gnat-gpl which is versioned by gcc backend and ACT
version
+# number added on top
+ACT_Ver=$(get_version_component_range 4)
+
+# 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"
+
+# ATTN! GCCVER stands for the provided backend gcc, not the one on the system
+# so tc-* functions are of no use here. The present versioning scheme makes
+# GCCVER basically a part of PV, but *this may change*!!
+#
+# GCCVER can be set in the ebuild.
+[[ -z ${GCCVER} ]] && GCCVER="${GNATRELEASE}"
+
+
+# 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
+# There are some special cases, so we allow it to be defined in the ebuild
+# ATTN!! If you set SLOT in the ebuild, don't forget to make sure that
+# BOOT_SLOT is also set properly!
+[[ -z ${SLOT} ]] && SLOT="${GCCBRANCH}"
+
+# possible future crosscompilation support
+export CTARGET=${CTARGET:-${CHOST}}
+
+is_crosscompile() {
+ [[ ${CHOST} != ${CTARGET} ]]
+}
+
+# Bootstrap CTARGET and SLOT logic. For now BOOT_TARGET=CHOST is "guaranteed"
by
+# profiles, so mostly watch out for the right SLOT used in the bootstrap.
+# As above, with SLOT, it may need to be defined in the ebuild
+BOOT_TARGET=${CTARGET}
+[[ -z ${BOOT_SLOT} ]] && BOOT_SLOT=${SLOT}
+
+# for newer bootstrap starting with 4.9 (still experimental)
+BOOT_VER=${GCCRELEASE}
+
+# set our install locations
+PREFIX=${GNATBUILD_PREFIX:-/usr} # not sure we need this hook, but may be..
+LIBPATH=${PREFIX}/$(get_libdir)/${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}
+# ATTN! the one below should match the path defined in eselect-gnat module
+CONFIG_PATH="/usr/share/gnat/eselect"
+gnat_profile="${CTARGET}-${PN}-${SLOT}"
+gnat_config_file="${CONFIG_PATH}/${gnat_profile}"
+
+# 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
+GNATBOOT="${WORKDIR}/usr"
+GNATBUILD="${WORKDIR}/build"
+#GNATBUILD="${BUILD_DIR}"
+
+# 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
+
+#----<< global toolchain vars >>----
+
+: ${TARGET_ABI:=${ABI}}
+: ${TARGET_MULTILIB_ABIS:=${MULTILIB_ABIS}}
+: ${TARGET_DEFAULT_ABI:=${DEFAULT_ABI}}
+
+
+#---->> specs + env.d logic <<----
+# TODO!!!
+# set MANPATH, etc..
+#----<< specs + env.d logic >>----
+
+
+#---->> some helper functions <<----
+tc_version_is_at_least() {
+ version_is_at_least "$1" "${2:-${GCCBRANCH}}"
+}
+
+guess_patch_type_in_dir() {
+ [[ -n $(ls "$1"/*.bz2 2>/dev/null) ]] \
+ && EPATCH_SUFFIX="patch.bz2" \
+ || EPATCH_SUFFIX="patch"
+}
+
+# configure to build with the hardened GCC specs as the default
+make_gcc_hard() {
+ # we want to be able to control the pie patch logic via something other
+ # than ALL_CFLAGS...
+ sed -e '/^ALL_CFLAGS/iHARD_CFLAGS = ' \
+ -e 's|^ALL_CFLAGS = |ALL_CFLAGS = $(HARD_CFLAGS) |' \
+ -i "${S}"/gcc/Makefile.in
+ # Need to add HARD_CFLAGS to ALL_CXXFLAGS on >= 4.7
+ if tc_version_is_at_least 4.7 ; then
+ sed -e '/^ALL_CXXFLAGS/iHARD_CFLAGS = ' \
+ -e 's|^ALL_CXXFLAGS = |ALL_CXXFLAGS = $(HARD_CFLAGS)
|' \
+ -i "${S}"/gcc/Makefile.in
+ fi
+
+ # defaults to enable for new gnatbuild
+ if use hardened ; then
+ gcc_hard_flags=" -DEFAULT_PIE_SSP"
+ else
+ gcc_hard_flags+=" -DEFAULT_SSP"
+ fi
+
+ sed -i \
+ -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \
+ "${S}"/gcc/Makefile.in || die
+
+}
+
+gcc-multilib-configure() {
+ if ! is_multilib ; then
+ confgcc="${confgcc} --disable-multilib"
+ # Fun times: if we are building for a target that has multiple
+ # possible ABI formats, and the user has told us to pick one
+ # that isn't the default, then not specifying it via the list
+ # below will break that on us.
+ else
+ confgcc="${confgcc} --enable-multilib"
+ fi
+
+ # translate our notion of multilibs into gcc's
+ local abi list
+ for abi in $(get_all_abis TARGET) ; do
+ local l=$(gcc-abi-map ${abi})
+ [[ -n ${l} ]] && list+=",${l}"
+ done
+ if [[ -n ${list} ]] ; then
+ case ${CTARGET} in
+ x86_64*)
+ tc_version_is_at_least 4.8 && confgcc="${confgcc}
--with-multilib-list=${list:1}"
+ ;;
+ esac
+ fi
+}
+
+gcc-abi-map() {
+ # Convert the ABI name we use in Gentoo to what gcc uses
+ local map=()
+ case ${CTARGET} in
+ mips*) map=("o32 32" "n32 n32" "n64 64") ;;
+ x86_64*) map=("amd64 m64" "x86 m32" "x32 mx32") ;;
+ esac
+
+ local m
+ for m in "${map[@]}" ; do
+ l=( ${m} )
+ [[ $1 == ${l[0]} ]] && echo ${l[1]} && break
+ done
+}
+
+is_multilib() {
+ tc_version_is_at_least 3 || return 1
+ use multilib
+}
+
+## note: replaced with minspecs (sort of)
+#create_specs_file() {
+# einfo "Creating a vanilla gcc specs file"
+# "${WORKDIR}"/build/gcc/xgcc -dumpspecs >
"${WORKDIR}"/build/vanilla.specs
+#}
+
+# 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 >> "${D}/${gnat_config_file}"
+ if ! is_multilib ; then
+ echo " ctarget=${CTARGET}" >> "${D}/${gnat_config_file}"
+ else
+ echo "[${abi}]" >> "${D}/${gnat_config_file}"
+ var="CTARGET_${abi}"
+ if [[ -n ${!var} ]] ; then
+ echo " ctarget=${!var}" >> "${D}/${gnat_config_file}"
+ else
+ var="CHOST_${abi}"
+ if [[ -n ${!var} ]] ; then
+ echo " ctarget=${!var}" >>
"${D}/${gnat_config_file}"
+ else
+ echo " ctarget=${CTARGET}" >>
"${D}/${gnat_config_file}"
+ fi
+ fi
+ fi
+
+ var="CFLAGS_${abi}"
+ if [[ -n ${!var} ]] ; then
+ echo " cflags=${!var}" >> "${D}/${gnat_config_file}"
+ fi
+}
+
+create_eselect_conf() {
+ local abi
+
+ dodir ${CONFIG_PATH}
+
+ echo "[global]" > "${D}/${gnat_config_file}"
+ echo " version=${CTARGET}-${SLOT}" >> "${D}/${gnat_config_file}"
+ echo " binpath=${BINPATH}" >> "${D}/${gnat_config_file}"
+ echo " libexecpath=${LIBEXECPATH}" >> "${D}/${gnat_config_file}"
+ echo " ldpath=${LIBPATH}" >> "${D}/${gnat_config_file}"
+ echo " manpath=${DATAPATH}/man" >> "${D}/${gnat_config_file}"
+ echo " infopath=${DATAPATH}/info" >> "${D}/${gnat_config_file}"
+ echo " bin_prefix=${CTARGET}" >> "${D}/${gnat_config_file}"
+
+ for abi in $(get_all_abis) ; do
+ add_profile_eselect_conf "${gnat_config_file}" "${abi}"
+ done
+}
+
+should_we_eselect_gnat() {
+ # we only want to switch compilers if installing to / or /tmp/stage1root
+ [[ ${ROOT} == "/" ]] || return 1
+
+ # if the current config is invalid, we definitely want a new one
+ # Note: due to bash quirkiness, the following must not be 1 line
+ local curr_config
+ curr_config=$(eselect --colour=no gnat show | grep ${CTARGET} | awk '{
print $1 }') || return 0
+ [[ -z ${curr_config} ]] && return 0
+
+ # The logic is basically "try to keep the same profile if possible"
+
+ if [[ ${curr_config} == ${CTARGET}-${PN}-${SLOT} ]] ; then
+ return 0
+ else
+ elog "The current gcc config appears valid, so it will not be"
+ elog "automatically switched for you. If you would like to"
+ elog "switch to the newly installed gcc version, do the"
+ elog "following:"
+ echo
+ elog "eselect gnat set <profile>"
+ echo
+ ebeep
+ return 1
+ fi
+}
+
+# active compiler selection, called from pkg_postinst
+do_gnat_config() {
+ eselect gnat set ${CTARGET}-${PN}-${SLOT} &> /dev/null
+
+ elog "The following gnat profile has been activated:"
+ elog "${CTARGET}-${PN}-${SLOT}"
+ elog ""
+ elog "The compiler has been installed as gnatgcc, and the coverage
testing"
+ elog "tool as gnatgcov."
+ elog ""
+ elog "Ada handling in Gentoo allows you to have multiple gnat variants"
+ elog "installed in parallel and automatically manage Ada libs."
+ elog "Please take a look at the Ada project page for some
documentation:"
+ elog "http://www.gentoo.org/proj/en/prog_lang/ada/index.xml";
+}
+
+
+# Taken straight from the toolchain.eclass. Only removed the "obsolete hunk"
+#
+# The purpose of this DISGUSTING gcc multilib hack is to allow 64bit libs
+# to live in lib instead of lib64 where they belong, with 32bit libraries
+# in lib32. This hack has been around since the beginning of the amd64 port,
+# and we're only now starting to fix everything that's broken. Eventually
+# this should go away.
+#
+# Travis Tilley <l...@gentoo.org> (03 Sep 2004)
+#
+disgusting_gcc_multilib_HACK() {
+ local config
+ local libdirs
+ if has_multilib_profile ; then
+ case $(tc-arch) in
+ amd64)
+ config="i386/t-linux64"
+ libdirs="../$(get_abi_LIBDIR amd64)
../$(get_abi_LIBDIR x86)" \
+ ;;
+ ppc64)
+ config="rs6000/t-linux64"
+ libdirs="../$(get_abi_LIBDIR ppc64)
../$(get_abi_LIBDIR ppc)" \
+ ;;
+ esac
+ else
+ die "Your profile is no longer supported by portage."
+ fi
+
+ einfo "updating multilib directories to be: ${libdirs}"
+ sed -i -e "s:^MULTILIB_OSDIRNAMES.*:MULTILIB_OSDIRNAMES = ${libdirs}:"
"${S}"/gcc/config/${config}
+}
+
+
+#---->> pkg_* <<----
+gnatbuild-r1_pkg_setup() {
+ debug-print-function ${FUNCNAME} $@
+
+ # Setup variables which would normally be in the profile
+ if is_crosscompile ; then
+ multilib_env ${CTARGET}
+ fi
+
+ # we dont want to use the installed compiler's specs to build gnat!
+ unset GCC_SPECS
+ unset LANGUAGES #265283
+}
+
+gnatbuild-r1_pkg_postinst() {
+ if should_we_eselect_gnat; then
+ do_gnat_config
+ else
+ eselect gnat update
+ fi
+
+ # if primary compiler list is empty, add this profile to the list, so
+ # that users are not left without active compilers (making sure that
+ # libs are getting built for at least one)
+ elog
+ . ${GnatCommon} || die "failed to source common code"
+ if [[ ! -f ${PRIMELIST} ]] || [[ ! -s ${PRIMELIST} ]]; then
+ echo "${gnat_profile}" > ${PRIMELIST}
+ elog "The list of primary compilers was empty and got assigned
${gnat_profile}."
+ fi
+ elog "Please edit ${PRIMELIST} and list there gnat profiles intended"
+ elog "for common use."
+}
+
+
+gnatbuild-r1_pkg_postrm() {
+ # "eselect gnat update" now removes the env.d file if the corresponding
+ # gnat profile was unmerged
+ eselect gnat update
+ elog "If you just unmerged the last gnat in this SLOT, your active gnat"
+ elog "profile got unset. Please check what eselect gnat show tells you"
+ elog "and set the desired profile"
+}
+#---->> pkg_* <<----
+
+#---->> src_* <<----
+
+# common unpack stuff
+gnatbuild-r1_src_unpack() {
+ debug-print-function ${FUNCNAME} $@
+
+ [ -z "$1" ] && gnatbuild-r1_src_unpack all
+
+ while [ "$1" ]; do
+ case $1 in
+ base_unpack)
+ unpack ${A}
+ pax-mark E $(find ${GNATBOOT} -name gnat1)
+
+ cd "${S}"
+ # patching gcc sources, following the toolchain
+ # first, the common patches
+ guess_patch_type_in_dir "${WORKDIR}"/patch
+ EPATCH_MULTI_MSG="Applying common Gentoo patches ..." \
+ epatch "${WORKDIR}"/patch
+ guess_patch_type_in_dir "${WORKDIR}"/piepatch
+ EPATCH_MULTI_MSG="Applying Gentoo PIE patches ..." \
+ epatch "${WORKDIR}"/piepatch
+
+ if [[ -d "${FILESDIR}"/patches ]] && [[ ! -z $(ls
"${FILESDIR}"/patches/*.patch 2>/dev/null) ]] ; then
+ EPATCH_MULTI_MSG="Applying local Gentoo patches
..." \
+ epatch "${FILESDIR}"/patches/*.patch
+ fi
+ #
+ # then per SLOT
+ if [[ -d "${FILESDIR}"/patches/${SLOT} ]] && [[ ! -z
$(ls "${FILESDIR}"/patches/${SLOT}/*.patch 2>/dev/null) ]] ; then
+ EPATCH_MULTI_MSG="Applying SLOT-specific Gentoo
patches ..." \
+ epatch "${FILESDIR}"/patches/${SLOT}/*.patch
+ fi
+
+ # add hardening as per toolchain eclass
+ make_gcc_hard
+
+ # Replacing obsolete head/tail with POSIX compliant ones
+ ht_fix_file */configure
+
+# if ! is_crosscompile && is_multilib && \
+# [[ ( $(tc-arch) == "amd64" || $(tc-arch) ==
"ppc64" ) && -z ${SKIP_MULTILIB_HACK} ]] ; then
+# disgusting_gcc_multilib_HACK || die
"multilib hack failed"
+# fi
+
+ # Fixup libtool to correctly generate .la files with
portage
+ cd "${S}"
+ elibtoolize --portage --shallow --no-uclibc
+
+ gnuconfig_update
+ # update configure files
+ einfo "Fixing misc issues in configure files"
+ for f in $(grep -l 'autoconf version 2.13' $(find
"${S}" -name configure)) ; do
+ ebegin " Updating ${f}"
+ patch "${f}"
"${FILESDIR}"/gcc-configure-LANG.patch >& "${T}"/configure-patch.log \
+ || eerror "Please file a bug about this"
+ eend $?
+ done
+
+ # apply global slot/path patch
+ EPATCH_MULTI_MSG="Adjusting default paths for gnat-gcc
..." \
+ epatch
"${FILESDIR}"/${PN}-4.9.3-make-default-paths-match-slot.patch
+ sed -i -e "s|SLOT_MARKER|${BOOT_SLOT}|"
"${S}"/gcc/Makefile.in
+
+ [[ ${CHOST} == ${CTARGET} ]] && epatch
"${FILESDIR}"/gcc-spec-env-r1.patch
+
+# this is only needed for gnat-gpl-4.1 and breaks for
gnat-gcc, so
+# this block was moved to corresponding ebuild
+# pushd "${S}"/gnattools &> /dev/null
+# eautoconf
+# popd &> /dev/null
+ ;;
+
+ common_prep)
+ # Prepare the gcc source directory
+ cd "${S}/gcc"
+ 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 for 3.4* backend
+ if [ "3.4" == "${GCCBRANCH}" ] ; then
+ cd ada
+ epatch "${FILESDIR}"/gnat-Make-lang.in.patch
+ fi
+
+ # gcc 4.3 sources seem to have a common omission of
$(DESTDIR),
+ # that leads to make install trying to rm -f file on
live system.
+ # As we do not need this rm, we simply remove the whole
line
+ if [ "4.3" == "${GCCBRANCH}" ] ; then
+ sed -i -e "/\$(RM) \$(bindir)/d"
"${S}"/gcc/ada/Make-lang.in
+ fi
+
+ find "${S}" -name Makefile.in \
+ -exec sed -i
'/^pkgconfigdir/s:=.*:=$(toolexeclibdir)/pkgconfig:' {} +
+
+ mkdir -p "${GNATBUILD}"
+ ;;
+
+ all)
+ gnatbuild-r1_src_unpack base_unpack common_prep
+ ;;
+ esac
+ shift
+ done
+}
+
+# for now just dont run default configure
+gnatbuild-r1_src_configure() {
+ :
+}
+
+# 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-r1_src_compile() {
+ debug-print-function ${FUNCNAME} $@
+
+ if [[ -z "$1" ]]; then
+ gnatbuild-r1_src_compile all
+ return $?
+ fi
+
+ if [[ "all" == "$1" ]]
+ then # specialcasing "all" to avoid scanning sources unnecessarily
+ gnatbuild-r1_src_compile configure make-tools \
+ bootstrap gnatlib_and_tools gnatlib-shared
+
+ else
+ # Set some paths to our bootstrap compiler.
+ export PATH="${GNATBOOT}/bin:${PATH}"
+ # !ATTN! the bootstrap compilers have a very simplystic
structure,
+ # so many paths are not identical to the installed ones.
+ # Plus it was simplified even more in new releases.
+ if [[ ${BOOT_SLOT} > 4.1 ]] ; then
+ case $(tc-arch) in
+ arm)
+
GNATLIB="${GNATBOOT}/lib/gcc/${BOOT_TARGET}/${BOOT_SLOT}"
+ ;;
+ x86|amd64)
+
GNATLIB="${GNATBOOT}/lib/gcc/${BOOT_TARGET}/${BOOT_VER}"
+ ;;
+ *)
+ GNATLIB="${GNATBOOT}/lib"
+ ;;
+ esac
+ else
+
GNATLIB="${GNATBOOT}/lib/gnatgcc/${BOOT_TARGET}/${BOOT_SLOT}"
+ fi
+
+ export CC="${GNATBOOT}/bin/gnatgcc"
+ export CXX="${GNATBOOT}/bin/gnatg++"
+ export LDFLAGS="${LDFLAGS}"
+ export CFLAGS="${CFLAGS}"
+ export CXXFLAGS="${CFLAGS}"
+ # CPATH is supposed to be applied for any language, thus
+ # superceding either of C/CPLUS/OBJC_INCLUDE_PATHs
+ export CPATH="${GNATLIB}/include"
+ LIB_DIR="${GNATLIB}"
+ LDFLAGS="${LDFLAGS} -L${GNATLIB}"
+
+ # additional vars from gnuada and elsewhere
+ export LIBRARY_PATH="${GNATLIB}"
+
+ STDCXX_INCDIR="${LIBPATH}/include/g++-v${SLOT/\.*/}"
+
+ export ADA_OBJECTS_PATH="${GNATLIB}/adalib"
+ export ADA_INCLUDE_PATH="${GNATLIB}/adainclude"
+
+ while [ "$1" ]; do
+ case $1 in
+ configure)
+ debug-print-section configure
+
+ # Configure gcc
+ local confgcc
+ confgcc="${confgcc} --host=${CHOST}"
+
+ # some cross-compile logic from toolchain
+ 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
+
+ if tc_version_is_at_least 4.6 ; then
+ confgcc="${confgcc} --enable-lto"
+ else
+ confgcc="${confgcc} --disable-lto"
+ fi
+
+ # setup multilib abi stuff
+ gcc-multilib-configure
+
+ use hardened && confgcc="${confgcc}
--enable-esp"
+
+ # reasonably sane globals (from toolchain)
+ # also disable mudflap and ssp
+ confgcc="${confgcc} \
+ --enable-languages="c,ada,c++" \
+ --with-gcc \
+ --with-system-zlib \
+ --enable-obsolete \
+ --enable-secureplt \
+ --disable-werror \
+ --enable-checking=release \
+ --enable-libstdcxx-time \
+ --disable-libmudflap \
+ --disable-libssp \
+ --disable-altivec \
+ --disable-fixed-point \
+ --disable-libgcj \
+ --disable-libcilkrts \
+ --disable-libquadmath \
+ --enable-libsanitizer \
+ --enable-targets=all \
+ --with-bugurl=https://bugs.gentoo.org/ \
+
--with-python-dir=${DATAPATH/$PREFIX/}/python"
+
+ if in_iuse openmp ; then
+ # Make sure target has pthreads
support. #326757 #335883
+ # There shouldn't be a chicken&egg
problem here as openmp won't
+ # build without a C library, and you
can't build that w/out
+ # already having a compiler ...
+ if ! is_crosscompile || \
+ $(tc-getCPP ${CTARGET}) -E -
<<<"#include <pthread.h>" >& /dev/null
+ then
+ case $(tc-arch) in
+ arm)
+
confgcc="${confgcc} --disable-libgomp"
+ ;;
+ *)
+ if use openmp ;
then
+
confgcc="${confgcc} --enable-libgomp"
+ else
+
confgcc="${confgcc} --disable-libgomp"
+ fi
+ ;;
+ esac
+ else
+ # Force disable as the
configure script can be dumb #359855
+ confgcc="${confgcc}
--disable-libgomp"
+ fi
+ else
+ # For gcc variants where we don't want
openmp (e.g. kgcc)
+ confgcc="${confgcc} --disable-libgomp"
+ fi
+
+ # ACT's gnat-gpl does not like libada for
whatever reason..
+ if tc_version_is_at_least 4.2 ; then
+ confgcc="${confgcc} --enable-libada"
+# else
+# einfo "ACT's gnat-gpl does not like
libada, disabling"
+# confgcc="${confgcc} --disable-libada"
+ fi
+
+ # set some specifics available in later versions
+ confgcc="${confgcc} --enable-shared"
+ if tc_version_is_at_least 4.7 ; then
+ einfo "setting gnat thread model"
+ confgcc="${confgcc}
--enable-threads=posix"
+ confgcc="${confgcc}
--enable-shared=boehm-gc,ada,libada"
+ elif tc_version_is_at_least 4.3 ; then
+ confgcc="${confgcc}
--enable-threads=gnat"
+ confgcc="${confgcc}
--enable-shared=boehm-gc,ada,libada"
+ else
+ confgcc="${confgcc}
--enable-threads=posix"
+ fi
+
+ # harfloat vs soft
+ case $(tc-is-softfloat) in
+ yes) confgcc="${confgcc} --with-float=soft"
;;
+ softfp) confgcc="${confgcc}
--with-float=softfp" ;;
+ *)
+ # If they've explicitly opt-ed in, do
hardfloat,
+ # otherwise let the gcc default kick in.
+ case ${CTARGET//_/-} in
+ *-hardfloat-*|*eabihf)
confgcc="${confgcc} --with-float=hard" ;;
+ esac
+ esac
+
+ # multilib and arch support
+ case $(tc-arch) in
+ arm)
+ local a arm_arch=${CTARGET%%-*}
+ # Remove trailing endian variations
first: eb el be bl b l
+ for a in e{b,l} {b,l}e b l ; do
+ if [[ ${arm_arch} == *${a} ]] ;
then
+
arm_arch=${arm_arch%${a}}
+ break
+ fi
+ done
+ # Convert armv7{a,r,m} to armv7-{a,r,m}
+ [[ ${arm_arch} == armv7? ]] &&
arm_arch=${arm_arch/7/7-}
+ # See if this is a valid --with-arch
flag
+ if (srcdir=${S}/gcc target=${CTARGET}
with_arch=${arm_arch};
+ . "${srcdir}"/config.gcc)
&>/dev/null
+ then
+ confgcc="${confgcc}
--with-arch=${arm_arch}"
+ fi
+
+ # Make default mode thumb for
microcontroller classes #418209
+ [[ ${arm_arch} == *-m ]] &&
confgcc="${confgcc} --with-mode=thumb"
+
+ # Enable hardvfp
+ if [[ $(tc-is-softfloat) == "no" ]] && \
+ [[ ${CTARGET} == armv[67]* ]]
+ then
+ # Follow the new arm hardfp
distro standard by default
+ confgcc="${confgcc}
--with-float=hard"
+ case ${CTARGET} in
+ armv6*) confgcc="${confgcc}
--with-fpu=vfp" ;;
+ armv7*) confgcc="${confgcc}
--with-fpu=vfpv3-d16" ;;
+ esac
+ fi
+ ;;
+ mips)
+ # Add --with-abi flags to set default
ABI
+ confgcc="${confgcc}
--with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI})"
+ ;;
+ ppc)
+ # Set up defaults based on current
CFLAGS
+ is-flagq -mfloat-gprs=double &&
confgcc="${confgcc} --enable-e500-double"
+ [[ ${CTARGET//_/-} == *-e500v2-* ]] &&
confgcc="${confgcc} --enable-e500-double"
+ ;;
+ amd64)
+ if is_multilib ; then
+ confgcc="${confgcc}
--enable-multilib"
+ if has x32 $(get_all_abis
TARGET) ; then
+ confgcc="${confgcc}
--with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI})"
+ fi
+ else
+ confgcc="${confgcc}
--disable-multilib"
+ fi
+ ;;
+ x86)
+ confgcc="${confgcc}
--with-arch=${CTARGET%%-*}"
+ confgcc="${confgcc} --disable-multilib"
+ ;;
+ esac
+
+ # __cxa_atexit is "essential for fully
standards-compliant handling of
+ # destructors", but apparently requires glibc.
+ if [[ ${CTARGET} == *-gnu* ]] ; then
+ confgcc="${confgcc}
--enable-__cxa_atexit"
+ confgcc="${confgcc}
--enable-clocale=gnu"
+ fi
+
+ export gcc_cv_lto_plugin=1 # okay to build,
default to opt-in
+ export gcc_cv_prog_makeinfo_modern=no
+ export ac_cv_have_x='have_x=yes ac_x_includes=
ac_x_libraries='
+ use hardened && export
gcc_cv_libc_provides_ssp=yes
+
+ # need to strip graphite/lto flags or we'll get
the
+ # dreaded C compiler cannot create
executables...
+ # error.
+# filter-flags -floop-interchange
-floop-strip-mine -floop-block
+# filter-flags -fuse-linker-plugin -flto*
+ strip-flags
+ replace-flags -O? -O2
+ filter-flags '-mabi*' -m31 -m32 -m64
+ filter-flags -frecord-gcc-switches
+ filter-flags -mno-rtm -mno-htm
+
+ # gold linker barfs on some arches/configs :/
+ #tc-ld-is-gold && tc-ld-disable-gold
+
+ case $(tc-arch) in
+ amd64|x86)
+ filter-flags '-mcpu=*'
+ ;;
+ *)
+ ;;
+ esac
+
+# strip-unsupported-flags
+
+ STAGE1_CFLAGS="${CFLAGS} -fPIC"
+ use hardened && STAGE1_CFLAGS="-O2 -fPIC"
+ BOOT_CFLAGS="$(get_abi_CFLAGS
${TARGET_DEFAULT_ABI}) ${CFLAGS} -fPIC"
+ is_crosscompile && BOOT_CFLAGS="-O2 -fPIC"
+
+ einfo "Environment vars:
+ CC=${CC},
+ CXX=${CXX},
+ CTARGET=${CTARGET}
+ ABI=${TARGET_DEFAULT_ABI},
+ TARGET_ABI=${TARGET_ABI}.
+ TARGET_MULTILIB_ABIS=${TARGET_MULTILIB_ABIS},
+ TARGET_DEFAULT_ABI=${TARGET_DEFAULT_ABI},
+ GCC_ABI=$(gcc-abi-map ${TARGET_DEFAULT_ABI})
+ ADA_OBJECTS_PATH=${ADA_OBJECTS_PATH},
+ ADA_INCLUDE_PATH=${ADA_INCLUDE_PATH},
+ PATH=${PATH}"
+
+ confgcc="${confgcc} ${EXTRA_ECONF}"
+ einfo "Configuring with confgcc=${confgcc}"
+
+ pushd "${GNATBUILD}" > /dev/null
+ CC="${CC}" CXX="${CXX}" \
+ LDFLAGS="${LDFLAGS}" \
+ CFLAGS="${CFLAGS}" \
+ CXXFLAGS="${CFLAGS}" \
+ "${S}"/configure \
+ --prefix="${PREFIX}" \
+ --bindir="${BINPATH}" \
+ --includedir="${INCLUDEPATH}" \
+ --datadir="${DATAPATH}" \
+ --mandir="${DATAPATH}"/man \
+ --infodir="${DATAPATH}"/info \
+
--with-gxx-include-dir="${STDCXX_INCDIR}" \
+ --with-pkgversion="Gentoo Hardened
${GNATRELEASE} p${PATCH_VER}, pie-${PIE_VER}" \
+ ${confgcc} || die "configure failed"
+ popd > /dev/null
+ ;;
+
+ 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 .
+ cp "${S}"/gcc/ada/xutil.ad{s,b} .
+ if (( ${GNATMINOR} > 5 )) ; then
+ cp "${S}"/gcc/ada/einfo.ad{s,b} .
+ cp "${S}"/gcc/ada/csinfo.adb .
+ cp "${S}"/gcc/ada/ceinfo.adb .
+ fi
+
+ gnatmake xtreeprs && \
+ gnatmake xsinfo && \
+ gnatmake xeinfo && \
+ gnatmake xnmake || die "building helper tools"
+
+ mv xeinfo xnmake xsinfo xtreeprs bin/
+ ;;
+
+ bootstrap)
+ debug-print-section bootstrap
+ # and, finally, the build itself
+ # do we need this? STAGE1_CFLAGS="${CFLAGS}"
+ # or this? bootstrap-lean
+ # removing both to try --disable-bootstrap
+ pushd "${GNATBUILD}" >/dev/null
+
+ emake \
+ LDFLAGS="${LDFLAGS}" \
+ LIBPATH="${LIBPATH}" \
+ CC="${CC}" CXX="${CXX}" \
+ STAGE1_CFLAGS="${STAGE1_CFLAGS}" \
+ LIBRARY_VERSION="${SLOT}" \
+ BOOT_CFLAGS="${BOOT_CFLAGS}" \
+ bootstrap-lean \
+ || die "bootstrap failed"
+
+ popd >/dev/null
+ ;;
+
+ 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="${SLOT}" || \
+ die "gnatlib-shared failed"
+ ;;
+
+ esac
+ shift
+ done # while
+ fi # "all" == "$1"
+}
+# -- end gnatbuild-r1_src_compile
+
+
+gnatbuild-r1_src_install() {
+ debug-print-function ${FUNCNAME} $@
+
+ if [[ -z "$1" ]] ; then
+ gnatbuild-r1_src_install all
+ return $?
+ fi
+
+ while [ "$1" ]; do
+ case $1 in
+ install) # runs provided make install
+ debug-print-section install
+
+ # Looks like we need an access to the bootstrap compiler here
too
+ # as gnat apparently wants to compile something during the
installation
+ # The spotted obuser was xgnatugn, used to process
gnat_ugn_urw.texi,
+ # during preparison of the docs.
+ export PATH="${GNATBOOT}/bin:${PATH}"
+ if [[ ${BOOT_SLOT} > 4.1 ]] ; then
+ GNATLIB="${GNATBOOT}/lib"
+ elif [[ ${BOOT_SLOT} > 4.8 ]] ; then
+
GNATLIB="${GNATBOOT}/lib/gnatgcc/${BOOT_TARGET}/${BOOT_VER}"
+ else
+
GNATLIB="${GNATBOOT}/lib/gnatgcc/${BOOT_TARGET}/${BOOT_SLOT}"
+ fi
+
+ export CC="${GNATBOOT}/bin/gnatgcc"
+ #export INCLUDE_DIR="${GNATLIB}/include"
+ #export C_INCLUDE_PATH="${GNATLIB}/include"
+ #export CPLUS_INCLUDE_PATH="${GNATLIB}/include"
+ export ADA_OBJECTS_PATH="${GNATLIB}/adalib"
+ export ADA_INCLUDE_PATH="${GNATLIB}/adainclude"
+
+ # Do not allow symlinks in
/usr/lib/gcc/${CHOST}/${MY_PV}/include as
+ # this can break the build.
+ find "${GNATBUILD}"/\*gcc/include/ -type l -delete
+
+ # 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
+
+
+ cd "${GNATBUILD}"
+ make -j1 DESTDIR="${D}" install || die
+
+ find "${D}" -name install-tools -prune -type d -exec rm -rf
"{}" \;
+ find "${D}" -name libiberty.a -delete
+
+ # Disable RANDMMAP so PCH works. #301299
+ pax-mark r "${D}${LIBEXECPATH}"/{gnat1,cc1,cc1plus}
+
+ # Quiet QA warnings, wait for adacore exec stack patch in gcc 7
+ # (note: needs testing with hardened emulate trampolines)
+ #if use hardened ; then
+ # pax-mark Emr
"${D}"${BINPATH}/{gnatmake,gnatname,gnatls,gnatclean,gnat}
+ #else
+ # export QA_EXECSTACK="${BINPATH:1}/gnatls
${BINPATH:1}/gnatname
+ # ${BINPATH:1}/gnatmake ${BINPATH:1}/gnatclean
${BINPATH:1}/gnat
+ # ${LIBEXECPATH:1}/gnat1
${LIBPATH:1}/adalib/libgnat-${SLOT}.so"
+ #fi
+# export QA_EXECSTACK="${BINPATH:1}/gnatls ${BINPATH:1}/gnatname
+# ${BINPATH:1}/gnatmake ${BINPATH:1}/gnatclean
${BINPATH:1}/gnat"
+
+ use hardened && pax-mark E
"${D}${BINPATH}"/{gnatmake,gnatname,gnatls,gnatclean,gnat}
+
+ if use doc ; then
+ if (( $(bc <<< "${GNATBRANCH} > 4.3") )) ; then
+ #make a convenience info link
+ ewarn "Yay! Math works."
+ dosym gnat_ugn.info ${DATAPATH}/info/gnat.info
+ fi
+ fi
+ ;;
+
+ move_libs)
+ debug-print-section move_libs
+
+ # first we need to remove some stuff to make moving easier
+ #rm -rf "${D}${LIBPATH}"/{32,include}
+ # gcc insists on installing libs in its own place
+ cp -a -t "${D}${LIBPATH}"/
"${D}${PREFIX}"/lib/gcc/"${CTARGET}/${GCCRELEASE}"/*
+ cp -a -t "${D}${LIBEXECPATH}"/
"${D}${PREFIX}"/libexec/gcc/"${CTARGET}/${GCCRELEASE}"/*
+ rm -rf "${D}${PREFIX}"/libexec/gcc
+
+ # libgcc_s and, with gcc>=4.0, other libs get installed in
multilib specific locations by gcc
+ # we pull everything together to simplify working environment
+ if is_multilib ; then
+ case $(tc-arch) in
+ amd64)
+ cp -a -t "${D}${LIBPATH}"/
"${D}${PREFIX}"/lib/"${PN}/${CTARGET}/${SLOT}"/*
+ mv -t "${D}${LIBPATH}"/32/
"${D}${PREFIX}"/lib32/*
+ mv -t "${D}${LIBPATH}"/
"${D}${PREFIX}"/lib64/lib*
+ rm -rf "${D}${PREFIX}"/lib
"${D}${PREFIX}"/lib32
+ ;;
+ ppc64)
+ # not supported yet, will have to be
adjusted when we
+ # actually build gnat for that arch
+ ;;
+ esac
+ else
+ # x86 cleanup (maybe arm)
+ mv -t "${D}${LIBPATH}"/
"${D}${PREFIX}/lib/gcc/${CTARGET}/${GCCRELEASE}"/*
+ mv -t "${D}${LIBPATH}"/ "${D}${PREFIX}"/lib/lib*
+ #mv -t "${D}${LIBPATH}"/include/
"${D}${LIBPATH}"/gcc/"${CTARGET}/${GCCRELEASE}"/include/*
+ rm -rf "${D}${PREFIX}"/lib/gcc
+ rm -rf "${D}${LIBPATH}"/gcc
+ fi
+
+ local py
gdbdir=/usr/share/gdb/auto-load${LIBPATH/\/lib\//\/$(get_libdir)\/}
+ pushd "${D}${LIBPATH}" >/dev/null
+ for py in $(find . -name '*-gdb.py') ; do
+ local multidir=${py%/*}
+ insinto "${gdbdir}/${multidir}"
+ sed -i "/^libdir =/s:=.*:= '${LIBPATH}/${multidir}':"
"${py}" || die
+ doins "${py}" || die
+ rm "${py}" || die
+ done
+ popd >/dev/null
+ ;;
+
+ cleanup)
+ debug-print-section cleanup
+
+ # force gnatgcc to use its own specs - versions prior to 3.4.6
read 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}"
+ if [[ ${GCCVER} < 3.4.6 ]] ; then
+ # gcc 4.1 uses builtin specs. What about 4.0?
+ mv gnatgcc gnatgcc_2wrap
+ cat > gnatgcc << EOF
+#! /bin/bash
+# wrapper to cause gnatgcc read appropriate specs and search for the right .h
+# files (in case no matching gcc is installed)
+BINDIR=\$(dirname \$0)
+# The paths in the next line have to be absolute, as gnatgcc may be called from
+# any location
+\${BINDIR}/gnatgcc_2wrap -specs="${LIBPATH}/specs" -I"${LIBPATH}/include" \$@
+EOF
+ chmod a+x gnatgcc
+ else
+ local i
+ for i in cpp gcc gcov c++ g++ ; do
+ ln -s ${i} gnat${i}
+ done
+ fi
+
+ # earlier gnat's generate some Makefile's at generic location,
need to
+ # move to avoid collisions
+ [ -f "${D}${PREFIX}"/share/gnat/Makefile.generic ] &&
+ mv "${D}${PREFIX}"/share/gnat/Makefile.*
"${D}${DATAPATH}"
+
+ rm -rf "${D}${LIBPATH}"/install-tools
"${D}${LIBEXECPATH}"/install-tools
+
+ # remove duplicate docs
+ rm -rf "${D}${DATAPATH}"/info
+ rm -rf "${D}${DATAPATH}"/man
+
+ # fix .la path for lto plugin
+ [ -f "${D}${LIBEXECPATH}"/liblto_plugin.la ] &&
+ sed -i -e \
+ "/libdir=/c\libdir='${LIBEXECPATH}'" \
+ "${D}${LIBEXECPATH}"/liblto_plugin.la
+
+ # 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}" 2>/dev/null
+
+ # add hardening spec stuff
+ if use hardened ; then
+ insinto "${LIBPATH}"
+ doins "${WORKDIR}"/specs/*.specs || die "failed to
install specs"
+ fi
+ ;;
+
+ prep_env)
+ # instead of putting junk under /etc/env.d/gnat we recreate env
files as
+ # needed with eselect
+ create_eselect_conf
+ ;;
+
+ all)
+ # remove the move to test new install paths # move_libs
+ gnatbuild-r1_src_install install move_libs cleanup prep_env
+ ;;
+ esac
+ shift
+ done # while
+}
+# -- end gnatbuild-r1_src_install
