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