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 7
   6
   7 DESCRIPTION="The GNU Compiler Collection"
   8 HOMEPAGE="https://gcc.gnu.org/"
   9
  10 inherit eutils fixheadtails flag-o-matic gnuconfig libtool multilib pax-utils toolchain-funcs prefix
  11
  12 if [[ ${PV} == *9999* ]] ; then
  13         EGIT_REPO_URI="git://gcc.gnu.org/git/gcc.git"
  14         # naming style:
  15         # gcc-10.1.0_pre9999 -> gcc-10-branch
  16         #  Note that the micro version is required or lots of stuff will break.
  17         #  To checkout master set gcc_LIVE_BRANCH="master" in the ebuild before
  18         #  inheriting this eclass.
  19         EGIT_BRANCH="${PN}-${PV%.?.?_pre9999}-branch"
  20         EGIT_BRANCH=${EGIT_BRANCH//./_}
  21         inherit git-r3
  22 fi
  23
  24 FEATURES=${FEATURES/multilib-strict/}
  25
  26 case ${EAPI:-0} in
  27         0|1|2|3|4*) die "Need to upgrade to at least EAPI=5" ;;
  28         5*|6) inherit eapi7-ver ;;
  29         7) ;;
  30         *) die "I don't speak EAPI ${EAPI}." ;;
  31 esac
  32
  33 tc_supports_dostrip() {
  34         case ${EAPI:-0} in
  35                 5*|6) return 1 ;;
  36                 7) return 0 ;;
  37                 *) die "Update apply_patches() for ${EAPI}." ;;
  38         esac
  39 }
  40
  41 tc_supports_dostrip || RESTRICT="strip" # cross-compilers need controlled stripping
  42
  43 EXPORT_FUNCTIONS pkg_pretend pkg_setup src_unpack src_prepare src_configure \
  44         src_compile src_test src_install pkg_postinst pkg_postrm
  45
  46 #---->> globals <<----
  47
  48 export CTARGET=${CTARGET:-${CHOST}}
  49 if [[ ${CTARGET} = ${CHOST} ]] ; then
  50         if [[ ${CATEGORY} == cross-* ]] ; then
  51                 export CTARGET=${CATEGORY#cross-}
  52         fi
  53 fi
  54 : ${TARGET_ABI:=${ABI}}
  55 : ${TARGET_MULTILIB_ABIS:=${MULTILIB_ABIS}}
  56 : ${TARGET_DEFAULT_ABI:=${DEFAULT_ABI}}
  57
  58 is_crosscompile() {
  59         [[ ${CHOST} != ${CTARGET} ]]
  60 }
  61
  62 # General purpose version check.  Without a second arg matches up to minor version (x.x.x)
  63 tc_version_is_at_least() {
  64         ver_test "${2:-${GCC_RELEASE_VER}}" -ge "$1"
  65 }
  66
  67 # General purpose version range check
  68 # Note that it matches up to but NOT including the second version
  69 tc_version_is_between() {
  70         tc_version_is_at_least "${1}" && ! tc_version_is_at_least "${2}"
  71 }
  72
  73 GCC_PV=${TOOLCHAIN_GCC_PV:-${PV}}
  74 GCC_PVR=${GCC_PV}
  75 [[ ${PR} != "r0" ]] && GCC_PVR=${GCC_PVR}-${PR}
  76 GCC_RELEASE_VER=$(ver_cut 1-3 ${GCC_PV})
  77 GCC_BRANCH_VER=$(ver_cut 1-2 ${GCC_PV})
  78 GCCMAJOR=$(ver_cut 1 ${GCC_PV})
  79 GCCMINOR=$(ver_cut 2 ${GCC_PV})
  80 GCCMICRO=$(ver_cut 3 ${GCC_PV})
  81
  82 # According to gcc/c-cppbuiltin.c, GCC_CONFIG_VER MUST match this regex.
  83 # ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?
  84 GCC_CONFIG_VER=${GCC_CONFIG_VER:-$(ver_rs 3 '-' ${GCC_PV})}
  85
  86 # Pre-release support
  87 if [[ ${GCC_PV} == *_pre* ]] ; then
  88         PRERELEASE=${GCC_PV/_pre/-}
  89 elif [[ ${GCC_PV} == *_alpha* ]] ; then
  90         SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_alpha}
  91 elif [[ ${GCC_PV} == *_beta* ]] ; then
  92         SNAPSHOT=${GCC_BRANCH_VER}-${GCC_PV##*_beta}
  93 elif [[ ${GCC_PV} == *_rc* ]] ; then
  94         SNAPSHOT=${GCC_PV%_rc*}-RC-${GCC_PV##*_rc}
  95 fi
  96
  97 if [[ ${SNAPSHOT} == [56789].0-* ]] ; then
  98         # The gcc-5+ releases have dropped the .0 for some reason.
  99         SNAPSHOT=${SNAPSHOT/.0}
 100 fi
 101
 102 PREFIX=${TOOLCHAIN_PREFIX:-${EPREFIX}/usr}
 103
 104 if tc_version_is_at_least 3.4.0 ; then
 105         LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc/${CTARGET}/${GCC_CONFIG_VER}}
 106 else
 107         LIBPATH=${TOOLCHAIN_LIBPATH:-${PREFIX}/lib/gcc-lib/${CTARGET}/${GCC_CONFIG_VER}}
 108 fi
 109 INCLUDEPATH=${TOOLCHAIN_INCLUDEPATH:-${LIBPATH}/include}
 110
 111 if is_crosscompile ; then
 112         BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CHOST}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}}
 113         HOSTLIBPATH=${PREFIX}/${CHOST}/${CTARGET}/lib/${GCC_CONFIG_VER}
 114 else
 115         BINPATH=${TOOLCHAIN_BINPATH:-${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}}
 116 fi
 117
 118 DATAPATH=${TOOLCHAIN_DATAPATH:-${PREFIX}/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}}
 119
 120 # Dont install in /usr/include/g++-v3/, but in gcc internal directory.
 121 # We will handle /usr/include/g++-v3/ with gcc-config ...
 122 STDCXX_INCDIR=${TOOLCHAIN_STDCXX_INCDIR:-${LIBPATH}/include/g++-v${GCC_BRANCH_VER/\.*/}}
 123
 124 #---->> LICENSE+SLOT+IUSE logic <<----
 125
 126 if tc_version_is_at_least 4.6 ; then
 127         LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.3+"
 128 elif tc_version_is_at_least 4.4 ; then
 129         LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ gcc-runtime-library-exception-3.1 ) FDL-1.2+"
 130 elif tc_version_is_at_least 4.3 ; then
 131         LICENSE="GPL-3+ LGPL-3+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+"
 132 elif tc_version_is_at_least 4.2 ; then
 133         LICENSE="GPL-3+ LGPL-2.1+ || ( GPL-3+ libgcc libstdc++ ) FDL-1.2+"
 134 elif tc_version_is_at_least 3.3 ; then
 135         LICENSE="GPL-2+ LGPL-2.1+ FDL-1.2+"
 136 else
 137         LICENSE="GPL-2+ LGPL-2.1+ FDL-1.1+"
 138 fi
 139
 140 IUSE="test vanilla +nls"
 141 RESTRICT="!test? ( test )"
 142
 143 TC_FEATURES=()
 144
 145 tc_has_feature() {
 146         has "$1" "${TC_FEATURES[@]}"
 147 }
 148
 149 if [[ ${PN} != "kgcc64" && ${PN} != gcc-* ]] ; then
 150         IUSE+=" altivec debug +cxx +fortran +nptl" TC_FEATURES+=(fortran nptl)
 151         [[ -n ${PIE_VER} ]] && IUSE+=" nopie"
 152         [[ -n ${HTB_VER} ]] && IUSE+=" boundschecking"
 153         [[ -n ${D_VER}   ]] && IUSE+=" d"
 154         [[ -n ${SPECS_VER} ]] && IUSE+=" nossp"
 155         tc_version_is_at_least 3 && IUSE+=" doc hardened multilib objc"
 156         tc_version_is_between 3 7 && IUSE+=" awt gcj" TC_FEATURES+=(gcj)
 157         tc_version_is_at_least 3.3 && IUSE+=" pgo"
 158         tc_version_is_at_least 4.0 &&
 159                 IUSE+=" objc-gc" TC_FEATURES+=(objc-gc)
 160         tc_version_is_between 4.0 4.9 && IUSE+=" mudflap"
 161         tc_version_is_at_least 4.1 && IUSE+=" libssp objc++"
 162         tc_version_is_at_least 4.2 && IUSE+=" +openmp"
 163         tc_version_is_at_least 4.3 && IUSE+=" fixed-point"
 164         tc_version_is_at_least 4.7 && IUSE+=" go"
 165         # Note: while <=gcc-4.7 also supported graphite, it required forked ppl
 166         # versions which we dropped.  Since graphite was also experimental in
 167         # the older versions, we don't want to bother supporting it.  #448024
 168         tc_version_is_at_least 4.8 &&
 169                 IUSE+=" graphite +sanitize" TC_FEATURES+=(graphite)
 170         tc_version_is_between 4.9 8 && IUSE+=" cilk"
 171         tc_version_is_at_least 4.9 && IUSE+=" +vtv"
 172         tc_version_is_at_least 5.0 && IUSE+=" jit"
 173         tc_version_is_between 5.0 9 && IUSE+=" mpx"
 174         tc_version_is_at_least 6.0 && IUSE+=" +pie +ssp +pch"
 175         # systemtap is a gentoo-specific switch: bug #654748
 176         tc_version_is_at_least 8.0 &&
 177                 IUSE+=" systemtap" TC_FEATURES+=(systemtap)
 178         tc_version_is_at_least 9.0 && IUSE+=" d"
 179         tc_version_is_at_least 9.1 && IUSE+=" lto"
 180 fi
 181
 182 if tc_version_is_at_least 10; then
 183         # Note: currently we pull in prereleases, snapshots and
 184         # git versions into the same SLOT.
 185         SLOT="${GCCMAJOR}"
 186 else
 187         SLOT="${GCC_CONFIG_VER}"
 188 fi
 189
 190 #---->> DEPEND <<----
 191
 192 RDEPEND="sys-libs/zlib
 193         nls? ( virtual/libintl )"
 194
 195 tc_version_is_at_least 3 && RDEPEND+=" virtual/libiconv"
 196
 197 if tc_version_is_at_least 4 ; then
 198         GMP_MPFR_DEPS=">=dev-libs/gmp-4.3.2:0= >=dev-libs/mpfr-2.4.2:0="
 199         if tc_version_is_at_least 4.3 ; then
 200                 RDEPEND+=" ${GMP_MPFR_DEPS}"
 201         elif tc_has_feature fortran ; then
 202                 RDEPEND+=" fortran? ( ${GMP_MPFR_DEPS} )"
 203         fi
 204 fi
 205
 206 tc_version_is_at_least 4.5 && RDEPEND+=" >=dev-libs/mpc-0.8.1:0="
 207
 208 if tc_has_feature objc-gc ; then
 209         if tc_version_is_at_least 7 ; then
 210                 RDEPEND+=" objc-gc? ( >=dev-libs/boehm-gc-7.4.2 )"
 211         fi
 212 fi
 213
 214 if tc_has_feature graphite ; then
 215         if tc_version_is_at_least 5.0 ; then
 216                 RDEPEND+=" graphite? ( >=dev-libs/isl-0.14:0= )"
 217         elif tc_version_is_at_least 4.8 ; then
 218                 RDEPEND+="
 219                         graphite? (
 220                                 >=dev-libs/cloog-0.18.0:0=
 221                                 >=dev-libs/isl-0.11.1:0=
 222                         )"
 223         fi
 224 fi
 225
 226 DEPEND="${RDEPEND}
 227         >=sys-devel/bison-1.875
 228         >=sys-devel/flex-2.5.4
 229         nls? ( sys-devel/gettext )
 230         test? (
 231                 >=dev-util/dejagnu-1.4.4
 232                 >=sys-devel/autogen-5.5.4
 233         )"
 234
 235 if tc_has_feature gcj ; then
 236         GCJ_DEPS=">=media-libs/libart_lgpl-2.1"
 237         GCJ_GTK_DEPS="
 238                 x11-base/xorg-proto
 239                 x11-libs/libXt
 240                 x11-libs/libX11
 241                 x11-libs/libXtst
 242                 =x11-libs/gtk+-2*
 243                 virtual/pkgconfig
 244         "
 245         tc_version_is_at_least 3.4 && GCJ_GTK_DEPS+=" x11-libs/pango"
 246         tc_version_is_at_least 4.2 && GCJ_DEPS+=" app-arch/zip app-arch/unzip"
 247         DEPEND+=" gcj? ( awt? ( ${GCJ_GTK_DEPS} ) ${GCJ_DEPS} )"
 248 fi
 249
 250 if tc_has_feature systemtap ; then
 251         # gcc needs sys/sdt.h headers on target
 252         DEPEND+=" systemtap? ( dev-util/systemtap )"
 253 fi
 254
 255 PDEPEND=">=sys-devel/gcc-config-1.7"
 256
 257 #---->> S + SRC_URI essentials <<----
 258
 259 # Set the source directory depending on whether we're using
 260 # a prerelease, snapshot, or release tarball.
 261 S=$(
 262         if [[ ${PV} == *9999* ]]; then
 263                 echo ${EGIT_CHECKOUT_DIR}
 264         elif [[ -n ${PRERELEASE} ]] ; then
 265                 echo ${WORKDIR}/gcc-${PRERELEASE}
 266         elif [[ -n ${SNAPSHOT} ]] ; then
 267                 echo ${WORKDIR}/gcc-${SNAPSHOT}
 268         else
 269                 echo ${WORKDIR}/gcc-${GCC_RELEASE_VER}
 270         fi
 271 )
 272
 273 gentoo_urls() {
 274         local devspace="HTTP~vapier/dist/URI HTTP~rhill/dist/URI
 275         HTTP~zorry/patches/gcc/URI HTTP~blueness/dist/URI
 276         HTTP~tamiko/distfiles/URI HTTP~slyfox/distfiles/URI"
 277         devspace=${devspace//HTTP/https:\/\/dev.gentoo.org\/}
 278         echo mirror://gentoo/$1 ${devspace//URI/$1}
 279 }
 280
 281 # This function handles the basics of setting the SRC_URI for a gcc ebuild.
 282 # To use, set SRC_URI with:
 283 #
 284 #       SRC_URI="$(get_gcc_src_uri)"
 285 #
 286 # Other than the variables normally set by portage, this function's behavior
 287 # can be altered by setting the following:
 288 #
 289 #       SNAPSHOT
 290 #                       If set, this variable signals that we should be using a snapshot of
 291 #                       gcc. It is expected to be in the format "YYYY-MM-DD". Note that if
 292 #                       the ebuild has a _pre suffix, this variable is ignored and the
 293 #                       prerelease tarball is used instead.
 294 #
 295 #       PATCH_VER
 296 #       PATCH_GCC_VER
 297 #                       This should be set to the version of the gentoo patch tarball.
 298 #                       The resulting filename of this tarball will be:
 299 #                       gcc-${PATCH_GCC_VER:-${GCC_RELEASE_VER}}-patches-${PATCH_VER}.tar.bz2
 300 #
 301 #       PIE_VER
 302 #       PIE_GCC_VER
 303 #                       These variables control patching in various updates for the logic
 304 #                       controlling Position Independant Executables. PIE_VER is expected
 305 #                       to be the version of this patch, and PIE_GCC_VER the gcc version of
 306 #                       the patch:
 307 #                       An example:
 308 #                                       PIE_VER="8.7.6.5"
 309 #                                       PIE_GCC_VER="3.4.0"
 310 #                       The resulting filename of this tarball will be:
 311 #                       gcc-${PIE_GCC_VER:-${GCC_RELEASE_VER}}-piepatches-v${PIE_VER}.tar.bz2
 312 #
 313 #       SPECS_VER
 314 #       SPECS_GCC_VER
 315 #                       This is for the minispecs files included in the hardened gcc-4.x
 316 #                       The specs files for hardenedno*, vanilla and for building the "specs" file.
 317 #                       SPECS_VER is expected to be the version of this patch, SPECS_GCC_VER
 318 #                       the gcc version of the patch.
 319 #                       An example:
 320 #                                       SPECS_VER="8.7.6.5"
 321 #                                       SPECS_GCC_VER="3.4.0"
 322 #                       The resulting filename of this tarball will be:
 323 #                       gcc-${SPECS_GCC_VER:-${GCC_RELEASE_VER}}-specs-${SPECS_VER}.tar.bz2
 324 #
 325 #       HTB_VER
 326 #       HTB_GCC_VER
 327 #                       These variables control whether or not an ebuild supports Herman
 328 #                       ten Brugge's bounds-checking patches. If you want to use a patch
 329 #                       for an older gcc version with a new gcc, make sure you set
 330 #                       HTB_GCC_VER to that version of gcc.
 331 #
 332 #       CYGWINPORTS_GITREV
 333 #                       If set, this variable signals that we should apply additional patches
 334 #                       maintained by upstream Cygwin developers at github/cygwinports/gcc,
 335 #                       using the specified git commit id there.  The list of patches to
 336 #                       apply is extracted from gcc.cygport, maintained there as well.
 337 #                       This is done for compilers running on Cygwin, not for cross compilers
 338 #                       with a Cygwin target.
 339 get_gcc_src_uri() {
 340         export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}}
 341         export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}}
 342         export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}}
 343         export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}}
 344         export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}}
 345
 346         # Set where to download gcc itself depending on whether we're using a
 347         # prerelease, snapshot, or release tarball.
 348         if [[ ${PV} == *9999* ]] ; then
 349                 # Nothing to do w/git snapshots.
 350                 :
 351         elif [[ -n ${PRERELEASE} ]] ; then
 352                 GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/prerelease-${PRERELEASE}/gcc-${PRERELEASE}.tar.bz2"
 353         elif [[ -n ${SNAPSHOT} ]] ; then
 354                 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
 355                         GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.xz"
 356                 else
 357                         GCC_SRC_URI="ftp://gcc.gnu.org/pub/gcc/snapshots/${SNAPSHOT}/gcc-${SNAPSHOT}.tar.bz2"
 358                 fi
 359         else
 360                 if tc_version_is_between 5.5 6 || tc_version_is_between 6.4 7 || tc_version_is_at_least 7.2 ; then
 361                         GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.xz"
 362                 else
 363                         GCC_SRC_URI="mirror://gnu/gcc/gcc-${GCC_PV}/gcc-${GCC_RELEASE_VER}.tar.bz2"
 364                 fi
 365         fi
 366
 367         [[ -n ${UCLIBC_VER} ]] && \
 368                 GCC_SRC_URI+=" $(gentoo_urls gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2)"
 369         [[ -n ${PATCH_VER} ]] && \
 370                 GCC_SRC_URI+=" $(gentoo_urls gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2)"
 371
 372         [[ -n ${PIE_VER} ]] && \
 373                 PIE_CORE=${PIE_CORE:-gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2} && \
 374                 GCC_SRC_URI+=" $(gentoo_urls ${PIE_CORE})"
 375
 376         # gcc minispec for the hardened gcc 4 compiler
 377         [[ -n ${SPECS_VER} ]] && \
 378                 GCC_SRC_URI+=" $(gentoo_urls gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2)"
 379
 380         # gcc bounds checking patch
 381         if [[ -n ${HTB_VER} ]] ; then
 382                 local HTBFILE="bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
 383                 GCC_SRC_URI+="
 384                         boundschecking? (
 385                                 mirror://sourceforge/boundschecking/${HTBFILE}
 386                                 $(gentoo_urls ${HTBFILE})
 387                         )"
 388         fi
 389
 390         [[ -n ${D_VER} ]] && \
 391                 GCC_SRC_URI+=" d? ( mirror://sourceforge/dgcc/gdc-${D_VER}-src.tar.bz2 )"
 392
 393         if tc_has_feature gcj ; then
 394                 if tc_version_is_at_least 4.5 ; then
 395                         GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.5.jar )"
 396                 elif tc_version_is_at_least 4.3 ; then
 397                         GCC_SRC_URI+=" gcj? ( ftp://sourceware.org/pub/java/ecj-4.3.jar )"
 398                 fi
 399         fi
 400
 401         # Cygwin patches from https://github.com/cygwinports/gcc
 402         [[ -n ${CYGWINPORTS_GITREV} ]] && \
 403                 GCC_SRC_URI+=" elibc_Cygwin? ( https://github.com/cygwinports/gcc/archive/${CYGWINPORTS_GITREV}.tar.gz
 404                         -> gcc-cygwinports-${CYGWINPORTS_GITREV}.tar.gz )"
 405
 406         echo "${GCC_SRC_URI}"
 407 }
 408
 409 SRC_URI=$(get_gcc_src_uri)
 410
 411 #---->> pkg_pretend <<----
 412
 413 toolchain_pkg_pretend() {
 414         if [[ -n ${PRERELEASE}${SNAPSHOT} || ${PV} == *9999* ]] &&
 415            [[ -z ${I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS} ]] ; then
 416                 die "Please \`export I_PROMISE_TO_SUPPLY_PATCHES_WITH_BUGS=1\` or define it" \
 417                         "in your make.conf if you want to use this version."
 418         fi
 419
 420         if ! use_if_iuse cxx ; then
 421                 use_if_iuse go && ewarn 'Go requires a C++ compiler, disabled due to USE="-cxx"'
 422                 use_if_iuse objc++ && ewarn 'Obj-C++ requires a C++ compiler, disabled due to USE="-cxx"'
 423                 use_if_iuse gcj && ewarn 'GCJ requires a C++ compiler, disabled due to USE="-cxx"'
 424         fi
 425
 426         want_minispecs
 427 }
 428
 429 #---->> pkg_setup <<----
 430
 431 toolchain_pkg_setup() {
 432         # we dont want to use the installed compiler's specs to build gcc
 433         unset GCC_SPECS
 434         unset LANGUAGES #265283
 435 }
 436
 437 #---->> src_unpack <<----
 438
 439 toolchain_src_unpack() {
 440         if [[ ${PV} == *9999* ]]; then
 441                 git-r3_src_unpack
 442         else
 443                 gcc_quick_unpack
 444         fi
 445 }
 446
 447 gcc_quick_unpack() {
 448         pushd "${WORKDIR}" > /dev/null
 449         export PATCH_GCC_VER=${PATCH_GCC_VER:-${GCC_RELEASE_VER}}
 450         export UCLIBC_GCC_VER=${UCLIBC_GCC_VER:-${PATCH_GCC_VER}}
 451         export PIE_GCC_VER=${PIE_GCC_VER:-${GCC_RELEASE_VER}}
 452         export HTB_GCC_VER=${HTB_GCC_VER:-${GCC_RELEASE_VER}}
 453         export SPECS_GCC_VER=${SPECS_GCC_VER:-${GCC_RELEASE_VER}}
 454
 455         # Injection point for more tarballs. dev-lang/gnat-gpl uses
 456         # 'GCC_A_FAKEIT' to specify it's own source and binary tarballs.
 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         fi
 474
 475         if [[ -n ${D_VER} ]] && use d ; then
 476                 pushd "${S}"/gcc > /dev/null
 477                 unpack gdc-${D_VER}-src.tar.bz2
 478                 cd ..
 479                 ebegin "Adding support for the D language"
 480                 ./gcc/d/setup-gcc.sh >& "${T}"/dgcc.log
 481                 if ! eend $? ; then
 482                         eerror "The D GCC package failed to apply"
 483                         eerror "Please include this log file when posting a bug report:"
 484                         eerror "  ${T}/dgcc.log"
 485                         die "failed to include the D language"
 486                 fi
 487                 popd > /dev/null
 488         fi
 489
 490         [[ -n ${PATCH_VER} ]] && \
 491                 unpack gcc-${PATCH_GCC_VER}-patches-${PATCH_VER}.tar.bz2
 492
 493         [[ -n ${UCLIBC_VER} ]] && \
 494                 unpack gcc-${UCLIBC_GCC_VER}-uclibc-patches-${UCLIBC_VER}.tar.bz2
 495
 496         if want_pie ; then
 497                 if [[ -n ${PIE_CORE} ]] ; then
 498                         unpack ${PIE_CORE}
 499                 else
 500                         unpack gcc-${PIE_GCC_VER}-piepatches-v${PIE_VER}.tar.bz2
 501                 fi
 502                 [[ -n ${SPECS_VER} ]] && \
 503                         unpack gcc-${SPECS_GCC_VER}-specs-${SPECS_VER}.tar.bz2
 504         fi
 505
 506         use_if_iuse boundschecking && unpack "bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch.bz2"
 507
 508         [[ -n ${CYGWINPORTS_GITREV} ]] && use elibc_Cygwin && unpack "gcc-cygwinports-${CYGWINPORTS_GITREV}.tar.gz"
 509
 510         popd > /dev/null
 511 }
 512
 513 #---->> src_prepare <<----
 514
 515 # 'epatch' is not available in EAPI=7. Abstract away patchset application
 516 # until we eventually get all gcc ebuilds on EAPI=7 or later.
 517 tc_apply_patches() {
 518         [[ ${#@} -lt 2 ]] && die "usage: tc_apply_patches <message> <patches...>"
 519
 520         einfo "$1"; shift
 521
 522         case ${EAPI:-0} in
 523                 # Note: even for EAPI=6 we used 'epatch' semantics. To avoid
 524                 # breaking existing ebuilds use 'eapply' only in EAPI=7 or later.
 525                 5*|6) epatch "$@" ;;
 526                 7) eapply "$@" ;;
 527                 *) die "Update apply_patches() for ${EAPI}." ;;
 528         esac
 529 }
 530
 531 toolchain_src_prepare() {
 532         export BRANDING_GCC_PKGVERSION="Gentoo ${GCC_PVR}"
 533         cd "${S}"
 534
 535         do_gcc_gentoo_patches
 536         do_gcc_HTB_patches
 537         do_gcc_PIE_patches
 538         do_gcc_CYGWINPORTS_patches
 539
 540         case ${EAPI:-0} in
 541                 5*) epatch_user;;
 542                 6|7) eapply_user ;;
 543                 *) die "Update toolchain_src_prepare() for ${EAPI}." ;;
 544         esac
 545
 546         if ( tc_version_is_at_least 4.8.2 || use_if_iuse hardened ) && ! use vanilla ; then
 547                 make_gcc_hard
 548         fi
 549
 550         # install the libstdc++ python into the right location
 551         # http://gcc.gnu.org/PR51368
 552         if tc_version_is_between 4.5 4.7 ; then
 553                 sed -i \
 554                         '/^pythondir =/s:=.*:= $(datadir)/python:' \
 555                         "${S}"/libstdc++-v3/python/Makefile.in || die
 556         fi
 557
 558         # make sure the pkg config files install into multilib dirs.
 559         # since we configure with just one --libdir, we can't use that
 560         # (as gcc itself takes care of building multilibs).  #435728
 561         find "${S}" -name Makefile.in \
 562                 -exec sed -i '/^pkgconfigdir/s:=.*:=$(toolexeclibdir)/pkgconfig:' {} +
 563
 564         # No idea when this first started being fixed, but let's go with 4.3.x for now
 565         if ! tc_version_is_at_least 4.3 ; then
 566                 fix_files=""
 567                 for x in contrib/test_summary libstdc++-v3/scripts/check_survey.in ; do
 568                         [[ -e ${x} ]] && fix_files="${fix_files} ${x}"
 569                 done
 570                 ht_fix_file ${fix_files} */configure *.sh */Makefile.in
 571         fi
 572
 573         setup_multilib_osdirnames
 574         gcc_version_patch
 575
 576         if tc_version_is_at_least 4.1 ; then
 577                 if [[ -n ${SNAPSHOT} || -n ${PRERELEASE} ]] ; then
 578                         # BASE-VER must be a three-digit version number
 579                         # followed by an optional -pre string
 580                         #   eg. 4.5.1, 4.6.2-pre20120213, 4.7.0-pre9999
 581                         # If BASE-VER differs from ${PV/_/-} then libraries get installed in
 582                         # the wrong directory.
 583                         echo ${PV/_/-} > "${S}"/gcc/BASE-VER
 584                 fi
 585         fi
 586
 587         # >= gcc-4.3 doesn't bundle ecj.jar, so copy it
 588         if tc_version_is_at_least 4.3 && use_if_iuse gcj ; then
 589                 if tc_version_is_at_least 4.5 ; then
 590                         einfo "Copying ecj-4.5.jar"
 591                         cp -pPR "${DISTDIR}/ecj-4.5.jar" "${S}/ecj.jar" || die
 592                 else
 593                         einfo "Copying ecj-4.3.jar"
 594                         cp -pPR "${DISTDIR}/ecj-4.3.jar" "${S}/ecj.jar" || die
 595                 fi
 596         fi
 597
 598         # disable --as-needed from being compiled into gcc specs
 599         # natively when using a gcc version < 3.4.4
 600         # http://gcc.gnu.org/PR14992
 601         if ! tc_version_is_at_least 3.4.4 ; then
 602                 sed -i -e s/HAVE_LD_AS_NEEDED/USE_LD_AS_NEEDED/g "${S}"/gcc/config.in
 603         fi
 604
 605         # In gcc 3.3.x and 3.4.x, rename the java bins to gcc-specific names
 606         # in line with gcc-4.
 607         if tc_version_is_between 3.3 4.0 ; then
 608                 do_gcc_rename_java_bins
 609         fi
 610
 611         # Prevent libffi from being installed
 612         if tc_version_is_between 3.0 4.8 ; then
 613                 sed -i -e 's/\(install.*:\) install-.*recursive/\1/' "${S}"/libffi/Makefile.in || die
 614                 sed -i -e 's/\(install-data-am:\).*/\1/' "${S}"/libffi/include/Makefile.in || die
 615         fi
 616
 617         # Fixup libtool to correctly generate .la files with portage
 618         elibtoolize --portage --shallow --no-uclibc
 619
 620         gnuconfig_update
 621
 622         # update configure files
 623         local f
 624         einfo "Fixing misc issues in configure files"
 625         for f in $(grep -l 'autoconf version 2.13' $(find "${S}" -name configure)) ; do
 626                 ebegin "  Updating ${f/${S}\/} [LANG]"
 627                 patch "${f}" "${FILESDIR}"/gcc-configure-LANG.patch >& "${T}"/configure-patch.log \
 628                         || eerror "Please file a bug about this"
 629                 eend $?
 630         done
 631         sed -i 's|A-Za-z0-9|[:alnum:]|g' "${S}"/gcc/*.awk #215828
 632
 633         # Prevent new texinfo from breaking old versions (see #198182, #464008)
 634         if tc_version_is_at_least 4.1; then
 635                 tc_apply_patches "Remove texinfo (bug #198182, bug ##464008)" "${FILESDIR}"/gcc-configure-texinfo.patch
 636         fi
 637
 638         # >=gcc-4
 639         if [[ -x contrib/gcc_update ]] ; then
 640                 einfo "Touching generated files"
 641                 ./contrib/gcc_update --touch | \
 642                         while read f ; do
 643                                 einfo "  ${f%%...}"
 644                         done
 645         fi
 646 }
 647
 648 do_gcc_gentoo_patches() {
 649         if ! use vanilla ; then
 650                 if [[ -n ${PATCH_VER} ]] ; then
 651                         tc_apply_patches "Applying Gentoo patches ..." "${WORKDIR}"/patch/*.patch
 652                         BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION} p${PATCH_VER}"
 653                 fi
 654                 if [[ -n ${UCLIBC_VER} ]] ; then
 655                         tc_apply_patches "Applying uClibc patches ..." "${WORKDIR}"/uclibc/*.patch
 656                 fi
 657         fi
 658 }
 659
 660 do_gcc_HTB_patches() {
 661         use_if_iuse boundschecking || return 0
 662
 663         # modify the bounds checking patch with a regression patch
 664         tc_apply_patches "Bounds checking patch" "${WORKDIR}/bounds-checking-gcc-${HTB_GCC_VER}-${HTB_VER}.patch"
 665         BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, HTB-${HTB_GCC_VER}-${HTB_VER}"
 666 }
 667
 668 do_gcc_PIE_patches() {
 669         want_pie || return 0
 670         use vanilla && return 0
 671
 672         tc_apply_patches "Applying pie patches ..." "${WORKDIR}"/piepatch/*.patch
 673
 674         BRANDING_GCC_PKGVERSION="${BRANDING_GCC_PKGVERSION}, pie-${PIE_VER}"
 675 }
 676
 677 do_gcc_CYGWINPORTS_patches() {
 678         [[ -n ${CYGWINPORTS_GITREV} ]] || return 0
 679         use elibc_Cygwin || return 0
 680
 681         local p d="${WORKDIR}/gcc-${CYGWINPORTS_GITREV}"
 682         # readarray -t is available since bash-4.4 only, #690686
 683         local patches=( $(sed -e '1,/PATCH_URI="/d;/"/,$d' < "${d}"/gcc.cygport) )
 684         tc_apply_patches "Applying cygwin port patches ..." ${patches[*]}
 685 }
 686
 687 # configure to build with the hardened GCC specs as the default
 688 make_gcc_hard() {
 689         local gcc_hard_flags=""
 690
 691         # If we use gcc-6 or newer with pie enable to compile older gcc we need to pass -no-pie
 692         # to stage1; bug #618908
 693         if ! tc_version_is_at_least 6.0 && [[ $(gcc-major-version) -ge 6 ]] ; then
 694                 einfo "Disabling PIE in stage1 (only) ..."
 695                 sed -i -e "/^STAGE1_LDFLAGS/ s/$/ -no-pie/" "${S}"/Makefile.in || die
 696         fi
 697
 698         # Gcc >= 6.X we can use configurations options to turn pie/ssp on as default
 699         if tc_version_is_at_least 6.0 ; then
 700                 if use_if_iuse pie ; then
 701                         einfo "Updating gcc to use automatic PIE building ..."
 702                 fi
 703                 if use_if_iuse ssp ; then
 704                         einfo "Updating gcc to use automatic SSP building ..."
 705                 fi
 706                 if use_if_iuse hardened ; then
 707                         # Will add some hardened options as default, like:
 708                         # -fstack-clash-protection
 709                         # -z now
 710                         # see *_all_extra-options.patch gcc patches.
 711                         gcc_hard_flags+=" -DEXTRA_OPTIONS"
 712                         # rebrand to make bug reports easier
 713                         BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened}
 714                 fi
 715         else
 716                 if use_if_iuse hardened ; then
 717                         # rebrand to make bug reports easier
 718                         BRANDING_GCC_PKGVERSION=${BRANDING_GCC_PKGVERSION/Gentoo/Gentoo Hardened}
 719                         if hardened_gcc_works ; then
 720                                 einfo "Updating gcc to use automatic PIE + SSP building ..."
 721                                 gcc_hard_flags+=" -DEFAULT_PIE_SSP"
 722                         elif hardened_gcc_works pie ; then
 723                                 einfo "Updating gcc to use automatic PIE building ..."
 724                                 ewarn "SSP has not been enabled by default"
 725                                 gcc_hard_flags+=" -DEFAULT_PIE"
 726                         elif hardened_gcc_works ssp ; then
 727                                 einfo "Updating gcc to use automatic SSP building ..."
 728                                 ewarn "PIE has not been enabled by default"
 729                                 gcc_hard_flags+=" -DEFAULT_SSP"
 730                         else
 731                                 # do nothing if hardened isn't supported, but don't die either
 732                                 ewarn "hardened is not supported for this arch in this gcc version"
 733                                 return 0
 734                         fi
 735                 else
 736                         if hardened_gcc_works ssp ; then
 737                                 einfo "Updating gcc to use automatic SSP building ..."
 738                                 gcc_hard_flags+=" -DEFAULT_SSP"
 739                         fi
 740                 fi
 741         fi
 742
 743         # we want to be able to control the pie patch logic via something other
 744         # than ALL_CFLAGS...
 745         sed -e '/^ALL_CFLAGS/iHARD_CFLAGS = ' \
 746                 -e 's|^ALL_CFLAGS = |ALL_CFLAGS = $(HARD_CFLAGS) |' \
 747                 -i "${S}"/gcc/Makefile.in
 748         # Need to add HARD_CFLAGS to ALL_CXXFLAGS on >= 4.7
 749         if tc_version_is_at_least 4.7 ; then
 750                 sed -e '/^ALL_CXXFLAGS/iHARD_CFLAGS = ' \
 751                         -e 's|^ALL_CXXFLAGS = |ALL_CXXFLAGS = $(HARD_CFLAGS) |' \
 752                         -i "${S}"/gcc/Makefile.in
 753         fi
 754
 755         sed -i \
 756                 -e "/^HARD_CFLAGS = /s|=|= ${gcc_hard_flags} |" \
 757                 "${S}"/gcc/Makefile.in || die
 758
 759 }
 760
 761 # This is a historical wart.  The original Gentoo/amd64 port used:
 762 #    lib32 - 32bit binaries (x86)
 763 #    lib64 - 64bit binaries (x86_64)
 764 #    lib   - "native" binaries (a symlink to lib64)
 765 # Most other distros use the logic (including mainline gcc):
 766 #    lib   - 32bit binaries (x86)
 767 #    lib64 - 64bit binaries (x86_64)
 768 # Over time, Gentoo is migrating to the latter form.
 769 #
 770 # Unfortunately, due to distros picking the lib32 behavior, newer gcc
 771 # versions will dynamically detect whether to use lib or lib32 for its
 772 # 32bit multilib.  So, to keep the automagic from getting things wrong
 773 # while people are transitioning from the old style to the new style,
 774 # we always set the MULTILIB_OSDIRNAMES var for relevant targets.
 775 setup_multilib_osdirnames() {
 776         is_multilib || return 0
 777
 778         local config
 779         local libdirs="../lib64 ../lib32"
 780
 781         # this only makes sense for some Linux targets
 782         case ${CTARGET} in
 783         x86_64*-linux*)    config="i386" ;;
 784         powerpc64*-linux*) config="rs6000" ;;
 785         sparc64*-linux*)   config="sparc" ;;
 786         s390x*-linux*)     config="s390" ;;
 787         *)                     return 0 ;;
 788         esac
 789         config+="/t-linux64"
 790
 791         local sed_args=()
 792         if tc_version_is_at_least 4.6 ; then
 793                 sed_args+=( -e 's:$[(]call if_multiarch[^)]*[)]::g' )
 794         fi
 795         if [[ ${SYMLINK_LIB} == "yes" ]] ; then
 796                 einfo "updating multilib directories to be: ${libdirs}"
 797                 if tc_version_is_at_least 4.6.4 || tc_version_is_at_least 4.7 ; then
 798                         sed_args+=( -e '/^MULTILIB_OSDIRNAMES.*lib32/s:[$][(]if.*):../lib32:' )
 799                 else
 800                         sed_args+=( -e "/^MULTILIB_OSDIRNAMES/s:=.*:= ${libdirs}:" )
 801                 fi
 802         else
 803                 einfo "using upstream multilib; disabling lib32 autodetection"
 804                 sed_args+=( -r -e 's:[$][(]if.*,(.*)[)]:\1:' )
 805         fi
 806         sed -i "${sed_args[@]}" "${S}"/gcc/config/${config} || die
 807 }
 808
 809 gcc_version_patch() {
 810         # gcc-4.3+ has configure flags (whoo!)
 811         tc_version_is_at_least 4.3 && return 0
 812
 813         local version_string=${GCC_CONFIG_VER}
 814
 815         einfo "patching gcc version: ${version_string} (${BRANDING_GCC_PKGVERSION})"
 816
 817         local gcc_sed=( -e 's:gcc\.gnu\.org/bugs\.html:bugs\.gentoo\.org/:' )
 818         if grep -qs VERSUFFIX "${S}"/gcc/version.c ; then
 819                 gcc_sed+=( -e "/VERSUFFIX \"\"/s:\"\":\" (${BRANDING_GCC_PKGVERSION})\":" )
 820         else
 821                 version_string="${version_string} (${BRANDING_GCC_PKGVERSION})"
 822                 gcc_sed+=( -e "/const char version_string\[\] = /s:= \".*\":= \"${version_string}\":" )
 823         fi
 824         sed -i "${gcc_sed[@]}" "${S}"/gcc/version.c || die
 825 }
 826
 827 do_gcc_rename_java_bins() {
 828         # bug #139918 - conflict between gcc and java-config-2 for ownership of
 829         # /usr/bin/rmi{c,registry}.      Done with mv & sed rather than a patch
 830         # because patches would be large (thanks to the rename of man files),
 831         # and it's clear from the sed invocations that all that changes is the
 832         # rmi{c,registry} names to grmi{c,registry} names.
 833         # Kevin F. Quinn 2006-07-12
 834         einfo "Renaming jdk executables rmic and rmiregistry to grmic and grmiregistry."
 835         # 1) Move the man files if present (missing prior to gcc-3.4)
 836         for manfile in rmic rmiregistry ; do
 837                 [[ -f ${S}/gcc/doc/${manfile}.1 ]] || continue
 838                 mv "${S}"/gcc/doc/${manfile}.1 "${S}"/gcc/doc/g${manfile}.1
 839         done
 840         # 2) Fixup references in the docs if present (mission prior to gcc-3.4)
 841         for jfile in gcc/doc/gcj.info gcc/doc/grmic.1 gcc/doc/grmiregistry.1 gcc/java/gcj.texi ; do
 842                 [[ -f ${S}/${jfile} ]] || continue
 843                 sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} ||
 844                         die "Failed to fixup file ${jfile} for rename to grmiregistry"
 845                 sed -i -e 's:rmic:grmic:g' "${S}"/${jfile} ||
 846                         die "Failed to fixup file ${jfile} for rename to grmic"
 847         done
 848         # 3) Fixup Makefiles to build the changed executable names
 849         #        These are present in all 3.x versions, and are the important bit
 850         #        to get gcc to build with the new names.
 851         for jfile in libjava/Makefile.am libjava/Makefile.in gcc/java/Make-lang.in ; do
 852                 sed -i -e 's:rmiregistry:grmiregistry:g' "${S}"/${jfile} ||
 853                         die "Failed to fixup file ${jfile} for rename to grmiregistry"
 854                 # Careful with rmic on these files; it's also the name of a directory
 855                 # which should be left unchanged.  Replace occurrences of 'rmic$',
 856                 # 'rmic_' and 'rmic '.
 857                 sed -i -e 's:rmic\([$_ ]\):grmic\1:g' "${S}"/${jfile} ||
 858                         die "Failed to fixup file ${jfile} for rename to grmic"
 859         done
 860 }
 861
 862 #---->> src_configure <<----
 863
 864 toolchain_src_configure() {
 865         downgrade_arch_flags
 866         gcc_do_filter_flags
 867
 868         einfo "CFLAGS=\"${CFLAGS}\""
 869         einfo "CXXFLAGS=\"${CXXFLAGS}\""
 870         einfo "LDFLAGS=\"${LDFLAGS}\""
 871
 872         # Force internal zip based jar script to avoid random
 873         # issues with 3rd party jar implementations.  #384291
 874         export JAR=no
 875
 876         # For hardened gcc 4.3 piepatchset to build the hardened specs
 877         # file (build.specs) to use when building gcc.
 878         if ! tc_version_is_at_least 4.4 && want_minispecs ; then
 879                 setup_minispecs_gcc_build_specs
 880         fi
 881
 882         local confgcc=( --host=${CHOST} )
 883
 884         if is_crosscompile || tc-is-cross-compiler ; then
 885                 # Straight from the GCC install doc:
 886                 # "GCC has code to correctly determine the correct value for target
 887                 # for nearly all native systems. Therefore, we highly recommend you
 888                 # not provide a configure target when configuring a native compiler."
 889                 confgcc+=( --target=${CTARGET} )
 890         fi
 891         [[ -n ${CBUILD} ]] && confgcc+=( --build=${CBUILD} )
 892
 893         confgcc+=(
 894                 --prefix="${PREFIX}"
 895                 --bindir="${BINPATH}"
 896                 --includedir="${INCLUDEPATH}"
 897                 --datadir="${DATAPATH}"
 898                 --mandir="${DATAPATH}/man"
 899                 --infodir="${DATAPATH}/info"
 900                 --with-gxx-include-dir="${STDCXX_INCDIR}"
 901         )
 902
 903         # Stick the python scripts in their own slotted directory (bug #279252)
 904         #
 905         #  --with-python-dir=DIR
 906         #  Specifies where to install the Python modules used for aot-compile. DIR
 907         #  should not include the prefix used in installation. For example, if the
 908         #  Python modules are to be installed in /usr/lib/python2.5/site-packages,
 909         #  then --with-python-dir=/lib/python2.5/site-packages should be passed.
 910         #
 911         # This should translate into "/share/gcc-data/${CTARGET}/${GCC_CONFIG_VER}/python"
 912         if tc_version_is_at_least 4.4 ; then
 913                 confgcc+=( --with-python-dir=${DATAPATH/$PREFIX/}/python )
 914         fi
 915
 916         ### language options
 917
 918         local GCC_LANG="c"
 919         is_cxx && GCC_LANG+=",c++"
 920         is_d   && GCC_LANG+=",d"
 921         is_gcj && GCC_LANG+=",java"
 922         is_go  && GCC_LANG+=",go"
 923         is_jit && GCC_LANG+=",jit"
 924         if is_objc || is_objcxx ; then
 925                 GCC_LANG+=",objc"
 926                 if tc_version_is_at_least 4 ; then
 927                         use objc-gc && confgcc+=( --enable-objc-gc )
 928                 fi
 929                 is_objcxx && GCC_LANG+=",obj-c++"
 930         fi
 931
 932         # fortran support just got sillier! the lang value can be f77 for
 933         # fortran77, f95 for fortran95, or just plain old fortran for the
 934         # currently supported standard depending on gcc version.
 935         is_fortran && GCC_LANG+=",fortran"
 936         is_f77 && GCC_LANG+=",f77"
 937         is_f95 && GCC_LANG+=",f95"
 938
 939         # We do NOT want 'ADA support' in here!
 940         # is_ada && GCC_LANG+=",ada"
 941
 942         confgcc+=( --enable-languages=${GCC_LANG} )
 943
 944         ### general options
 945
 946         confgcc+=(
 947                 --enable-obsolete
 948                 --enable-secureplt
 949                 --disable-werror
 950                 --with-system-zlib
 951         )
 952
 953         if use nls ; then
 954                 confgcc+=( --enable-nls --without-included-gettext )
 955         else
 956                 confgcc+=( --disable-nls )
 957         fi
 958
 959         tc_version_is_at_least 3.4 || confgcc+=( --disable-libunwind-exceptions )
 960
 961         # Use the default ("release") checking because upstream usually neglects
 962         # to test "disabled" so it has a history of breaking. bug #317217
 963         if tc_version_is_at_least 3.4 && in_iuse debug ; then
 964                 # The "release" keyword is new to 4.0. bug #551636
 965                 local off=$(tc_version_is_at_least 4.0 && echo release || echo no)
 966                 confgcc+=( --enable-checking="${GCC_CHECKS_LIST:-$(usex debug yes ${off})}" )
 967         fi
 968
 969         # Branding
 970         tc_version_is_at_least 4.3 && confgcc+=(
 971                 --with-bugurl=https://bugs.gentoo.org/
 972                 --with-pkgversion="${BRANDING_GCC_PKGVERSION}"
 973         )
 974
 975         # If we want hardened support with the newer piepatchset for >=gcc 4.4
 976         if tc_version_is_at_least 4.4 && want_minispecs && in_iuse hardened ; then
 977                 confgcc+=( $(use_enable hardened esp) )
 978         fi
 979
 980         # allow gcc to search for clock funcs in the main C lib.
 981         # if it can't find them, then tough cookies -- we aren't
 982         # going to link in -lrt to all C++ apps. bug #411681
 983         if tc_version_is_at_least 4.4 && is_cxx ; then
 984                 confgcc+=( --enable-libstdcxx-time )
 985         fi
 986
 987         # Build compiler itself using LTO
 988         if tc_version_is_at_least 9.1 && use_if_iuse lto ; then
 989                 confgcc+=( --with-build-config=bootstrap-lto )
 990         fi
 991
 992         # Support to disable pch when building libstdcxx
 993         if tc_version_is_at_least 6.0 && ! use_if_iuse pch ; then
 994                 confgcc+=( --disable-libstdcxx-pch )
 995         fi
 996
 997         # The jit language requires this.
 998         is_jit && confgcc+=( --enable-host-shared )
 999
1000         # build-id was disabled for file collisions: bug #526144
1001         #
1002         # # Turn on the -Wl,--build-id flag by default for ELF targets. bug #525942
1003         # # This helps with locating debug files.
1004         # case ${CTARGET} in
1005         # *-linux-*|*-elf|*-eabi)
1006         #       tc_version_is_at_least 4.5 && confgcc+=(
1007         #               --enable-linker-build-id
1008         #       )
1009         #       ;;
1010         # esac
1011
1012         # newer gcc versions like to bootstrap themselves with C++,
1013         # so we need to manually disable it ourselves
1014         if tc_version_is_between 4.7 4.8 && ! is_cxx ; then
1015                 confgcc+=( --disable-build-with-cxx --disable-build-poststage1-with-cxx )
1016         fi
1017
1018         ### Cross-compiler options
1019         if is_crosscompile ; then
1020                 # Enable build warnings by default with cross-compilers when system
1021                 # paths are included (e.g. via -I flags).
1022                 confgcc+=( --enable-poison-system-directories )
1023
1024                 # When building a stage1 cross-compiler (just C compiler), we have to
1025                 # disable a bunch of features or gcc goes boom
1026                 local needed_libc=""
1027                 case ${CTARGET} in
1028                 *-linux)                 needed_libc=error-unknown-libc;;
1029                 *-dietlibc)              needed_libc=dietlibc;;
1030                 *-elf|*-eabi)
1031                         needed_libc=newlib
1032                         # Bare-metal targets don't have access to clock_gettime()
1033                         # arm-none-eabi example: bug #589672
1034                         # But we explicitly do --enable-libstdcxx-time above.
1035                         # Undoing it here.
1036                         confgcc+=( --disable-libstdcxx-time )
1037                         ;;
1038                 *-freebsd*)              needed_libc=freebsd-lib;;
1039                 *-gnu*)                  needed_libc=glibc;;
1040                 *-klibc)                 needed_libc=klibc;;
1041                 *-musl*)                 needed_libc=musl;;
1042                 *-uclibc*)
1043                         # Enable shared library support only on targets
1044                         # that support it: bug #291870
1045                         if ! echo '#include <features.h>' | \
1046                            $(tc-getCPP ${CTARGET}) -E -dD - 2>/dev/null | \
1047                            grep -q __HAVE_SHARED__
1048                         then
1049                                 confgcc+=( --disable-shared )
1050                         fi
1051                         needed_libc=uclibc-ng
1052                         ;;
1053                 *-cygwin)                needed_libc=cygwin;;
1054                 x86_64-*-mingw*|\
1055                 *-w64-mingw*)    needed_libc=mingw64-runtime;;
1056                 avr)                     confgcc+=( --enable-shared --disable-threads );;
1057                 esac
1058                 if [[ -n ${needed_libc} ]] ; then
1059                         local confgcc_no_libc=( --disable-shared )
1060                         tc_version_is_at_least 4.8 && confgcc_no_libc+=( --disable-libatomic )
1061                         if ! has_version ${CATEGORY}/${needed_libc} ; then
1062                                 confgcc+=(
1063                                         "${confgcc_no_libc[@]}"
1064                                         --disable-threads
1065                                         --without-headers
1066                                 )
1067                         elif has_version "${CATEGORY}/${needed_libc}[headers-only(-)]" ; then
1068                                 confgcc+=(
1069                                         "${confgcc_no_libc[@]}"
1070                                         --with-sysroot="${PREFIX}"/${CTARGET}
1071                                 )
1072                         else
1073                                 confgcc+=( --with-sysroot="${PREFIX}"/${CTARGET} )
1074                         fi
1075                 fi
1076
1077                 tc_version_is_at_least 4.2 && confgcc+=( --disable-bootstrap )
1078         else
1079                 if tc-is-static-only ; then
1080                         confgcc+=( --disable-shared )
1081                 else
1082                         confgcc+=( --enable-shared )
1083                 fi
1084                 case ${CHOST} in
1085                 mingw*|*-mingw*)
1086                         confgcc+=( --enable-threads=win32 ) ;;
1087                 *)
1088                         confgcc+=( --enable-threads=posix ) ;;
1089                 esac
1090         fi
1091
1092         # __cxa_atexit is "essential for fully standards-compliant handling of
1093         # destructors", but apparently requires glibc.
1094         case ${CTARGET} in
1095         *-uclibc*)
1096                 if tc_has_feature nptl ; then
1097                         confgcc+=(
1098                                 --disable-__cxa_atexit
1099                                 $(use_enable nptl tls)
1100                         )
1101                 fi
1102                 tc_version_is_between 3.3 3.4 && confgcc+=( --enable-sjlj-exceptions )
1103                 if tc_version_is_between 3.4 4.3 ; then
1104                         confgcc+=( --enable-clocale=uclibc )
1105                 fi
1106                 ;;
1107         *-elf|*-eabi)
1108                 confgcc+=( --with-newlib )
1109                 ;;
1110         *-musl*)
1111                 confgcc+=( --enable-__cxa_atexit )
1112                 ;;
1113         *-gnu*)
1114                 confgcc+=(
1115                         --enable-__cxa_atexit
1116                         --enable-clocale=gnu
1117                 )
1118                 ;;
1119         *-freebsd*)
1120                 confgcc+=( --enable-__cxa_atexit )
1121                 ;;
1122         *-solaris*)
1123                 confgcc+=( --enable-__cxa_atexit )
1124                 ;;
1125         esac
1126
1127         ### arch options
1128
1129         gcc-multilib-configure
1130
1131         # ppc altivec support
1132         in_iuse altivec && confgcc+=( $(use_enable altivec) )
1133
1134         # gcc has fixed-point arithmetic support in 4.3 for mips targets that can
1135         # significantly increase compile time by several hours.  This will allow
1136         # users to control this feature in the event they need the support.
1137         tc_version_is_at_least 4.3 && in_iuse fixed-point && confgcc+=( $(use_enable fixed-point) )
1138
1139         case $(tc-is-softfloat) in
1140         yes)    confgcc+=( --with-float=soft ) ;;
1141         softfp) confgcc+=( --with-float=softfp ) ;;
1142         *)
1143                 # If they've explicitly opt-ed in, do hardfloat,
1144                 # otherwise let the gcc default kick in.
1145                 case ${CTARGET//_/-} in
1146                 *-hardfloat-*|*eabihf) confgcc+=( --with-float=hard ) ;;
1147                 esac
1148         esac
1149
1150         local with_abi_map=()
1151         case $(tc-arch) in
1152         arm)    #264534 #414395
1153                 local a arm_arch=${CTARGET%%-*}
1154                 # Remove trailing endian variations first: eb el be bl b l
1155                 for a in e{b,l} {b,l}e b l ; do
1156                         if [[ ${arm_arch} == *${a} ]] ; then
1157                                 arm_arch=${arm_arch%${a}}
1158                                 break
1159                         fi
1160                 done
1161                 # Convert armv7{a,r,m} to armv7-{a,r,m}
1162                 [[ ${arm_arch} == armv7? ]] && arm_arch=${arm_arch/7/7-}
1163                 # See if this is a valid --with-arch flag
1164                 if (srcdir=${S}/gcc target=${CTARGET} with_arch=${arm_arch};
1165                     . "${srcdir}"/config.gcc) &>/dev/null
1166                 then
1167                         confgcc+=( --with-arch=${arm_arch} )
1168                 fi
1169
1170                 # Make default mode thumb for microcontroller classes #418209
1171                 [[ ${arm_arch} == *-m ]] && confgcc+=( --with-mode=thumb )
1172
1173                 # Enable hardvfp
1174                 if [[ $(tc-is-softfloat) == "no" ]] && \
1175                    [[ ${CTARGET} == armv[67]* ]] && \
1176                    tc_version_is_at_least 4.5
1177                 then
1178                         # Follow the new arm hardfp distro standard by default
1179                         confgcc+=( --with-float=hard )
1180                         case ${CTARGET} in
1181                         armv6*) confgcc+=( --with-fpu=vfp ) ;;
1182                         armv7*) confgcc+=( --with-fpu=vfpv3-d16 ) ;;
1183                         esac
1184                 fi
1185                 ;;
1186         mips)
1187                 # Add --with-abi flags to set default ABI
1188                 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1189                 ;;
1190         amd64)
1191                 # drop the older/ABI checks once this get's merged into some
1192                 # version of gcc upstream
1193                 if tc_version_is_at_least 4.8 && has x32 $(get_all_abis TARGET) ; then
1194                         confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1195                 fi
1196                 ;;
1197         x86)
1198                 # Default arch for x86 is normally i386, lets give it a bump
1199                 # since glibc will do so based on CTARGET anyways
1200                 confgcc+=( --with-arch=${CTARGET%%-*} )
1201                 ;;
1202         hppa)
1203                 # Enable sjlj exceptions for backward compatibility on hppa
1204                 [[ ${GCCMAJOR} == "3" ]] && confgcc+=( --enable-sjlj-exceptions )
1205                 ;;
1206         ppc)
1207                 # Set up defaults based on current CFLAGS
1208                 is-flagq -mfloat-gprs=double && confgcc+=( --enable-e500-double )
1209                 [[ ${CTARGET//_/-} == *-e500v2-* ]] && confgcc+=( --enable-e500-double )
1210                 ;;
1211         riscv)
1212                 # Add --with-abi flags to set default ABI
1213                 confgcc+=( --with-abi=$(gcc-abi-map ${TARGET_DEFAULT_ABI}) )
1214                 ;;
1215         esac
1216
1217         # if the target can do biarch (-m32/-m64), enable it.  overhead should
1218         # be small, and should simplify building of 64bit kernels in a 32bit
1219         # userland by not needing sys-devel/kgcc64.  #349405
1220         case $(tc-arch) in
1221         ppc|ppc64) tc_version_is_at_least 3.4 && confgcc+=( --enable-targets=all ) ;;
1222         sparc)     tc_version_is_at_least 4.4 && confgcc+=( --enable-targets=all ) ;;
1223         amd64|x86) tc_version_is_at_least 4.3 && confgcc+=( --enable-targets=all ) ;;
1224         esac
1225
1226         # On Darwin we need libdir to be set in order to get correct install names
1227         # for things like libobjc-gnu, libgcj and libfortran.  If we enable it on
1228         # non-Darwin we screw up the behaviour this eclass relies on.  We in
1229         # particular need this over --libdir for bug #255315.
1230         [[ ${CTARGET} == *-darwin* ]] && \
1231                 confgcc+=( --enable-version-specific-runtime-libs )
1232
1233         ### library options
1234
1235         if tc_version_is_between 3.0 7.0 ; then
1236                 if is_gcj ; then
1237                         confgcc+=( --disable-gjdoc )
1238                         use awt && confgcc+=( --enable-java-awt=gtk )
1239                 else
1240                         confgcc+=( --disable-libgcj )
1241                 fi
1242         fi
1243
1244         if tc_version_is_at_least 4.2 ; then
1245                 if in_iuse openmp ; then
1246                         # Make sure target has pthreads support. #326757 #335883
1247                         # There shouldn't be a chicken & egg problem here as openmp won't
1248                         # build without a C library, and you can't build that w/out
1249                         # already having a compiler ...
1250                         if ! is_crosscompile || \
1251                            $(tc-getCPP ${CTARGET}) -E - <<<"#include <pthread.h>" >& /dev/null
1252                         then
1253                                 confgcc+=( $(use_enable openmp libgomp) )
1254                         else
1255                                 # Force disable as the configure script can be dumb #359855
1256                                 confgcc+=( --disable-libgomp )
1257                         fi
1258                 else
1259                         # For gcc variants where we don't want openmp (e.g. kgcc)
1260                         confgcc+=( --disable-libgomp )
1261                 fi
1262         fi
1263
1264         if tc_version_is_at_least 4.0 ; then
1265                 if in_iuse mudflap ; then
1266                         confgcc+=( $(use_enable mudflap libmudflap) )
1267                 else
1268                         confgcc+=( --disable-libmudflap )
1269                 fi
1270
1271                 if use_if_iuse libssp ; then
1272                         confgcc+=( --enable-libssp )
1273                 else
1274                         if hardened_gcc_is_stable ssp; then
1275                                 export gcc_cv_libc_provides_ssp=yes
1276                         fi
1277                         if use_if_iuse ssp; then
1278                                 # On some targets USE="ssp -libssp" is an invalid
1279                                 # configuration as target libc does not provide
1280                                 # stack_chk_* functions. Do not disable libssp there.
1281                                 case ${CTARGET} in
1282                                         mingw*|*-mingw*) ewarn "Not disabling libssp" ;;
1283                                         *) confgcc+=( --disable-libssp ) ;;
1284                                 esac
1285                         else
1286                                 confgcc+=( --disable-libssp )
1287                         fi
1288                 fi
1289         fi
1290
1291         if in_iuse cilk ; then
1292                 confgcc+=( $(use_enable cilk libcilkrts) )
1293         fi
1294
1295         if in_iuse mpx ; then
1296                 confgcc+=( $(use_enable mpx libmpx) )
1297         fi
1298
1299         if in_iuse systemtap ; then
1300                 confgcc+=( $(use_enable systemtap) )
1301         fi
1302
1303         if in_iuse vtv ; then
1304                 confgcc+=(
1305                         $(use_enable vtv vtable-verify)
1306                         # See Note [implicitly enabled flags]
1307                         $(usex vtv '' --disable-libvtv)
1308                 )
1309         fi
1310
1311         # newer gcc's come with libquadmath, but only fortran uses
1312         # it, so auto punt it when we don't care
1313         if tc_version_is_at_least 4.6 && ! is_fortran ; then
1314                 confgcc+=( --disable-libquadmath )
1315         fi
1316
1317         if tc_version_is_at_least 4.6 ; then
1318                 confgcc+=( --enable-lto )
1319         elif tc_version_is_at_least 4.5 ; then
1320                 confgcc+=( --disable-lto )
1321         fi
1322
1323         # graphite was added in 4.4 but we only support it in 4.8+ due to external
1324         # library issues.  #448024
1325         if tc_version_is_at_least 5.0 && in_iuse graphite ; then
1326                 confgcc+=( $(use_with graphite isl) )
1327                 use graphite && confgcc+=( --disable-isl-version-check )
1328         elif tc_version_is_at_least 4.8 && in_iuse graphite ; then
1329                 confgcc+=( $(use_with graphite cloog) )
1330                 use graphite && confgcc+=( --disable-isl-version-check )
1331         elif tc_version_is_at_least 4.4 ; then
1332                 confgcc+=( --without-{cloog,ppl} )
1333         fi
1334
1335         if tc_version_is_at_least 4.8 && in_iuse sanitize ; then
1336                 # See Note [implicitly enabled flags]
1337                 confgcc+=( $(usex sanitize '' --disable-libsanitizer) )
1338         fi
1339
1340         if tc_version_is_at_least 6.0 && in_iuse pie ; then
1341                 confgcc+=( $(use_enable pie default-pie) )
1342         fi
1343
1344         if tc_version_is_at_least 6.0 && in_iuse ssp ; then
1345                 confgcc+=(
1346                         # This defaults to -fstack-protector-strong.
1347                         $(use_enable ssp default-ssp)
1348                 )
1349         fi
1350
1351         # Disable gcc info regeneration -- it ships with generated info pages
1352         # already.  Our custom version/urls/etc... trigger it.  #464008
1353         export gcc_cv_prog_makeinfo_modern=no
1354
1355         # Do not let the X detection get in our way.  We know things can be found
1356         # via system paths, so no need to hardcode things that'll break multilib.
1357         # Older gcc versions will detect ac_x_libraries=/usr/lib64 which ends up
1358         # killing the 32bit builds which want /usr/lib.
1359         export ac_cv_have_x='have_x=yes ac_x_includes= ac_x_libraries='
1360
1361         confgcc+=( "$@" ${EXTRA_ECONF} )
1362
1363         # Nothing wrong with a good dose of verbosity
1364         echo
1365         einfo "PREFIX:          ${PREFIX}"
1366         einfo "BINPATH:         ${BINPATH}"
1367         einfo "LIBPATH:         ${LIBPATH}"
1368         einfo "DATAPATH:        ${DATAPATH}"
1369         einfo "STDCXX_INCDIR:   ${STDCXX_INCDIR}"
1370         echo
1371         einfo "Languages:       ${GCC_LANG}"
1372         echo
1373         einfo "Configuring GCC with: ${confgcc[@]//--/\n\t--}"
1374         echo
1375
1376         # Build in a separate build tree
1377         mkdir -p "${WORKDIR}"/build
1378         pushd "${WORKDIR}"/build > /dev/null
1379
1380         # and now to do the actual configuration
1381         addwrite /dev/zero
1382         echo "${S}"/configure "${confgcc[@]}"
1383         # Older gcc versions did not detect bash and re-exec itself, so force the
1384         # use of bash.  Newer ones will auto-detect, but this is not harmful.
1385         CONFIG_SHELL="${EPREFIX}/bin/bash" \
1386         bash "${S}"/configure "${confgcc[@]}" || die "failed to run configure"
1387
1388         # return to whatever directory we were in before
1389         popd > /dev/null
1390 }
1391
1392 # Replace -m flags unsupported by the version being built with the best
1393 # available equivalent
1394 downgrade_arch_flags() {
1395         local arch bver i isa myarch mytune rep ver
1396
1397         bver=${1:-${GCC_BRANCH_VER}}
1398         [[ $(gcc-version) < ${bver} ]] && return 0
1399         [[ $(tc-arch) != amd64 && $(tc-arch) != x86 ]] && return 0
1400
1401         myarch=$(get-flag march)
1402         mytune=$(get-flag mtune)
1403
1404         # If -march=native isn't supported we have to tease out the actual arch
1405         if [[ ${myarch} == native || ${mytune} == native ]] ; then
1406                 if [[ ${bver} < 4.2 ]] ; then
1407                         arch=$($(tc-getCC) -march=native -v -E -P - </dev/null 2>&1 \
1408                                 | sed -rn "/cc1.*-march/s:.*-march=([^ ']*).*:\1:p")
1409                         replace-cpu-flags native ${arch}
1410                 fi
1411         fi
1412
1413         # Handle special -mtune flags
1414         [[ ${mytune} == intel && ${bver} < 4.9 ]] && replace-cpu-flags intel generic
1415         [[ ${mytune} == generic && ${bver} < 4.2 ]] && filter-flags '-mtune=*'
1416         [[ ${mytune} == x86-64 ]] && filter-flags '-mtune=*'
1417         [[ ${bver} < 3.4 ]] && filter-flags '-mtune=*'
1418
1419         # "added" "arch" "replacement"
1420         local archlist=(
1421                 4.9 bdver4 bdver3
1422                 4.9 bonnell atom
1423                 4.9 broadwell core-avx2
1424                 4.9 haswell core-avx2
1425                 4.9 ivybridge core-avx-i
1426                 4.9 nehalem corei7
1427                 4.9 sandybridge corei7-avx
1428                 4.9 silvermont corei7
1429                 4.9 westmere corei7
1430                 4.8 bdver3 bdver2
1431                 4.8 btver2 btver1
1432                 4.7 bdver2 bdver1
1433                 4.7 core-avx2 core-avx-i
1434                 4.6 bdver1 amdfam10
1435                 4.6 btver1 amdfam10
1436                 4.6 core-avx-i core2
1437                 4.6 corei7 core2
1438                 4.6 corei7-avx core2
1439                 4.5 atom core2
1440                 4.3 amdfam10 k8
1441                 4.3 athlon64-sse3 k8
1442                 4.3 barcelona k8
1443                 4.3 core2 nocona
1444                 4.3 geode k6-2 # gcc.gnu.org/PR41989#c22
1445                 4.3 k8-sse3 k8
1446                 4.3 opteron-sse3 k8
1447                 3.4 athlon-fx x86-64
1448                 3.4 athlon64 x86-64
1449                 3.4 c3-2 c3
1450                 3.4 k8 x86-64
1451                 3.4 opteron x86-64
1452                 3.4 pentium-m pentium3
1453                 3.4 pentium3m pentium3
1454                 3.4 pentium4m pentium4
1455         )
1456
1457         for ((i = 0; i < ${#archlist[@]}; i += 3)) ; do
1458                 myarch=$(get-flag march)
1459                 mytune=$(get-flag mtune)
1460
1461                 ver=${archlist[i]}
1462                 arch=${archlist[i + 1]}
1463                 rep=${archlist[i + 2]}
1464
1465                 [[ ${myarch} != ${arch} && ${mytune} != ${arch} ]] && continue
1466
1467                 if [[ ${ver} > ${bver} ]] ; then
1468                         einfo "Replacing ${myarch} (added in gcc ${ver}) with ${rep}..."
1469                         [[ ${myarch} == ${arch} ]] && replace-cpu-flags ${myarch} ${rep}
1470                         [[ ${mytune} == ${arch} ]] && replace-cpu-flags ${mytune} ${rep}
1471                         continue
1472                 else
1473                         break
1474                 fi
1475         done
1476
1477         # we only check -mno* here since -m* get removed by strip-flags later on
1478         local isalist=(
1479                 4.9 -mno-sha
1480                 4.9 -mno-avx512pf
1481                 4.9 -mno-avx512f
1482                 4.9 -mno-avx512er
1483                 4.9 -mno-avx512cd
1484                 4.8 -mno-xsaveopt
1485                 4.8 -mno-xsave
1486                 4.8 -mno-rtm
1487                 4.8 -mno-fxsr
1488                 4.7 -mno-lzcnt
1489                 4.7 -mno-bmi2
1490                 4.7 -mno-avx2
1491                 4.6 -mno-tbm
1492                 4.6 -mno-rdrnd
1493                 4.6 -mno-fsgsbase
1494                 4.6 -mno-f16c
1495                 4.6 -mno-bmi
1496                 4.5 -mno-xop
1497                 4.5 -mno-movbe
1498                 4.5 -mno-lwp
1499                 4.5 -mno-fma4
1500                 4.4 -mno-pclmul
1501                 4.4 -mno-fma
1502                 4.4 -mno-avx
1503                 4.4 -mno-aes
1504                 4.3 -mno-ssse3
1505                 4.3 -mno-sse4a
1506                 4.3 -mno-sse4
1507                 4.3 -mno-sse4.2
1508                 4.3 -mno-sse4.1
1509                 4.3 -mno-popcnt
1510                 4.3 -mno-abm
1511         )
1512
1513         for ((i = 0; i < ${#isalist[@]}; i += 2)) ; do
1514                 ver=${isalist[i]}
1515                 isa=${isalist[i + 1]}
1516                 [[ ${ver} > ${bver} ]] && filter-flags ${isa} ${isa/-m/-mno-}
1517         done
1518 }
1519
1520 gcc_do_filter_flags() {
1521         strip-flags
1522         replace-flags -O? -O2
1523
1524         # dont want to funk ourselves
1525         filter-flags '-mabi*' -m31 -m32 -m64
1526
1527         filter-flags -frecord-gcc-switches # 490738
1528         filter-flags -mno-rtm -mno-htm # 506202
1529
1530         if tc_version_is_between 3.2 3.4 ; then
1531                 # XXX: this is so outdated it's barely useful, but it don't hurt...
1532                 replace-cpu-flags G3 750
1533                 replace-cpu-flags G4 7400
1534                 replace-cpu-flags G5 7400
1535
1536                 # XXX: should add a sed or something to query all supported flags
1537                 #      from the gcc source and trim everything else ...
1538                 filter-flags -f{no-,}unit-at-a-time -f{no-,}web -mno-tls-direct-seg-refs
1539                 filter-flags -f{no-,}stack-protector{,-all}
1540                 filter-flags -fvisibility-inlines-hidden -fvisibility=hidden
1541                 # and warning options
1542                 filter-flags -Wextra -Wstack-protector
1543         fi
1544         if ! tc_version_is_at_least 4.1 ; then
1545                 filter-flags -fdiagnostics-show-option
1546                 filter-flags -Wstack-protector
1547         fi
1548
1549         if tc_version_is_between 6 8 ; then
1550                 # -mstackrealign triggers crashes in exception throwing
1551                 # at least on ada: bug #688580
1552                 # The reason is unknown. Drop the flag for now.
1553                 filter-flags -mstackrealign
1554         fi
1555
1556         if tc_version_is_at_least 3.4 ; then
1557                 case $(tc-arch) in
1558                         amd64|x86)
1559                                 filter-flags '-mcpu=*'
1560
1561                                 tc_version_is_between 4.4 4.5 && append-flags -mno-avx # 357287
1562
1563                                 if tc_version_is_between 4.6 4.7 ; then
1564                                         # https://bugs.gentoo.org/411333
1565                                         # https://bugs.gentoo.org/466454
1566                                         replace-cpu-flags c3-2 pentium2 pentium3 pentium3m pentium-m i686
1567                                 fi
1568                                 ;;
1569                         alpha)
1570                                 # https://bugs.gentoo.org/454426
1571                                 append-ldflags -Wl,--no-relax
1572                                 ;;
1573                         sparc)
1574                                 # temporary workaround for random ICEs reproduced by multiple users
1575                                 # https://bugs.gentoo.org/457062
1576                                 tc_version_is_between 4.6 4.8 && MAKEOPTS+=" -j1"
1577                                 ;;
1578                         *-macos)
1579                                 # http://gcc.gnu.org/PR25127
1580                                 tc_version_is_between 4.0 4.2 && \
1581                                         filter-flags '-mcpu=*' '-march=*' '-mtune=*'
1582                                 ;;
1583                 esac
1584         fi
1585
1586         strip-unsupported-flags
1587
1588         # these are set here so we have something sane at configure time
1589         if is_crosscompile ; then
1590                 # Set this to something sane for both native and target
1591                 CFLAGS="-O2 -pipe"
1592                 FFLAGS=${CFLAGS}
1593                 FCFLAGS=${CFLAGS}
1594
1595                 # "hppa2.0-unknown-linux-gnu" -> hppa2_0_unknown_linux_gnu
1596                 local VAR="CFLAGS_"${CTARGET//[-.]/_}
1597                 CXXFLAGS=${!VAR-${CFLAGS}}
1598         fi
1599
1600         export GCJFLAGS=${GCJFLAGS:-${CFLAGS}}
1601 }
1602
1603 setup_minispecs_gcc_build_specs() {
1604         # Setup the "build.specs" file for gcc 4.3 to use when building.
1605         if hardened_gcc_works pie ; then
1606                 cat "${WORKDIR}"/specs/pie.specs >> "${WORKDIR}"/build.specs
1607         fi
1608         if hardened_gcc_works ssp ; then
1609                 for s in ssp sspall ; do
1610                         cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1611                 done
1612         fi
1613         for s in nostrict znow ; do
1614                 cat "${WORKDIR}"/specs/${s}.specs >> "${WORKDIR}"/build.specs
1615         done
1616         export GCC_SPECS="${WORKDIR}"/build.specs
1617 }
1618
1619 gcc-multilib-configure() {
1620         if ! is_multilib ; then
1621                 confgcc+=( --disable-multilib )
1622                 # Fun times: if we are building for a target that has multiple
1623                 # possible ABI formats, and the user has told us to pick one
1624                 # that isn't the default, then not specifying it via the list
1625                 # below will break that on us.
1626         else
1627                 confgcc+=( --enable-multilib )
1628         fi
1629
1630         # translate our notion of multilibs into gcc's
1631         local abi list
1632         for abi in $(get_all_abis TARGET) ; do
1633                 local l=$(gcc-abi-map ${abi})
1634                 [[ -n ${l} ]] && list+=",${l}"
1635         done
1636         if [[ -n ${list} ]] ; then
1637                 case ${CTARGET} in
1638                 x86_64*)
1639                         tc_version_is_at_least 4.8 && confgcc+=( --with-multilib-list=${list:1} )
1640                         ;;
1641                 esac
1642         fi
1643 }
1644
1645 gcc-abi-map() {
1646         # Convert the ABI name we use in Gentoo to what gcc uses
1647         local map=()
1648         case ${CTARGET} in
1649         mips*)   map=("o32 32" "n32 n32" "n64 64") ;;
1650         riscv*)  map=("lp64d lp64d" "lp64 lp64") ;;
1651         x86_64*) map=("amd64 m64" "x86 m32" "x32 mx32") ;;
1652         esac
1653
1654         local m
1655         for m in "${map[@]}" ; do
1656                 l=( ${m} )
1657                 [[ $1 == ${l[0]} ]] && echo ${l[1]} && break
1658         done
1659 }
1660
1661 #----> src_compile <----
1662
1663 toolchain_src_compile() {
1664         touch "${S}"/gcc/c-gperf.h
1665
1666         # Do not make manpages if we do not have perl ...
1667         [[ ! -x /usr/bin/perl ]] \
1668                 && find "${WORKDIR}"/build -name '*.[17]' -exec touch {} +
1669
1670         # Older gcc versions did not detect bash and re-exec itself, so force the
1671         # use of bash.  Newer ones will auto-detect, but this is not harmful.
1672         # This needs to be set for compile as well, as it's used in libtool
1673         # generation, which will break install otherwise (at least in 3.3.6): #664486
1674         CONFIG_SHELL="${EPREFIX}/bin/bash" \
1675         gcc_do_make ${GCC_MAKE_TARGET}
1676 }
1677
1678 gcc_do_make() {
1679         # This function accepts one optional argument, the make target to be used.
1680         # If omitted, gcc_do_make will try to guess whether it should use all,
1681         # or bootstrap-lean depending on CTARGET and arch.
1682         # An example of how to use this function:
1683         #
1684         #       gcc_do_make all-target-libstdc++-v3
1685
1686         [[ -n ${1} ]] && GCC_MAKE_TARGET=${1}
1687
1688         # default target
1689         if is_crosscompile || tc-is-cross-compiler ; then
1690                 # 3 stage bootstrapping doesnt quite work when you cant run the
1691                 # resulting binaries natively ^^;
1692                 GCC_MAKE_TARGET=${GCC_MAKE_TARGET-all}
1693         else
1694                 if tc_version_is_at_least 3.3 && use_if_iuse pgo; then
1695                         GCC_MAKE_TARGET=${GCC_MAKE_TARGET-profiledbootstrap}
1696                 else
1697                         GCC_MAKE_TARGET=${GCC_MAKE_TARGET-bootstrap-lean}
1698                 fi
1699         fi
1700
1701         # Older versions of GCC could not do profiledbootstrap in parallel due to
1702         # collisions with profiling info.
1703         # boundschecking also seems to introduce parallel build issues.
1704         if [[ ${GCC_MAKE_TARGET} == "profiledbootstrap" ]] || use_if_iuse boundschecking ; then
1705                 ! tc_version_is_at_least 4.6 && export MAKEOPTS="${MAKEOPTS} -j1"
1706         fi
1707
1708         if [[ ${GCC_MAKE_TARGET} == "all" ]] ; then
1709                 STAGE1_CFLAGS=${STAGE1_CFLAGS-"${CFLAGS}"}
1710         elif [[ $(gcc-version) == "3.4" && ${GCC_BRANCH_VER} == "3.4" ]] && gcc-specs-ssp ; then
1711                 # See bug #79852
1712                 STAGE1_CFLAGS=${STAGE1_CFLAGS-"-O2"}
1713         fi
1714
1715         if is_crosscompile; then
1716                 # In 3.4, BOOT_CFLAGS is never used on a crosscompile...
1717                 # but I'll leave this in anyways as someone might have had
1718                 # some reason for putting it in here... --eradicator
1719                 BOOT_CFLAGS=${BOOT_CFLAGS-"-O2"}
1720         else
1721                 # we only want to use the system's CFLAGS if not building a
1722                 # cross-compiler.
1723                 BOOT_CFLAGS=${BOOT_CFLAGS-"$(get_abi_CFLAGS ${TARGET_DEFAULT_ABI}) ${CFLAGS}"}
1724         fi
1725
1726         einfo "Compiling ${PN} (${GCC_MAKE_TARGET})..."
1727
1728         pushd "${WORKDIR}"/build >/dev/null
1729
1730         emake \
1731                 LDFLAGS="${LDFLAGS}" \
1732                 STAGE1_CFLAGS="${STAGE1_CFLAGS}" \
1733                 LIBPATH="${LIBPATH}" \
1734                 BOOT_CFLAGS="${BOOT_CFLAGS}" \
1735                 ${GCC_MAKE_TARGET} \
1736                 || die "emake failed with ${GCC_MAKE_TARGET}"
1737
1738         if ! is_crosscompile && use_if_iuse cxx && use_if_iuse doc ; then
1739                 if type -p doxygen > /dev/null ; then
1740                         if tc_version_is_at_least 4.3 ; then
1741                                 cd "${CTARGET}"/libstdc++-v3/doc
1742                                 emake doc-man-doxygen || ewarn "failed to make docs"
1743                         elif tc_version_is_at_least 3.0 ; then
1744                                 cd "${CTARGET}"/libstdc++-v3
1745                                 emake doxygen-man || ewarn "failed to make docs"
1746                         fi
1747                         # Clean bogus manpages.  #113902
1748                         find -name '*_build_*' -delete
1749                         # Blow away generated directory references.  Newer versions of gcc
1750                         # have gotten better at this, but not perfect.  This is easier than
1751                         # backporting all of the various doxygen patches.  #486754
1752                         find -name '*_.3' -exec grep -l ' Directory Reference ' {} + | \
1753                                 xargs rm -f
1754                 else
1755                         ewarn "Skipping libstdc++ manpage generation since you don't have doxygen installed"
1756                 fi
1757         fi
1758
1759         popd >/dev/null
1760 }
1761
1762 #---->> src_test <<----
1763
1764 toolchain_src_test() {
1765         cd "${WORKDIR}"/build
1766         # enable verbose test run and result logging
1767         emake -k check
1768 }
1769
1770 #---->> src_install <<----
1771
1772 toolchain_src_install() {
1773         cd "${WORKDIR}"/build
1774
1775         # Don't 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         create_revdep_rebuild_entry
1820
1821         # Setup the gcc_env_entry for hardened gcc 4 with minispecs
1822         want_minispecs && copy_minispecs_gcc_specs
1823
1824         # Make sure we dont have stuff lying around that
1825         # can nuke multiple versions of gcc
1826         gcc_slot_java
1827
1828         dodir /usr/bin
1829         cd "${D}"${BINPATH}
1830         # Ugh: we really need to auto-detect this list.
1831         #      It's constantly out of date.
1832         for x in cpp gcc g++ c++ gcov g77 gcj gcjh gfortran gccgo ; do
1833                 # For some reason, g77 gets made instead of ${CTARGET}-g77...
1834                 # this should take care of that
1835                 if [[ -f ${x} ]] ; then
1836                         # In case they're hardlinks, clear out the target first
1837                         # otherwise the mv below will complain.
1838                         rm -f ${CTARGET}-${x}
1839                         mv ${x} ${CTARGET}-${x}
1840                 fi
1841
1842                 if [[ -f ${CTARGET}-${x} ]] ; then
1843                         if ! is_crosscompile ; then
1844                                 ln -sf ${CTARGET}-${x} ${x}
1845                                 dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1846                                         /usr/bin/${x}-${GCC_CONFIG_VER}
1847                         fi
1848                         # Create versioned symlinks
1849                         dosym ${BINPATH#${EPREFIX}}/${CTARGET}-${x} \
1850                                 /usr/bin/${CTARGET}-${x}-${GCC_CONFIG_VER}
1851                 fi
1852
1853                 if [[ -f ${CTARGET}-${x}-${GCC_CONFIG_VER} ]] ; then
1854                         rm -f ${CTARGET}-${x}-${GCC_CONFIG_VER}
1855                         ln -sf ${CTARGET}-${x} ${CTARGET}-${x}-${GCC_CONFIG_VER}
1856                 fi
1857         done
1858
1859         # When gcc builds a crosscompiler it does not install unprefixed tools.
1860         # When cross-building gcc does install native tools.
1861         if ! is_crosscompile; then
1862                 # Rename the main go binaries as we don't want to clobber dev-lang/go
1863                 # when gcc-config runs. #567806
1864                 if tc_version_is_at_least 5 && is_go ; then
1865                         for x in go gofmt; do
1866                                 mv ${x} ${x}-${GCCMAJOR} || die
1867                         done
1868                 fi
1869         fi
1870
1871         # As gcc installs object files built against bost ${CHOST} and ${CTARGET}
1872         # ideally we will need to strip them 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         # As dostrip does not specify host to override ${CHOST} tools just skip
1880         # non-native binary stripping.
1881         is_crosscompile && tc_supports_dostrip && dostrip -x "${LIBPATH}"
1882
1883         cd "${S}"
1884         if is_crosscompile; then
1885                 rm -rf "${ED}"/usr/share/{man,info}
1886                 rm -rf "${D}"${DATAPATH}/{man,info}
1887         else
1888                 if tc_version_is_at_least 3.0 ; then
1889                         local cxx_mandir=$(find "${WORKDIR}/build/${CTARGET}/libstdc++-v3" -name man)
1890                         if [[ -d ${cxx_mandir} ]] ; then
1891                                 cp -r "${cxx_mandir}"/man? "${D}${DATAPATH}"/man/
1892                         fi
1893                 fi
1894         fi
1895
1896         # portage regenerates 'dir' files on it's own: bug #672408
1897         # Drop 'dir' files to avoid collisions.
1898         if [[ -f "${D}${DATAPATH}"/info/dir ]]; then
1899                 einfo "Deleting '${D}${DATAPATH}/info/dir'"
1900                 rm "${D}${DATAPATH}"/info/dir || die
1901         fi
1902
1903         # prune empty dirs left behind
1904         find "${ED}" -depth -type d -delete 2>/dev/null
1905
1906         # Rather install the script, else portage with changing $FILESDIR
1907         # between binary and source package borks things ....
1908         if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
1909                 insinto "${DATAPATH#${EPREFIX}}"
1910                 newins "$(prefixify_ro "${FILESDIR}"/awk/fixlafiles.awk-no_gcc_la)" fixlafiles.awk || die
1911                 exeinto "${DATAPATH#${EPREFIX}}"
1912                 doexe "$(prefixify_ro "${FILESDIR}"/fix_libtool_files.sh)" || die
1913                 doexe "${FILESDIR}"/c{89,99} || die
1914         fi
1915
1916         # libstdc++.la: Delete as it doesn't add anything useful: g++ itself
1917         # handles linkage correctly in the dynamic & static case.  It also just
1918         # causes us pain: any C++ progs/libs linking with libtool will gain a
1919         # reference to the full libstdc++.la file which is gcc version specific.
1920         # libstdc++fs.la: It doesn't link against anything useful.
1921         # libsupc++.la: This has no dependencies.
1922         # libcc1.la: There is no static library, only dynamic.
1923         # libcc1plugin.la: Same as above, and it's loaded via dlopen.
1924         # libcp1plugin.la: Same as above, and it's loaded via dlopen.
1925         # libgomp.la: gcc itself handles linkage (libgomp.spec).
1926         # libgomp-plugin-*.la: Same as above, and it's an internal plugin only
1927         # loaded via dlopen.
1928         # libgfortran.la: gfortran itself handles linkage correctly in the
1929         # dynamic & static case (libgfortran.spec). #573302
1930         # libgfortranbegin.la: Same as above, and it's an internal lib.
1931         # libmpx.la: gcc itself handles linkage correctly (libmpx.spec).
1932         # libmpxwrappers.la: See above.
1933         # libitm.la: gcc itself handles linkage correctly (libitm.spec).
1934         # libvtv.la: gcc itself handles linkage correctly.
1935         # lib*san.la: Sanitizer linkage is handled internally by gcc, and they
1936         # do not support static linking. #487550 #546700
1937         find "${D}${LIBPATH}" \
1938                 '(' \
1939                         -name libstdc++.la -o \
1940                         -name libstdc++fs.la -o \
1941                         -name libsupc++.la -o \
1942                         -name libcc1.la -o \
1943                         -name libcc1plugin.la -o \
1944                         -name libcp1plugin.la -o \
1945                         -name 'libgomp.la' -o \
1946                         -name 'libgomp-plugin-*.la' -o \
1947                         -name libgfortran.la -o \
1948                         -name libgfortranbegin.la -o \
1949                         -name libmpx.la -o \
1950                         -name libmpxwrappers.la -o \
1951                         -name libitm.la -o \
1952                         -name libvtv.la -o \
1953                         -name 'lib*san.la' \
1954                 ')' -type f -delete
1955
1956         # Use gid of 0 because some stupid ports don't have
1957         # the group 'root' set to gid 0.  Send to /dev/null
1958         # for people who are testing as non-root.
1959         chown -R root:0 "${D}${LIBPATH}" 2>/dev/null
1960
1961         # Installing gdb pretty-printers into gdb-specific location.
1962         local py gdbdir=/usr/share/gdb/auto-load${LIBPATH}
1963         pushd "${D}${LIBPATH}" >/dev/null
1964         for py in $(find . -name '*-gdb.py') ; do
1965                 local multidir=${py%/*}
1966                 insinto "${gdbdir}/${multidir}"
1967                 sed -i "/^libdir =/s:=.*:= '${LIBPATH}/${multidir}':" "${py}" || die #348128
1968                 doins "${py}" || die
1969                 rm "${py}" || die
1970         done
1971         popd >/dev/null
1972
1973         # Don't scan .gox files for executable stacks - false positives
1974         export QA_EXECSTACK="usr/lib*/go/*/*.gox"
1975         export QA_WX_LOAD="usr/lib*/go/*/*.gox"
1976
1977         # Disable RANDMMAP so PCH works. #301299
1978         if tc_version_is_at_least 4.3 ; then
1979                 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1"
1980                 pax-mark -r "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/cc1plus"
1981         fi
1982
1983         # Disable MPROTECT so java works. #574808
1984         if is_gcj ; then
1985                 pax-mark -m "${D}${PREFIX}/libexec/gcc/${CTARGET}/${GCC_CONFIG_VER}/ecj1"
1986                 pax-mark -m "${D}${PREFIX}/${CTARGET}/gcc-bin/${GCC_CONFIG_VER}/gij"
1987         fi
1988 }
1989
1990 # Move around the libs to the right location.  For some reason,
1991 # when installing gcc, it dumps internal libraries into /usr/lib
1992 # instead of the private gcc lib path
1993 gcc_movelibs() {
1994         # older versions of gcc did not support --print-multi-os-directory
1995         tc_version_is_at_least 3.2 || return 0
1996
1997         # For non-target libs which are for CHOST and not CTARGET, we want to
1998         # move them to the compiler-specific CHOST internal dir.  This is stuff
1999         # that you want to link against when building tools rather than building
2000         # code to run on the target.
2001         if tc_version_is_at_least 5 && is_crosscompile ; then
2002                 dodir "${HOSTLIBPATH#${EPREFIX}}"
2003                 mv "${ED}"/usr/$(get_libdir)/libcc1* "${D}${HOSTLIBPATH}" || die
2004         fi
2005
2006         # For all the libs that are built for CTARGET, move them into the
2007         # compiler-specific CTARGET internal dir.
2008         local x multiarg removedirs=""
2009         for multiarg in $($(XGCC) -print-multi-lib) ; do
2010                 multiarg=${multiarg#*;}
2011                 multiarg=${multiarg//@/ -}
2012
2013                 local OS_MULTIDIR=$($(XGCC) ${multiarg} --print-multi-os-directory)
2014                 local MULTIDIR=$($(XGCC) ${multiarg} --print-multi-directory)
2015                 local TODIR="${D}${LIBPATH}"/${MULTIDIR}
2016                 local FROMDIR=
2017
2018                 [[ -d ${TODIR} ]] || mkdir -p ${TODIR}
2019
2020                 for FROMDIR in \
2021                         "${LIBPATH}"/${OS_MULTIDIR} \
2022                         "${LIBPATH}"/../${MULTIDIR} \
2023                         "${PREFIX}"/lib/${OS_MULTIDIR} \
2024                         "${PREFIX}"/${CTARGET}/lib/${OS_MULTIDIR}
2025                 do
2026                         removedirs="${removedirs} ${FROMDIR}"
2027                         FROMDIR=${D}${FROMDIR}
2028                         if [[ ${FROMDIR} != "${TODIR}" && -d ${FROMDIR} ]] ; then
2029                                 local files=$(find "${FROMDIR}" -maxdepth 1 ! -type d 2>/dev/null)
2030                                 if [[ -n ${files} ]] ; then
2031                                         mv ${files} "${TODIR}" || die
2032                                 fi
2033                         fi
2034                 done
2035                 fix_libtool_libdir_paths "${LIBPATH}/${MULTIDIR}"
2036
2037                 # SLOT up libgcj.pc if it's available (and let gcc-config worry about links)
2038                 FROMDIR="${PREFIX}/lib/${OS_MULTIDIR}"
2039                 for x in "${D}${FROMDIR}"/pkgconfig/libgcj*.pc ; do
2040                         [[ -f ${x} ]] || continue
2041                         sed -i "/^libdir=/s:=.*:=${LIBPATH}/${MULTIDIR}:" "${x}" || die
2042                         mv "${x}" "${D}${FROMDIR}"/pkgconfig/libgcj-${GCC_PV}.pc || die
2043                 done
2044         done
2045
2046         # We remove directories separately to avoid this case:
2047         #       mv SRC/lib/../lib/*.o DEST
2048         #       rmdir SRC/lib/../lib/
2049         #       mv SRC/lib/../lib32/*.o DEST  # Bork
2050         for FROMDIR in ${removedirs} ; do
2051                 rmdir "${D}"${FROMDIR} >& /dev/null
2052         done
2053         find -depth "${ED}" -type d -exec rmdir {} + >& /dev/null
2054 }
2055
2056 # make sure the libtool archives have libdir set to where they actually
2057 # -are-, and not where they -used- to be.  also, any dependencies we have
2058 # on our own .la files need to be updated.
2059 fix_libtool_libdir_paths() {
2060         local libpath="$1"
2061
2062         pushd "${D}" >/dev/null
2063
2064         pushd "./${libpath}" >/dev/null
2065         local dir="${PWD#${D%/}}"
2066         local allarchives=$(echo *.la)
2067         allarchives="\(${allarchives// /\\|}\)"
2068         popd >/dev/null
2069
2070         # The libdir might not have any .la files. #548782
2071         find "./${dir}" -maxdepth 1 -name '*.la' \
2072                 -exec sed -i -e "/^libdir=/s:=.*:='${dir}':" {} + || die
2073         # Would be nice to combine these, but -maxdepth can not be specified
2074         # on sub-expressions.
2075         find "./${PREFIX}"/lib* -maxdepth 3 -name '*.la' \
2076                 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2077         find "./${dir}/" -maxdepth 1 -name '*.la' \
2078                 -exec sed -i -e "/^dependency_libs=/s:/[^ ]*/${allarchives}:${libpath}/\1:g" {} + || die
2079
2080         popd >/dev/null
2081 }
2082
2083 create_gcc_env_entry() {
2084         dodir /etc/env.d/gcc
2085         local gcc_envd_base="/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}"
2086
2087         local gcc_specs_file
2088         local gcc_envd_file="${ED}${gcc_envd_base}"
2089         if [[ -z $1 ]] ; then
2090                 # I'm leaving the following commented out to remind me that it
2091                 # was an insanely -bad- idea. Stuff broke. GCC_SPECS isnt unset
2092                 # on chroot or in non-toolchain.eclass gcc ebuilds!
2093                 #gcc_specs_file="${LIBPATH}/specs"
2094                 gcc_specs_file=""
2095         else
2096                 gcc_envd_file+="-$1"
2097                 gcc_specs_file="${LIBPATH}/$1.specs"
2098         fi
2099
2100         # We want to list the default ABI's LIBPATH first so libtool
2101         # searches that directory first.  This is a temporary
2102         # workaround for libtool being stupid and using .la's from
2103         # conflicting ABIs by using the first one in the search path
2104         local ldpaths mosdirs
2105         if tc_version_is_at_least 3.2 ; then
2106                 local mdir mosdir abi ldpath
2107                 for abi in $(get_all_abis TARGET) ; do
2108                         mdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) --print-multi-directory)
2109                         ldpath=${LIBPATH}
2110                         [[ ${mdir} != "." ]] && ldpath+="/${mdir}"
2111                         ldpaths="${ldpath}${ldpaths:+:${ldpaths}}"
2112
2113                         mosdir=$($(XGCC) $(get_abi_CFLAGS ${abi}) -print-multi-os-directory)
2114                         mosdirs="${mosdir}${mosdirs:+:${mosdirs}}"
2115                 done
2116         else
2117                 # Older gcc's didn't do multilib, so logic is simple.
2118                 ldpaths=${LIBPATH}
2119         fi
2120
2121         cat <<-EOF > ${gcc_envd_file}
2122         GCC_PATH="${BINPATH}"
2123         LDPATH="${ldpaths}"
2124         MANPATH="${DATAPATH}/man"
2125         INFOPATH="${DATAPATH}/info"
2126         STDCXX_INCDIR="${STDCXX_INCDIR##*/}"
2127         CTARGET="${CTARGET}"
2128         GCC_SPECS="${gcc_specs_file}"
2129         MULTIOSDIRS="${mosdirs}"
2130         EOF
2131 }
2132
2133 create_revdep_rebuild_entry() {
2134         local revdep_rebuild_base="/etc/revdep-rebuild/05cross-${CTARGET}-${GCC_CONFIG_VER}"
2135         local revdep_rebuild_file="${ED}${revdep_rebuild_base}"
2136
2137         is_crosscompile || return 0
2138
2139         dodir /etc/revdep-rebuild
2140         cat <<-EOF > "${revdep_rebuild_file}"
2141         # Generated by ${CATEGORY}/${PF}
2142         # Ignore libraries built for ${CTARGET}, https://bugs.gentoo.org/692844.
2143         SEARCH_DIRS_MASK="${LIBPATH}"
2144         EOF
2145 }
2146
2147 copy_minispecs_gcc_specs() {
2148         # on gcc 6 we don't need minispecs
2149         if tc_version_is_at_least 6.0 ; then
2150                 return 0
2151         fi
2152
2153         # setup the hardenedno* specs files and the vanilla specs file.
2154         if hardened_gcc_works ; then
2155                 create_gcc_env_entry hardenednopiessp
2156         fi
2157         if hardened_gcc_works pie ; then
2158                 create_gcc_env_entry hardenednopie
2159         fi
2160         if hardened_gcc_works ssp ; then
2161                 create_gcc_env_entry hardenednossp
2162         fi
2163         create_gcc_env_entry vanilla
2164         insinto ${LIBPATH#${EPREFIX}}
2165         doins "${WORKDIR}"/specs/*.specs || die "failed to install specs"
2166         # Build system specs file which, if it exists, must be a complete set of
2167         # specs as it completely and unconditionally overrides the builtin specs.
2168         if ! tc_version_is_at_least 4.4 ; then
2169                 $(XGCC) -dumpspecs > "${WORKDIR}"/specs/specs
2170                 cat "${WORKDIR}"/build.specs >> "${WORKDIR}"/specs/specs
2171                 doins "${WORKDIR}"/specs/specs || die "failed to install the specs file"
2172         fi
2173 }
2174
2175 gcc_slot_java() {
2176         local x
2177
2178         # Move Java headers to compiler-specific dir
2179         for x in "${D}${PREFIX}"/include/gc*.h "${D}${PREFIX}"/include/j*.h ; do
2180                 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/include/
2181         done
2182         for x in gcj gnu java javax org ; do
2183                 if [[ -d ${D}${PREFIX}/include/${x} ]] ; then
2184                         dodir /${LIBPATH#${EPREFIX}}/include/${x}
2185                         mv -f "${D}${PREFIX}"/include/${x}/* "${D}${LIBPATH}"/include/${x}/
2186                         rm -rf "${D}${PREFIX}"/include/${x}
2187                 fi
2188         done
2189
2190         if [[ -d ${D}${PREFIX}/lib/security ]] || [[ -d ${D}${PREFIX}/$(get_libdir)/security ]] ; then
2191                 dodir /${LIBPATH#${EPREFIX}}/security
2192                 mv -f "${D}${PREFIX}"/lib*/security/* "${D}${LIBPATH}"/security
2193                 rm -rf "${D}${PREFIX}"/lib*/security
2194         fi
2195
2196         # Move random gcj files to compiler-specific directories
2197         for x in libgcj.spec logging.properties ; do
2198                 x="${D}${PREFIX}/lib/${x}"
2199                 [[ -f ${x} ]] && mv -f "${x}" "${D}${LIBPATH}"/
2200         done
2201
2202         # Rename jar because it could clash with Kaffe's jar if this gcc is
2203         # primary compiler (aka don't have the -<version> extension)
2204         cd "${D}${BINPATH}"
2205         [[ -f jar ]] && mv -f jar gcj-jar
2206 }
2207
2208 #---->> pkg_post* <<----
2209
2210 toolchain_pkg_postinst() {
2211         do_gcc_config
2212         if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2213                 eselect compiler-shadow update all
2214         fi
2215
2216         if ! is_crosscompile && [[ ${PN} != "kgcc64" ]] ; then
2217                 echo
2218                 ewarn "If you have issues with packages unable to locate libstdc++.la,"
2219                 ewarn "then try running 'fix_libtool_files.sh' on the old gcc versions."
2220                 echo
2221                 ewarn "You might want to review the GCC upgrade guide when moving between"
2222                 ewarn "major versions (like 4.2 to 4.3):"
2223                 ewarn "https://wiki.gentoo.org/wiki/Upgrading_GCC"
2224                 echo
2225
2226                 # Clean up old paths
2227                 rm -f "${EROOT%/}"/*/rcscripts/awk/fixlafiles.awk "${EROOT%/}"/sbin/fix_libtool_files.sh
2228                 rmdir "${EROOT%/}"/*/rcscripts{/awk,} 2>/dev/null
2229
2230                 mkdir -p "${EROOT%/}"/usr/{share/gcc-data,sbin,bin}
2231                 # DATAPATH has EPREFIX already, use ROOT with it
2232                 cp "${ROOT%/}${DATAPATH}"/fixlafiles.awk "${EROOT%/}"/usr/share/gcc-data/ || die
2233                 cp "${ROOT%/}${DATAPATH}"/fix_libtool_files.sh "${EROOT%/}"/usr/sbin/ || die
2234
2235                 # Since these aren't critical files and portage sucks with
2236                 # handling of binpkgs, don't require these to be found
2237                 cp "${ROOT%/}${DATAPATH}"/c{89,99} "${EROOT%/}"/usr/bin/ 2>/dev/null
2238         fi
2239
2240         if [[ -n ${PRERELEASE}${SNAPSHOT} ]] ; then
2241                 einfo "This GCC ebuild is provided for your convenience, and the use"
2242                 einfo "of this compiler is not supported by the Gentoo Developers."
2243                 einfo "Please report bugs to upstream at http://gcc.gnu.org/bugzilla/"
2244         fi
2245 }
2246
2247 toolchain_pkg_postrm() {
2248         do_gcc_config
2249         if [[ ! ${ROOT%/} && -f ${EPREFIX}/usr/share/eselect/modules/compiler-shadow.eselect ]] ; then
2250                 eselect compiler-shadow clean all
2251         fi
2252
2253         # to make our lives easier (and saner), we do the fix_libtool stuff here.
2254         # rather than checking SLOT's and trying in upgrade paths, we just see if
2255         # the common libstdc++.la exists in the ${LIBPATH} of the gcc that we are
2256         # unmerging.  if it does, that means this was a simple re-emerge.
2257
2258         # clean up the cruft left behind by cross-compilers
2259         if is_crosscompile ; then
2260                 if [[ -z $(ls "${EROOT%/}"/etc/env.d/gcc/${CTARGET}* 2>/dev/null) ]] ; then
2261                         einfo "Removing last cross-compiler instance. Deleting dangling symlinks."
2262                         rm -f "${EROOT%/}"/etc/env.d/gcc/config-${CTARGET}
2263                         rm -f "${EROOT%/}"/etc/env.d/??gcc-${CTARGET}
2264                         rm -f "${EROOT%/}"/usr/bin/${CTARGET}-{gcc,{g,c}++}{,32,64}
2265                 fi
2266                 return 0
2267         fi
2268
2269         # ROOT isnt handled by the script
2270         [[ ${ROOT%/} ]] && return 0
2271
2272         if [[ ! -e ${LIBPATH}/libstdc++.so ]] ; then
2273                 einfo "Running 'fix_libtool_files.sh ${GCC_RELEASE_VER}'"
2274                 fix_libtool_files.sh ${GCC_RELEASE_VER}
2275         fi
2276
2277         return 0
2278 }
2279
2280 do_gcc_config() {
2281         if ! should_we_gcc_config ; then
2282                 gcc-config --use-old --force
2283                 return 0
2284         fi
2285
2286         local current_gcc_config target
2287
2288         current_gcc_config=$(gcc-config -c ${CTARGET} 2>/dev/null)
2289         if [[ -n ${current_gcc_config} ]] ; then
2290                 local current_specs use_specs
2291                 # figure out which specs-specific config is active
2292                 current_specs=$(gcc-config -S ${current_gcc_config} | awk '{print $3}')
2293                 [[ -n ${current_specs} ]] && use_specs=-${current_specs}
2294
2295                 if [[ -n ${use_specs} ]] && \
2296                    [[ ! -e ${EROOT%/}/etc/env.d/gcc/${CTARGET}-${GCC_CONFIG_VER}${use_specs} ]]
2297                 then
2298                         ewarn "The currently selected specs-specific gcc config,"
2299                         ewarn "${current_specs}, doesn't exist anymore. This is usually"
2300                         ewarn "due to enabling/disabling hardened or switching to a version"
2301                         ewarn "of gcc that doesnt create multiple specs files. The default"
2302                         ewarn "config will be used, and the previous preference forgotten."
2303                         use_specs=""
2304                 fi
2305
2306                 target="${CTARGET}-${GCC_CONFIG_VER}${use_specs}"
2307         else
2308                 # The curent target is invalid.  Attempt to switch to a valid one.
2309                 # Blindly pick the latest version.  #529608
2310                 # TODO: Should update gcc-config to accept `-l ${CTARGET}` rather than
2311                 # doing a partial grep like this.
2312                 target=$(gcc-config -l 2>/dev/null | grep " ${CTARGET}-[0-9]" | tail -1 | awk '{print $2}')
2313         fi
2314
2315         gcc-config "${target}"
2316 }
2317
2318 should_we_gcc_config() {
2319         # if the current config is invalid, we definitely want a new one
2320         # Note: due to bash quirkiness, the following must not be 1 line
2321         local curr_config
2322         curr_config=$(gcc-config -c ${CTARGET} 2>&1) || return 0
2323
2324         # if the previously selected config has the same major.minor (branch) as
2325         # the version we are installing, then it will probably be uninstalled
2326         # for being in the same SLOT, make sure we run gcc-config.
2327         local curr_config_ver=$(gcc-config -S ${curr_config} | awk '{print $2}')
2328
2329         local curr_branch_ver=$(ver_cut 1-2 ${curr_config_ver})
2330
2331         if [[ ${curr_branch_ver} == ${GCC_BRANCH_VER} ]] ; then
2332                 return 0
2333         else
2334                 # if we're installing a genuinely different compiler version,
2335                 # we should probably tell the user -how- to switch to the new
2336                 # gcc version, since we're not going to do it for him/her.
2337                 # We don't want to switch from say gcc-3.3 to gcc-3.4 right in
2338                 # the middle of an emerge operation (like an 'emerge -e world'
2339                 # which could install multiple gcc versions).
2340                 # Only warn if we're installing a pkg as we might be called from
2341                 # the pkg_{pre,post}rm steps.  #446830
2342                 if [[ ${EBUILD_PHASE} == *"inst" ]] ; then
2343                         einfo "The current gcc config appears valid, so it will not be"
2344                         einfo "automatically switched for you.  If you would like to"
2345                         einfo "switch to the newly installed gcc version, do the"
2346                         einfo "following:"
2347                         echo
2348                         einfo "gcc-config ${CTARGET}-${GCC_CONFIG_VER}"
2349                         einfo "source /etc/profile"
2350                         echo
2351                 fi
2352                 return 1
2353         fi
2354 }
2355
2356 #---->> support and misc functions <<----
2357
2358 # This is to make sure we don't accidentally try to enable support for a
2359 # language that doesnt exist. GCC 3.4 supports f77, while 4.0 supports f95, etc.
2360 #
2361 # Also add a hook so special ebuilds (kgcc64) can control which languages
2362 # exactly get enabled
2363 gcc-lang-supported() {
2364         grep ^language=\"${1}\" "${S}"/gcc/*/config-lang.in > /dev/null || return 1
2365         [[ -z ${TOOLCHAIN_ALLOWED_LANGS} ]] && return 0
2366         has $1 ${TOOLCHAIN_ALLOWED_LANGS}
2367 }
2368
2369 is_ada() {
2370         gcc-lang-supported ada || return 1
2371         use_if_iuse ada
2372 }
2373
2374 is_cxx() {
2375         gcc-lang-supported 'c++' || return 1
2376         use_if_iuse cxx
2377 }
2378
2379 is_d() {
2380         gcc-lang-supported d || return 1
2381         use_if_iuse d
2382 }
2383
2384 is_f77() {
2385         gcc-lang-supported f77 || return 1
2386         use_if_iuse fortran
2387 }
2388
2389 is_f95() {
2390         gcc-lang-supported f95 || return 1
2391         use_if_iuse fortran
2392 }
2393
2394 is_fortran() {
2395         gcc-lang-supported fortran || return 1
2396         use_if_iuse fortran
2397 }
2398
2399 is_gcj() {
2400         gcc-lang-supported java || return 1
2401         use_if_iuse cxx && use_if_iuse gcj
2402 }
2403
2404 is_go() {
2405         gcc-lang-supported go || return 1
2406         use_if_iuse cxx && use_if_iuse go
2407 }
2408
2409 is_jit() {
2410         gcc-lang-supported jit || return 1
2411         # cross-compiler does not really support jit as it has
2412         # to generate code for a target. On target like avr
2413         # libgcclit.so can't link at all: bug #594572
2414         is_crosscompile && return 1
2415         use_if_iuse jit
2416 }
2417
2418 is_multilib() {
2419         tc_version_is_at_least 3 || return 1
2420         use_if_iuse multilib
2421 }
2422
2423 is_objc() {
2424         gcc-lang-supported objc || return 1
2425         use_if_iuse objc
2426 }
2427
2428 is_objcxx() {
2429         gcc-lang-supported 'obj-c++' || return 1
2430         use_if_iuse cxx && use_if_iuse objc++
2431 }
2432
2433 # Grab a variable from the build system (taken from linux-info.eclass)
2434 get_make_var() {
2435         local var=$1 makefile=${2:-${WORKDIR}/build/Makefile}
2436         echo -e "e:\\n\\t@echo \$(${var})\\ninclude ${makefile}" | \
2437                 r=${makefile%/*} emake --no-print-directory -s -f - 2>/dev/null
2438 }
2439
2440 XGCC() { get_make_var GCC_FOR_TARGET ; }
2441
2442 # The gentoo piessp patches allow for 3 configurations:
2443 # 1) PIE+SSP by default
2444 # 2) PIE by default
2445 # 3) SSP by default
2446 hardened_gcc_works() {
2447         if [[ $1 == "pie" ]] ; then
2448                 # $gcc_cv_ld_pie is unreliable as it simply take the output of
2449                 # `ld --help | grep -- -pie`, that reports the option in all cases, also if
2450                 # the loader doesn't actually load the resulting executables.
2451                 # To avoid breakage, blacklist FreeBSD here at least
2452                 [[ ${CTARGET} == *-freebsd* ]] && return 1
2453
2454                 want_pie || return 1
2455                 use_if_iuse nopie && return 1
2456                 hardened_gcc_is_stable pie
2457                 return $?
2458         elif [[ $1 == "ssp" ]] ; then
2459                 [[ -n ${SPECS_VER} ]] || return 1
2460                 use_if_iuse nossp && return 1
2461                 hardened_gcc_is_stable ssp
2462                 return $?
2463         else
2464                 # laziness ;)
2465                 hardened_gcc_works pie || return 1
2466                 hardened_gcc_works ssp || return 1
2467                 return 0
2468         fi
2469 }
2470
2471 hardened_gcc_is_stable() {
2472         local tocheck
2473         if [[ $1 == "pie" ]] ; then
2474                 if [[ ${CTARGET} == *-uclibc* ]] ; then
2475                         tocheck=${PIE_UCLIBC_STABLE}
2476                 else
2477                         tocheck=${PIE_GLIBC_STABLE}
2478                 fi
2479         elif [[ $1 == "ssp" ]] ; then
2480                 if [[ ${CTARGET} == *-uclibc* ]] ; then
2481                         tocheck=${SSP_UCLIBC_STABLE}
2482                 elif  [[ ${CTARGET} == *-gnu* ]] ; then
2483                         tocheck=${SSP_STABLE}
2484                 fi
2485         else
2486                 die "hardened_gcc_stable needs to be called with pie or ssp"
2487         fi
2488
2489         has $(tc-arch) ${tocheck} && return 0
2490         return 1
2491 }
2492
2493 want_minispecs() {
2494         # on gcc 6 we don't need minispecs
2495         if tc_version_is_at_least 6.0 ; then
2496                 return 0
2497         fi
2498         if tc_version_is_at_least 4.3.2 && use_if_iuse hardened ; then
2499                 if ! want_pie ; then
2500                         ewarn "PIE_VER or SPECS_VER is not defined in the GCC ebuild."
2501                 elif use vanilla ; then
2502                         ewarn "You will not get hardened features if you have the vanilla USE-flag."
2503                 elif use_if_iuse nopie && use_if_iuse nossp ; then
2504                         ewarn "You will not get hardened features if you have the nopie and nossp USE-flag."
2505                 elif ! hardened_gcc_works ; then
2506                         ewarn "Your $(tc-arch) arch is not supported."
2507                 else
2508                         return 0
2509                 fi
2510                 ewarn "Hope you know what you are doing. Hardened will not work."
2511                 return 0
2512         fi
2513         return 1
2514 }
2515
2516 want_pie() {
2517         ! use_if_iuse hardened && [[ -n ${PIE_VER} ]] && use_if_iuse nopie && return 1
2518         [[ -n ${PIE_VER} ]] && [[ -n ${SPECS_VER} ]] && return 0
2519         tc_version_is_at_least 4.3.2 && return 1
2520         [[ -z ${PIE_VER} ]] && return 1
2521         use_if_iuse nopie || return 0
2522         return 1
2523 }
2524
2525 has toolchain_death_notice ${EBUILD_DEATH_HOOKS} || EBUILD_DEATH_HOOKS+=" toolchain_death_notice"
2526 toolchain_death_notice() {
2527         if [[ -e "${WORKDIR}"/build ]] ; then
2528                 pushd "${WORKDIR}"/build >/dev/null
2529                 (echo '' | $(tc-getCC ${CTARGET}) ${CFLAGS} -v -E - 2>&1) > gccinfo.log
2530                 [[ -e "${T}"/build.log ]] && cp "${T}"/build.log .
2531                 tar jcf "${WORKDIR}"/gcc-build-logs.tar.bz2 \
2532                         gccinfo.log build.log $(find -name config.log)
2533                 rm gccinfo.log build.log
2534                 eerror
2535                 eerror "Please include ${WORKDIR}/gcc-build-logs.tar.bz2 in your bug report."
2536                 eerror
2537                 popd >/dev/null
2538         fi
2539 }
2540
2541 # Note [implicitly enabled flags]
2542 # -------------------------------
2543 # Usually configure-based packages handle explicit feature requests
2544 # like
2545 #     ./configure --enable-foo
2546 # as explicit request to check for support of 'foo' and bail out at
2547 # configure time.
2548 #
2549 # GCC does not follow this pattern and instead overrides autodetection
2550 # of the feature and enables it unconditionally.
2551 # See bugs:
2552 #    https://gcc.gnu.org/PR85663 (libsanitizer on mips)
2553 #    https://bugs.gentoo.org/661252 (libvtv on powerpc64)
2554 #
2555 # Thus safer way to enable/disable the feature is to rely on implicit
2556 # enabled-by-default state:
2557 #    econf $(usex foo '' --disable-foo)