1 | # Copyright 1999-2004 Gentoo Foundation |
1 | # Copyright 1999-2012 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.13 2004/12/14 05:04:09 vapier Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.118 2012/09/27 19:34:28 axs Exp $ |
4 | # |
4 | |
|
|
5 | # @ECLASS: toolchain-funcs.eclass |
|
|
6 | # @MAINTAINER: |
5 | # Author: Toolchain Ninjas <ninjas@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 | |
|
|
16 | if [[ ${___ECLASS_ONCE_TOOLCHAIN_FUNCS} != "recur -_+^+_- spank" ]] ; then |
|
|
17 | ___ECLASS_ONCE_TOOLCHAIN_FUNCS="recur -_+^+_- spank" |
|
|
18 | |
10 | inherit eutils |
19 | inherit multilib |
11 | |
20 | |
12 | ECLASS=toolchain-funcs |
21 | # tc-getPROG <VAR [search vars]> <default> [tuple] |
13 | INHERITED="$INHERITED $ECLASS" |
|
|
14 | |
|
|
15 | DESCRIPTION="Based on the ${ECLASS} eclass" |
|
|
16 | |
|
|
17 | tc-getPROG() { |
22 | _tc-getPROG() { |
18 | local var="$1" |
23 | local tuple=$1 |
|
|
24 | local v var vars=$2 |
19 | local prog="$2" |
25 | local prog=$3 |
20 | local search="" |
|
|
21 | |
26 | |
|
|
27 | var=${vars%% *} |
|
|
28 | for v in ${vars} ; do |
22 | if [ -n "${!var}" ] ; then |
29 | if [[ -n ${!v} ]] ; then |
|
|
30 | export ${var}="${!v}" |
23 | echo "${!var}" |
31 | echo "${!v}" |
24 | return 0 |
32 | return 0 |
25 | fi |
33 | fi |
|
|
34 | done |
26 | |
35 | |
27 | if [ -n "${CTARGET}" ] ; then |
36 | local search= |
28 | search="$(type -p "${CTARGET}-${prog}")" |
37 | [[ -n $4 ]] && search=$(type -p "$4-${prog}") |
29 | elif [ -n "${CHOST}" ] ; then |
38 | [[ -z ${search} && -n ${!tuple} ]] && search=$(type -p "${!tuple}-${prog}") |
30 | search="$(type -p "${CHOST}-${prog}")" |
39 | [[ -n ${search} ]] && prog=${search##*/} |
31 | fi |
|
|
32 | |
40 | |
33 | if [ -n "${search}" ] ; then |
|
|
34 | prog="${search##*/}" |
|
|
35 | fi |
|
|
36 | export ${var}="${prog}" |
41 | export ${var}=${prog} |
37 | echo "${!var}" |
42 | echo "${!var}" |
38 | } |
43 | } |
|
|
44 | tc-getBUILD_PROG() { _tc-getPROG CBUILD "BUILD_$1 $1_FOR_BUILD HOST$1" "${@:2}"; } |
|
|
45 | tc-getPROG() { _tc-getPROG CHOST "$@"; } |
39 | |
46 | |
40 | # Returns the name of the archiver |
47 | # @FUNCTION: tc-getAR |
|
|
48 | # @USAGE: [toolchain prefix] |
|
|
49 | # @RETURN: name of the archiver |
41 | tc-getAR() { tc-getPROG AR ar; } |
50 | tc-getAR() { tc-getPROG AR ar "$@"; } |
42 | # Returns the name of the assembler |
51 | # @FUNCTION: tc-getAS |
|
|
52 | # @USAGE: [toolchain prefix] |
|
|
53 | # @RETURN: name of the assembler |
43 | tc-getAS() { tc-getPROG AS as; } |
54 | tc-getAS() { tc-getPROG AS as "$@"; } |
|
|
55 | # @FUNCTION: tc-getCC |
|
|
56 | # @USAGE: [toolchain prefix] |
44 | # Returns the name of the C compiler |
57 | # @RETURN: name of the C compiler |
45 | tc-getCC() { tc-getPROG CC gcc; } |
58 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
|
|
59 | # @FUNCTION: tc-getCPP |
|
|
60 | # @USAGE: [toolchain prefix] |
|
|
61 | # @RETURN: name of the C preprocessor |
|
|
62 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
|
|
63 | # @FUNCTION: tc-getCXX |
|
|
64 | # @USAGE: [toolchain prefix] |
46 | # Returns the name of the C++ compiler |
65 | # @RETURN: name of the C++ compiler |
47 | tc-getCXX() { tc-getPROG CXX g++; } |
66 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
48 | # Returns the name of the linker |
67 | # @FUNCTION: tc-getLD |
|
|
68 | # @USAGE: [toolchain prefix] |
|
|
69 | # @RETURN: name of the linker |
49 | tc-getLD() { tc-getPROG LD ld; } |
70 | tc-getLD() { tc-getPROG LD ld "$@"; } |
|
|
71 | # @FUNCTION: tc-getSTRIP |
|
|
72 | # @USAGE: [toolchain prefix] |
|
|
73 | # @RETURN: name of the strip program |
|
|
74 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
|
|
75 | # @FUNCTION: tc-getNM |
|
|
76 | # @USAGE: [toolchain prefix] |
50 | # Returns the name of the symbol/object thingy |
77 | # @RETURN: name of the symbol/object thingy |
51 | tc-getNM() { tc-getPROG NM nm; } |
78 | tc-getNM() { tc-getPROG NM nm "$@"; } |
|
|
79 | # @FUNCTION: tc-getRANLIB |
|
|
80 | # @USAGE: [toolchain prefix] |
52 | # Returns the name of the archiver indexer |
81 | # @RETURN: name of the archiver indexer |
53 | tc-getRANLIB() { tc-getPROG RANLIB ranlib; } |
82 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
54 | # Returns the name of the fortran compiler |
83 | # @FUNCTION: tc-getOBJCOPY |
|
|
84 | # @USAGE: [toolchain prefix] |
|
|
85 | # @RETURN: name of the object copier |
|
|
86 | tc-getOBJCOPY() { tc-getPROG OBJCOPY objcopy "$@"; } |
|
|
87 | # @FUNCTION: tc-getF77 |
|
|
88 | # @USAGE: [toolchain prefix] |
|
|
89 | # @RETURN: name of the Fortran 77 compiler |
55 | tc-getF77() { tc-getPROG F77 f77; } |
90 | tc-getF77() { tc-getPROG F77 gfortran "$@"; } |
|
|
91 | # @FUNCTION: tc-getFC |
|
|
92 | # @USAGE: [toolchain prefix] |
|
|
93 | # @RETURN: name of the Fortran 90 compiler |
|
|
94 | tc-getFC() { tc-getPROG FC gfortran "$@"; } |
|
|
95 | # @FUNCTION: tc-getGCJ |
|
|
96 | # @USAGE: [toolchain prefix] |
56 | # Returns the name of the java compiler |
97 | # @RETURN: name of the java compiler |
57 | tc-getGCJ() { tc-getPROG GCJ gcj; } |
98 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
|
|
99 | # @FUNCTION: tc-getPKG_CONFIG |
|
|
100 | # @USAGE: [toolchain prefix] |
|
|
101 | # @RETURN: name of the pkg-config tool |
|
|
102 | tc-getPKG_CONFIG() { tc-getPROG PKG_CONFIG pkg-config "$@"; } |
|
|
103 | # @FUNCTION: tc-getRC |
|
|
104 | # @USAGE: [toolchain prefix] |
|
|
105 | # @RETURN: name of the Windows resource compiler |
|
|
106 | tc-getRC() { tc-getPROG RC windres "$@"; } |
|
|
107 | # @FUNCTION: tc-getDLLWRAP |
|
|
108 | # @USAGE: [toolchain prefix] |
|
|
109 | # @RETURN: name of the Windows dllwrap utility |
|
|
110 | tc-getDLLWRAP() { tc-getPROG DLLWRAP dllwrap "$@"; } |
58 | |
111 | |
59 | # Returns the name of the C compiler for build |
112 | # @FUNCTION: tc-getBUILD_AR |
60 | tc-getBUILD_CC() { |
113 | # @USAGE: [toolchain prefix] |
61 | if [ -n "${CC_FOR_BUILD}" ] ; then |
114 | # @RETURN: name of the archiver for building binaries to run on the build machine |
62 | export BUILD_CC="${CC_FOR_BUILD}" |
115 | tc-getBUILD_AR() { tc-getBUILD_PROG AR ar "$@"; } |
63 | echo "${CC_FOR_BUILD}" |
116 | # @FUNCTION: tc-getBUILD_AS |
64 | return 0 |
117 | # @USAGE: [toolchain prefix] |
65 | fi |
118 | # @RETURN: name of the assembler for building binaries to run on the build machine |
|
|
119 | tc-getBUILD_AS() { tc-getBUILD_PROG AS as "$@"; } |
|
|
120 | # @FUNCTION: tc-getBUILD_CC |
|
|
121 | # @USAGE: [toolchain prefix] |
|
|
122 | # @RETURN: name of the C compiler for building binaries to run on the build machine |
|
|
123 | tc-getBUILD_CC() { tc-getBUILD_PROG CC gcc "$@"; } |
|
|
124 | # @FUNCTION: tc-getBUILD_CPP |
|
|
125 | # @USAGE: [toolchain prefix] |
|
|
126 | # @RETURN: name of the C preprocessor for building binaries to run on the build machine |
|
|
127 | tc-getBUILD_CPP() { tc-getBUILD_PROG CPP cpp "$@"; } |
|
|
128 | # @FUNCTION: tc-getBUILD_CXX |
|
|
129 | # @USAGE: [toolchain prefix] |
|
|
130 | # @RETURN: name of the C++ compiler for building binaries to run on the build machine |
|
|
131 | tc-getBUILD_CXX() { tc-getBUILD_PROG CXX g++ "$@"; } |
|
|
132 | # @FUNCTION: tc-getBUILD_LD |
|
|
133 | # @USAGE: [toolchain prefix] |
|
|
134 | # @RETURN: name of the linker for building binaries to run on the build machine |
|
|
135 | tc-getBUILD_LD() { tc-getBUILD_PROG LD ld "$@"; } |
|
|
136 | # @FUNCTION: tc-getBUILD_STRIP |
|
|
137 | # @USAGE: [toolchain prefix] |
|
|
138 | # @RETURN: name of the strip program for building binaries to run on the build machine |
|
|
139 | tc-getBUILD_STRIP() { tc-getBUILD_PROG STRIP strip "$@"; } |
|
|
140 | # @FUNCTION: tc-getBUILD_NM |
|
|
141 | # @USAGE: [toolchain prefix] |
|
|
142 | # @RETURN: name of the symbol/object thingy for building binaries to run on the build machine |
|
|
143 | tc-getBUILD_NM() { tc-getBUILD_PROG NM nm "$@"; } |
|
|
144 | # @FUNCTION: tc-getBUILD_RANLIB |
|
|
145 | # @USAGE: [toolchain prefix] |
|
|
146 | # @RETURN: name of the archiver indexer for building binaries to run on the build machine |
|
|
147 | tc-getBUILD_RANLIB() { tc-getBUILD_PROG RANLIB ranlib "$@"; } |
|
|
148 | # @FUNCTION: tc-getBUILD_OBJCOPY |
|
|
149 | # @USAGE: [toolchain prefix] |
|
|
150 | # @RETURN: name of the object copier for building binaries to run on the build machine |
|
|
151 | tc-getBUILD_OBJCOPY() { tc-getBUILD_PROG OBJCOPY objcopy "$@"; } |
|
|
152 | # @FUNCTION: tc-getBUILD_PKG_CONFIG |
|
|
153 | # @USAGE: [toolchain prefix] |
|
|
154 | # @RETURN: name of the pkg-config tool for building binaries to run on the build machine |
|
|
155 | tc-getBUILD_PKG_CONFIG() { tc-getBUILD_PROG PKG_CONFIG pkg-config "$@"; } |
66 | |
156 | |
67 | local search= |
157 | # @FUNCTION: tc-export |
68 | if [ -n "${CBUILD}" ] ; then |
158 | # @USAGE: <list of toolchain variables> |
69 | search="$(type -p "${CBUILD}-gcc")" |
159 | # @DESCRIPTION: |
70 | fi |
|
|
71 | |
|
|
72 | if [ -n "${search}" ] ; then |
|
|
73 | search="${search##*/}" |
|
|
74 | else |
|
|
75 | search="gcc" |
|
|
76 | fi |
|
|
77 | |
|
|
78 | export BUILD_CC="${search}" |
|
|
79 | echo "${search}" |
|
|
80 | } |
|
|
81 | |
|
|
82 | # Quick way to export a bunch of vars at once |
160 | # Quick way to export a bunch of compiler vars at once. |
83 | tc-export() { |
161 | tc-export() { |
84 | local var |
162 | local var |
85 | for var in "$@" ; do |
163 | for var in "$@" ; do |
|
|
164 | [[ $(type -t tc-get${var}) != "function" ]] && die "tc-export: invalid export variable '${var}'" |
86 | eval tc-get${var} |
165 | eval tc-get${var} > /dev/null |
87 | done |
166 | done |
88 | } |
167 | } |
89 | |
168 | |
90 | # A simple way to see if we're using a cross-compiler ... |
169 | # @FUNCTION: tc-is-cross-compiler |
|
|
170 | # @RETURN: Shell true if we are using a cross-compiler, shell false otherwise |
91 | tc-is-cross-compiler() { |
171 | tc-is-cross-compiler() { |
92 | local ret tmpfile=$(emktemp).c |
172 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
93 | echo 'int main(){return 0;}' > "${tmpfile}" |
173 | } |
94 | $(tc-getCC) "${tmpfile}" -o "${tmpfile}".bin |
174 | |
95 | "${tmpfile}".bin &>/dev/null |
175 | # @FUNCTION: tc-is-softfloat |
96 | ret=$? |
176 | # @DESCRIPTION: |
97 | rm -f "${tmpfile}" "${tmpfile}".bin |
177 | # See if this toolchain is a softfloat based one. |
|
|
178 | # @CODE |
|
|
179 | # The possible return values: |
|
|
180 | # - only: the target is always softfloat (never had fpu) |
|
|
181 | # - yes: the target should support softfloat |
|
|
182 | # - softfp: (arm specific) the target should use hardfloat insns, but softfloat calling convention |
|
|
183 | # - no: the target doesn't support softfloat |
|
|
184 | # @CODE |
|
|
185 | # This allows us to react differently where packages accept |
|
|
186 | # softfloat flags in the case where support is optional, but |
|
|
187 | # rejects softfloat flags where the target always lacks an fpu. |
|
|
188 | tc-is-softfloat() { |
|
|
189 | local CTARGET=${CTARGET:-${CHOST}} |
|
|
190 | case ${CTARGET} in |
|
|
191 | bfin*|h8300*) |
|
|
192 | echo "only" ;; |
|
|
193 | *) |
|
|
194 | if [[ ${CTARGET//_/-} == *-softfloat-* ]] ; then |
|
|
195 | echo "yes" |
|
|
196 | elif [[ ${CTARGET//_/-} == *-softfp-* ]] ; then |
|
|
197 | echo "softfp" |
|
|
198 | else |
|
|
199 | echo "no" |
|
|
200 | fi |
|
|
201 | ;; |
|
|
202 | esac |
|
|
203 | } |
|
|
204 | |
|
|
205 | # @FUNCTION: tc-is-static-only |
|
|
206 | # @DESCRIPTION: |
|
|
207 | # Return shell true if the target does not support shared libs, shell false |
|
|
208 | # otherwise. |
|
|
209 | tc-is-static-only() { |
|
|
210 | local host=${CTARGET:-${CHOST}} |
|
|
211 | |
|
|
212 | # *MiNT doesn't have shared libraries, only platform so far |
|
|
213 | return $([[ ${host} == *-mint* ]]) |
|
|
214 | } |
|
|
215 | |
|
|
216 | # @FUNCTION: tc-export_build_env |
|
|
217 | # @USAGE: [compiler variables] |
|
|
218 | # @DESCRIPTION: |
|
|
219 | # Export common build related compiler settings. |
|
|
220 | tc-export_build_env() { |
|
|
221 | tc-export "$@" |
|
|
222 | : ${BUILD_CFLAGS:=-O1 -pipe} |
|
|
223 | : ${BUILD_CXXFLAGS:=-O1 -pipe} |
|
|
224 | : ${BUILD_CPPFLAGS:=} |
|
|
225 | : ${BUILD_LDFLAGS:=} |
|
|
226 | export BUILD_{C,CXX,CPP,LD}FLAGS |
|
|
227 | } |
|
|
228 | |
|
|
229 | # @FUNCTION: tc-env_build |
|
|
230 | # @USAGE: <command> [command args] |
|
|
231 | # @INTERNAL |
|
|
232 | # @DESCRIPTION: |
|
|
233 | # Setup the compile environment to the build tools and then execute the |
|
|
234 | # specified command. We use tc-getBUILD_XX here so that we work with |
|
|
235 | # all of the semi-[non-]standard env vars like $BUILD_CC which often |
|
|
236 | # the target build system does not check. |
|
|
237 | tc-env_build() { |
|
|
238 | tc-export_build_env |
|
|
239 | CFLAGS=${BUILD_CFLAGS} \ |
|
|
240 | CXXFLAGS=${BUILD_CXXFLAGS} \ |
|
|
241 | CPPFLAGS=${BUILD_CPPFLAGS} \ |
|
|
242 | LDFLAGS=${BUILD_LDFLAGS} \ |
|
|
243 | AR=$(tc-getBUILD_AR) \ |
|
|
244 | AS=$(tc-getBUILD_AS) \ |
|
|
245 | CC=$(tc-getBUILD_CC) \ |
|
|
246 | CPP=$(tc-getBUILD_CPP) \ |
|
|
247 | CXX=$(tc-getBUILD_CXX) \ |
|
|
248 | LD=$(tc-getBUILD_LD) \ |
|
|
249 | NM=$(tc-getBUILD_NM) \ |
|
|
250 | PKG_CONFIG=$(tc-getBUILD_PKG_CONFIG) \ |
|
|
251 | RANLIB=$(tc-getBUILD_RANLIB) \ |
|
|
252 | "$@" |
|
|
253 | } |
|
|
254 | |
|
|
255 | # @FUNCTION: econf_build |
|
|
256 | # @USAGE: [econf flags] |
|
|
257 | # @DESCRIPTION: |
|
|
258 | # Sometimes we need to locally build up some tools to run on CBUILD because |
|
|
259 | # the package has helper utils which are compiled+executed when compiling. |
|
|
260 | # This won't work when cross-compiling as the CHOST is set to a target which |
|
|
261 | # we cannot natively execute. |
|
|
262 | # |
|
|
263 | # For example, the python package will build up a local python binary using |
|
|
264 | # a portable build system (configure+make), but then use that binary to run |
|
|
265 | # local python scripts to build up other components of the overall python. |
|
|
266 | # We cannot rely on the python binary in $PATH as that often times will be |
|
|
267 | # a different version, or not even installed in the first place. Instead, |
|
|
268 | # we compile the code in a different directory to run on CBUILD, and then |
|
|
269 | # use that binary when compiling the main package to run on CHOST. |
|
|
270 | # |
|
|
271 | # For example, with newer EAPIs, you'd do something like: |
|
|
272 | # @CODE |
|
|
273 | # src_configure() { |
|
|
274 | # ECONF_SOURCE=${S} |
|
|
275 | # if tc-is-cross-compiler ; then |
|
|
276 | # mkdir "${WORKDIR}"/${CBUILD} |
|
|
277 | # pushd "${WORKDIR}"/${CBUILD} >/dev/null |
|
|
278 | # econf_build --disable-some-unused-stuff |
|
|
279 | # popd >/dev/null |
|
|
280 | # fi |
|
|
281 | # ... normal build paths ... |
|
|
282 | # } |
|
|
283 | # src_compile() { |
|
|
284 | # if tc-is-cross-compiler ; then |
|
|
285 | # pushd "${WORKDIR}"/${CBUILD} >/dev/null |
|
|
286 | # emake one-or-two-build-tools |
|
|
287 | # ln/mv build-tools to normal build paths in ${S}/ |
|
|
288 | # popd >/dev/null |
|
|
289 | # fi |
|
|
290 | # ... normal build paths ... |
|
|
291 | # } |
|
|
292 | # @CODE |
|
|
293 | econf_build() { |
|
|
294 | tc-env_build econf --build=${CBUILD:-${CHOST}} "$@" |
|
|
295 | } |
|
|
296 | |
|
|
297 | # @FUNCTION: tc-has-openmp |
|
|
298 | # @USAGE: [toolchain prefix] |
|
|
299 | # @DESCRIPTION: |
|
|
300 | # See if the toolchain supports OpenMP. |
|
|
301 | tc-has-openmp() { |
|
|
302 | local base="${T}/test-tc-openmp" |
|
|
303 | cat <<-EOF > "${base}.c" |
|
|
304 | #include <omp.h> |
|
|
305 | int main() { |
|
|
306 | int nthreads, tid, ret = 0; |
|
|
307 | #pragma omp parallel private(nthreads, tid) |
|
|
308 | { |
|
|
309 | tid = omp_get_thread_num(); |
|
|
310 | nthreads = omp_get_num_threads(); ret += tid + nthreads; |
|
|
311 | } |
|
|
312 | return ret; |
|
|
313 | } |
|
|
314 | EOF |
|
|
315 | $(tc-getCC "$@") -fopenmp "${base}.c" -o "${base}" >&/dev/null |
|
|
316 | local ret=$? |
|
|
317 | rm -f "${base}"* |
98 | return ${ret} |
318 | return ${ret} |
99 | } |
319 | } |
100 | |
320 | |
|
|
321 | # @FUNCTION: tc-has-tls |
|
|
322 | # @USAGE: [-s|-c|-l] [toolchain prefix] |
|
|
323 | # @DESCRIPTION: |
|
|
324 | # See if the toolchain supports thread local storage (TLS). Use -s to test the |
|
|
325 | # compiler, -c to also test the assembler, and -l to also test the C library |
|
|
326 | # (the default). |
|
|
327 | tc-has-tls() { |
|
|
328 | local base="${T}/test-tc-tls" |
|
|
329 | cat <<-EOF > "${base}.c" |
|
|
330 | int foo(int *i) { |
|
|
331 | static __thread int j = 0; |
|
|
332 | return *i ? j : *i; |
|
|
333 | } |
|
|
334 | EOF |
|
|
335 | local flags |
|
|
336 | case $1 in |
|
|
337 | -s) flags="-S";; |
|
|
338 | -c) flags="-c";; |
|
|
339 | -l) ;; |
|
|
340 | -*) die "Usage: tc-has-tls [-c|-l] [toolchain prefix]";; |
|
|
341 | esac |
|
|
342 | : ${flags:=-fPIC -shared -Wl,-z,defs} |
|
|
343 | [[ $1 == -* ]] && shift |
|
|
344 | $(tc-getCC "$@") ${flags} "${base}.c" -o "${base}" >&/dev/null |
|
|
345 | local ret=$? |
|
|
346 | rm -f "${base}"* |
|
|
347 | return ${ret} |
|
|
348 | } |
101 | |
349 | |
102 | # Returns the version as by `$CC -dumpversion` |
350 | |
|
|
351 | # Parse information from CBUILD/CHOST/CTARGET rather than |
|
|
352 | # use external variables from the profile. |
|
|
353 | tc-ninja_magic_to_arch() { |
|
|
354 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
|
|
355 | |
|
|
356 | local type=$1 |
|
|
357 | local host=$2 |
|
|
358 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
359 | |
|
|
360 | local KV=${KV:-${KV_FULL}} |
|
|
361 | [[ -z ${KV} ]] && die "toolchain-funcs.eclass: Kernel version could not be determined, please inherit kernel-2 or linux-info" |
|
|
362 | |
|
|
363 | case ${host} in |
|
|
364 | aarch64*) ninj aarch64 arm;; |
|
|
365 | alpha*) echo alpha;; |
|
|
366 | arm*) echo arm;; |
|
|
367 | avr*) ninj avr32 avr;; |
|
|
368 | bfin*) ninj blackfin bfin;; |
|
|
369 | cris*) echo cris;; |
|
|
370 | hppa*) ninj parisc hppa;; |
|
|
371 | i?86*) |
|
|
372 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
373 | # trees have been unified into 'x86'. |
|
|
374 | # FreeBSD still uses i386 |
|
|
375 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -lt $(KV_to_int 2.6.24) || ${host} == *freebsd* ]] ; then |
|
|
376 | echo i386 |
|
|
377 | else |
|
|
378 | echo x86 |
|
|
379 | fi |
|
|
380 | ;; |
|
|
381 | ia64*) echo ia64;; |
|
|
382 | m68*) echo m68k;; |
|
|
383 | mips*) echo mips;; |
|
|
384 | nios2*) echo nios2;; |
|
|
385 | nios*) echo nios;; |
|
|
386 | powerpc*) |
|
|
387 | # Starting with linux-2.6.15, the 'ppc' and 'ppc64' trees |
|
|
388 | # have been unified into simply 'powerpc', but until 2.6.16, |
|
|
389 | # ppc32 is still using ARCH="ppc" as default |
|
|
390 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.16) ]] ; then |
|
|
391 | echo powerpc |
|
|
392 | elif [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -eq $(KV_to_int 2.6.15) ]] ; then |
|
|
393 | if [[ ${host} == powerpc64* ]] || [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
|
|
394 | echo powerpc |
|
|
395 | else |
|
|
396 | echo ppc |
|
|
397 | fi |
|
|
398 | elif [[ ${host} == powerpc64* ]] ; then |
|
|
399 | echo ppc64 |
|
|
400 | elif [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
|
|
401 | ninj ppc64 ppc |
|
|
402 | else |
|
|
403 | echo ppc |
|
|
404 | fi |
|
|
405 | ;; |
|
|
406 | s390*) echo s390;; |
|
|
407 | sh64*) ninj sh64 sh;; |
|
|
408 | sh*) echo sh;; |
|
|
409 | sparc64*) ninj sparc64 sparc;; |
|
|
410 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
|
|
411 | && ninj sparc64 sparc \ |
|
|
412 | || echo sparc |
|
|
413 | ;; |
|
|
414 | vax*) echo vax;; |
|
|
415 | x86_64*freebsd*) echo amd64;; |
|
|
416 | x86_64*) |
|
|
417 | # Starting with linux-2.6.24, the 'x86_64' and 'i386' |
|
|
418 | # trees have been unified into 'x86'. |
|
|
419 | if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.24) ]] ; then |
|
|
420 | echo x86 |
|
|
421 | else |
|
|
422 | ninj x86_64 amd64 |
|
|
423 | fi |
|
|
424 | ;; |
|
|
425 | |
|
|
426 | # since our usage of tc-arch is largely concerned with |
|
|
427 | # normalizing inputs for testing ${CTARGET}, let's filter |
|
|
428 | # other cross targets (mingw and such) into the unknown. |
|
|
429 | *) echo unknown;; |
|
|
430 | esac |
|
|
431 | } |
|
|
432 | # @FUNCTION: tc-arch-kernel |
|
|
433 | # @USAGE: [toolchain prefix] |
|
|
434 | # @RETURN: name of the kernel arch according to the compiler target |
|
|
435 | tc-arch-kernel() { |
|
|
436 | tc-ninja_magic_to_arch kern "$@" |
|
|
437 | } |
|
|
438 | # @FUNCTION: tc-arch |
|
|
439 | # @USAGE: [toolchain prefix] |
|
|
440 | # @RETURN: name of the portage arch according to the compiler target |
|
|
441 | tc-arch() { |
|
|
442 | tc-ninja_magic_to_arch portage "$@" |
|
|
443 | } |
|
|
444 | |
|
|
445 | tc-endian() { |
|
|
446 | local host=$1 |
|
|
447 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
448 | host=${host%%-*} |
|
|
449 | |
|
|
450 | case ${host} in |
|
|
451 | aarch64*be) echo big;; |
|
|
452 | aarch64) echo little;; |
|
|
453 | alpha*) echo big;; |
|
|
454 | arm*b*) echo big;; |
|
|
455 | arm*) echo little;; |
|
|
456 | cris*) echo little;; |
|
|
457 | hppa*) echo big;; |
|
|
458 | i?86*) echo little;; |
|
|
459 | ia64*) echo little;; |
|
|
460 | m68*) echo big;; |
|
|
461 | mips*l*) echo little;; |
|
|
462 | mips*) echo big;; |
|
|
463 | powerpc*) echo big;; |
|
|
464 | s390*) echo big;; |
|
|
465 | sh*b*) echo big;; |
|
|
466 | sh*) echo little;; |
|
|
467 | sparc*) echo big;; |
|
|
468 | x86_64*) echo little;; |
|
|
469 | *) echo wtf;; |
|
|
470 | esac |
|
|
471 | } |
|
|
472 | |
|
|
473 | # Internal func. The first argument is the version info to expand. |
|
|
474 | # Query the preprocessor to improve compatibility across different |
|
|
475 | # compilers rather than maintaining a --version flag matrix. #335943 |
|
|
476 | _gcc_fullversion() { |
|
|
477 | local ver="$1"; shift |
|
|
478 | set -- `$(tc-getCPP "$@") -E -P - <<<"__GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__"` |
|
|
479 | eval echo "$ver" |
|
|
480 | } |
|
|
481 | |
|
|
482 | # @FUNCTION: gcc-fullversion |
|
|
483 | # @RETURN: compiler version (major.minor.micro: [3.4.6]) |
103 | gcc-fullversion() { |
484 | gcc-fullversion() { |
104 | echo "$($(tc-getCC) -dumpversion)" |
485 | _gcc_fullversion '$1.$2.$3' "$@" |
105 | } |
486 | } |
106 | # Returns the version, but only the <major>.<minor> |
487 | # @FUNCTION: gcc-version |
|
|
488 | # @RETURN: compiler version (major.minor: [3.4].6) |
107 | gcc-version() { |
489 | gcc-version() { |
108 | echo "$(gcc-fullversion | cut -f1,2 -d.)" |
490 | _gcc_fullversion '$1.$2' "$@" |
109 | } |
491 | } |
110 | # Returns the Major version |
492 | # @FUNCTION: gcc-major-version |
|
|
493 | # @RETURN: major compiler version (major: [3].4.6) |
111 | gcc-major-version() { |
494 | gcc-major-version() { |
112 | echo "$(gcc-version | cut -f1 -d.)" |
495 | _gcc_fullversion '$1' "$@" |
113 | } |
496 | } |
114 | # Returns the Minor version |
497 | # @FUNCTION: gcc-minor-version |
|
|
498 | # @RETURN: minor compiler version (minor: 3.[4].6) |
115 | gcc-minor-version() { |
499 | gcc-minor-version() { |
116 | echo "$(gcc-version | cut -f2 -d.)" |
500 | _gcc_fullversion '$2' "$@" |
117 | } |
501 | } |
118 | # Returns the Micro version |
502 | # @FUNCTION: gcc-micro-version |
|
|
503 | # @RETURN: micro compiler version (micro: 3.4.[6]) |
119 | gcc-micro-version() { |
504 | gcc-micro-version() { |
120 | echo "$(gcc-fullversion | cut -f3 -d.)" |
505 | _gcc_fullversion '$3' "$@" |
121 | } |
506 | } |
|
|
507 | |
|
|
508 | # Returns the installation directory - internal toolchain |
|
|
509 | # function for use by _gcc-specs-exists (for flag-o-matic). |
|
|
510 | _gcc-install-dir() { |
|
|
511 | echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null |\ |
|
|
512 | awk '$1=="install:" {print $2}')" |
|
|
513 | } |
|
|
514 | # Returns true if the indicated specs file exists - internal toolchain |
|
|
515 | # function for use by flag-o-matic. |
|
|
516 | _gcc-specs-exists() { |
|
|
517 | [[ -f $(_gcc-install-dir)/$1 ]] |
|
|
518 | } |
|
|
519 | |
|
|
520 | # Returns requested gcc specs directive unprocessed - for used by |
|
|
521 | # gcc-specs-directive() |
|
|
522 | # Note; later specs normally overwrite earlier ones; however if a later |
|
|
523 | # spec starts with '+' then it appends. |
|
|
524 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
|
|
525 | # as "Reading <file>", in order. Strictly speaking, if there's a |
|
|
526 | # $(gcc_install_dir)/specs, the built-in specs aren't read, however by |
|
|
527 | # the same token anything from 'gcc -dumpspecs' is overridden by |
|
|
528 | # the contents of $(gcc_install_dir)/specs so the result is the |
|
|
529 | # same either way. |
|
|
530 | _gcc-specs-directive_raw() { |
|
|
531 | local cc=$(tc-getCC) |
|
|
532 | local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}') |
|
|
533 | ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
|
|
534 | 'BEGIN { pspec=""; spec=""; outside=1 } |
|
|
535 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
|
|
536 | outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } |
|
|
537 | spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next } |
|
|
538 | { spec=spec $0 } |
|
|
539 | END { print spec }' |
|
|
540 | return 0 |
|
|
541 | } |
|
|
542 | |
|
|
543 | # Return the requested gcc specs directive, with all included |
|
|
544 | # specs expanded. |
|
|
545 | # Note, it does not check for inclusion loops, which cause it |
|
|
546 | # to never finish - but such loops are invalid for gcc and we're |
|
|
547 | # assuming gcc is operational. |
|
|
548 | gcc-specs-directive() { |
|
|
549 | local directive subdname subdirective |
|
|
550 | directive="$(_gcc-specs-directive_raw $1)" |
|
|
551 | while [[ ${directive} == *%\(*\)* ]]; do |
|
|
552 | subdname=${directive/*%\(} |
|
|
553 | subdname=${subdname/\)*} |
|
|
554 | subdirective="$(_gcc-specs-directive_raw ${subdname})" |
|
|
555 | directive="${directive//\%(${subdname})/${subdirective}}" |
|
|
556 | done |
|
|
557 | echo "${directive}" |
|
|
558 | return 0 |
|
|
559 | } |
|
|
560 | |
|
|
561 | # Returns true if gcc sets relro |
|
|
562 | gcc-specs-relro() { |
|
|
563 | local directive |
|
|
564 | directive=$(gcc-specs-directive link_command) |
|
|
565 | return $([[ "${directive/\{!norelro:}" != "${directive}" ]]) |
|
|
566 | } |
|
|
567 | # Returns true if gcc sets now |
|
|
568 | gcc-specs-now() { |
|
|
569 | local directive |
|
|
570 | directive=$(gcc-specs-directive link_command) |
|
|
571 | return $([[ "${directive/\{!nonow:}" != "${directive}" ]]) |
|
|
572 | } |
|
|
573 | # Returns true if gcc builds PIEs |
|
|
574 | gcc-specs-pie() { |
|
|
575 | local directive |
|
|
576 | directive=$(gcc-specs-directive cc1) |
|
|
577 | return $([[ "${directive/\{!nopie:}" != "${directive}" ]]) |
|
|
578 | } |
|
|
579 | # Returns true if gcc builds with the stack protector |
|
|
580 | gcc-specs-ssp() { |
|
|
581 | local directive |
|
|
582 | directive=$(gcc-specs-directive cc1) |
|
|
583 | return $([[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]]) |
|
|
584 | } |
|
|
585 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
|
|
586 | gcc-specs-ssp-to-all() { |
|
|
587 | local directive |
|
|
588 | directive=$(gcc-specs-directive cc1) |
|
|
589 | return $([[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]]) |
|
|
590 | } |
|
|
591 | # Returns true if gcc builds with fno-strict-overflow |
|
|
592 | gcc-specs-nostrict() { |
|
|
593 | local directive |
|
|
594 | directive=$(gcc-specs-directive cc1) |
|
|
595 | return $([[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]]) |
|
|
596 | } |
|
|
597 | |
|
|
598 | |
|
|
599 | # @FUNCTION: gen_usr_ldscript |
|
|
600 | # @USAGE: [-a] <list of libs to create linker scripts for> |
|
|
601 | # @DESCRIPTION: |
|
|
602 | # This function generate linker scripts in /usr/lib for dynamic |
|
|
603 | # libs in /lib. This is to fix linking problems when you have |
|
|
604 | # the .so in /lib, and the .a in /usr/lib. What happens is that |
|
|
605 | # in some cases when linking dynamic, the .a in /usr/lib is used |
|
|
606 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
|
|
607 | # library search path. This causes many builds to fail. |
|
|
608 | # See bug #4411 for more info. |
|
|
609 | # |
|
|
610 | # Note that you should in general use the unversioned name of |
|
|
611 | # the library (libfoo.so), as ldconfig should usually update it |
|
|
612 | # correctly to point to the latest version of the library present. |
|
|
613 | gen_usr_ldscript() { |
|
|
614 | local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname) |
|
|
615 | [[ -z ${ED+set} ]] && local ED=${D%/}${EPREFIX}/ |
|
|
616 | |
|
|
617 | tc-is-static-only && return |
|
|
618 | |
|
|
619 | # Eventually we'd like to get rid of this func completely #417451 |
|
|
620 | case ${CTARGET:-${CHOST}} in |
|
|
621 | *-darwin*) ;; |
|
|
622 | *linux*|*-freebsd*|*-openbsd*|*-netbsd*) |
|
|
623 | use prefix && return 0 ;; |
|
|
624 | *) return 0 ;; |
|
|
625 | esac |
|
|
626 | |
|
|
627 | # Just make sure it exists |
|
|
628 | dodir /usr/${libdir} |
|
|
629 | |
|
|
630 | if [[ $1 == "-a" ]] ; then |
|
|
631 | auto=true |
|
|
632 | shift |
|
|
633 | dodir /${libdir} |
|
|
634 | fi |
|
|
635 | |
|
|
636 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
|
|
637 | # is referenced ... makes multilib saner |
|
|
638 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
|
|
639 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
|
|
640 | |
|
|
641 | for lib in "$@" ; do |
|
|
642 | local tlib |
|
|
643 | if ${auto} ; then |
|
|
644 | lib="lib${lib}${suffix}" |
|
|
645 | else |
|
|
646 | # Ensure /lib/${lib} exists to avoid dangling scripts/symlinks. |
|
|
647 | # This especially is for AIX where $(get_libname) can return ".a", |
|
|
648 | # so /lib/${lib} might be moved to /usr/lib/${lib} (by accident). |
|
|
649 | [[ -r ${ED}/${libdir}/${lib} ]] || continue |
|
|
650 | #TODO: better die here? |
|
|
651 | fi |
|
|
652 | |
|
|
653 | case ${CTARGET:-${CHOST}} in |
|
|
654 | *-darwin*) |
|
|
655 | if ${auto} ; then |
|
|
656 | tlib=$(scanmacho -qF'%S#F' "${ED}"/usr/${libdir}/${lib}) |
|
|
657 | else |
|
|
658 | tlib=$(scanmacho -qF'%S#F' "${ED}"/${libdir}/${lib}) |
|
|
659 | fi |
|
|
660 | [[ -z ${tlib} ]] && die "unable to read install_name from ${lib}" |
|
|
661 | tlib=${tlib##*/} |
|
|
662 | |
|
|
663 | if ${auto} ; then |
|
|
664 | mv "${ED}"/usr/${libdir}/${lib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die |
|
|
665 | # some install_names are funky: they encode a version |
|
|
666 | if [[ ${tlib} != ${lib%${suffix}}.*${suffix#.} ]] ; then |
|
|
667 | mv "${ED}"/usr/${libdir}/${tlib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die |
|
|
668 | fi |
|
|
669 | rm -f "${ED}"/${libdir}/${lib} |
|
|
670 | fi |
|
|
671 | |
|
|
672 | # Mach-O files have an id, which is like a soname, it tells how |
|
|
673 | # another object linking against this lib should reference it. |
|
|
674 | # Since we moved the lib from usr/lib into lib this reference is |
|
|
675 | # wrong. Hence, we update it here. We don't configure with |
|
|
676 | # libdir=/lib because that messes up libtool files. |
|
|
677 | # Make sure we don't lose the specific version, so just modify the |
|
|
678 | # existing install_name |
|
|
679 | if [[ ! -w "${ED}/${libdir}/${tlib}" ]] ; then |
|
|
680 | chmod u+w "${ED}${libdir}/${tlib}" # needed to write to it |
|
|
681 | local nowrite=yes |
|
|
682 | fi |
|
|
683 | install_name_tool \ |
|
|
684 | -id "${EPREFIX}"/${libdir}/${tlib} \ |
|
|
685 | "${ED}"/${libdir}/${tlib} || die "install_name_tool failed" |
|
|
686 | [[ -n ${nowrite} ]] && chmod u-w "${ED}${libdir}/${tlib}" |
|
|
687 | # Now as we don't use GNU binutils and our linker doesn't |
|
|
688 | # understand linker scripts, just create a symlink. |
|
|
689 | pushd "${ED}/usr/${libdir}" > /dev/null |
|
|
690 | ln -snf "../../${libdir}/${tlib}" "${lib}" |
|
|
691 | popd > /dev/null |
|
|
692 | ;; |
|
|
693 | *) |
|
|
694 | if ${auto} ; then |
|
|
695 | tlib=$(scanelf -qF'%S#F' "${ED}"/usr/${libdir}/${lib}) |
|
|
696 | [[ -z ${tlib} ]] && die "unable to read SONAME from ${lib}" |
|
|
697 | mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die |
|
|
698 | # some SONAMEs are funky: they encode a version before the .so |
|
|
699 | if [[ ${tlib} != ${lib}* ]] ; then |
|
|
700 | mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die |
|
|
701 | fi |
|
|
702 | rm -f "${ED}"/${libdir}/${lib} |
|
|
703 | else |
|
|
704 | tlib=${lib} |
|
|
705 | fi |
|
|
706 | cat > "${ED}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
|
|
707 | /* GNU ld script |
|
|
708 | Since Gentoo has critical dynamic libraries in /lib, and the static versions |
|
|
709 | in /usr/lib, we need to have a "fake" dynamic lib in /usr/lib, otherwise we |
|
|
710 | run into linking problems. This "fake" dynamic lib is a linker script that |
|
|
711 | redirects the linker to the real lib. And yes, this works in the cross- |
|
|
712 | compiling scenario as the sysroot-ed linker will prepend the real path. |
|
|
713 | |
|
|
714 | See bug http://bugs.gentoo.org/4411 for more info. |
|
|
715 | */ |
|
|
716 | ${output_format} |
|
|
717 | GROUP ( ${EPREFIX}/${libdir}/${tlib} ) |
|
|
718 | END_LDSCRIPT |
|
|
719 | ;; |
|
|
720 | esac |
|
|
721 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
|
|
722 | done |
|
|
723 | } |
|
|
724 | |
|
|
725 | fi |