eclass/toolchain.eclass

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