1 # Copyright 1999-2018 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
4 # Maintainer: Toolchain Ninjas <toolchain@gentoo.org>
5 # @SUPPORTED_EAPIS: 5 6
7 DESCRIPTION="The GNU Compiler Collection"
8 HOMEPAGE="https://gcc.gnu.org/"
9 RESTRICT="strip" # cross-compilers need controlled stripping
11 inherit eutils fixheadtails flag-o-matic gnuconfig libtool multilib pax-utils toolchain-funcs prefix
13 if [[ ${PV} == *_pre9999* ]] ; then
14 EGIT_REPO_URI="git://gcc.gnu.org/git/gcc.git"
16 # gcc-4.7.1_pre9999 -> gcc-4_7-branch
17 # Note that the micro version is required or lots of stuff will break.
18 # To checkout master set gcc_LIVE_BRANCH="master" in the ebuild before
19 # inheriting this eclass.
20 EGIT_BRANCH="${PN}-${PV%.?_pre9999}-branch"
21 EGIT_BRANCH=${EGIT_BRANCH//./_}
25 FEATURES=${FEATURES/multilib-strict/}
28 0|1|2|3|4*) die "Need to upgrade to at least EAPI=5" ;;
29 5*|6) inherit eapi7-ver ;;
30 *) die "I don't speak EAPI ${EAPI}." ;;
32 EXPORT_FUNCTIONS pkg_pretend pkg_setup src_unpack src_prepare src_configure \
33 src_compile src_test src_install pkg_postinst pkg_postrm
35 #---->> globals <<----
37 export CTARGET=${CTARGET:-${CHOST}}
38 if [[ ${CTARGET} = ${CHOST} ]] ; then
39 if [[ ${CATEGORY} == cross-* ]] ; then
40 export CTARGET=${CATEGORY#cross-}
43 : ${TARGET_ABI:=${ABI}}
44 : ${TARGET_MULTILIB_ABIS:=${MULTILIB_ABIS}}
45 : ${TARGET_DEFAULT_ABI:=${DEFAULT_ABI}}
48 [[ ${CHOST} != ${CTARGET} ]]
51 # General purpose version check. Without a second arg matches up to minor version (x.x.x)
52 tc_version_is_at_least() {
53 ver_test "${2:-${GCC_RELEASE_VER}}" -ge "$1"
56 # General purpose version range check
57 # Note that it matches up to but NOT including the second version
58 tc_version_is_between() {
59 tc_version_is_at_least "${1}" && ! tc_version_is_at_least "${2}"
62 GCC_PV=${TOOLCHAIN_GCC_PV:-${PV}}
64 [[ ${PR} != "r0" ]] && GCC_PVR=${GCC_PVR}-${PR}
65 GCC_RELEASE_VER=$(ver_cut 1-3 ${GCC_PV})
66 GCC_BRANCH_VER=$(ver_cut 1-2 ${GCC_PV})
67 GCCMAJOR=$(ver_cut 1 ${GCC_PV})
68 GCCMINOR=$(ver_cut 2 ${GCC_PV})
69 GCCMICRO=$(ver_cut 3 ${GCC_PV})
70 [[ ${BRANCH_UPDATE-notset} == "notset" ]] && \
71 BRANCH_UPDATE=$(ver_cut 4 ${GCC_PV})
73 # According to gcc/c-cppbuiltin.c, GCC_CONFIG_VER MUST match this regex.
74 # ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?
75 GCC_CONFIG_VER=${GCC_CONFIG_VER:-$(ver_rs 3 '-' ${GCC_PV})}
78 if [[ ${GCC_PV} == *_pre* ]] ; then
79 PRERELEASE=${GCC_PV/_pre/-}
80 elif [[ ${GCC_PV} == *_alpha* ]] ; then
81 SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_alpha}
82 elif [[ ${GCC_PV} == *_beta* ]] ; then
83 SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_beta}
84 elif [[ ${GCC_PV} == *_rc* ]] ; then
85 SNAPSHOT=${GCC_PV%_rc*}-RC-${GCC_PV##*_rc}
88 if [[ ${SNAPSHOT} == [56789].0-* ]] ; then
89 # The gcc-5+ releases have dropped the .0 for some reason.
90 SNAPSHOT=${SNAPSHOT/.0}
93 PREFIX=${TOOLCHAIN_PREFIX:-${EPREFIX}/usr}
95 if tc_version_is_at_least 3.4.0 ; then
96 LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc/${CTARGET}/${GCC_CONFIG_VER}}
98 LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc-lib/${CTARGET}/${GCC_CONFIG_VER}}
100 INCLUDEPATH=${TOOLCHAIN_INCLUDEPATH:-${LIBPATH}/include}
102 if is_crosscompile ; then
103 BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CHOST}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}}
104 HOSTLIBPATH=${PREFIX}/${CHOST}/${CTARGET}/lib/${GCC_CONFIG_VER}
106 BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}}
109 DATAPATH=${TOOLCHAIN_DATAPATH:-${PREFIX}/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}}
111 # Dont install in /usr/include/g++-v3/, but in gcc internal directory.
112 # We will handle /usr/include/g++-v3/ with gcc-config ...
113 STDCXX_INCDIR=${TOOLCHAIN_STDCXX_INCDIR:-${LIBPATH}/include/g++-v${GCC_BRANCH_VER/\.*/}}
115 #---->> LICENSE+SLOT+IUSE logic <<----
117 if tc_version_is_at_least 4.6 ; then
118 LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.3+"
119 elif tc_version_is_at_least 4.4 ; then
120 LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.2+"
121 elif tc_version_is_at_least 4.3 ; then
122 LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+"
123 elif tc_version_is_at_least 4.2 ; then
124 LICENSE="GPL-3+ LGPL-2.1+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+"
125 elif tc_version_is_at_least 3.3 ; then
126 LICENSE="GPL-2+ LGPL-2.1+ FDL-1.2+"
128 LICENSE="GPL-2+ LGPL-2.1+ FDL-1.1+"
131 if tc_version_is_at_least 8.3; then
132 GCC_EBUILD_TEST_FLAG='test'
134 # Don't force USE regression-test->test change on every
135 # gcc ebuild just yet. Let's do the change when >=gcc-8.3
136 # is commonly used as a main compiler.
137 GCC_EBUILD_TEST_FLAG='regression-test'
139 IUSE="${GCC_EBUILD_TEST_FLAG} vanilla +nls +nptl"
144 has "$1" "${TC_FEATURES[@]}"
147 if [[ ${PN} != "kgcc64" && ${PN} != gcc-* ]] ; then
148 IUSE+=" altivec debug +cxx +fortran" TC_FEATURES+=(fortran)
149 [[ -n ${PIE_VER} ]] && IUSE+=" nopie"
150 [[ -n ${HTB_VER} ]] && IUSE+=" boundschecking"
151 [[ -n ${D_VER} ]] && IUSE+=" d"
152 [[ -n ${SPECS_VER} ]] && IUSE+=" nossp"
153 tc_version_is_at_least 3 && IUSE+=" doc hardened multilib objc"
154 tc_version_is_between 3 7 && IUSE+=" awt gcj" TC_FEATURES+=(gcj)
155 tc_version_is_at_least 3.3 && IUSE+=" pgo"
156 tc_version_is_at_least 4.0 &&
157 IUSE+=" objc-gc" TC_FEATURES+=(objc-gc)
158 tc_version_is_between 4.0 4.9 && IUSE+=" mudflap"
159 tc_version_is_at_least 4.1 && IUSE+=" libssp objc++"
160 tc_version_is_at_least 4.2 && IUSE+=" +openmp"
161 tc_version_is_at_least 4.3 && IUSE+=" fixed-point"
162 tc_version_is_at_least 4.7 && IUSE+=" go"
163 # Note: while <=gcc-4.7 also supported graphite, it required forked ppl
164 # versions which we dropped. Since graphite was also experimental in
165 # the older versions, we don't want to bother supporting it. #448024
166 tc_version_is_at_least 4.8 &&
167 IUSE+=" graphite +sanitize" TC_FEATURES+=(graphite)
168 tc_version_is_between 4.9 8 && IUSE+=" cilk"
169 tc_version_is_at_least 4.9 && IUSE+=" +vtv"
170 tc_version_is_at_least 5.0 && IUSE+=" jit"
171 tc_version_is_between 5.0 9 && IUSE+=" mpx"
172 tc_version_is_at_least 6.0 && IUSE+=" +pie +ssp +pch"
173 # systemtap is a gentoo-specific switch: bug #654748
174 tc_version_is_at_least 8.0 &&
175 IUSE+=" systemtap" TC_FEATURES+=(systemtap)
176 tc_version_is_at_least 9.0 && IUSE+=" d"
177 tc_version_is_at_least 9.1 && IUSE+=" lto"
180 SLOT="${GCC_CONFIG_VER}"
182 #---->> DEPEND <<----
184 RDEPEND="sys-libs/zlib
185 nls? ( virtual/libintl )"
187 tc_version_is_at_least 3 && RDEPEND+=" virtual/libiconv"
189 if tc_version_is_at_least 4 ; then
190 GMP_MPFR_DEPS=">=dev-libs/gmp-4.3.2:0= >=dev-libs/mpfr-2.4.2:0="
191 if tc_version_is_at_least 4.3 ; then
192 RDEPEND+=" ${GMP_MPFR_DEPS}"
193 elif tc_has_feature fortran ; then
194 RDEPEND+=" fortran? ( ${GMP_MPFR_DEPS} )"
198 tc_version_is_at_least 4.5 && RDEPEND+=" >=dev-libs/mpc-0.8.1:0="
200 if tc_has_feature objc-gc ; then
201 if tc_version_is_at_least 7 ; then
202 RDEPEND+=" objc-gc? ( >=dev-libs/boehm-gc-7.4.2 )"
206 if tc_has_feature graphite ; then
207 if tc_version_is_at_least 5.0 ; then
208 RDEPEND+=" graphite? ( >=dev-libs/isl-0.14:0= )"
209 elif tc_version_is_at_least 4.8 ; then
212 >=dev-libs/cloog-0.18.0:0=
213 >=dev-libs/isl-0.11.1:0=
219 >=sys-devel/bison-1.875
220 >=sys-devel/flex-2.5.4
221 nls? ( sys-devel/gettext )
222 ${GCC_EBUILD_TEST_FLAG}? (
223 >=dev-util/dejagnu-1.4.4
224 >=sys-devel/autogen-5.5.4
227 if tc_has_feature gcj ; then
228 GCJ_DEPS=">=media-libs/libart_lgpl-2.1"
237 tc_version_is_at_least 3.4 && GCJ_GTK_DEPS+=" x11-libs/pango"
238 tc_version_is_at_least 4.2 && GCJ_DEPS+=" app-arch/zip app-arch/unzip"
239 DEPEND+=" gcj? ( awt? ( ${GCJ_GTK_DEPS} ) ${GCJ_DEPS} )"
242 if tc_has_feature systemtap ; then
243 # gcc needs sys/sdt.h headers on target
244 DEPEND+=" systemtap? ( dev-util/systemtap )"
247 PDEPEND=">=sys-devel/gcc-config-1.7"
249 #---->> S + SRC_URI essentials <<----
251 # Set the source directory depending on whether we're using
252 # a prerelease, snapshot, or release tarball.
254 if [[ -n ${PRERELEASE} ]] ; then
255 echo ${WORKDIR}/gcc-${PRERELEASE}
256 elif [[ -n ${SNAPSHOT} ]] ; then
257 echo ${WORKDIR}/gcc-${SNAPSHOT}
259 echo ${WORKDIR}/gcc-${GCC_RELEASE_VER}
264 local devspace="HTTP~vapier/dist/URI HTTP~rhill/dist/URI
265 HTTP~zorry/patches/gcc/URI HTTP~blueness/dist/URI
266 HTTP~tamiko/distfiles/URI HTTP~slyfox/distfiles/URI"
267 devspace=${devspace//HTTP/https:\/\/dev.gentoo.org\/}
268 echo mirror://gentoo/$1 ${devspace//URI/$1}
271 # This function handles the basics of setting the SRC_URI for a gcc ebuild.
272 # To use, set SRC_URI with:
274 # SRC_URI="$(get_gcc_src_uri)"
276 # Other than the variables normally set by portage, this function's behavior
277 # can be altered by setting the following:
280 # If set, this variable signals that we should be using a snapshot of
281 # gcc. It is expected to be in the format "YYYY-MM-DD". Note that if
282 # the ebuild has a _pre suffix, this variable is ignored and the
283 # prerelease tarball is used instead.
286 # If set, this variable signals that we should be using the main
287 # release tarball (determined by ebuild version) and applying a
288 # CVS branch update patch against it. The location of this branch
289 # update patch is assumed to be in ${GENTOO_TOOLCHAIN_BASE_URI}.
290 # Just like with SNAPSHOT, this variable is ignored if the ebuild
295 # This should be set to the version of the gentoo patch tarball.
296 # The resulting filename of this tarball will be:
297 # gcc-${PATCH_GCC_VER:-${GCC_RELEASE_VER}}-patches-${PATCH_VER}.tar.bz2
301 # These variables control patching in various updates for the logic
302 # controlling Position Independant Executables. PIE_VER is expected
303 # to be the version of this patch, and PIE_GCC_VER the gcc version of
307 # PIE_GCC_VER="3.4.0"
308 # The resulting filename of this tarball will be:
309 # gcc-${PIE_GCC_VER:-${GCC_RELEASE_VER}}-piepatches-v${PIE_VER}.tar.bz2
313 # This is for the minispecs files included in the hardened gcc-4.x
314 # The specs files for hardenedno*, vanilla and for building the "specs" file.
315 # SPECS_VER is expected to be the version of this patch, SPECS_GCC_VER
316 # the gcc version of the patch.
318 # SPECS_VER="8.7.6.5"
319 # SPECS_GCC_VER="3.4.0"
320 # The resulting filename of this tarball will be:
321 # gcc-${SPECS_GCC_VER:-${GCC_RELEASE_VER}}-specs-${SPECS_VER}.tar.bz2
325 # These variables control whether or not an ebuild supports Herman
326 # ten Brugge's bounds-checking patches. If you want to use a patch
327 # for an older gcc version with a new gcc, make sure you set
328 # HTB_GCC_VER to that version of gcc.
331 # If set, this variable signals that we should apply additional patches
332 # maintained by upstream Cygwin developers at github/cygwinports/gcc,
333 # using the specified git commit id there. The list of patches to
334 # apply is extracted from gcc.cygport, maintained there as well.
335 # This is done for compilers running on Cygwin, not for cross compilers
336 # with a Cygwin target.
338 export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}}
339 export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}}
340 export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}}
341 export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}}
342 export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}}
344 # Set where to download gcc itself depending on whether we're using a
345 # prerelease, snapshot, or release tarball.
346 if [[ ${PV} == *9999* ]] ; then
347 # Nothing to do w/git snapshots.
349 elif [[ -n ${PRERELEASE} ]] ; then
350 GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/prerelease-${PRERELEASE}/gcc-${PRERELEASE}.tar.bz2"
351 elif [[ -n ${SNAPSHOT} ]] ; then
352 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
353 GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.xz"
355 GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.bz2"
358 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
359 GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.xz"
361 GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.bz2"
363 # we want all branch updates to be against the main release
364 [[ -n ${BRANCH_UPDATE} ]] && \
365 GCC_SRC_URI+=" $(gentoo_urls gcc-${GCC_RELEASE_VER}-branch-update-${BRANCH_UPDATE}.patch.bz2)"
368 [[ -n ${UCLIBC_VER} ]] && \
369 GCC_SRC_URI+=" $(gentoo_urls gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2)"
370 [[ -n ${PATCH_VER} ]] && \
371 GCC_SRC_URI+=" $(gentoo_urls gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2)"
373 # strawberry pie, Cappuccino and a Gauloises (it's a good thing)
374 [[ -n ${PIE_VER} ]] && \
375 PIE_CORE=${PIE_CORE:-gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2} && \
376 GCC_SRC_URI+=" $(gentoo_urls ${PIE_CORE})"
378 # gcc minispec for the hardened gcc 4 compiler
379 [[ -n ${SPECS_VER} ]] && \
380 GCC_SRC_URI+=" $(gentoo_urls gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2)"
382 # gcc bounds checking patch
383 if [[ -n ${HTB_VER} ]] ; then
384 local HTBFILE="bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
387 mirror://sourceforge/boundschecking/${HTBFILE}
388 $(gentoo_urls ${HTBFILE})
392 [[ -n ${D_VER} ]] && \
393 GCC_SRC_URI+=" d? ( mirror://sourceforge/dgcc/gdc-${D_VER}-src.tar.bz2 )"
395 if tc_has_feature gcj ; then
396 if tc_version_is_at_least 4.5 ; then
397 GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.5.jar )"
398 elif tc_version_is_at_least 4.3 ; then
399 GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.3.jar )"
403 # Cygwin patches from https://github.com/cygwinports/gcc
404 [[ -n ${CYGWINPORTS_GITREV} ]] && \
405 GCC_SRC_URI+=" elibc_Cygwin? ( https://github.com/cygwinports/gcc/archive/${CYGWINPORTS_GITREV}.tar.gz
406 -> gcc-cygwinports-${CYGWINPORTS_GITREV}.tar.gz )"
408 echo "${GCC_SRC_URI}"
411 SRC_URI=$(get_gcc_src_uri)
413 #---->> pkg_pretend <<----
415 toolchain_pkg_pretend() {
416 if [[ -n ${PRERELEASE}${SNAPSHOT} || ${PV} == *9999* ]] &&
417 [[ -z ${I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS} ]] ; then
418 die "Please \`export I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS=1\` or define it" \
419 "in your make.conf if you want to use this version."
422 if ! use_if_iuse cxx ; then
423 use_if_iuse go && ewarn 'Go requires a C++ compiler, disabled due to USE="-cxx"'
424 use_if_iuse objc++ && ewarn 'Obj-C++ requires a C++ compiler, disabled due to USE="-cxx"'
425 use_if_iuse gcj && ewarn 'GCJ requires a C++ compiler, disabled due to USE="-cxx"'
431 #---->> pkg_setup <<----
433 toolchain_pkg_setup() {
434 # we dont want to use the installed compiler's specs to build gcc
436 unset LANGUAGES #265283
439 #---->> src_unpack <<----
441 toolchain_src_unpack() {
442 if [[ ${PV} == *9999* ]]; then
450 pushd "${WORKDIR}" > /dev/null
451 export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}}
452 export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}}
453 export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}}
454 export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}}
455 export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}}
457 if [[ -n ${GCC_A_FAKEIT} ]] ; then
458 unpack ${GCC_A_FAKEIT}
459 elif [[ -n ${PRERELEASE} ]] ; then
460 unpack gcc-${PRERELEASE}.tar.bz2
461 elif [[ -n ${SNAPSHOT} ]] ; then
462 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
463 unpack gcc-${SNAPSHOT}.tar.xz
465 unpack gcc-${SNAPSHOT}.tar.bz2
467 elif [[ ${PV} != *9999* ]] ; then
468 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
469 unpack gcc-${GCC_RELEASE_VER}.tar.xz
471 unpack gcc-${GCC_RELEASE_VER}.tar.bz2
473 # We want branch updates to be against a release tarball
474 if [[ -n ${BRANCH_UPDATE} ]] ; then
475 pushd "${S}" > /dev/null
476 epatch "${DISTDIR}"/gcc-${GCC_RELEASE_VER}-branch-update-${BRANCH_UPDATE}.patch.bz2
481 if [[ -n ${D_VER} ]] && use d ; then
482 pushd "${S}"/gcc > /dev/null
483 unpack gdc-${D_VER}-src.tar.bz2
485 ebegin "Adding support for the D language"
486 ./gcc/d/setup-gcc.sh >& "${T}"/dgcc.log
488 eerror "The D GCC package failed to apply"
489 eerror "Please include this log file when posting a bug report:"
490 eerror " ${T}/dgcc.log"
491 die "failed to include the D language"
496 [[ -n ${PATCH_VER} ]] && \
497 unpack gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2
499 [[ -n ${UCLIBC_VER} ]] && \
500 unpack gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2
503 if [[ -n ${PIE_CORE} ]] ; then
506 unpack gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2
508 [[ -n ${SPECS_VER} ]] && \
509 unpack gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2
512 use_if_iuse boundschecking && unpack "bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
514 [[ -n ${CYGWINPORTS_GITREV} ]] && use elibc_Cygwin && unpack "gcc-cygwinports-${CYGWINPORTS_GITREV}.tar.gz"
519 #---->> src_prepare <<----
521 toolchain_src_prepare() {
522 export BRANDING_GCC_PKGVERSION="Gentoo ${GCC_PVR}"
525 if ! use vanilla ; then
526 if [[ -n ${PATCH_VER} ]] ; then
527 guess_patch_type_in_dir "${WORKDIR}"/patch
528 EPATCH_MULTI_MSG="Applying Gentoo patches ..." \
529 epatch "${WORKDIR}"/patch
530 BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION} p${PATCH_VER}"
532 if [[ -n ${UCLIBC_VER} ]] ; then
533 guess_patch_type_in_dir "${WORKDIR}"/uclibc
534 EPATCH_MULTI_MSG="Applying uClibc patches ..." \
535 epatch "${WORKDIR}"/uclibc
540 do_gcc_CYGWINPORTS_patches
545 *) die "Update toolchain_src_prepare() for ${EAPI}." ;;
548 if ( tc_version_is_at_least 4.8.2 || use_if_iuse hardened ) && ! use vanilla ; then
552 # install the libstdc++ python into the right location
553 # http://gcc.gnu.org/PR51368
554 if tc_version_is_between 4.5 4.7 ; then
556 '/^pythondir =/s:=.*:= $(datadir)/python:' \
557 "${S}"/libstdc++-v3/python/Makefile.in || die
560 # make sure the pkg config files install into multilib dirs.
561 # since we configure with just one --libdir, we can't use that
562 # (as gcc itself takes care of building multilibs). #435728
563 find "${S}" -name Makefile.in \
564 -exec sed -i '/^pkgconfigdir/s:=.*:=$(toolexeclibdir)/pkgconfig:' {} +
566 # No idea when this first started being fixed, but let's go with 4.3.x for now
567 if ! tc_version_is_at_least 4.3 ; then
569 for x in contrib/test_summary libstdc++-v3/scripts/check_survey.in ; do
570 [[ -e ${x} ]] && fix_files="${fix_files} ${x}"
572 ht_fix_file ${fix_files} */configure *.sh */Makefile.in
575 setup_multilib_osdirnames
578 if tc_version_is_at_least 4.1 ; then
579 if [[ -n ${SNAPSHOT} || -n ${PRERELEASE} ]] ; then
580 # BASE-VER must be a three-digit version number
581 # followed by an optional -pre string
582 # eg. 4.5.1, 4.6.2-pre20120213, 4.7.0-pre9999
583 # If BASE-VER differs from ${PV/_/-} then libraries get installed in
584 # the wrong directory.
585 echo ${PV/_/-} > "${S}"/gcc/BASE-VER
589 # >= gcc-4.3 doesn't bundle ecj.jar, so copy it
590 if tc_version_is_at_least 4.3 && use_if_iuse gcj ; then
591 if tc_version_is_at_least 4.5 ; then
592 einfo "Copying ecj-4.5.jar"
593 cp -pPR "${DISTDIR}/ecj-4.5.jar" "${S}/ecj.jar" || die
595 einfo "Copying ecj-4.3.jar"
596 cp -pPR "${DISTDIR}/ecj-4.3.jar" "${S}/ecj.jar" || die
600 # disable --as-needed from being compiled into gcc specs
601 # natively when using a gcc version < 3.4.4
602 # http://gcc.gnu.org/PR14992
603 if ! tc_version_is_at_least 3.4.4 ; then
604 sed -i -e s/HAVE_LD_AS_NEEDED/USE_LD_AS_NEEDED/g "${S}"/gcc/config.in
607 # In gcc 3.3.x and 3.4.x, rename the java bins to gcc-specific names
608 # in line with gcc-4.
609 if tc_version_is_between 3.3 4.0 ; then
610 do_gcc_rename_java_bins
613 # Prevent libffi from being installed
614 if tc_version_is_between 3.0 4.8 ; then
615 sed -i -e 's/\(install.*:\) install-.*recursive/\1/' "${S}"/libffi/Makefile.in || die
616 sed -i -e 's/\(install-data-am:\).*/\1/' "${S}"/libffi/include/Makefile.in || die
619 # Fixup libtool to correctly generate .la files with portage
620 elibtoolize --portage --shallow --no-uclibc
624 # update configure files
626 einfo "Fixing misc issues in configure files"
627 for f in $(grep -l 'autoconf version 2.13' $(find "${S}" -name configure)) ; do
628 ebegin " Updating ${f/${S}\/} [LANG]"
629 patch "${f}" "${FILESDIR}"/gcc-configure-LANG.patch >& "${T}"/configure-patch.log \
630 || eerror "Please file a bug about this"
633 sed -i 's|A-Za-z0-9|[:alnum:]|g' "${S}"/gcc/*.awk #215828
635 # Prevent new texinfo from breaking old versions (see #198182, #464008)
636 tc_version_is_at_least 4.1 && epatch "${FILESDIR}"/gcc-configure-texinfo.patch
638 if [[ -x contrib/gcc_update ]] ; then
639 einfo "Touching generated files"
640 ./contrib/gcc_update --touch | \
647 guess_patch_type_in_dir() {
648 [[ -n $(ls "$1"/*.bz2 2>/dev/null) ]] \
649 && EPATCH_SUFFIX="patch.bz2" \
650 || EPATCH_SUFFIX="patch"
653 do_gcc_HTB_patches() {
654 use_if_iuse boundschecking || return 0
656 # modify the bounds checking patch with a regression patch
657 epatch "${WORKDIR}/bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch"
658 BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, HTB-${HTB_GCC_VER}-${HTB_VER}"
661 do_gcc_PIE_patches() {
663 use vanilla && return 0
665 if tc_version_is_at_least 4.3.2 ; then
666 guess_patch_type_in_dir "${WORKDIR}"/piepatch/
667 EPATCH_MULTI_MSG="Applying pie patches ..." \
668 epatch "${WORKDIR}"/piepatch/
670 guess_patch_type_in_dir "${WORKDIR}"/piepatch/upstream
672 # corrects startfile/endfile selection and shared/static/pie flag usage
673 EPATCH_MULTI_MSG="Applying upstream pie patches ..." \
674 epatch "${WORKDIR}"/piepatch/upstream
675 # adds non-default pie support (rs6000)
676 EPATCH_MULTI_MSG="Applying non-default pie patches ..." \
677 epatch "${WORKDIR}"/piepatch/nondef
678 # adds default pie support (rs6000 too) if DEFAULT_PIE[_SSP] is defined
679 EPATCH_MULTI_MSG="Applying default pie patches ..." \
680 epatch "${WORKDIR}"/piepatch/def
683 BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, pie-${PIE_VER}"
686 do_gcc_CYGWINPORTS_patches() {
687 [[ -n ${CYGWINPORTS_GITREV} ]] || return 0
688 use elibc_Cygwin || return 0
691 local p d="${WORKDIR}/gcc-${CYGWINPORTS_GITREV}"
692 readarray -t patches < <(sed -e '1,/PATCH_URI="/d;/"/,$d' < "${d}"/gcc.cygport)
693 for p in ${patches[*]}; do
698 # configure to build with the hardened GCC specs as the default
701 local gcc_hard_flags=""
703 # If we use gcc-6 or newer with pie enable to compile older gcc we need to pass -no-pie
704 # to stage1; bug 618908
705 if ! tc_version_is_at_least 6.0 && [[ $(gcc-major-version) -ge 6 ]] ; then
706 einfo "Disabling PIE in stage1 (only) ..."
707 sed -i -e "/^STAGE1_LDFLAGS/ s/$/ -no-pie/" "${S}"/Makefile.in || die
710 # Gcc >= 6.X we can use configurations options to turn pie/ssp on as default
711 if tc_version_is_at_least 6.0 ; then
712 if use_if_iuse pie ; then
713 einfo "Updating gcc to use automatic PIE building ..."
715 if use_if_iuse ssp ; then
716 einfo "Updating gcc to use automatic SSP building ..."
718 if use_if_iuse hardened ; then
719 # Will add some optimatizion as default.
720 gcc_hard_flags+=" -DEXTRA_OPTIONS"
721 # rebrand to make bug reports easier
722 BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened}
725 if use_if_iuse hardened ; then
726 # rebrand to make bug reports easier
727 BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened}
728 if hardened_gcc_works ; then
729 einfo "Updating gcc to use automatic PIE + SSP building ..."
730 gcc_hard_flags+=" -DEFAULT_PIE_SSP"
731 elif hardened_gcc_works pie ; then
732 einfo "Updating gcc to use automatic PIE building ..."
733 ewarn "SSP has not been enabled by default"
734 gcc_hard_flags+=" -DEFAULT_PIE"
735 elif hardened_gcc_works ssp ; then
736 einfo "Updating gcc to use automatic SSP building ..."
737 ewarn "PIE has not been enabled by default"
738 gcc_hard_flags+=" -DEFAULT_SSP"
740 # do nothing if hardened isn't supported, but don't die either
741 ewarn "hardened is not supported for this arch in this gcc version"
745 if hardened_gcc_works ssp ; then
746 einfo "Updating gcc to use automatic SSP building ..."
747 gcc_hard_flags+=" -DEFAULT_SSP"
752 # we want to be able to control the pie patch logic via something other
754 sed -e '/^ALL_CFLAGS/iHARD_CFLAGS = ' \
755 -e 's|^ALL_CFLAGS = |ALL_CFLAGS = $(HARD_CFLAGS) |' \
756 -i "${S}"/gcc/Makefile.in
757 # Need to add HARD_CFLAGS to ALL_CXXFLAGS on >= 4.7
758 if tc_version_is_at_least 4.7 ; then
759 sed -e '/^ALL_CXXFLAGS/iHARD_CFLAGS = ' \
760 -e 's|^ALL_CXXFLAGS = |ALL_CXXFLAGS = $(HARD_CFLAGS) |' \
761 -i "${S}"/gcc/Makefile.in
765 -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \
766 "${S}"/gcc/Makefile.in || die
770 # This is a historical wart. The original Gentoo/amd64 port used:
771 # lib32 - 32bit binaries (x86)
772 # lib64 - 64bit binaries (x86_64)
773 # lib - "native" binaries (a symlink to lib64)
774 # Most other distros use the logic (including mainline gcc):
775 # lib - 32bit binaries (x86)
776 # lib64 - 64bit binaries (x86_64)
777 # Over time, Gentoo is migrating to the latter form.
779 # Unfortunately, due to distros picking the lib32 behavior, newer gcc
780 # versions will dynamically detect whether to use lib or lib32 for its
781 # 32bit multilib. So, to keep the automagic from getting things wrong
782 # while people are transitioning from the old style to the new style,
783 # we always set the MULTILIB_OSDIRNAMES var for relevant targets.
784 setup_multilib_osdirnames() {
785 is_multilib || return 0
788 local libdirs="../lib64 ../lib32"
790 # this only makes sense for some Linux targets
792 x86_64*-linux*) config="i386" ;;
793 powerpc64*-linux*) config="rs6000" ;;
794 sparc64*-linux*) config="sparc" ;;
795 s390x*-linux*) config="s390" ;;
801 if tc_version_is_at_least 4.6 ; then
802 sed_args+=( -e 's:$[(]call if_multiarch[^)]*[)]::g' )
804 if [[ ${SYMLINK_LIB} == "yes" ]] ; then
805 einfo "updating multilib directories to be: ${libdirs}"
806 if tc_version_is_at_least 4.6.4 || tc_version_is_at_least 4.7 ; then
807 sed_args+=( -e '/^MULTILIB_OSDIRNAMES.*lib32/s:[$][(]if.*):../lib32:' )
809 sed_args+=( -e "/^MULTILIB_OSDIRNAMES/s:=.*:= ${libdirs}:" )
812 einfo "using upstream multilib; disabling lib32 autodetection"
813 sed_args+=( -r -e 's:[$][(]if.*,(.*)[)]:\1:' )
815 sed -i "${sed_args[@]}" "${S}"/gcc/config/${config} || die
818 gcc_version_patch() {
819 # gcc-4.3+ has configure flags (whoo!)
820 tc_version_is_at_least 4.3 && return 0
822 local version_string=${GCC_CONFIG_VER}
823 [[ -n ${BRANCH_UPDATE} ]] && version_string+=" ${BRANCH_UPDATE}"
825 einfo "patching gcc version: ${version_string} (${BRANDING_GCC_PKGVERSION})"
827 local gcc_sed=( -e 's:gcc\.gnu\.org/bugs\.html:bugs\.gentoo\.org/:' )
828 if grep -qs VERSUFFIX "${S}"/gcc/version.c ; then
829 gcc_sed+=( -e "/VERSUFFIX \"\"/s:\"\":\" (${BRANDING_GCC_PKGVERSION})\":" )
831 version_string="${version_string} (${BRANDING_GCC_PKGVERSION})"
832 gcc_sed+=( -e "/const char version_string\[\] = /s:= \".*\":= \"${version_string}\":" )
834 sed -i "${gcc_sed[@]}" "${S}"/gcc/version.c || die
837 do_gcc_rename_java_bins() {
838 # bug #139918 - conflict between gcc and java-config-2 for ownership of
839 # /usr/bin/rmi{c,registry}. Done with mv & sed rather than a patch
840 # because patches would be large (thanks to the rename of man files),
841 # and it's clear from the sed invocations that all that changes is the
842 # rmi{c,registry} names to grmi{c,registry} names.
843 # Kevin F. Quinn 2006-07-12
844 einfo "Renaming jdk executables rmic and rmiregistry to grmic and grmiregistry."
845 # 1) Move the man files if present (missing prior to gcc-3.4)
846 for manfile in rmic rmiregistry ; do
847 [[ -f ${S}/gcc/doc/${manfile}.1 ]] || continue
848 mv "${S}"/gcc/doc/${manfile}.1 "${S}"/gcc/doc/g${manfile}.1
850 # 2) Fixup references in the docs if present (mission prior to gcc-3.4)
851 for jfile in gcc/doc/gcj.info gcc/doc/grmic.1 gcc/doc/grmiregistry.1 gcc/java/gcj.texi ; do
852 [[ -f ${S}/${jfile} ]] || continue
853 sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} ||
854 die "Failed to fixup file ${jfile} for rename to grmiregistry"
855 sed -i -e 's:rmic:grmic:g' "${S}"/${jfile} ||
856 die "Failed to fixup file ${jfile} for rename to grmic"
858 # 3) Fixup Makefiles to build the changed executable names
859 # These are present in all 3.x versions, and are the important bit
860 # to get gcc to build with the new names.
861 for jfile in libjava/Makefile.am libjava/Makefile.in gcc/java/Make-lang.in ; do
862 sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} ||
863 die "Failed to fixup file ${jfile} for rename to grmiregistry"
864 # Careful with rmic on these files; it's also the name of a directory
865 # which should be left unchanged. Replace occurrences of 'rmic$',
866 # 'rmic_' and 'rmic '.
867 sed -i -e 's:rmic\([$_ ]\):grmic\1:g' "${S}"/${jfile} ||
868 die "Failed to fixup file ${jfile} for rename to grmic"
872 #---->> src_configure <<----
874 toolchain_src_configure() {
878 einfo "CFLAGS=\"${CFLAGS}\""
879 einfo "CXXFLAGS=\"${CXXFLAGS}\""
880 einfo "LDFLAGS=\"${LDFLAGS}\""
882 # Force internal zip based jar script to avoid random
883 # issues with 3rd party jar implementations. #384291
886 # For hardened gcc 4.3 piepatchset to build the hardened specs
887 # file (build.specs) to use when building gcc.
888 if ! tc_version_is_at_least 4.4 && want_minispecs ; then
889 setup_minispecs_gcc_build_specs
892 local confgcc=( --host=${CHOST} )
894 if is_crosscompile || tc-is-cross-compiler ; then
895 # Straight from the GCC install doc:
896 # "GCC has code to correctly determine the correct value for target
897 # for nearly all native systems. Therefore, we highly recommend you
898 # not provide a configure target when configuring a native compiler."
899 confgcc+=( --target=${CTARGET} )
901 [[ -n ${CBUILD} ]] && confgcc+=( --build=${CBUILD} )
905 --bindir="${BINPATH}"
906 --includedir="${INCLUDEPATH}"
907 --datadir="${DATAPATH}"
908 --mandir="${DATAPATH}/man"
909 --infodir="${DATAPATH}/info"
910 --with-gxx-include-dir="${STDCXX_INCDIR}"
913 # Stick the python scripts in their own slotted directory (bug #279252)
915 # --with-python-dir=DIR
916 # Specifies where to install the Python modules used for aot-compile. DIR
917 # should not include the prefix used in installation. For example, if the
918 # Python modules are to be installed in /usr/lib/python2.5/site-packages,
919 # then --with-python-dir=/lib/python2.5/site-packages should be passed.
921 # This should translate into "/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}/python"
922 if tc_version_is_at_least 4.4 ; then
923 confgcc+=( --with-python-dir=${DATAPATH/$PREFIX/}/python )
929 is_cxx && GCC_LANG+=",c++"
930 is_d && GCC_LANG+=",d"
931 is_gcj && GCC_LANG+=",java"
932 is_go && GCC_LANG+=",go"
933 is_jit && GCC_LANG+=",jit"
934 if is_objc || is_objcxx ; then
936 if tc_version_is_at_least 4 ; then
937 use objc-gc && confgcc+=( --enable-objc-gc )
939 is_objcxx && GCC_LANG+=",obj-c++"
942 # fortran support just got sillier! the lang value can be f77 for
943 # fortran77, f95 for fortran95, or just plain old fortran for the
944 # currently supported standard depending on gcc version.
945 is_fortran && GCC_LANG+=",fortran"
946 is_f77 && GCC_LANG+=",f77"
947 is_f95 && GCC_LANG+=",f95"
949 # We do NOT want 'ADA support' in here!
950 # is_ada && GCC_LANG+=",ada"
952 confgcc+=( --enable-languages=${GCC_LANG} )
964 confgcc+=( --enable-nls --without-included-gettext )
966 confgcc+=( --disable-nls )
969 tc_version_is_at_least 3.4 || confgcc+=( --disable-libunwind-exceptions )
971 # Use the default ("release") checking because upstream usually neglects
972 # to test "disabled" so it has a history of breaking. #317217
973 if tc_version_is_at_least 3.4 && in_iuse debug ; then
974 # The "release" keyword is new to 4.0. #551636
975 local off=$(tc_version_is_at_least 4.0 && echo release || echo no)
976 confgcc+=( --enable-checking="${GCC_CHECKS_LIST:-$(usex debug yes ${off})}" )
980 tc_version_is_at_least 4.3 && confgcc+=(
981 --with-bugurl=https://bugs.gentoo.org/
982 --with-pkgversion="${BRANDING_GCC_PKGVERSION}"
985 # If we want hardened support with the newer piepatchset for >=gcc 4.4
986 if tc_version_is_at_least 4.4 && want_minispecs && in_iuse hardened ; then
987 confgcc+=( $(use_enable hardened esp) )
990 # allow gcc to search for clock funcs in the main C lib.
991 # if it can't find them, then tough cookies -- we aren't
992 # going to link in -lrt to all C++ apps. #411681
993 if tc_version_is_at_least 4.4 && is_cxx ; then
994 confgcc+=( --enable-libstdcxx-time )
997 # Build compiler using LTO
998 if tc_version_is_at_least 9.1 && use_if_iuse lto ; then
999 confgcc+=( --with-build-config=bootstrap-lto )
1002 # Support to disable pch when building libstdcxx
1003 if tc_version_is_at_least 6.0 && ! use_if_iuse pch ; then
1004 confgcc+=( --disable-libstdcxx-pch )
1007 # The jit language requires this.
1008 is_jit && confgcc+=( --enable-host-shared )
1010 # # Turn on the -Wl,--build-id flag by default for ELF targets. #525942
1011 # # This helps with locating debug files.
1012 # case ${CTARGET} in
1013 # *-linux-*|*-elf|*-eabi)
1014 # tc_version_is_at_least 4.5 && confgcc+=(
1015 # --enable-linker-build-id
1020 # newer gcc versions like to bootstrap themselves with C++,
1021 # so we need to manually disable it ourselves
1022 if tc_version_is_between 4.7 4.8 && ! is_cxx ; then
1023 confgcc+=( --disable-build-with-cxx --disable-build-poststage1-with-cxx )
1026 ### Cross-compiler options
1027 if is_crosscompile ; then
1028 # Enable build warnings by default with cross-compilers when system
1029 # paths are included (e.g. via -I flags).
1030 confgcc+=( --enable-poison-system-directories )
1032 # When building a stage1 cross-compiler (just C compiler), we have to
1033 # disable a bunch of features or gcc goes boom
1034 local needed_libc=""
1036 *-linux) needed_libc=no-fucking-clue;;
1037 *-dietlibc) needed_libc=dietlibc;;
1040 # Bare-metal targets don't have access to clock_gettime()
1041 # arm-none-eabi example: bug #589672
1042 # But we explicitly do --enable-libstdcxx-time above.
1044 confgcc+=( --disable-libstdcxx-time )
1046 *-freebsd*) needed_libc=freebsd-lib;;
1047 *-gnu*) needed_libc=glibc;;
1048 *-klibc) needed_libc=klibc;;
1049 *-musl*) needed_libc=musl;;
1051 if ! echo '#include <features.h>' | \
1052 $(tc-getCPP ${CTARGET}) -E -dD - 2>/dev/null | \
1053 grep -q __HAVE_SHARED__
1055 confgcc+=( --disable-shared )
1057 needed_libc=uclibc-ng
1059 *-cygwin) needed_libc=cygwin;;
1061 *-w64-mingw*) needed_libc=mingw64-runtime;;
1062 mingw*|*-mingw*) needed_libc=mingw-runtime;;
1063 avr) confgcc+=( --enable-shared --disable-threads );;
1065 if [[ -n ${needed_libc} ]] ; then
1066 local confgcc_no_libc=( --disable-shared )
1067 tc_version_is_at_least 4.8 && confgcc_no_libc+=( --disable-libatomic )
1068 if ! has_version ${CATEGORY}/${needed_libc} ; then
1070 "${confgcc_no_libc[@]}"
1074 elif has_version "${CATEGORY}/${needed_libc}[headers-only(-)]" ; then
1076 "${confgcc_no_libc[@]}"
1077 --with-sysroot="${PREFIX}"/${CTARGET}
1080 confgcc+=( --with-sysroot="${PREFIX}"/${CTARGET} )
1084 tc_version_is_at_least 4.2 && confgcc+=( --disable-bootstrap )
1086 if tc-is-static-only ; then
1087 confgcc+=( --disable-shared )
1089 confgcc+=( --enable-shared )
1093 confgcc+=( --enable-threads=win32 ) ;;
1095 confgcc+=( --enable-threads=posix ) ;;
1099 # __cxa_atexit is "essential for fully standards-compliant handling of
1100 # destructors", but apparently requires glibc.
1104 --disable-__cxa_atexit
1105 $(use_enable nptl tls)
1107 tc_version_is_between 3.3 3.4 && confgcc+=( --enable-sjlj-exceptions )
1108 if tc_version_is_between 3.4 4.3 ; then
1109 confgcc+=( --enable-clocale=uclibc )
1113 confgcc+=( --with-newlib )
1116 confgcc+=( --enable-__cxa_atexit )
1120 --enable-__cxa_atexit
1121 --enable-clocale=gnu
1125 confgcc+=( --enable-__cxa_atexit )
1128 confgcc+=( --enable-__cxa_atexit )
1134 gcc-multilib-configure
1136 # ppc altivec support
1137 in_iuse altivec && confgcc+=( $(use_enable altivec) )
1139 # gcc has fixed-point arithmetic support in 4.3 for mips targets that can
1140 # significantly increase compile time by several hours. This will allow
1141 # users to control this feature in the event they need the support.
1142 tc_version_is_at_least 4.3 && in_iuse fixed-point && confgcc+=( $(use_enable fixed-point) )
1144 case $(tc-is-softfloat) in
1145 yes) confgcc+=( --with-float=soft ) ;;
1146 softfp) confgcc+=( --with-float=softfp ) ;;
1148 # If they've explicitly opt-ed in, do hardfloat,
1149 # otherwise let the gcc default kick in.
1150 case ${CTARGET//_/-} in
1151 *-hardfloat-*|*eabihf) confgcc+=( --with-float=hard ) ;;
1155 local with_abi_map=()
1157 arm) #264534 #414395
1158 local a arm_arch=${CTARGET%%-*}
1159 # Remove trailing endian variations first: eb el be bl b l
1160 for a in e{b,l} {b,l}e b l ; do
1161 if [[ ${arm_arch} == *${a} ]] ; then
1162 arm_arch=${arm_arch%${a}}
1166 # Convert armv7{a,r,m} to armv7-{a,r,m}
1167 [[ ${arm_arch} == armv7? ]] && arm_arch=${arm_arch/7/7-}
1168 # See if this is a valid --with-arch flag
1169 if (srcdir=${S}/gcc target=${CTARGET} with_arch=${arm_arch};
1170 . "${srcdir}"/config.gcc) &>/dev/null
1172 confgcc+=( --with-arch=${arm_arch} )
1175 # Make default mode thumb for microcontroller classes #418209
1176 [[ ${arm_arch} == *-m ]] && confgcc+=( --with-mode=thumb )
1179 if [[ $(tc-is-softfloat) == "no" ]] && \
1180 [[ ${CTARGET} == armv[67]* ]] && \
1181 tc_version_is_at_least 4.5
1183 # Follow the new arm hardfp distro standard by default
1184 confgcc+=( --with-float=hard )
1186 armv6*) confgcc+=( --with-fpu=vfp ) ;;
1187 armv7*) confgcc+=( --with-fpu=vfpv3-d16 ) ;;
1192 # Add --with-abi flags to set default ABI
1193 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1196 # drop the older/ABI checks once this get's merged into some
1197 # version of gcc upstream
1198 if tc_version_is_at_least 4.8 && has x32 $(get_all_abis TARGET) ; then
1199 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1203 # Default arch for x86 is normally i386, lets give it a bump
1204 # since glibc will do so based on CTARGET anyways
1205 confgcc+=( --with-arch=${CTARGET%%-*} )
1208 # Enable sjlj exceptions for backward compatibility on hppa
1209 [[ ${GCCMAJOR} == "3" ]] && confgcc+=( --enable-sjlj-exceptions )
1212 # Set up defaults based on current CFLAGS
1213 is-flagq -mfloat-gprs=double && confgcc+=( --enable-e500-double )
1214 [[ ${CTARGET//_/-} == *-e500v2-* ]] && confgcc+=( --enable-e500-double )
1217 # Add --with-abi flags to set default ABI
1218 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1222 # if the target can do biarch (-m32/-m64), enable it. overhead should
1223 # be small, and should simplify building of 64bit kernels in a 32bit
1224 # userland by not needing sys-devel/kgcc64. #349405
1226 ppc|ppc64) tc_version_is_at_least 3.4 && confgcc+=( --enable-targets=all ) ;;
1227 sparc) tc_version_is_at_least 4.4 && confgcc+=( --enable-targets=all ) ;;
1228 amd64|x86) tc_version_is_at_least 4.3 && confgcc+=( --enable-targets=all ) ;;
1231 # On Darwin we need libdir to be set in order to get correct install names
1232 # for things like libobjc-gnu, libgcj and libfortran. If we enable it on
1233 # non-Darwin we screw up the behaviour this eclass relies on. We in
1234 # particular need this over --libdir for bug #255315.
1235 [[ ${CTARGET} == *-darwin* ]] && \
1236 confgcc+=( --enable-version-specific-runtime-libs )
1240 if tc_version_is_between 3.0 7.0 ; then
1242 confgcc+=( --disable-libgcj )
1244 confgcc+=( --enable-java-awt=gtk )
1248 if tc_version_is_at_least 4.2 ; then
1249 if in_iuse openmp ; then
1250 # Make sure target has pthreads support. #326757 #335883
1251 # There shouldn't be a chicken & egg problem here as openmp won't
1252 # build without a C library, and you can't build that w/out
1253 # already having a compiler ...
1254 if ! is_crosscompile || \
1255 $(tc-getCPP ${CTARGET}) -E - <<<"#include <pthread.h>" >& /dev/null
1257 confgcc+=( $(use_enable openmp libgomp) )
1259 # Force disable as the configure script can be dumb #359855
1260 confgcc+=( --disable-libgomp )
1263 # For gcc variants where we don't want openmp (e.g. kgcc)
1264 confgcc+=( --disable-libgomp )
1268 if tc_version_is_at_least 4.0 ; then
1269 if in_iuse mudflap ; then
1270 confgcc+=( $(use_enable mudflap libmudflap) )
1272 confgcc+=( --disable-libmudflap )
1275 if use_if_iuse libssp ; then
1276 confgcc+=( --enable-libssp )
1278 if hardened_gcc_is_stable ssp; then
1279 export gcc_cv_libc_provides_ssp=yes
1281 if use_if_iuse ssp; then
1282 # On some targets USE="ssp -libssp" is an invalid
1283 # configuration as target libc does not provide
1284 # stack_chk_* functions. Do not disable libssp there.
1286 mingw*|*-mingw*) ewarn "Not disabling libssp" ;;
1287 *) confgcc+=( --disable-libssp ) ;;
1290 confgcc+=( --disable-libssp )
1295 if in_iuse cilk ; then
1296 confgcc+=( $(use_enable cilk libcilkrts) )
1299 if in_iuse mpx ; then
1300 confgcc+=( $(use_enable mpx libmpx) )
1303 if in_iuse systemtap ; then
1304 confgcc+=( $(use_enable systemtap) )
1307 if in_iuse vtv ; then
1309 $(use_enable vtv vtable-verify)
1310 # See Note [implicitly enabled flags]
1311 $(usex vtv '' --disable-libvtv)
1315 # newer gcc's come with libquadmath, but only fortran uses
1316 # it, so auto punt it when we don't care
1317 if tc_version_is_at_least 4.6 && ! is_fortran ; then
1318 confgcc+=( --disable-libquadmath )
1321 if tc_version_is_at_least 4.6 ; then
1322 confgcc+=( --enable-lto )
1323 elif tc_version_is_at_least 4.5 ; then
1324 confgcc+=( --disable-lto )
1327 # graphite was added in 4.4 but we only support it in 4.8+ due to external
1328 # library issues. #448024
1329 if tc_version_is_at_least 5.0 && in_iuse graphite ; then
1330 confgcc+=( $(use_with graphite isl) )
1331 use graphite && confgcc+=( --disable-isl-version-check )
1332 elif tc_version_is_at_least 4.8 && in_iuse graphite ; then
1333 confgcc+=( $(use_with graphite cloog) )
1334 use graphite && confgcc+=( --disable-isl-version-check )
1335 elif tc_version_is_at_least 4.4 ; then
1336 confgcc+=( --without-{cloog,ppl} )
1339 if tc_version_is_at_least 4.8 && in_iuse sanitize ; then
1340 # See Note [implicitly enabled flags]
1341 confgcc+=( $(usex sanitize '' --disable-libsanitizer) )
1344 if tc_version_is_at_least 6.0 && in_iuse pie ; then
1345 confgcc+=( $(use_enable pie default-pie) )
1348 if tc_version_is_at_least 6.0 && in_iuse ssp ; then
1350 # This defaults to -fstack-protector-strong.
1351 $(use_enable ssp default-ssp)
1355 # Disable gcc info regeneration -- it ships with generated info pages
1356 # already. Our custom version/urls/etc... trigger it. #464008
1357 export gcc_cv_prog_makeinfo_modern=no
1359 # Do not let the X detection get in our way. We know things can be found
1360 # via system paths, so no need to hardcode things that'll break multilib.
1361 # Older gcc versions will detect ac_x_libraries=/usr/lib64 which ends up
1362 # killing the 32bit builds which want /usr/lib.
1363 export ac_cv_have_x='have_x=yes ac_x_includes= ac_x_libraries='
1365 confgcc+=( "$@" ${EXTRA_ECONF} )
1367 # Nothing wrong with a good dose of verbosity
1369 einfo "PREFIX: ${PREFIX}"
1370 einfo "BINPATH: ${BINPATH}"
1371 einfo "LIBPATH: ${LIBPATH}"
1372 einfo "DATAPATH: ${DATAPATH}"
1373 einfo "STDCXX_INCDIR: ${STDCXX_INCDIR}"
1375 einfo "Languages: ${GCC_LANG}"
1377 einfo "Configuring GCC with: ${confgcc[@]//--/\n\t--}"
1380 # Build in a separate build tree
1381 mkdir -p "${WORKDIR}"/build
1382 pushd "${WORKDIR}"/build > /dev/null
1384 # and now to do the actual configuration
1386 echo "${S}"/configure "${confgcc[@]}"
1387 # Older gcc versions did not detect bash and re-exec itself, so force the
1388 # use of bash. Newer ones will auto-detect, but this is not harmful.
1389 CONFIG_SHELL="${EPREFIX}/bin/bash" \
1390 bash "${S}"/configure "${confgcc[@]}" || die "failed to run configure"
1392 # return to whatever directory we were in before
1396 # Replace -m flags unsupported by the version being built with the best
1397 # available equivalent
1398 downgrade_arch_flags() {
1399 local arch bver i isa myarch mytune rep ver
1401 bver=${1:-${GCC_BRANCH_VER}}
1402 [[ $(gcc-version) < ${bver} ]] && return 0
1403 [[ $(tc-arch) != amd64 && $(tc-arch) != x86 ]] && return 0
1405 myarch=$(get-flag march)
1406 mytune=$(get-flag mtune)
1408 # If -march=native isn't supported we have to tease out the actual arch
1409 if [[ ${myarch} == native || ${mytune} == native ]] ; then
1410 if [[ ${bver} < 4.2 ]] ; then
1411 arch=$($(tc-getCC) -march=native -v -E -P - </dev/null 2>&1 \
1412 | sed -rn "/cc1.*-march/s:.*-march=([^ ']*).*:\1:p")
1413 replace-cpu-flags native ${arch}
1417 # Handle special -mtune flags
1418 [[ ${mytune} == intel && ${bver} < 4.9 ]] && replace-cpu-flags intel generic
1419 [[ ${mytune} == generic && ${bver} < 4.2 ]] && filter-flags '-mtune=*'
1420 [[ ${mytune} == x86-64 ]] && filter-flags '-mtune=*'
1421 [[ ${bver} < 3.4 ]] && filter-flags '-mtune=*'
1423 # "added" "arch" "replacement"
1427 4.9 broadwell core-avx2
1428 4.9 haswell core-avx2
1429 4.9 ivybridge core-avx-i
1431 4.9 sandybridge corei7-avx
1432 4.9 silvermont corei7
1437 4.7 core-avx2 core-avx-i
1440 4.6 core-avx-i core2
1442 4.6 corei7-avx core2
1445 4.3 athlon64-sse3 k8
1448 4.3 geode k6-2 # gcc.gnu.org/PR41989#c22
1451 3.4 athlon-fx x86-64
1456 3.4 pentium-m pentium3
1457 3.4 pentium3m pentium3
1458 3.4 pentium4m pentium4
1461 for ((i = 0; i < ${#archlist[@]}; i += 3)) ; do
1462 myarch=$(get-flag march)
1463 mytune=$(get-flag mtune)
1466 arch=${archlist[i + 1]}
1467 rep=${archlist[i + 2]}
1469 [[ ${myarch} != ${arch} && ${mytune} != ${arch} ]] && continue
1471 if [[ ${ver} > ${bver} ]] ; then
1472 einfo "Replacing ${myarch} (added in gcc ${ver}) with ${rep}..."
1473 [[ ${myarch} == ${arch} ]] && replace-cpu-flags ${myarch} ${rep}
1474 [[ ${mytune} == ${arch} ]] && replace-cpu-flags ${mytune} ${rep}
1481 # we only check -mno* here since -m* get removed by strip-flags later on
1517 for ((i = 0; i < ${#isalist[@]}; i += 2)) ; do
1519 isa=${isalist[i + 1]}
1520 [[ ${ver} > ${bver} ]] && filter-flags ${isa} ${isa/-m/-mno-}
1524 gcc_do_filter_flags() {
1526 replace-flags -O? -O2
1528 # dont want to funk ourselves
1529 filter-flags '-mabi*' -m31 -m32 -m64
1531 filter-flags -frecord-gcc-switches # 490738
1532 filter-flags -mno-rtm -mno-htm # 506202
1534 if tc_version_is_between 3.2 3.4 ; then
1535 # XXX: this is so outdated it's barely useful, but it don't hurt...
1536 replace-cpu-flags G3 750
1537 replace-cpu-flags G4 7400
1538 replace-cpu-flags G5 7400
1540 # XXX: should add a sed or something to query all supported flags
1541 # from the gcc source and trim everything else ...
1542 filter-flags -f{no-,}unit-at-a-time -f{no-,}web -mno-tls-direct-seg-refs
1543 filter-flags -f{no-,}stack-protector{,-all}
1544 filter-flags -fvisibility-inlines-hidden -fvisibility=hidden
1545 # and warning options
1546 filter-flags -Wextra -Wstack-protector
1548 if ! tc_version_is_at_least 4.1 ; then
1549 filter-flags -fdiagnostics-show-option
1550 filter-flags -Wstack-protector
1553 if tc_version_is_at_least 3.4 ; then
1556 filter-flags '-mcpu=*'
1558 tc_version_is_between 4.4 4.5 && append-flags -mno-avx # 357287
1560 if tc_version_is_between 4.6 4.7 ; then
1561 # https://bugs.gentoo.org/411333
1562 # https://bugs.gentoo.org/466454
1563 replace-cpu-flags c3-2 pentium2 pentium3 pentium3m pentium-m i686
1567 # https://bugs.gentoo.org/454426
1568 append-ldflags -Wl,--no-relax
1571 # temporary workaround for random ICEs reproduced by multiple users
1572 # https://bugs.gentoo.org/457062
1573 tc_version_is_between 4.6 4.8 && MAKEOPTS+=" -j1"
1576 # http://gcc.gnu.org/PR25127
1577 tc_version_is_between 4.0 4.2 && \
1578 filter-flags '-mcpu=*' '-march=*' '-mtune=*'
1583 strip-unsupported-flags
1585 # these are set here so we have something sane at configure time
1586 if is_crosscompile ; then
1587 # Set this to something sane for both native and target
1592 # "hppa2.0-unknown-linux-gnu" -> hppa2_0_unknown_linux_gnu
1593 local VAR="CFLAGS_"${CTARGET//[-.]/_}
1594 CXXFLAGS=${!VAR-${CFLAGS}}
1597 export GCJFLAGS=${GCJFLAGS:-${CFLAGS}}
1600 setup_minispecs_gcc_build_specs() {
1601 # Setup the "build.specs" file for gcc 4.3 to use when building.
1602 if hardened_gcc_works pie ; then
1603 cat "${WORKDIR}"/specs/pie.specs >> "${WORKDIR}"/build.specs
1605 if hardened_gcc_works ssp ; then
1606 for s in ssp sspall ; do
1607 cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1610 for s in nostrict znow ; do
1611 cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1613 export GCC_SPECS="${WORKDIR}"/build.specs
1616 gcc-multilib-configure() {
1617 if ! is_multilib ; then
1618 confgcc+=( --disable-multilib )
1619 # Fun times: if we are building for a target that has multiple
1620 # possible ABI formats, and the user has told us to pick one
1621 # that isn't the default, then not specifying it via the list
1622 # below will break that on us.
1624 confgcc+=( --enable-multilib )
1627 # translate our notion of multilibs into gcc's
1629 for abi in $(get_all_abis TARGET) ; do
1630 local l=$(gcc-abi-map ${abi})
1631 [[ -n ${l} ]] && list+=",${l}"
1633 if [[ -n ${list} ]] ; then
1636 tc_version_is_at_least 4.8 && confgcc+=( --with-multilib-list=${list:1} )
1643 # Convert the ABI name we use in Gentoo to what gcc uses
1646 mips*) map=("o32 32" "n32 n32" "n64 64") ;;
1647 riscv*) map=("lp64d lp64d" "lp64 lp64") ;;
1648 x86_64*) map=("amd64 m64" "x86 m32" "x32 mx32") ;;
1652 for m in "${map[@]}" ; do
1654 [[ $1 == ${l[0]} ]] && echo ${l[1]} && break
1658 #----> src_compile <----
1660 toolchain_src_compile() {
1661 touch "${S}"/gcc/c-gperf.h
1663 # Do not make manpages if we do not have perl ...
1664 [[ ! -x /usr/bin/perl ]] \
1665 && find "${WORKDIR}"/build -name '*.[17]' -exec touch {} +
1667 # Older gcc versions did not detect bash and re-exec itself, so force the
1668 # use of bash. Newer ones will auto-detect, but this is not harmful.
1669 # This needs to be set for compile as well, as it's used in libtool
1670 # generation, which will break install otherwise (at least in 3.3.6): #664486
1671 CONFIG_SHELL="${EPREFIX}/bin/bash" \
1672 gcc_do_make ${GCC_MAKE_TARGET}
1676 # This function accepts one optional argument, the make target to be used.
1677 # If omitted, gcc_do_make will try to guess whether it should use all,
1678 # or bootstrap-lean depending on CTARGET and arch.
1679 # An example of how to use this function:
1681 # gcc_do_make all-target-libstdc++-v3
1683 [[ -n ${1} ]] && GCC_MAKE_TARGET=${1}
1686 if is_crosscompile || tc-is-cross-compiler ; then
1687 # 3 stage bootstrapping doesnt quite work when you cant run the
1688 # resulting binaries natively ^^;
1689 GCC_MAKE_TARGET=${GCC_MAKE_TARGET-all}
1691 if tc_version_is_at_least 3.3 && use_if_iuse pgo; then
1692 GCC_MAKE_TARGET=${GCC_MAKE_TARGET-profiledbootstrap}
1694 GCC_MAKE_TARGET=${GCC_MAKE_TARGET-bootstrap-lean}
1698 # Older versions of GCC could not do profiledbootstrap in parallel due to
1699 # collisions with profiling info.
1700 # boundschecking also seems to introduce parallel build issues.
1701 if [[ ${GCC_MAKE_TARGET} == "profiledbootstrap" ]] || use_if_iuse boundschecking ; then
1702 ! tc_version_is_at_least 4.6 && export MAKEOPTS="${MAKEOPTS} -j1"
1705 if [[ ${GCC_MAKE_TARGET} == "all" ]] ; then
1706 STAGE1_CFLAGS=${STAGE1_CFLAGS-"${CFLAGS}"}
1707 elif [[ $(gcc-version) == "3.4" && ${GCC_BRANCH_VER} == "3.4" ]] && gcc-specs-ssp ; then
1709 STAGE1_CFLAGS=${STAGE1_CFLAGS-"-O2"}
1712 if is_crosscompile; then
1713 # In 3.4, BOOT_CFLAGS is never used on a crosscompile...
1714 # but I'll leave this in anyways as someone might have had
1715 # some reason for putting it in here... --eradicator
1716 BOOT_CFLAGS=${BOOT_CFLAGS-"-O2"}
1718 # we only want to use the system's CFLAGS if not building a
1720 BOOT_CFLAGS=${BOOT_CFLAGS-"$(get_abi_CFLAGS ${TARGET_DEFAULT_ABI}) ${CFLAGS}"}
1723 einfo "Compiling ${PN} (${GCC_MAKE_TARGET})..."
1725 pushd "${WORKDIR}"/build >/dev/null
1728 LDFLAGS="${LDFLAGS}" \
1729 STAGE1_CFLAGS="${STAGE1_CFLAGS}" \
1730 LIBPATH="${LIBPATH}" \
1731 BOOT_CFLAGS="${BOOT_CFLAGS}" \
1732 ${GCC_MAKE_TARGET} \
1733 || die "emake failed with ${GCC_MAKE_TARGET}"
1735 if ! is_crosscompile && use_if_iuse cxx && use_if_iuse doc ; then
1736 if type -p doxygen > /dev/null ; then
1737 if tc_version_is_at_least 4.3 ; then
1738 cd "${CTARGET}"/libstdc++-v3/doc
1739 emake doc-man-doxygen || ewarn "failed to make docs"
1740 elif tc_version_is_at_least 3.0 ; then
1741 cd "${CTARGET}"/libstdc++-v3
1742 emake doxygen-man || ewarn "failed to make docs"
1744 # Clean bogus manpages. #113902
1745 find -name '*_build_*' -delete
1746 # Blow away generated directory references. Newer versions of gcc
1747 # have gotten better at this, but not perfect. This is easier than
1748 # backporting all of the various doxygen patches. #486754
1749 find -name '*_.3' -exec grep -l ' Directory Reference ' {} + | \
1752 ewarn "Skipping libstdc++ manpage generation since you don't have doxygen installed"
1759 #---->> src_test <<----
1761 toolchain_src_test() {
1762 if use ${GCC_EBUILD_TEST_FLAG} ; then
1763 cd "${WORKDIR}"/build
1764 # enable verbose test run and result logging
1765 emake -k check RUNTESTFLAGS='-a -v'
1769 #---->> src_install <<----
1771 toolchain_src_install() {
1772 cd "${WORKDIR}"/build
1774 # Do allow symlinks in private gcc include dir as this can break the build
1775 find gcc/include*/ -type l -delete
1777 # Copy over the info pages. We disabled their generation earlier, but the
1778 # build system only expects to install out of the build dir, not the source. #464008
1781 for x in "${S}"/gcc/doc/*.info* ; do
1782 if [[ -f ${x} ]] ; then
1783 cp "${x}" gcc/doc/ || die
1787 # We remove the generated fixincludes, as they can cause things to break
1788 # (ncurses, openssl, etc). We do not prevent them from being built, as
1789 # in the following commit which we revert:
1790 # https://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/eclass/toolchain.eclass?r1=1.647&r2=1.648
1791 # This is because bsd userland needs fixedincludes to build gcc, while
1792 # linux does not. Both can dispose of them afterwards.
1794 grep -q 'It has been auto-edited by fixincludes from' "${x}" \
1796 done < <(find gcc/include*/ -name '*.h')
1798 # Do the 'make install' from the build directory
1799 S="${WORKDIR}"/build emake -j1 DESTDIR="${D}" install || die
1801 # Punt some tools which are really only useful while building gcc
1802 find "${ED}" -name install-tools -prune -type d -exec rm -rf "{}" \;
1803 # This one comes with binutils
1804 find "${ED}" -name libiberty.a -delete
1806 # Move the libraries to the proper location
1809 # Basic sanity check
1810 if ! is_crosscompile ; then
1812 eval $(grep ^EXEEXT= "${WORKDIR}"/build/gcc/config.log)
1813 [[ -r ${D}${BINPATH}/gcc${EXEEXT} ]] || die "gcc not found in ${ED}"
1816 dodir /etc/env.d/gcc
1817 create_gcc_env_entry
1819 # Setup the gcc_env_entry for hardened gcc 4 with minispecs
1820 want_minispecs && copy_minispecs_gcc_specs
1822 # Make sure we dont have stuff lying around that
1823 # can nuke multiple versions of gcc
1828 # Ugh: we really need to auto-detect this list.
1829 # It's constantly out of date.
1830 for x in cpp gcc g++ c++ gcov g77 gcj gcjh gfortran gccgo ; do
1831 # For some reason, g77 gets made instead of ${CTARGET}-g77...
1832 # this should take care of that
1833 if [[ -f ${x} ]] ; then
1834 # In case they're hardlinks, clear out the target first
1835 # otherwise the mv below will complain.
1836 rm -f ${CTARGET}-${x}
1837 mv ${x} ${CTARGET}-${x}
1840 if [[ -f ${CTARGET}-${x} ]] ; then
1841 if ! is_crosscompile ; then
1842 ln -sf ${CTARGET}-${x} ${x}
1843 dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1844 /usr/bin/${x}-${GCC_CONFIG_VER}
1846 # Create versioned symlinks
1847 dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1848 /usr/bin/${CTARGET}-${x}-${GCC_CONFIG_VER}
1851 if [[ -f ${CTARGET}-${x}-${GCC_CONFIG_VER} ]] ; then
1852 rm -f ${CTARGET}-${x}-${GCC_CONFIG_VER}
1853 ln -sf ${CTARGET}-${x} ${CTARGET}-${x}-${GCC_CONFIG_VER}
1857 # When gcc builds a crosscompiler it does not install unprefixed tools.
1858 # When cross-building gcc does install native tools.
1859 if ! is_crosscompile; then
1860 # Rename the main go binaries as we don't want to clobber dev-lang/go
1861 # when gcc-config runs. #567806
1862 if tc_version_is_at_least 5 && is_go ; then
1863 for x in go gofmt; do
1864 mv ${x} ${x}-${GCCMAJOR} || die
1869 # TODO: implement stripping (we use RESTRICT=strip)
1870 # As gcc installs object files both build against ${CHOST} and ${CTARGET}
1871 # we will ned to run stripping using different tools:
1872 # Using ${CHOST} tools:
1873 # - "${D}${BINPATH}"
1874 # - (for is_crosscompile) "${D}${HOSTLIBPATH}"
1875 # - "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}"
1876 # Using ${CTARGET} tools:
1877 # - "${D}${LIBPATH}"
1880 if is_crosscompile; then
1881 rm -rf "${ED}"/usr/share/{man,info}
1882 rm -rf "${D}"${DATAPATH}/{man,info}
1884 if tc_version_is_at_least 3.0 ; then
1885 local cxx_mandir=$(find "${WORKDIR}/build/${CTARGET}/libstdc++-v3" -name man)
1886 if [[ -d ${cxx_mandir} ]] ; then
1887 cp -r "${cxx_mandir}"/man? "${D}${DATAPATH}"/man/
1892 # portage regenerates 'dir' files on it's own: bug #672408
1893 # Drop 'dir' files to avoid collisions.
1894 if [[ -f "${D}${DATAPATH}"/info/dir ]]; then
1895 einfo "Deleting '${D}${DATAPATH}/info/dir'"
1896 rm "${D}${DATAPATH}"/info/dir || die
1899 # prune empty dirs left behind
1900 find "${ED}" -depth -type d -delete 2>/dev/null
1902 # install testsuite results
1903 if use ${GCC_EBUILD_TEST_FLAG}; then
1905 find "${WORKDIR}"/build -type f -name "*.sum" -exec dodoc {} +
1906 find "${WORKDIR}"/build -type f -path "*/testsuite/*.log" -exec dodoc {} +
1909 # Rather install the script, else portage with changing $FILESDIR
1910 # between binary and source package borks things ....
1911 if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
1912 insinto "${DATAPATH#${EPREFIX}}"
1913 newins "$(prefixify_ro "${FILESDIR}"/awk/fixlafiles.awk-no_gcc_la)" fixlafiles.awk || die
1914 exeinto "${DATAPATH#${EPREFIX}}"
1915 doexe "$(prefixify_ro "${FILESDIR}"/fix_libtool_files.sh)" || die
1916 doexe "${FILESDIR}"/c{89,99} || die
1919 # libstdc++.la: Delete as it doesn't add anything useful: g++ itself
1920 # handles linkage correctly in the dynamic & static case. It also just
1921 # causes us pain: any C++ progs/libs linking with libtool will gain a
1922 # reference to the full libstdc++.la file which is gcc version specific.
1923 # libstdc++fs.la: It doesn't link against anything useful.
1924 # libsupc++.la: This has no dependencies.
1925 # libcc1.la: There is no static library, only dynamic.
1926 # libcc1plugin.la: Same as above, and it's loaded via dlopen.
1927 # libcp1plugin.la: Same as above, and it's loaded via dlopen.
1928 # libgomp.la: gcc itself handles linkage (libgomp.spec).
1929 # libgomp-plugin-*.la: Same as above, and it's an internal plugin only
1930 # loaded via dlopen.
1931 # libgfortran.la: gfortran itself handles linkage correctly in the
1932 # dynamic & static case (libgfortran.spec). #573302
1933 # libgfortranbegin.la: Same as above, and it's an internal lib.
1934 # libmpx.la: gcc itself handles linkage correctly (libmpx.spec).
1935 # libmpxwrappers.la: See above.
1936 # libitm.la: gcc itself handles linkage correctly (libitm.spec).
1937 # libvtv.la: gcc itself handles linkage correctly.
1938 # lib*san.la: Sanitizer linkage is handled internally by gcc, and they
1939 # do not support static linking. #487550 #546700
1940 find "${D}${LIBPATH}" \
1942 -name libstdc++.la -o \
1943 -name libstdc++fs.la -o \
1944 -name libsupc++.la -o \
1945 -name libcc1.la -o \
1946 -name libcc1plugin.la -o \
1947 -name libcp1plugin.la -o \
1948 -name 'libgomp.la' -o \
1949 -name 'libgomp-plugin-*.la' -o \
1950 -name libgfortran.la -o \
1951 -name libgfortranbegin.la -o \
1952 -name libmpx.la -o \
1953 -name libmpxwrappers.la -o \
1954 -name libitm.la -o \
1955 -name libvtv.la -o \
1956 -name 'lib*san.la' \
1959 # Use gid of 0 because some stupid ports don't have
1960 # the group 'root' set to gid 0. Send to /dev/null
1961 # for people who are testing as non-root.
1962 chown -R root:0 "${D}${LIBPATH}" 2>/dev/null
1964 # Move pretty-printers to gdb datadir to shut ldconfig up
1965 local py gdbdir=/usr/share/gdb/auto-load${LIBPATH/\/lib\//\/$(get_libdir)\/}
1966 pushd "${D}${LIBPATH}" >/dev/null
1967 for py in $(find . -name '*-gdb.py') ; do
1968 local multidir=${py%/*}
1969 insinto "${gdbdir}/${multidir}"
1970 sed -i "/^libdir =/s:=.*:= '${LIBPATH}/${multidir}':" "${py}" || die #348128
1971 doins "${py}" || die
1976 # Don't scan .gox files for executable stacks - false positives
1977 export QA_EXECSTACK="usr/lib*/go/*/*.gox"
1978 export QA_WX_LOAD="usr/lib*/go/*/*.gox"
1980 # Disable RANDMMAP so PCH works. #301299
1981 if tc_version_is_at_least 4.3 ; then
1982 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1"
1983 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1plus"
1986 # Disable MPROTECT so java works. #574808
1988 pax-mark -m "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/ecj1"
1989 pax-mark -m "${D}${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}/gij"
1993 # Move around the libs to the right location. For some reason,
1994 # when installing gcc, it dumps internal libraries into /usr/lib
1995 # instead of the private gcc lib path
1997 # older versions of gcc did not support --print-multi-os-directory
1998 tc_version_is_at_least 3.2 || return 0
2000 # For non-target libs which are for CHOST and not CTARGET, we want to
2001 # move them to the compiler-specific CHOST internal dir. This is stuff
2002 # that you want to link against when building tools rather than building
2003 # code to run on the target.
2004 if tc_version_is_at_least 5 && is_crosscompile ; then
2005 dodir "${HOSTLIBPATH#${EPREFIX}}"
2006 mv "${ED}"/usr/$(get_libdir)/libcc1* "${D}${HOSTLIBPATH}" || die
2009 # For all the libs that are built for CTARGET, move them into the
2010 # compiler-specific CTARGET internal dir.
2011 local x multiarg removedirs=""
2012 for multiarg in $($(XGCC) -print-multi-lib) ; do
2013 multiarg=${multiarg#*;}
2014 multiarg=${multiarg//@/ -}
2016 local OS_MULTIDIR=$($(XGCC) ${multiarg} --print-multi-os-directory)
2017 local MULTIDIR=$($(XGCC) ${multiarg} --print-multi-directory)
2018 local TODIR="${D}${LIBPATH}"/${MULTIDIR}
2021 [[ -d ${TODIR} ]] || mkdir -p ${TODIR}
2024 "${LIBPATH}"/${OS_MULTIDIR} \
2025 "${LIBPATH}"/../${MULTIDIR} \
2026 "${PREFIX}"/lib/${OS_MULTIDIR} \
2027 "${PREFIX}"/${CTARGET}/lib/${OS_MULTIDIR}
2029 removedirs="${removedirs} ${FROMDIR}"
2030 FROMDIR=${D}${FROMDIR}
2031 if [[ ${FROMDIR} != "${TODIR}" && -d ${FROMDIR} ]] ; then
2032 local files=$(find "${FROMDIR}" -maxdepth 1 ! -type d 2>/dev/null)
2033 if [[ -n ${files} ]] ; then
2034 mv ${files} "${TODIR}" || die
2038 fix_libtool_libdir_paths "${LIBPATH}/${MULTIDIR}"
2040 # SLOT up libgcj.pc if it's available (and let gcc-config worry about links)
2041 FROMDIR="${PREFIX}/lib/${OS_MULTIDIR}"
2042 for x in "${D}${FROMDIR}"/pkgconfig/libgcj*.pc ; do
2043 [[ -f ${x} ]] || continue
2044 sed -i "/^libdir=/s:=.*:=${LIBPATH}/${MULTIDIR}:" "${x}" || die
2045 mv "${x}" "${D}${FROMDIR}"/pkgconfig/libgcj-${GCC_PV}.pc || die
2049 # We remove directories separately to avoid this case:
2050 # mv SRC/lib/../lib/*.o DEST
2051 # rmdir SRC/lib/../lib/
2052 # mv SRC/lib/../lib32/*.o DEST # Bork
2053 for FROMDIR in ${removedirs} ; do
2054 rmdir "${D}"${FROMDIR} >& /dev/null
2056 find -depth "${ED}" -type d -exec rmdir {} + >& /dev/null
2059 # make sure the libtool archives have libdir set to where they actually
2060 # -are-, and not where they -used- to be. also, any dependencies we have
2061 # on our own .la files need to be updated.
2062 fix_libtool_libdir_paths() {
2065 pushd "${D}" >/dev/null
2067 pushd "./${libpath}" >/dev/null
2068 local dir="${PWD#${D%/}}"
2069 local allarchives=$(echo *.la)
2070 allarchives="\(${allarchives// /\\|}\)"
2073 # The libdir might not have any .la files. #548782
2074 find "./${dir}" -maxdepth 1 -name '*.la' \
2075 -exec sed -i -e "/^libdir=/s:=.*:='${dir}':" {} + || die
2076 # Would be nice to combine these, but -maxdepth can not be specified
2077 # on sub-expressions.
2078 find "./${PREFIX}"/lib* -maxdepth 3 -name '*.la' \
2079 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2080 find "./${dir}/" -maxdepth 1 -name '*.la' \
2081 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2086 create_gcc_env_entry() {
2087 dodir /etc/env.d/gcc
2088 local gcc_envd_base="/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}"
2090 local gcc_specs_file
2091 local gcc_envd_file="${ED}${gcc_envd_base}"
2092 if [[ -z $1 ]] ; then
2093 # I'm leaving the following commented out to remind me that it
2094 # was an insanely -bad- idea. Stuff broke. GCC_SPECS isnt unset
2095 # on chroot or in non-toolchain.eclass gcc ebuilds!
2096 #gcc_specs_file="${LIBPATH}/specs"
2099 gcc_envd_file+="-$1"
2100 gcc_specs_file="${LIBPATH}/$1.specs"
2103 # We want to list the default ABI's LIBPATH first so libtool
2104 # searches that directory first. This is a temporary
2105 # workaround for libtool being stupid and using .la's from
2106 # conflicting ABIs by using the first one in the search path
2107 local ldpaths mosdirs
2108 if tc_version_is_at_least 3.2 ; then
2109 local mdir mosdir abi ldpath
2110 for abi in $(get_all_abis TARGET) ; do
2111 mdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) --print-multi-directory)
2113 [[ ${mdir} != "." ]] && ldpath+="/${mdir}"
2114 ldpaths="${ldpath}${ldpaths:+:${ldpaths}}"
2116 mosdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) -print-multi-os-directory)
2117 mosdirs="${mosdir}${mosdirs:+:${mosdirs}}"
2120 # Older gcc's didn't do multilib, so logic is simple.
2124 cat <<-EOF > ${gcc_envd_file}
2126 ROOTPATH="${BINPATH}"
2127 GCC_PATH="${BINPATH}"
2129 MANPATH="${DATAPATH}/man"
2130 INFOPATH="${DATAPATH}/info"
2131 STDCXX_INCDIR="${STDCXX_INCDIR##*/}"
2132 CTARGET="${CTARGET}"
2133 GCC_SPECS="${gcc_specs_file}"
2134 MULTIOSDIRS="${mosdirs}"
2138 copy_minispecs_gcc_specs() {
2139 # on gcc 6 we don't need minispecs
2140 if tc_version_is_at_least 6.0 ; then
2144 # setup the hardenedno* specs files and the vanilla specs file.
2145 if hardened_gcc_works ; then
2146 create_gcc_env_entry hardenednopiessp
2148 if hardened_gcc_works pie ; then
2149 create_gcc_env_entry hardenednopie
2151 if hardened_gcc_works ssp ; then
2152 create_gcc_env_entry hardenednossp
2154 create_gcc_env_entry vanilla
2155 insinto ${LIBPATH#${EPREFIX}}
2156 doins "${WORKDIR}"/specs/*.specs || die "failed to install specs"
2157 # Build system specs file which, if it exists, must be a complete set of
2158 # specs as it completely and unconditionally overrides the builtin specs.
2159 if ! tc_version_is_at_least 4.4 ; then
2160 $(XGCC) -dumpspecs > "${WORKDIR}"/specs/specs
2161 cat "${WORKDIR}"/build.specs >> "${WORKDIR}"/specs/specs
2162 doins "${WORKDIR}"/specs/specs || die "failed to install the specs file"
2169 # Move Java headers to compiler-specific dir
2170 for x in "${D}${PREFIX}"/include/gc*.h "${D}${PREFIX}"/include/j*.h ; do
2171 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/include/
2173 for x in gcj gnu java javax org ; do
2174 if [[ -d ${D}${PREFIX}/include/${x} ]] ; then
2175 dodir /${LIBPATH#${EPREFIX}}/include/${x}
2176 mv -f "${D}${PREFIX}"/include/${x}/* "${D}${LIBPATH}"/include/${x}/
2177 rm -rf "${D}${PREFIX}"/include/${x}
2181 if [[ -d ${D}${PREFIX}/lib/security ]] || [[ -d ${D}${PREFIX}/$(get_libdir)/security ]] ; then
2182 dodir /${LIBPATH#${EPREFIX}}/security
2183 mv -f "${D}${PREFIX}"/lib*/security/* "${D}${LIBPATH}"/security
2184 rm -rf "${D}${PREFIX}"/lib*/security
2187 # Move random gcj files to compiler-specific directories
2188 for x in libgcj.spec logging.properties ; do
2189 x="${D}${PREFIX}/lib/${x}"
2190 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/
2193 # Rename jar because it could clash with Kaffe's jar if this gcc is
2194 # primary compiler (aka don't have the -<version> extension)
2196 [[ -f jar ]] && mv -f jar gcj-jar
2199 #---->> pkg_post* <<----
2201 toolchain_pkg_postinst() {
2203 if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2204 eselect compiler-shadow update all
2207 if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
2209 ewarn "If you have issues with packages unable to locate libstdc++.la,"
2210 ewarn "then try running 'fix_libtool_files.sh' on the old gcc versions."
2212 ewarn "You might want to review the GCC upgrade guide when moving between"
2213 ewarn "major versions (like 4.2 to 4.3):"
2214 ewarn "https://wiki.gentoo.org/wiki/Upgrading_GCC"
2217 # Clean up old paths
2218 rm -f "${EROOT%/}"/*/rcscripts/awk/fixlafiles.awk "${EROOT%/}"/sbin/fix_libtool_files.sh
2219 rmdir "${EROOT%/}"/*/rcscripts{/awk,} 2>/dev/null
2221 mkdir -p "${EROOT%/}"/usr/{share/gcc-data,sbin,bin}
2222 # DATAPATH has EPREFIX already, use ROOT with it
2223 cp "${ROOT%/}${DATAPATH}"/fixlafiles.awk "${EROOT%/}"/usr/share/gcc-data/ || die
2224 cp "${ROOT%/}${DATAPATH}"/fix_libtool_files.sh "${EROOT%/}"/usr/sbin/ || die
2226 # Since these aren't critical files and portage sucks with
2227 # handling of binpkgs, don't require these to be found
2228 cp "${ROOT%/}${DATAPATH}"/c{89,99} "${EROOT%/}"/usr/bin/ 2>/dev/null
2231 if use ${GCC_EBUILD_TEST_FLAG} ; then
2232 elog "Testsuite results have been installed into /usr/share/doc/${PF}/testsuite"
2236 if [[ -n ${PRERELEASE}${SNAPSHOT} ]] ; then
2237 einfo "This GCC ebuild is provided for your convenience, and the use"
2238 einfo "of this compiler is not supported by the Gentoo Developers."
2239 einfo "Please report bugs to upstream at http://gcc.gnu.org/bugzilla/"
2243 toolchain_pkg_postrm() {
2244 if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2245 eselect compiler-shadow clean all
2248 # to make our lives easier (and saner), we do the fix_libtool stuff here.
2249 # rather than checking SLOT's and trying in upgrade paths, we just see if
2250 # the common libstdc++.la exists in the ${LIBPATH} of the gcc that we are
2251 # unmerging. if it does, that means this was a simple re-emerge.
2253 # clean up the cruft left behind by cross-compilers
2254 if is_crosscompile ; then
2255 if [[ -z $(ls "${EROOT%/}"/etc/env.d/gcc/${CTARGET}* 2>/dev/null) ]] ; then
2256 rm -f "${EROOT%/}"/etc/env.d/gcc/config-${CTARGET}
2257 rm -f "${EROOT%/}"/etc/env.d/??gcc-${CTARGET}
2258 rm -f "${EROOT%/}"/usr/bin/${CTARGET}-{gcc,{g,c}++}{,32,64}
2263 # ROOT isnt handled by the script
2264 [[ ${ROOT%/} ]] && return 0
2266 if [[ ! -e ${LIBPATH}/libstdc++.so ]] ; then
2267 # make sure the profile is sane during same-slot upgrade #289403
2270 einfo "Running 'fix_libtool_files.sh ${GCC_RELEASE_VER}'"
2271 fix_libtool_files.sh ${GCC_RELEASE_VER}
2272 if [[ -n ${BRANCH_UPDATE} ]] ; then
2273 einfo "Running 'fix_libtool_files.sh ${GCC_RELEASE_VER}-${BRANCH_UPDATE}'"
2274 fix_libtool_files.sh ${GCC_RELEASE_VER}-${BRANCH_UPDATE}
2282 if ! should_we_gcc_config ; then
2283 gcc-config --use-old --force
2287 local current_gcc_config target
2289 current_gcc_config=$(gcc-config -c ${CTARGET} 2>/dev/null)
2290 if [[ -n ${current_gcc_config} ]] ; then
2291 local current_specs use_specs
2292 # figure out which specs-specific config is active
2293 current_specs=$(gcc-config -S ${current_gcc_config} | awk '{print $3}')
2294 [[ -n ${current_specs} ]] && use_specs=-${current_specs}
2296 if [[ -n ${use_specs} ]] && \
2297 [[ ! -e ${EROOT%/}/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}${use_specs} ]]
2299 ewarn "The currently selected specs-specific gcc config,"
2300 ewarn "${current_specs}, doesn't exist anymore. This is usually"
2301 ewarn "due to enabling/disabling hardened or switching to a version"
2302 ewarn "of gcc that doesnt create multiple specs files. The default"
2303 ewarn "config will be used, and the previous preference forgotten."
2307 target="${CTARGET}-${GCC_CONFIG_VER}${use_specs}"
2309 # The curent target is invalid. Attempt to switch to a valid one.
2310 # Blindly pick the latest version. #529608
2311 # TODO: Should update gcc-config to accept `-l ${CTARGET}` rather than
2312 # doing a partial grep like this.
2313 target=$(gcc-config -l 2>/dev/null | grep " ${CTARGET}-[0-9]" | tail -1 | awk '{print $2}')
2316 gcc-config "${target}"
2319 should_we_gcc_config() {
2320 # if the current config is invalid, we definitely want a new one
2321 # Note: due to bash quirkiness, the following must not be 1 line
2323 curr_config=$(gcc-config -c ${CTARGET} 2>&1) || return 0
2325 # if the previously selected config has the same major.minor (branch) as
2326 # the version we are installing, then it will probably be uninstalled
2327 # for being in the same SLOT, make sure we run gcc-config.
2328 local curr_config_ver=$(gcc-config -S ${curr_config} | awk '{print $2}')
2330 local curr_branch_ver=$(ver_cut 1-2 ${curr_config_ver})
2332 if [[ ${curr_branch_ver} == ${GCC_BRANCH_VER} ]] ; then
2335 # if we're installing a genuinely different compiler version,
2336 # we should probably tell the user -how- to switch to the new
2337 # gcc version, since we're not going to do it for him/her.
2338 # We don't want to switch from say gcc-3.3 to gcc-3.4 right in
2339 # the middle of an emerge operation (like an 'emerge -e world'
2340 # which could install multiple gcc versions).
2341 # Only warn if we're installing a pkg as we might be called from
2342 # the pkg_{pre,post}rm steps. #446830
2343 if [[ ${EBUILD_PHASE} == *"inst" ]] ; then
2344 einfo "The current gcc config appears valid, so it will not be"
2345 einfo "automatically switched for you. If you would like to"
2346 einfo "switch to the newly installed gcc version, do the"
2349 einfo "gcc-config ${CTARGET}-${GCC_CONFIG_VER}"
2350 einfo "source /etc/profile"
2357 #---->> support and misc functions <<----
2359 # This is to make sure we don't accidentally try to enable support for a
2360 # language that doesnt exist. GCC 3.4 supports f77, while 4.0 supports f95, etc.
2362 # Also add a hook so special ebuilds (kgcc64) can control which languages
2363 # exactly get enabled
2364 gcc-lang-supported() {
2365 grep ^language=\"${1}\" "${S}"/gcc/*/config-lang.in > /dev/null || return 1
2366 [[ -z ${TOOLCHAIN_ALLOWED_LANGS} ]] && return 0
2367 has $1 ${TOOLCHAIN_ALLOWED_LANGS}
2371 gcc-lang-supported ada || return 1
2376 gcc-lang-supported 'c++' || return 1
2377 ! is_crosscompile && tc_version_is_at_least 4.8 && return 0
2382 gcc-lang-supported d || return 1
2387 gcc-lang-supported f77 || return 1
2392 gcc-lang-supported f95 || return 1
2397 gcc-lang-supported fortran || return 1
2402 gcc-lang-supported java || return 1
2403 use_if_iuse cxx && use_if_iuse gcj
2407 gcc-lang-supported go || return 1
2408 use_if_iuse cxx && use_if_iuse go
2412 gcc-lang-supported jit || return 1
2413 # cross-compiler does not really support jit as it has
2414 # to generate code for a target. On target like avr
2415 # libgcclit.so can't link at all: bug #594572
2416 is_crosscompile && return 1
2421 tc_version_is_at_least 3 || return 1
2422 use_if_iuse multilib
2426 gcc-lang-supported objc || return 1
2431 gcc-lang-supported 'obj-c++' || return 1
2432 use_if_iuse cxx && use_if_iuse objc++
2435 # Grab a variable from the build system (taken from linux-info.eclass)
2437 local var=$1 makefile=${2:-${WORKDIR}/build/Makefile}
2438 echo -e "e:\\n\\t@echo \$(${var})\\ninclude ${makefile}" | \
2439 r=${makefile%/*} emake --no-print-directory -s -f - 2>/dev/null
2442 XGCC() { get_make_var GCC_FOR_TARGET ; }
2444 # The gentoo piessp patches allow for 3 configurations:
2445 # 1) PIE+SSP by default
2448 hardened_gcc_works() {
2449 if [[ $1 == "pie" ]] ; then
2450 # $gcc_cv_ld_pie is unreliable as it simply take the output of
2451 # `ld --help | grep -- -pie`, that reports the option in all cases, also if
2452 # the loader doesn't actually load the resulting executables.
2453 # To avoid breakage, blacklist FreeBSD here at least
2454 [[ ${CTARGET} == *-freebsd* ]] && return 1
2456 want_pie || return 1
2457 use_if_iuse nopie && return 1
2458 hardened_gcc_is_stable pie
2460 elif [[ $1 == "ssp" ]] ; then
2461 [[ -n ${SPECS_VER} ]] || return 1
2462 use_if_iuse nossp && return 1
2463 hardened_gcc_is_stable ssp
2467 hardened_gcc_works pie || return 1
2468 hardened_gcc_works ssp || return 1
2473 hardened_gcc_is_stable() {
2475 if [[ $1 == "pie" ]] ; then
2476 if [[ ${CTARGET} == *-uclibc* ]] ; then
2477 tocheck=${PIE_UCLIBC_STABLE}
2479 tocheck=${PIE_GLIBC_STABLE}
2481 elif [[ $1 == "ssp" ]] ; then
2482 if [[ ${CTARGET} == *-uclibc* ]] ; then
2483 tocheck=${SSP_UCLIBC_STABLE}
2484 elif [[ ${CTARGET} == *-gnu* ]] ; then
2485 tocheck=${SSP_STABLE}
2488 die "hardened_gcc_stable needs to be called with pie or ssp"
2491 has $(tc-arch) ${tocheck} && return 0
2496 # on gcc 6 we don't need minispecs
2497 if tc_version_is_at_least 6.0 ; then
2500 if tc_version_is_at_least 4.3.2 && use_if_iuse hardened ; then
2501 if ! want_pie ; then
2502 ewarn "PIE_VER or SPECS_VER is not defined in the GCC ebuild."
2503 elif use vanilla ; then
2504 ewarn "You will not get hardened features if you have the vanilla USE-flag."
2505 elif use_if_iuse nopie && use_if_iuse nossp ; then
2506 ewarn "You will not get hardened features if you have the nopie and nossp USE-flag."
2507 elif ! hardened_gcc_works ; then
2508 ewarn "Your $(tc-arch) arch is not supported."
2512 ewarn "Hope you know what you are doing. Hardened will not work."
2519 ! use_if_iuse hardened && [[ -n ${PIE_VER} ]] && use_if_iuse nopie && return 1
2520 [[ -n ${PIE_VER} ]] && [[ -n ${SPECS_VER} ]] && return 0
2521 tc_version_is_at_least 4.3.2 && return 1
2522 [[ -z ${PIE_VER} ]] && return 1
2523 use_if_iuse nopie || return 0
2527 has toolchain_death_notice ${EBUILD_DEATH_HOOKS} || EBUILD_DEATH_HOOKS+=" toolchain_death_notice"
2528 toolchain_death_notice() {
2529 if [[ -e "${WORKDIR}"/build ]] ; then
2530 pushd "${WORKDIR}"/build >/dev/null
2531 (echo '' | $(tc-getCC ${CTARGET}) ${CFLAGS} -v -E - 2>&1) > gccinfo.log
2532 [[ -e "${T}"/build.log ]] && cp "${T}"/build.log .
2533 tar jcf "${WORKDIR}"/gcc-build-logs.tar.bz2 \
2534 gccinfo.log build.log $(find -name config.log)
2535 rm gccinfo.log build.log
2537 eerror "Please include ${WORKDIR}/gcc-build-logs.tar.bz2 in your bug report."
2543 # Note [implicitly enabled flags]
2544 # -------------------------------
2545 # Usually configure-based packages handle explicit feature requests
2547 # ./configure --enable-foo
2548 # as explicit request to check for support of 'foo' and bail out at
2551 # GCC does not follow this pattern and instead overrides autodetection
2552 # of the feature and enables it unconditionally.
2554 # https://gcc.gnu.org/PR85663 (libsanitizer on mips)
2555 # https://bugs.gentoo.org/661252 (libvtv on powerpc64)
2557 # Thus safer way to enable/disable the feature is to rely on implicit
2558 # enabled-by-default state:
2559 # econf $(usex foo '' --disable-foo)