eclass/toolchain.eclass

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