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.64 2007/01/07 11:39:08 vapier Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.89 2009/04/04 17:17:56 grobian Exp $ |
4 | # |
4 | |
|
|
5 | # @ECLASS: toolchain-funcs.eclass |
|
|
6 | # @MAINTAINER: |
5 | # Author: Toolchain Ninjas <toolchain@gentoo.org> |
7 | # Toolchain Ninjas <toolchain@gentoo.org> |
6 | # |
8 | # @BLURB: functions to query common info about the toolchain |
7 | # This eclass contains (or should) functions to get common info |
9 | # @DESCRIPTION: |
8 | # about the toolchain (libc/compiler/binutils/etc...) |
10 | # The toolchain-funcs aims to provide a complete suite of functions |
|
|
11 | # for gleaning useful information about the toolchain and to simplify |
|
|
12 | # ugly things like cross-compiling and multilib. All of this is done |
|
|
13 | # in such a way that you can rely on the function always returning |
|
|
14 | # something sane. |
9 | |
15 | |
10 | inherit multilib |
16 | ___ECLASS_RECUR_TOOLCHAIN_FUNCS="yes" |
|
|
17 | [[ -z ${___ECLASS_RECUR_MULTILIB} ]] && inherit multilib |
11 | |
18 | |
12 | DESCRIPTION="Based on the ${ECLASS} eclass" |
19 | DESCRIPTION="Based on the ${ECLASS} eclass" |
13 | |
20 | |
14 | tc-getPROG() { |
21 | tc-getPROG() { |
15 | local var=$1 |
22 | local var=$1 |
… | |
… | |
27 | |
34 | |
28 | export ${var}=${prog} |
35 | export ${var}=${prog} |
29 | echo "${!var}" |
36 | echo "${!var}" |
30 | } |
37 | } |
31 | |
38 | |
32 | # Returns the name of the archiver |
39 | # @FUNCTION: tc-getAR |
|
|
40 | # @USAGE: [toolchain prefix] |
|
|
41 | # @RETURN: name of the archiver |
33 | tc-getAR() { tc-getPROG AR ar "$@"; } |
42 | tc-getAR() { tc-getPROG AR ar "$@"; } |
34 | # Returns the name of the assembler |
43 | # @FUNCTION: tc-getAS |
|
|
44 | # @USAGE: [toolchain prefix] |
|
|
45 | # @RETURN: name of the assembler |
35 | tc-getAS() { tc-getPROG AS as "$@"; } |
46 | tc-getAS() { tc-getPROG AS as "$@"; } |
|
|
47 | # @FUNCTION: tc-getCC |
|
|
48 | # @USAGE: [toolchain prefix] |
36 | # Returns the name of the C compiler |
49 | # @RETURN: name of the C compiler |
37 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
50 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
|
|
51 | # @FUNCTION: tc-getCPP |
|
|
52 | # @USAGE: [toolchain prefix] |
38 | # Returns the name of the C preprocessor |
53 | # @RETURN: name of the C preprocessor |
39 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
54 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
|
|
55 | # @FUNCTION: tc-getCXX |
|
|
56 | # @USAGE: [toolchain prefix] |
40 | # Returns the name of the C++ compiler |
57 | # @RETURN: name of the C++ compiler |
41 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
58 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
42 | # Returns the name of the linker |
59 | # @FUNCTION: tc-getLD |
|
|
60 | # @USAGE: [toolchain prefix] |
|
|
61 | # @RETURN: name of the linker |
43 | tc-getLD() { tc-getPROG LD ld "$@"; } |
62 | tc-getLD() { tc-getPROG LD ld "$@"; } |
44 | # Returns the name of the strip prog |
63 | # @FUNCTION: tc-getSTRIP |
|
|
64 | # @USAGE: [toolchain prefix] |
|
|
65 | # @RETURN: name of the strip program |
45 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
66 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
|
|
67 | # @FUNCTION: tc-getNM |
|
|
68 | # @USAGE: [toolchain prefix] |
46 | # Returns the name of the symbol/object thingy |
69 | # @RETURN: name of the symbol/object thingy |
47 | tc-getNM() { tc-getPROG NM nm "$@"; } |
70 | tc-getNM() { tc-getPROG NM nm "$@"; } |
|
|
71 | # @FUNCTION: tc-getRANLIB |
|
|
72 | # @USAGE: [toolchain prefix] |
48 | # Returns the name of the archiver indexer |
73 | # @RETURN: name of the archiver indexer |
49 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
74 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
|
|
75 | # @FUNCTION: tc-getOBJCOPY |
|
|
76 | # @USAGE: [toolchain prefix] |
|
|
77 | # @RETURN: name of the object copier |
|
|
78 | tc-getOBJCOPY() { tc-getPROG OBJCOPY objcopy "$@"; } |
|
|
79 | # @FUNCTION: tc-getF77 |
|
|
80 | # @USAGE: [toolchain prefix] |
50 | # Returns the name of the fortran 77 compiler |
81 | # @RETURN: name of the Fortran 77 compiler |
51 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
82 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
|
|
83 | # @FUNCTION: tc-getFC |
|
|
84 | # @USAGE: [toolchain prefix] |
52 | # Returns the name of the fortran 90 compiler |
85 | # @RETURN: name of the Fortran 90 compiler |
53 | tc-getF90() { tc-getPROG F90 gfortran "$@"; } |
86 | tc-getFC() { tc-getPROG FC gfortran "$@"; } |
54 | # Returns the name of the fortran compiler |
87 | # @FUNCTION: tc-getGCJ |
55 | tc-getFORTRAN() { tc-getPROG FORTRAN gfortran "$@"; } |
88 | # @USAGE: [toolchain prefix] |
56 | # Returns the name of the java compiler |
89 | # @RETURN: name of the java compiler |
57 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
90 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
58 | |
91 | |
59 | # Returns the name of the C compiler for build |
92 | # @FUNCTION: tc-getBUILD_CC |
|
|
93 | # @USAGE: [toolchain prefix] |
|
|
94 | # @RETURN: name of the C compiler for building binaries to run on the build machine |
60 | tc-getBUILD_CC() { |
95 | tc-getBUILD_CC() { |
61 | local v |
96 | local v |
62 | for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do |
97 | for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do |
63 | if [[ -n ${!v} ]] ; then |
98 | if [[ -n ${!v} ]] ; then |
64 | export BUILD_CC=${!v} |
99 | export BUILD_CC=${!v} |
… | |
… | |
76 | |
111 | |
77 | export BUILD_CC=${search} |
112 | export BUILD_CC=${search} |
78 | echo "${search}" |
113 | echo "${search}" |
79 | } |
114 | } |
80 | |
115 | |
|
|
116 | # @FUNCTION: tc-export |
|
|
117 | # @USAGE: <list of toolchain variables> |
|
|
118 | # @DESCRIPTION: |
81 | # Quick way to export a bunch of vars at once |
119 | # Quick way to export a bunch of compiler vars at once. |
82 | tc-export() { |
120 | tc-export() { |
83 | local var |
121 | local var |
84 | for var in "$@" ; do |
122 | for var in "$@" ; do |
|
|
123 | [[ $(type -t tc-get${var}) != "function" ]] && die "tc-export: invalid export variable '${var}'" |
85 | eval tc-get${var} > /dev/null |
124 | eval tc-get${var} > /dev/null |
86 | done |
125 | done |
87 | } |
126 | } |
88 | |
127 | |
89 | # A simple way to see if we're using a cross-compiler ... |
128 | # @FUNCTION: tc-is-cross-compiler |
|
|
129 | # @RETURN: Shell true if we are using a cross-compiler, shell false otherwise |
90 | tc-is-cross-compiler() { |
130 | tc-is-cross-compiler() { |
91 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
131 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
92 | } |
132 | } |
93 | |
133 | |
|
|
134 | # @FUNCTION: tc-is-softfloat |
|
|
135 | # @DESCRIPTION: |
|
|
136 | # See if this toolchain is a softfloat based one. |
|
|
137 | # @CODE |
|
|
138 | # The possible return values: |
|
|
139 | # - only: the target is always softfloat (never had fpu) |
|
|
140 | # - yes: the target should support softfloat |
|
|
141 | # - no: the target should support hardfloat |
|
|
142 | # @CODE |
|
|
143 | # This allows us to react differently where packages accept |
|
|
144 | # softfloat flags in the case where support is optional, but |
|
|
145 | # rejects softfloat flags where the target always lacks an fpu. |
|
|
146 | tc-is-softfloat() { |
|
|
147 | case ${CTARGET} in |
|
|
148 | bfin*|h8300*) |
|
|
149 | echo "only" ;; |
|
|
150 | *) |
|
|
151 | [[ ${CTARGET//_/-} == *-softfloat-* ]] \ |
|
|
152 | && echo "yes" \ |
|
|
153 | || echo "no" |
|
|
154 | ;; |
|
|
155 | esac |
|
|
156 | } |
94 | |
157 | |
95 | # Parse information from CBUILD/CHOST/CTARGET rather than |
158 | # Parse information from CBUILD/CHOST/CTARGET rather than |
96 | # use external variables from the profile. |
159 | # use external variables from the profile. |
97 | tc-ninja_magic_to_arch() { |
160 | tc-ninja_magic_to_arch() { |
98 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
161 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
… | |
… | |
100 | local type=$1 |
163 | local type=$1 |
101 | local host=$2 |
164 | local host=$2 |
102 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
165 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
103 | |
166 | |
104 | case ${host} in |
167 | case ${host} in |
|
|
168 | powerpc-apple-darwin*) |
|
|
169 | echo ppc-macos;; |
|
|
170 | powerpc64-apple-darwin*) |
|
|
171 | echo ppc64-macos;; |
|
|
172 | i?86-apple-darwin*) |
|
|
173 | echo x86-macos;; |
|
|
174 | x86_64-apple-darwin*) |
|
|
175 | echo x64-macos;; |
|
|
176 | sparc-sun-solaris*) |
|
|
177 | echo sparc-solaris;; |
|
|
178 | sparcv9-sun-solaris*) |
|
|
179 | echo sparc64-solaris;; |
|
|
180 | i?86-pc-solaris*) |
|
|
181 | echo x86-solaris;; |
|
|
182 | x86_64-pc-solaris*) |
|
|
183 | echo x64-solaris;; |
|
|
184 | powerpc-ibm-aix*) |
|
|
185 | echo ppc-aix;; |
|
|
186 | mips-sgi-irix*) |
|
|
187 | echo mips-irix;; |
|
|
188 | ia64-hp-hpux*) |
|
|
189 | echo ia64-hpux;; |
|
|
190 | i?86-pc-freebsd*) |
|
|
191 | echo x86-freebsd;; |
|
|
192 | x86_64-pc-freebsd*) |
|
|
193 | echo x64-freebsd;; |
|
|
194 | i?86-pc-netbsd*) |
|
|
195 | echo x86-netbsd;; |
|
|
196 | i?86-pc-interix*) |
|
|
197 | echo x86-interix;; |
|
|
198 | i?86-pc-winnt*) |
|
|
199 | echo x86-winnt;; |
|
|
200 | i*-pc-freebsd*) |
|
|
201 | echo x86-freebsd;; |
|
|
202 | x86_64-pc-freebsd*) |
|
|
203 | echo x64-freebsd;; |
|
|
204 | |
105 | alpha*) echo alpha;; |
205 | alpha*) echo alpha;; |
106 | arm*) echo arm;; |
206 | arm*) echo arm;; |
|
|
207 | avr*) ninj avr32 avr;; |
107 | bfin*) ninj blackfin bfin;; |
208 | bfin*) ninj blackfin bfin;; |
108 | cris*) echo cris;; |
209 | cris*) echo cris;; |
109 | hppa*) ninj parisc hppa;; |
210 | hppa*) ninj parisc hppa;; |
110 | i?86*) ninj i386 x86;; |
211 | i?86*) |
|
|
212 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
213 | # trees have been unified into 'x86'. |
|
|
214 | # FreeBSD still uses i386 |
|
|
215 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -lt $(KV_to_int 2.6.24) || ${host} == *freebsd* ]] ; then |
|
|
216 | echo i386 |
|
|
217 | else |
|
|
218 | echo x86 |
|
|
219 | fi |
|
|
220 | ;; |
111 | ia64*) echo ia64;; |
221 | ia64*) echo ia64;; |
112 | m68*) echo m68k;; |
222 | m68*) echo m68k;; |
113 | mips*) echo mips;; |
223 | mips*) echo mips;; |
114 | nios2*) echo nios2;; |
224 | nios2*) echo nios2;; |
115 | nios*) echo nios;; |
225 | nios*) echo nios;; |
… | |
… | |
140 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
250 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
141 | && ninj sparc64 sparc \ |
251 | && ninj sparc64 sparc \ |
142 | || echo sparc |
252 | || echo sparc |
143 | ;; |
253 | ;; |
144 | vax*) echo vax;; |
254 | vax*) echo vax;; |
145 | x86_64*) ninj x86_64 amd64;; |
255 | x86_64*) |
146 | *) echo ${ARCH};; |
256 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
257 | # trees have been unified into 'x86'. |
|
|
258 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.24) ]] ; then |
|
|
259 | echo x86 |
|
|
260 | else |
|
|
261 | ninj x86_64 amd64 |
|
|
262 | fi |
|
|
263 | ;; |
|
|
264 | |
|
|
265 | # since our usage of tc-arch is largely concerned with |
|
|
266 | # normalizing inputs for testing ${CTARGET}, let's filter |
|
|
267 | # other cross targets (mingw and such) into the unknown. |
|
|
268 | *) echo unknown;; |
147 | esac |
269 | esac |
148 | } |
270 | } |
|
|
271 | # @FUNCTION: tc-arch-kernel |
|
|
272 | # @USAGE: [toolchain prefix] |
|
|
273 | # @RETURN: name of the kernel arch according to the compiler target |
149 | tc-arch-kernel() { |
274 | tc-arch-kernel() { |
150 | tc-ninja_magic_to_arch kern $@ |
275 | tc-ninja_magic_to_arch kern "$@" |
151 | } |
276 | } |
|
|
277 | # @FUNCTION: tc-arch |
|
|
278 | # @USAGE: [toolchain prefix] |
|
|
279 | # @RETURN: name of the portage arch according to the compiler target |
152 | tc-arch() { |
280 | tc-arch() { |
153 | tc-ninja_magic_to_arch portage $@ |
281 | tc-ninja_magic_to_arch portage "$@" |
154 | } |
282 | } |
155 | |
283 | |
156 | # Returns the version as by `$CC -dumpversion` |
284 | tc-endian() { |
|
|
285 | local host=$1 |
|
|
286 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
287 | host=${host%%-*} |
|
|
288 | |
|
|
289 | case ${host} in |
|
|
290 | alpha*) echo big;; |
|
|
291 | arm*b*) echo big;; |
|
|
292 | arm*) echo little;; |
|
|
293 | cris*) echo little;; |
|
|
294 | hppa*) echo big;; |
|
|
295 | i?86*) echo little;; |
|
|
296 | ia64*) echo little;; |
|
|
297 | m68*) echo big;; |
|
|
298 | mips*l*) echo little;; |
|
|
299 | mips*) echo big;; |
|
|
300 | powerpc*) echo big;; |
|
|
301 | s390*) echo big;; |
|
|
302 | sh*b*) echo big;; |
|
|
303 | sh*) echo little;; |
|
|
304 | sparc*) echo big;; |
|
|
305 | x86_64*) echo little;; |
|
|
306 | *) echo wtf;; |
|
|
307 | esac |
|
|
308 | } |
|
|
309 | |
|
|
310 | # @FUNCTION: gcc-fullversion |
|
|
311 | # @RETURN: compiler version (major.minor.micro: [3.4.6]) |
157 | gcc-fullversion() { |
312 | gcc-fullversion() { |
158 | $(tc-getCC "$@") -dumpversion |
313 | $(tc-getCC "$@") -dumpversion |
159 | } |
314 | } |
160 | # Returns the version, but only the <major>.<minor> |
315 | # @FUNCTION: gcc-version |
|
|
316 | # @RETURN: compiler version (major.minor: [3.4].6) |
161 | gcc-version() { |
317 | gcc-version() { |
162 | gcc-fullversion "$@" | cut -f1,2 -d. |
318 | gcc-fullversion "$@" | cut -f1,2 -d. |
163 | } |
319 | } |
164 | # Returns the Major version |
320 | # @FUNCTION: gcc-major-version |
|
|
321 | # @RETURN: major compiler version (major: [3].4.6) |
165 | gcc-major-version() { |
322 | gcc-major-version() { |
166 | gcc-version "$@" | cut -f1 -d. |
323 | gcc-version "$@" | cut -f1 -d. |
167 | } |
324 | } |
168 | # Returns the Minor version |
325 | # @FUNCTION: gcc-minor-version |
|
|
326 | # @RETURN: minor compiler version (minor: 3.[4].6) |
169 | gcc-minor-version() { |
327 | gcc-minor-version() { |
170 | gcc-version "$@" | cut -f2 -d. |
328 | gcc-version "$@" | cut -f2 -d. |
171 | } |
329 | } |
172 | # Returns the Micro version |
330 | # @FUNCTION: gcc-micro-version |
|
|
331 | # @RETURN: micro compiler version (micro: 3.4.[6]) |
173 | gcc-micro-version() { |
332 | gcc-micro-version() { |
174 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
333 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
175 | } |
334 | } |
176 | |
335 | |
|
|
336 | # Returns the installation directory - internal toolchain |
|
|
337 | # function for use by _gcc-specs-exists (for flag-o-matic). |
|
|
338 | _gcc-install-dir() { |
|
|
339 | echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null |\ |
|
|
340 | awk '$1=="install:" {print $2}')" |
|
|
341 | } |
|
|
342 | # Returns true if the indicated specs file exists - internal toolchain |
|
|
343 | # function for use by flag-o-matic. |
|
|
344 | _gcc-specs-exists() { |
|
|
345 | [[ -f $(_gcc-install-dir)/$1 ]] |
|
|
346 | } |
|
|
347 | |
177 | # Returns requested gcc specs directive |
348 | # Returns requested gcc specs directive unprocessed - for used by |
|
|
349 | # gcc-specs-directive() |
178 | # Note; later specs normally overwrite earlier ones; however if a later |
350 | # Note; later specs normally overwrite earlier ones; however if a later |
179 | # spec starts with '+' then it appends. |
351 | # spec starts with '+' then it appends. |
180 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
352 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
181 | # as "Reading <file>", in order. |
353 | # as "Reading <file>", in order. Strictly speaking, if there's a |
|
|
354 | # $(gcc_install_dir)/specs, the built-in specs aren't read, however by |
|
|
355 | # the same token anything from 'gcc -dumpspecs' is overridden by |
|
|
356 | # the contents of $(gcc_install_dir)/specs so the result is the |
|
|
357 | # same either way. |
182 | gcc-specs-directive() { |
358 | _gcc-specs-directive_raw() { |
183 | local cc=$(tc-getCC) |
359 | local cc=$(tc-getCC) |
184 | local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}') |
360 | local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}') |
185 | ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
361 | ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
186 | 'BEGIN { pspec=""; spec=""; outside=1 } |
362 | 'BEGIN { pspec=""; spec=""; outside=1 } |
187 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
363 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
… | |
… | |
190 | { spec=spec $0 } |
366 | { spec=spec $0 } |
191 | END { print spec }' |
367 | END { print spec }' |
192 | return 0 |
368 | return 0 |
193 | } |
369 | } |
194 | |
370 | |
|
|
371 | # Return the requested gcc specs directive, with all included |
|
|
372 | # specs expanded. |
|
|
373 | # Note, it does not check for inclusion loops, which cause it |
|
|
374 | # to never finish - but such loops are invalid for gcc and we're |
|
|
375 | # assuming gcc is operational. |
|
|
376 | gcc-specs-directive() { |
|
|
377 | local directive subdname subdirective |
|
|
378 | directive="$(_gcc-specs-directive_raw $1)" |
|
|
379 | while [[ ${directive} == *%\(*\)* ]]; do |
|
|
380 | subdname=${directive/*%\(} |
|
|
381 | subdname=${subdname/\)*} |
|
|
382 | subdirective="$(_gcc-specs-directive_raw ${subdname})" |
|
|
383 | directive="${directive//\%(${subdname})/${subdirective}}" |
|
|
384 | done |
|
|
385 | echo "${directive}" |
|
|
386 | return 0 |
|
|
387 | } |
|
|
388 | |
195 | # Returns true if gcc sets relro |
389 | # Returns true if gcc sets relro |
196 | gcc-specs-relro() { |
390 | gcc-specs-relro() { |
197 | local directive |
391 | local directive |
198 | directive=$(gcc-specs-directive link_command) |
392 | directive=$(gcc-specs-directive link_command) |
199 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
393 | return $([[ "${directive/\{!norelro:}" != "${directive}" ]]) |
200 | } |
394 | } |
201 | # Returns true if gcc sets now |
395 | # Returns true if gcc sets now |
202 | gcc-specs-now() { |
396 | gcc-specs-now() { |
203 | local directive |
397 | local directive |
204 | directive=$(gcc-specs-directive link_command) |
398 | directive=$(gcc-specs-directive link_command) |
205 | return $([[ ${directive/\{!nonow:} != ${directive} ]]) |
399 | return $([[ "${directive/\{!nonow:}" != "${directive}" ]]) |
206 | } |
400 | } |
207 | # Returns true if gcc builds PIEs |
401 | # Returns true if gcc builds PIEs |
208 | gcc-specs-pie() { |
402 | gcc-specs-pie() { |
209 | local directive |
403 | local directive |
210 | directive=$(gcc-specs-directive cc1) |
404 | directive=$(gcc-specs-directive cc1) |
211 | return $([[ ${directive/\{!nopie:} != ${directive} ]]) |
405 | return $([[ "${directive/\{!nopie:}" != "${directive}" ]]) |
212 | } |
406 | } |
213 | # Returns true if gcc builds with the stack protector |
407 | # Returns true if gcc builds with the stack protector |
214 | gcc-specs-ssp() { |
408 | gcc-specs-ssp() { |
215 | local directive |
409 | local directive |
216 | directive=$(gcc-specs-directive cc1) |
410 | directive=$(gcc-specs-directive cc1) |
217 | return $([[ ${directive/\{!fno-stack-protector:} != ${directive} ]]) |
411 | return $([[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]]) |
218 | } |
412 | } |
219 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
413 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
220 | gcc-specs-ssp-to-all() { |
414 | gcc-specs-ssp-to-all() { |
221 | local directive |
415 | local directive |
222 | directive=$(gcc-specs-directive cc1) |
416 | directive=$(gcc-specs-directive cc1) |
223 | return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]]) |
417 | return $([[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]]) |
224 | } |
418 | } |
|
|
419 | # Returns true if gcc builds with fno-strict-overflow |
|
|
420 | gcc-specs-nostrict() { |
|
|
421 | local directive |
|
|
422 | directive=$(gcc-specs-directive cc1) |
|
|
423 | return $([[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]]) |
|
|
424 | } |
225 | |
425 | |
226 | |
426 | |
|
|
427 | # @FUNCTION: gen_usr_ldscript |
|
|
428 | # @USAGE: [-a] <list of libs to create linker scripts for> |
|
|
429 | # @DESCRIPTION: |
227 | # This function generate linker scripts in /usr/lib for dynamic |
430 | # This function generate linker scripts in /usr/lib for dynamic |
228 | # libs in /lib. This is to fix linking problems when you have |
431 | # libs in /lib. This is to fix linking problems when you have |
229 | # the .so in /lib, and the .a in /usr/lib. What happens is that |
432 | # the .so in /lib, and the .a in /usr/lib. What happens is that |
230 | # in some cases when linking dynamic, the .a in /usr/lib is used |
433 | # in some cases when linking dynamic, the .a in /usr/lib is used |
231 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
434 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
232 | # library search path. This cause many builds to fail. |
435 | # library search path. This causes many builds to fail. |
233 | # See bug #4411 for more info. |
436 | # See bug #4411 for more info. |
234 | # |
437 | # |
235 | # To use, simply call: |
|
|
236 | # |
|
|
237 | # gen_usr_ldscript libfoo.so |
|
|
238 | # |
|
|
239 | # Note that you should in general use the unversioned name of |
438 | # Note that you should in general use the unversioned name of |
240 | # the library, as ldconfig should usually update it correctly |
439 | # the library (libfoo.so), as ldconfig should usually update it |
241 | # to point to the latest version of the library present. |
440 | # correctly to point to the latest version of the library present. |
242 | _tc_gen_usr_ldscript() { |
441 | gen_usr_ldscript() { |
243 | local lib libdir=$(get_libdir) output_format="" |
442 | local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname) |
244 | # Just make sure it exists |
443 | # Just make sure it exists |
245 | dodir /usr/${libdir} |
444 | dodir /usr/${libdir} |
|
|
445 | |
|
|
446 | if [[ $1 == "-a" ]] ; then |
|
|
447 | auto=true |
|
|
448 | shift |
|
|
449 | dodir /${libdir} |
|
|
450 | fi |
246 | |
451 | |
247 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
452 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
248 | # is referenced ... makes multilib saner |
453 | # is referenced ... makes multilib saner |
249 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
454 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
250 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
455 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
251 | |
456 | |
252 | for lib in "$@" ; do |
457 | for lib in "$@" ; do |
253 | if [[ ${USERLAND} == "Darwin" ]] ; then |
458 | |
254 | ewarn "Not creating fake dynamic library for $lib on Darwin;" |
459 | # Ensure /lib/${lib} exists to avoid dangling scripts/symlinks. |
255 | ewarn "making a symlink instead." |
460 | # This especially is for AIX where $(get_libname) can return ".a", |
256 | dosym "/${libdir}/${lib}" "/usr/${libdir}/${lib}" |
461 | # so /lib/${lib} might be moved to /usr/lib/${lib} (by accident). |
|
|
462 | [[ -r "${ED}"/${libdir}/${lib} ]] || continue |
|
|
463 | |
|
|
464 | case ${CHOST} in |
|
|
465 | *-darwin*) |
|
|
466 | # Mach-O files have an id, which is like a soname, it tells how |
|
|
467 | # another object linking against this lib should reference it. |
|
|
468 | # Since we moved the lib from usr/lib into lib this reference is |
|
|
469 | # wrong. Hence, we update it here. We don't configure with |
|
|
470 | # libdir=/lib because that messes up libtool files. |
|
|
471 | # Make sure we don't lose the specific version, so just modify the |
|
|
472 | # existing install_name |
|
|
473 | install_name=$(otool -DX "${ED}"/${libdir}/${lib}) |
|
|
474 | [[ -z ${install_name} ]] && die "No install name found for ${ED}/${libdir}/${lib}" |
|
|
475 | install_name_tool \ |
|
|
476 | -id "${EPREFIX}"/${libdir}/${install_name##*/} \ |
|
|
477 | "${ED}"/${libdir}/${lib} |
|
|
478 | # Now as we don't use GNU binutils and our linker doesn't |
|
|
479 | # understand linker scripts, just create a symlink. |
|
|
480 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
481 | ln -snf "../../${libdir}/${lib}" "${lib}" |
|
|
482 | popd > /dev/null |
|
|
483 | ;; |
|
|
484 | *-aix*|*-irix*|*-hpux*) |
|
|
485 | # we don't have GNU binutils on these platforms, so we symlink |
|
|
486 | # instead, which seems to work fine. Keep it relative, otherwise |
|
|
487 | # we break some QA checks in Portage |
|
|
488 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
489 | ln -snf "../../${libdir}/${lib}" "${lib}" |
|
|
490 | popd > /dev/null |
|
|
491 | ;; |
|
|
492 | *-interix*|*-winnt*) |
|
|
493 | # on interix, the linker scripts would work fine in _most_ |
|
|
494 | # situations. if a library links to such a linker script the |
|
|
495 | # absolute path to the correct library is inserted into the binary, |
|
|
496 | # which is wrong, since anybody linking _without_ libtool will miss |
|
|
497 | # some dependencies, since the stupid linker cannot find libraries |
|
|
498 | # hardcoded with absolute paths (as opposed to the loader, which |
|
|
499 | # seems to be able to do this). |
|
|
500 | # this has been seen while building shared-mime-info which needs |
|
|
501 | # libxml2, but links without libtool (and does not add libz to the |
|
|
502 | # command line by itself). |
|
|
503 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
504 | ln -snf "../../${libdir}/${lib}" "${lib}" |
|
|
505 | popd > /dev/null |
|
|
506 | ;; |
|
|
507 | *-mint*) |
|
|
508 | # do nothing |
|
|
509 | return |
|
|
510 | ;; |
|
|
511 | *) |
|
|
512 | local tlib |
|
|
513 | if ${auto} ; then |
|
|
514 | lib="lib${lib}${suffix}" |
|
|
515 | tlib=$(scanelf -qF'%S#F' "${D}"/usr/${libdir}/${lib}) |
|
|
516 | mv "${D}"/usr/${libdir}/${lib}* "${D}"/${libdir}/ || die |
|
|
517 | # some SONAMEs are funky: they encode a version before the .so |
|
|
518 | if [[ ${tlib} != ${lib}* ]] ; then |
|
|
519 | mv "${D}"/usr/${libdir}/${tlib}* "${D}"/${libdir}/ || die |
|
|
520 | fi |
|
|
521 | [[ -z ${tlib} ]] && die "unable to read SONAME from ${lib}" |
|
|
522 | rm -f "${D}"/${libdir}/${lib} |
257 | else |
523 | else |
|
|
524 | tlib=${lib} |
|
|
525 | fi |
258 | cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
526 | cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
259 | /* GNU ld script |
527 | /* GNU ld script |
260 | Since Gentoo has critical dynamic libraries |
528 | Since Gentoo has critical dynamic libraries in /lib, and the static versions |
261 | in /lib, and the static versions in /usr/lib, |
529 | in /usr/lib, we need to have a "fake" dynamic lib in /usr/lib, otherwise we |
262 | we need to have a "fake" dynamic lib in /usr/lib, |
530 | run into linking problems. This "fake" dynamic lib is a linker script that |
263 | otherwise we run into linking problems. |
531 | redirects the linker to the real lib. And yes, this works in the cross- |
|
|
532 | compiling scenario as the sysroot-ed linker will prepend the real path. |
264 | |
533 | |
265 | See bug http://bugs.gentoo.org/4411 for more info. |
534 | See bug http://bugs.gentoo.org/4411 for more info. |
266 | */ |
535 | */ |
267 | ${output_format} |
536 | ${output_format} |
268 | GROUP ( /${libdir}/${lib} ) |
537 | GROUP ( /${libdir}/${tlib} ) |
269 | END_LDSCRIPT |
538 | END_LDSCRIPT |
270 | fi |
539 | ;; |
|
|
540 | esac |
271 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
541 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
272 | done |
542 | done |
273 | } |
543 | } |
274 | gen_usr_ldscript() { _tc_gen_usr_ldscript "$@" ; } |
544 | |
|
|
545 | # This function is for AIX only. |
|
|
546 | # |
|
|
547 | # Showing a sample IMO is the best description: |
|
|
548 | # |
|
|
549 | # First, AIX has its own /usr/lib/libiconv.a containing 'shr.o' and 'shr4.o'. |
|
|
550 | # Both of them are shared-objects packed into an archive, thus /usr/lib/libiconv.a |
|
|
551 | # is a shared library (!), even it is called lib*.a. |
|
|
552 | # This is the default layout on aix for shared libraries. |
|
|
553 | # Read the ld(1) manpage for more information. |
|
|
554 | # |
|
|
555 | # But now, we want to install GNU libiconv (sys-libs/libiconv) both as |
|
|
556 | # shared and static library. |
|
|
557 | # AIX (since 4.3) can create shared libraries if '-brtl' or '-G' linker flags |
|
|
558 | # are used. |
|
|
559 | # |
|
|
560 | # Now assume we have GNU tar installed while GNU libiconv was not. |
|
|
561 | # This tar now has a runtime dependency on "libiconv.a(shr4.o)". |
|
|
562 | # With our ld-wrapper (from sys-devel/binutils-config) we add EPREFIX/usr/lib |
|
|
563 | # as linker path, thus it is recorded as loader path into the binary. |
|
|
564 | # |
|
|
565 | # When having libiconv.a (the static GNU libiconv) in prefix, the loader finds |
|
|
566 | # that one and claims that it does not contain an 'shr4.o' object file: |
|
|
567 | # |
|
|
568 | # Could not load program tar: |
|
|
569 | # Dependent module EPREFIX/usr/lib/libiconv.a(shr4.o) could not be loaded. |
|
|
570 | # Member shr4.o is not found in archive |
|
|
571 | # |
|
|
572 | # According to gcc's "host/target specific installation notes" for *-ibm-aix* [1], |
|
|
573 | # we can extract that 'shr4.o' from /usr/lib/libiconv.a, mark it as |
|
|
574 | # non-linkable, and include it in our new static library. |
|
|
575 | # |
|
|
576 | # [1] http://gcc.gnu.org/install/specific.html#x-ibm-aix |
|
|
577 | # |
|
|
578 | # usage: |
|
|
579 | # keep_aix_runtime_object <target-archive inside EPREFIX> <source-archive(objects)> |
|
|
580 | # keep_aix_runtime_object "/usr/lib/libiconv.a "/usr/lib/libiconv.a(shr4.o,...)" |
|
|
581 | keep_aix_runtime_objects() { |
|
|
582 | [[ ${CHOST} == *-*-aix* ]] || return 0 |
|
|
583 | |
|
|
584 | local target=$1 |
|
|
585 | shift |
|
|
586 | local sources="$@" |
|
|
587 | |
|
|
588 | # strip possible ${ED} prefixes |
|
|
589 | target=${target##/} |
|
|
590 | target=${target#${D##/}} |
|
|
591 | target=${target#${EPREFIX##/}} |
|
|
592 | target=${target##/} |
|
|
593 | |
|
|
594 | if ! $(tc-getAR) -t "${ED}${target}" &>/dev/null; then |
|
|
595 | if [[ -e ${ED}${target} ]]; then |
|
|
596 | ewarn "${target} is not an archive." |
|
|
597 | fi |
|
|
598 | return 0 |
|
|
599 | fi |
|
|
600 | |
|
|
601 | local tmpdir=${TMP}/keep_aix_runtime_object-$$ |
|
|
602 | mkdir ${tmpdir} || die |
|
|
603 | |
|
|
604 | local origdir=$(pwd) |
|
|
605 | local s |
|
|
606 | for s in ${sources}; do |
|
|
607 | local sourcelib sourceobjs so |
|
|
608 | # format of $s: "/usr/lib/libiconv.a(shr4.o,shr.o)" |
|
|
609 | sourcelib=${s%%(*} |
|
|
610 | sourceobjs=${s#*(} |
|
|
611 | sourceobjs=${sourceobjs%)} |
|
|
612 | sourceobjs=${sourceobjs//,/ } |
|
|
613 | cd ${tmpdir} || die |
|
|
614 | for so in ${sourceobjs}; do |
|
|
615 | ebegin "keeping aix runtime object '${sourcelib}(${so})' in '${EPREFIX}/${target}'" |
|
|
616 | if ! $(tc-getAR) -x "${sourcelib}" ${so}; then |
|
|
617 | eend 1 |
|
|
618 | continue |
|
|
619 | fi |
|
|
620 | chmod +w ${so} && |
|
|
621 | $(tc-getSTRIP) -e ${so} && |
|
|
622 | $(tc-getAR) -q "${ED}${target}" ${so} && |
|
|
623 | eend 0 || |
|
|
624 | eend 1 |
|
|
625 | done |
|
|
626 | done |
|
|
627 | cd "${origdir}" |
|
|
628 | } |