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

Contents of /eclass/toolchain.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.567 - (show annotations) (download)
Tue Jan 15 02:30:53 2013 UTC (19 months, 1 week ago) by dirtyepic
Branch: MAIN
Changes since 1.566: +3 -3 lines
Drop go support for 4.6 - broken by newer glibc versions and upstream recommends it not be used.

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

  ViewVC Help
Powered by ViewVC 1.1.20