diff options
Diffstat (limited to 'eclass')
-rw-r--r-- | eclass/toolchain-binutils.eclass | 476 | ||||
-rw-r--r-- | eclass/toolchain.eclass | 2128 | ||||
-rw-r--r-- | eclass/wxwidgets.eclass | 285 |
3 files changed, 2889 insertions, 0 deletions
diff --git a/eclass/toolchain-binutils.eclass b/eclass/toolchain-binutils.eclass new file mode 100644 index 0000000..d9197e0 --- /dev/null +++ b/eclass/toolchain-binutils.eclass @@ -0,0 +1,476 @@ +# Copyright 1999-2012 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-binutils.eclass,v 1.123 2013/02/09 04:32:48 vapier Exp $ +# +# Maintainer: Toolchain Ninjas <toolchain@gentoo.org> +# +# We install binutils into CTARGET-VERSION specific directories. This lets +# us easily merge multiple versions for multiple targets (if we wish) and +# then switch the versions on the fly (with `binutils-config`). +# +# binutils-99999999 -> live cvs +# binutils-9999 -> live git +# binutils-9999_preYYMMDD -> nightly snapshot date YYMMDD +# binutils-# -> normal release + +extra_eclass="" +if [[ -n ${BINUTILS_TYPE} ]] ; then + BTYPE=${BINUTILS_TYPE} +else + case ${PV} in + 99999999) BTYPE="cvs";; + 9999) BTYPE="git";; + 9999_pre*) BTYPE="snap";; + *.*.90) BTYPE="snap";; + *.*.*.*.*) BTYPE="hjlu";; + *) BTYPE="rel";; + esac +fi + +case ${BTYPE} in +cvs) + extra_eclass="cvs" + ECVS_SERVER="sourceware.org:/cvs/src" + ECVS_MODULE="binutils" + ECVS_USER="anoncvs" + ECVS_PASS="anoncvs" + BVER="cvs" + ;; +git) + extra_eclass="git-2" + BVER="git" + EGIT_REPO_URI="git://sourceware.org/git/binutils.git" + ;; +snap) + BVER=${PV/9999_pre} + ;; +*) + BVER=${BINUTILS_VER:-${PV}} + ;; +esac + +inherit eutils libtool flag-o-matic gnuconfig multilib versionator unpacker ${extra_eclass} +EXPORT_FUNCTIONS src_unpack src_compile src_test src_install pkg_postinst pkg_postrm + +export CTARGET=${CTARGET:-${CHOST}} +if [[ ${CTARGET} == ${CHOST} ]] ; then + if [[ ${CATEGORY/cross-} != ${CATEGORY} ]] ; then + export CTARGET=${CATEGORY/cross-} + fi +fi +is_cross() { [[ ${CHOST} != ${CTARGET} ]] ; } + +DESCRIPTION="Tools necessary to build programs" +HOMEPAGE="http://sourceware.org/binutils/" + +case ${BTYPE} in + cvs|git) SRC_URI="" ;; + snap) + SRC_URI="ftp://gcc.gnu.org/pub/binutils/snapshots/binutils-${BVER}.tar.bz2 + ftp://sourceware.org/pub/binutils/snapshots/binutils-${BVER}.tar.bz2" ;; + hjlu) + SRC_URI="mirror://kernel/linux/devel/binutils/binutils-${BVER}.tar." + version_is_at_least 2.21.51.0.5 && SRC_URI+="xz" || SRC_URI+="bz2" ;; + rel) SRC_URI="mirror://gnu/binutils/binutils-${BVER}.tar.bz2" ;; +esac +add_src_uri() { + [[ -z $2 ]] && return + local a=$1 + if version_is_at_least 2.22.52.0.2 ; then + a+=".xz" + else + a+=".bz2" + fi + set -- mirror://gentoo http://dev.gentoo.org/~vapier/dist + SRC_URI="${SRC_URI} ${@/%//${a}}" +} +add_src_uri binutils-${BVER}-patches-${PATCHVER}.tar ${PATCHVER} +add_src_uri binutils-${BVER}-uclibc-patches-${UCLIBC_PATCHVER}.tar ${UCLIBC_PATCHVER} +add_src_uri elf2flt-${ELF2FLT_VER}.tar ${ELF2FLT_VER} + +if version_is_at_least 2.18 ; then + LICENSE="|| ( GPL-3 LGPL-3 )" +else + LICENSE="|| ( GPL-2 LGPL-2 )" +fi +IUSE="cxx nls multitarget multislot static-libs test vanilla" +if version_is_at_least 2.19 ; then + IUSE+=" zlib" +fi +if use multislot ; then + SLOT="${BVER}" +else + SLOT="0" +fi + +RDEPEND=">=sys-devel/binutils-config-1.9" +in_iuse zlib && RDEPEND+=" zlib? ( sys-libs/zlib )" +DEPEND="${RDEPEND} + test? ( dev-util/dejagnu ) + nls? ( sys-devel/gettext ) + sys-devel/flex + virtual/yacc" + +S=${WORKDIR}/binutils +case ${BVER} in +cvs|git) ;; +*) S=${S}-${BVER} ;; +esac + +LIBPATH=/usr/$(get_libdir)/binutils/${CTARGET}/${BVER} +INCPATH=${LIBPATH}/include +DATAPATH=/usr/share/binutils-data/${CTARGET}/${BVER} +MY_BUILDDIR=${WORKDIR}/build +if is_cross ; then + BINPATH=/usr/${CHOST}/${CTARGET}/binutils-bin/${BVER} +else + BINPATH=/usr/${CTARGET}/binutils-bin/${BVER} +fi + +tc-binutils_unpack() { + case ${BTYPE} in + cvs) cvs_src_unpack ;; + git) git-2_src_unpack ;; + *) unpacker ${A} ;; + esac + mkdir -p "${MY_BUILDDIR}" + [[ -d ${WORKDIR}/patch ]] && mkdir "${WORKDIR}"/patch/skip +} + +# In case the ebuild wants to add a few of their own. +PATCHES=() + +tc-binutils_apply_patches() { + cd "${S}" + + if ! use vanilla ; then + if [[ -n ${PATCHVER} ]] ; then + EPATCH_SOURCE=${WORKDIR}/patch + if [[ ${CTARGET} == mips* ]] ; then + # remove gnu-hash for mips (bug #233233) + EPATCH_EXCLUDE+=" 77_all_generate-gnu-hash.patch" + fi + [[ -n $(ls "${EPATCH_SOURCE}"/*.bz2 2>/dev/null) ]] \ + && EPATCH_SUFFIX="patch.bz2" \ + || EPATCH_SUFFIX="patch" + epatch + fi + if [[ -n ${UCLIBC_PATCHVER} ]] ; then + EPATCH_SOURCE=${WORKDIR}/uclibc-patches + [[ -n $(ls "${EPATCH_SOURCE}"/*.bz2 2>/dev/null) ]] \ + && EPATCH_SUFFIX="patch.bz2" \ + || EPATCH_SUFFIX="patch" + EPATCH_MULTI_MSG="Applying uClibc fixes ..." \ + epatch + elif [[ ${CTARGET} == *-uclibc* ]] ; then + # starting with binutils-2.17.50.0.17, we no longer need + # uClibc patchsets :D + if grep -qs 'linux-gnu' "${S}"/ltconfig ; then + die "sorry, but this binutils doesn't yet support uClibc :(" + fi + fi + [[ ${#PATCHES[@]} -gt 0 ]] && epatch "${PATCHES[@]}" + epatch_user + fi + + # fix locale issues if possible #122216 + if [[ -e ${FILESDIR}/binutils-configure-LANG.patch ]] ; then + einfo "Fixing misc issues in configure files" + for f in $(grep -l 'autoconf version 2.13' $(find "${S}" -name configure)) ; do + ebegin " Updating ${f/${S}\/}" + patch "${f}" "${FILESDIR}"/binutils-configure-LANG.patch >& "${T}"/configure-patch.log \ + || eerror "Please file a bug about this" + eend $? + done + fi + # fix conflicts with newer glibc #272594 + if [[ -e libiberty/testsuite/test-demangle.c ]] ; then + sed -i 's:\<getline\>:get_line:g' libiberty/testsuite/test-demangle.c + fi + + # Fix po Makefile generators + sed -i \ + -e '/^datadir = /s:$(prefix)/@DATADIRNAME@:@datadir@:' \ + -e '/^gnulocaledir = /s:$(prefix)/share:$(datadir):' \ + */po/Make-in || die "sed po's failed" + + # Run misc portage update scripts + gnuconfig_update + elibtoolize --portage --no-uclibc +} + +toolchain-binutils_src_unpack() { + tc-binutils_unpack + tc-binutils_apply_patches +} + +toolchain-binutils_src_compile() { + # prevent makeinfo from running in releases. it may not always be + # installed, and older binutils may fail with newer texinfo. + # besides, we never patch the doc files anyways, so regenerating + # in the first place is useless. #193364 + find . '(' -name '*.info' -o -name '*.texi' ')' -print0 | xargs -0 touch -r . + + # make sure we filter $LINGUAS so that only ones that + # actually work make it through #42033 + strip-linguas -u */po + + # keep things sane + strip-flags + + local x + echo + for x in CATEGORY CBUILD CHOST CTARGET CFLAGS LDFLAGS ; do + einfo "$(printf '%10s' ${x}:) ${!x}" + done + echo + + cd "${MY_BUILDDIR}" + local myconf=() + + # enable gold if available (installed as ld.gold) + if use cxx ; then + if grep -q 'enable-gold=default' "${S}"/configure ; then + myconf+=( --enable-gold ) + # old ways - remove when 2.21 is stable + elif grep -q 'enable-gold=both/ld' "${S}"/configure ; then + myconf+=( --enable-gold=both/ld ) + elif grep -q 'enable-gold=both/bfd' "${S}"/configure ; then + myconf+=( --enable-gold=both/bfd ) + fi + if grep -q -e '--enable-plugins' "${S}"/ld/configure ; then + myconf+=( --enable-plugins ) + fi + fi + + use nls \ + && myconf+=( --without-included-gettext ) \ + || myconf+=( --disable-nls ) + + if in_iuse zlib ; then + # older versions did not have an explicit configure flag + export ac_cv_search_zlibVersion=$(usex zlib -lz no) + myconf+=( $(use_with zlib) ) + fi + + # For bi-arch systems, enable a 64bit bfd. This matches + # the bi-arch logic in toolchain.eclass. #446946 + # We used to do it for everyone, but it's slow on 32bit arches. #438522 + case $(tc-arch) in + ppc|sparc|x86) myconf+=( --enable-64-bit-bfd ) ;; + esac + + use multitarget && myconf+=( --enable-targets=all --enable-64-bit-bfd ) + [[ -n ${CBUILD} ]] && myconf+=( --build=${CBUILD} ) + is_cross && myconf+=( --with-sysroot="${EPREFIX}"/usr/${CTARGET} ) + + # glibc-2.3.6 lacks support for this ... so rather than force glibc-2.5+ + # on everyone in alpha (for now), we'll just enable it when possible + has_version ">=${CATEGORY}/glibc-2.5" && myconf+=( --enable-secureplt ) + has_version ">=sys-libs/glibc-2.5" && myconf+=( --enable-secureplt ) + + myconf+=( + --prefix="${EPREFIX}"/usr + --host=${CHOST} + --target=${CTARGET} + --datadir="${EPREFIX}"${DATAPATH} + --infodir="${EPREFIX}"${DATAPATH}/info + --mandir="${EPREFIX}"${DATAPATH}/man + --bindir="${EPREFIX}"${BINPATH} + --libdir="${EPREFIX}"${LIBPATH} + --libexecdir="${EPREFIX}"${LIBPATH} + --includedir="${EPREFIX}"${INCPATH} + --enable-obsolete + --enable-shared + --enable-threads + --disable-werror + --with-bugurl=http://bugs.gentoo.org/ + $(use_enable static-libs static) + ${EXTRA_ECONF} + ) + echo ./configure "${myconf[@]}" + "${S}"/configure "${myconf[@]}" || die + + emake all || die "emake failed" + + # only build info pages if we user wants them, and if + # we have makeinfo (may not exist when we bootstrap) + if type -p makeinfo > /dev/null ; then + emake info || die "make info failed" + fi + # we nuke the manpages when we're left with junk + # (like when we bootstrap, no perl -> no manpages) + find . -name '*.1' -a -size 0 | xargs rm -f + + # elf2flt only works on some arches / targets + if [[ -n ${ELF2FLT_VER} ]] && [[ ${CTARGET} == *linux* || ${CTARGET} == *-elf* ]] ; then + cd "${WORKDIR}"/elf2flt-${ELF2FLT_VER} + + local x supported_arches=$(sed -n '/defined(TARGET_/{s:^.*TARGET_::;s:)::;p}' elf2flt.c | sort -u) + for x in ${supported_arches} UNSUPPORTED ; do + [[ ${CTARGET} == ${x}* ]] && break + done + + if [[ ${x} != "UNSUPPORTED" ]] ; then + append-flags -I"${S}"/include + myconf+=( + --with-bfd-include-dir=${MY_BUILDDIR}/bfd + --with-libbfd=${MY_BUILDDIR}/bfd/libbfd.a + --with-libiberty=${MY_BUILDDIR}/libiberty/libiberty.a + --with-binutils-ldscript-dir="${EPREFIX}"${LIBPATH}/ldscripts + ) + echo ./configure "${myconf[@]}" + ./configure "${myconf[@]}" || die + emake || die "make elf2flt failed" + fi + fi +} + +toolchain-binutils_src_test() { + cd "${MY_BUILDDIR}" + emake -k check || die "check failed :(" +} + +toolchain-binutils_src_install() { + local x d + + cd "${MY_BUILDDIR}" + emake DESTDIR="${D}" tooldir="${EPREFIX}/${LIBPATH}" install || die + rm -rf "${ED}"/${LIBPATH}/bin + use static-libs || find "${ED}" -name '*.la' -delete + + # Newer versions of binutils get fancy with ${LIBPATH} #171905 + cd "${ED}"/${LIBPATH} + for d in ../* ; do + [[ ${d} == ../${BVER} ]] && continue + mv ${d}/* . || die + rmdir ${d} || die + done + + # Now we collect everything intp the proper SLOT-ed dirs + # When something is built to cross-compile, it installs into + # /usr/$CHOST/ by default ... we have to 'fix' that :) + if is_cross ; then + cd "${ED}"/${BINPATH} + for x in * ; do + mv ${x} ${x/${CTARGET}-} + done + + if [[ -d ${ED}/usr/${CHOST}/${CTARGET} ]] ; then + mv "${ED}"/usr/${CHOST}/${CTARGET}/include "${ED}"/${INCPATH} + mv "${ED}"/usr/${CHOST}/${CTARGET}/lib/* "${ED}"/${LIBPATH}/ + rm -r "${ED}"/usr/${CHOST}/{include,lib} + fi + fi + insinto ${INCPATH} + local libiberty_headers=( + # Not all the libiberty headers. See libiberty/Makefile.in:install_to_libdir. + demangle.h + dyn-string.h + fibheap.h + hashtab.h + libiberty.h + objalloc.h + splay-tree.h + ) + doins "${libiberty_headers[@]/#/${S}/include/}" || die + if [[ -d ${ED}/${LIBPATH}/lib ]] ; then + mv "${ED}"/${LIBPATH}/lib/* "${ED}"/${LIBPATH}/ + rm -r "${ED}"/${LIBPATH}/lib + fi + + # Insert elf2flt where appropriate + if [[ -x ${WORKDIR}/elf2flt-${ELF2FLT_VER}/elf2flt ]] ; then + cd "${WORKDIR}"/elf2flt-${ELF2FLT_VER} + insinto ${LIBPATH}/ldscripts + doins elf2flt.ld || die "doins elf2flt.ld failed" + exeinto ${BINPATH} + doexe elf2flt flthdr || die "doexe elf2flt flthdr failed" + mv "${ED}"/${BINPATH}/{ld,ld.real} || die + newexe ld-elf2flt ld || die "doexe ld-elf2flt failed" + newdoc README README.elf2flt + fi + + # Now, some binutils are tricky and actually provide + # for multiple TARGETS. Really, we're talking just + # 32bit/64bit support (like mips/ppc/sparc). Here + # we want to tell binutils-config that it's cool if + # it generates multiple sets of binutil symlinks. + # e.g. sparc gets {sparc,sparc64}-unknown-linux-gnu + local targ=${CTARGET/-*} src="" dst="" + local FAKE_TARGETS=${CTARGET} + case ${targ} in + mips*) src="mips" dst="mips64";; + powerpc*) src="powerpc" dst="powerpc64";; + s390*) src="s390" dst="s390x";; + sparc*) src="sparc" dst="sparc64";; + esac + case ${targ} in + mips64*|powerpc64*|s390x*|sparc64*) targ=${src} src=${dst} dst=${targ};; + esac + [[ -n ${src}${dst} ]] && FAKE_TARGETS="${FAKE_TARGETS} ${CTARGET/${src}/${dst}}" + + # Generate an env.d entry for this binutils + cd "${S}" + insinto /etc/env.d/binutils + cat <<-EOF > env.d + TARGET="${CTARGET}" + VER="${BVER}" + LIBPATH="${EPREFIX}/${LIBPATH}" + FAKE_TARGETS="${FAKE_TARGETS}" + EOF + newins env.d ${CTARGET}-${BVER} + + # Handle documentation + if ! is_cross ; then + cd "${S}" + dodoc README + docinto bfd + dodoc bfd/ChangeLog* bfd/README bfd/PORTING bfd/TODO + docinto binutils + dodoc binutils/ChangeLog binutils/NEWS binutils/README + docinto gas + dodoc gas/ChangeLog* gas/CONTRIBUTORS gas/NEWS gas/README* + docinto gprof + dodoc gprof/ChangeLog* gprof/TEST gprof/TODO gprof/bbconv.pl + docinto ld + dodoc ld/ChangeLog* ld/README ld/NEWS ld/TODO + docinto libiberty + dodoc libiberty/ChangeLog* libiberty/README + docinto opcodes + dodoc opcodes/ChangeLog* + fi + # Remove shared info pages + rm -f "${ED}"/${DATAPATH}/info/{dir,configure.info,standards.info} + # Trim all empty dirs + find "${ED}" -type d | xargs rmdir >& /dev/null +} + +toolchain-binutils_pkg_postinst() { + # Make sure this ${CTARGET} has a binutils version selected + [[ -e ${EROOT}/etc/env.d/binutils/config-${CTARGET} ]] && return 0 + binutils-config ${CTARGET}-${BVER} +} + +toolchain-binutils_pkg_postrm() { + local current_profile=$(binutils-config -c ${CTARGET}) + + # If no other versions exist, then uninstall for this + # target ... otherwise, switch to the newest version + # Note: only do this if this version is unmerged. We + # rerun binutils-config if this is a remerge, as + # we want the mtimes on the symlinks updated (if + # it is the same as the current selected profile) + if [[ ! -e ${EPREFIX}${BINPATH}/ld ]] && [[ ${current_profile} == ${CTARGET}-${BVER} ]] ; then + local choice=$(binutils-config -l | grep ${CTARGET} | awk '{print $2}') + choice=${choice//$'\n'/ } + choice=${choice/* } + if [[ -z ${choice} ]] ; then + env -i ROOT="${ROOT}" binutils-config -u ${CTARGET} + else + binutils-config ${choice} + fi + elif [[ $(CHOST=${CTARGET} binutils-config -c) == ${CTARGET}-${BVER} ]] ; then + binutils-config ${CTARGET}-${BVER} + fi +} diff --git a/eclass/toolchain.eclass b/eclass/toolchain.eclass new file mode 100644 index 0000000..76d92e6 --- /dev/null +++ b/eclass/toolchain.eclass @@ -0,0 +1,2128 @@ +# Copyright 1999-2013 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain.eclass,v 1.597 2013/07/24 01:34:38 dirtyepic Exp $ + +# Maintainer: Toolchain Ninjas <toolchain@gentoo.org> + +#---->> eclass stuff <<---- +DESCRIPTION="The GNU Compiler Collection" +HOMEPAGE="http://gcc.gnu.org/" +LICENSE="GPL-2 LGPL-2.1" +RESTRICT="strip" # cross-compilers need controlled stripping + +inherit eutils versionator libtool toolchain-funcs flag-o-matic gnuconfig multilib fixheadtails pax-utils prefix + +if [[ ${PV} == *_pre9999* ]] ; then + EGIT_REPO_URI="git://gcc.gnu.org/git/gcc.git" + # naming style: + # gcc-4.7.1_pre9999 -> gcc-4_7-branch + # Note that the micro version is required or lots of stuff will break. + # To checkout master set gcc_LIVE_BRANCH="master" in the ebuild before + # inheriting this eclass. + EGIT_BRANCH="${PN}-${PV%.?_pre9999}-branch" + EGIT_BRANCH=${EGIT_BRANCH//./_} + inherit git-2 +fi + +FEATURES=${FEATURES/multilib-strict/} + +EXPORT_FUNCTIONS pkg_setup src_unpack src_compile src_test src_install pkg_postinst pkg_postrm +#----<< eclass stuff >>---- + +#---->> globals <<---- +export CTARGET=${CTARGET:-${CHOST}} +if [[ ${CTARGET} = ${CHOST} ]] ; then + if [[ ${CATEGORY/cross-} != ${CATEGORY} ]] ; then + export CTARGET=${CATEGORY/cross-} + fi +fi +: ${TARGET_ABI:=${ABI}} +: ${TARGET_MULTILIB_ABIS:=${MULTILIB_ABIS}} +: ${TARGET_DEFAULT_ABI:=${DEFAULT_ABI}} + +is_crosscompile() { + [[ ${CHOST} != ${CTARGET} ]] +} + +# General purpose version check. Without a second arg matches up to minor version (x.x.x) +# (ie. 4.6.0_pre9999 matches 4 or 4.6 or 4.6.0 but not 4.6.1) +tc_version_is_at_least() { + version_is_at_least "$1" "${2:-${GCC_RELEASE_VER}}" +} + +GCC_PV=${TOOLCHAIN_GCC_PV:-${PV}} +GCC_PVR=${GCC_PV} +[[ ${PR} != "r0" ]] && GCC_PVR=${GCC_PVR}-${PR} +GCC_RELEASE_VER=$(get_version_component_range 1-3 ${GCC_PV}) +GCC_BRANCH_VER=$(get_version_component_range 1-2 ${GCC_PV}) +GCCMAJOR=$(get_version_component_range 1 ${GCC_PV}) +GCCMINOR=$(get_version_component_range 2 ${GCC_PV}) +GCCMICRO=$(get_version_component_range 3 ${GCC_PV}) +[[ ${BRANCH_UPDATE-notset} == "notset" ]] && \ + BRANCH_UPDATE=$(get_version_component_range 4 ${GCC_PV}) + +# According to gcc/c-cppbuiltin.c, GCC_CONFIG_VER MUST match this regex. +# ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? +GCC_CONFIG_VER=${GCC_CONFIG_VER:-$(replace_version_separator 3 '-' ${GCC_PV})} + +# Pre-release support +if [[ ${GCC_PV} != ${GCC_PV/_pre/-} ]] ; then + PRERELEASE=${GCC_PV/_pre/-} +fi + +# make _alpha and _beta ebuilds automatically use a snapshot +if [[ ${GCC_PV} == *_alpha* ]] ; then + SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_alpha} +elif [[ ${GCC_PV} == *_beta* ]] ; then + SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_beta} +elif [[ ${GCC_PV} == *_rc* ]] ; then + SNAPSHOT=${GCC_PV%_rc*}-RC-${GCC_PV##*_rc} +fi + +export GCC_FILESDIR=${GCC_FILESDIR:-${FILESDIR}} +PREFIX=${TOOLCHAIN_PREFIX:-/usr} + +if tc_version_is_at_least 3.4.0 ; then + LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc/${CTARGET}/${GCC_CONFIG_VER}} +else + LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc-lib/${CTARGET}/${GCC_CONFIG_VER}} +fi +INCLUDEPATH=${TOOLCHAIN_INCLUDEPATH:-${LIBPATH}/include} + +if is_crosscompile ; then + BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CHOST}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}} +else + BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}} +fi + +DATAPATH=${TOOLCHAIN_DATAPATH:-${PREFIX}/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}} + +# Dont install in /usr/include/g++-v3/, but in gcc internal directory. +# We will handle /usr/include/g++-v3/ with gcc-config ... +STDCXX_INCDIR=${TOOLCHAIN_STDCXX_INCDIR:-${LIBPATH}/include/g++-v${GCC_BRANCH_VER/\.*/}} +#----<< globals >>---- + +#---->> SLOT+IUSE logic <<---- +IUSE="multislot nls nptl regression-test vanilla" + +if [[ ${PN} != "kgcc64" && ${PN} != gcc-* ]] ; then + IUSE+=" altivec cxx fortran" + [[ -n ${PIE_VER} ]] && IUSE+=" nopie" + [[ -n ${HTB_VER} ]] && IUSE+=" boundschecking" + [[ -n ${D_VER} ]] && IUSE+=" d" + [[ -n ${SPECS_VER} ]] && IUSE+=" nossp" + tc_version_is_at_least 3 && IUSE+=" doc gcj gtk hardened multilib objc" + tc_version_is_at_least 4.0 && IUSE+=" objc-gc mudflap" + tc_version_is_at_least 4.1 && IUSE+=" libssp objc++" + tc_version_is_at_least 4.2 && IUSE+=" openmp" + tc_version_is_at_least 4.3 && IUSE+=" fixed-point" + tc_version_is_at_least 4.6 && IUSE+=" graphite" + tc_version_is_at_least 4.6 && IUSE+=" lto" + tc_version_is_at_least 4.7 && IUSE+=" go" +fi + +# Support upgrade paths here or people get pissed +if use multislot ; then + SLOT="${GCC_CONFIG_VER}" +else + SLOT="${GCC_BRANCH_VER}" +fi +#----<< SLOT+IUSE logic >>---- + +#---->> DEPEND <<---- +RDEPEND="sys-libs/zlib + nls? ( sys-devel/gettext )" + +tc_version_is_at_least 3 && RDEPEND+=" virtual/libiconv" + +if tc_version_is_at_least 4 ; then + GMP_MPFR_DEPS=">=dev-libs/gmp-4.3.2 >=dev-libs/mpfr-2.4.2" + if tc_version_is_at_least 4.3 ; then + RDEPEND+=" ${GMP_MPFR_DEPS}" + elif in_iuse fortran ; then + RDEPEND+=" fortran? ( ${GMP_MPFR_DEPS} )" + fi +fi + +tc_version_is_at_least 4.5 && RDEPEND+=" >=dev-libs/mpc-0.8.1" + +if in_iuse graphite ; then + if tc_version_is_at_least 4.8 ; then + RDEPEND+=" + graphite? ( + >=dev-libs/cloog-0.18.0 + >=dev-libs/isl-0.11.1 + )" + else + RDEPEND+=" + graphite? ( + >=dev-libs/cloog-ppl-0.15.10 + >=dev-libs/ppl-0.11 + )" + fi +fi + +DEPEND="${RDEPEND} + >=sys-devel/bison-1.875 + >=sys-devel/flex-2.5.4 + regression-test? ( + >=dev-util/dejagnu-1.4.4 + >=sys-devel/autogen-5.5.4 + )" + +if in_iuse gcj ; then + GCJ_DEPS=">=media-libs/libart_lgpl-2.1" + GCJ_GTK_DEPS=" + x11-libs/libXt + x11-libs/libX11 + x11-libs/libXtst + x11-proto/xproto + x11-proto/xextproto + =x11-libs/gtk+-2* + virtual/pkgconfig + amd64? ( multilib? ( + app-emulation/emul-linux-x86-gtklibs + app-emulation/emul-linux-x86-xlibs + ) ) + " + tc_version_is_at_least 3.4 && GCJ_GTK_DEPS+=" x11-libs/pango" + tc_version_is_at_least 4.2 && GCJ_DEPS+=" app-arch/zip app-arch/unzip" + DEPEND+=" gcj? ( gtk? ( ${GCJ_GTK_DEPS} ) ${GCJ_DEPS} )" +fi + +PDEPEND=">=sys-devel/gcc-config-1.7" +#----<< DEPEND >>---- + +#---->> S + SRC_URI essentials <<---- + +# Set the source directory depending on whether we're using +# a prerelease, snapshot, or release tarball. +S=$( + if [[ -n ${PRERELEASE} ]] ; then + echo ${WORKDIR}/gcc-${PRERELEASE} + elif [[ -n ${SNAPSHOT} ]] ; then + echo ${WORKDIR}/gcc-${SNAPSHOT} + else + echo ${WORKDIR}/gcc-${GCC_RELEASE_VER} + fi +) + +# This function handles the basics of setting the SRC_URI for a gcc ebuild. +# To use, set SRC_URI with: +# +# SRC_URI="$(get_gcc_src_uri)" +# +# Other than the variables normally set by portage, this function's behavior +# can be altered by setting the following: +# +# SNAPSHOT +# If set, this variable signals that we should be using a snapshot of +# gcc. It is expected to be in the format "YYYY-MM-DD". Note that if +# the ebuild has a _pre suffix, this variable is ignored and the +# prerelease tarball is used instead. +# +# BRANCH_UPDATE +# If set, this variable signals that we should be using the main +# release tarball (determined by ebuild version) and applying a +# CVS branch update patch against it. The location of this branch +# update patch is assumed to be in ${GENTOO_TOOLCHAIN_BASE_URI}. +# Just like with SNAPSHOT, this variable is ignored if the ebuild +# has a _pre suffix. +# +# PATCH_VER +# PATCH_GCC_VER +# This should be set to the version of the gentoo patch tarball. +# The resulting filename of this tarball will be: +# gcc-${PATCH_GCC_VER:-${GCC_RELEASE_VER}}-patches-${PATCH_VER}.tar.bz2 +# +# PIE_VER +# PIE_GCC_VER +# These variables control patching in various updates for the logic +# controlling Position Independant Executables. PIE_VER is expected +# to be the version of this patch, and PIE_GCC_VER the gcc version of +# the patch: +# An example: +# PIE_VER="8.7.6.5" +# PIE_GCC_VER="3.4.0" +# The resulting filename of this tarball will be: +# gcc-${PIE_GCC_VER:-${GCC_RELEASE_VER}}-piepatches-v${PIE_VER}.tar.bz2 +# +# SPECS_VER +# SPECS_GCC_VER +# This is for the minispecs files included in the hardened gcc-4.x +# The specs files for hardenedno*, vanilla and for building the "specs" file. +# SPECS_VER is expected to be the version of this patch, SPECS_GCC_VER +# the gcc version of the patch. +# An example: +# SPECS_VER="8.7.6.5" +# SPECS_GCC_VER="3.4.0" +# The resulting filename of this tarball will be: +# gcc-${SPECS_GCC_VER:-${GCC_RELEASE_VER}}-specs-${SPECS_VER}.tar.bz2 +# +# HTB_VER +# HTB_GCC_VER +# These variables control whether or not an ebuild supports Herman +# ten Brugge's bounds-checking patches. If you want to use a patch +# for an older gcc version with a new gcc, make sure you set +# HTB_GCC_VER to that version of gcc. +# +gentoo_urls() { + local devspace="HTTP~vapier/dist/URI HTTP~dirtyepic/dist/URI + HTTP~halcy0n/patches/URI HTTP~zorry/patches/gcc/URI" + devspace=${devspace//HTTP/http:\/\/dev.gentoo.org\/} + echo mirror://gentoo/$1 ${devspace//URI/$1} +} + +get_gcc_src_uri() { + export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}} + export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}} + export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}} + export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}} + export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}} + + # Set where to download gcc itself depending on whether we're using a + # prerelease, snapshot, or release tarball. + if [[ -n ${PRERELEASE} ]] ; then + GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/prerelease-${PRERELEASE}/gcc-${PRERELEASE}.tar.bz2" + elif [[ -n ${SNAPSHOT} ]] ; then + GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.bz2" + elif [[ ${PV} != *9999* ]] ; then + GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.bz2" + # we want all branch updates to be against the main release + [[ -n ${BRANCH_UPDATE} ]] && \ + GCC_SRC_URI+=" $(gentoo_urls gcc-${GCC_RELEASE_VER}-branch-update-${BRANCH_UPDATE}.patch.bz2)" + fi + + [[ -n ${UCLIBC_VER} ]] && \ + GCC_SRC_URI+=" $(gentoo_urls gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2)" + [[ -n ${PATCH_VER} ]] && \ + GCC_SRC_URI+=" $(gentoo_urls gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2)" + + # strawberry pie, Cappuccino and a Gauloises (it's a good thing) + [[ -n ${PIE_VER} ]] && \ + PIE_CORE=${PIE_CORE:-gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2} && \ + GCC_SRC_URI+=" $(gentoo_urls ${PIE_CORE})" + + # gcc minispec for the hardened gcc 4 compiler + [[ -n ${SPECS_VER} ]] && \ + GCC_SRC_URI+=" $(gentoo_urls gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2)" + + # gcc bounds checking patch + if [[ -n ${HTB_VER} ]] ; then + local HTBFILE="bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2" + GCC_SRC_URI+=" + boundschecking? ( + mirror://sourceforge/boundschecking/${HTBFILE} + $(gentoo_urls ${HTBFILE}) + )" + fi + + [[ -n ${D_VER} ]] && \ + GCC_SRC_URI+=" d? ( mirror://sourceforge/dgcc/gdc-${D_VER}-src.tar.bz2 )" + + if in_iuse gcj ; then + if tc_version_is_at_least 4.5 ; then + GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.5.jar )" + elif tc_version_is_at_least 4.3 ; then + GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.3.jar )" + fi + fi + + echo "${GCC_SRC_URI}" +} +SRC_URI=$(get_gcc_src_uri) +#---->> S + SRC_URI essentials >>---- + +#---->> support checks <<---- + +# Grab a variable from the build system (taken from linux-info.eclass) +get_make_var() { + local var=$1 makefile=${2:-${WORKDIR}/build/Makefile} + echo -e "e:\\n\\t@echo \$(${var})\\ninclude ${makefile}" | \ + r=${makefile%/*} emake --no-print-directory -s -f - 2>/dev/null +} +XGCC() { get_make_var GCC_FOR_TARGET ; } + +# The gentoo piessp patches allow for 3 configurations: +# 1) PIE+SSP by default +# 2) PIE by default +# 3) SSP by default +hardened_gcc_works() { + if [[ $1 == "pie" ]] ; then + # $gcc_cv_ld_pie is unreliable as it simply take the output of + # `ld --help | grep -- -pie`, that reports the option in all cases, also if + # the loader doesn't actually load the resulting executables. + # To avoid breakage, blacklist FreeBSD here at least + [[ ${CTARGET} == *-freebsd* ]] && return 1 + + want_pie || return 1 + use_if_iuse nopie && return 1 + hardened_gcc_is_stable pie + return $? + elif [[ $1 == "ssp" ]] ; then + [[ -n ${SPECS_VER} ]] || return 1 + use_if_iuse nossp && return 1 + hardened_gcc_is_stable ssp + return $? + else + # laziness ;) + hardened_gcc_works pie || return 1 + hardened_gcc_works ssp || return 1 + return 0 + fi +} + +hardened_gcc_is_stable() { + local tocheck + if [[ $1 == "pie" ]] ; then + if [[ ${CTARGET} == *-uclibc* ]] ; then + tocheck=${PIE_UCLIBC_STABLE} + else + tocheck=${PIE_GLIBC_STABLE} + fi + elif [[ $1 == "ssp" ]] ; then + if [[ ${CTARGET} == *-uclibc* ]] ; then + tocheck=${SSP_UCLIBC_STABLE} + else + tocheck=${SSP_STABLE} + fi + else + die "hardened_gcc_stable needs to be called with pie or ssp" + fi + + has $(tc-arch) ${tocheck} && return 0 + return 1 +} + +want_pie() { + ! use hardened && [[ -n ${PIE_VER} ]] && use nopie && return 1 + [[ -n ${PIE_VER} ]] && [[ -n ${SPECS_VER} ]] && return 0 + tc_version_is_at_least 4.3.2 && return 1 + [[ -z ${PIE_VER} ]] && return 1 + use !nopie && return 0 + return 1 +} + +want_minispecs() { + if tc_version_is_at_least 4.3.2 && use hardened ; then + if ! want_pie ; then + ewarn "PIE_VER or SPECS_VER is not defined in the GCC ebuild." + elif use vanilla ; then + ewarn "You will not get hardened features if you have the vanilla USE-flag." + elif use nopie && use nossp ; then + ewarn "You will not get hardened features if you have the nopie and nossp USE-flag." + elif ! hardened_gcc_works ; then + ewarn "Your $(tc-arch) arch is not supported." + else + return 0 + fi + ewarn "Hope you know what you are doing. Hardened will not work." + return 0 + fi + return 1 +} + +# This is to make sure we don't accidentally try to enable support for a +# language that doesnt exist. GCC 3.4 supports f77, while 4.0 supports f95, etc. +# +# Also add a hook so special ebuilds (kgcc64) can control which languages +# exactly get enabled +gcc-lang-supported() { + grep ^language=\"${1}\" "${S}"/gcc/*/config-lang.in > /dev/null || return 1 + [[ -z ${TOOLCHAIN_ALLOWED_LANGS} ]] && return 0 + has $1 ${TOOLCHAIN_ALLOWED_LANGS} +} +#----<< support checks >>---- + +#---->> specs + env.d logic <<---- + +# configure to build with the hardened GCC specs as the default +make_gcc_hard() { + # defaults to enable for all hardened toolchains + local gcc_hard_flags="-DEFAULT_RELRO -DEFAULT_BIND_NOW" + + if hardened_gcc_works ; then + einfo "Updating gcc to use automatic PIE + SSP building ..." + gcc_hard_flags+=" -DEFAULT_PIE_SSP" + elif hardened_gcc_works pie ; then + einfo "Updating gcc to use automatic PIE building ..." + ewarn "SSP has not been enabled by default" + gcc_hard_flags+=" -DEFAULT_PIE" + elif hardened_gcc_works ssp ; then + einfo "Updating gcc to use automatic SSP building ..." + ewarn "PIE has not been enabled by default" + gcc_hard_flags+=" -DEFAULT_SSP" + else + # do nothing if hardened isnt supported, but dont die either + ewarn "hardened is not supported for this arch in this gcc version" + ebeep + return 0 + fi + + sed -i \ + -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \ + "${S}"/gcc/Makefile.in || die + + # rebrand to make bug reports easier + BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened} +} + +create_gcc_env_entry() { + dodir /etc/env.d/gcc + local gcc_envd_base="/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}" + + local gcc_specs_file + local gcc_envd_file="${ED}${gcc_envd_base}" + if [[ -z $1 ]] ; then + # I'm leaving the following commented out to remind me that it + # was an insanely -bad- idea. Stuff broke. GCC_SPECS isnt unset + # on chroot or in non-toolchain.eclass gcc ebuilds! + #gcc_specs_file="${LIBPATH}/specs" + gcc_specs_file="" + else + gcc_envd_file+="-$1" + gcc_specs_file="${EPREFIX}${LIBPATH}/$1.specs" + fi + + # We want to list the default ABI's LIBPATH first so libtool + # searches that directory first. This is a temporary + # workaround for libtool being stupid and using .la's from + # conflicting ABIs by using the first one in the search path + local ldpaths mosdirs + if tc_version_is_at_least 3.2 ; then + local mdir mosdir abi ldpath + for abi in $(get_all_abis TARGET) ; do + mdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) --print-multi-directory) + ldpath=${EPREFIX}${LIBPATH} + [[ ${mdir} != "." ]] && ldpath+="/${mdir}" + ldpaths="${ldpath}${ldpaths:+:${ldpaths}}" + + mosdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) -print-multi-os-directory) + mosdirs="${mosdir}${mosdirs:+:${mosdirs}}" + done + else + # Older gcc's didn't do multilib, so logic is simple. + ldpaths=${EPREFIX}${LIBPATH} + fi + + cat <<-EOF > ${gcc_envd_file} + PATH="${EPREFIX}${BINPATH}" + ROOTPATH="${EPREFIX}${BINPATH}" + GCC_PATH="${EPREFIX}${BINPATH}" + LDPATH="${ldpaths}" + MANPATH="${EPREFIX}${DATAPATH}/man" + INFOPATH="${EPREFIX}${DATAPATH}/info" + STDCXX_INCDIR="${STDCXX_INCDIR##*/}" + CTARGET="${CTARGET}" + GCC_SPECS="${gcc_specs_file}" + MULTIOSDIRS="${mosdirs}" + EOF +} + +setup_minispecs_gcc_build_specs() { + # Setup the "build.specs" file for gcc 4.3 to use when building. + if hardened_gcc_works pie ; then + cat "${WORKDIR}"/specs/pie.specs >> "${WORKDIR}"/build.specs + fi + if hardened_gcc_works ssp ; then + for s in ssp sspall ; do + cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs + done + fi + for s in nostrict znow ; do + cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs + done + export GCC_SPECS="${WORKDIR}"/build.specs +} + +copy_minispecs_gcc_specs() { + # setup the hardenedno* specs files and the vanilla specs file. + if hardened_gcc_works ; then + create_gcc_env_entry hardenednopiessp + fi + if hardened_gcc_works pie ; then + create_gcc_env_entry hardenednopie + fi + if hardened_gcc_works ssp ; then + create_gcc_env_entry hardenednossp + fi + create_gcc_env_entry vanilla + insinto ${LIBPATH} + doins "${WORKDIR}"/specs/*.specs || die "failed to install specs" + # Build system specs file which, if it exists, must be a complete set of + # specs as it completely and unconditionally overrides the builtin specs. + if ! tc_version_is_at_least 4.4 ; then + $(XGCC) -dumpspecs > "${WORKDIR}"/specs/specs + cat "${WORKDIR}"/build.specs >> "${WORKDIR}"/specs/specs + doins "${WORKDIR}"/specs/specs || die "failed to install the specs file" + fi +} + +#----<< specs + env.d logic >>---- + +#---->> pkg_* <<---- +toolchain_pkg_setup() { + if [[ -n ${PRERELEASE}${SNAPSHOT} || ${PV} == *9999* ]] && + [[ -z ${I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS} ]] ; then + die "Please \`export I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS=1\` or define it" \ + "in your make.conf if you want to use this version." + fi + + local realEPREFIX=$(python -c 'import os; print(os.path.realpath("'"${EPREFIX}"'"))') + if [[ ${EPREFIX} != ${realEPREFIX} ]] ; then + ewarn "Your \${EPREFIX} contains one or more symlinks. GCC has a" + ewarn "bug which prevents it from working properly when there are" + ewarn "symlinks in your \${EPREFIX}." + ewarn "See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=29831" + fi + + # we dont want to use the installed compiler's specs to build gcc! + unset GCC_SPECS + + if ! use_if_iuse cxx ; then + use_if_iuse go && ewarn 'Go requires a C++ compiler, disabled due to USE="-cxx"' + use_if_iuse objc++ && ewarn 'Obj-C++ requires a C++ compiler, disabled due to USE="-cxx"' + use_if_iuse gcj && ewarn 'GCJ requires a C++ compiler, disabled due to USE="-cxx"' + fi + + want_minispecs + + unset LANGUAGES #265283 +} + +toolchain_pkg_postinst() { + do_gcc_config + + if ! is_crosscompile ; then + echo + ewarn "If you have issues with packages unable to locate libstdc++.la," + ewarn "then try running 'fix_libtool_files.sh' on the old gcc versions." + echo + ewarn "You might want to review the GCC upgrade guide when moving between" + ewarn "major versions (like 4.2 to 4.3):" + ewarn "http://www.gentoo.org/doc/en/gcc-upgrading.xml" + echo + + # Clean up old paths + rm -f "${EROOT}"/*/rcscripts/awk/fixlafiles.awk "${EROOT}"/sbin/fix_libtool_files.sh + rmdir "${EROOT}"/*/rcscripts{/awk,} 2>/dev/null + + mkdir -p "${EROOT}"/usr/{share/gcc-data,sbin,bin} + cp "${EROOT}/${DATAPATH}"/fixlafiles.awk "${EROOT}"/usr/share/gcc-data/ || die + cp "${EROOT}/${DATAPATH}"/fix_libtool_files.sh "${EROOT}"/usr/sbin/ || die + + # Since these aren't critical files and portage sucks with + # handling of binpkgs, don't require these to be found + cp "${EROOT}/${DATAPATH}"/c{89,99} "${EROOT}"/usr/bin/ 2>/dev/null + fi + + if use regression-test ; then + elog "Testsuite results have been installed into /usr/share/doc/${PF}/testsuite" + echo + fi +} + +toolchain_pkg_postrm() { + # to make our lives easier (and saner), we do the fix_libtool stuff here. + # rather than checking SLOT's and trying in upgrade paths, we just see if + # the common libstdc++.la exists in the ${LIBPATH} of the gcc that we are + # unmerging. if it does, that means this was a simple re-emerge. + + # clean up the cruft left behind by cross-compilers + if is_crosscompile ; then + if [[ -z $(ls "${EROOT}"/etc/env.d/gcc/${CTARGET}* 2>/dev/null) ]] ; then + rm -f "${EROOT}"/etc/env.d/gcc/config-${CTARGET} + rm -f "${EROOT}"/etc/env.d/??gcc-${CTARGET} + rm -f "${EROOT}"/usr/bin/${CTARGET}-{gcc,{g,c}++}{,32,64} + fi + return 0 + fi + + # ROOT isnt handled by the script + [[ ${ROOT} != "/" ]] && return 0 + + if [[ ! -e ${EPREFIX}${LIBPATH}/libstdc++.so ]] ; then + # make sure the profile is sane during same-slot upgrade #289403 + do_gcc_config + + einfo "Running 'fix_libtool_files.sh ${GCC_RELEASE_VER}'" + "${EPREFIX}"/usr/sbin/fix_libtool_files.sh ${GCC_RELEASE_VER} + if [[ -n ${BRANCH_UPDATE} ]] ; then + einfo "Running 'fix_libtool_files.sh ${GCC_RELEASE_VER}-${BRANCH_UPDATE}'" + "${EPREFIX}"/usr/sbin/fix_libtool_files.sh ${GCC_RELEASE_VER}-${BRANCH_UPDATE} + fi + fi + + return 0 +} + +#---->> pkg_* <<---- + +#---->> src_* <<---- + +guess_patch_type_in_dir() { + [[ -n $(ls "$1"/*.bz2 2>/dev/null) ]] \ + && EPATCH_SUFFIX="patch.bz2" \ + || EPATCH_SUFFIX="patch" +} + +do_gcc_rename_java_bins() { + # bug #139918 - conflict between gcc and java-config-2 for ownership of + # /usr/bin/rmi{c,registry}. Done with mv & sed rather than a patch + # because patches would be large (thanks to the rename of man files), + # and it's clear from the sed invocations that all that changes is the + # rmi{c,registry} names to grmi{c,registry} names. + # Kevin F. Quinn 2006-07-12 + einfo "Renaming jdk executables rmic and rmiregistry to grmic and grmiregistry." + # 1) Move the man files if present (missing prior to gcc-3.4) + for manfile in rmic rmiregistry ; do + [[ -f ${S}/gcc/doc/${manfile}.1 ]] || continue + mv "${S}"/gcc/doc/${manfile}.1 "${S}"/gcc/doc/g${manfile}.1 + done + # 2) Fixup references in the docs if present (mission prior to gcc-3.4) + for jfile in gcc/doc/gcj.info gcc/doc/grmic.1 gcc/doc/grmiregistry.1 gcc/java/gcj.texi ; do + [[ -f ${S}/${jfile} ]] || continue + sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} || + die "Failed to fixup file ${jfile} for rename to grmiregistry" + sed -i -e 's:rmic:grmic:g' "${S}"/${jfile} || + die "Failed to fixup file ${jfile} for rename to grmic" + done + # 3) Fixup Makefiles to build the changed executable names + # These are present in all 3.x versions, and are the important bit + # to get gcc to build with the new names. + for jfile in libjava/Makefile.am libjava/Makefile.in gcc/java/Make-lang.in ; do + sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} || + die "Failed to fixup file ${jfile} for rename to grmiregistry" + # Careful with rmic on these files; it's also the name of a directory + # which should be left unchanged. Replace occurrences of 'rmic$', + # 'rmic_' and 'rmic '. + sed -i -e 's:rmic\([$_ ]\):grmic\1:g' "${S}"/${jfile} || + die "Failed to fixup file ${jfile} for rename to grmic" + done +} + +toolchain_src_unpack() { + [[ -z ${UCLIBC_VER} ]] && [[ ${CTARGET} == *-uclibc* ]] && \ + die "Sorry, this version does not support uClibc" + + if [[ ${PV} == *9999* ]]; then + git-2_src_unpack + else + gcc_quick_unpack + fi + + export BRANDING_GCC_PKGVERSION="Gentoo ${GCC_PVR}" + cd "${S}" + + if ! use vanilla ; then + if [[ -n ${PATCH_VER} ]] ; then + guess_patch_type_in_dir "${WORKDIR}"/patch + EPATCH_MULTI_MSG="Applying Gentoo patches ..." \ + epatch "${WORKDIR}"/patch + BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION} p${PATCH_VER}" + fi + if [[ -n ${UCLIBC_VER} ]] ; then + guess_patch_type_in_dir "${WORKDIR}"/uclibc + EPATCH_MULTI_MSG="Applying uClibc patches ..." \ + epatch "${WORKDIR}"/uclibc + fi + fi + do_gcc_HTB_patches + do_gcc_PIE_patches + epatch_user + + use hardened && make_gcc_hard + + # install the libstdc++ python into the right location + # http://gcc.gnu.org/PR51368 + if tc_version_is_at_least 4.5 && ! tc_version_is_at_least 4.7 ; then + sed -i \ + '/^pythondir =/s:=.*:= $(datadir)/python:' \ + "${S}"/libstdc++-v3/python/Makefile.in || die + fi + + # make sure the pkg config files install into multilib dirs. + # since we configure with just one --libdir, we can't use that + # (as gcc itself takes care of building multilibs). #435728 + find "${S}" -name Makefile.in \ + -exec sed -i '/^pkgconfigdir/s:=.*:=$(toolexeclibdir)/pkgconfig:' {} + + + # No idea when this first started being fixed, but let's go with 4.3.x for now + if ! tc_version_is_at_least 4.3 ; then + fix_files="" + for x in contrib/test_summary libstdc++-v3/scripts/check_survey.in ; do + [[ -e ${x} ]] && fix_files="${fix_files} ${x}" + done + ht_fix_file ${fix_files} */configure *.sh */Makefile.in + fi + + setup_multilib_osdirnames + gcc_version_patch + + if tc_version_is_at_least 4.1 ; then + if [[ -n ${SNAPSHOT} || -n ${PRERELEASE} ]] ; then + # BASE-VER must be a three-digit version number + # followed by an optional -pre string + # eg. 4.5.1, 4.6.2-pre20120213, 4.7.0-pre9999 + # If BASE-VER differs from ${PV/_/-} then libraries get installed in + # the wrong directory. + echo ${PV/_/-} > "${S}"/gcc/BASE-VER + fi + fi + + # >= gcc-4.3 doesn't bundle ecj.jar, so copy it + if tc_version_is_at_least 4.3 && use gcj ; then + if tc_version_is_at_least 4.5 ; then + einfo "Copying ecj-4.5.jar" + cp -pPR "${DISTDIR}/ecj-4.5.jar" "${S}/ecj.jar" || die + else + einfo "Copying ecj-4.3.jar" + cp -pPR "${DISTDIR}/ecj-4.3.jar" "${S}/ecj.jar" || die + fi + fi + + # disable --as-needed from being compiled into gcc specs + # natively when using a gcc version < 3.4.4 + # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14992 + if ! tc_version_is_at_least 3.4.4 ; then + sed -i -e s/HAVE_LD_AS_NEEDED/USE_LD_AS_NEEDED/g "${S}"/gcc/config.in + fi + + # In gcc 3.3.x and 3.4.x, rename the java bins to gcc-specific names + # in line with gcc-4. + if tc_version_is_at_least 3.3 && ! tc_version_is_at_least 4.0 ; then + do_gcc_rename_java_bins + fi + + # Prevent libffi from being installed + if tc_version_is_at_least 3.0 && ! tc_version_is_at_least 4.8 ; then + sed -i -e 's/\(install.*:\) install-.*recursive/\1/' "${S}"/libffi/Makefile.in || die + sed -i -e 's/\(install-data-am:\).*/\1/' "${S}"/libffi/include/Makefile.in || die + fi + + # Fixup libtool to correctly generate .la files with portage + elibtoolize --portage --shallow --no-uclibc + + gnuconfig_update + + # update configure files + local f + einfo "Fixing misc issues in configure files" + # TODO - check if we can drop this now that we don't gen info files + tc_version_is_at_least 4.1 && epatch "${GCC_FILESDIR}"/gcc-configure-texinfo.patch + for f in $(grep -l 'autoconf version 2.13' $(find "${S}" -name configure)) ; do + ebegin " Updating ${f/${S}\/} [LANG]" + patch "${f}" "${GCC_FILESDIR}"/gcc-configure-LANG.patch >& "${T}"/configure-patch.log \ + || eerror "Please file a bug about this" + eend $? + done + sed -i 's|A-Za-z0-9|[:alnum:]|g' "${S}"/gcc/*.awk #215828 + + if [[ -x contrib/gcc_update ]] ; then + einfo "Touching generated files" + ./contrib/gcc_update --touch | \ + while read f ; do + einfo " ${f%%...}" + done + 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 +} + +gcc-multilib-configure() { + if ! is_multilib ; then + 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+=( --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.7 && confgcc+=( --with-multilib-list=${list:1} ) + ;; + esac + fi +} + +gcc-compiler-configure() { + gcc-multilib-configure + + if tc_version_is_at_least 4.0 ; then + if in_iuse mudflap ; then + confgcc+=( $(use_enable mudflap libmudflap) ) + else + confgcc+=( --disable-libmudflap ) + fi + + if use_if_iuse libssp ; then + confgcc+=( --enable-libssp ) + else + export gcc_cv_libc_provides_ssp=yes + confgcc+=( --disable-libssp ) + fi + + # If we want hardened support with the newer piepatchset for >=gcc 4.4 + if tc_version_is_at_least 4.4 && want_minispecs ; then + confgcc+=( $(use_enable hardened esp) ) + fi + + if tc_version_is_at_least 4.2 ; then + 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 + confgcc+=( $(use_enable openmp libgomp) ) + else + # Force disable as the configure script can be dumb #359855 + confgcc+=( --disable-libgomp ) + fi + else + # For gcc variants where we don't want openmp (e.g. kgcc) + confgcc+=( --disable-libgomp ) + fi + fi + + # Stick the python scripts in their own slotted directory + # bug #279252 + # + # --with-python-dir=DIR + # Specifies where to install the Python modules used for aot-compile. DIR + # should not include the prefix used in installation. For example, if the + # Python modules are to be installed in /usr/lib/python2.5/site-packages, + # then --with-python-dir=/lib/python2.5/site-packages should be passed. + # + # This should translate into "/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}/python" + if tc_version_is_at_least 4.4 ; then + confgcc+=( --with-python-dir=${DATAPATH/$PREFIX/}/python ) + fi + fi + + # Enable build warnings by default with cross-compilers when system + # paths are included (e.g. via -I flags). + is_crosscompile && confgcc+=( --enable-poison-system-directories ) + + # For newer versions of gcc, use the default ("release"), because no + # one (even upstream apparently) tests with it disabled. #317217 + if tc_version_is_at_least 4 || [[ -n ${GCC_CHECKS_LIST} ]] ; then + confgcc+=( --enable-checking=${GCC_CHECKS_LIST:-release} ) + else + confgcc+=( --disable-checking ) + fi + + # GTK+ is preferred over xlib in 3.4.x (xlib is unmaintained + # right now). Much thanks to <csm@gnu.org> for the heads up. + # Travis Tilley <lv@gentoo.org> (11 Jul 2004) + if ! is_gcj ; then + confgcc+=( --disable-libgcj ) + elif use gtk ; then + confgcc+=( --enable-java-awt=gtk ) + fi + + # allow gcc to search for clock funcs in the main C lib. + # if it can't find them, then tough cookies -- we aren't + # going to link in -lrt to all C++ apps. #411681 + if tc_version_is_at_least 4.4 && is_cxx ; then + confgcc+=( --enable-libstdcxx-time ) + fi + + # newer gcc versions like to bootstrap themselves with C++, + # so we need to manually disable it ourselves + if tc_version_is_at_least 4.7 && ! is_cxx ; then + confgcc+=( --disable-build-with-cxx --disable-build-poststage1-with-cxx ) + fi + + # newer gcc's come with libquadmath, but only fortran uses + # it, so auto punt it when we don't care + if tc_version_is_at_least 4.6 && ! is_fortran ; then + confgcc+=( --disable-libquadmath ) + fi + + local with_abi_map=() + case $(tc-arch) in + arm) #264534 #414395 + 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+=( --with-arch=${arm_arch} ) + fi + + # Make default mode thumb for microcontroller classes #418209 + [[ ${arm_arch} == *-m ]] && confgcc+=( --with-mode=thumb ) + + # Enable hardvfp + if [[ $(tc-is-softfloat) == "no" ]] && \ + [[ ${CTARGET} == armv[67]* ]] && \ + tc_version_is_at_least 4.5 + then + # Follow the new arm hardfp distro standard by default + confgcc+=( --with-float=hard ) + case ${CTARGET} in + armv6*) confgcc+=( --with-fpu=vfp ) ;; + armv7*) confgcc+=( --with-fpu=vfpv3-d16 ) ;; + esac + fi + ;; + mips) + # Add --with-abi flags to set default ABI + confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) ) + ;; + amd64) + # drop the older/ABI checks once this get's merged into some + # version of gcc upstream + if tc_version_is_at_least 4.7 && has x32 $(get_all_abis TARGET) ; then + confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) ) + fi + ;; + x86) + # Default arch for x86 is normally i386, lets give it a bump + # since glibc will do so based on CTARGET anyways + confgcc+=( --with-arch=${CTARGET%%-*} ) + ;; + hppa) + # Enable sjlj exceptions for backward compatibility on hppa + [[ ${GCCMAJOR} == "3" ]] && confgcc+=( --enable-sjlj-exceptions ) + ;; + ppc) + # Set up defaults based on current CFLAGS + is-flagq -mfloat-gprs=double && confgcc+=( --enable-e500-double ) + [[ ${CTARGET//_/-} == *-e500v2-* ]] && confgcc+=( --enable-e500-double ) + ;; + esac + + local GCC_LANG="c" + is_cxx && GCC_LANG+=",c++" + is_d && GCC_LANG+=",d" + is_gcj && GCC_LANG+=",java" + is_go && GCC_LANG+=",go" + if is_objc || is_objcxx ; then + GCC_LANG+=",objc" + if tc_version_is_at_least 4 ; then + use objc-gc && confgcc+=( --enable-objc-gc ) + fi + is_objcxx && GCC_LANG+=",obj-c++" + fi + is_treelang && GCC_LANG+=",treelang" + + # fortran support just got sillier! the lang value can be f77 for + # fortran77, f95 for fortran95, or just plain old fortran for the + # currently supported standard depending on gcc version. + is_fortran && GCC_LANG+=",fortran" + is_f77 && GCC_LANG+=",f77" + is_f95 && GCC_LANG+=",f95" + + # We do NOT want 'ADA support' in here! + # is_ada && GCC_LANG+=",ada" + + einfo "configuring for GCC_LANG: ${GCC_LANG}" + confgcc+=( --enable-languages=${GCC_LANG} ) +} + +gcc_do_configure() { + local confgcc=( + --prefix="${EPREFIX}${PREFIX}" + --bindir="${EPREFIX}${BINPATH}" + --includedir="${EPREFIX}${INCLUDEPATH}" + --datadir="${EPREFIX}${DATAPATH}" + --mandir="${EPREFIX}${DATAPATH}/man" + --infodir="${EPREFIX}${DATAPATH}/info" + --with-gxx-include-dir="${EPREFIX}${STDCXX_INCDIR}" + ) + # On Darwin we need libdir to be set in order to get correct install names + # for things like libobjc-gnu, libgcj and libfortran. If we enable it on + # non-Darwin we screw up the behaviour this eclass relies on. We in + # particular need this over --libdir for bug #255315. + [[ ${CTARGET} == *-darwin* ]] && \ + confgcc+=( --enable-version-specific-runtime-libs ) + + # All our cross-compile logic goes here ! woo ! + confgcc+=( --host=${CHOST} ) + if is_crosscompile || tc-is-cross-compiler ; then + # Straight from the GCC install doc: + # "GCC has code to correctly determine the correct value for target + # for nearly all native systems. Therefore, we highly recommend you + # not provide a configure target when configuring a native compiler." + confgcc+=( --target=${CTARGET} ) + fi + [[ -n ${CBUILD} ]] && confgcc+=( --build=${CBUILD} ) + + # ppc altivec support + confgcc+=( $(use_enable altivec) ) + + # gcc has fixed-point arithmetic support in 4.3 for mips targets that can + # significantly increase compile time by several hours. This will allow + # users to control this feature in the event they need the support. + tc_version_is_at_least 4.3 && confgcc+=( $(use_enable fixed-point) ) + + # graphite was added in 4.4 but we only support it in 4.6+ due to external + # library issues. 4.6/4.7 uses cloog-ppl which is a fork of CLooG with a + # PPL backend. 4.8+ uses upstream CLooG with the ISL backend. We install + # cloog-ppl into a non-standard location to prevent collisions. + if tc_version_is_at_least 4.8 ; then + confgcc+=( $(use_with graphite cloog) ) + use graphite && confgcc+=( --disable-isl-version-check ) + elif tc_version_is_at_least 4.6 ; then + confgcc+=( $(use_with graphite cloog) ) + confgcc+=( $(use_with graphite ppl) ) + use graphite && confgcc+=( --with-cloog-include="${EPREFIX}"/usr/include/cloog-ppl ) + use graphite && confgcc+=( --disable-ppl-version-check ) + elif tc_version_is_at_least 4.4 ; then + confgcc+=( --without-cloog ) + confgcc+=( --without-ppl ) + fi + + if tc_version_is_at_least 4.6 ; then + confgcc+=( $(use_enable lto) ) + elif tc_version_is_at_least 4.5 ; then + confgcc+=( --disable-lto ) + fi + + case $(tc-is-softfloat) in + yes) confgcc+=( --with-float=soft ) ;; + softfp) confgcc+=( --with-float=softfp ) ;; + *) + # If they've explicitly opt-ed in, do hardfloat, + # otherwise let the gcc default kick in. + [[ ${CTARGET//_/-} == *-hardfloat-* ]] \ + && confgcc+=( --with-float=hard ) + ;; + esac + + # Native Language Support + if use nls ; then + confgcc+=( --enable-nls --without-included-gettext ) + else + confgcc+=( --disable-nls ) + fi + + # reasonably sane globals (hopefully) + confgcc+=( + --with-system-zlib + --enable-obsolete + --disable-werror + --enable-secureplt + ) + + gcc-compiler-configure || die + + if is_crosscompile ; then + # When building a stage1 cross-compiler (just C compiler), we have to + # disable a bunch of features or gcc goes boom + local needed_libc="" + case ${CTARGET} in + *-linux) needed_libc=no-fucking-clue;; + *-dietlibc) needed_libc=dietlibc;; + *-elf|*-eabi) needed_libc=newlib;; + *-freebsd*) needed_libc=freebsd-lib;; + *-gnu*) needed_libc=glibc;; + *-klibc) needed_libc=klibc;; + *-musl*) needed_libc=musl;; + *-uclibc*) + if ! echo '#include <features.h>' | \ + $(tc-getCPP ${CTARGET}) -E -dD - 2>/dev/null | \ + grep -q __HAVE_SHARED__ + then #291870 + confgcc+=( --disable-shared ) + fi + needed_libc=uclibc + ;; + *-cygwin) needed_libc=cygwin;; + x86_64-*-mingw*|\ + *-w64-mingw*) needed_libc=mingw64-runtime;; + mingw*|*-mingw*) needed_libc=mingw-runtime;; + avr) confgcc+=( --enable-shared --disable-threads );; + *-apple-darwin*) confgcc+=( --with-sysroot="${EPREFIX}"${PREFIX}/${CTARGET} );; + *-solaris*) confgcc+=( --with-sysroot="${EPREFIX}"${PREFIX}/${CTARGET} );; + *-freebsd*) confgcc+=( --with-sysroot="${EPREFIX}"${PREFIX}/${CTARGET} );; + esac + if [[ -n ${needed_libc} ]] ; then + local confgcc_no_libc=( --disable-shared ) + tc_version_is_at_least 4.8 && confgcc_no_libc+=( --disable-libatomic ) + if ! has_version ${CATEGORY}/${needed_libc} ; then + confgcc+=( + "${confgcc_no_libc[@]}" + --disable-threads + --without-headers + ) + elif built_with_use --hidden --missing false ${CATEGORY}/${needed_libc} crosscompile_opts_headers-only ; then + confgcc+=( + "${confgcc_no_libc[@]}" + --with-sysroot="${EPREFIX}"${PREFIX}/${CTARGET} + ) + else + confgcc+=( --with-sysroot="${EPREFIX}"${PREFIX}/${CTARGET} ) + fi + fi + + tc_version_is_at_least 4.2 && confgcc+=( --disable-bootstrap ) + else + if tc-is-static-only ; then + confgcc+=( --disable-shared ) + else + confgcc+=( --enable-shared ) + fi + case ${CHOST} in + mingw*|*-mingw*|*-cygwin) + confgcc+=( --enable-threads=win32 ) ;; + *) + confgcc+=( --enable-threads=posix ) ;; + esac + + if use prefix ; then + # should be /usr, because it's the path to search includes for, + # which is unrelated to TOOLCHAIN_PREFIX, a.k.a. PREFIX + confgcc+=( --with-local-prefix="${TPREFIX}"/usr ) + fi + fi + # __cxa_atexit is "essential for fully standards-compliant handling of + # destructors", but apparently requires glibc. + case ${CTARGET} in + *-uclibc*) + confgcc+=( + --disable-__cxa_atexit + $(use_enable nptl tls) + ) + [[ ${GCCMAJOR}.${GCCMINOR} == 3.3 ]] && confgcc+=( --enable-sjlj-exceptions ) + if tc_version_is_at_least 3.4 && ! tc_version_is_at_least 4.3 ; then + confgcc+=( --enable-clocale=uclibc ) + fi + ;; + *-elf|*-eabi) + confgcc+=( --with-newlib ) + ;; + *-gnu*) + confgcc+=( + --enable-__cxa_atexit + --enable-clocale=gnu + ) + ;; + *-freebsd*) + confgcc+=( --enable-__cxa_atexit ) + ;; + *-solaris*) + confgcc+=( --enable-__cxa_atexit ) + ;; + esac + + tc_version_is_at_least 3.4 || confgcc+=( --disable-libunwind-exceptions ) + + # if the target can do biarch (-m32/-m64), enable it. overhead should + # be small, and should simplify building of 64bit kernels in a 32bit + # userland by not needing sys-devel/kgcc64. #349405 + if ! use prefix ; then + case $(tc-arch) in + ppc|ppc64) tc_version_is_at_least 3.4 && confgcc+=( --enable-targets=all ) ;; + sparc) tc_version_is_at_least 4.4 && confgcc+=( --enable-targets=all ) ;; + amd64|x86) tc_version_is_at_least 4.3 && confgcc+=( --enable-targets=all ) ;; + esac + fi + + tc_version_is_at_least 4.3 && confgcc+=( + --with-bugurl=http://bugs.gentoo.org/ + --with-pkgversion="${BRANDING_GCC_PKGVERSION}" + ) + + confgcc+=( + "$@" + ${EXTRA_ECONF} + ) + + # Disable gcc info regeneration -- it ships with generated info pages + # already. Our custom version/urls/etc... trigger it. #464008 + export gcc_cv_prog_makeinfo_modern=no + + # Do not let the X detection get in our way. We know things can be found + # via system paths, so no need to hardcode things that'll break multilib. + # Older gcc versions will detect ac_x_libraries=/usr/lib64 which ends up + # killing the 32bit builds which want /usr/lib. + export ac_cv_have_x='have_x=yes ac_x_includes= ac_x_libraries=' + + # Nothing wrong with a good dose of verbosity + echo + einfo "EPREFIX: ${EPREFIX}" + einfo "PREFIX: ${PREFIX}" + einfo "BINPATH: ${BINPATH}" + einfo "LIBPATH: ${LIBPATH}" + einfo "DATAPATH: ${DATAPATH}" + einfo "STDCXX_INCDIR: ${STDCXX_INCDIR}" + echo + einfo "Configuring GCC with: ${confgcc[@]//--/\n\t--}" + echo + + # Build in a separate build tree + mkdir -p "${WORKDIR}"/build + pushd "${WORKDIR}"/build > /dev/null + + # and now to do the actual configuration + addwrite /dev/zero + echo "${S}"/configure "${confgcc[@]}" + "${S}"/configure "${confgcc[@]}" || die "failed to run configure" + + # return to whatever directory we were in before + popd > /dev/null +} + +has toolchain_death_notice ${EBUILD_DEATH_HOOKS} || EBUILD_DEATH_HOOKS+=" toolchain_death_notice" +toolchain_death_notice() { + pushd "${WORKDIR}"/build >/dev/null + tar jcf gcc-build-logs.tar.bz2 $(find -name config.log) + eerror + eerror "Please include ${PWD}/gcc-build-logs.tar.bz2 in your bug report" + eerror + popd >/dev/null +} + +# This function accepts one optional argument, the make target to be used. +# If ommitted, gcc_do_make will try to guess whether it should use all, +# profiledbootstrap, or bootstrap-lean depending on CTARGET and arch. An +# example of how to use this function: +# +# gcc_do_make all-target-libstdc++-v3 +# +# In addition to the target to be used, the following variables alter the +# behavior of this function: +# +# LDFLAGS +# Flags to pass to ld +# +# STAGE1_CFLAGS +# CFLAGS to use during stage1 of a gcc bootstrap +# +# BOOT_CFLAGS +# CFLAGS to use during stages 2+3 of a gcc bootstrap. +# +# Travis Tilley <lv@gentoo.org> (04 Sep 2004) +# +gcc_do_make() { + # Set make target to $1 if passed + [[ -n $1 ]] && GCC_MAKE_TARGET=$1 + # default target + if is_crosscompile || tc-is-cross-compiler ; then + # 3 stage bootstrapping doesnt quite work when you cant run the + # resulting binaries natively ^^; + GCC_MAKE_TARGET=${GCC_MAKE_TARGET-all} + else + GCC_MAKE_TARGET=${GCC_MAKE_TARGET-bootstrap-lean} + fi + + # the gcc docs state that parallel make isnt supported for the + # profiledbootstrap target, as collisions in profile collecting may occur. + # boundschecking also seems to introduce parallel build issues. + if [[ ${GCC_MAKE_TARGET} == "profiledbootstrap" ]] || + use_if_iuse boundschecking + then + export MAKEOPTS="${MAKEOPTS} -j1" + fi + + if [[ ${GCC_MAKE_TARGET} == "all" ]] ; then + STAGE1_CFLAGS=${STAGE1_CFLAGS-"${CFLAGS}"} + elif [[ $(gcc-version) == "3.4" && ${GCC_BRANCH_VER} == "3.4" ]] && gcc-specs-ssp ; then + # See bug #79852 + STAGE1_CFLAGS=${STAGE1_CFLAGS-"-O2"} + fi + + if is_crosscompile; then + # In 3.4, BOOT_CFLAGS is never used on a crosscompile... + # but I'll leave this in anyways as someone might have had + # some reason for putting it in here... --eradicator + BOOT_CFLAGS=${BOOT_CFLAGS-"-O2"} + else + # we only want to use the system's CFLAGS if not building a + # cross-compiler. + BOOT_CFLAGS=${BOOT_CFLAGS-"$(get_abi_CFLAGS ${TARGET_DEFAULT_ABI}) ${CFLAGS}"} + fi + + pushd "${WORKDIR}"/build >/dev/null + + # we "undef" T because the GCC makefiles use this variable, and if it's set + # in the environment (like Portage does) the build fails, bug #286494 + emake \ + T= \ + LDFLAGS="${LDFLAGS}" \ + STAGE1_CFLAGS="${STAGE1_CFLAGS}" \ + LIBPATH="${EPREFIX}${LIBPATH}" \ + BOOT_CFLAGS="${BOOT_CFLAGS}" \ + ${GCC_MAKE_TARGET} \ + || die "emake failed with ${GCC_MAKE_TARGET}" + + if ! is_crosscompile && use cxx && use_if_iuse doc ; then + if type -p doxygen > /dev/null ; then + if tc_version_is_at_least 4.3 ; then + cd "${CTARGET}"/libstdc++-v3/doc + emake doc-man-doxygen || ewarn "failed to make docs" + elif tc_version_is_at_least 3.0 ; then + cd "${CTARGET}"/libstdc++-v3 + emake doxygen-man || ewarn "failed to make docs" + fi + else + ewarn "Skipping libstdc++ manpage generation since you don't have doxygen installed" + fi + fi + + popd >/dev/null +} + +gcc_do_filter_flags() { + + strip-flags + + # In general gcc does not like optimization, and add -O2 where + # it is safe. This is especially true for gcc 3.3 + 3.4 + replace-flags -O? -O2 + + # ... sure, why not? + strip-unsupported-flags + + # dont want to funk ourselves + filter-flags '-mabi*' -m31 -m32 -m64 + + case ${GCC_BRANCH_VER} in + 3.2|3.3) + replace-cpu-flags k8 athlon64 opteron i686 x86-64 + replace-cpu-flags pentium-m pentium3m pentium3 + case $(tc-arch) in + amd64|x86) filter-flags '-mtune=*' ;; + # in gcc 3.3 there is a bug on ppc64 where if -mcpu is used, + # the compiler wrongly assumes a 32bit target + ppc64) filter-flags "-mcpu=*";; + esac + case $(tc-arch) in + amd64) replace-cpu-flags core2 nocona;; + x86) replace-cpu-flags core2 prescott;; + esac + + replace-cpu-flags G3 750 + replace-cpu-flags G4 7400 + replace-cpu-flags G5 7400 + + # XXX: should add a sed or something to query all supported flags + # from the gcc source and trim everything else ... + filter-flags -f{no-,}unit-at-a-time -f{no-,}web -mno-tls-direct-seg-refs + filter-flags -f{no-,}stack-protector{,-all} + filter-flags -fvisibility-inlines-hidden -fvisibility=hidden + ;; + 3.4|4.*) + case $(tc-arch) in + x86|amd64) filter-flags '-mcpu=*';; + *-macos) + # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25127 + [[ ${GCC_BRANCH_VER} == 4.0 || ${GCC_BRANCH_VER} == 4.1 ]] && \ + filter-flags '-mcpu=*' '-march=*' '-mtune=*' + ;; + esac + ;; + esac + + case ${GCC_BRANCH_VER} in + 4.6) + # https://bugs.gentoo.org/411333 + # https://bugs.gentoo.org/466454 + replace-cpu-flags c3-2 pentium2 pentium3 pentium3m pentium-m i686 + ;; + esac + + # TODO: Move to gcc_do_make() + + # CFLAGS logic (verified with 3.4.3): + # CFLAGS: + # This conflicts when creating a crosscompiler, so set to a sane + # default in this case: + # used in ./configure and elsewhere for the native compiler + # used by gcc when creating libiberty.a + # used by xgcc when creating libstdc++ (and probably others)! + # this behavior should be removed... + # + # CXXFLAGS: + # used by xgcc when creating libstdc++ + # + # STAGE1_CFLAGS (not used in creating a crosscompile gcc): + # used by ${CHOST}-gcc for building stage1 compiler + # + # BOOT_CFLAGS (not used in creating a crosscompile gcc): + # used by xgcc for building stage2/3 compiler + + if is_crosscompile ; then + # Set this to something sane for both native and target + CFLAGS="-O2 -pipe" + FFLAGS=${CFLAGS} + FCFLAGS=${CFLAGS} + + local VAR="CFLAGS_"${CTARGET//-/_} + CXXFLAGS=${!VAR} + fi + + export GCJFLAGS=${GCJFLAGS:-${CFLAGS}} +} + +toolchain_src_compile() { + gcc_do_filter_flags + einfo "CFLAGS=\"${CFLAGS}\"" + einfo "CXXFLAGS=\"${CXXFLAGS}\"" + + # Force internal zip based jar script to avoid random + # issues with 3rd party jar implementations. #384291 + export JAR=no + + # For hardened gcc 4.3 piepatchset to build the hardened specs + # file (build.specs) to use when building gcc. + if ! tc_version_is_at_least 4.4 && want_minispecs ; then + setup_minispecs_gcc_build_specs + fi + # Build in a separate build tree + mkdir -p "${WORKDIR}"/build + pushd "${WORKDIR}"/build > /dev/null + + einfo "Configuring ${PN} ..." + gcc_do_configure + + touch "${S}"/gcc/c-gperf.h + + # Do not make manpages if we do not have perl ... + [[ ! -x ${EPREFIX}/usr/bin/perl ]] \ + && find "${WORKDIR}"/build -name '*.[17]' | xargs touch + + einfo "Compiling ${PN} ..." + gcc_do_make ${GCC_MAKE_TARGET} + + popd > /dev/null +} + +toolchain_src_test() { + if use regression-test ; then + cd "${WORKDIR}"/build + emake -k check + fi +} + +toolchain_src_install() { + cd "${WORKDIR}"/build + + # Do allow symlinks in private gcc include dir as this can break the build + find gcc/include*/ -type l -delete + + # Copy over the info pages. We disabled their generation earlier, but the + # build system only expects to install out of the build dir, not the source. #464008 + mkdir -p gcc/doc + local x= + for x in "${S}"/gcc/doc/*.info* ; do + if [[ -f ${x} ]] ; then + cp "${x}" gcc/doc/ || die + fi + done + + # Remove generated headers, as they can cause things to break + # (ncurses, openssl, etc). + while read x ; do + grep -q 'It has been auto-edited by fixincludes from' "${x}" \ + && rm -f "${x}" + done < <(find gcc/include*/ -name '*.h') + + # Do the 'make install' from the build directory + S="${WORKDIR}"/build emake -j1 DESTDIR="${D}" install || die + + # Punt some tools which are really only useful while building gcc + find "${ED}" -name install-tools -prune -type d -exec rm -rf "{}" \; + # This one comes with binutils + find "${ED}" -name libiberty.a -delete + + # Move the libraries to the proper location + gcc_movelibs + + # Basic sanity check + if ! is_crosscompile ; then + local EXEEXT + eval $(grep ^EXEEXT= "${WORKDIR}"/build/gcc/config.log) + [[ -r ${ED}${BINPATH}/gcc${EXEEXT} ]] || die "gcc not found in ${ED}" + fi + + dodir /etc/env.d/gcc + create_gcc_env_entry + + # Setup the gcc_env_entry for hardened gcc 4 with minispecs + want_minispecs && copy_minispecs_gcc_specs + + # Make sure we dont have stuff lying around that + # can nuke multiple versions of gcc + gcc_slot_java + + dodir /usr/bin + cd "${ED}"${BINPATH} + # Ugh: we really need to auto-detect this list. + # It's constantly out of date. + for x in cpp gcc g++ c++ gcov g77 gcj gcjh gfortran gccgo ; do + # For some reason, g77 gets made instead of ${CTARGET}-g77... + # this should take care of that + [[ -f ${x} ]] && mv ${x} ${CTARGET}-${x} + + if [[ -f ${CTARGET}-${x} ]] ; then + if ! is_crosscompile ; then + ln -sf ${CTARGET}-${x} ${x} + dosym ${BINPATH}/${CTARGET}-${x} \ + /usr/bin/${x}-${GCC_CONFIG_VER} + fi + # Create versioned symlinks + dosym ${BINPATH}/${CTARGET}-${x} \ + /usr/bin/${CTARGET}-${x}-${GCC_CONFIG_VER} + fi + + if [[ -f ${CTARGET}-${x}-${GCC_CONFIG_VER} ]] ; then + rm -f ${CTARGET}-${x}-${GCC_CONFIG_VER} + ln -sf ${CTARGET}-${x} ${CTARGET}-${x}-${GCC_CONFIG_VER} + fi + done + + # Now do the fun stripping stuff + env RESTRICT="" CHOST=${CHOST} prepstrip "${ED}${BINPATH}" + env RESTRICT="" CHOST=${CTARGET} prepstrip "${ED}${LIBPATH}" + # gcc used to install helper binaries in lib/ but then moved to libexec/ + [[ -d ${ED}${PREFIX}/libexec/gcc ]] && \ + env RESTRICT="" CHOST=${CHOST} prepstrip "${ED}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}" + + cd "${S}" + if is_crosscompile; then + rm -rf "${ED}"/usr/share/{man,info} + rm -rf "${ED}"${DATAPATH}/{man,info} + else + if tc_version_is_at_least 3.0 ; then + local cxx_mandir=$(find "${WORKDIR}/build/${CTARGET}/libstdc++-v3" -name man) + if [[ -d ${cxx_mandir} ]] ; then + # clean bogus manpages #113902 + find "${cxx_mandir}" -name '*_build_*' -exec rm {} \; + cp -r "${cxx_mandir}"/man? "${ED}/${DATAPATH}"/man/ + fi + fi + has noinfo ${FEATURES} \ + && rm -r "${ED}/${DATAPATH}"/info \ + || prepinfo "${DATAPATH}" + has noman ${FEATURES} \ + && rm -r "${ED}/${DATAPATH}"/man \ + || prepman "${DATAPATH}" + fi + # prune empty dirs left behind + find "${ED}" -depth -type d -delete 2>/dev/null + + # install testsuite results + if use regression-test; then + docinto testsuite + find "${WORKDIR}"/build -type f -name "*.sum" -print0 | xargs -0 dodoc + find "${WORKDIR}"/build -type f -path "*/testsuite/*.log" -print0 \ + | xargs -0 dodoc + fi + + # Rather install the script, else portage with changing $FILESDIR + # between binary and source package borks things .... + if ! is_crosscompile ; then + cp "${GCC_FILESDIR}"/fix_libtool_files.sh "${T}" + cp "${GCC_FILESDIR}"/awk/fixlafiles.awk-no_gcc_la "${T}" + cp "${GCC_FILESDIR}"/awk/fixlafiles.awk "${T}" + eprefixify \ + "${T}"/fix_libtool_files.sh \ + "${T}"/fixlafiles.awk-no_gcc_la \ + "${T}"/fixlafiles.awk + + insinto "${DATAPATH}" + if tc_version_is_at_least 4.0 ; then + newins "${T}"/fixlafiles.awk-no_gcc_la fixlafiles.awk || die + find "${ED}/${LIBPATH}" -name libstdc++.la -type f -exec rm "{}" \; + else + doins "${T}"/fixlafiles.awk || die + fi + exeinto "${DATAPATH}" + doexe "${T}"/fix_libtool_files.sh || die + doexe "${GCC_FILESDIR}"/c{89,99} || die + fi + + # Use gid of 0 because some stupid ports don't have + # the group 'root' set to gid 0. Send to /dev/null + # for people who are testing as non-root. + chown -R ${PORTAGE_INST_UID:-0}:${PORTAGE_INST_GID:-0} "${ED}"${LIBPATH} 2>/dev/null + + # Move pretty-printers to gdb datadir to shut ldconfig up + local py gdbdir=/usr/share/gdb/auto-load${LIBPATH/\/lib\//\/$(get_libdir)\/} + pushd "${ED}"${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 #348128 + doins "${py}" || die + rm "${py}" || die + done + popd >/dev/null + + # Don't scan .gox files for executable stacks - false positives + export QA_EXECSTACK="usr/lib*/go/*/*.gox" + export QA_WX_LOAD="usr/lib*/go/*/*.gox" + + # Disable RANDMMAP so PCH works. #301299 + if tc_version_is_at_least 4.3 ; then + pax-mark -r "${ED}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1" + pax-mark -r "${ED}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1plus" + fi +} + +gcc_slot_java() { + local x + + # Move Java headers to compiler-specific dir + for x in "${ED}"${PREFIX}/include/gc*.h "${ED}"${PREFIX}/include/j*.h ; do + [[ -f ${x} ]] && mv -f "${x}" "${ED}"${LIBPATH}/include/ + done + for x in gcj gnu java javax org ; do + if [[ -d ${ED}${PREFIX}/include/${x} ]] ; then + dodir /${LIBPATH}/include/${x} + mv -f "${ED}"${PREFIX}/include/${x}/* "${ED}"${LIBPATH}/include/${x}/ + rm -rf "${ED}"${PREFIX}/include/${x} + fi + done + + if [[ -d ${ED}${PREFIX}/lib/security ]] || [[ -d ${ED}${PREFIX}/$(get_libdir)/security ]] ; then + dodir /${LIBPATH}/security + mv -f "${ED}"${PREFIX}/lib*/security/* "${ED}"${LIBPATH}/security + rm -rf "${ED}"${PREFIX}/lib*/security + fi + + # Move random gcj files to compiler-specific directories + for x in libgcj.spec logging.properties ; do + x="${ED}${PREFIX}/lib/${x}" + [[ -f ${x} ]] && mv -f "${x}" "${ED}"${LIBPATH}/ + done + + # Rename jar because it could clash with Kaffe's jar if this gcc is + # primary compiler (aka don't have the -<version> extension) + cd "${ED}"${BINPATH} + [[ -f jar ]] && mv -f jar gcj-jar +} + +# Move around the libs to the right location. For some reason, +# when installing gcc, it dumps internal libraries into /usr/lib +# instead of the private gcc lib path +gcc_movelibs() { + # older versions of gcc did not support --print-multi-os-directory + tc_version_is_at_least 3.2 || return 0 + + local x multiarg removedirs="" + for multiarg in $($(XGCC) -print-multi-lib) ; do + multiarg=${multiarg#*;} + multiarg=${multiarg//@/ -} + + local OS_MULTIDIR=$($(XGCC) ${multiarg} --print-multi-os-directory) + local MULTIDIR=$($(XGCC) ${multiarg} --print-multi-directory) + local TODIR=${ED}${LIBPATH}/${MULTIDIR} + local FROMDIR= + + [[ -d ${TODIR} ]] || mkdir -p ${TODIR} + + for FROMDIR in \ + ${LIBPATH}/${OS_MULTIDIR} \ + ${LIBPATH}/../${MULTIDIR} \ + ${PREFIX}/lib/${OS_MULTIDIR} \ + ${PREFIX}/${CTARGET}/lib/${OS_MULTIDIR} + do + removedirs="${removedirs} ${FROMDIR}" + FROMDIR=${ED}${FROMDIR} + if [[ ${FROMDIR} != "${TODIR}" && -d ${FROMDIR} ]] ; then + local files=$(find "${FROMDIR}" -maxdepth 1 ! -type d 2>/dev/null) + if [[ -n ${files} ]] ; then + mv ${files} "${TODIR}" + fi + fi + done + fix_libtool_libdir_paths "${LIBPATH}/${MULTIDIR}" + + # SLOT up libgcj.pc if it's available (and let gcc-config worry about links) + FROMDIR="${PREFIX}/lib/${OS_MULTIDIR}" + for x in "${ED}${FROMDIR}"/pkgconfig/libgcj*.pc ; do + [[ -f ${x} ]] || continue + sed -i "/^libdir=/s:=.*:=${LIBPATH}/${MULTIDIR}:" "${x}" + mv "${x}" "${ED}${FROMDIR}"/pkgconfig/libgcj-${GCC_PV}.pc || die + done + done + + # We remove directories separately to avoid this case: + # mv SRC/lib/../lib/*.o DEST + # rmdir SRC/lib/../lib/ + # mv SRC/lib/../lib32/*.o DEST # Bork + for FROMDIR in ${removedirs} ; do + rmdir "${ED}"${FROMDIR} >& /dev/null + done + find "${ED}" -type d | xargs rmdir >& /dev/null +} +#----<< src_* >>---- + +#---->> unorganized crap in need of refactoring follows + +# gcc_quick_unpack will unpack the gcc tarball and patches in a way that is +# consistant with the behavior of get_gcc_src_uri. The only patch it applies +# itself is the branch update if present. +# +# Travis Tilley <lv@gentoo.org> (03 Sep 2004) +# +gcc_quick_unpack() { + pushd "${WORKDIR}" > /dev/null + export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}} + export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}} + export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}} + export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}} + export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}} + + if [[ -n ${GCC_A_FAKEIT} ]] ; then + unpack ${GCC_A_FAKEIT} + elif [[ -n ${PRERELEASE} ]] ; then + unpack gcc-${PRERELEASE}.tar.bz2 + elif [[ -n ${SNAPSHOT} ]] ; then + unpack gcc-${SNAPSHOT}.tar.bz2 + elif [[ ${PV} != *9999* ]] ; then + unpack gcc-${GCC_RELEASE_VER}.tar.bz2 + # We want branch updates to be against a release tarball + if [[ -n ${BRANCH_UPDATE} ]] ; then + pushd "${S}" > /dev/null + epatch "${DISTDIR}"/gcc-${GCC_RELEASE_VER}-branch-update-${BRANCH_UPDATE}.patch.bz2 + popd > /dev/null + fi + fi + + if [[ -n ${D_VER} ]] && use d ; then + pushd "${S}"/gcc > /dev/null + unpack gdc-${D_VER}-src.tar.bz2 + cd .. + ebegin "Adding support for the D language" + ./gcc/d/setup-gcc.sh >& "${T}"/dgcc.log + if ! eend $? ; then + eerror "The D gcc package failed to apply" + eerror "Please include this log file when posting a bug report:" + eerror " ${T}/dgcc.log" + die "failed to include the D language" + fi + popd > /dev/null + fi + + [[ -n ${PATCH_VER} ]] && \ + unpack gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2 + + [[ -n ${UCLIBC_VER} ]] && \ + unpack gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2 + + if want_pie ; then + if [[ -n ${PIE_CORE} ]] ; then + unpack ${PIE_CORE} + else + unpack gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2 + fi + [[ -n ${SPECS_VER} ]] && \ + unpack gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2 + fi + + use_if_iuse boundschecking && unpack "bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2" + + popd > /dev/null +} + +do_gcc_HTB_patches() { + use_if_iuse boundschecking || return 0 + + # modify the bounds checking patch with a regression patch + epatch "${WORKDIR}/bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch" + BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, HTB-${HTB_GCC_VER}-${HTB_VER}" +} + +# do various updates to PIE logic +do_gcc_PIE_patches() { + want_pie || return 0 + + use vanilla && return 0 + + if tc_version_is_at_least 4.3.2 ; then + guess_patch_type_in_dir "${WORKDIR}"/piepatch/ + EPATCH_MULTI_MSG="Applying pie patches ..." \ + epatch "${WORKDIR}"/piepatch/ + else + guess_patch_type_in_dir "${WORKDIR}"/piepatch/upstream + + # corrects startfile/endfile selection and shared/static/pie flag usage + EPATCH_MULTI_MSG="Applying upstream pie patches ..." \ + epatch "${WORKDIR}"/piepatch/upstream + # adds non-default pie support (rs6000) + EPATCH_MULTI_MSG="Applying non-default pie patches ..." \ + epatch "${WORKDIR}"/piepatch/nondef + # adds default pie support (rs6000 too) if DEFAULT_PIE[_SSP] is defined + EPATCH_MULTI_MSG="Applying default pie patches ..." \ + epatch "${WORKDIR}"/piepatch/def + fi + + # 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 + + BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, pie-${PIE_VER}" +} + +should_we_gcc_config() { + # 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=$(env -i ROOT="${ROOT}" "${EPREFIX}"/usr/bin/gcc-config -c ${CTARGET} 2>&1) || return 0 + + # if the previously selected config has the same major.minor (branch) as + # the version we are installing, then it will probably be uninstalled + # for being in the same SLOT, make sure we run gcc-config. + local curr_config_ver=$(env -i ROOT="${ROOT}" "${EPREFIX}"/usr/bin/gcc-config -S ${curr_config} | awk '{print $2}') + + local curr_branch_ver=$(get_version_component_range 1-2 ${curr_config_ver}) + + # If we're using multislot, just run gcc-config if we're installing + # to the same profile as the current one. + use multislot && return $([[ ${curr_config_ver} == ${GCC_CONFIG_VER} ]]) + + if [[ ${curr_branch_ver} == ${GCC_BRANCH_VER} ]] ; then + return 0 + else + # if we're installing a genuinely different compiler version, + # we should probably tell the user -how- to switch to the new + # gcc version, since we're not going to do it for him/her. + # We don't want to switch from say gcc-3.3 to gcc-3.4 right in + # the middle of an emerge operation (like an 'emerge -e world' + # which could install multiple gcc versions). + # Only warn if we're installing a pkg as we might be called from + # the pkg_{pre,post}rm steps. #446830 + if [[ ${EBUILD_PHASE} == *"inst" ]] ; then + einfo "The current gcc config appears valid, so it will not be" + einfo "automatically switched for you. If you would like to" + einfo "switch to the newly installed gcc version, do the" + einfo "following:" + echo + einfo "gcc-config ${CTARGET}-${GCC_CONFIG_VER}" + einfo "source /etc/profile" + echo + fi + return 1 + fi +} + +do_gcc_config() { + if ! should_we_gcc_config ; then + env -i ROOT="${ROOT}" "${EPREFIX}"/usr/bin/gcc-config --use-old --force + return 0 + fi + + local current_gcc_config="" current_specs="" use_specs="" + + current_gcc_config=$(env -i ROOT="${ROOT}" "${EPREFIX}"/usr/bin/gcc-config -c ${CTARGET} 2>/dev/null) + if [[ -n ${current_gcc_config} ]] ; then + # figure out which specs-specific config is active + current_specs=$(gcc-config -S ${current_gcc_config} | awk '{print $3}') + [[ -n ${current_specs} ]] && use_specs=-${current_specs} + fi + if [[ -n ${use_specs} ]] && \ + [[ ! -e ${EROOT}/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}${use_specs} ]] + then + ewarn "The currently selected specs-specific gcc config," + ewarn "${current_specs}, doesn't exist anymore. This is usually" + ewarn "due to enabling/disabling hardened or switching to a version" + ewarn "of gcc that doesnt create multiple specs files. The default" + ewarn "config will be used, and the previous preference forgotten." + use_specs="" + fi + + gcc-config ${CTARGET}-${GCC_CONFIG_VER}${use_specs} +} + +# This function allows us to gentoo-ize GCCs version number and bugzilla +# URL without needing to use patches. +gcc_version_patch() { + # gcc-4.3+ has configure flags (whoo!) + tc_version_is_at_least 4.3 && return 0 + + local version_string=${GCC_CONFIG_VER} + [[ -n ${BRANCH_UPDATE} ]] && version_string+=" ${BRANCH_UPDATE}" + + einfo "patching gcc version: ${version_string} (${BRANDING_GCC_PKGVERSION})" + + local gcc_sed=( -e 's:gcc\.gnu\.org/bugs\.html:bugs\.gentoo\.org/:' ) + if grep -qs VERSUFFIX "${S}"/gcc/version.c ; then + gcc_sed+=( -e "/VERSUFFIX \"\"/s:\"\":\" (${BRANDING_GCC_PKGVERSION})\":" ) + else + version_string="${version_string} (${BRANDING_GCC_PKGVERSION})" + gcc_sed+=( -e "/const char version_string\[\] = /s:= \".*\":= \"${version_string}\":" ) + fi + sed -i "${gcc_sed[@]}" "${S}"/gcc/version.c || die +} + +# This is a historical wart. The original Gentoo/amd64 port used: +# lib32 - 32bit binaries (x86) +# lib64 - 64bit binaries (x86_64) +# lib - "native" binaries (a symlink to lib64) +# Most other distros use the logic (including mainline gcc): +# lib - 32bit binaries (x86) +# lib64 - 64bit binaries (x86_64) +# Over time, Gentoo is migrating to the latter form. +# +# Unfortunately, due to distros picking the lib32 behavior, newer gcc +# versions will dynamically detect whether to use lib or lib32 for its +# 32bit multilib. So, to keep the automagic from getting things wrong +# while people are transitioning from the old style to the new style, +# we always set the MULTILIB_OSDIRNAMES var for relevant targets. +setup_multilib_osdirnames() { + is_multilib || return 0 + + local config + local libdirs="../lib64 ../lib32" + + # this only makes sense for some Linux targets + case ${CTARGET} in + x86_64*-linux*) config="i386" ;; + powerpc64*-linux*) config="rs6000" ;; + sparc64*-linux*) config="sparc" ;; + s390x*-linux*) config="s390" ;; + *) return 0 ;; + esac + config+="/t-linux64" + + local sed_args=() + if tc_version_is_at_least 4.6 ; then + sed_args+=( -e 's:$[(]call if_multiarch[^)]*[)]::g' ) + fi + if [[ ${SYMLINK_LIB} == "yes" ]] ; then + einfo "updating multilib directories to be: ${libdirs}" + if tc_version_is_at_least 4.6.4 || tc_version_is_at_least 4.7 ; then + sed_args+=( -e '/^MULTILIB_OSDIRNAMES.*lib32/s:[$][(]if.*):../lib32:' ) + else + sed_args+=( -e "/^MULTILIB_OSDIRNAMES/s:=.*:= ${libdirs}:" ) + fi + else + einfo "using upstream multilib; disabling lib32 autodetection" + sed_args+=( -r -e 's:[$][(]if.*,(.*)[)]:\1:' ) + fi + sed -i "${sed_args[@]}" "${S}"/gcc/config/${config} || die +} + +# make sure the libtool archives have libdir set to where they actually +# -are-, and not where they -used- to be. also, any dependencies we have +# on our own .la files need to be updated. +fix_libtool_libdir_paths() { + pushd "${ED}" >/dev/null + + pushd "./${1}" >/dev/null + local dir="${PWD#${D%/}}" + local allarchives=$(echo *.la) + allarchives="\(${allarchives// /\\|}\)" + popd >/dev/null + + sed -i \ + -e "/^libdir=/s:=.*:='${EPREFIX}/${dir##/}':" \ + ./${dir}/*.la + sed -i \ + -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${EPREFIX}/${LIBPATH##/}/\1:g" \ + $(find ./${PREFIX}/lib* -maxdepth 3 -name '*.la') \ + ./${dir}/*.la + + popd >/dev/null +} + +is_multilib() { + tc_version_is_at_least 3 || return 1 + use multilib +} + +is_cxx() { + gcc-lang-supported 'c++' || return 1 + use cxx +} + +is_d() { + gcc-lang-supported d || return 1 + use_if_iuse d +} + +is_f77() { + gcc-lang-supported f77 || return 1 + use fortran +} + +is_f95() { + gcc-lang-supported f95 || return 1 + use fortran +} + +is_fortran() { + gcc-lang-supported fortran || return 1 + use fortran +} + +is_gcj() { + gcc-lang-supported java || return 1 + use cxx && use_if_iuse gcj +} + +is_go() { + gcc-lang-supported go || return 1 + use cxx && use_if_iuse go +} + +is_objc() { + gcc-lang-supported objc || return 1 + use_if_iuse objc +} + +is_objcxx() { + gcc-lang-supported 'obj-c++' || return 1 + use cxx && use_if_iuse objc++ +} + +is_ada() { + gcc-lang-supported ada || return 1 + use ada +} + +is_treelang() { + use_if_iuse boundschecking && return 1 #260532 + is_crosscompile && return 1 #199924 + gcc-lang-supported treelang || return 1 + #use treelang + return 0 +} diff --git a/eclass/wxwidgets.eclass b/eclass/wxwidgets.eclass new file mode 100644 index 0000000..16a0cc5 --- /dev/null +++ b/eclass/wxwidgets.eclass @@ -0,0 +1,285 @@ +# Copyright 1999-2011 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/eclass/wxwidgets.eclass,v 1.34 2013/08/16 07:59:17 heroxbd Exp $ + +# @ECLASS: wxwidgets.eclass +# @MAINTAINER: +# wxwidgets@gentoo.org +# @BLURB: Manages build configuration for wxGTK-using packages. +# @DESCRIPTION: +# The wxGTK libraries come in several different possible configurations +# (release, debug, ansi, unicode, etc.) most of which can be installed +# side-by-side. The purpose of this eclass is to provide ebuilds the ability +# to build against a specific type of profile without interfering with the +# user-set system configuration. +# +# Ebuilds that use wxGTK _must_ inherit this eclass. +# +# - Using this eclass - +# +# 1. set WX_GTK_VER to a valid wxGTK SLOT +# 2. inherit wxwidgets +# 3. add an appropriate DEPEND +# 4. done +# +# @CODE +# WX_GTK_VER="2.8" +# +# inherit wxwidgets +# +# DEPEND="x11-libs/wxGTK:2.8[X]" +# RDEPEND="${DEPEND}" +# [...] +# @CODE +# +# This will get you the default configuration, which is what you want 99% +# of the time (in 2.6 the default is "ansi", all other versions default to +# "unicode"). +# +# If your package has optional wxGTK support controlled by a USE flag or you +# need to use the wxBase libraries (USE="-X") then you should not set +# WX_GTK_VER before inherit and instead refer to the need-wxwidgets function +# below. +# +# The variable WX_CONFIG is exported, containing the absolute path to the +# wx-config file to use. Most configure scripts use this path if it's set in +# the environment or accept --with-wx-config="${WX_CONFIG}". + +inherit eutils multilib + +case "${EAPI:-0}" in + 0|1) + EXPORT_FUNCTIONS pkg_setup + ;; + *) + ;; +esac + +# We do this globally so ebuilds can get sane defaults just by inheriting. They +# can be overridden with need-wxwidgets later if need be. + +# ensure this only runs once +if [[ -z ${WX_CONFIG} ]]; then + # and only if WX_GTK_VER is set before inherit + if [[ -n ${WX_GTK_VER} ]]; then + if [[ ${WX_GTK_VER} == 2.6 ]]; then + wxchar="ansi" + else + wxchar="unicode" + fi + for wxtoolkit in gtk2 base; do + # newer versions don't have a seperate debug profile + for wxdebug in xxx release- debug-; do + wxconf="${wxtoolkit}-${wxchar}-${wxdebug/xxx/}${WX_GTK_VER}" + if [[ -f ${EPREFIX}/usr/$(get_libdir)/wx/config/${wxconf} ]]; then + # if this is a wxBase install, die in pkg_setup + [[ ${wxtoolkit} == "base" ]] && WXBASE_DIE=1 + else + continue + fi + WX_CONFIG="${EPREFIX}/usr/$(get_libdir)/wx/config/${wxconf}" + WX_ECLASS_CONFIG="${WX_CONFIG}" + break + done + [[ -n ${WX_CONFIG} ]] && break + done + [[ -n ${WX_CONFIG} ]] && export WX_CONFIG WX_ECLASS_CONFIG + fi +fi + +# @FUNCTION: wxwidgets_pkg_setup +# @DESCRIPTION: +# +# It's possible for wxGTK to be installed with USE="-X", resulting in something +# called wxBase. There's only ever been a couple packages in the tree that use +# wxBase so this is probably not what you want. Whenever possible, use EAPI 2 +# USE dependencies(tm) to ensure that wxGTK was built with USE="X". This +# function is only exported for EAPI 0 or 1 and catches any remaining cases. +# +# If you do use wxBase, don't set WX_GTK_VER before inherit. Use +# need-wxwidgets() instead. + +wxwidgets_pkg_setup() { + [[ -n $WXBASE_DIE ]] && check_wxuse X +} + +# @FUNCTION: need-wxwidgets +# @USAGE: <configuration> +# @DESCRIPTION: +# +# Available configurations are: +# +# [2.6] ansi [>=2.8] unicode +# unicode base-unicode +# base +# base-unicode +# +# If your package has optional wxGTK support controlled by a USE flag, set +# WX_GTK_VER inside a conditional rather than before inherit. Some broken +# configure scripts will force wxGTK on if they find ${WX_CONFIG} set. +# +# @CODE +# src_configure() { +# if use wxwidgets; then +# WX_GTK_VER="2.8" +# if use X; then +# need-wxwidgets unicode +# else +# need-wxwidgets base-unicode +# fi +# fi +# @CODE +# + +need-wxwidgets() { + debug-print-function $FUNCNAME $* + + local wxtoolkit wxchar wxdebug wxconf + + if [[ -z ${WX_GTK_VER} ]]; then + echo + eerror "WX_GTK_VER must be set before calling $FUNCNAME." + echo + die "WX_GTK_VER missing" + fi + + if [[ ${WX_GTK_VER} != 2.6 && ${WX_GTK_VER} != 2.8 && ${WX_GTK_VER} != 2.9 ]]; then + echo + eerror "Invalid WX_GTK_VER: ${WX_GTK_VER} - must be set to a valid wxGTK SLOT." + echo + die "Invalid WX_GTK_VER" + fi + + debug-print "WX_GTK_VER is ${WX_GTK_VER}" + + case $1 in + ansi) + debug-print-section ansi + if [[ ${WX_GTK_VER} == 2.6 ]]; then + wxchar="ansi" + else + wxchar="unicode" + fi + check_wxuse X + ;; + unicode) + debug-print-section unicode + check_wxuse X + [[ ${WX_GTK_VER} == 2.6 ]] && check_wxuse unicode + wxchar="unicode" + ;; + base) + debug-print-section base + if [[ ${WX_GTK_VER} == 2.6 ]]; then + wxchar="ansi" + else + wxchar="unicode" + fi + ;; + base-unicode) + debug-print-section base-unicode + [[ ${WX_GTK_VER} == 2.6 ]] && check_wxuse unicode + wxchar="unicode" + ;; + # backwards compatibility + gtk2) + debug-print-section gtk2 + if [[ ${WX_GTK_VER} == 2.6 ]]; then + wxchar="ansi" + else + wxchar="unicode" + fi + check_wxuse X + ;; + *) + echo + eerror "Invalid $FUNCNAME argument: $1" + echo + die "Invalid argument" + ;; + esac + + debug-print "wxchar is ${wxchar}" + + # TODO: remove built_with_use + + # wxBase can be provided by both gtk2 and base installations + if built_with_use =x11-libs/wxGTK-${WX_GTK_VER}* X; then + wxtoolkit="gtk2" + else + wxtoolkit="base" + fi + + debug-print "wxtoolkit is ${wxtoolkit}" + + # debug or release? + if [[ ${WX_GTK_VER} == 2.6 || ${WX_GTK_VER} == 2.8 ]]; then + if built_with_use =x11-libs/wxGTK-${WX_GTK_VER}* debug; then + wxdebug="debug-" + else + wxdebug="release-" + fi + fi + + debug-print "wxdebug is ${wxdebug}" + + # put it all together + wxconf="${wxtoolkit}-${wxchar}-${wxdebug}${WX_GTK_VER}" + + debug-print "wxconf is ${wxconf}" + + # if this doesn't work, something is seriously screwed + if [[ ! -f ${EPREFIX}/usr/$(get_libdir)/wx/config/${wxconf} ]]; then + echo + eerror "Failed to find configuration ${wxconf}" + echo + die "Missing wx-config" + fi + + debug-print "Found config ${wxconf} - setting WX_CONFIG" + + export WX_CONFIG="${EPREFIX}/usr/$(get_libdir)/wx/config/${wxconf}" + + debug-print "WX_CONFIG is ${WX_CONFIG}" + + export WX_ECLASS_CONFIG="${WX_CONFIG}" + + echo + einfo "Requested wxWidgets: ${1} ${WX_GTK_VER}" + einfo "Using wxWidgets: ${wxconf}" + echo +} + + +# @FUNCTION: check_wxuse +# @USAGE: <USE flag> +# @DESCRIPTION: +# +# Provides a consistant way to check if wxGTK was built with a particular USE +# flag enabled. A better way is EAPI 2 USE dependencies (hint hint). + +check_wxuse() { + debug-print-function $FUNCNAME $* + + if [[ -z ${WX_GTK_VER} ]]; then + echo + eerror "WX_GTK_VER must be set before calling $FUNCNAME." + echo + die "WX_GTK_VER missing" + fi + + # TODO: Remove built_with_use + + ebegin "Checking wxGTK-${WX_GTK_VER} for ${1} support" + if built_with_use =x11-libs/wxGTK-${WX_GTK_VER}* "${1}"; then + eend 0 + else + eend 1 + echo + eerror "${FUNCNAME} - You have requested functionality that requires ${1} support to" + eerror "have been built into x11-libs/wxGTK." + eerror + eerror "Please re-merge =x11-libs/wxGTK-${WX_GTK_VER}* with the ${1} USE flag enabled." + die "Missing USE flags." + fi +} |