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

Contents of /eclass/toolchain.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.573 - (show annotations) (download)
Tue Apr 2 03:02:22 2013 UTC (16 months, 3 weeks ago) by dirtyepic
Branch: MAIN
Changes since 1.572: +1 -5 lines
Revert previous due to breakage.

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

  ViewVC Help
Powered by ViewVC 1.1.20