Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 445698 Details for
Bug 592060
Add Ada to toolchain.eclass
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
[patch]
Add Ada to toolchain.eclass v9
toolchain.eclass (text/plain), 75.74 KB, created by
Luke A. Guest
on 2016-09-14 16:46:26 UTC
(
hide
)
Description:
Add Ada to toolchain.eclass v9
Filename:
MIME Type:
Creator:
Luke A. Guest
Created:
2016-09-14 16:46:26 UTC
Size:
75.74 KB
patch
obsolete
># Copyright 1999-2016 Gentoo Foundation ># Distributed under the terms of the GNU General Public License v2 ># $Id$ > ># Maintainer: Toolchain Ninjas <toolchain@gentoo.org> > >DESCRIPTION="The GNU Compiler Collection" >HOMEPAGE="https://gcc.gnu.org/" >RESTRICT="strip" # cross-compilers need controlled stripping > >inherit eutils fixheadtails flag-o-matic gnuconfig libtool multilib pax-utils toolchain-funcs versionator > >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/} > >EXPORTED_FUNCTIONS="pkg_setup src_unpack src_compile src_test src_install pkg_postinst pkg_postrm" >case ${EAPI:-0} in > 0|1) die "Need to upgrade to at least EAPI=2";; > 2|3) EXPORTED_FUNCTIONS+=" src_prepare src_configure" ;; > 4*|5*) EXPORTED_FUNCTIONS+=" pkg_pretend src_prepare src_configure" ;; > *) die "I don't speak EAPI ${EAPI}." >esac >EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS} > >#---->> globals <<---- > >export CTARGET=${CTARGET:-${CHOST}} >if [[ ${CTARGET} = ${CHOST} ]] ; then > if [[ ${CATEGORY} == cross-* ]] ; 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) >tc_version_is_at_least() { > version_is_at_least "$1" "${2:-${GCC_RELEASE_VER}}" >} > ># General purpose version range check ># Note that it matches up to but NOT including the second version >tc_version_is_between() { > tc_version_is_at_least "${1}" && ! tc_version_is_at_least "${2}" >} > >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} == *_pre* ]] ; then > PRERELEASE=${GCC_PV/_pre/-} >elif [[ ${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 > >if [[ ${SNAPSHOT} == [56789].0-* ]] ; then > # The gcc-5+ releases have dropped the .0 for some reason. > SNAPSHOT=${SNAPSHOT/.0} >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}} > HOSTLIBPATH=${PREFIX}/${CHOST}/${CTARGET}/lib/${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/\.*/}} > >#---->> LICENSE+SLOT+IUSE logic <<---- > >if tc_version_is_at_least 4.6 ; then > LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.3+" >elif tc_version_is_at_least 4.4 ; then > LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.2+" >elif tc_version_is_at_least 4.3 ; then > LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+" >elif tc_version_is_at_least 4.2 ; then > LICENSE="GPL-3+ LGPL-2.1+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+" >elif tc_version_is_at_least 3.3 ; then > LICENSE="GPL-2+ LGPL-2.1+ FDL-1.2+" >else > LICENSE="GPL-2+ LGPL-2.1+ FDL-1.1+" >fi > >IUSE="regression-test vanilla" >IUSE_DEF=( nls nptl ) > >if [[ ${PN} != "kgcc64" && ${PN} != gcc-* ]] ; then > IUSE+=" altivec debug" > IUSE_DEF+=( 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 awt hardened multilib objc" > tc_version_is_at_least 4.0 && IUSE+=" objc-gc" > tc_version_is_between 4.0 4.9 && IUSE+=" mudflap" > tc_version_is_at_least 4.1 && IUSE+=" libssp objc++" > tc_version_is_at_least 4.2 && IUSE_DEF+=( openmp ) > tc_version_is_at_least 4.3 && IUSE+=" fixed-point" > tc_version_is_at_least 4.7 && IUSE+=" go" > # Note: while <=gcc-4.7 also supported graphite, it required forked ppl > # versions which we dropped. Since graphite was also experimental in > # the older versions, we don't want to bother supporting it. #448024 > tc_version_is_at_least 4.8 && IUSE+=" graphite" IUSE_DEF+=( sanitize ) > tc_version_is_at_least 4.9 && IUSE+=" ada cilk +vtv" > tc_version_is_at_least 5.0 && IUSE+=" jit mpx" > tc_version_is_at_least 6.0 && IUSE+=" pie ssp +pch" >fi > >IUSE+=" ${IUSE_DEF[*]/#/+}" > >SLOT="${GCC_CONFIG_VER}" > ># When using Ada, use this bootstrap compiler to build, only when there is no pre-existing Ada compiler. >if in_iuse ada; then > # First time build, so need to bootstrap this. > # A newer version of GNAT should build an older version, just not vice-versa. 4.9 can definitely build 5.1.0. > GNAT_BOOTSTRAP_VERSION="4.9" >fi > >#---->> DEPEND <<---- > >RDEPEND="sys-libs/zlib > nls? ( virtual/libintl )" > >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:0 >=dev-libs/mpfr-2.4.2:0" > 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:0" > >if in_iuse graphite ; then > if tc_version_is_at_least 5.0 ; then > RDEPEND+=" graphite? ( >=dev-libs/isl-0.14 )" > elif tc_version_is_at_least 4.8 ; then > RDEPEND+=" > graphite? ( > >=dev-libs/cloog-0.18.0 > >=dev-libs/isl-0.11.1 > )" > fi >fi > >DEPEND="${RDEPEND} > >=sys-devel/bison-1.875 > >=sys-devel/flex-2.5.4 > nls? ( sys-devel/gettext ) > 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 > " > 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? ( awt? ( ${GCJ_GTK_DEPS} ) ${GCJ_DEPS} )" >fi > >PDEPEND=">=sys-devel/gcc-config-1.7" > >#---->> 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 >) > >gentoo_urls() { > local devspace="HTTP~vapier/dist/URI HTTP~rhill/dist/URI > HTTP~zorry/patches/gcc/URI HTTP~blueness/dist/URI" > devspace=${devspace//HTTP/https:\/\/dev.gentoo.org\/} > echo mirror://gentoo/$1 ${devspace//URI/$1} >} > ># 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. >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 [[ ${PV} == *9999* ]] ; then > # Nothing to do w/git snapshots. > : > elif [[ -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" > else > 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 > > if in_iuse ada; then > GCC_SRC_URI+=" amd64? ( https://dev.gentoo.org/~nerdboy/files/gnatboot-${GNAT_BOOTSTRAP_VERSION}-amd64.tar.xz ) > x86? ( https://dev.gentoo.org/~nerdboy/files/gnatboot-${GNAT_BOOTSTRAP_VERSION}-i686.tar.xz ) > arm? ( https://dev.gentoo.org/~nerdboy/files/gnatboot-${GNAT_BOOTSTRAP_VERSION}-arm.tar.xz )" > fi > > echo "${GCC_SRC_URI}" >} > >SRC_URI=$(get_gcc_src_uri) > >#---->> pkg_pretend <<---- > >toolchain_pkg_pretend() { > 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 > > [[ -z ${UCLIBC_VER} ]] && [[ ${CTARGET} == *-uclibc* ]] && \ > die "Sorry, this version does not support uClibc" > > 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 >} > >#---->> pkg_setup <<---- > >toolchain_pkg_setup() { > case ${EAPI} in > 2|3) toolchain_pkg_pretend ;; > esac > > # we dont want to use the installed compiler's specs to build gcc > unset GCC_SPECS > unset LANGUAGES #265283 >} > >#---->> src_unpack <<---- > >toolchain_src_unpack() { > if [[ ${PV} == *9999* ]]; then > git-2_src_unpack > else > gcc_quick_unpack > fi > > # Unpack the Ada bootstrap if we're using it. > if in_iuse ada && ! type -P gnatbind > /dev/null; then > mkdir -p "${WORKDIR}/gnat_bootstrap" || die "Couldn't make GNAT bootstrap directory" > pushd "${WORKDIR}/gnat_bootstrap" > /dev/null || die > > case $(tc-arch) in > amd64) > unpack gnatboot-${GNAT_BOOTSTRAP_VERSION}-amd64.tar.xz || die "Failed to unpack AMD64 GNAT bootstrap compiler" > ;; > x86) > unpack gnatboot-${GNAT_BOOTSTRAP_VERSION}-i686.tar.xz || die "Failed to unpack x86 GNAT bootstrap compiler" > ;; > arm) > unpack gnatboot-${GNAT_BOOTSTRAP_VERSION}-arm.tar.xz || die "Failed to unpack ARM GNAT bootstrap compiler" > ;; > esac > > popd > /dev/null || die > fi >} > >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 >} > >#---->> src_prepare <<---- > >toolchain_src_prepare() { > 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 > > if ( tc_version_is_at_least 4.8.2 || use hardened ) && ! use vanilla ; then > make_gcc_hard > fi > > # install the libstdc++ python into the right location > # http://gcc.gnu.org/PR51368 > if tc_version_is_between 4.5 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/PR14992 > 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_between 3.3 4.0 ; then > do_gcc_rename_java_bins > fi > > # Prevent libffi from being installed > if tc_version_is_between 3.0 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" > 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 > > # Prevent new texinfo from breaking old versions (see #198182, #464008) > tc_version_is_at_least 4.1 && epatch "${GCC_FILESDIR}"/gcc-configure-texinfo.patch > > if [[ -x contrib/gcc_update ]] ; then > einfo "Touching generated files" > ./contrib/gcc_update --touch | \ > while read f ; do > einfo " ${f%%...}" > done > fi >} > >guess_patch_type_in_dir() { > [[ -n $(ls "$1"/*.bz2 2>/dev/null) ]] \ > && EPATCH_SUFFIX="patch.bz2" \ > || EPATCH_SUFFIX="patch" >} > >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_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 > > BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, pie-${PIE_VER}" >} > ># configure to build with the hardened GCC specs as the default >make_gcc_hard() { > > local gcc_hard_flags="" > # Gcc >= 6.X we can use configurations options to turn pie/ssp on as default > if tc_version_is_at_least 6.0 ; then > if use pie ; then > einfo "Updating gcc to use automatic PIE building ..." > fi > if use ssp ; then > einfo "Updating gcc to use automatic SSP building ..." > fi > if use hardened ; then > # Will add some optimatizion as default. > gcc_hard_flags+=" -DEXTRA_OPTIONS" > # rebrand to make bug reports easier > BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened} > fi > else > if use hardened ; then > # rebrand to make bug reports easier > BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened} > 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 isn't supported, but don't die either > ewarn "hardened is not supported for this arch in this gcc version" > return 0 > fi > else > if hardened_gcc_works ssp ; then > einfo "Updating gcc to use automatic SSP building ..." > gcc_hard_flags+=" -DEFAULT_SSP" > fi > fi > 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 > > sed -i \ > -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \ > "${S}"/gcc/Makefile.in || 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 >} > >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 >} > >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 >} > >#---->> src_configure <<---- > >toolchain_src_configure() { > downgrade_arch_flags > gcc_do_filter_flags > > einfo "CFLAGS=\"${CFLAGS}\"" > einfo "CXXFLAGS=\"${CXXFLAGS}\"" > einfo "LDFLAGS=\"${LDFLAGS}\"" > > # 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 > > local 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} ) > > # Add variables we need to make the build find the bootstrap compiler. > # We only want to use the bootstrap compiler for stage 1 of bootstrap, this will build the necessary compilers, > # then stage 2 uses these compilers. > # > # We only want to use the bootstrap when we don't have an already installed GNAT compiler. > if in_iuse ada && [[ -d ${WORKDIR}/gnat_bootstrap ]] ; then > # We need to tell the system about our cross compiler! > export GNATBOOT="${WORKDIR}/gnat_bootstrap/usr" > export PATH="${GNATBOOT}/bin:${PATH}" > > confgcc+=( > CC=${GNATBOOT}/bin/gnatgcc > CXX=${GNATBOOT}/bin/gnatg++ > AR=${GNATBOOT}/bin/ar > AS=${GNATBOOT}/bin/as > LD=${GNATBOOT}/bin/ld > NM=${GNATBOOT}/bin/nm > RANLIB=${GNATBOOT}/bin/ranlib > ) > fi > > confgcc+=( > --prefix="${PREFIX}" > --bindir="${BINPATH}" > --includedir="${INCLUDEPATH}" > --datadir="${DATAPATH}" > --mandir="${DATAPATH}/man" > --infodir="${DATAPATH}/info" > --with-gxx-include-dir="${STDCXX_INCDIR}" > ) > > # 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 > > ### language options > > local GCC_LANG="c" > is_cxx && GCC_LANG+=",c++" > is_d && GCC_LANG+=",d" > is_gcj && GCC_LANG+=",java" > is_go && GCC_LANG+=",go" > is_jit && GCC_LANG+=",jit" > 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 > > # 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 want 'Ada support' in here! > is_ada && GCC_LANG+=",ada" > > confgcc+=( --enable-languages=${GCC_LANG} ) > > ### general options > > confgcc+=( > --enable-obsolete > --enable-secureplt > --disable-werror > --with-system-zlib > ) > > if use nls ; then > confgcc+=( --enable-nls --without-included-gettext ) > else > confgcc+=( --disable-nls ) > fi > > tc_version_is_at_least 3.4 || confgcc+=( --disable-libunwind-exceptions ) > > # Use the default ("release") checking because upstream usually neglects > # to test "disabled" so it has a history of breaking. #317217 > if tc_version_is_at_least 3.4 ; then > # The "release" keyword is new to 4.0. #551636 > local off=$(tc_version_is_at_least 4.0 && echo release || echo no) > confgcc+=( --enable-checking="${GCC_CHECKS_LIST:-$(usex debug yes ${off})}" ) > fi > > # Branding > tc_version_is_at_least 4.3 && confgcc+=( > --with-bugurl=https://bugs.gentoo.org/ > --with-pkgversion="${BRANDING_GCC_PKGVERSION}" > ) > > # 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 > > # 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 > > # Support to disable pch when building libstdcxx > if tc_version_is_at_least 6.0 && ! use pch ; then > confgcc+=( --disable-libstdcxx-pch ) > fi > > # The jit language requires this. > is_jit && confgcc+=( --enable-host-shared ) > > # # Turn on the -Wl,--build-id flag by default for ELF targets. #525942 > # # This helps with locating debug files. > # case ${CTARGET} in > # *-linux-*|*-elf|*-eabi) > # tc_version_is_at_least 4.5 && confgcc+=( > # --enable-linker-build-id > # ) > # ;; > # esac > > # newer gcc versions like to bootstrap themselves with C++, > # so we need to manually disable it ourselves > if tc_version_is_between 4.7 4.8 && ! is_cxx ; then > confgcc+=( --disable-build-with-cxx --disable-build-poststage1-with-cxx ) > fi > > ### Cross-compiler options > if is_crosscompile ; then > # Enable build warnings by default with cross-compilers when system > # paths are included (e.g. via -I flags). > confgcc+=( --enable-poison-system-directories ) > > # 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 );; > 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=${PREFIX}/${CTARGET} > ) > else > confgcc+=( --with-sysroot=${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 > 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) > ) > tc_version_is_between 3.3 3.4 && confgcc+=( --enable-sjlj-exceptions ) > if tc_version_is_between 3.4 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 > > ### arch options > > gcc-multilib-configure > > # 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) ) > > 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. > case ${CTARGET//_/-} in > *-hardfloat-*|*eabihf) confgcc+=( --with-float=hard ) ;; > esac > esac > > 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.8 && 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 > > # 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 > 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 > > # 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 ) > > ### library options > > if ! is_gcj ; then > confgcc+=( --disable-libgcj ) > elif use awt ; then > confgcc+=( --enable-java-awt=gtk ) > 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 > > 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 > if hardened_gcc_is_stable ssp; then > export gcc_cv_libc_provides_ssp=yes > fi > confgcc+=( --disable-libssp ) > fi > fi > > if in_iuse cilk ; then > confgcc+=( $(use_enable cilk libcilkrts) ) > fi > > if in_iuse mpx ; then > confgcc+=( $(use_enable mpx libmpx) ) > fi > > if in_iuse vtv ; then > confgcc+=( > $(use_enable vtv vtable-verify) > $(use_enable vtv libvtv) > ) > 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 > > if tc_version_is_at_least 4.6 ; then > confgcc+=( --enable-lto ) > elif tc_version_is_at_least 4.5 ; then > confgcc+=( --disable-lto ) > fi > > # graphite was added in 4.4 but we only support it in 4.8+ due to external > # library issues. #448024 > if tc_version_is_at_least 5.0 ; then > confgcc+=( $(use_with graphite isl) ) > use graphite && confgcc+=( --disable-isl-version-check ) > elif 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.4 ; then > confgcc+=( --without-{cloog,ppl} ) > fi > > if tc_version_is_at_least 4.8 ; then > confgcc+=( $(use_enable sanitize libsanitizer) ) > fi > > if tc_version_is_at_least 6.0 ; then > confgcc+=( > $(use_enable pie default-pie) > # This defaults to -fstack-protector-strong. > $(use_enable ssp default-ssp) > ) > fi > > # 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=' > > confgcc+=( "$@" ${EXTRA_ECONF} ) > > # Nothing wrong with a good dose of verbosity > echo > einfo "PREFIX: ${PREFIX}" > einfo "BINPATH: ${BINPATH}" > einfo "LIBPATH: ${LIBPATH}" > einfo "DATAPATH: ${DATAPATH}" > einfo "STDCXX_INCDIR: ${STDCXX_INCDIR}" > echo > einfo "Languages: ${GCC_LANG}" > 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[@]}" > # Older gcc versions did not detect bash and re-exec itself, so force the > # use of bash. Newer ones will auto-detect, but this is not harmeful. > CONFIG_SHELL="/bin/bash" \ > bash "${S}"/configure "${confgcc[@]}" || die "failed to run configure" > > # return to whatever directory we were in before > popd > /dev/null >} > ># Replace -m flags unsupported by the version being built with the best ># available equivalent >downgrade_arch_flags() { > local arch bver i isa myarch mytune rep ver > > bver=${1:-${GCC_BRANCH_VER}} > [[ $(gcc-version) < ${bver} ]] && return 0 > [[ $(tc-arch) != amd64 && $(tc-arch) != x86 ]] && return 0 > > myarch=$(get-flag march) > mytune=$(get-flag mtune) > > # If -march=native isn't supported we have to tease out the actual arch > if [[ ${myarch} == native || ${mytune} == native ]] ; then > if [[ ${bver} < 4.2 ]] ; then > arch=$($(tc-getCC) -march=native -v -E -P - </dev/null 2>&1 \ > | sed -rn "/cc1.*-march/s:.*-march=([^ ']*).*:\1:p") > replace-cpu-flags native ${arch} > fi > fi > > # Handle special -mtune flags > [[ ${mytune} == intel && ${bver} < 4.9 ]] && replace-cpu-flags intel generic > [[ ${mytune} == generic && ${bver} < 4.2 ]] && filter-flags '-mtune=*' > [[ ${mytune} == x86-64 ]] && filter-flags '-mtune=*' > [[ ${bver} < 3.4 ]] && filter-flags '-mtune=*' > > # "added" "arch" "replacement" > local archlist=( > 4.9 bdver4 bdver3 > 4.9 bonnell atom > 4.9 broadwell core-avx2 > 4.9 haswell core-avx2 > 4.9 ivybridge core-avx-i > 4.9 nehalem corei7 > 4.9 sandybridge corei7-avx > 4.9 silvermont corei7 > 4.9 westmere corei7 > 4.8 bdver3 bdver2 > 4.8 btver2 btver1 > 4.7 bdver2 bdver1 > 4.7 core-avx2 core-avx-i > 4.6 bdver1 amdfam10 > 4.6 btver1 amdfam10 > 4.6 core-avx-i core2 > 4.6 corei7 core2 > 4.6 corei7-avx core2 > 4.5 atom core2 > 4.3 amdfam10 k8 > 4.3 athlon64-sse3 k8 > 4.3 barcelona k8 > 4.3 core2 nocona > 4.3 geode k6-2 # gcc.gnu.org/PR41989#c22 > 4.3 k8-sse3 k8 > 4.3 opteron-sse3 k8 > 3.4 athlon-fx x86-64 > 3.4 athlon64 x86-64 > 3.4 c3-2 c3 > 3.4 k8 x86-64 > 3.4 opteron x86-64 > 3.4 pentium-m pentium3 > 3.4 pentium3m pentium3 > 3.4 pentium4m pentium4 > ) > > for ((i = 0; i < ${#archlist[@]}; i += 3)) ; do > myarch=$(get-flag march) > mytune=$(get-flag mtune) > > ver=${archlist[i]} > arch=${archlist[i + 1]} > rep=${archlist[i + 2]} > > [[ ${myarch} != ${arch} && ${mytune} != ${arch} ]] && continue > > if [[ ${ver} > ${bver} ]] ; then > einfo "Replacing ${myarch} (added in gcc ${ver}) with ${rep}..." > [[ ${myarch} == ${arch} ]] && replace-cpu-flags ${myarch} ${rep} > [[ ${mytune} == ${arch} ]] && replace-cpu-flags ${mytune} ${rep} > continue > else > break > fi > done > > # we only check -mno* here since -m* get removed by strip-flags later on > local isalist=( > 4.9 -mno-sha > 4.9 -mno-avx512pf > 4.9 -mno-avx512f > 4.9 -mno-avx512er > 4.9 -mno-avx512cd > 4.8 -mno-xsaveopt > 4.8 -mno-xsave > 4.8 -mno-rtm > 4.8 -mno-fxsr > 4.7 -mno-lzcnt > 4.7 -mno-bmi2 > 4.7 -mno-avx2 > 4.6 -mno-tbm > 4.6 -mno-rdrnd > 4.6 -mno-fsgsbase > 4.6 -mno-f16c > 4.6 -mno-bmi > 4.5 -mno-xop > 4.5 -mno-movbe > 4.5 -mno-lwp > 4.5 -mno-fma4 > 4.4 -mno-pclmul > 4.4 -mno-fma > 4.4 -mno-avx > 4.4 -mno-aes > 4.3 -mno-ssse3 > 4.3 -mno-sse4a > 4.3 -mno-sse4 > 4.3 -mno-sse4.2 > 4.3 -mno-sse4.1 > 4.3 -mno-popcnt > 4.3 -mno-abm > ) > > for ((i = 0; i < ${#isalist[@]}; i += 2)) ; do > ver=${isalist[i]} > isa=${isalist[i + 1]} > [[ ${ver} > ${bver} ]] && filter-flags ${isa} ${isa/-m/-mno-} > done >} > >gcc_do_filter_flags() { > strip-flags > replace-flags -O? -O2 > > # dont want to funk ourselves > filter-flags '-mabi*' -m31 -m32 -m64 > > filter-flags -frecord-gcc-switches # 490738 > filter-flags -mno-rtm -mno-htm # 506202 > > if tc_version_is_between 3.2 3.4 ; then > # XXX: this is so outdated it's barely useful, but it don't hurt... > 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 > fi > > if tc_version_is_at_least 3.4 ; then > case $(tc-arch) in > amd64|x86) > filter-flags '-mcpu=*' > > tc_version_is_between 4.4 4.5 && append-flags -mno-avx # 357287 > > if tc_version_is_between 4.6 4.7 ; then > # https://bugs.gentoo.org/411333 > # https://bugs.gentoo.org/466454 > replace-cpu-flags c3-2 pentium2 pentium3 pentium3m pentium-m i686 > fi > ;; > alpha) > # https://bugs.gentoo.org/454426 > append-ldflags -Wl,--no-relax > ;; > sparc) > # temporary workaround for random ICEs reproduced by multiple users > # https://bugs.gentoo.org/457062 > tc_version_is_between 4.6 4.8 && MAKEOPTS+=" -j1" > ;; > *-macos) > # http://gcc.gnu.org/PR25127 > tc_version_is_between 4.0 4.2 && \ > filter-flags '-mcpu=*' '-march=*' '-mtune=*' > ;; > esac > fi > > strip-unsupported-flags > > # these are set here so we have something sane at configure time > 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}} >} > >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 >} > >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.8 && 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 >} > >#----> src_compile <---- > >toolchain_src_compile() { > touch "${S}"/gcc/c-gperf.h > > # Do not make manpages if we do not have perl ... > [[ ! -x /usr/bin/perl ]] \ > && find "${WORKDIR}"/build -name '*.[17]' -exec touch {} + > > gcc_do_make ${GCC_MAKE_TARGET} >} > >gcc_do_make() { > # This function accepts one optional argument, the make target to be used. > # If omitted, gcc_do_make will try to guess whether it should use all, > # or bootstrap-lean depending on CTARGET and arch. > # An example of how to use this function: > # > # gcc_do_make all-target-libstdc++-v3 > > [[ -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 > > # Older versions of GCC could not do profiledbootstrap in parallel due to > # collisions with profiling info. > # boundschecking also seems to introduce parallel build issues. > if [[ ${GCC_MAKE_TARGET} == "profiledbootstrap" ]] || use_if_iuse boundschecking ; then > ! tc_version_is_at_least 4.6 && 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 > > einfo "Compiling ${PN} (${GCC_MAKE_TARGET})..." > > pushd "${WORKDIR}"/build >/dev/null > > emake \ > LDFLAGS="${LDFLAGS}" \ > STAGE1_CFLAGS="${STAGE1_CFLAGS}" \ > LIBPATH="${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 > # Clean bogus manpages. #113902 > find -name '*_build_*' -delete > # Blow away generated directory references. Newer versions of gcc > # have gotten better at this, but not perfect. This is easier than > # backporting all of the various doxygen patches. #486754 > find -name '*_.3' -exec grep -l ' Directory Reference ' {} + | \ > xargs rm -f > else > ewarn "Skipping libstdc++ manpage generation since you don't have doxygen installed" > fi > fi > > popd >/dev/null >} > >#---->> src_test <<---- > >toolchain_src_test() { > if use regression-test ; then > cd "${WORKDIR}"/build > emake -k check > fi >} > >#---->> src_install <<---- > >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 > > # We remove the generated fixincludes, as they can cause things to break > # (ncurses, openssl, etc). We do not prevent them from being built, as > # in the following commit which we revert: > # https://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/eclass/toolchain.eclass?r1=1.647&r2=1.648 > # This is because bsd userland needs fixedincludes to build gcc, while > # linux does not. Both can dispose of them afterwards. > 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 "${D}" -name install-tools -prune -type d -exec rm -rf "{}" \; > # This one comes with binutils > find "${D}" -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 ${D}${BINPATH}/gcc${EXEEXT} ]] || die "gcc not found in ${D}" > 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 "${D}"${BINPATH} > # Ugh: we really need to auto-detect this list. > # It's constantly out of date. > if in_iuse ada ; then > local gnat_extra_bins="gnat gnatbind gnatchop gnatclean gnatfind gnatkr gnatlink gnatls gnatmake gnatname gnatprep gnatxref" > fi > > 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 > if [[ -f ${x} ]] ; then > # In case they're hardlinks, clear out the target first > # otherwise the mv below will complain. > rm -f ${CTARGET}-${x} > mv ${x} ${CTARGET}-${x} > fi > > 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 > # Rename the main go binaries as we don't want to clobber dev-lang/go > # when gcc-config runs. #567806 > if tc_version_is_at_least 5 && is_go ; then > for x in go gofmt; do > mv ${x} ${x}-${GCCMAJOR} || die > done > fi > > # Now do the fun stripping stuff > env RESTRICT="" CHOST=${CHOST} prepstrip "${D}${BINPATH}" > is_crosscompile && \ > env RESTRICT="" CHOST=${CHOST} prepstrip "${D}/${HOSTLIBPATH}" > env RESTRICT="" CHOST=${CTARGET} prepstrip "${D}${LIBPATH}" > # gcc used to install helper binaries in lib/ but then moved to libexec/ > [[ -d ${D}${PREFIX}/libexec/gcc ]] && \ > env RESTRICT="" CHOST=${CHOST} prepstrip "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}" > > cd "${S}" > if is_crosscompile; then > rm -rf "${D}"/usr/share/{man,info} > rm -rf "${D}"${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 > cp -r "${cxx_mandir}"/man? "${D}/${DATAPATH}"/man/ > fi > fi > has noinfo ${FEATURES} \ > && rm -r "${D}/${DATAPATH}"/info \ > || prepinfo "${DATAPATH}" > has noman ${FEATURES} \ > && rm -r "${D}/${DATAPATH}"/man \ > || prepman "${DATAPATH}" > fi > # prune empty dirs left behind > find "${D}" -depth -type d -delete 2>/dev/null > > # install testsuite results > if use regression-test; then > docinto testsuite > find "${WORKDIR}"/build -type f -name "*.sum" -exec dodoc {} + > find "${WORKDIR}"/build -type f -path "*/testsuite/*.log" -exec dodoc {} + > fi > > # Rather install the script, else portage with changing $FILESDIR > # between binary and source package borks things .... > if ! is_crosscompile ; then > insinto "${DATAPATH}" > newins "${GCC_FILESDIR}"/awk/fixlafiles.awk-no_gcc_la fixlafiles.awk || die > exeinto "${DATAPATH}" > doexe "${GCC_FILESDIR}"/fix_libtool_files.sh || die > doexe "${GCC_FILESDIR}"/c{89,99} || die > fi > > # libstdc++.la: Delete as it doesn't add anything useful: g++ itself > # handles linkage correctly in the dynamic & static case. It also just > # causes us pain: any C++ progs/libs linking with libtool will gain a > # reference to the full libstdc++.la file which is gcc version specific. > # libstdc++fs.la: It doesn't link against anything useful. > # libsupc++.la: This has no dependencies. > # libcc1.la: There is no static library, only dynamic. > # libcc1plugin.la: Same as above, and it's loaded via dlopen. > # libgomp.la: gcc itself handles linkage (libgomp.spec). > # libgomp-plugin-*.la: Same as above, and it's an internal plugin only > # loaded via dlopen. > # libgfortran.la: gfortran itself handles linkage correctly in the > # dynamic & static case (libgfortran.spec). #573302 > # libgfortranbegin.la: Same as above, and it's an internal lib. > # libmpx.la: gcc itself handles linkage correctly (libmpx.spec). > # libmpxwrappers.la: See above. > # libitm.la: gcc itself handles linkage correctly (libitm.spec). > # libvtv.la: gcc itself handles linkage correctly. > # lib*san.la: Sanitizer linkage is handled internally by gcc, and they > # do not support static linking. #487550 #546700 > find "${D}/${LIBPATH}" \ > '(' \ > -name libstdc++.la -o \ > -name libstdc++fs.la -o \ > -name libsupc++.la -o \ > -name libcc1.la -o \ > -name libcc1plugin.la -o \ > -name 'libgomp.la' -o \ > -name 'libgomp-plugin-*.la' -o \ > -name libgfortran.la -o \ > -name libgfortranbegin.la -o \ > -name libmpx.la -o \ > -name libmpxwrappers.la -o \ > -name libitm.la -o \ > -name libvtv.la -o \ > -name 'lib*san.la' \ > ')' -type f -delete > > # 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 root:0 "${D}"${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 "${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 #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 "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1" > pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1plus" > fi >} > ># 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 > > # For non-target libs which are for CHOST and not CTARGET, we want to > # move them to the compiler-specific CHOST internal dir. This is stuff > # that you want to link against when building tools rather than building > # code to run on the target. > if tc_version_is_at_least 5 && is_crosscompile ; then > dodir "${HOSTLIBPATH}" > mv "${D}"/usr/$(get_libdir)/libcc1* "${D}${HOSTLIBPATH}" || die > fi > > # For all the libs that are built for CTARGET, move them into the > # compiler-specific CTARGET internal dir. > 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=${D}${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=${D}${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}" || die > 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 "${D}${FROMDIR}"/pkgconfig/libgcj*.pc ; do > [[ -f ${x} ]] || continue > sed -i "/^libdir=/s:=.*:=${LIBPATH}/${MULTIDIR}:" "${x}" || die > mv "${x}" "${D}${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 "${D}"${FROMDIR} >& /dev/null > done > find -depth "${D}" -type d -exec rmdir {} + >& /dev/null >} > ># 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() { > local libpath="$1" > > pushd "${D}" >/dev/null > > pushd "./${libpath}" >/dev/null > local dir="${PWD#${D%/}}" > local allarchives=$(echo *.la) > allarchives="\(${allarchives// /\\|}\)" > popd >/dev/null > > # The libdir might not have any .la files. #548782 > find "./${dir}" -maxdepth 1 -name '*.la' \ > -exec sed -i -e "/^libdir=/s:=.*:='${dir}':" {} + || die > # Would be nice to combine these, but -maxdepth can not be specified > # on sub-expressions. > find "./${PREFIX}"/lib* -maxdepth 3 -name '*.la' \ > -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die > find "./${dir}/" -maxdepth 1 -name '*.la' \ > -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die > > popd >/dev/null >} > >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="${D}${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="${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=${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=${LIBPATH} > fi > > cat <<-EOF > ${gcc_envd_file} > PATH="${BINPATH}" > ROOTPATH="${BINPATH}" > GCC_PATH="${BINPATH}" > LDPATH="${ldpaths}" > MANPATH="${DATAPATH}/man" > INFOPATH="${DATAPATH}/info" > STDCXX_INCDIR="${STDCXX_INCDIR##*/}" > CTARGET="${CTARGET}" > GCC_SPECS="${gcc_specs_file}" > MULTIOSDIRS="${mosdirs}" > EOF >} > >copy_minispecs_gcc_specs() { > # on gcc 6 we don't need minispecs > if tc_version_is_at_least 6.0 ; then > return 0 > fi > > # 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 >} > >gcc_slot_java() { > local x > > # Move Java headers to compiler-specific dir > for x in "${D}"${PREFIX}/include/gc*.h "${D}"${PREFIX}/include/j*.h ; do > [[ -f ${x} ]] && mv -f "${x}" "${D}"${LIBPATH}/include/ > done > for x in gcj gnu java javax org ; do > if [[ -d ${D}${PREFIX}/include/${x} ]] ; then > dodir /${LIBPATH}/include/${x} > mv -f "${D}"${PREFIX}/include/${x}/* "${D}"${LIBPATH}/include/${x}/ > rm -rf "${D}"${PREFIX}/include/${x} > fi > done > > if [[ -d ${D}${PREFIX}/lib/security ]] || [[ -d ${D}${PREFIX}/$(get_libdir)/security ]] ; then > dodir /${LIBPATH}/security > mv -f "${D}"${PREFIX}/lib*/security/* "${D}"${LIBPATH}/security > rm -rf "${D}"${PREFIX}/lib*/security > fi > > # Move random gcj files to compiler-specific directories > for x in libgcj.spec logging.properties ; do > x="${D}${PREFIX}/lib/${x}" > [[ -f ${x} ]] && mv -f "${x}" "${D}"${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 "${D}"${BINPATH} > [[ -f jar ]] && mv -f jar gcj-jar >} > >#---->> pkg_post* <<---- > >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 "https://wiki.gentoo.org/wiki/Upgrading_GCC" > echo > > # Clean up old paths > rm -f "${ROOT}"/*/rcscripts/awk/fixlafiles.awk "${ROOT}"/sbin/fix_libtool_files.sh > rmdir "${ROOT}"/*/rcscripts{/awk,} 2>/dev/null > > mkdir -p "${ROOT}"/usr/{share/gcc-data,sbin,bin} > cp "${ROOT}/${DATAPATH}"/fixlafiles.awk "${ROOT}"/usr/share/gcc-data/ || die > cp "${ROOT}/${DATAPATH}"/fix_libtool_files.sh "${ROOT}"/usr/sbin/ || die > > # Since these aren't critical files and portage sucks with > # handling of binpkgs, don't require these to be found > cp "${ROOT}/${DATAPATH}"/c{89,99} "${ROOT}"/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 > > if [[ -n ${PRERELEASE}${SNAPSHOT} ]] ; then > einfo "This GCC ebuild is provided for your convenience, and the use" > einfo "of this compiler is not supported by the Gentoo Developers." > einfo "Please report bugs to upstream at http://gcc.gnu.org/bugzilla/" > 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 "${ROOT}"/etc/env.d/gcc/${CTARGET}* 2>/dev/null) ]] ; then > rm -f "${ROOT}"/etc/env.d/gcc/config-${CTARGET} > rm -f "${ROOT}"/etc/env.d/??gcc-${CTARGET} > rm -f "${ROOT}"/usr/bin/${CTARGET}-{gcc,{g,c}++}{,32,64} > fi > return 0 > fi > > # ROOT isnt handled by the script > [[ ${ROOT} != "/" ]] && return 0 > > if [[ ! -e ${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}'" > /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}'" > /usr/sbin/fix_libtool_files.sh ${GCC_RELEASE_VER}-${BRANCH_UPDATE} > fi > fi > > return 0 >} > >do_gcc_config() { > if ! should_we_gcc_config ; then > env -i ROOT="${ROOT}" gcc-config --use-old --force > return 0 > fi > > local current_gcc_config target > > current_gcc_config=$(env -i ROOT="${ROOT}" gcc-config -c ${CTARGET} 2>/dev/null) > if [[ -n ${current_gcc_config} ]] ; then > local current_specs use_specs > # 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} > > if [[ -n ${use_specs} ]] && \ > [[ ! -e ${ROOT}/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 > > target="${CTARGET}-${GCC_CONFIG_VER}${use_specs}" > else > # The curent target is invalid. Attempt to switch to a valid one. > # Blindly pick the latest version. #529608 > # TODO: Should update gcc-config to accept `-l ${CTARGET}` rather than > # doing a partial grep like this. > target=$(gcc-config -l 2>/dev/null | grep " ${CTARGET}-[0-9]" | tail -1 | awk '{print $2}') > fi > > gcc-config "${target}" >} > >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}" 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}" gcc-config -S ${curr_config} | awk '{print $2}') > > local curr_branch_ver=$(get_version_component_range 1-2 ${curr_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 >} > >#---->> support and misc functions <<---- > ># 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} >} > >is_ada() { > gcc-lang-supported ada || return 1 > use ada >} > >is_cxx() { > gcc-lang-supported 'c++' || return 1 > ! is_crosscompile && tc_version_is_at_least 4.8 && return 0 > 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_jit() { > gcc-lang-supported jit || return 1 > use_if_iuse jit >} > >is_multilib() { > tc_version_is_at_least 3 || return 1 > use multilib >} > >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++ >} > ># 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} > elif [[ ${CTARGET} == *-gnu* ]] ; then > 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_minispecs() { > # on gcc 6 we don't need minispecs > if tc_version_is_at_least 6.0 ; then > return 0 > fi > 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 >} > >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 >} > >has toolchain_death_notice ${EBUILD_DEATH_HOOKS} || EBUILD_DEATH_HOOKS+=" toolchain_death_notice" >toolchain_death_notice() { > if [[ -e "${WORKDIR}"/build ]] ; then > pushd "${WORKDIR}"/build >/dev/null > (echo '' | $(tc-getCC ${CTARGET}) ${CFLAGS} -v -E - 2>&1) > gccinfo.log > [[ -e "${T}"/build.log ]] && cp "${T}"/build.log . > tar jcf "${WORKDIR}"/gcc-build-logs.tar.bz2 \ > gccinfo.log build.log $(find -name config.log) > rm gccinfo.log build.log > eerror > eerror "Please include ${WORKDIR}/gcc-build-logs.tar.bz2 in your bug report." > eerror > popd >/dev/null > fi >}
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Diff
Attachments on
bug 592060
:
444064
|
444066
|
444082
|
444146
|
444148
|
444250
|
445698
|
470640
|
471560
|
477544
|
488908
|
489108
|
489110
|
489112
|
489216
|
489690
|
489692
|
489694
|
489696
|
490036