1 | # Copyright 1999-2006 Gentoo Foundation |
1 | # Copyright 1999-2007 Gentoo Foundation |
2 | # Distributed under the terms of the GNU General Public License v2 |
2 | # Distributed under the terms of the GNU General Public License v2 |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.52 2006/01/15 20:21:59 vapier Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.70 2007/06/16 07:11:43 vapier Exp $ |
4 | # |
4 | # |
5 | # Author: Toolchain Ninjas <toolchain@gentoo.org> |
5 | # Maintainer: Toolchain Ninjas <toolchain@gentoo.org> |
6 | # |
6 | # |
7 | # This eclass contains (or should) functions to get common info |
7 | # This eclass contains (or should) functions to get common info |
8 | # about the toolchain (libc/compiler/binutils/etc...) |
8 | # about the toolchain (libc/compiler/binutils/etc...) |
9 | |
9 | |
10 | inherit multilib |
10 | ___ECLASS_RECUR_TOOLCHAIN_FUNCS="yes" |
|
|
11 | [[ -z ${___ECLASS_RECUR_MULTILIB} ]] && inherit multilib |
11 | |
12 | |
12 | DESCRIPTION="Based on the ${ECLASS} eclass" |
13 | DESCRIPTION="Based on the ${ECLASS} eclass" |
13 | |
14 | |
14 | tc-getPROG() { |
15 | tc-getPROG() { |
15 | local var=$1 |
16 | local var=$1 |
… | |
… | |
33 | tc-getAR() { tc-getPROG AR ar "$@"; } |
34 | tc-getAR() { tc-getPROG AR ar "$@"; } |
34 | # Returns the name of the assembler |
35 | # Returns the name of the assembler |
35 | tc-getAS() { tc-getPROG AS as "$@"; } |
36 | tc-getAS() { tc-getPROG AS as "$@"; } |
36 | # Returns the name of the C compiler |
37 | # Returns the name of the C compiler |
37 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
38 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
|
|
39 | # Returns the name of the C preprocessor |
|
|
40 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
38 | # Returns the name of the C++ compiler |
41 | # Returns the name of the C++ compiler |
39 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
42 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
40 | # Returns the name of the linker |
43 | # Returns the name of the linker |
41 | tc-getLD() { tc-getPROG LD ld "$@"; } |
44 | tc-getLD() { tc-getPROG LD ld "$@"; } |
|
|
45 | # Returns the name of the strip prog |
|
|
46 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
42 | # Returns the name of the symbol/object thingy |
47 | # Returns the name of the symbol/object thingy |
43 | tc-getNM() { tc-getPROG NM nm "$@"; } |
48 | tc-getNM() { tc-getPROG NM nm "$@"; } |
44 | # Returns the name of the archiver indexer |
49 | # Returns the name of the archiver indexer |
45 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
50 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
|
|
51 | # Returns the name of the fortran 77 compiler |
|
|
52 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
|
|
53 | # Returns the name of the fortran 90 compiler |
|
|
54 | tc-getF90() { tc-getPROG F90 gfortran "$@"; } |
46 | # Returns the name of the fortran compiler |
55 | # Returns the name of the fortran compiler |
47 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
56 | tc-getFORTRAN() { tc-getPROG FORTRAN gfortran "$@"; } |
48 | # Returns the name of the java compiler |
57 | # Returns the name of the java compiler |
49 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
58 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
50 | |
59 | |
51 | # Returns the name of the C compiler for build |
60 | # Returns the name of the C compiler for build |
52 | tc-getBUILD_CC() { |
61 | tc-getBUILD_CC() { |
… | |
… | |
81 | # A simple way to see if we're using a cross-compiler ... |
90 | # A simple way to see if we're using a cross-compiler ... |
82 | tc-is-cross-compiler() { |
91 | tc-is-cross-compiler() { |
83 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
92 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
84 | } |
93 | } |
85 | |
94 | |
|
|
95 | # See if this toolchain is a softfloat based one. |
|
|
96 | # The possible return values: |
|
|
97 | # - only: the target is always softfloat (never had fpu) |
|
|
98 | # - yes: the target should support softfloat |
|
|
99 | # - no: the target should support hardfloat |
|
|
100 | # This allows us to react differently where packages accept |
|
|
101 | # softfloat flags in the case where support is optional, but |
|
|
102 | # rejects softfloat flags where the target always lacks an fpu. |
|
|
103 | tc-is-softfloat() { |
|
|
104 | case ${CTARGET} in |
|
|
105 | bfin*|h8300*) |
|
|
106 | echo "only" ;; |
|
|
107 | *) |
|
|
108 | [[ ${CTARGET//_/-} == *-softfloat-* ]] \ |
|
|
109 | && echo "yes" \ |
|
|
110 | || echo "no" |
|
|
111 | ;; |
|
|
112 | esac |
|
|
113 | } |
86 | |
114 | |
87 | # Parse information from CBUILD/CHOST/CTARGET rather than |
115 | # Parse information from CBUILD/CHOST/CTARGET rather than |
88 | # use external variables from the profile. |
116 | # use external variables from the profile. |
89 | tc-ninja_magic_to_arch() { |
117 | tc-ninja_magic_to_arch() { |
90 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
118 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
… | |
… | |
94 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
122 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
95 | |
123 | |
96 | case ${host} in |
124 | case ${host} in |
97 | alpha*) echo alpha;; |
125 | alpha*) echo alpha;; |
98 | arm*) echo arm;; |
126 | arm*) echo arm;; |
99 | bfin*) ninj bfin blackfin;; |
127 | bfin*) ninj blackfin bfin;; |
100 | cris*) echo cris;; |
128 | cris*) echo cris;; |
101 | hppa*) ninj parisc hppa;; |
129 | hppa*) ninj parisc hppa;; |
102 | i?86*) ninj i386 x86;; |
130 | i?86*) ninj i386 x86;; |
103 | ia64*) echo ia64;; |
131 | ia64*) echo ia64;; |
104 | m68*) echo m68k;; |
132 | m68*) echo m68k;; |
105 | mips*) echo mips;; |
133 | mips*) echo mips;; |
106 | nios2*) echo nios2;; |
134 | nios2*) echo nios2;; |
107 | nios*) echo nios;; |
135 | nios*) echo nios;; |
108 | powerpc*) |
136 | powerpc*) |
109 | # Starting with linux-2.6.15, the 'ppc' and 'ppc64' trees |
137 | # Starting with linux-2.6.15, the 'ppc' and 'ppc64' trees |
110 | # have been unified into simply 'powerpc' |
138 | # have been unified into simply 'powerpc', but until 2.6.16, |
|
|
139 | # ppc32 is still using ARCH="ppc" as default |
111 | if [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.15) ]] && [[ ${type} == "kern" ]] ; then |
140 | if [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.16) ]] && [[ ${type} == "kern" ]] ; then |
112 | echo powerpc |
141 | echo powerpc |
|
|
142 | elif [[ $(KV_to_int ${KV}) -eq $(KV_to_int 2.6.15) ]] && [[ ${type} == "kern" ]] ; then |
|
|
143 | if [[ ${host} == powerpc64* ]] || [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
|
|
144 | echo powerpc |
|
|
145 | else |
|
|
146 | echo ppc |
|
|
147 | fi |
113 | elif [[ ${host} == powerpc64* ]] ; then |
148 | elif [[ ${host} == powerpc64* ]] ; then |
114 | echo ppc64 |
149 | echo ppc64 |
115 | elif [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
150 | elif [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
116 | ninj ppc64 ppc |
151 | ninj ppc64 ppc |
117 | else |
152 | else |
… | |
… | |
135 | tc-ninja_magic_to_arch kern $@ |
170 | tc-ninja_magic_to_arch kern $@ |
136 | } |
171 | } |
137 | tc-arch() { |
172 | tc-arch() { |
138 | tc-ninja_magic_to_arch portage $@ |
173 | tc-ninja_magic_to_arch portage $@ |
139 | } |
174 | } |
140 | tc-endian() { |
|
|
141 | local host=$1 |
|
|
142 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
143 | host=${host%%-*} |
|
|
144 | |
|
|
145 | case ${host} in |
|
|
146 | alpha*) echo big;; |
|
|
147 | arm*b*) echo big;; |
|
|
148 | arm*) echo little;; |
|
|
149 | cris*) echo little;; |
|
|
150 | hppa*) echo big;; |
|
|
151 | i?86*) echo little;; |
|
|
152 | ia64*) echo little;; |
|
|
153 | m68*) echo big;; |
|
|
154 | mips*l*) echo little;; |
|
|
155 | mips*) echo big;; |
|
|
156 | powerpc*) echo big;; |
|
|
157 | s390*) echo big;; |
|
|
158 | sh*b*) echo big;; |
|
|
159 | sh*) echo little;; |
|
|
160 | sparc*) echo big;; |
|
|
161 | x86_64*) echo little;; |
|
|
162 | *) echo wtf;; |
|
|
163 | esac |
|
|
164 | } |
|
|
165 | |
175 | |
166 | # Returns the version as by `$CC -dumpversion` |
176 | # Returns the version as by `$CC -dumpversion` |
167 | gcc-fullversion() { |
177 | gcc-fullversion() { |
168 | echo "$($(tc-getCC) -dumpversion)" |
178 | $(tc-getCC "$@") -dumpversion |
169 | } |
179 | } |
170 | # Returns the version, but only the <major>.<minor> |
180 | # Returns the version, but only the <major>.<minor> |
171 | gcc-version() { |
181 | gcc-version() { |
172 | echo "$(gcc-fullversion | cut -f1,2 -d.)" |
182 | gcc-fullversion "$@" | cut -f1,2 -d. |
173 | } |
183 | } |
174 | # Returns the Major version |
184 | # Returns the Major version |
175 | gcc-major-version() { |
185 | gcc-major-version() { |
176 | echo "$(gcc-version | cut -f1 -d.)" |
186 | gcc-version "$@" | cut -f1 -d. |
177 | } |
187 | } |
178 | # Returns the Minor version |
188 | # Returns the Minor version |
179 | gcc-minor-version() { |
189 | gcc-minor-version() { |
180 | echo "$(gcc-version | cut -f2 -d.)" |
190 | gcc-version "$@" | cut -f2 -d. |
181 | } |
191 | } |
182 | # Returns the Micro version |
192 | # Returns the Micro version |
183 | gcc-micro-version() { |
193 | gcc-micro-version() { |
184 | echo "$(gcc-fullversion | cut -f3 -d. | cut -f1 -d-)" |
194 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
185 | } |
195 | } |
|
|
196 | # Returns the installation directory - internal toolchain |
|
|
197 | # function for use by _gcc-specs-exists (for flag-o-matic). |
|
|
198 | _gcc-install-dir() { |
|
|
199 | echo "$($(tc-getCC) -print-search-dirs 2> /dev/null |\ |
|
|
200 | awk '$1=="install:" {print $2}')" |
|
|
201 | } |
|
|
202 | # Returns true if the indicated specs file exists - internal toolchain |
|
|
203 | # function for use by flag-o-matic. |
|
|
204 | _gcc-specs-exists() { |
|
|
205 | [[ -f $(_gcc-install-dir)/$1 ]] |
|
|
206 | } |
186 | |
207 | |
187 | # Returns requested gcc specs directive |
208 | # Returns requested gcc specs directive unprocessed - for used by |
|
|
209 | # gcc-specs-directive() |
188 | # Note; later specs normally overwrite earlier ones; however if a later |
210 | # Note; later specs normally overwrite earlier ones; however if a later |
189 | # spec starts with '+' then it appends. |
211 | # spec starts with '+' then it appends. |
190 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
212 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
191 | # as "Reading <file>", in order. |
213 | # as "Reading <file>", in order. Strictly speaking, if there's a |
|
|
214 | # $(gcc_install_dir)/specs, the built-in specs aren't read, however by |
|
|
215 | # the same token anything from 'gcc -dumpspecs' is overridden by |
|
|
216 | # the contents of $(gcc_install_dir)/specs so the result is the |
|
|
217 | # same either way. |
192 | gcc-specs-directive() { |
218 | _gcc-specs-directive_raw() { |
|
|
219 | local cc=$(tc-getCC) |
193 | local specfiles=$($(tc-getCC) -v 2>&1 | awk '$1=="Reading" {print $NF}') |
220 | local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}') |
194 | $(tc-getCC) -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
221 | ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
195 | 'BEGIN { pspec=""; spec=""; outside=1 } |
222 | 'BEGIN { pspec=""; spec=""; outside=1 } |
196 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
223 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
197 | outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } |
224 | outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } |
198 | spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next } |
225 | spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next } |
199 | { spec=spec $0 } |
226 | { spec=spec $0 } |
200 | END { print spec }' |
227 | END { print spec }' |
201 | return 0 |
228 | return 0 |
202 | } |
229 | } |
203 | |
230 | |
|
|
231 | # Return the requested gcc specs directive, with all included |
|
|
232 | # specs expanded. |
|
|
233 | # Note, it does not check for inclusion loops, which cause it |
|
|
234 | # to never finish - but such loops are invalid for gcc and we're |
|
|
235 | # assuming gcc is operational. |
|
|
236 | gcc-specs-directive() { |
|
|
237 | local directive subdname subdirective |
|
|
238 | directive="$(_gcc-specs-directive_raw $1)" |
|
|
239 | while [[ ${directive} == *%\(*\)* ]]; do |
|
|
240 | subdname=${directive/*%\(} |
|
|
241 | subdname=${subdname/\)*} |
|
|
242 | subdirective="$(_gcc-specs-directive_raw ${subdname})" |
|
|
243 | directive="${directive//\%(${subdname})/${subdirective}}" |
|
|
244 | done |
|
|
245 | echo "${directive}" |
|
|
246 | return 0 |
|
|
247 | } |
|
|
248 | |
204 | # Returns true if gcc sets relro |
249 | # Returns true if gcc sets relro |
205 | gcc-specs-relro() { |
250 | gcc-specs-relro() { |
206 | local directive |
251 | local directive |
207 | directive=$(gcc-specs-directive link_command) |
252 | directive=$(gcc-specs-directive link_command) |
208 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
253 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
… | |
… | |
229 | gcc-specs-ssp-to-all() { |
274 | gcc-specs-ssp-to-all() { |
230 | local directive |
275 | local directive |
231 | directive=$(gcc-specs-directive cc1) |
276 | directive=$(gcc-specs-directive cc1) |
232 | return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]]) |
277 | return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]]) |
233 | } |
278 | } |
|
|
279 | |
|
|
280 | |
|
|
281 | # This function generate linker scripts in /usr/lib for dynamic |
|
|
282 | # libs in /lib. This is to fix linking problems when you have |
|
|
283 | # the .so in /lib, and the .a in /usr/lib. What happens is that |
|
|
284 | # in some cases when linking dynamic, the .a in /usr/lib is used |
|
|
285 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
|
|
286 | # library search path. This cause many builds to fail. |
|
|
287 | # See bug #4411 for more info. |
|
|
288 | # |
|
|
289 | # To use, simply call: |
|
|
290 | # |
|
|
291 | # gen_usr_ldscript libfoo.so |
|
|
292 | # |
|
|
293 | # Note that you should in general use the unversioned name of |
|
|
294 | # the library, as ldconfig should usually update it correctly |
|
|
295 | # to point to the latest version of the library present. |
|
|
296 | gen_usr_ldscript() { |
|
|
297 | local lib libdir=$(get_libdir) output_format="" |
|
|
298 | # Just make sure it exists |
|
|
299 | dodir /usr/${libdir} |
|
|
300 | |
|
|
301 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
|
|
302 | # is referenced ... makes multilib saner |
|
|
303 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
|
|
304 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
|
|
305 | |
|
|
306 | for lib in "$@" ; do |
|
|
307 | if [[ ${USERLAND} == "Darwin" ]] ; then |
|
|
308 | ewarn "Not creating fake dynamic library for $lib on Darwin;" |
|
|
309 | ewarn "making a symlink instead." |
|
|
310 | dosym "/${libdir}/${lib}" "/usr/${libdir}/${lib}" |
|
|
311 | else |
|
|
312 | cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
|
|
313 | /* GNU ld script |
|
|
314 | Since Gentoo has critical dynamic libraries |
|
|
315 | in /lib, and the static versions in /usr/lib, |
|
|
316 | we need to have a "fake" dynamic lib in /usr/lib, |
|
|
317 | otherwise we run into linking problems. |
|
|
318 | |
|
|
319 | See bug http://bugs.gentoo.org/4411 for more info. |
|
|
320 | */ |
|
|
321 | ${output_format} |
|
|
322 | GROUP ( /${libdir}/${lib} ) |
|
|
323 | END_LDSCRIPT |
|
|
324 | fi |
|
|
325 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
|
|
326 | done |
|
|
327 | } |