1 | # Copyright 1999-2007 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.70 2007/06/16 07:11:43 vapier Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.101 2010/08/20 15:04:11 dberkholz Exp $ |
4 | # |
4 | |
|
|
5 | # @ECLASS: toolchain-funcs.eclass |
|
|
6 | # @MAINTAINER: |
5 | # Maintainer: 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 | ___ECLASS_RECUR_TOOLCHAIN_FUNCS="yes" |
16 | ___ECLASS_RECUR_TOOLCHAIN_FUNCS="yes" |
11 | [[ -z ${___ECLASS_RECUR_MULTILIB} ]] && inherit multilib |
17 | [[ -z ${___ECLASS_RECUR_MULTILIB} ]] && inherit multilib |
12 | |
18 | |
13 | DESCRIPTION="Based on the ${ECLASS} eclass" |
19 | DESCRIPTION="Based on the ${ECLASS} eclass" |
… | |
… | |
28 | |
34 | |
29 | export ${var}=${prog} |
35 | export ${var}=${prog} |
30 | echo "${!var}" |
36 | echo "${!var}" |
31 | } |
37 | } |
32 | |
38 | |
33 | # Returns the name of the archiver |
39 | # @FUNCTION: tc-getAR |
|
|
40 | # @USAGE: [toolchain prefix] |
|
|
41 | # @RETURN: name of the archiver |
34 | tc-getAR() { tc-getPROG AR ar "$@"; } |
42 | tc-getAR() { tc-getPROG AR ar "$@"; } |
35 | # Returns the name of the assembler |
43 | # @FUNCTION: tc-getAS |
|
|
44 | # @USAGE: [toolchain prefix] |
|
|
45 | # @RETURN: name of the assembler |
36 | tc-getAS() { tc-getPROG AS as "$@"; } |
46 | tc-getAS() { tc-getPROG AS as "$@"; } |
|
|
47 | # @FUNCTION: tc-getCC |
|
|
48 | # @USAGE: [toolchain prefix] |
37 | # Returns the name of the C compiler |
49 | # @RETURN: name of the C compiler |
38 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
50 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
|
|
51 | # @FUNCTION: tc-getCPP |
|
|
52 | # @USAGE: [toolchain prefix] |
39 | # Returns the name of the C preprocessor |
53 | # @RETURN: name of the C preprocessor |
40 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
54 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
|
|
55 | # @FUNCTION: tc-getCXX |
|
|
56 | # @USAGE: [toolchain prefix] |
41 | # Returns the name of the C++ compiler |
57 | # @RETURN: name of the C++ compiler |
42 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
58 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
43 | # Returns the name of the linker |
59 | # @FUNCTION: tc-getLD |
|
|
60 | # @USAGE: [toolchain prefix] |
|
|
61 | # @RETURN: name of the linker |
44 | tc-getLD() { tc-getPROG LD ld "$@"; } |
62 | tc-getLD() { tc-getPROG LD ld "$@"; } |
45 | # Returns the name of the strip prog |
63 | # @FUNCTION: tc-getSTRIP |
|
|
64 | # @USAGE: [toolchain prefix] |
|
|
65 | # @RETURN: name of the strip program |
46 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
66 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
|
|
67 | # @FUNCTION: tc-getNM |
|
|
68 | # @USAGE: [toolchain prefix] |
47 | # Returns the name of the symbol/object thingy |
69 | # @RETURN: name of the symbol/object thingy |
48 | tc-getNM() { tc-getPROG NM nm "$@"; } |
70 | tc-getNM() { tc-getPROG NM nm "$@"; } |
|
|
71 | # @FUNCTION: tc-getRANLIB |
|
|
72 | # @USAGE: [toolchain prefix] |
49 | # Returns the name of the archiver indexer |
73 | # @RETURN: name of the archiver indexer |
50 | 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] |
51 | # Returns the name of the fortran 77 compiler |
81 | # @RETURN: name of the Fortran 77 compiler |
52 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
82 | tc-getF77() { tc-getPROG F77 gfortran "$@"; } |
|
|
83 | # @FUNCTION: tc-getFC |
|
|
84 | # @USAGE: [toolchain prefix] |
53 | # Returns the name of the fortran 90 compiler |
85 | # @RETURN: name of the Fortran 90 compiler |
54 | tc-getF90() { tc-getPROG F90 gfortran "$@"; } |
86 | tc-getFC() { tc-getPROG FC gfortran "$@"; } |
55 | # Returns the name of the fortran compiler |
87 | # @FUNCTION: tc-getGCJ |
56 | tc-getFORTRAN() { tc-getPROG FORTRAN gfortran "$@"; } |
88 | # @USAGE: [toolchain prefix] |
57 | # Returns the name of the java compiler |
89 | # @RETURN: name of the java compiler |
58 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
90 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
|
|
91 | # @FUNCTION: tc-getPKG_CONFIG |
|
|
92 | # @USAGE: [toolchain prefix] |
|
|
93 | # @RETURN: name of the pkg-config tool |
|
|
94 | tc-getPKG_CONFIG() { tc-getPROG PKG_CONFIG pkg-config "$@"; } |
|
|
95 | # @FUNCTION: tc-getRC |
|
|
96 | # @USAGE: [toolchain prefix] |
|
|
97 | # @RETURN: name of the Windows resource compiler |
|
|
98 | tc-getRC() { tc-getPROG RC windres "$@"; } |
|
|
99 | # @FUNCTION: tc-getDLLWRAP |
|
|
100 | # @USAGE: [toolchain prefix] |
|
|
101 | # @RETURN: name of the Windows dllwrap utility |
|
|
102 | tc-getDLLWRAP() { tc-getPROG DLLWRAP dllwrap "$@"; } |
59 | |
103 | |
60 | # Returns the name of the C compiler for build |
104 | # @FUNCTION: tc-getBUILD_CC |
|
|
105 | # @USAGE: [toolchain prefix] |
|
|
106 | # @RETURN: name of the C compiler for building binaries to run on the build machine |
61 | tc-getBUILD_CC() { |
107 | tc-getBUILD_CC() { |
62 | local v |
108 | local v |
63 | for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do |
109 | for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do |
64 | if [[ -n ${!v} ]] ; then |
110 | if [[ -n ${!v} ]] ; then |
65 | export BUILD_CC=${!v} |
111 | export BUILD_CC=${!v} |
… | |
… | |
77 | |
123 | |
78 | export BUILD_CC=${search} |
124 | export BUILD_CC=${search} |
79 | echo "${search}" |
125 | echo "${search}" |
80 | } |
126 | } |
81 | |
127 | |
|
|
128 | # @FUNCTION: tc-export |
|
|
129 | # @USAGE: <list of toolchain variables> |
|
|
130 | # @DESCRIPTION: |
82 | # Quick way to export a bunch of vars at once |
131 | # Quick way to export a bunch of compiler vars at once. |
83 | tc-export() { |
132 | tc-export() { |
84 | local var |
133 | local var |
85 | for var in "$@" ; do |
134 | for var in "$@" ; do |
|
|
135 | [[ $(type -t tc-get${var}) != "function" ]] && die "tc-export: invalid export variable '${var}'" |
86 | eval tc-get${var} > /dev/null |
136 | eval tc-get${var} > /dev/null |
87 | done |
137 | done |
88 | } |
138 | } |
89 | |
139 | |
90 | # A simple way to see if we're using a cross-compiler ... |
140 | # @FUNCTION: tc-is-cross-compiler |
|
|
141 | # @RETURN: Shell true if we are using a cross-compiler, shell false otherwise |
91 | tc-is-cross-compiler() { |
142 | tc-is-cross-compiler() { |
92 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
143 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
93 | } |
144 | } |
94 | |
145 | |
|
|
146 | # @FUNCTION: tc-is-softfloat |
|
|
147 | # @DESCRIPTION: |
95 | # See if this toolchain is a softfloat based one. |
148 | # See if this toolchain is a softfloat based one. |
|
|
149 | # @CODE |
96 | # The possible return values: |
150 | # The possible return values: |
97 | # - only: the target is always softfloat (never had fpu) |
151 | # - only: the target is always softfloat (never had fpu) |
98 | # - yes: the target should support softfloat |
152 | # - yes: the target should support softfloat |
99 | # - no: the target should support hardfloat |
153 | # - no: the target doesn't support softfloat |
|
|
154 | # @CODE |
100 | # This allows us to react differently where packages accept |
155 | # This allows us to react differently where packages accept |
101 | # softfloat flags in the case where support is optional, but |
156 | # softfloat flags in the case where support is optional, but |
102 | # rejects softfloat flags where the target always lacks an fpu. |
157 | # rejects softfloat flags where the target always lacks an fpu. |
103 | tc-is-softfloat() { |
158 | tc-is-softfloat() { |
104 | case ${CTARGET} in |
159 | case ${CTARGET} in |
… | |
… | |
110 | || echo "no" |
165 | || echo "no" |
111 | ;; |
166 | ;; |
112 | esac |
167 | esac |
113 | } |
168 | } |
114 | |
169 | |
|
|
170 | # @FUNCTION: tc-is-hardfloat |
|
|
171 | # @DESCRIPTION: |
|
|
172 | # See if this toolchain is a hardfloat based one. |
|
|
173 | # @CODE |
|
|
174 | # The possible return values: |
|
|
175 | # - yes: the target should support hardfloat |
|
|
176 | # - no: the target doesn't support hardfloat |
|
|
177 | tc-is-hardfloat() { |
|
|
178 | [[ ${CTARGET//_/-} == *-hardfloat-* ]] \ |
|
|
179 | && echo "yes" \ |
|
|
180 | || echo "no" |
|
|
181 | } |
|
|
182 | |
|
|
183 | # @FUNCTION: tc-is-static-only |
|
|
184 | # @DESCRIPTION: |
|
|
185 | # Return shell true if the target does not support shared libs, shell false |
|
|
186 | # otherwise. |
|
|
187 | tc-is-static-only() { |
|
|
188 | local host=${CTARGET:-${CHOST}} |
|
|
189 | |
|
|
190 | # *MiNT doesn't have shared libraries, only platform so far |
|
|
191 | return $([[ ${host} == *-mint* ]]) |
|
|
192 | } |
|
|
193 | |
|
|
194 | # @FUNCTION: tc-has-openmp |
|
|
195 | # @USAGE: [toolchain prefix] |
|
|
196 | # @DESCRIPTION: |
|
|
197 | # See if the toolchain supports OpenMP. |
|
|
198 | tc-has-openmp() { |
|
|
199 | local base="${T}/test-tc-openmp" |
|
|
200 | cat <<-EOF > "${base}.c" |
|
|
201 | #include <omp.h> |
|
|
202 | int main() { |
|
|
203 | int nthreads, tid, ret = 0; |
|
|
204 | #pragma omp parallel private(nthreads, tid) |
|
|
205 | { |
|
|
206 | tid = omp_get_thread_num(); |
|
|
207 | nthreads = omp_get_num_threads(); ret += tid + nthreads; |
|
|
208 | } |
|
|
209 | return ret; |
|
|
210 | } |
|
|
211 | EOF |
|
|
212 | $(tc-getCC "$@") -fopenmp "${base}.c" -o "${base}" >&/dev/null |
|
|
213 | local ret=$? |
|
|
214 | rm -f "${base}"* |
|
|
215 | return ${ret} |
|
|
216 | } |
|
|
217 | |
|
|
218 | # @FUNCTION: tc-has-tls |
|
|
219 | # @USAGE: [-s|-c|-l] [toolchain prefix] |
|
|
220 | # @DESCRIPTION: |
|
|
221 | # See if the toolchain supports thread local storage (TLS). Use -s to test the |
|
|
222 | # compiler, -c to also test the assembler, and -l to also test the C library |
|
|
223 | # (the default). |
|
|
224 | tc-has-tls() { |
|
|
225 | local base="${T}/test-tc-tls" |
|
|
226 | cat <<-EOF > "${base}.c" |
|
|
227 | int foo(int *i) { |
|
|
228 | static __thread int j = 0; |
|
|
229 | return *i ? j : *i; |
|
|
230 | } |
|
|
231 | EOF |
|
|
232 | local flags |
|
|
233 | case $1 in |
|
|
234 | -s) flags="-S";; |
|
|
235 | -c) flags="-c";; |
|
|
236 | -l) ;; |
|
|
237 | -*) die "Usage: tc-has-tls [-c|-l] [toolchain prefix]";; |
|
|
238 | esac |
|
|
239 | : ${flags:=-fPIC -shared -Wl,-z,defs} |
|
|
240 | [[ $1 == -* ]] && shift |
|
|
241 | $(tc-getCC "$@") ${flags} "${base}.c" -o "${base}" >&/dev/null |
|
|
242 | local ret=$? |
|
|
243 | rm -f "${base}"* |
|
|
244 | return ${ret} |
|
|
245 | } |
|
|
246 | |
|
|
247 | |
115 | # Parse information from CBUILD/CHOST/CTARGET rather than |
248 | # Parse information from CBUILD/CHOST/CTARGET rather than |
116 | # use external variables from the profile. |
249 | # use external variables from the profile. |
117 | tc-ninja_magic_to_arch() { |
250 | tc-ninja_magic_to_arch() { |
118 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
251 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
119 | |
252 | |
… | |
… | |
122 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
255 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
123 | |
256 | |
124 | case ${host} in |
257 | case ${host} in |
125 | alpha*) echo alpha;; |
258 | alpha*) echo alpha;; |
126 | arm*) echo arm;; |
259 | arm*) echo arm;; |
|
|
260 | avr*) ninj avr32 avr;; |
127 | bfin*) ninj blackfin bfin;; |
261 | bfin*) ninj blackfin bfin;; |
128 | cris*) echo cris;; |
262 | cris*) echo cris;; |
129 | hppa*) ninj parisc hppa;; |
263 | hppa*) ninj parisc hppa;; |
130 | i?86*) ninj i386 x86;; |
264 | i?86*) |
|
|
265 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
266 | # trees have been unified into 'x86'. |
|
|
267 | # FreeBSD still uses i386 |
|
|
268 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -lt $(KV_to_int 2.6.24) || ${host} == *freebsd* ]] ; then |
|
|
269 | echo i386 |
|
|
270 | else |
|
|
271 | echo x86 |
|
|
272 | fi |
|
|
273 | ;; |
131 | ia64*) echo ia64;; |
274 | ia64*) echo ia64;; |
132 | m68*) echo m68k;; |
275 | m68*) echo m68k;; |
133 | mips*) echo mips;; |
276 | mips*) echo mips;; |
134 | nios2*) echo nios2;; |
277 | nios2*) echo nios2;; |
135 | nios*) echo nios;; |
278 | nios*) echo nios;; |
… | |
… | |
160 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
303 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
161 | && ninj sparc64 sparc \ |
304 | && ninj sparc64 sparc \ |
162 | || echo sparc |
305 | || echo sparc |
163 | ;; |
306 | ;; |
164 | vax*) echo vax;; |
307 | vax*) echo vax;; |
165 | x86_64*) ninj x86_64 amd64;; |
308 | x86_64*) |
166 | *) echo ${ARCH};; |
309 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
310 | # trees have been unified into 'x86'. |
|
|
311 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.24) ]] ; then |
|
|
312 | echo x86 |
|
|
313 | else |
|
|
314 | ninj x86_64 amd64 |
|
|
315 | fi |
|
|
316 | ;; |
|
|
317 | |
|
|
318 | # since our usage of tc-arch is largely concerned with |
|
|
319 | # normalizing inputs for testing ${CTARGET}, let's filter |
|
|
320 | # other cross targets (mingw and such) into the unknown. |
|
|
321 | *) echo unknown;; |
167 | esac |
322 | esac |
168 | } |
323 | } |
|
|
324 | # @FUNCTION: tc-arch-kernel |
|
|
325 | # @USAGE: [toolchain prefix] |
|
|
326 | # @RETURN: name of the kernel arch according to the compiler target |
169 | tc-arch-kernel() { |
327 | tc-arch-kernel() { |
170 | tc-ninja_magic_to_arch kern $@ |
328 | tc-ninja_magic_to_arch kern "$@" |
171 | } |
329 | } |
|
|
330 | # @FUNCTION: tc-arch |
|
|
331 | # @USAGE: [toolchain prefix] |
|
|
332 | # @RETURN: name of the portage arch according to the compiler target |
172 | tc-arch() { |
333 | tc-arch() { |
173 | tc-ninja_magic_to_arch portage $@ |
334 | tc-ninja_magic_to_arch portage "$@" |
174 | } |
335 | } |
175 | |
336 | |
176 | # Returns the version as by `$CC -dumpversion` |
337 | tc-endian() { |
|
|
338 | local host=$1 |
|
|
339 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
340 | host=${host%%-*} |
|
|
341 | |
|
|
342 | case ${host} in |
|
|
343 | alpha*) echo big;; |
|
|
344 | arm*b*) echo big;; |
|
|
345 | arm*) echo little;; |
|
|
346 | cris*) echo little;; |
|
|
347 | hppa*) echo big;; |
|
|
348 | i?86*) echo little;; |
|
|
349 | ia64*) echo little;; |
|
|
350 | m68*) echo big;; |
|
|
351 | mips*l*) echo little;; |
|
|
352 | mips*) echo big;; |
|
|
353 | powerpc*) echo big;; |
|
|
354 | s390*) echo big;; |
|
|
355 | sh*b*) echo big;; |
|
|
356 | sh*) echo little;; |
|
|
357 | sparc*) echo big;; |
|
|
358 | x86_64*) echo little;; |
|
|
359 | *) echo wtf;; |
|
|
360 | esac |
|
|
361 | } |
|
|
362 | |
|
|
363 | # @FUNCTION: gcc-fullversion |
|
|
364 | # @RETURN: compiler version (major.minor.micro: [3.4.6]) |
177 | gcc-fullversion() { |
365 | gcc-fullversion() { |
178 | $(tc-getCC "$@") -dumpversion |
366 | $(tc-getCC "$@") -dumpversion |
179 | } |
367 | } |
180 | # Returns the version, but only the <major>.<minor> |
368 | # @FUNCTION: gcc-version |
|
|
369 | # @RETURN: compiler version (major.minor: [3.4].6) |
181 | gcc-version() { |
370 | gcc-version() { |
182 | gcc-fullversion "$@" | cut -f1,2 -d. |
371 | gcc-fullversion "$@" | cut -f1,2 -d. |
183 | } |
372 | } |
184 | # Returns the Major version |
373 | # @FUNCTION: gcc-major-version |
|
|
374 | # @RETURN: major compiler version (major: [3].4.6) |
185 | gcc-major-version() { |
375 | gcc-major-version() { |
186 | gcc-version "$@" | cut -f1 -d. |
376 | gcc-version "$@" | cut -f1 -d. |
187 | } |
377 | } |
188 | # Returns the Minor version |
378 | # @FUNCTION: gcc-minor-version |
|
|
379 | # @RETURN: minor compiler version (minor: 3.[4].6) |
189 | gcc-minor-version() { |
380 | gcc-minor-version() { |
190 | gcc-version "$@" | cut -f2 -d. |
381 | gcc-version "$@" | cut -f2 -d. |
191 | } |
382 | } |
192 | # Returns the Micro version |
383 | # @FUNCTION: gcc-micro-version |
|
|
384 | # @RETURN: micro compiler version (micro: 3.4.[6]) |
193 | gcc-micro-version() { |
385 | gcc-micro-version() { |
194 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
386 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
195 | } |
387 | } |
|
|
388 | |
196 | # Returns the installation directory - internal toolchain |
389 | # Returns the installation directory - internal toolchain |
197 | # function for use by _gcc-specs-exists (for flag-o-matic). |
390 | # function for use by _gcc-specs-exists (for flag-o-matic). |
198 | _gcc-install-dir() { |
391 | _gcc-install-dir() { |
199 | echo "$($(tc-getCC) -print-search-dirs 2> /dev/null |\ |
392 | echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null |\ |
200 | awk '$1=="install:" {print $2}')" |
393 | awk '$1=="install:" {print $2}')" |
201 | } |
394 | } |
202 | # Returns true if the indicated specs file exists - internal toolchain |
395 | # Returns true if the indicated specs file exists - internal toolchain |
203 | # function for use by flag-o-matic. |
396 | # function for use by flag-o-matic. |
204 | _gcc-specs-exists() { |
397 | _gcc-specs-exists() { |
… | |
… | |
248 | |
441 | |
249 | # Returns true if gcc sets relro |
442 | # Returns true if gcc sets relro |
250 | gcc-specs-relro() { |
443 | gcc-specs-relro() { |
251 | local directive |
444 | local directive |
252 | directive=$(gcc-specs-directive link_command) |
445 | directive=$(gcc-specs-directive link_command) |
253 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
446 | return $([[ "${directive/\{!norelro:}" != "${directive}" ]]) |
254 | } |
447 | } |
255 | # Returns true if gcc sets now |
448 | # Returns true if gcc sets now |
256 | gcc-specs-now() { |
449 | gcc-specs-now() { |
257 | local directive |
450 | local directive |
258 | directive=$(gcc-specs-directive link_command) |
451 | directive=$(gcc-specs-directive link_command) |
259 | return $([[ ${directive/\{!nonow:} != ${directive} ]]) |
452 | return $([[ "${directive/\{!nonow:}" != "${directive}" ]]) |
260 | } |
453 | } |
261 | # Returns true if gcc builds PIEs |
454 | # Returns true if gcc builds PIEs |
262 | gcc-specs-pie() { |
455 | gcc-specs-pie() { |
263 | local directive |
456 | local directive |
264 | directive=$(gcc-specs-directive cc1) |
457 | directive=$(gcc-specs-directive cc1) |
265 | return $([[ ${directive/\{!nopie:} != ${directive} ]]) |
458 | return $([[ "${directive/\{!nopie:}" != "${directive}" ]]) |
266 | } |
459 | } |
267 | # Returns true if gcc builds with the stack protector |
460 | # Returns true if gcc builds with the stack protector |
268 | gcc-specs-ssp() { |
461 | gcc-specs-ssp() { |
269 | local directive |
462 | local directive |
270 | directive=$(gcc-specs-directive cc1) |
463 | directive=$(gcc-specs-directive cc1) |
271 | return $([[ ${directive/\{!fno-stack-protector:} != ${directive} ]]) |
464 | return $([[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]]) |
272 | } |
465 | } |
273 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
466 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
274 | gcc-specs-ssp-to-all() { |
467 | gcc-specs-ssp-to-all() { |
275 | local directive |
468 | local directive |
276 | directive=$(gcc-specs-directive cc1) |
469 | directive=$(gcc-specs-directive cc1) |
277 | return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]]) |
470 | return $([[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]]) |
278 | } |
471 | } |
|
|
472 | # Returns true if gcc builds with fno-strict-overflow |
|
|
473 | gcc-specs-nostrict() { |
|
|
474 | local directive |
|
|
475 | directive=$(gcc-specs-directive cc1) |
|
|
476 | return $([[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]]) |
|
|
477 | } |
279 | |
478 | |
280 | |
479 | |
|
|
480 | # @FUNCTION: gen_usr_ldscript |
|
|
481 | # @USAGE: [-a] <list of libs to create linker scripts for> |
|
|
482 | # @DESCRIPTION: |
281 | # This function generate linker scripts in /usr/lib for dynamic |
483 | # This function generate linker scripts in /usr/lib for dynamic |
282 | # libs in /lib. This is to fix linking problems when you have |
484 | # 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 |
485 | # 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 |
486 | # 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 |
487 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
286 | # library search path. This cause many builds to fail. |
488 | # library search path. This causes many builds to fail. |
287 | # See bug #4411 for more info. |
489 | # See bug #4411 for more info. |
288 | # |
490 | # |
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 |
491 | # Note that you should in general use the unversioned name of |
294 | # the library, as ldconfig should usually update it correctly |
492 | # the library (libfoo.so), as ldconfig should usually update it |
295 | # to point to the latest version of the library present. |
493 | # correctly to point to the latest version of the library present. |
296 | gen_usr_ldscript() { |
494 | gen_usr_ldscript() { |
297 | local lib libdir=$(get_libdir) output_format="" |
495 | local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname) |
|
|
496 | [[ -z ${ED+set} ]] && local ED=${D%/}${EPREFIX}/ |
|
|
497 | |
|
|
498 | tc-is-static-only && return |
|
|
499 | |
298 | # Just make sure it exists |
500 | # Just make sure it exists |
299 | dodir /usr/${libdir} |
501 | dodir /usr/${libdir} |
|
|
502 | |
|
|
503 | if [[ $1 == "-a" ]] ; then |
|
|
504 | auto=true |
|
|
505 | shift |
|
|
506 | dodir /${libdir} |
|
|
507 | fi |
300 | |
508 | |
301 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
509 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
302 | # is referenced ... makes multilib saner |
510 | # is referenced ... makes multilib saner |
303 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
511 | 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} )" |
512 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
305 | |
513 | |
306 | for lib in "$@" ; do |
514 | for lib in "$@" ; do |
307 | if [[ ${USERLAND} == "Darwin" ]] ; then |
515 | local tlib |
308 | ewarn "Not creating fake dynamic library for $lib on Darwin;" |
516 | if ${auto} ; then |
309 | ewarn "making a symlink instead." |
517 | lib="lib${lib}${suffix}" |
310 | dosym "/${libdir}/${lib}" "/usr/${libdir}/${lib}" |
|
|
311 | else |
518 | else |
|
|
519 | # Ensure /lib/${lib} exists to avoid dangling scripts/symlinks. |
|
|
520 | # This especially is for AIX where $(get_libname) can return ".a", |
|
|
521 | # so /lib/${lib} might be moved to /usr/lib/${lib} (by accident). |
|
|
522 | [[ -r ${ED}/${libdir}/${lib} ]] || continue |
|
|
523 | #TODO: better die here? |
|
|
524 | fi |
|
|
525 | |
|
|
526 | case ${CTARGET:-${CHOST}} in |
|
|
527 | *-darwin*) |
|
|
528 | if ${auto} ; then |
|
|
529 | tlib=$(scanmacho -qF'%S#F' "${ED}"/usr/${libdir}/${lib}) |
|
|
530 | else |
|
|
531 | tlib=$(scanmacho -qF'%S#F' "${ED}"/${libdir}/${lib}) |
|
|
532 | fi |
|
|
533 | [[ -z ${tlib} ]] && die "unable to read install_name from ${lib}" |
|
|
534 | tlib=${tlib##*/} |
|
|
535 | |
|
|
536 | if ${auto} ; then |
|
|
537 | mv "${ED}"/usr/${libdir}/${lib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die |
|
|
538 | # some install_names are funky: they encode a version |
|
|
539 | if [[ ${tlib} != ${lib%${suffix}}.*${suffix#.} ]] ; then |
|
|
540 | mv "${ED}"/usr/${libdir}/${tlib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die |
|
|
541 | fi |
|
|
542 | rm -f "${ED}"/${libdir}/${lib} |
|
|
543 | fi |
|
|
544 | |
|
|
545 | # Mach-O files have an id, which is like a soname, it tells how |
|
|
546 | # another object linking against this lib should reference it. |
|
|
547 | # Since we moved the lib from usr/lib into lib this reference is |
|
|
548 | # wrong. Hence, we update it here. We don't configure with |
|
|
549 | # libdir=/lib because that messes up libtool files. |
|
|
550 | # Make sure we don't lose the specific version, so just modify the |
|
|
551 | # existing install_name |
|
|
552 | if [[ ! -w "${ED}/${libdir}/${tlib}" ]] ; then |
|
|
553 | chmod u+w "${ED}${libdir}/${tlib}" # needed to write to it |
|
|
554 | local nowrite=yes |
|
|
555 | fi |
|
|
556 | install_name_tool \ |
|
|
557 | -id "${EPREFIX}"/${libdir}/${tlib} \ |
|
|
558 | "${ED}"/${libdir}/${tlib} || die "install_name_tool failed" |
|
|
559 | [[ -n ${nowrite} ]] && chmod u-w "${ED}${libdir}/${tlib}" |
|
|
560 | # Now as we don't use GNU binutils and our linker doesn't |
|
|
561 | # understand linker scripts, just create a symlink. |
|
|
562 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
563 | ln -snf "../../${libdir}/${tlib}" "${lib}" |
|
|
564 | popd > /dev/null |
|
|
565 | ;; |
|
|
566 | *-aix*|*-irix*|*64*-hpux*|*-interix*|*-winnt*) |
|
|
567 | if ${auto} ; then |
|
|
568 | mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die |
|
|
569 | # no way to retrieve soname on these platforms (?) |
|
|
570 | tlib=$(readlink "${ED}"/${libdir}/${lib}) |
|
|
571 | tlib=${tlib##*/} |
|
|
572 | if [[ -z ${tlib} ]] ; then |
|
|
573 | # ok, apparently was not a symlink, don't remove it and |
|
|
574 | # just link to it |
|
|
575 | tlib=${lib} |
|
|
576 | else |
|
|
577 | rm -f "${ED}"/${libdir}/${lib} |
|
|
578 | fi |
|
|
579 | else |
|
|
580 | tlib=${lib} |
|
|
581 | fi |
|
|
582 | |
|
|
583 | # we don't have GNU binutils on these platforms, so we symlink |
|
|
584 | # instead, which seems to work fine. Keep it relative, otherwise |
|
|
585 | # we break some QA checks in Portage |
|
|
586 | # on interix, the linker scripts would work fine in _most_ |
|
|
587 | # situations. if a library links to such a linker script the |
|
|
588 | # absolute path to the correct library is inserted into the binary, |
|
|
589 | # which is wrong, since anybody linking _without_ libtool will miss |
|
|
590 | # some dependencies, since the stupid linker cannot find libraries |
|
|
591 | # hardcoded with absolute paths (as opposed to the loader, which |
|
|
592 | # seems to be able to do this). |
|
|
593 | # this has been seen while building shared-mime-info which needs |
|
|
594 | # libxml2, but links without libtool (and does not add libz to the |
|
|
595 | # command line by itself). |
|
|
596 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
597 | ln -snf "../../${libdir}/${tlib}" "${lib}" |
|
|
598 | popd > /dev/null |
|
|
599 | ;; |
|
|
600 | hppa*-hpux*) # PA-RISC 32bit (SOM) only, others (ELF) match *64*-hpux* above. |
|
|
601 | if ${auto} ; then |
|
|
602 | tlib=$(chatr "${ED}"/usr/${libdir}/${lib} | sed -n '/internal name:/{n;s/^ *//;p;q}') |
|
|
603 | [[ -z ${tlib} ]] && tlib=${lib} |
|
|
604 | tlib=${tlib##*/} # 'internal name' can have a path component |
|
|
605 | mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die |
|
|
606 | # some SONAMEs are funky: they encode a version before the .so |
|
|
607 | if [[ ${tlib} != ${lib}* ]] ; then |
|
|
608 | mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die |
|
|
609 | fi |
|
|
610 | [[ ${tlib} != ${lib} ]] && |
|
|
611 | rm -f "${ED}"/${libdir}/${lib} |
|
|
612 | else |
|
|
613 | tlib=$(chatr "${ED}"/${libdir}/${lib} | sed -n '/internal name:/{n;s/^ *//;p;q}') |
|
|
614 | [[ -z ${tlib} ]] && tlib=${lib} |
|
|
615 | tlib=${tlib##*/} # 'internal name' can have a path component |
|
|
616 | fi |
|
|
617 | pushd "${ED}"/usr/${libdir} >/dev/null |
|
|
618 | ln -snf "../../${libdir}/${tlib}" "${lib}" |
|
|
619 | # need the internal name in usr/lib too, to be available at runtime |
|
|
620 | # when linked with /path/to/lib.sl (hardcode_direct_absolute=yes) |
|
|
621 | [[ ${tlib} != ${lib} ]] && |
|
|
622 | ln -snf "../../${libdir}/${tlib}" "${tlib}" |
|
|
623 | popd >/dev/null |
|
|
624 | ;; |
|
|
625 | *) |
|
|
626 | if ${auto} ; then |
|
|
627 | tlib=$(scanelf -qF'%S#F' "${ED}"/usr/${libdir}/${lib}) |
|
|
628 | [[ -z ${tlib} ]] && die "unable to read SONAME from ${lib}" |
|
|
629 | mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die |
|
|
630 | # some SONAMEs are funky: they encode a version before the .so |
|
|
631 | if [[ ${tlib} != ${lib}* ]] ; then |
|
|
632 | mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die |
|
|
633 | fi |
|
|
634 | rm -f "${ED}"/${libdir}/${lib} |
|
|
635 | else |
|
|
636 | tlib=${lib} |
|
|
637 | fi |
312 | cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
638 | cat > "${ED}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
313 | /* GNU ld script |
639 | /* GNU ld script |
314 | Since Gentoo has critical dynamic libraries |
640 | Since Gentoo has critical dynamic libraries in /lib, and the static versions |
315 | in /lib, and the static versions in /usr/lib, |
641 | in /usr/lib, we need to have a "fake" dynamic lib in /usr/lib, otherwise we |
316 | we need to have a "fake" dynamic lib in /usr/lib, |
642 | run into linking problems. This "fake" dynamic lib is a linker script that |
317 | otherwise we run into linking problems. |
643 | redirects the linker to the real lib. And yes, this works in the cross- |
|
|
644 | compiling scenario as the sysroot-ed linker will prepend the real path. |
318 | |
645 | |
319 | See bug http://bugs.gentoo.org/4411 for more info. |
646 | See bug http://bugs.gentoo.org/4411 for more info. |
320 | */ |
647 | */ |
321 | ${output_format} |
648 | ${output_format} |
322 | GROUP ( /${libdir}/${lib} ) |
649 | GROUP ( ${EPREFIX}/${libdir}/${tlib} ) |
323 | END_LDSCRIPT |
650 | END_LDSCRIPT |
324 | fi |
651 | ;; |
|
|
652 | esac |
325 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
653 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
326 | done |
654 | done |
327 | } |
655 | } |