/[gentoo-x86]/eclass/flag-o-matic.eclass
Gentoo

Diff of /eclass/flag-o-matic.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.92 Revision 1.96
1# Copyright 1999-2005 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/flag-o-matic.eclass,v 1.92 2005/08/01 10:50:55 kevquinn Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/flag-o-matic.eclass,v 1.96 2005/12/08 12:16:12 azarah Exp $
4 4
5 5
6# need access to emktemp() 6# need access to emktemp()
7inherit eutils toolchain-funcs multilib 7inherit eutils toolchain-funcs multilib
8 8
57# -fno-stack-protector to {C,CXX,LD}FLAGS 57# -fno-stack-protector to {C,CXX,LD}FLAGS
58# when a package is filtering -fstack-protector, -fstack-protector-all 58# when a package is filtering -fstack-protector, -fstack-protector-all
59# notice: modern automatic specs files will also suppress -fstack-protector-all 59# notice: modern automatic specs files will also suppress -fstack-protector-all
60# when only -fno-stack-protector is given 60# when only -fno-stack-protector is given
61# 61#
62#### bindnow-flags ####
63# Returns the flags to enable "now" binding in the current selected linker.
62# 64#
63################ DEPRECATED functions ################ 65################ DEPRECATED functions ################
64# The following are still present to avoid breaking existing 66# The following are still present to avoid breaking existing
65# code more than necessary; however they are deprecated. Please 67# code more than necessary; however they are deprecated. Please
66# use gcc-specs-* from toolchain-funcs.eclass instead, if you 68# use gcc-specs-* from toolchain-funcs.eclass instead, if you
147 149
148 return 0 150 return 0
149} 151}
150 152
151filter-lfs-flags() { 153filter-lfs-flags() {
154 [[ -n $@ ]] && die "filter-lfs-flags takes no arguments"
152 filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE 155 filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
153} 156}
154 157
155append-lfs-flags() { 158append-lfs-flags() {
159 [[ -n $@ ]] && die "append-lfs-flags takes no arguments"
156 append-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE 160 append-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
157} 161}
158 162
159append-flags() { 163append-flags() {
160 [[ -z $* ]] && return 0 164 [[ -z $* ]] && return 0
164 -n "`is-flag -fno-stack-protector-all`" ] && fstack-flags 168 -n "`is-flag -fno-stack-protector-all`" ] && fstack-flags
165 return 0 169 return 0
166} 170}
167 171
168replace-flags() { 172replace-flags() {
173 [[ $# != 2 ]] \
174 && echo && eerror "Usage: replace-flags <old flag> <new flag>" \
175 && die "replace-flags takes 2 arguments, not $#"
176
169 local f fset 177 local f fset
170 declare -a new_CFLAGS new_CXXFLAGS 178 declare -a new_CFLAGS new_CXXFLAGS
171 179
172 for fset in CFLAGS CXXFLAGS; do 180 for fset in CFLAGS CXXFLAGS; do
173 # Looping over the flags instead of using a global 181 # Looping over the flags instead of using a global
285 export CFLAGS="${NEW_CFLAGS}" 293 export CFLAGS="${NEW_CFLAGS}"
286 export CXXFLAGS="${NEW_CXXFLAGS}" 294 export CXXFLAGS="${NEW_CXXFLAGS}"
287 return 0 295 return 0
288} 296}
289 297
298test-flag-PROG() {
299 local comp=$1
300 local flags="$2"
301
302 [[ -z ${comp} || -z ${flags} ]] && \
303 return 1
304
305 local PROG=$(tc-get${comp})
306 ${PROG} ${flags} -S -o /dev/null -xc /dev/null \
307 > /dev/null 2>&1
308}
309
310# Returns true if C compiler support given flag
311test-flag-CC() { test-flag-PROG "CC" "$1"; }
312
313# Returns true if C++ compiler support given flag
314test-flag-CXX() { test-flag-PROG "CXX" "$1"; }
315
316test-flags() {
317 local x
318
319 for x in "$@" ; do
320 test-flag-CC "${x}" || return 1
321 done
322
323 echo "$@"
324
325 return 0
326}
327
328# Depriciated, use test-flags()
290test_flag() { 329test_flag() {
291 if $(tc-getCC) -S -xc "$@" -o "$(emktemp)" /dev/null &>/dev/null; then 330 ewarn "test_flag: deprecated, please use test-flags()!" >/dev/stderr
292 printf "%s\n" "$*" 331
293 return 0 332 test-flags "$@"
294 fi
295 return 1
296} 333}
297 334
298test_version_info() { 335test_version_info() {
299 if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then 336 if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
300 return 0 337 return 0
302 return 1 339 return 1
303 fi 340 fi
304} 341}
305 342
306strip-unsupported-flags() { 343strip-unsupported-flags() {
307 local NEW_CFLAGS NEW_CXXFLAGS 344 local x NEW_CFLAGS NEW_CXXFLAGS
308 345
309 for x in ${CFLAGS} ; do 346 for x in ${CFLAGS} ; do
310 NEW_CFLAGS="${NEW_CFLAGS} `test_flag ${x}`" 347 NEW_CFLAGS="${NEW_CFLAGS} $(test-flags ${x})"
311 done 348 done
312 for x in ${CXXFLAGS} ; do 349 for x in ${CXXFLAGS} ; do
313 NEW_CXXFLAGS="${NEW_CXXFLAGS} `test_flag ${x}`" 350 NEW_CXXFLAGS="${NEW_CXXFLAGS} $(test-flags ${x})"
314 done 351 done
315 352
316 export CFLAGS="${NEW_CFLAGS}" 353 export CFLAGS=${NEW_CFLAGS}
317 export CXXFLAGS="${NEW_CXXFLAGS}" 354 export CXXFLAGS=${NEW_CXXFLAGS}
318} 355}
319 356
320get-flag() { 357get-flag() {
321 local f findflag="$1" 358 local f findflag="$1"
322 359
334 return 1 371 return 1
335} 372}
336 373
337# DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs 374# DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs
338has_hardened() { 375has_hardened() {
376 ewarn "has_hardened: deprecated, please use gcc-specs-{relro,now}()!" \
377 >/dev/stderr
378
339 test_version_info Hardened && return 0 379 test_version_info Hardened && return 0
340 # the specs file wont exist unless gcc has GCC_SPECS support 380 # The specs file wont exist unless gcc has GCC_SPECS support
341 [ -f "${GCC_SPECS}" -a "${GCC_SPECS}" != "${GCC_SPECS/hardened/}" ] && \ 381 [[ -f ${GCC_SPECS} && ${GCC_SPECS} != ${GCC_SPECS/hardened/} ]]
342 return 0
343 return 1
344} 382}
345 383
346# DEPRECATED - use gcc-specs-pie from toolchain-funcs 384# DEPRECATED - use gcc-specs-pie from toolchain-funcs
347# indicate whether PIC is set 385# indicate whether PIC is set
348has_pic() { 386has_pic() {
349 [ "${CFLAGS/-fPIC}" != "${CFLAGS}" ] && return 0 387 ewarn "has_pic: deprecated, please use gcc-specs-pie()!" >/dev/stderr
350 [ "${CFLAGS/-fpic}" != "${CFLAGS}" ] && return 0 388
389 [[ ${CFLAGS/-fPIC} != ${CFLAGS} || \
390 ${CFLAGS/-fpic} != ${CFLAGS} || \
351 [ "$(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__)" ] && return 0 391 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__) ]]
352 return 1
353} 392}
354 393
355# DEPRECATED - use gcc-specs-pie from toolchain-funcs 394# DEPRECATED - use gcc-specs-pie from toolchain-funcs
356# indicate whether PIE is set 395# indicate whether PIE is set
357has_pie() { 396has_pie() {
358 [ "${CFLAGS/-fPIE}" != "${CFLAGS}" ] && return 0 397 ewarn "has_pie: deprecated, please use gcc-specs-pie()!" >/dev/stderr
359 [ "${CFLAGS/-fpie}" != "${CFLAGS}" ] && return 0 398
399 [[ ${CFLAGS/-fPIE} != ${CFLAGS} || \
400 ${CFLAGS/-fpie} != ${CFLAGS} || \
401 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIE__) || \
360 [ "$(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIE__)" ] && return 0 402 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__) ]]
361 # test PIC while waiting for specs to be updated to generate __PIE__ 403 # test PIC while waiting for specs to be updated to generate __PIE__
362 [ "$(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__)" ] && return 0
363 return 1
364} 404}
365 405
366# DEPRECATED - use gcc-specs-ssp from toolchain-funcs 406# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
367# indicate whether code for SSP is being generated for all functions 407# indicate whether code for SSP is being generated for all functions
368has_ssp_all() { 408has_ssp_all() {
409 ewarn "has_ssp_all: deprecated, please use gcc-specs-ssp()!" >/dev/stderr
410
369 # note; this matches only -fstack-protector-all 411 # note; this matches only -fstack-protector-all
370 [ "${CFLAGS/-fstack-protector-all}" != "${CFLAGS}" ] && return 0 412 [[ ${CFLAGS/-fstack-protector-all} != ${CFLAGS} || \
371 [ "$(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP_ALL__)" ] && return 0 413 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP_ALL__) ]] || \
372 gcc-specs-ssp && return 0 414 gcc-specs-ssp
373 return 1
374} 415}
375 416
376# DEPRECATED - use gcc-specs-ssp from toolchain-funcs 417# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
377# indicate whether code for SSP is being generated 418# indicate whether code for SSP is being generated
378has_ssp() { 419has_ssp() {
420 ewarn "has_ssp: deprecated, please use gcc-specs-ssp()!" >/dev/stderr
421
379 # note; this matches both -fstack-protector and -fstack-protector-all 422 # note; this matches both -fstack-protector and -fstack-protector-all
380 [ "${CFLAGS/-fstack-protector}" != "${CFLAGS}" ] && return 0 423 [[ ${CFLAGS/-fstack-protector} != ${CFLAGS} || \
381 [ "$(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP__)" ] && return 0 424 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP__) ]] || \
382 gcc-specs-ssp && return 0 425 gcc-specs-ssp
383 return 1
384} 426}
385 427
386has_m64() { 428has_m64() {
387 # this doesnt test if the flag is accepted, it tests if the flag 429 # this doesnt test if the flag is accepted, it tests if the flag
388 # actually -WORKS-. non-multilib gcc will take both -m32 and -m64! 430 # actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
389 # please dont replace this function with test_flag in some future 431 # please dont replace this function with test_flag in some future
390 # clean-up! 432 # clean-up!
433
391 local temp="$(emktemp)" 434 local temp="$(emktemp)"
392 echo "int main() { return(0); }" > ${temp}.c 435 echo "int main() { return(0); }" > "${temp}".c
393 MY_CC=$(tc-getCC) 436 MY_CC=$(tc-getCC)
394 ${MY_CC/ .*/} -m64 -o "$(emktemp)" ${temp}.c > /dev/null 2>&1 437 ${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
395 local ret=$? 438 local ret=$?
396 rm -f ${temp}.c 439 rm -f "${temp}".c
397 [ "$ret" != "1" ] && return 0 440 [[ ${ret} != 1 ]] && return 0
398 return 1 441 return 1
399} 442}
400 443
401has_m32() { 444has_m32() {
402 # this doesnt test if the flag is accepted, it tests if the flag 445 # this doesnt test if the flag is accepted, it tests if the flag
404 # please dont replace this function with test_flag in some future 447 # please dont replace this function with test_flag in some future
405 # clean-up! 448 # clean-up!
406 449
407 [ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0 450 [ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0
408 451
409 local temp="$(emktemp)" 452 local temp=$(emktemp)
410 echo "int main() { return(0); }" > ${temp}.c 453 echo "int main() { return(0); }" > "${temp}".c
411 MY_CC=$(tc-getCC) 454 MY_CC=$(tc-getCC)
412 ${MY_CC/ .*/} -m32 -o "$(emktemp)" ${temp}.c > /dev/null 2>&1 455 ${MY_CC/ .*/} -m32 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
413 local ret=$? 456 local ret=$?
414 rm -f ${temp}.c 457 rm -f "${temp}".c
415 [ "$ret" != "1" ] && return 0 458 [[ ${ret} != 1 ]] && return 0
416 return 1 459 return 1
417} 460}
418 461
419replace-sparc64-flags() { 462replace-sparc64-flags() {
420 local SPARC64_CPUS="ultrasparc v9" 463 local SPARC64_CPUS="ultrasparc v9"
490 533
491 replace-cpu-flags ev6{7,8} ev6 534 replace-cpu-flags ev6{7,8} ev6
492 535
493 export CFLAGS CXXFLAGS 536 export CFLAGS CXXFLAGS
494} 537}
538
539# Gets the flags needed for "NOW" binding
540bindnow-flags() {
541 case $($(tc-getLD) -v 2>&1 </dev/null) in
542 *GNU* | *'with BFD'*) # GNU ld
543 echo "-Wl,-z,now" ;;
544 *Apple*) # Darwin ld
545 echo "-bind_at_load" ;;
546 *)
547 # Some linkers just recognize -V instead of -v
548 case $($(tc-getLD) -V 2>&1 </dev/null) in
549 *Solaris*) # Solaris accept almost the same GNU options
550 echo "-Wl,-z,now" ;;
551 esac
552 ;;
553 esac
554}

Legend:
Removed from v.1.92  
changed lines
  Added in v.1.96

  ViewVC Help
Powered by ViewVC 1.1.20