1 | # Copyright 1999-2004 Gentoo Foundation |
1 | # Copyright 1999-2005 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.7 2004/10/28 15:30:09 vapier Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.42 2005/08/02 13:26:59 azarah Exp $ |
4 | # |
4 | # |
5 | # Author: Toolchain Ninjas <ninjas@gentoo.org> |
5 | # Author: Toolchain Ninjas <ninjas@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 | |
11 | |
12 | ECLASS=toolchain-funcs |
|
|
13 | INHERITED="$INHERITED $ECLASS" |
|
|
14 | |
12 | |
15 | DESCRIPTION="Based on the ${ECLASS} eclass" |
13 | DESCRIPTION="Based on the ${ECLASS} eclass" |
16 | |
14 | |
17 | tc-getPROG() { |
15 | tc-getPROG() { |
18 | local var="$1" |
16 | local var=$1 |
19 | local prog="$2" |
17 | local prog=$2 |
20 | local search="" |
|
|
21 | |
18 | |
22 | if [ -n "${!var}" ] ; then |
19 | if [[ -n ${!var} ]] ; then |
23 | echo "${!var}" |
20 | echo "${!var}" |
24 | return 0 |
21 | return 0 |
25 | fi |
22 | fi |
26 | |
23 | |
27 | # how should we handle the host/target/build ? |
24 | local search= |
28 | if [ -n "${CTARGET}" ] ; then |
25 | [[ -n $3 ]] && search=$(type -p "$3-${prog}") |
29 | search="$(type -p "${CTARGET}-${prog}")" |
26 | [[ -z ${search} && -n $(get_abi_CHOST) ]] && search=$(type -p "$(get_abi_CHOST)-${prog}") |
30 | else |
27 | [[ -z ${search} && -n ${CHOST} ]] && search=$(type -p "${CHOST}-${prog}") |
31 | if [ -n "${CHOST}" ] ; then |
28 | [[ -n ${search} ]] && prog=${search##*/} |
32 | search="$(type -p "${CHOST}-${prog}")" |
|
|
33 | fi |
|
|
34 | fi |
|
|
35 | |
29 | |
36 | if [ -n "${search}" ] ; then |
|
|
37 | prog="${search##*/}" |
|
|
38 | fi |
|
|
39 | export ${var}="${prog}" |
30 | export ${var}=${prog} |
40 | echo "${!var}" |
31 | echo "${!var}" |
41 | } |
32 | } |
42 | |
33 | |
43 | # Returns the name of the archiver |
34 | # Returns the name of the archiver |
44 | tc-getAR() { tc-getPROG AR ar; } |
35 | tc-getAR() { tc-getPROG AR ar "$@"; } |
45 | # Returns the name of the assembler |
36 | # Returns the name of the assembler |
46 | tc-getAS() { tc-getPROG AS as; } |
37 | tc-getAS() { tc-getPROG AS as "$@"; } |
47 | # Returns the name of the C compiler |
38 | # Returns the name of the C compiler |
48 | tc-getCC() { tc-getPROG CC gcc; } |
39 | tc-getCC() { tc-getPROG CC gcc "$@"; } |
49 | # Returns the name of the C++ compiler |
40 | # Returns the name of the C++ compiler |
50 | tc-getCXX() { tc-getPROG CXX g++; } |
41 | tc-getCXX() { tc-getPROG CXX g++ "$@"; } |
51 | # Returns the name of the linker |
42 | # Returns the name of the linker |
52 | tc-getLD() { tc-getPROG LD ld; } |
43 | tc-getLD() { tc-getPROG LD ld "$@"; } |
53 | # Returns the name of the symbol/object thingy |
44 | # Returns the name of the symbol/object thingy |
54 | tc-getNM() { tc-getPROG NM nm; } |
45 | tc-getNM() { tc-getPROG NM nm "$@"; } |
55 | # Returns the name of the archiver indexer |
46 | # Returns the name of the archiver indexer |
56 | tc-getRANLIB() { tc-getPROG RANLIB ranlib; } |
47 | tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; } |
57 | # Returns the name of the fortran compiler |
48 | # Returns the name of the fortran compiler |
58 | tc-getF77() { tc-getPROG F77 f77; } |
49 | tc-getF77() { tc-getPROG F77 f77 "$@"; } |
|
|
50 | # Returns the name of the java compiler |
|
|
51 | tc-getGCJ() { tc-getPROG GCJ gcj "$@"; } |
59 | |
52 | |
60 | # Returns the name of the C compiler for build |
53 | # Returns the name of the C compiler for build |
61 | tc-getBUILD_CC() { |
54 | tc-getBUILD_CC() { |
62 | if [ -n "${CC_FOR_BUILD}" ] ; then |
55 | if [[ -n ${CC_FOR_BUILD} ]] ; then |
|
|
56 | export BUILD_CC=${CC_FOR_BUILD} |
63 | echo "${CC_FOR_BUILD}" |
57 | echo "${CC_FOR_BUILD}" |
64 | return 0 |
58 | return 0 |
65 | fi |
59 | fi |
66 | |
60 | |
|
|
61 | local search= |
67 | if [ -n "${CBUILD}" ] ; then |
62 | if [[ -n ${CBUILD} ]] ; then |
68 | local cc="$(type -p "${CBUILD}-gcc")" |
63 | search=$(type -p ${CBUILD}-gcc) |
69 | if [ -n "${cc}" ] ; then |
64 | search=${search##*/} |
70 | echo "${cc}" |
65 | else |
|
|
66 | search=gcc |
71 | fi |
67 | fi |
72 | fi |
|
|
73 | |
68 | |
74 | echo "gcc" |
69 | export BUILD_CC=${search} |
|
|
70 | echo "${search}" |
75 | } |
71 | } |
76 | |
72 | |
|
|
73 | # Quick way to export a bunch of vars at once |
|
|
74 | tc-export() { |
|
|
75 | local var |
|
|
76 | for var in "$@" ; do |
|
|
77 | eval tc-get${var} > /dev/null |
|
|
78 | done |
|
|
79 | } |
|
|
80 | |
|
|
81 | # A simple way to see if we're using a cross-compiler ... |
|
|
82 | tc-is-cross-compiler() { |
|
|
83 | if [[ -n ${CBUILD} ]] ; then |
|
|
84 | return $([[ ${CBUILD} != ${CHOST} ]]) |
|
|
85 | fi |
|
|
86 | return 1 |
|
|
87 | } |
|
|
88 | |
|
|
89 | |
|
|
90 | # Parse information from CBUILD/CHOST/CTARGET rather than |
|
|
91 | # use external variables from the profile. |
|
|
92 | tc-ninja_magic_to_arch() { |
|
|
93 | ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; } |
|
|
94 | |
|
|
95 | local type=$1 |
|
|
96 | local host=$2 |
|
|
97 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
98 | |
|
|
99 | case ${host} in |
|
|
100 | alpha*) echo alpha;; |
|
|
101 | x86_64*) ninj x86_64 amd64;; |
|
|
102 | arm*) echo arm;; |
|
|
103 | hppa*) ninj parisc hppa;; |
|
|
104 | ia64*) echo ia64;; |
|
|
105 | m68*) echo m68k;; |
|
|
106 | mips*) echo mips;; |
|
|
107 | powerpc64*) echo ppc64;; |
|
|
108 | powerpc*) [[ ${PROFILE_ARCH} == "ppc64" ]] \ |
|
|
109 | && ninj ppc64 ppc \ |
|
|
110 | || echo ppc |
|
|
111 | ;; |
|
|
112 | sparc64*) ninj sparc64 sparc;; |
|
|
113 | sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \ |
|
|
114 | && ninj sparc64 sparc \ |
|
|
115 | || echo sparc |
|
|
116 | ;; |
|
|
117 | s390*) echo s390;; |
|
|
118 | sh64*) ninj sh64 sh;; |
|
|
119 | sh*) echo sh;; |
|
|
120 | i?86*) ninj i386 x86;; |
|
|
121 | *) echo ${ARCH};; |
|
|
122 | esac |
|
|
123 | } |
|
|
124 | tc-arch-kernel() { |
|
|
125 | tc-ninja_magic_to_arch kern $@ |
|
|
126 | } |
|
|
127 | tc-arch() { |
|
|
128 | tc-ninja_magic_to_arch portage $@ |
|
|
129 | } |
|
|
130 | tc-endian() { |
|
|
131 | local host=$1 |
|
|
132 | [[ -z ${host} ]] && host=${CTARGET:-${CHOST}} |
|
|
133 | host=${host%%-*} |
|
|
134 | |
|
|
135 | case ${host} in |
|
|
136 | alpha*) echo big;; |
|
|
137 | x86_64*) echo little;; |
|
|
138 | arm*b*) echo big;; |
|
|
139 | arm*) echo little;; |
|
|
140 | hppa*) echo big;; |
|
|
141 | ia64*) echo little;; |
|
|
142 | m68*) echo big;; |
|
|
143 | mips*l*) echo little;; |
|
|
144 | mips*) echo big;; |
|
|
145 | powerpc*) echo big;; |
|
|
146 | sparc*) echo big;; |
|
|
147 | s390*) echo big;; |
|
|
148 | sh*b*) echo big;; |
|
|
149 | sh*) echo little;; |
|
|
150 | i?86*) echo little;; |
|
|
151 | *) echo wtf;; |
|
|
152 | esac |
|
|
153 | } |
77 | |
154 | |
78 | # Returns the version as by `$CC -dumpversion` |
155 | # Returns the version as by `$CC -dumpversion` |
79 | gcc-fullversion() { |
156 | gcc-fullversion() { |
80 | echo "$($(tc-getCC) -dumpversion)" |
157 | echo "$($(tc-getCC) -dumpversion)" |
81 | } |
158 | } |
… | |
… | |
91 | gcc-minor-version() { |
168 | gcc-minor-version() { |
92 | echo "$(gcc-version | cut -f2 -d.)" |
169 | echo "$(gcc-version | cut -f2 -d.)" |
93 | } |
170 | } |
94 | # Returns the Micro version |
171 | # Returns the Micro version |
95 | gcc-micro-version() { |
172 | gcc-micro-version() { |
96 | echo "$(gcc-fullversion | cut -f3 -d.)" |
173 | echo "$(gcc-fullversion | cut -f3 -d. | cut -f1 -d-)" |
97 | } |
174 | } |
|
|
175 | |
|
|
176 | # Returns requested gcc specs directive |
|
|
177 | # Note; if a spec exists more than once (e.g. in more than one specs file) |
|
|
178 | # the last one read is the active definition - i.e. they do not accumulate, |
|
|
179 | # each new definition replaces any previous definition. |
|
|
180 | gcc-specs-directive() { |
|
|
181 | local specfiles=$($(tc-getCC) -v 2>&1 | grep "^Reading" | awk '{print $NF}') |
|
|
182 | [[ -z ${specfiles} ]] && return 0 |
|
|
183 | awk -v spec=$1 \ |
|
|
184 | 'BEGIN { sstr=""; outside=1 } |
|
|
185 | $1=="*"spec":" { sstr=""; outside=0; next } |
|
|
186 | outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } |
|
|
187 | { sstr=sstr $0 } |
|
|
188 | END { print sstr }' ${specfiles} |
|
|
189 | } |
|
|
190 | |
|
|
191 | # Returns true if gcc sets relro |
|
|
192 | gcc-specs-relro() { |
|
|
193 | local directive |
|
|
194 | directive=$(gcc-specs-directive link_command) |
|
|
195 | return $([[ ${directive/\{!norelro:} != ${directive} ]]) |
|
|
196 | } |
|
|
197 | # Returns true if gcc sets now |
|
|
198 | gcc-specs-now() { |
|
|
199 | local directive |
|
|
200 | directive=$(gcc-specs-directive link_command) |
|
|
201 | return $([[ ${directive/\{!nonow:} != ${directive} ]]) |
|
|
202 | } |
|
|
203 | # Returns true if gcc builds PIEs |
|
|
204 | gcc-specs-pie() { |
|
|
205 | local directive |
|
|
206 | directive=$(gcc-specs-directive cc1) |
|
|
207 | return $([[ ${directive/\{!nopie:} != ${directive} ]]) |
|
|
208 | } |
|
|
209 | # Returns true if gcc builds with the stack protector |
|
|
210 | gcc-specs-ssp() { |
|
|
211 | local directive |
|
|
212 | directive=$(gcc-specs-directive cc1) |
|
|
213 | return $([[ ${directive/\{!fno-stack-protector:} != ${directive} ]]) |
|
|
214 | } |
|
|
215 | |