eclass/toolchain.eclass

   1 # Copyright 1999-2019 Gentoo Authors
   2 # Distributed under the terms of the GNU General Public License v2
   3
   4 # Maintainer: Toolchain Ninjas <toolchain@gentoo.org>
   5 # @SUPPORTED_EAPIS: 5 6
   6
   7 DESCRIPTION="The GNU Compiler Collection"
   8 HOMEPAGE="https://gcc.gnu.org/"
   9 RESTRICT="strip" # cross-compilers need controlled stripping
  10
  11 inherit eutils fixheadtails flag-o-matic gnuconfig libtool multilib pax-utils toolchain-funcs prefix
  12
  13 if [[ ${PV} == *_pre9999* ]] ; then
  14         EGIT_REPO_URI="git://gcc.gnu.org/git/gcc.git"
  15         # naming style:
  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//./_}
  22         inherit git-2
  23 fi
  24
  25 FEATURES=${FEATURES/multilib-strict/}
  26
  27 case ${EAPI:-0} in
  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}." ;;
  31 esac
  32 EXPORT_FUNCTIONS pkg_pretend pkg_setup src_unpack src_prepare src_configure \
  33         src_compile src_test src_install pkg_postinst pkg_postrm
  34
  35 #---->> globals <<----
  36
  37 export CTARGET=${CTARGET:-${CHOST}}
  38 if [[ ${CTARGET} = ${CHOST} ]] ; then
  39         if [[ ${CATEGORY} == cross-* ]] ; then
  40                 export CTARGET=${CATEGORY#cross-}
  41         fi
  42 fi
  43 : ${TARGET_ABI:=${ABI}}
  44 : ${TARGET_MULTILIB_ABIS:=${MULTILIB_ABIS}}
  45 : ${TARGET_DEFAULT_ABI:=${DEFAULT_ABI}}
  46
  47 is_crosscompile() {
  48         [[ ${CHOST} != ${CTARGET} ]]
  49 }
  50
  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"
  54 }
  55
  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}"
  60 }
  61
  62 GCC_PV=${TOOLCHAIN_GCC_PV:-${PV}}
  63 GCC_PVR=${GCC_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})
  72
  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})}
  76
  77 # Pre-release support
  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}
  86 fi
  87
  88 if [[ ${SNAPSHOT} == [56789].0-* ]] ; then
  89         # The gcc-5+ releases have dropped the .0 for some reason.
  90         SNAPSHOT=${SNAPSHOT/.0}
  91 fi
  92
  93 PREFIX=${TOOLCHAIN_PREFIX:-${EPREFIX}/usr}
  94
  95 if tc_version_is_at_least 3.4.0 ; then
  96         LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc/${CTARGET}/${GCC_CONFIG_VER}}
  97 else
  98         LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc-lib/${CTARGET}/${GCC_CONFIG_VER}}
  99 fi
 100 INCLUDEPATH=${TOOLCHAIN_INCLUDEPATH:-${LIBPATH}/include}
 101
 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}
 105 else
 106         BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}}
 107 fi
 108
 109 DATAPATH=${TOOLCHAIN_DATAPATH:-${PREFIX}/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}}
 110
 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/\.*/}}
 114
 115 #---->> LICENSE+SLOT+IUSE logic <<----
 116
 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+"
 127 else
 128         LICENSE="GPL-2+ LGPL-2.1+ FDL-1.1+"
 129 fi
 130
 131 if tc_version_is_at_least 8.3; then
 132         GCC_EBUILD_TEST_FLAG='test'
 133 else
 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'
 138 fi
 139 IUSE="${GCC_EBUILD_TEST_FLAG} vanilla +nls +nptl"
 140
 141 TC_FEATURES=()
 142
 143 tc_has_feature() {
 144         has "$1" "${TC_FEATURES[@]}"
 145 }
 146
 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"
 178 fi
 179
 180 SLOT="${GCC_CONFIG_VER}"
 181
 182 #---->> DEPEND <<----
 183
 184 RDEPEND="sys-libs/zlib
 185         nls? ( virtual/libintl )"
 186
 187 tc_version_is_at_least 3 && RDEPEND+=" virtual/libiconv"
 188
 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} )"
 195         fi
 196 fi
 197
 198 tc_version_is_at_least 4.5 && RDEPEND+=" >=dev-libs/mpc-0.8.1:0="
 199
 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 )"
 203         fi
 204 fi
 205
 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
 210                 RDEPEND+="
 211                         graphite? (
 212                                 >=dev-libs/cloog-0.18.0:0=
 213                                 >=dev-libs/isl-0.11.1:0=
 214                         )"
 215         fi
 216 fi
 217
 218 DEPEND="${RDEPEND}
 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
 225         )"
 226
 227 if tc_has_feature gcj ; then
 228         GCJ_DEPS=">=media-libs/libart_lgpl-2.1"
 229         GCJ_GTK_DEPS="
 230                 x11-base/xorg-proto
 231                 x11-libs/libXt
 232                 x11-libs/libX11
 233                 x11-libs/libXtst
 234                 =x11-libs/gtk+-2*
 235                 virtual/pkgconfig
 236         "
 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} )"
 240 fi
 241
 242 if tc_has_feature systemtap ; then
 243         # gcc needs sys/sdt.h headers on target
 244         DEPEND+=" systemtap? ( dev-util/systemtap )"
 245 fi
 246
 247 PDEPEND=">=sys-devel/gcc-config-1.7"
 248
 249 #---->> S + SRC_URI essentials <<----
 250
 251 # Set the source directory depending on whether we're using
 252 # a prerelease, snapshot, or release tarball.
 253 S=$(
 254         if [[ -n ${PRERELEASE} ]] ; then
 255                 echo ${WORKDIR}/gcc-${PRERELEASE}
 256         elif [[ -n ${SNAPSHOT} ]] ; then
 257                 echo ${WORKDIR}/gcc-${SNAPSHOT}
 258         else
 259                 echo ${WORKDIR}/gcc-${GCC_RELEASE_VER}
 260         fi
 261 )
 262
 263 gentoo_urls() {
 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}
 269 }
 270
 271 # This function handles the basics of setting the SRC_URI for a gcc ebuild.
 272 # To use, set SRC_URI with:
 273 #
 274 #       SRC_URI="$(get_gcc_src_uri)"
 275 #
 276 # Other than the variables normally set by portage, this function's behavior
 277 # can be altered by setting the following:
 278 #
 279 #       SNAPSHOT
 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.
 284 #
 285 #       BRANCH_UPDATE
 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
 291 #                       has a _pre suffix.
 292 #
 293 #       PATCH_VER
 294 #       PATCH_GCC_VER
 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
 298 #
 299 #       PIE_VER
 300 #       PIE_GCC_VER
 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
 304 #                       the patch:
 305 #                       An example:
 306 #                                       PIE_VER="8.7.6.5"
 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
 310 #
 311 #       SPECS_VER
 312 #       SPECS_GCC_VER
 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.
 317 #                       An example:
 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
 322 #
 323 #       HTB_VER
 324 #       HTB_GCC_VER
 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.
 329 #
 330 #       CYGWINPORTS_GITREV
 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.
 337 get_gcc_src_uri() {
 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}}
 343
 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.
 348                 :
 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"
 354                 else
 355                         GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.bz2"
 356                 fi
 357         else
 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"
 360                 else
 361                         GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.bz2"
 362                 fi
 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)"
 366         fi
 367
 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)"
 372
 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})"
 377
 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)"
 381
 382         # gcc bounds checking patch
 383         if [[ -n ${HTB_VER} ]] ; then
 384                 local HTBFILE="bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
 385                 GCC_SRC_URI+="
 386                         boundschecking? (
 387                                 mirror://sourceforge/boundschecking/${HTBFILE}
 388                                 $(gentoo_urls ${HTBFILE})
 389                         )"
 390         fi
 391
 392         [[ -n ${D_VER} ]] && \
 393                 GCC_SRC_URI+=" d? ( mirror://sourceforge/dgcc/gdc-${D_VER}-src.tar.bz2 )"
 394
 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 )"
 400                 fi
 401         fi
 402
 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 )"
 407
 408         echo "${GCC_SRC_URI}"
 409 }
 410
 411 SRC_URI=$(get_gcc_src_uri)
 412
 413 #---->> pkg_pretend <<----
 414
 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."
 420         fi
 421
 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"'
 426         fi
 427
 428         want_minispecs
 429 }
 430
 431 #---->> pkg_setup <<----
 432
 433 toolchain_pkg_setup() {
 434         # we dont want to use the installed compiler's specs to build gcc
 435         unset GCC_SPECS
 436         unset LANGUAGES #265283
 437 }
 438
 439 #---->> src_unpack <<----
 440
 441 toolchain_src_unpack() {
 442         if [[ ${PV} == *9999* ]]; then
 443                 git-2_src_unpack
 444         else
 445                 gcc_quick_unpack
 446         fi
 447 }
 448
 449 gcc_quick_unpack() {
 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}}
 456
 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
 464                 else
 465                         unpack gcc-${SNAPSHOT}.tar.bz2
 466                 fi
 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
 470                 else
 471                         unpack gcc-${GCC_RELEASE_VER}.tar.bz2
 472                 fi
 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
 477                         popd > /dev/null
 478                 fi
 479         fi
 480
 481         if [[ -n ${D_VER} ]] && use d ; then
 482                 pushd "${S}"/gcc > /dev/null
 483                 unpack gdc-${D_VER}-src.tar.bz2
 484                 cd ..
 485                 ebegin "Adding support for the D language"
 486                 ./gcc/d/setup-gcc.sh >& "${T}"/dgcc.log
 487                 if ! eend $? ; then
 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"
 492                 fi
 493                 popd > /dev/null
 494         fi
 495
 496         [[ -n ${PATCH_VER} ]] && \
 497                 unpack gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2
 498
 499         [[ -n ${UCLIBC_VER} ]] && \
 500                 unpack gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2
 501
 502         if want_pie ; then
 503                 if [[ -n ${PIE_CORE} ]] ; then
 504                         unpack ${PIE_CORE}
 505                 else
 506                         unpack gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2
 507                 fi
 508                 [[ -n ${SPECS_VER} ]] && \
 509                         unpack gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2
 510         fi
 511
 512         use_if_iuse boundschecking && unpack "bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
 513
 514         [[ -n ${CYGWINPORTS_GITREV} ]] && use elibc_Cygwin && unpack "gcc-cygwinports-${CYGWINPORTS_GITREV}.tar.gz"
 515
 516         popd > /dev/null
 517 }
 518
 519 #---->> src_prepare <<----
 520
 521 toolchain_src_prepare() {
 522         export BRANDING_GCC_PKGVERSION="Gentoo ${GCC_PVR}"
 523         cd "${S}"
 524
 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}"
 531                 fi
 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
 536                 fi
 537         fi
 538         do_gcc_HTB_patches
 539         do_gcc_PIE_patches
 540         do_gcc_CYGWINPORTS_patches
 541
 542         case ${EAPI:-0} in
 543                 5*) epatch_user;;
 544                 6) eapply_user ;;
 545                 *) die "Update toolchain_src_prepare() for ${EAPI}." ;;
 546         esac
 547
 548         if ( tc_version_is_at_least 4.8.2 || use_if_iuse hardened ) && ! use vanilla ; then
 549                 make_gcc_hard
 550         fi
 551
 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
 555                 sed -i \
 556                         '/^pythondir =/s:=.*:= $(datadir)/python:' \
 557                         "${S}"/libstdc++-v3/python/Makefile.in || die
 558         fi
 559
 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:' {} +
 565
 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
 568                 fix_files=""
 569                 for x in contrib/test_summary libstdc++-v3/scripts/check_survey.in ; do
 570                         [[ -e ${x} ]] && fix_files="${fix_files} ${x}"
 571                 done
 572                 ht_fix_file ${fix_files} */configure *.sh */Makefile.in
 573         fi
 574
 575         setup_multilib_osdirnames
 576         gcc_version_patch
 577
 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
 586                 fi
 587         fi
 588
 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
 594                 else
 595                         einfo "Copying ecj-4.3.jar"
 596                         cp -pPR "${DISTDIR}/ecj-4.3.jar" "${S}/ecj.jar" || die
 597                 fi
 598         fi
 599
 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
 605         fi
 606
 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
 611         fi
 612
 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
 617         fi
 618
 619         # Fixup libtool to correctly generate .la files with portage
 620         elibtoolize --portage --shallow --no-uclibc
 621
 622         gnuconfig_update
 623
 624         # update configure files
 625         local f
 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"
 631                 eend $?
 632         done
 633         sed -i 's|A-Za-z0-9|[:alnum:]|g' "${S}"/gcc/*.awk #215828
 634
 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
 637
 638         if [[ -x contrib/gcc_update ]] ; then
 639                 einfo "Touching generated files"
 640                 ./contrib/gcc_update --touch | \
 641                         while read f ; do
 642                                 einfo "  ${f%%...}"
 643                         done
 644         fi
 645 }
 646
 647 guess_patch_type_in_dir() {
 648         [[ -n $(ls "$1"/*.bz2 2>/dev/null) ]] \
 649                 && EPATCH_SUFFIX="patch.bz2" \
 650                 || EPATCH_SUFFIX="patch"
 651 }
 652
 653 do_gcc_HTB_patches() {
 654         use_if_iuse boundschecking || return 0
 655
 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}"
 659 }
 660
 661 do_gcc_PIE_patches() {
 662         want_pie || return 0
 663         use vanilla && return 0
 664
 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/
 669         else
 670                 guess_patch_type_in_dir "${WORKDIR}"/piepatch/upstream
 671
 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
 681         fi
 682
 683         BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, pie-${PIE_VER}"
 684 }
 685
 686 do_gcc_CYGWINPORTS_patches() {
 687         [[ -n ${CYGWINPORTS_GITREV} ]] || return 0
 688         use elibc_Cygwin || return 0
 689
 690         local p d="${WORKDIR}/gcc-${CYGWINPORTS_GITREV}"
 691         # readarray -t is available since bash-4.4 only, #690686
 692         local patches=( $(sed -e '1,/PATCH_URI="/d;/"/,$d' < "${d}"/gcc.cygport) )
 693         for p in ${patches[*]}; do
 694                 epatch "${d}/${p}"
 695         done
 696 }
 697
 698 # configure to build with the hardened GCC specs as the default
 699 make_gcc_hard() {
 700
 701         local gcc_hard_flags=""
 702
 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
 708         fi
 709
 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 ..."
 714                 fi
 715                 if use_if_iuse ssp ; then
 716                         einfo "Updating gcc to use automatic SSP building ..."
 717                 fi
 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}
 723                 fi
 724         else
 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"
 739                         else
 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"
 742                                 return 0
 743                         fi
 744                 else
 745                         if hardened_gcc_works ssp ; then
 746                                 einfo "Updating gcc to use automatic SSP building ..."
 747                                 gcc_hard_flags+=" -DEFAULT_SSP"
 748                         fi
 749                 fi
 750         fi
 751
 752         # we want to be able to control the pie patch logic via something other
 753         # than ALL_CFLAGS...
 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
 762         fi
 763
 764         sed -i \
 765                 -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \
 766                 "${S}"/gcc/Makefile.in || die
 767
 768 }
 769
 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.
 778 #
 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
 786
 787         local config
 788         local libdirs="../lib64 ../lib32"
 789
 790         # this only makes sense for some Linux targets
 791         case ${CTARGET} in
 792         x86_64*-linux*)    config="i386" ;;
 793         powerpc64*-linux*) config="rs6000" ;;
 794         sparc64*-linux*)   config="sparc" ;;
 795         s390x*-linux*)     config="s390" ;;
 796         *)                     return 0 ;;
 797         esac
 798         config+="/t-linux64"
 799
 800         local sed_args=()
 801         if tc_version_is_at_least 4.6 ; then
 802                 sed_args+=( -e 's:$[(]call if_multiarch[^)]*[)]::g' )
 803         fi
 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:' )
 808                 else
 809                         sed_args+=( -e "/^MULTILIB_OSDIRNAMES/s:=.*:= ${libdirs}:" )
 810                 fi
 811         else
 812                 einfo "using upstream multilib; disabling lib32 autodetection"
 813                 sed_args+=( -r -e 's:[$][(]if.*,(.*)[)]:\1:' )
 814         fi
 815         sed -i "${sed_args[@]}" "${S}"/gcc/config/${config} || die
 816 }
 817
 818 gcc_version_patch() {
 819         # gcc-4.3+ has configure flags (whoo!)
 820         tc_version_is_at_least 4.3 && return 0
 821
 822         local version_string=${GCC_CONFIG_VER}
 823         [[ -n ${BRANCH_UPDATE} ]] && version_string+=" ${BRANCH_UPDATE}"
 824
 825         einfo "patching gcc version: ${version_string} (${BRANDING_GCC_PKGVERSION})"
 826
 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})\":" )
 830         else
 831                 version_string="${version_string} (${BRANDING_GCC_PKGVERSION})"
 832                 gcc_sed+=( -e "/const char version_string\[\] = /s:= \".*\":= \"${version_string}\":" )
 833         fi
 834         sed -i "${gcc_sed[@]}" "${S}"/gcc/version.c || die
 835 }
 836
 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
 849         done
 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"
 857         done
 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"
 869         done
 870 }
 871
 872 #---->> src_configure <<----
 873
 874 toolchain_src_configure() {
 875         downgrade_arch_flags
 876         gcc_do_filter_flags
 877
 878         einfo "CFLAGS=\"${CFLAGS}\""
 879         einfo "CXXFLAGS=\"${CXXFLAGS}\""
 880         einfo "LDFLAGS=\"${LDFLAGS}\""
 881
 882         # Force internal zip based jar script to avoid random
 883         # issues with 3rd party jar implementations.  #384291
 884         export JAR=no
 885
 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
 890         fi
 891
 892         local confgcc=( --host=${CHOST} )
 893
 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} )
 900         fi
 901         [[ -n ${CBUILD} ]] && confgcc+=( --build=${CBUILD} )
 902
 903         confgcc+=(
 904                 --prefix="${PREFIX}"
 905                 --bindir="${BINPATH}"
 906                 --includedir="${INCLUDEPATH}"
 907                 --datadir="${DATAPATH}"
 908                 --mandir="${DATAPATH}/man"
 909                 --infodir="${DATAPATH}/info"
 910                 --with-gxx-include-dir="${STDCXX_INCDIR}"
 911         )
 912
 913         # Stick the python scripts in their own slotted directory (bug #279252)
 914         #
 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.
 920         #
 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 )
 924         fi
 925
 926         ### language options
 927
 928         local GCC_LANG="c"
 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
 935                 GCC_LANG+=",objc"
 936                 if tc_version_is_at_least 4 ; then
 937                         use objc-gc && confgcc+=( --enable-objc-gc )
 938                 fi
 939                 is_objcxx && GCC_LANG+=",obj-c++"
 940         fi
 941
 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"
 948
 949         # We do NOT want 'ADA support' in here!
 950         # is_ada && GCC_LANG+=",ada"
 951
 952         confgcc+=( --enable-languages=${GCC_LANG} )
 953
 954         ### general options
 955
 956         confgcc+=(
 957                 --enable-obsolete
 958                 --enable-secureplt
 959                 --disable-werror
 960                 --with-system-zlib
 961         )
 962
 963         if use nls ; then
 964                 confgcc+=( --enable-nls --without-included-gettext )
 965         else
 966                 confgcc+=( --disable-nls )
 967         fi
 968
 969         tc_version_is_at_least 3.4 || confgcc+=( --disable-libunwind-exceptions )
 970
 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})}" )
 977         fi
 978
 979         # Branding
 980         tc_version_is_at_least 4.3 && confgcc+=(
 981                 --with-bugurl=https://bugs.gentoo.org/
 982                 --with-pkgversion="${BRANDING_GCC_PKGVERSION}"
 983         )
 984
 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) )
 988         fi
 989
 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 )
 995         fi
 996
 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 )
1000         fi
1001
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 )
1005         fi
1006
1007         # The jit language requires this.
1008         is_jit && confgcc+=( --enable-host-shared )
1009
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
1016         #       )
1017         #       ;;
1018         # esac
1019
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 )
1024         fi
1025
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 )
1031
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=""
1035                 case ${CTARGET} in
1036                 *-linux)                 needed_libc=no-fucking-clue;;
1037                 *-dietlibc)              needed_libc=dietlibc;;
1038                 *-elf|*-eabi)
1039                         needed_libc=newlib
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.
1043                         # Undoing it here.
1044                         confgcc+=( --disable-libstdcxx-time )
1045                         ;;
1046                 *-freebsd*)              needed_libc=freebsd-lib;;
1047                 *-gnu*)                  needed_libc=glibc;;
1048                 *-klibc)                 needed_libc=klibc;;
1049                 *-musl*)                 needed_libc=musl;;
1050                 *-uclibc*)
1051                         if ! echo '#include <features.h>' | \
1052                            $(tc-getCPP ${CTARGET}) -E -dD - 2>/dev/null | \
1053                            grep -q __HAVE_SHARED__
1054                         then #291870
1055                                 confgcc+=( --disable-shared )
1056                         fi
1057                         needed_libc=uclibc-ng
1058                         ;;
1059                 *-cygwin)                needed_libc=cygwin;;
1060                 x86_64-*-mingw*|\
1061                 *-w64-mingw*)    needed_libc=mingw64-runtime;;
1062                 mingw*|*-mingw*) needed_libc=mingw-runtime;;
1063                 avr)                     confgcc+=( --enable-shared --disable-threads );;
1064                 esac
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
1069                                 confgcc+=(
1070                                         "${confgcc_no_libc[@]}"
1071                                         --disable-threads
1072                                         --without-headers
1073                                 )
1074                         elif has_version "${CATEGORY}/${needed_libc}[headers-only(-)]" ; then
1075                                 confgcc+=(
1076                                         "${confgcc_no_libc[@]}"
1077                                         --with-sysroot="${PREFIX}"/${CTARGET}
1078                                 )
1079                         else
1080                                 confgcc+=( --with-sysroot="${PREFIX}"/${CTARGET} )
1081                         fi
1082                 fi
1083
1084                 tc_version_is_at_least 4.2 && confgcc+=( --disable-bootstrap )
1085         else
1086                 if tc-is-static-only ; then
1087                         confgcc+=( --disable-shared )
1088                 else
1089                         confgcc+=( --enable-shared )
1090                 fi
1091                 case ${CHOST} in
1092                 mingw*|*-mingw*)
1093                         confgcc+=( --enable-threads=win32 ) ;;
1094                 *)
1095                         confgcc+=( --enable-threads=posix ) ;;
1096                 esac
1097         fi
1098
1099         # __cxa_atexit is "essential for fully standards-compliant handling of
1100         # destructors", but apparently requires glibc.
1101         case ${CTARGET} in
1102         *-uclibc*)
1103                 confgcc+=(
1104                         --disable-__cxa_atexit
1105                         $(use_enable nptl tls)
1106                 )
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 )
1110                 fi
1111                 ;;
1112         *-elf|*-eabi)
1113                 confgcc+=( --with-newlib )
1114                 ;;
1115         *-musl*)
1116                 confgcc+=( --enable-__cxa_atexit )
1117                 ;;
1118         *-gnu*)
1119                 confgcc+=(
1120                         --enable-__cxa_atexit
1121                         --enable-clocale=gnu
1122                 )
1123                 ;;
1124         *-freebsd*)
1125                 confgcc+=( --enable-__cxa_atexit )
1126                 ;;
1127         *-solaris*)
1128                 confgcc+=( --enable-__cxa_atexit )
1129                 ;;
1130         esac
1131
1132         ### arch options
1133
1134         gcc-multilib-configure
1135
1136         # ppc altivec support
1137         in_iuse altivec && confgcc+=( $(use_enable altivec) )
1138
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) )
1143
1144         case $(tc-is-softfloat) in
1145         yes)    confgcc+=( --with-float=soft ) ;;
1146         softfp) confgcc+=( --with-float=softfp ) ;;
1147         *)
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 ) ;;
1152                 esac
1153         esac
1154
1155         local with_abi_map=()
1156         case $(tc-arch) in
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}}
1163                                 break
1164                         fi
1165                 done
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
1171                 then
1172                         confgcc+=( --with-arch=${arm_arch} )
1173                 fi
1174
1175                 # Make default mode thumb for microcontroller classes #418209
1176                 [[ ${arm_arch} == *-m ]] && confgcc+=( --with-mode=thumb )
1177
1178                 # Enable hardvfp
1179                 if [[ $(tc-is-softfloat) == "no" ]] && \
1180                    [[ ${CTARGET} == armv[67]* ]] && \
1181                    tc_version_is_at_least 4.5
1182                 then
1183                         # Follow the new arm hardfp distro standard by default
1184                         confgcc+=( --with-float=hard )
1185                         case ${CTARGET} in
1186                         armv6*) confgcc+=( --with-fpu=vfp ) ;;
1187                         armv7*) confgcc+=( --with-fpu=vfpv3-d16 ) ;;
1188                         esac
1189                 fi
1190                 ;;
1191         mips)
1192                 # Add --with-abi flags to set default ABI
1193                 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1194                 ;;
1195         amd64)
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}) )
1200                 fi
1201                 ;;
1202         x86)
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%%-*} )
1206                 ;;
1207         hppa)
1208                 # Enable sjlj exceptions for backward compatibility on hppa
1209                 [[ ${GCCMAJOR} == "3" ]] && confgcc+=( --enable-sjlj-exceptions )
1210                 ;;
1211         ppc)
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 )
1215                 ;;
1216         riscv)
1217                 # Add --with-abi flags to set default ABI
1218                 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1219                 ;;
1220         esac
1221
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
1225         case $(tc-arch) in
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 ) ;;
1229         esac
1230
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 )
1237
1238         ### library options
1239
1240         if tc_version_is_between 3.0 7.0 ; then
1241                 if is_gcj ; then
1242                         confgcc+=( --disable-gjdoc )
1243                         use awt && confgcc+=( --enable-java-awt=gtk )
1244                 else
1245                         confgcc+=( --disable-libgcj )
1246                 fi
1247         fi
1248
1249         if tc_version_is_at_least 4.2 ; then
1250                 if in_iuse openmp ; then
1251                         # Make sure target has pthreads support. #326757 #335883
1252                         # There shouldn't be a chicken & egg problem here as openmp won't
1253                         # build without a C library, and you can't build that w/out
1254                         # already having a compiler ...
1255                         if ! is_crosscompile || \
1256                            $(tc-getCPP ${CTARGET}) -E - <<<"#include <pthread.h>" >& /dev/null
1257                         then
1258                                 confgcc+=( $(use_enable openmp libgomp) )
1259                         else
1260                                 # Force disable as the configure script can be dumb #359855
1261                                 confgcc+=( --disable-libgomp )
1262                         fi
1263                 else
1264                         # For gcc variants where we don't want openmp (e.g. kgcc)
1265                         confgcc+=( --disable-libgomp )
1266                 fi
1267         fi
1268
1269         if tc_version_is_at_least 4.0 ; then
1270                 if in_iuse mudflap ; then
1271                         confgcc+=( $(use_enable mudflap libmudflap) )
1272                 else
1273                         confgcc+=( --disable-libmudflap )
1274                 fi
1275
1276                 if use_if_iuse libssp ; then
1277                         confgcc+=( --enable-libssp )
1278                 else
1279                         if hardened_gcc_is_stable ssp; then
1280                                 export gcc_cv_libc_provides_ssp=yes
1281                         fi
1282                         if use_if_iuse ssp; then
1283                                 # On some targets USE="ssp -libssp" is an invalid
1284                                 # configuration as target libc does not provide
1285                                 # stack_chk_* functions. Do not disable libssp there.
1286                                 case ${CTARGET} in
1287                                         mingw*|*-mingw*) ewarn "Not disabling libssp" ;;
1288                                         *) confgcc+=( --disable-libssp ) ;;
1289                                 esac
1290                         else
1291                                 confgcc+=( --disable-libssp )
1292                         fi
1293                 fi
1294         fi
1295
1296         if in_iuse cilk ; then
1297                 confgcc+=( $(use_enable cilk libcilkrts) )
1298         fi
1299
1300         if in_iuse mpx ; then
1301                 confgcc+=( $(use_enable mpx libmpx) )
1302         fi
1303
1304         if in_iuse systemtap ; then
1305                 confgcc+=( $(use_enable systemtap) )
1306         fi
1307
1308         if in_iuse vtv ; then
1309                 confgcc+=(
1310                         $(use_enable vtv vtable-verify)
1311                         # See Note [implicitly enabled flags]
1312                         $(usex vtv '' --disable-libvtv)
1313                 )
1314         fi
1315
1316         # newer gcc's come with libquadmath, but only fortran uses
1317         # it, so auto punt it when we don't care
1318         if tc_version_is_at_least 4.6 && ! is_fortran ; then
1319                 confgcc+=( --disable-libquadmath )
1320         fi
1321
1322         if tc_version_is_at_least 4.6 ; then
1323                 confgcc+=( --enable-lto )
1324         elif tc_version_is_at_least 4.5 ; then
1325                 confgcc+=( --disable-lto )
1326         fi
1327
1328         # graphite was added in 4.4 but we only support it in 4.8+ due to external
1329         # library issues.  #448024
1330         if tc_version_is_at_least 5.0 && in_iuse graphite ; then
1331                 confgcc+=( $(use_with graphite isl) )
1332                 use graphite && confgcc+=( --disable-isl-version-check )
1333         elif tc_version_is_at_least 4.8 && in_iuse graphite ; then
1334                 confgcc+=( $(use_with graphite cloog) )
1335                 use graphite && confgcc+=( --disable-isl-version-check )
1336         elif tc_version_is_at_least 4.4 ; then
1337                 confgcc+=( --without-{cloog,ppl} )
1338         fi
1339
1340         if tc_version_is_at_least 4.8 && in_iuse sanitize ; then
1341                 # See Note [implicitly enabled flags]
1342                 confgcc+=( $(usex sanitize '' --disable-libsanitizer) )
1343         fi
1344
1345         if tc_version_is_at_least 6.0 && in_iuse pie ; then
1346                 confgcc+=( $(use_enable pie default-pie) )
1347         fi
1348
1349         if tc_version_is_at_least 6.0 && in_iuse ssp ; then
1350                 confgcc+=(
1351                         # This defaults to -fstack-protector-strong.
1352                         $(use_enable ssp default-ssp)
1353                 )
1354         fi
1355
1356         # Disable gcc info regeneration -- it ships with generated info pages
1357         # already.  Our custom version/urls/etc... trigger it.  #464008
1358         export gcc_cv_prog_makeinfo_modern=no
1359
1360         # Do not let the X detection get in our way.  We know things can be found
1361         # via system paths, so no need to hardcode things that'll break multilib.
1362         # Older gcc versions will detect ac_x_libraries=/usr/lib64 which ends up
1363         # killing the 32bit builds which want /usr/lib.
1364         export ac_cv_have_x='have_x=yes ac_x_includes= ac_x_libraries='
1365
1366         confgcc+=( "$@" ${EXTRA_ECONF} )
1367
1368         # Nothing wrong with a good dose of verbosity
1369         echo
1370         einfo "PREFIX:          ${PREFIX}"
1371         einfo "BINPATH:         ${BINPATH}"
1372         einfo "LIBPATH:         ${LIBPATH}"
1373         einfo "DATAPATH:        ${DATAPATH}"
1374         einfo "STDCXX_INCDIR:   ${STDCXX_INCDIR}"
1375         echo
1376         einfo "Languages:       ${GCC_LANG}"
1377         echo
1378         einfo "Configuring GCC with: ${confgcc[@]//--/\n\t--}"
1379         echo
1380
1381         # Build in a separate build tree
1382         mkdir -p "${WORKDIR}"/build
1383         pushd "${WORKDIR}"/build > /dev/null
1384
1385         # and now to do the actual configuration
1386         addwrite /dev/zero
1387         echo "${S}"/configure "${confgcc[@]}"
1388         # Older gcc versions did not detect bash and re-exec itself, so force the
1389         # use of bash.  Newer ones will auto-detect, but this is not harmful.
1390         CONFIG_SHELL="${EPREFIX}/bin/bash" \
1391         bash "${S}"/configure "${confgcc[@]}" || die "failed to run configure"
1392
1393         # return to whatever directory we were in before
1394         popd > /dev/null
1395 }
1396
1397 # Replace -m flags unsupported by the version being built with the best
1398 # available equivalent
1399 downgrade_arch_flags() {
1400         local arch bver i isa myarch mytune rep ver
1401
1402         bver=${1:-${GCC_BRANCH_VER}}
1403         [[ $(gcc-version) < ${bver} ]] && return 0
1404         [[ $(tc-arch) != amd64 && $(tc-arch) != x86 ]] && return 0
1405
1406         myarch=$(get-flag march)
1407         mytune=$(get-flag mtune)
1408
1409         # If -march=native isn't supported we have to tease out the actual arch
1410         if [[ ${myarch} == native || ${mytune} == native ]] ; then
1411                 if [[ ${bver} < 4.2 ]] ; then
1412                         arch=$($(tc-getCC) -march=native -v -E -P - </dev/null 2>&1 \
1413                                 | sed -rn "/cc1.*-march/s:.*-march=([^ ']*).*:\1:p")
1414                         replace-cpu-flags native ${arch}
1415                 fi
1416         fi
1417
1418         # Handle special -mtune flags
1419         [[ ${mytune} == intel && ${bver} < 4.9 ]] && replace-cpu-flags intel generic
1420         [[ ${mytune} == generic && ${bver} < 4.2 ]] && filter-flags '-mtune=*'
1421         [[ ${mytune} == x86-64 ]] && filter-flags '-mtune=*'
1422         [[ ${bver} < 3.4 ]] && filter-flags '-mtune=*'
1423
1424         # "added" "arch" "replacement"
1425         local archlist=(
1426                 4.9 bdver4 bdver3
1427                 4.9 bonnell atom
1428                 4.9 broadwell core-avx2
1429                 4.9 haswell core-avx2
1430                 4.9 ivybridge core-avx-i
1431                 4.9 nehalem corei7
1432                 4.9 sandybridge corei7-avx
1433                 4.9 silvermont corei7
1434                 4.9 westmere corei7
1435                 4.8 bdver3 bdver2
1436                 4.8 btver2 btver1
1437                 4.7 bdver2 bdver1
1438                 4.7 core-avx2 core-avx-i
1439                 4.6 bdver1 amdfam10
1440                 4.6 btver1 amdfam10
1441                 4.6 core-avx-i core2
1442                 4.6 corei7 core2
1443                 4.6 corei7-avx core2
1444                 4.5 atom core2
1445                 4.3 amdfam10 k8
1446                 4.3 athlon64-sse3 k8
1447                 4.3 barcelona k8
1448                 4.3 core2 nocona
1449                 4.3 geode k6-2 # gcc.gnu.org/PR41989#c22
1450                 4.3 k8-sse3 k8
1451                 4.3 opteron-sse3 k8
1452                 3.4 athlon-fx x86-64
1453                 3.4 athlon64 x86-64
1454                 3.4 c3-2 c3
1455                 3.4 k8 x86-64
1456                 3.4 opteron x86-64
1457                 3.4 pentium-m pentium3
1458                 3.4 pentium3m pentium3
1459                 3.4 pentium4m pentium4
1460         )
1461
1462         for ((i = 0; i < ${#archlist[@]}; i += 3)) ; do
1463                 myarch=$(get-flag march)
1464                 mytune=$(get-flag mtune)
1465
1466                 ver=${archlist[i]}
1467                 arch=${archlist[i + 1]}
1468                 rep=${archlist[i + 2]}
1469
1470                 [[ ${myarch} != ${arch} && ${mytune} != ${arch} ]] && continue
1471
1472                 if [[ ${ver} > ${bver} ]] ; then
1473                         einfo "Replacing ${myarch} (added in gcc ${ver}) with ${rep}..."
1474                         [[ ${myarch} == ${arch} ]] && replace-cpu-flags ${myarch} ${rep}
1475                         [[ ${mytune} == ${arch} ]] && replace-cpu-flags ${mytune} ${rep}
1476                         continue
1477                 else
1478                         break
1479                 fi
1480         done
1481
1482         # we only check -mno* here since -m* get removed by strip-flags later on
1483         local isalist=(
1484                 4.9 -mno-sha
1485                 4.9 -mno-avx512pf
1486                 4.9 -mno-avx512f
1487                 4.9 -mno-avx512er
1488                 4.9 -mno-avx512cd
1489                 4.8 -mno-xsaveopt
1490                 4.8 -mno-xsave
1491                 4.8 -mno-rtm
1492                 4.8 -mno-fxsr
1493                 4.7 -mno-lzcnt
1494                 4.7 -mno-bmi2
1495                 4.7 -mno-avx2
1496                 4.6 -mno-tbm
1497                 4.6 -mno-rdrnd
1498                 4.6 -mno-fsgsbase
1499                 4.6 -mno-f16c
1500                 4.6 -mno-bmi
1501                 4.5 -mno-xop
1502                 4.5 -mno-movbe
1503                 4.5 -mno-lwp
1504                 4.5 -mno-fma4
1505                 4.4 -mno-pclmul
1506                 4.4 -mno-fma
1507                 4.4 -mno-avx
1508                 4.4 -mno-aes
1509                 4.3 -mno-ssse3
1510                 4.3 -mno-sse4a
1511                 4.3 -mno-sse4
1512                 4.3 -mno-sse4.2
1513                 4.3 -mno-sse4.1
1514                 4.3 -mno-popcnt
1515                 4.3 -mno-abm
1516         )
1517
1518         for ((i = 0; i < ${#isalist[@]}; i += 2)) ; do
1519                 ver=${isalist[i]}
1520                 isa=${isalist[i + 1]}
1521                 [[ ${ver} > ${bver} ]] && filter-flags ${isa} ${isa/-m/-mno-}
1522         done
1523 }
1524
1525 gcc_do_filter_flags() {
1526         strip-flags
1527         replace-flags -O? -O2
1528
1529         # dont want to funk ourselves
1530         filter-flags '-mabi*' -m31 -m32 -m64
1531
1532         filter-flags -frecord-gcc-switches # 490738
1533         filter-flags -mno-rtm -mno-htm # 506202
1534
1535         if tc_version_is_between 3.2 3.4 ; then
1536                 # XXX: this is so outdated it's barely useful, but it don't hurt...
1537                 replace-cpu-flags G3 750
1538                 replace-cpu-flags G4 7400
1539                 replace-cpu-flags G5 7400
1540
1541                 # XXX: should add a sed or something to query all supported flags
1542                 #      from the gcc source and trim everything else ...
1543                 filter-flags -f{no-,}unit-at-a-time -f{no-,}web -mno-tls-direct-seg-refs
1544                 filter-flags -f{no-,}stack-protector{,-all}
1545                 filter-flags -fvisibility-inlines-hidden -fvisibility=hidden
1546                 # and warning options
1547                 filter-flags -Wextra -Wstack-protector
1548         fi
1549         if ! tc_version_is_at_least 4.1 ; then
1550                 filter-flags -fdiagnostics-show-option
1551                 filter-flags -Wstack-protector
1552         fi
1553
1554         if tc_version_is_at_least 3.4 ; then
1555                 case $(tc-arch) in
1556                         amd64|x86)
1557                                 filter-flags '-mcpu=*'
1558
1559                                 tc_version_is_between 4.4 4.5 && append-flags -mno-avx # 357287
1560
1561                                 if tc_version_is_between 4.6 4.7 ; then
1562                                         # https://bugs.gentoo.org/411333
1563                                         # https://bugs.gentoo.org/466454
1564                                         replace-cpu-flags c3-2 pentium2 pentium3 pentium3m pentium-m i686
1565                                 fi
1566                                 ;;
1567                         alpha)
1568                                 # https://bugs.gentoo.org/454426
1569                                 append-ldflags -Wl,--no-relax
1570                                 ;;
1571                         sparc)
1572                                 # temporary workaround for random ICEs reproduced by multiple users
1573                                 # https://bugs.gentoo.org/457062
1574                                 tc_version_is_between 4.6 4.8 && MAKEOPTS+=" -j1"
1575                                 ;;
1576                         *-macos)
1577                                 # http://gcc.gnu.org/PR25127
1578                                 tc_version_is_between 4.0 4.2 && \
1579                                         filter-flags '-mcpu=*' '-march=*' '-mtune=*'
1580                                 ;;
1581                 esac
1582         fi
1583
1584         strip-unsupported-flags
1585
1586         # these are set here so we have something sane at configure time
1587         if is_crosscompile ; then
1588                 # Set this to something sane for both native and target
1589                 CFLAGS="-O2 -pipe"
1590                 FFLAGS=${CFLAGS}
1591                 FCFLAGS=${CFLAGS}
1592
1593                 # "hppa2.0-unknown-linux-gnu" -> hppa2_0_unknown_linux_gnu
1594                 local VAR="CFLAGS_"${CTARGET//[-.]/_}
1595                 CXXFLAGS=${!VAR-${CFLAGS}}
1596         fi
1597
1598         export GCJFLAGS=${GCJFLAGS:-${CFLAGS}}
1599 }
1600
1601 setup_minispecs_gcc_build_specs() {
1602         # Setup the "build.specs" file for gcc 4.3 to use when building.
1603         if hardened_gcc_works pie ; then
1604                 cat "${WORKDIR}"/specs/pie.specs >> "${WORKDIR}"/build.specs
1605         fi
1606         if hardened_gcc_works ssp ; then
1607                 for s in ssp sspall ; do
1608                         cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1609                 done
1610         fi
1611         for s in nostrict znow ; do
1612                 cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1613         done
1614         export GCC_SPECS="${WORKDIR}"/build.specs
1615 }
1616
1617 gcc-multilib-configure() {
1618         if ! is_multilib ; then
1619                 confgcc+=( --disable-multilib )
1620                 # Fun times: if we are building for a target that has multiple
1621                 # possible ABI formats, and the user has told us to pick one
1622                 # that isn't the default, then not specifying it via the list
1623                 # below will break that on us.
1624         else
1625                 confgcc+=( --enable-multilib )
1626         fi
1627
1628         # translate our notion of multilibs into gcc's
1629         local abi list
1630         for abi in $(get_all_abis TARGET) ; do
1631                 local l=$(gcc-abi-map ${abi})
1632                 [[ -n ${l} ]] && list+=",${l}"
1633         done
1634         if [[ -n ${list} ]] ; then
1635                 case ${CTARGET} in
1636                 x86_64*)
1637                         tc_version_is_at_least 4.8 && confgcc+=( --with-multilib-list=${list:1} )
1638                         ;;
1639                 esac
1640         fi
1641 }
1642
1643 gcc-abi-map() {
1644         # Convert the ABI name we use in Gentoo to what gcc uses
1645         local map=()
1646         case ${CTARGET} in
1647         mips*)   map=("o32 32" "n32 n32" "n64 64") ;;
1648         riscv*)  map=("lp64d lp64d" "lp64 lp64") ;;
1649         x86_64*) map=("amd64 m64" "x86 m32" "x32 mx32") ;;
1650         esac
1651
1652         local m
1653         for m in "${map[@]}" ; do
1654                 l=( ${m} )
1655                 [[ $1 == ${l[0]} ]] && echo ${l[1]} && break
1656         done
1657 }
1658
1659 #----> src_compile <----
1660
1661 toolchain_src_compile() {
1662         touch "${S}"/gcc/c-gperf.h
1663
1664         # Do not make manpages if we do not have perl ...
1665         [[ ! -x /usr/bin/perl ]] \
1666                 && find "${WORKDIR}"/build -name '*.[17]' -exec touch {} +
1667
1668         # Older gcc versions did not detect bash and re-exec itself, so force the
1669         # use of bash.  Newer ones will auto-detect, but this is not harmful.
1670         # This needs to be set for compile as well, as it's used in libtool
1671         # generation, which will break install otherwise (at least in 3.3.6): #664486
1672         CONFIG_SHELL="${EPREFIX}/bin/bash" \
1673         gcc_do_make ${GCC_MAKE_TARGET}
1674 }
1675
1676 gcc_do_make() {
1677         # This function accepts one optional argument, the make target to be used.
1678         # If omitted, gcc_do_make will try to guess whether it should use all,
1679         # or bootstrap-lean depending on CTARGET and arch.
1680         # An example of how to use this function:
1681         #
1682         #       gcc_do_make all-target-libstdc++-v3
1683
1684         [[ -n ${1} ]] && GCC_MAKE_TARGET=${1}
1685
1686         # default target
1687         if is_crosscompile || tc-is-cross-compiler ; then
1688                 # 3 stage bootstrapping doesnt quite work when you cant run the
1689                 # resulting binaries natively ^^;
1690                 GCC_MAKE_TARGET=${GCC_MAKE_TARGET-all}
1691         else
1692                 if tc_version_is_at_least 3.3 && use_if_iuse pgo; then
1693                         GCC_MAKE_TARGET=${GCC_MAKE_TARGET-profiledbootstrap}
1694                 else
1695                         GCC_MAKE_TARGET=${GCC_MAKE_TARGET-bootstrap-lean}
1696                 fi
1697         fi
1698
1699         # Older versions of GCC could not do profiledbootstrap in parallel due to
1700         # collisions with profiling info.
1701         # boundschecking also seems to introduce parallel build issues.
1702         if [[ ${GCC_MAKE_TARGET} == "profiledbootstrap" ]] || use_if_iuse boundschecking ; then
1703                 ! tc_version_is_at_least 4.6 && export MAKEOPTS="${MAKEOPTS} -j1"
1704         fi
1705
1706         if [[ ${GCC_MAKE_TARGET} == "all" ]] ; then
1707                 STAGE1_CFLAGS=${STAGE1_CFLAGS-"${CFLAGS}"}
1708         elif [[ $(gcc-version) == "3.4" && ${GCC_BRANCH_VER} == "3.4" ]] && gcc-specs-ssp ; then
1709                 # See bug #79852
1710                 STAGE1_CFLAGS=${STAGE1_CFLAGS-"-O2"}
1711         fi
1712
1713         if is_crosscompile; then
1714                 # In 3.4, BOOT_CFLAGS is never used on a crosscompile...
1715                 # but I'll leave this in anyways as someone might have had
1716                 # some reason for putting it in here... --eradicator
1717                 BOOT_CFLAGS=${BOOT_CFLAGS-"-O2"}
1718         else
1719                 # we only want to use the system's CFLAGS if not building a
1720                 # cross-compiler.
1721                 BOOT_CFLAGS=${BOOT_CFLAGS-"$(get_abi_CFLAGS ${TARGET_DEFAULT_ABI}) ${CFLAGS}"}
1722         fi
1723
1724         einfo "Compiling ${PN} (${GCC_MAKE_TARGET})..."
1725
1726         pushd "${WORKDIR}"/build >/dev/null
1727
1728         emake \
1729                 LDFLAGS="${LDFLAGS}" \
1730                 STAGE1_CFLAGS="${STAGE1_CFLAGS}" \
1731                 LIBPATH="${LIBPATH}" \
1732                 BOOT_CFLAGS="${BOOT_CFLAGS}" \
1733                 ${GCC_MAKE_TARGET} \
1734                 || die "emake failed with ${GCC_MAKE_TARGET}"
1735
1736         if ! is_crosscompile && use_if_iuse cxx && use_if_iuse doc ; then
1737                 if type -p doxygen > /dev/null ; then
1738                         if tc_version_is_at_least 4.3 ; then
1739                                 cd "${CTARGET}"/libstdc++-v3/doc
1740                                 emake doc-man-doxygen || ewarn "failed to make docs"
1741                         elif tc_version_is_at_least 3.0 ; then
1742                                 cd "${CTARGET}"/libstdc++-v3
1743                                 emake doxygen-man || ewarn "failed to make docs"
1744                         fi
1745                         # Clean bogus manpages.  #113902
1746                         find -name '*_build_*' -delete
1747                         # Blow away generated directory references.  Newer versions of gcc
1748                         # have gotten better at this, but not perfect.  This is easier than
1749                         # backporting all of the various doxygen patches.  #486754
1750                         find -name '*_.3' -exec grep -l ' Directory Reference ' {} + | \
1751                                 xargs rm -f
1752                 else
1753                         ewarn "Skipping libstdc++ manpage generation since you don't have doxygen installed"
1754                 fi
1755         fi
1756
1757         popd >/dev/null
1758 }
1759
1760 #---->> src_test <<----
1761
1762 toolchain_src_test() {
1763         if use ${GCC_EBUILD_TEST_FLAG} ; then
1764                 cd "${WORKDIR}"/build
1765                 # enable verbose test run and result logging
1766                 emake -k check RUNTESTFLAGS='-a -v'
1767         fi
1768 }
1769
1770 #---->> src_install <<----
1771
1772 toolchain_src_install() {
1773         cd "${WORKDIR}"/build
1774
1775         # Do allow symlinks in private gcc include dir as this can break the build
1776         find gcc/include*/ -type l -delete
1777
1778         # Copy over the info pages.  We disabled their generation earlier, but the
1779         # build system only expects to install out of the build dir, not the source.  #464008
1780         mkdir -p gcc/doc
1781         local x=
1782         for x in "${S}"/gcc/doc/*.info* ; do
1783                 if [[ -f ${x} ]] ; then
1784                         cp "${x}" gcc/doc/ || die
1785                 fi
1786         done
1787
1788         # We remove the generated fixincludes, as they can cause things to break
1789         # (ncurses, openssl, etc).  We do not prevent them from being built, as
1790         # in the following commit which we revert:
1791         # https://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/eclass/toolchain.eclass?r1=1.647&r2=1.648
1792         # This is because bsd userland needs fixedincludes to build gcc, while
1793         # linux does not.  Both can dispose of them afterwards.
1794         while read x ; do
1795                 grep -q 'It has been auto-edited by fixincludes from' "${x}" \
1796                         && rm -f "${x}"
1797         done < <(find gcc/include*/ -name '*.h')
1798
1799         # Do the 'make install' from the build directory
1800         S="${WORKDIR}"/build emake -j1 DESTDIR="${D}" install || die
1801
1802         # Punt some tools which are really only useful while building gcc
1803         find "${ED}" -name install-tools -prune -type d -exec rm -rf "{}" \;
1804         # This one comes with binutils
1805         find "${ED}" -name libiberty.a -delete
1806
1807         # Move the libraries to the proper location
1808         gcc_movelibs
1809
1810         # Basic sanity check
1811         if ! is_crosscompile ; then
1812                 local EXEEXT
1813                 eval $(grep ^EXEEXT= "${WORKDIR}"/build/gcc/config.log)
1814                 [[ -r ${D}${BINPATH}/gcc${EXEEXT} ]] || die "gcc not found in ${ED}"
1815         fi
1816
1817         dodir /etc/env.d/gcc
1818         create_gcc_env_entry
1819
1820         # Setup the gcc_env_entry for hardened gcc 4 with minispecs
1821         want_minispecs && copy_minispecs_gcc_specs
1822
1823         # Make sure we dont have stuff lying around that
1824         # can nuke multiple versions of gcc
1825         gcc_slot_java
1826
1827         dodir /usr/bin
1828         cd "${D}"${BINPATH}
1829         # Ugh: we really need to auto-detect this list.
1830         #      It's constantly out of date.
1831         for x in cpp gcc g++ c++ gcov g77 gcj gcjh gfortran gccgo ; do
1832                 # For some reason, g77 gets made instead of ${CTARGET}-g77...
1833                 # this should take care of that
1834                 if [[ -f ${x} ]] ; then
1835                         # In case they're hardlinks, clear out the target first
1836                         # otherwise the mv below will complain.
1837                         rm -f ${CTARGET}-${x}
1838                         mv ${x} ${CTARGET}-${x}
1839                 fi
1840
1841                 if [[ -f ${CTARGET}-${x} ]] ; then
1842                         if ! is_crosscompile ; then
1843                                 ln -sf ${CTARGET}-${x} ${x}
1844                                 dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1845                                         /usr/bin/${x}-${GCC_CONFIG_VER}
1846                         fi
1847                         # Create versioned symlinks
1848                         dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1849                                 /usr/bin/${CTARGET}-${x}-${GCC_CONFIG_VER}
1850                 fi
1851
1852                 if [[ -f ${CTARGET}-${x}-${GCC_CONFIG_VER} ]] ; then
1853                         rm -f ${CTARGET}-${x}-${GCC_CONFIG_VER}
1854                         ln -sf ${CTARGET}-${x} ${CTARGET}-${x}-${GCC_CONFIG_VER}
1855                 fi
1856         done
1857
1858         # When gcc builds a crosscompiler it does not install unprefixed tools.
1859         # When cross-building gcc does install native tools.
1860         if ! is_crosscompile; then
1861                 # Rename the main go binaries as we don't want to clobber dev-lang/go
1862                 # when gcc-config runs. #567806
1863                 if tc_version_is_at_least 5 && is_go ; then
1864                         for x in go gofmt; do
1865                                 mv ${x} ${x}-${GCCMAJOR} || die
1866                         done
1867                 fi
1868         fi
1869
1870         # TODO: implement stripping (we use RESTRICT=strip)
1871         # As gcc installs object files both build against ${CHOST} and ${CTARGET}
1872         # we will ned to run stripping using different tools:
1873         # Using ${CHOST} tools:
1874         #  - "${D}${BINPATH}"
1875         #  - (for is_crosscompile) "${D}${HOSTLIBPATH}"
1876         #  - "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}"
1877         # Using ${CTARGET} tools:
1878         #  - "${D}${LIBPATH}"
1879
1880         cd "${S}"
1881         if is_crosscompile; then
1882                 rm -rf "${ED}"/usr/share/{man,info}
1883                 rm -rf "${D}"${DATAPATH}/{man,info}
1884         else
1885                 if tc_version_is_at_least 3.0 ; then
1886                         local cxx_mandir=$(find "${WORKDIR}/build/${CTARGET}/libstdc++-v3" -name man)
1887                         if [[ -d ${cxx_mandir} ]] ; then
1888                                 cp -r "${cxx_mandir}"/man? "${D}${DATAPATH}"/man/
1889                         fi
1890                 fi
1891         fi
1892
1893         # portage regenerates 'dir' files on it's own: bug #672408
1894         # Drop 'dir' files to avoid collisions.
1895         if [[ -f "${D}${DATAPATH}"/info/dir ]]; then
1896                 einfo "Deleting '${D}${DATAPATH}/info/dir'"
1897                 rm "${D}${DATAPATH}"/info/dir || die
1898         fi
1899
1900         # prune empty dirs left behind
1901         find "${ED}" -depth -type d -delete 2>/dev/null
1902
1903         # install testsuite results
1904         if use ${GCC_EBUILD_TEST_FLAG}; then
1905                 docinto testsuite
1906                 find "${WORKDIR}"/build -type f -name "*.sum" -exec dodoc {} +
1907                 find "${WORKDIR}"/build -type f -path "*/testsuite/*.log" -exec dodoc {} +
1908         fi
1909
1910         # Rather install the script, else portage with changing $FILESDIR
1911         # between binary and source package borks things ....
1912         if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
1913                 insinto "${DATAPATH#${EPREFIX}}"
1914                 newins "$(prefixify_ro "${FILESDIR}"/awk/fixlafiles.awk-no_gcc_la)" fixlafiles.awk || die
1915                 exeinto "${DATAPATH#${EPREFIX}}"
1916                 doexe "$(prefixify_ro "${FILESDIR}"/fix_libtool_files.sh)" || die
1917                 doexe "${FILESDIR}"/c{89,99} || die
1918         fi
1919
1920         # libstdc++.la: Delete as it doesn't add anything useful: g++ itself
1921         # handles linkage correctly in the dynamic & static case.  It also just
1922         # causes us pain: any C++ progs/libs linking with libtool will gain a
1923         # reference to the full libstdc++.la file which is gcc version specific.
1924         # libstdc++fs.la: It doesn't link against anything useful.
1925         # libsupc++.la: This has no dependencies.
1926         # libcc1.la: There is no static library, only dynamic.
1927         # libcc1plugin.la: Same as above, and it's loaded via dlopen.
1928         # libcp1plugin.la: Same as above, and it's loaded via dlopen.
1929         # libgomp.la: gcc itself handles linkage (libgomp.spec).
1930         # libgomp-plugin-*.la: Same as above, and it's an internal plugin only
1931         # loaded via dlopen.
1932         # libgfortran.la: gfortran itself handles linkage correctly in the
1933         # dynamic & static case (libgfortran.spec). #573302
1934         # libgfortranbegin.la: Same as above, and it's an internal lib.
1935         # libmpx.la: gcc itself handles linkage correctly (libmpx.spec).
1936         # libmpxwrappers.la: See above.
1937         # libitm.la: gcc itself handles linkage correctly (libitm.spec).
1938         # libvtv.la: gcc itself handles linkage correctly.
1939         # lib*san.la: Sanitizer linkage is handled internally by gcc, and they
1940         # do not support static linking. #487550 #546700
1941         find "${D}${LIBPATH}" \
1942                 '(' \
1943                         -name libstdc++.la -o \
1944                         -name libstdc++fs.la -o \
1945                         -name libsupc++.la -o \
1946                         -name libcc1.la -o \
1947                         -name libcc1plugin.la -o \
1948                         -name libcp1plugin.la -o \
1949                         -name 'libgomp.la' -o \
1950                         -name 'libgomp-plugin-*.la' -o \
1951                         -name libgfortran.la -o \
1952                         -name libgfortranbegin.la -o \
1953                         -name libmpx.la -o \
1954                         -name libmpxwrappers.la -o \
1955                         -name libitm.la -o \
1956                         -name libvtv.la -o \
1957                         -name 'lib*san.la' \
1958                 ')' -type f -delete
1959
1960         # Use gid of 0 because some stupid ports don't have
1961         # the group 'root' set to gid 0.  Send to /dev/null
1962         # for people who are testing as non-root.
1963         chown -R root:0 "${D}${LIBPATH}" 2>/dev/null
1964
1965         # Installing gdb pretty-printers into gdb-specific location.
1966         local py gdbdir=/usr/share/gdb/auto-load${LIBPATH}
1967         pushd "${D}${LIBPATH}" >/dev/null
1968         for py in $(find . -name '*-gdb.py') ; do
1969                 local multidir=${py%/*}
1970                 insinto "${gdbdir}/${multidir}"
1971                 sed -i "/^libdir =/s:=.*:= '${LIBPATH}/${multidir}':" "${py}" || die #348128
1972                 doins "${py}" || die
1973                 rm "${py}" || die
1974         done
1975         popd >/dev/null
1976
1977         # Don't scan .gox files for executable stacks - false positives
1978         export QA_EXECSTACK="usr/lib*/go/*/*.gox"
1979         export QA_WX_LOAD="usr/lib*/go/*/*.gox"
1980
1981         # Disable RANDMMAP so PCH works. #301299
1982         if tc_version_is_at_least 4.3 ; then
1983                 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1"
1984                 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1plus"
1985         fi
1986
1987         # Disable MPROTECT so java works. #574808
1988         if is_gcj ; then
1989                 pax-mark -m "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/ecj1"
1990                 pax-mark -m "${D}${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}/gij"
1991         fi
1992 }
1993
1994 # Move around the libs to the right location.  For some reason,
1995 # when installing gcc, it dumps internal libraries into /usr/lib
1996 # instead of the private gcc lib path
1997 gcc_movelibs() {
1998         # older versions of gcc did not support --print-multi-os-directory
1999         tc_version_is_at_least 3.2 || return 0
2000
2001         # For non-target libs which are for CHOST and not CTARGET, we want to
2002         # move them to the compiler-specific CHOST internal dir.  This is stuff
2003         # that you want to link against when building tools rather than building
2004         # code to run on the target.
2005         if tc_version_is_at_least 5 && is_crosscompile ; then
2006                 dodir "${HOSTLIBPATH#${EPREFIX}}"
2007                 mv "${ED}"/usr/$(get_libdir)/libcc1* "${D}${HOSTLIBPATH}" || die
2008         fi
2009
2010         # For all the libs that are built for CTARGET, move them into the
2011         # compiler-specific CTARGET internal dir.
2012         local x multiarg removedirs=""
2013         for multiarg in $($(XGCC) -print-multi-lib) ; do
2014                 multiarg=${multiarg#*;}
2015                 multiarg=${multiarg//@/ -}
2016
2017                 local OS_MULTIDIR=$($(XGCC) ${multiarg} --print-multi-os-directory)
2018                 local MULTIDIR=$($(XGCC) ${multiarg} --print-multi-directory)
2019                 local TODIR="${D}${LIBPATH}"/${MULTIDIR}
2020                 local FROMDIR=
2021
2022                 [[ -d ${TODIR} ]] || mkdir -p ${TODIR}
2023
2024                 for FROMDIR in \
2025                         "${LIBPATH}"/${OS_MULTIDIR} \
2026                         "${LIBPATH}"/../${MULTIDIR} \
2027                         "${PREFIX}"/lib/${OS_MULTIDIR} \
2028                         "${PREFIX}"/${CTARGET}/lib/${OS_MULTIDIR}
2029                 do
2030                         removedirs="${removedirs} ${FROMDIR}"
2031                         FROMDIR=${D}${FROMDIR}
2032                         if [[ ${FROMDIR} != "${TODIR}" && -d ${FROMDIR} ]] ; then
2033                                 local files=$(find "${FROMDIR}" -maxdepth 1 ! -type d 2>/dev/null)
2034                                 if [[ -n ${files} ]] ; then
2035                                         mv ${files} "${TODIR}" || die
2036                                 fi
2037                         fi
2038                 done
2039                 fix_libtool_libdir_paths "${LIBPATH}/${MULTIDIR}"
2040
2041                 # SLOT up libgcj.pc if it's available (and let gcc-config worry about links)
2042                 FROMDIR="${PREFIX}/lib/${OS_MULTIDIR}"
2043                 for x in "${D}${FROMDIR}"/pkgconfig/libgcj*.pc ; do
2044                         [[ -f ${x} ]] || continue
2045                         sed -i "/^libdir=/s:=.*:=${LIBPATH}/${MULTIDIR}:" "${x}" || die
2046                         mv "${x}" "${D}${FROMDIR}"/pkgconfig/libgcj-${GCC_PV}.pc || die
2047                 done
2048         done
2049
2050         # We remove directories separately to avoid this case:
2051         #       mv SRC/lib/../lib/*.o DEST
2052         #       rmdir SRC/lib/../lib/
2053         #       mv SRC/lib/../lib32/*.o DEST  # Bork
2054         for FROMDIR in ${removedirs} ; do
2055                 rmdir "${D}"${FROMDIR} >& /dev/null
2056         done
2057         find -depth "${ED}" -type d -exec rmdir {} + >& /dev/null
2058 }
2059
2060 # make sure the libtool archives have libdir set to where they actually
2061 # -are-, and not where they -used- to be.  also, any dependencies we have
2062 # on our own .la files need to be updated.
2063 fix_libtool_libdir_paths() {
2064         local libpath="$1"
2065
2066         pushd "${D}" >/dev/null
2067
2068         pushd "./${libpath}" >/dev/null
2069         local dir="${PWD#${D%/}}"
2070         local allarchives=$(echo *.la)
2071         allarchives="\(${allarchives// /\\|}\)"
2072         popd >/dev/null
2073
2074         # The libdir might not have any .la files. #548782
2075         find "./${dir}" -maxdepth 1 -name '*.la' \
2076                 -exec sed -i -e "/^libdir=/s:=.*:='${dir}':" {} + || die
2077         # Would be nice to combine these, but -maxdepth can not be specified
2078         # on sub-expressions.
2079         find "./${PREFIX}"/lib* -maxdepth 3 -name '*.la' \
2080                 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2081         find "./${dir}/" -maxdepth 1 -name '*.la' \
2082                 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2083
2084         popd >/dev/null
2085 }
2086
2087 create_gcc_env_entry() {
2088         dodir /etc/env.d/gcc
2089         local gcc_envd_base="/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}"
2090
2091         local gcc_specs_file
2092         local gcc_envd_file="${ED}${gcc_envd_base}"
2093         if [[ -z $1 ]] ; then
2094                 # I'm leaving the following commented out to remind me that it
2095                 # was an insanely -bad- idea. Stuff broke. GCC_SPECS isnt unset
2096                 # on chroot or in non-toolchain.eclass gcc ebuilds!
2097                 #gcc_specs_file="${LIBPATH}/specs"
2098                 gcc_specs_file=""
2099         else
2100                 gcc_envd_file+="-$1"
2101                 gcc_specs_file="${LIBPATH}/$1.specs"
2102         fi
2103
2104         # We want to list the default ABI's LIBPATH first so libtool
2105         # searches that directory first.  This is a temporary
2106         # workaround for libtool being stupid and using .la's from
2107         # conflicting ABIs by using the first one in the search path
2108         local ldpaths mosdirs
2109         if tc_version_is_at_least 3.2 ; then
2110                 local mdir mosdir abi ldpath
2111                 for abi in $(get_all_abis TARGET) ; do
2112                         mdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) --print-multi-directory)
2113                         ldpath=${LIBPATH}
2114                         [[ ${mdir} != "." ]] && ldpath+="/${mdir}"
2115                         ldpaths="${ldpath}${ldpaths:+:${ldpaths}}"
2116
2117                         mosdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) -print-multi-os-directory)
2118                         mosdirs="${mosdir}${mosdirs:+:${mosdirs}}"
2119                 done
2120         else
2121                 # Older gcc's didn't do multilib, so logic is simple.
2122                 ldpaths=${LIBPATH}
2123         fi
2124
2125         cat <<-EOF > ${gcc_envd_file}
2126         PATH="${BINPATH}"
2127         ROOTPATH="${BINPATH}"
2128         GCC_PATH="${BINPATH}"
2129         LDPATH="${ldpaths}"
2130         MANPATH="${DATAPATH}/man"
2131         INFOPATH="${DATAPATH}/info"
2132         STDCXX_INCDIR="${STDCXX_INCDIR##*/}"
2133         CTARGET="${CTARGET}"
2134         GCC_SPECS="${gcc_specs_file}"
2135         MULTIOSDIRS="${mosdirs}"
2136         EOF
2137 }
2138
2139 copy_minispecs_gcc_specs() {
2140         # on gcc 6 we don't need minispecs
2141         if tc_version_is_at_least 6.0 ; then
2142                 return 0
2143         fi
2144
2145         # setup the hardenedno* specs files and the vanilla specs file.
2146         if hardened_gcc_works ; then
2147                 create_gcc_env_entry hardenednopiessp
2148         fi
2149         if hardened_gcc_works pie ; then
2150                 create_gcc_env_entry hardenednopie
2151         fi
2152         if hardened_gcc_works ssp ; then
2153                 create_gcc_env_entry hardenednossp
2154         fi
2155         create_gcc_env_entry vanilla
2156         insinto ${LIBPATH#${EPREFIX}}
2157         doins "${WORKDIR}"/specs/*.specs || die "failed to install specs"
2158         # Build system specs file which, if it exists, must be a complete set of
2159         # specs as it completely and unconditionally overrides the builtin specs.
2160         if ! tc_version_is_at_least 4.4 ; then
2161                 $(XGCC) -dumpspecs > "${WORKDIR}"/specs/specs
2162                 cat "${WORKDIR}"/build.specs >> "${WORKDIR}"/specs/specs
2163                 doins "${WORKDIR}"/specs/specs || die "failed to install the specs file"
2164         fi
2165 }
2166
2167 gcc_slot_java() {
2168         local x
2169
2170         # Move Java headers to compiler-specific dir
2171         for x in "${D}${PREFIX}"/include/gc*.h "${D}${PREFIX}"/include/j*.h ; do
2172                 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/include/
2173         done
2174         for x in gcj gnu java javax org ; do
2175                 if [[ -d ${D}${PREFIX}/include/${x} ]] ; then
2176                         dodir /${LIBPATH#${EPREFIX}}/include/${x}
2177                         mv -f "${D}${PREFIX}"/include/${x}/* "${D}${LIBPATH}"/include/${x}/
2178                         rm -rf "${D}${PREFIX}"/include/${x}
2179                 fi
2180         done
2181
2182         if [[ -d ${D}${PREFIX}/lib/security ]] || [[ -d ${D}${PREFIX}/$(get_libdir)/security ]] ; then
2183                 dodir /${LIBPATH#${EPREFIX}}/security
2184                 mv -f "${D}${PREFIX}"/lib*/security/* "${D}${LIBPATH}"/security
2185                 rm -rf "${D}${PREFIX}"/lib*/security
2186         fi
2187
2188         # Move random gcj files to compiler-specific directories
2189         for x in libgcj.spec logging.properties ; do
2190                 x="${D}${PREFIX}/lib/${x}"
2191                 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/
2192         done
2193
2194         # Rename jar because it could clash with Kaffe's jar if this gcc is
2195         # primary compiler (aka don't have the -<version> extension)
2196         cd "${D}${BINPATH}"
2197         [[ -f jar ]] && mv -f jar gcj-jar
2198 }
2199
2200 #---->> pkg_post* <<----
2201
2202 toolchain_pkg_postinst() {
2203         do_gcc_config
2204         if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2205                 eselect compiler-shadow update all
2206         fi
2207
2208         if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
2209                 echo
2210                 ewarn "If you have issues with packages unable to locate libstdc++.la,"
2211                 ewarn "then try running 'fix_libtool_files.sh' on the old gcc versions."
2212                 echo
2213                 ewarn "You might want to review the GCC upgrade guide when moving between"
2214                 ewarn "major versions (like 4.2 to 4.3):"
2215                 ewarn "https://wiki.gentoo.org/wiki/Upgrading_GCC"
2216                 echo
2217
2218                 # Clean up old paths
2219                 rm -f "${EROOT%/}"/*/rcscripts/awk/fixlafiles.awk "${EROOT%/}"/sbin/fix_libtool_files.sh
2220                 rmdir "${EROOT%/}"/*/rcscripts{/awk,} 2>/dev/null
2221
2222                 mkdir -p "${EROOT%/}"/usr/{share/gcc-data,sbin,bin}
2223                 # DATAPATH has EPREFIX already, use ROOT with it
2224                 cp "${ROOT%/}${DATAPATH}"/fixlafiles.awk "${EROOT%/}"/usr/share/gcc-data/ || die
2225                 cp "${ROOT%/}${DATAPATH}"/fix_libtool_files.sh "${EROOT%/}"/usr/sbin/ || die
2226
2227                 # Since these aren't critical files and portage sucks with
2228                 # handling of binpkgs, don't require these to be found
2229                 cp "${ROOT%/}${DATAPATH}"/c{89,99} "${EROOT%/}"/usr/bin/ 2>/dev/null
2230         fi
2231
2232         if use ${GCC_EBUILD_TEST_FLAG} ; then
2233                 elog "Testsuite results have been installed into /usr/share/doc/${PF}/testsuite"
2234                 echo
2235         fi
2236
2237         if [[ -n ${PRERELEASE}${SNAPSHOT} ]] ; then
2238                 einfo "This GCC ebuild is provided for your convenience, and the use"
2239                 einfo "of this compiler is not supported by the Gentoo Developers."
2240                 einfo "Please report bugs to upstream at http://gcc.gnu.org/bugzilla/"
2241         fi
2242 }
2243
2244 toolchain_pkg_postrm() {
2245         do_gcc_config
2246         if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2247                 eselect compiler-shadow clean all
2248         fi
2249
2250         # to make our lives easier (and saner), we do the fix_libtool stuff here.
2251         # rather than checking SLOT's and trying in upgrade paths, we just see if
2252         # the common libstdc++.la exists in the ${LIBPATH} of the gcc that we are
2253         # unmerging.  if it does, that means this was a simple re-emerge.
2254
2255         # clean up the cruft left behind by cross-compilers
2256         if is_crosscompile ; then
2257                 if [[ -z $(ls "${EROOT%/}"/etc/env.d/gcc/${CTARGET}* 2>/dev/null) ]] ; then
2258                         einfo "Removing last cross-compiler instance. Deleting dangling symlinks."
2259                         rm -f "${EROOT%/}"/etc/env.d/gcc/config-${CTARGET}
2260                         rm -f "${EROOT%/}"/etc/env.d/??gcc-${CTARGET}
2261                         rm -f "${EROOT%/}"/usr/bin/${CTARGET}-{gcc,{g,c}++}{,32,64}
2262                 fi
2263                 return 0
2264         fi
2265
2266         # ROOT isnt handled by the script
2267         [[ ${ROOT%/} ]] && return 0
2268
2269         if [[ ! -e ${LIBPATH}/libstdc++.so ]] ; then
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}
2275                 fi
2276         fi
2277
2278         return 0
2279 }
2280
2281 do_gcc_config() {
2282         if ! should_we_gcc_config ; then
2283                 gcc-config --use-old --force
2284                 return 0
2285         fi
2286
2287         local current_gcc_config target
2288
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}
2295
2296                 if [[ -n ${use_specs} ]] && \
2297                    [[ ! -e ${EROOT%/}/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}${use_specs} ]]
2298                 then
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."
2304                         use_specs=""
2305                 fi
2306
2307                 target="${CTARGET}-${GCC_CONFIG_VER}${use_specs}"
2308         else
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}')
2314         fi
2315
2316         gcc-config "${target}"
2317 }
2318
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
2322         local curr_config
2323         curr_config=$(gcc-config -c ${CTARGET} 2>&1) || return 0
2324
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}')
2329
2330         local curr_branch_ver=$(ver_cut 1-2 ${curr_config_ver})
2331
2332         if [[ ${curr_branch_ver} == ${GCC_BRANCH_VER} ]] ; then
2333                 return 0
2334         else
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"
2347                         einfo "following:"
2348                         echo
2349                         einfo "gcc-config ${CTARGET}-${GCC_CONFIG_VER}"
2350                         einfo "source /etc/profile"
2351                         echo
2352                 fi
2353                 return 1
2354         fi
2355 }
2356
2357 #---->> support and misc functions <<----
2358
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.
2361 #
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}
2368 }
2369
2370 is_ada() {
2371         gcc-lang-supported ada || return 1
2372         use_if_iuse ada
2373 }
2374
2375 is_cxx() {
2376         gcc-lang-supported 'c++' || return 1
2377         use_if_iuse cxx
2378 }
2379
2380 is_d() {
2381         gcc-lang-supported d || return 1
2382         use_if_iuse d
2383 }
2384
2385 is_f77() {
2386         gcc-lang-supported f77 || return 1
2387         use_if_iuse fortran
2388 }
2389
2390 is_f95() {
2391         gcc-lang-supported f95 || return 1
2392         use_if_iuse fortran
2393 }
2394
2395 is_fortran() {
2396         gcc-lang-supported fortran || return 1
2397         use_if_iuse fortran
2398 }
2399
2400 is_gcj() {
2401         gcc-lang-supported java || return 1
2402         use_if_iuse cxx && use_if_iuse gcj
2403 }
2404
2405 is_go() {
2406         gcc-lang-supported go || return 1
2407         use_if_iuse cxx && use_if_iuse go
2408 }
2409
2410 is_jit() {
2411         gcc-lang-supported jit || return 1
2412         # cross-compiler does not really support jit as it has
2413         # to generate code for a target. On target like avr
2414         # libgcclit.so can't link at all: bug #594572
2415         is_crosscompile && return 1
2416         use_if_iuse jit
2417 }
2418
2419 is_multilib() {
2420         tc_version_is_at_least 3 || return 1
2421         use_if_iuse multilib
2422 }
2423
2424 is_objc() {
2425         gcc-lang-supported objc || return 1
2426         use_if_iuse objc
2427 }
2428
2429 is_objcxx() {
2430         gcc-lang-supported 'obj-c++' || return 1
2431         use_if_iuse cxx && use_if_iuse objc++
2432 }
2433
2434 # Grab a variable from the build system (taken from linux-info.eclass)
2435 get_make_var() {
2436         local var=$1 makefile=${2:-${WORKDIR}/build/Makefile}
2437         echo -e "e:\\n\\t@echo \$(${var})\\ninclude ${makefile}" | \
2438                 r=${makefile%/*} emake --no-print-directory -s -f - 2>/dev/null
2439 }
2440
2441 XGCC() { get_make_var GCC_FOR_TARGET ; }
2442
2443 # The gentoo piessp patches allow for 3 configurations:
2444 # 1) PIE+SSP by default
2445 # 2) PIE by default
2446 # 3) SSP by default
2447 hardened_gcc_works() {
2448         if [[ $1 == "pie" ]] ; then
2449                 # $gcc_cv_ld_pie is unreliable as it simply take the output of
2450                 # `ld --help | grep -- -pie`, that reports the option in all cases, also if
2451                 # the loader doesn't actually load the resulting executables.
2452                 # To avoid breakage, blacklist FreeBSD here at least
2453                 [[ ${CTARGET} == *-freebsd* ]] && return 1
2454
2455                 want_pie || return 1
2456                 use_if_iuse nopie && return 1
2457                 hardened_gcc_is_stable pie
2458                 return $?
2459         elif [[ $1 == "ssp" ]] ; then
2460                 [[ -n ${SPECS_VER} ]] || return 1
2461                 use_if_iuse nossp && return 1
2462                 hardened_gcc_is_stable ssp
2463                 return $?
2464         else
2465                 # laziness ;)
2466                 hardened_gcc_works pie || return 1
2467                 hardened_gcc_works ssp || return 1
2468                 return 0
2469         fi
2470 }
2471
2472 hardened_gcc_is_stable() {
2473         local tocheck
2474         if [[ $1 == "pie" ]] ; then
2475                 if [[ ${CTARGET} == *-uclibc* ]] ; then
2476                         tocheck=${PIE_UCLIBC_STABLE}
2477                 else
2478                         tocheck=${PIE_GLIBC_STABLE}
2479                 fi
2480         elif [[ $1 == "ssp" ]] ; then
2481                 if [[ ${CTARGET} == *-uclibc* ]] ; then
2482                         tocheck=${SSP_UCLIBC_STABLE}
2483                 elif  [[ ${CTARGET} == *-gnu* ]] ; then
2484                         tocheck=${SSP_STABLE}
2485                 fi
2486         else
2487                 die "hardened_gcc_stable needs to be called with pie or ssp"
2488         fi
2489
2490         has $(tc-arch) ${tocheck} && return 0
2491         return 1
2492 }
2493
2494 want_minispecs() {
2495         # on gcc 6 we don't need minispecs
2496         if tc_version_is_at_least 6.0 ; then
2497                 return 0
2498         fi
2499         if tc_version_is_at_least 4.3.2 && use_if_iuse hardened ; then
2500                 if ! want_pie ; then
2501                         ewarn "PIE_VER or SPECS_VER is not defined in the GCC ebuild."
2502                 elif use vanilla ; then
2503                         ewarn "You will not get hardened features if you have the vanilla USE-flag."
2504                 elif use_if_iuse nopie && use_if_iuse nossp ; then
2505                         ewarn "You will not get hardened features if you have the nopie and nossp USE-flag."
2506                 elif ! hardened_gcc_works ; then
2507                         ewarn "Your $(tc-arch) arch is not supported."
2508                 else
2509                         return 0
2510                 fi
2511                 ewarn "Hope you know what you are doing. Hardened will not work."
2512                 return 0
2513         fi
2514         return 1
2515 }
2516
2517 want_pie() {
2518         ! use_if_iuse hardened && [[ -n ${PIE_VER} ]] && use_if_iuse nopie && return 1
2519         [[ -n ${PIE_VER} ]] && [[ -n ${SPECS_VER} ]] && return 0
2520         tc_version_is_at_least 4.3.2 && return 1
2521         [[ -z ${PIE_VER} ]] && return 1
2522         use_if_iuse nopie || return 0
2523         return 1
2524 }
2525
2526 has toolchain_death_notice ${EBUILD_DEATH_HOOKS} || EBUILD_DEATH_HOOKS+=" toolchain_death_notice"
2527 toolchain_death_notice() {
2528         if [[ -e "${WORKDIR}"/build ]] ; then
2529                 pushd "${WORKDIR}"/build >/dev/null
2530                 (echo '' | $(tc-getCC ${CTARGET}) ${CFLAGS} -v -E - 2>&1) > gccinfo.log
2531                 [[ -e "${T}"/build.log ]] && cp "${T}"/build.log .
2532                 tar jcf "${WORKDIR}"/gcc-build-logs.tar.bz2 \
2533                         gccinfo.log build.log $(find -name config.log)
2534                 rm gccinfo.log build.log
2535                 eerror
2536                 eerror "Please include ${WORKDIR}/gcc-build-logs.tar.bz2 in your bug report."
2537                 eerror
2538                 popd >/dev/null
2539         fi
2540 }
2541
2542 # Note [implicitly enabled flags]
2543 # -------------------------------
2544 # Usually configure-based packages handle explicit feature requests
2545 # like
2546 #     ./configure --enable-foo
2547 # as explicit request to check for support of 'foo' and bail out at
2548 # configure time.
2549 #
2550 # GCC does not follow this pattern and instead overrides autodetection
2551 # of the feature and enables it unconditionally.
2552 # See bugs:
2553 #    https://gcc.gnu.org/PR85663 (libsanitizer on mips)
2554 #    https://bugs.gentoo.org/661252 (libvtv on powerpc64)
2555 #
2556 # Thus safer way to enable/disable the feature is to rely on implicit
2557 # enabled-by-default state:
2558 #    econf $(usex foo '' --disable-foo)