/[gentoo-x86]/eclass/toolchain-funcs.eclass

Diff of /eclass/toolchain-funcs.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.64		Revision 1.84
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.84 2009/01/08 11:06:10 gengor 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-getF77
		76	# @USAGE: [toolchain prefix]
50	# Returns the name of the fortran 77 compiler	77	# @RETURN: name of the Fortran 77 compiler
51	tc-getF77() { tc-getPROG F77 f77 "$@"; }	78	tc-getF77() { tc-getPROG F77 f77 "$@"; }
		79	# @FUNCTION: tc-getFC
		80	# @USAGE: [toolchain prefix]
52	# Returns the name of the fortran 90 compiler	81	# @RETURN: name of the Fortran 90 compiler
53	tc-getF90() { tc-getPROG F90 gfortran "$@"; }	82	tc-getFC() { tc-getPROG FC gfortran "$@"; }
54	# Returns the name of the fortran compiler	83	# @FUNCTION: tc-getGCJ
55	tc-getFORTRAN() { tc-getPROG FORTRAN gfortran "$@"; }	84	# @USAGE: [toolchain prefix]
56	# Returns the name of the java compiler	85	# @RETURN: name of the java compiler
57	tc-getGCJ() { tc-getPROG GCJ gcj "$@"; }	86	tc-getGCJ() { tc-getPROG GCJ gcj "$@"; }
58		87
59	# Returns the name of the C compiler for build	88	# @FUNCTION: tc-getBUILD_CC
		89	# @USAGE: [toolchain prefix]
		90	# @RETURN: name of the C compiler for building binaries to run on the build machine
60	tc-getBUILD_CC() {	91	tc-getBUILD_CC() {
61	local v	92	local v
62	for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do	93	for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do
63	if [[ -n ${!v} ]] ; then	94	if [[ -n ${!v} ]] ; then
64	export BUILD_CC=${!v}	95	export BUILD_CC=${!v}
…		…
76		107
77	export BUILD_CC=${search}	108	export BUILD_CC=${search}
78	echo "${search}"	109	echo "${search}"
79	}	110	}
80		111
		112	# @FUNCTION: tc-export
		113	# @USAGE: <list of toolchain variables>
		114	# @DESCRIPTION:
81	# Quick way to export a bunch of vars at once	115	# Quick way to export a bunch of compiler vars at once.
82	tc-export() {	116	tc-export() {
83	local var	117	local var
84	for var in "$@" ; do	118	for var in "$@" ; do
		119	[[ $(type -t tc-get${var}) != "function" ]] && die "tc-export: invalid export variable '${var}'"
85	eval tc-get${var} > /dev/null	120	eval tc-get${var} > /dev/null
86	done	121	done
87	}	122	}
88		123
89	# A simple way to see if we're using a cross-compiler ...	124	# @FUNCTION: tc-is-cross-compiler
		125	# @RETURN: Shell true if we are using a cross-compiler, shell false otherwise
90	tc-is-cross-compiler() {	126	tc-is-cross-compiler() {
91	return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]])	127	return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]])
92	}	128	}
93		129
		130	# @FUNCTION: tc-is-softfloat
		131	# @DESCRIPTION:
		132	# See if this toolchain is a softfloat based one.
		133	# @CODE
		134	# The possible return values:
		135	# - only: the target is always softfloat (never had fpu)
		136	# - yes: the target should support softfloat
		137	# - no: the target should support hardfloat
		138	# @CODE
		139	# This allows us to react differently where packages accept
		140	# softfloat flags in the case where support is optional, but
		141	# rejects softfloat flags where the target always lacks an fpu.
		142	tc-is-softfloat() {
		143	case ${CTARGET} in
		144	bfin\|h8300)
		145	echo "only" ;;
		146	*)
		147	[[ ${CTARGET//_/-} == -softfloat- ]] \
		148	&& echo "yes" \
		149	\|\| echo "no"
		150	;;
		151	esac
		152	}
94		153
95	# Parse information from CBUILD/CHOST/CTARGET rather than	154	# Parse information from CBUILD/CHOST/CTARGET rather than
96	# use external variables from the profile.	155	# use external variables from the profile.
97	tc-ninja_magic_to_arch() {	156	tc-ninja_magic_to_arch() {
98	ninj() { [[ ${type} == "kern" ]] && echo $1 \|\| echo $2 ; }	157	ninj() { [[ ${type} == "kern" ]] && echo $1 \|\| echo $2 ; }
…		…
102	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}}	161	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}}
103		162
104	case ${host} in	163	case ${host} in
105	alpha*) echo alpha;;	164	alpha*) echo alpha;;
106	arm*) echo arm;;	165	arm*) echo arm;;
		166	avr*) ninj avr32 avr;;
107	bfin*) ninj blackfin bfin;;	167	bfin*) ninj blackfin bfin;;
108	cris*) echo cris;;	168	cris*) echo cris;;
109	hppa*) ninj parisc hppa;;	169	hppa*) ninj parisc hppa;;
110	i?86*) ninj i386 x86;;	170	i?86*)
		171	# Starting with linux-2.6.24, the 'x86_64' and 'i386'
		172	# trees have been unified into 'x86'.
		173	# FreeBSD still uses i386
		174	if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -lt $(KV_to_int 2.6.24) \|\| ${host} == freebsd ]] ; then
		175	echo i386
		176	else
		177	echo x86
		178	fi
		179	;;
111	ia64*) echo ia64;;	180	ia64*) echo ia64;;
112	m68*) echo m68k;;	181	m68*) echo m68k;;
113	mips*) echo mips;;	182	mips*) echo mips;;
114	nios2*) echo nios2;;	183	nios2*) echo nios2;;
115	nios*) echo nios;;	184	nios*) echo nios;;
…		…
140	sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \	209	sparc*) [[ ${PROFILE_ARCH} == "sparc64" ]] \
141	&& ninj sparc64 sparc \	210	&& ninj sparc64 sparc \
142	\|\| echo sparc	211	\|\| echo sparc
143	;;	212	;;
144	vax*) echo vax;;	213	vax*) echo vax;;
145	x86_64*) ninj x86_64 amd64;;	214	x86_64*)
146	*) echo ${ARCH};;	215	# Starting with linux-2.6.24, the 'x86_64' and 'i386'
		216	# trees have been unified into 'x86'.
		217	if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.24) ]] ; then
		218	echo x86
		219	else
		220	ninj x86_64 amd64
		221	fi
		222	;;
		223
		224	# since our usage of tc-arch is largely concerned with
		225	# normalizing inputs for testing ${CTARGET}, let's filter
		226	# other cross targets (mingw and such) into the unknown.
		227	*) echo unknown;;
147	esac	228	esac
148	}	229	}
		230	# @FUNCTION: tc-arch-kernel
		231	# @USAGE: [toolchain prefix]
		232	# @RETURN: name of the kernel arch according to the compiler target
149	tc-arch-kernel() {	233	tc-arch-kernel() {
150	tc-ninja_magic_to_arch kern $@	234	tc-ninja_magic_to_arch kern "$@"
151	}	235	}
		236	# @FUNCTION: tc-arch
		237	# @USAGE: [toolchain prefix]
		238	# @RETURN: name of the portage arch according to the compiler target
152	tc-arch() {	239	tc-arch() {
153	tc-ninja_magic_to_arch portage $@	240	tc-ninja_magic_to_arch portage "$@"
154	}	241	}
155		242
156	# Returns the version as by `$CC -dumpversion`	243	tc-endian() {
		244	local host=$1
		245	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}}
		246	host=${host%%-*}
		247
		248	case ${host} in
		249	alpha*) echo big;;
		250	armb) echo big;;
		251	arm*) echo little;;
		252	cris*) echo little;;
		253	hppa*) echo big;;
		254	i?86*) echo little;;
		255	ia64*) echo little;;
		256	m68*) echo big;;
		257	mipsl) echo little;;
		258	mips*) echo big;;
		259	powerpc*) echo big;;
		260	s390*) echo big;;
		261	shb) echo big;;
		262	sh*) echo little;;
		263	sparc*) echo big;;
		264	x86_64*) echo little;;
		265	*) echo wtf;;
		266	esac
		267	}
		268
		269	# @FUNCTION: gcc-fullversion
		270	# @RETURN: compiler version (major.minor.micro: [3.4.6])
157	gcc-fullversion() {	271	gcc-fullversion() {
158	$(tc-getCC "$@") -dumpversion	272	$(tc-getCC "$@") -dumpversion
159	}	273	}
160	# Returns the version, but only the <major>.<minor>	274	# @FUNCTION: gcc-version
		275	# @RETURN: compiler version (major.minor: [3.4].6)
161	gcc-version() {	276	gcc-version() {
162	gcc-fullversion "$@" \| cut -f1,2 -d.	277	gcc-fullversion "$@" \| cut -f1,2 -d.
163	}	278	}
164	# Returns the Major version	279	# @FUNCTION: gcc-major-version
		280	# @RETURN: major compiler version (major: [3].4.6)
165	gcc-major-version() {	281	gcc-major-version() {
166	gcc-version "$@" \| cut -f1 -d.	282	gcc-version "$@" \| cut -f1 -d.
167	}	283	}
168	# Returns the Minor version	284	# @FUNCTION: gcc-minor-version
		285	# @RETURN: minor compiler version (minor: 3.[4].6)
169	gcc-minor-version() {	286	gcc-minor-version() {
170	gcc-version "$@" \| cut -f2 -d.	287	gcc-version "$@" \| cut -f2 -d.
171	}	288	}
172	# Returns the Micro version	289	# @FUNCTION: gcc-micro-version
		290	# @RETURN: micro compiler version (micro: 3.4.[6])
173	gcc-micro-version() {	291	gcc-micro-version() {
174	gcc-fullversion "$@" \| cut -f3 -d. \| cut -f1 -d-	292	gcc-fullversion "$@" \| cut -f3 -d. \| cut -f1 -d-
175	}	293	}
176		294
		295	# Returns the installation directory - internal toolchain
		296	# function for use by _gcc-specs-exists (for flag-o-matic).
		297	_gcc-install-dir() {
		298	echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null \|\
		299	awk '$1=="install:" {print $2}')"
		300	}
		301	# Returns true if the indicated specs file exists - internal toolchain
		302	# function for use by flag-o-matic.
		303	_gcc-specs-exists() {
		304	[[ -f $(_gcc-install-dir)/$1 ]]
		305	}
		306
177	# Returns requested gcc specs directive	307	# Returns requested gcc specs directive unprocessed - for used by
		308	# gcc-specs-directive()
178	# Note; later specs normally overwrite earlier ones; however if a later	309	# Note; later specs normally overwrite earlier ones; however if a later
179	# spec starts with '+' then it appends.	310	# spec starts with '+' then it appends.
180	# gcc -dumpspecs is parsed first, followed by files listed by "gcc -v"	311	# gcc -dumpspecs is parsed first, followed by files listed by "gcc -v"
181	# as "Reading <file>", in order.	312	# as "Reading <file>", in order. Strictly speaking, if there's a
		313	# $(gcc_install_dir)/specs, the built-in specs aren't read, however by
		314	# the same token anything from 'gcc -dumpspecs' is overridden by
		315	# the contents of $(gcc_install_dir)/specs so the result is the
		316	# same either way.
182	gcc-specs-directive() {	317	_gcc-specs-directive_raw() {
183	local cc=$(tc-getCC)	318	local cc=$(tc-getCC)
184	local specfiles=$(LC_ALL=C ${cc} -v 2>&1 \| awk '$1=="Reading" {print $NF}')	319	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 \	320	${cc} -dumpspecs 2> /dev/null \| cat - ${specfiles} \| awk -v directive=$1 \
186	'BEGIN { pspec=""; spec=""; outside=1 }	321	'BEGIN { pspec=""; spec=""; outside=1 }
187	$1=="*"directive":" { pspec=spec; spec=""; outside=0; next }	322	$1=="*"directive":" { pspec=spec; spec=""; outside=0; next }
…		…
190	{ spec=spec $0 }	325	{ spec=spec $0 }
191	END { print spec }'	326	END { print spec }'
192	return 0	327	return 0
193	}	328	}
194		329
		330	# Return the requested gcc specs directive, with all included
		331	# specs expanded.
		332	# Note, it does not check for inclusion loops, which cause it
		333	# to never finish - but such loops are invalid for gcc and we're
		334	# assuming gcc is operational.
		335	gcc-specs-directive() {
		336	local directive subdname subdirective
		337	directive="$(_gcc-specs-directive_raw $1)"
		338	while [[ ${directive} == %$$* ]]; do
		339	subdname=${directive/*%\(}
		340	subdname=${subdname/\)*}
		341	subdirective="$(_gcc-specs-directive_raw ${subdname})"
		342	directive="${directive//\%(${subdname})/${subdirective}}"
		343	done
		344	echo "${directive}"
		345	return 0
		346	}
		347
195	# Returns true if gcc sets relro	348	# Returns true if gcc sets relro
196	gcc-specs-relro() {	349	gcc-specs-relro() {
197	local directive	350	local directive
198	directive=$(gcc-specs-directive link_command)	351	directive=$(gcc-specs-directive link_command)
199	return $([[ ${directive/\{!norelro:} != ${directive} ]])	352	return $([[ "${directive/\{!norelro:}" != "${directive}" ]])
200	}	353	}
201	# Returns true if gcc sets now	354	# Returns true if gcc sets now
202	gcc-specs-now() {	355	gcc-specs-now() {
203	local directive	356	local directive
204	directive=$(gcc-specs-directive link_command)	357	directive=$(gcc-specs-directive link_command)
205	return $([[ ${directive/\{!nonow:} != ${directive} ]])	358	return $([[ "${directive/\{!nonow:}" != "${directive}" ]])
206	}	359	}
207	# Returns true if gcc builds PIEs	360	# Returns true if gcc builds PIEs
208	gcc-specs-pie() {	361	gcc-specs-pie() {
209	local directive	362	local directive
210	directive=$(gcc-specs-directive cc1)	363	directive=$(gcc-specs-directive cc1)
211	return $([[ ${directive/\{!nopie:} != ${directive} ]])	364	return $([[ "${directive/\{!nopie:}" != "${directive}" ]])
212	}	365	}
213	# Returns true if gcc builds with the stack protector	366	# Returns true if gcc builds with the stack protector
214	gcc-specs-ssp() {	367	gcc-specs-ssp() {
215	local directive	368	local directive
216	directive=$(gcc-specs-directive cc1)	369	directive=$(gcc-specs-directive cc1)
217	return $([[ ${directive/\{!fno-stack-protector:} != ${directive} ]])	370	return $([[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]])
218	}	371	}
219	# Returns true if gcc upgrades fstack-protector to fstack-protector-all	372	# Returns true if gcc upgrades fstack-protector to fstack-protector-all
220	gcc-specs-ssp-to-all() {	373	gcc-specs-ssp-to-all() {
221	local directive	374	local directive
222	directive=$(gcc-specs-directive cc1)	375	directive=$(gcc-specs-directive cc1)
223	return $([[ ${directive/\{!fno-stack-protector-all:} != ${directive} ]])	376	return $([[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]])
224	}	377	}
		378	# Returns true if gcc builds with fno-strict-overflow
		379	gcc-specs-nostrict() {
		380	local directive
		381	directive=$(gcc-specs-directive cc1)
		382	return $([[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]])
		383	}
225		384
226		385
		386	# @FUNCTION: gen_usr_ldscript
		387	# @USAGE: <list of libs to create linker scripts for>
		388	# @DESCRIPTION:
227	# This function generate linker scripts in /usr/lib for dynamic	389	# This function generate linker scripts in /usr/lib for dynamic
228	# libs in /lib. This is to fix linking problems when you have	390	# 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	391	# 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	392	# 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	393	# instead of the .so in /lib due to gcc/libtool tweaking ld's
232	# library search path. This cause many builds to fail.	394	# library search path. This causes many builds to fail.
233	# See bug #4411 for more info.	395	# See bug #4411 for more info.
234	#	396	#
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	397	# Note that you should in general use the unversioned name of
240	# the library, as ldconfig should usually update it correctly	398	# the library (libfoo.so), as ldconfig should usually update it
241	# to point to the latest version of the library present.	399	# correctly to point to the latest version of the library present.
242	_tc_gen_usr_ldscript() {	400	gen_usr_ldscript() {
243	local lib libdir=$(get_libdir) output_format=""	401	local lib libdir=$(get_libdir) output_format=""
244	# Just make sure it exists	402	# Just make sure it exists
245	dodir /usr/${libdir}	403	dodir /usr/${libdir}
246		404
247	# OUTPUT_FORMAT gives hints to the linker as to what binary format	405	# OUTPUT_FORMAT gives hints to the linker as to what binary format
…		…
269	END_LDSCRIPT	427	END_LDSCRIPT
270	fi	428	fi
271	fperms a+x "/usr/${libdir}/${lib}" \|\| die "could not change perms on ${lib}"	429	fperms a+x "/usr/${libdir}/${lib}" \|\| die "could not change perms on ${lib}"
272	done	430	done
273	}	431	}
274	gen_usr_ldscript() { _tc_gen_usr_ldscript "$@" ; }

 Legend:



Removed from v.1.64
 


changed lines


 
Added in v.1.84
 Legend:



Removed from v.1.64
 


changed lines


 
Added in v.1.84
-Removed from v.1.64
+Added in v.1.84

	ViewVC Help
Powered by ViewVC 1.1.20