/[gentoo-x86]/eclass/toolchain.eclass
Gentoo

Contents of /eclass/toolchain.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.560 - (show annotations) (download)
Thu Nov 29 01:16:41 2012 UTC (23 months, 4 weeks ago) by vapier
Branch: MAIN
Changes since 1.559: +7 -1 lines
disable X configure flags setting up bad -I/-L flags that will mess with multilib builds that need 3rd party libs (such as libjava and gtk/etc...)

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

  ViewVC Help
Powered by ViewVC 1.1.20