eclass/toolchain.eclass

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