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

Diff of /eclass/toolchain-funcs.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.67
 


changed lines


 
Added in v.1.77
 Legend:



Removed from v.1.67
 


changed lines


 
Added in v.1.77
-Removed from v.1.67
+Added in v.1.77

	ViewVC Help
Powered by ViewVC 1.1.20