1 | # Copyright 1999-2004 Gentoo Foundation |
1 | # Copyright 1999-2006 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.65 2007/02/12 05:01:09 vapier Exp $ |
4 | # |
4 | # |
5 | # Author: Toolchain Ninjas <ninjas@gentoo.org> |
5 | # Author: Toolchain Ninjas <toolchain@gentoo.org> |
6 | # |
6 | # |
7 | # This eclass contains (or should) functions to get common info |
7 | # This eclass contains (or should) functions to get common info |
8 | # about the toolchain (libc/compiler/binutils/etc...) |
8 | # about the toolchain (libc/compiler/binutils/etc...) |
9 | |
9 | |
10 | inherit eutils |
10 | inherit multilib |
11 | |
|
|
12 | ECLASS=toolchain-funcs |
|
|
13 | INHERITED="$INHERITED $ECLASS" |
|
|
14 | |
11 | |
15 | DESCRIPTION="Based on the ${ECLASS} eclass" |
12 | DESCRIPTION="Based on the ${ECLASS} eclass" |
16 | |
13 | |
17 | tc-getPROG() { |
14 | tc-getPROG() { |
18 | local var="$1" |
15 | local var=$1 |
19 | local prog="$2" |
16 | local prog=$2 |
20 | local search="" |
|
|
21 | |
17 | |
22 | if [ -n "${!var}" ] ; then |
18 | if [[ -n ${!var} ]] ; then |
23 | echo "${!var}" |
19 | echo "${!var}" |
24 | return 0 |
20 | return 0 |
25 | fi |
21 | fi |
26 | |
22 | |
27 | if [ -n "${CTARGET}" ] ; then |
23 | local search= |
28 | search="$(type -p "${CTARGET}-${prog}")" |
24 | [[ -n $3 ]] && search=$(type -p "$3-${prog}") |
29 | elif [ -n "${CHOST}" ] ; then |
25 | [[ -z ${search} && -n ${CHOST} ]] && search=$(type -p "${CHOST}-${prog}") |
30 | search="$(type -p "${CHOST}-${prog}")" |
26 | [[ -n ${search} ]] && prog=${search##*/} |
31 | fi |
|
|
32 | |
27 | |
33 | if [ -n "${search}" ] ; then |
|
|
34 | prog="${search##*/}" |
|
|
35 | fi |
|
|
36 | export ${var}="${prog}" |
28 | export ${var}=${prog} |
37 | echo "${!var}" |
29 | echo "${!var}" |
38 | } |
30 | } |
39 | |
31 | |
40 | # Returns the name of the archiver |
32 | # Returns the name of the archiver |
41 | tc-getAR() { tc-getPROG AR ar; } |
33 | tc-getAR() { tc-getPROG AR ar "$@"; } |
42 | # Returns the name of the assembler |
34 | # Returns the name of the assembler |
43 | tc-getAS() { tc-getPROG AS as; } |
35 | tc-getAS() { tc-getPROG AS as "$@"; } |
44 | # Returns the name of the C compiler |
36 | # Returns the name of the C compiler |
45 | tc-getCC() { tc-getPROG CC gcc; } |
37 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
|
|
38 | # Returns the name of the C preprocessor |
|
|
39 | tc-getCPP() { tc-getPROG CPP cpp "$@"; } |
46 | # Returns the name of the C++ compiler |
40 | # Returns the name of the C++ compiler |
47 | tc-getCXX() { tc-getPROG CXX g++; } |
41 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
48 | # Returns the name of the linker |
42 | # Returns the name of the linker |
49 | tc-getLD() { tc-getPROG LD ld; } |
43 | tc-getLD() { tc-getPROG LD ld "$@"; } |
|
|
44 | # Returns the name of the strip prog |
|
|
45 | tc-getSTRIP() { tc-getPROG STRIP strip "$@"; } |
50 | # Returns the name of the symbol/object thingy |
46 | # Returns the name of the symbol/object thingy |
51 | tc-getNM() { tc-getPROG NM nm; } |
47 | tc-getNM() { tc-getPROG NM nm "$@"; } |
52 | # Returns the name of the archiver indexer |
48 | # Returns the name of the archiver indexer |
53 | tc-getRANLIB() { tc-getPROG RANLIB ranlib; } |
49 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
|
|
50 | # Returns the name of the fortran 77 compiler |
|
|
51 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
|
|
52 | # Returns the name of the fortran 90 compiler |
|
|
53 | tc-getF90() { tc-getPROG F90 gfortran "$@"; } |
54 | # Returns the name of the fortran compiler |
54 | # Returns the name of the fortran compiler |
55 | tc-getF77() { tc-getPROG F77 f77; } |
55 | tc-getFORTRAN() { tc-getPROG FORTRAN gfortran "$@"; } |
56 | # Returns the name of the java compiler |
56 | # Returns the name of the java compiler |
57 | tc-getGCJ() { tc-getPROG GCJ gcj; } |
57 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
58 | |
58 | |
59 | # Returns the name of the C compiler for build |
59 | # Returns the name of the C compiler for build |
60 | tc-getBUILD_CC() { |
60 | tc-getBUILD_CC() { |
61 | if [ -n "${CC_FOR_BUILD}" ] ; then |
61 | local v |
62 | export BUILD_CC="${CC_FOR_BUILD}" |
62 | for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do |
63 | echo "${CC_FOR_BUILD}" |
63 | if [[ -n ${!v} ]] ; then |
|
|
64 | export BUILD_CC=${!v} |
|
|
65 | echo "${!v}" |
64 | return 0 |
66 | return 0 |
|
|
67 | fi |
|
|
68 | done |
|
|
69 | |
|
|
70 | local search= |
|
|
71 | if [[ -n ${CBUILD} ]] ; then |
|
|
72 | search=$(type -p ${CBUILD}-gcc) |
|
|
73 | search=${search##*/} |
65 | fi |
74 | fi |
|
|
75 | search=${search:-gcc} |
66 | |
76 | |
67 | local search= |
|
|
68 | if [ -n "${CBUILD}" ] ; then |
|
|
69 | search="$(type -p "${CBUILD}-gcc")" |
|
|
70 | fi |
|
|
71 | |
|
|
72 | if [ -n "${search}" ] ; then |
|
|
73 | search="${search##*/}" |
|
|
74 | else |
|
|
75 | search="gcc" |
|
|
76 | fi |
|
|
77 | |
|
|
78 | export BUILD_CC="${search}" |
77 | export BUILD_CC=${search} |
79 | echo "${search}" |
78 | echo "${search}" |
80 | } |
79 | } |
81 | |
80 | |
82 | # Quick way to export a bunch of vars at once |
81 | # Quick way to export a bunch of vars at once |
83 | tc-export() { |
82 | tc-export() { |
84 | local var |
83 | local var |
85 | for var in "$@" ; do |
84 | for var in "$@" ; do |
86 | eval tc-get${var} |
85 | eval tc-get${var} > /dev/null |
87 | done |
86 | done |
88 | } |
87 | } |
89 | |
88 | |
90 | # A simple way to see if we're using a cross-compiler ... |
89 | # A simple way to see if we're using a cross-compiler ... |
91 | tc-is-cross-compiler() { |
90 | tc-is-cross-compiler() { |
92 | local ret tmpfile=$(emktemp).c |
91 | return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]]) |
93 | echo 'int main(){return 0;}' > "${tmpfile}" |
|
|
94 | $(tc-getCC) "${tmpfile}" -o "${tmpfile}".bin |
|
|
95 | "${tmpfile}".bin &>/dev/null |
|
|
96 | ret=$? |
|
|
97 | rm -f "${tmpfile}" "${tmpfile}".bin |
|
|
98 | return ${ret} |
|
|
99 | } |
92 | } |
100 | |
93 | |
|
|
94 | # See if this toolchain is a softfloat based one. |
|
|
95 | # The possible return values: |
|
|
96 | # - only: the target is always softfloat (never had fpu) |
|
|
97 | # - yes: the target should support softfloat |
|
|
98 | # - no: the target should support hardfloat |
|
|
99 | # This allows us to react differently where packages accept |
|
|
100 | # softfloat flags in the case where support is optional, but |
|
|
101 | # rejects softfloat flags where the target always lacks an fpu. |
|
|
102 | tc-is-softfloat() { |
|
|
103 | case ${CTARGET} in |
|
|
104 | h8300*) |
|
|
105 | echo "only" ;; |
|
|
106 | *) |
|
|
107 | [[ ${CTARGET//_/-} == *-softfloat-* ]] \ |
|
|
108 | && echo "yes" \ |
|
|
109 | || echo "no" |
|
|
110 | ;; |
|
|
111 | esac |
|
|
112 | } |
|
|
113 | |
|
|
114 | # Parse information from CBUILD/CHOST/CTARGET rather than |
|
|
115 | # use external variables from the profile. |
|
|
116 | tc-ninja_magic_to_arch() { |
|
|
117 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
|
|
118 | |
|
|
119 | local type=$1 |
|
|
120 | local host=$2 |
|
|
121 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
122 | |
|
|
123 | case ${host} in |
|
|
124 | alpha*) echo alpha;; |
|
|
125 | arm*) echo arm;; |
|
|
126 | bfin*) ninj blackfin bfin;; |
|
|
127 | cris*) echo cris;; |
|
|
128 | hppa*) ninj parisc hppa;; |
|
|
129 | i?86*) ninj i386 x86;; |
|
|
130 | ia64*) echo ia64;; |
|
|
131 | m68*) echo m68k;; |
|
|
132 | mips*) echo mips;; |
|
|
133 | nios2*) echo nios2;; |
|
|
134 | nios*) echo nios;; |
|
|
135 | powerpc*) |
|
|
136 | # Starting with linux-2.6.15, the 'ppc' and 'ppc64' trees |
|
|
137 | # have been unified into simply 'powerpc', but until 2.6.16, |
|
|
138 | # ppc32 is still using ARCH="ppc" as default |
|
|
139 | if [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.16) ]] && [[ ${type} == "kern" ]] ; then |
|
|
140 | echo powerpc |
|
|
141 | elif [[ $(KV_to_int ${KV}) -eq $(KV_to_int 2.6.15) ]] && [[ ${type} == "kern" ]] ; then |
|
|
142 | if [[ ${host} == powerpc64* ]] || [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
|
|
143 | echo powerpc |
|
|
144 | else |
|
|
145 | echo ppc |
|
|
146 | fi |
|
|
147 | elif [[ ${host} == powerpc64* ]] ; then |
|
|
148 | echo ppc64 |
|
|
149 | elif [[ ${PROFILE_ARCH} == "ppc64" ]] ; then |
|
|
150 | ninj ppc64 ppc |
|
|
151 | else |
|
|
152 | echo ppc |
|
|
153 | fi |
|
|
154 | ;; |
|
|
155 | s390*) echo s390;; |
|
|
156 | sh64*) ninj sh64 sh;; |
|
|
157 | sh*) echo sh;; |
|
|
158 | sparc64*) ninj sparc64 sparc;; |
|
|
159 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
|
|
160 | && ninj sparc64 sparc \ |
|
|
161 | || echo sparc |
|
|
162 | ;; |
|
|
163 | vax*) echo vax;; |
|
|
164 | x86_64*) ninj x86_64 amd64;; |
|
|
165 | *) echo ${ARCH};; |
|
|
166 | esac |
|
|
167 | } |
|
|
168 | tc-arch-kernel() { |
|
|
169 | tc-ninja_magic_to_arch kern $@ |
|
|
170 | } |
|
|
171 | tc-arch() { |
|
|
172 | tc-ninja_magic_to_arch portage $@ |
|
|
173 | } |
101 | |
174 | |
102 | # Returns the version as by `$CC -dumpversion` |
175 | # Returns the version as by `$CC -dumpversion` |
103 | gcc-fullversion() { |
176 | gcc-fullversion() { |
104 | echo "$($(tc-getCC) -dumpversion)" |
177 | $(tc-getCC "$@") -dumpversion |
105 | } |
178 | } |
106 | # Returns the version, but only the <major>.<minor> |
179 | # Returns the version, but only the <major>.<minor> |
107 | gcc-version() { |
180 | gcc-version() { |
108 | echo "$(gcc-fullversion | cut -f1,2 -d.)" |
181 | gcc-fullversion "$@" | cut -f1,2 -d. |
109 | } |
182 | } |
110 | # Returns the Major version |
183 | # Returns the Major version |
111 | gcc-major-version() { |
184 | gcc-major-version() { |
112 | echo "$(gcc-version | cut -f1 -d.)" |
185 | gcc-version "$@" | cut -f1 -d. |
113 | } |
186 | } |
114 | # Returns the Minor version |
187 | # Returns the Minor version |
115 | gcc-minor-version() { |
188 | gcc-minor-version() { |
116 | echo "$(gcc-version | cut -f2 -d.)" |
189 | gcc-version "$@" | cut -f2 -d. |
117 | } |
190 | } |
118 | # Returns the Micro version |
191 | # Returns the Micro version |
119 | gcc-micro-version() { |
192 | gcc-micro-version() { |
120 | echo "$(gcc-fullversion | cut -f3 -d.)" |
193 | gcc-fullversion "$@" | cut -f3 -d. | cut -f1 -d- |
121 | } |
194 | } |
|
|
195 | |
|
|
196 | # Returns requested gcc specs directive |
|
|
197 | # Note; later specs normally overwrite earlier ones; however if a later |
|
|
198 | # spec starts with '+' then it appends. |
|
|
199 | # gcc -dumpspecs is parsed first, followed by files listed by "gcc -v" |
|
|
200 | # as "Reading <file>", in order. |
|
|
201 | gcc-specs-directive() { |
|
|
202 | local cc=$(tc-getCC) |
|
|
203 | local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}') |
|
|
204 | ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 \ |
|
|
205 | 'BEGIN { pspec=""; spec=""; outside=1 } |
|
|
206 | $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } |
|
|
207 | outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } |
|
|
208 | spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next } |
|
|
209 | { spec=spec $0 } |
|
|
210 | END { print spec }' |
|
|
211 | return 0 |
|
|
212 | } |
|
|
213 | |
|
|
214 | # Returns true if gcc sets relro |
|
|
215 | gcc-specs-relro() { |
|
|
216 | local directive |
|
|
217 | directive=$(gcc-specs-directive link_command) |
|
|
218 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
|
|
219 | } |
|
|
220 | # Returns true if gcc sets now |
|
|
221 | gcc-specs-now() { |
|
|
222 | local directive |
|
|
223 | directive=$(gcc-specs-directive link_command) |
|
|
224 | return $([[ ${directive/\{!nonow:} != ${directive} ]]) |
|
|
225 | } |
|
|
226 | # Returns true if gcc builds PIEs |
|
|
227 | gcc-specs-pie() { |
|
|
228 | local directive |
|
|
229 | directive=$(gcc-specs-directive cc1) |
|
|
230 | return $([[ ${directive/\{!nopie:} != ${directive} ]]) |
|
|
231 | } |
|
|
232 | # Returns true if gcc builds with the stack protector |
|
|
233 | gcc-specs-ssp() { |
|
|
234 | local directive |
|
|
235 | directive=$(gcc-specs-directive cc1) |
|
|
236 | return $([[ ${directive/\{!fno-stack-protector:} != ${directive} ]]) |
|
|
237 | } |
|
|
238 | # Returns true if gcc upgrades fstack-protector to fstack-protector-all |
|
|
239 | gcc-specs-ssp-to-all() { |
|
|
240 | local directive |
|
|
241 | directive=$(gcc-specs-directive cc1) |
|
|
242 | return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]]) |
|
|
243 | } |
|
|
244 | |
|
|
245 | |
|
|
246 | # This function generate linker scripts in /usr/lib for dynamic |
|
|
247 | # libs in /lib. This is to fix linking problems when you have |
|
|
248 | # the .so in /lib, and the .a in /usr/lib. What happens is that |
|
|
249 | # in some cases when linking dynamic, the .a in /usr/lib is used |
|
|
250 | # instead of the .so in /lib due to gcc/libtool tweaking ld's |
|
|
251 | # library search path. This cause many builds to fail. |
|
|
252 | # See bug #4411 for more info. |
|
|
253 | # |
|
|
254 | # To use, simply call: |
|
|
255 | # |
|
|
256 | # gen_usr_ldscript libfoo.so |
|
|
257 | # |
|
|
258 | # Note that you should in general use the unversioned name of |
|
|
259 | # the library, as ldconfig should usually update it correctly |
|
|
260 | # to point to the latest version of the library present. |
|
|
261 | _tc_gen_usr_ldscript() { |
|
|
262 | local lib libdir=$(get_libdir) output_format="" |
|
|
263 | # Just make sure it exists |
|
|
264 | dodir /usr/${libdir} |
|
|
265 | |
|
|
266 | # OUTPUT_FORMAT gives hints to the linker as to what binary format |
|
|
267 | # is referenced ... makes multilib saner |
|
|
268 | output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p') |
|
|
269 | [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )" |
|
|
270 | |
|
|
271 | for lib in "$@" ; do |
|
|
272 | if [[ ${USERLAND} == "Darwin" ]] ; then |
|
|
273 | ewarn "Not creating fake dynamic library for $lib on Darwin;" |
|
|
274 | ewarn "making a symlink instead." |
|
|
275 | dosym "/${libdir}/${lib}" "/usr/${libdir}/${lib}" |
|
|
276 | else |
|
|
277 | cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT |
|
|
278 | /* GNU ld script |
|
|
279 | Since Gentoo has critical dynamic libraries |
|
|
280 | in /lib, and the static versions in /usr/lib, |
|
|
281 | we need to have a "fake" dynamic lib in /usr/lib, |
|
|
282 | otherwise we run into linking problems. |
|
|
283 | |
|
|
284 | See bug http://bugs.gentoo.org/4411 for more info. |
|
|
285 | */ |
|
|
286 | ${output_format} |
|
|
287 | GROUP ( /${libdir}/${lib} ) |
|
|
288 | END_LDSCRIPT |
|
|
289 | fi |
|
|
290 | fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}" |
|
|
291 | done |
|
|
292 | } |
|
|
293 | gen_usr_ldscript() { _tc_gen_usr_ldscript "$@" ; } |