gentoo-x86/eclass/flag-o-matic.eclass

# Copyright 1999-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/flag-o-matic.eclass,v 1.103 2006/01/10 01:14:30 vapier Exp $


# need access to emktemp()
inherit eutils toolchain-funcs multilib

#
#### filter-flags <flags> ####
# Remove particular flags from C[XX]FLAGS
# Matches only complete flags
#
#### append-flags <flags> ####
# Add extra flags to your current C[XX]FLAGS
#
#### replace-flags <orig.flag> <new.flag> ###
# Replace a flag by another one
#
#### replace-cpu-flags <old.cpus> <new.cpu> ###
# Replace march/mcpu flags that specify <old.cpus>
# with flags that specify <new.cpu>
#
#### is-flag <flag> ####
# Returns "true" if flag is set in C[XX]FLAGS
# Matches only complete a flag
#
#### strip-flags ####
# Strip C[XX]FLAGS of everything except known
# good options.
#
#### strip-unsupported-flags ####
# Strip C[XX]FLAGS of any flags not supported by
# installed version of gcc
#
#### get-flag <flag> ####
# Find and echo the value for a particular flag
#
#### replace-sparc64-flags ####
# Sets mcpu to v8 and uses the original value
# as mtune if none specified.
#
#### filter-mfpmath <math types> ####
# Remove specified math types from the fpmath specification
# If the user has -mfpmath=sse,386, running `filter-mfpmath sse`
# will leave the user with -mfpmath=386
#
#### append-ldflags ####
# Add extra flags to your current LDFLAGS
#
#### filter-ldflags <flags> ####
# Remove particular flags from LDFLAGS
# Matches only complete flags
#
#### fstack-flags ####
# hooked function for hardened gcc that appends
# -fno-stack-protector to {C,CXX,LD}FLAGS
# when a package is filtering -fstack-protector, -fstack-protector-all
# notice: modern automatic specs files will also suppress -fstack-protector-all
# when only -fno-stack-protector is given
#
#### bindnow-flags ####
# Returns the flags to enable "now" binding in the current selected linker.
#
################ DEPRECATED functions ################
# The following are still present to avoid breaking existing
# code more than necessary; however they are deprecated. Please
# use gcc-specs-* from toolchain-funcs.eclass instead, if you
# need to know which hardened techs are active in the compiler.
# See bug #100974
#
#### has_hardened ####
# Returns true if the compiler has 'Hardened' in its version string,
# (note; switched-spec vanilla compilers satisfy this condition) or
# the specs file name contains 'hardened'.
#
#### has_pie ####
# Returns true if the compiler by default or with current CFLAGS
# builds position-independent code.
#
#### has_pic ####
# Returns true if the compiler by default or with current CFLAGS
# builds position-independent code.
#
#### has_ssp_all ####
# Returns true if the compiler by default or with current CFLAGS
# generates stack smash protections for all functions
#
#### has_ssp ####
# Returns true if the compiler by default or with current CFLAGS
# generates stack smash protections for most vulnerable functions
#

# C[XX]FLAGS that we allow in strip-flags
setup-allowed-flags() {
        if [[ -z ${ALLOWED_FLAGS} ]] ; then
                export ALLOWED_FLAGS="-pipe"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -O -O0 -O1 -O2 -mcpu -march -mtune"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fstack-protector -fstack-protector-all"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fbounds-checking -fno-bounds-checking"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-pie -fno-unit-at-a-time"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -g -g0 -g1 -g2 -g3 -ggdb -ggdb0 -ggdb1 -ggdb2 -ggdb3"
        fi
        # allow a bunch of flags that negate features / control ABI
        ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-stack-protector -fno-stack-protector-all"
        ALLOWED_FLAGS="${ALLOWED_FLAGS} -mregparm -mno-app-regs -mapp-regs \
                -mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow \
                -mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 \
                -msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
                -mieee -mieee-with-inexact \
                -mtls-direct-seg-refs -mno-tls-direct-seg-refs \
                -mflat -mno-flat -mno-faster-structs -mfaster-structs \
                -m32 -m64 -mabi -mlittle-endian -mbig-endian -EL -EB -fPIC \
                -mlive-g0 -mcmodel -mstack-bias -mno-stack-bias"

        # C[XX]FLAGS that we are think is ok, but needs testing
        # NOTE:  currently -Os have issues with gcc3 and K6* arch's
        export UNSTABLE_FLAGS="-Os -O3 -freorder-blocks -fprefetch-loop-arrays"
        return 0
}

filter-flags() {
        local x f fset
        declare -a new_CFLAGS new_CXXFLAGS

        for x in "$@" ; do
                case "${x}" in
                        -fPIC|-fpic|-fPIE|-fpie|-pie)
                                append-flags `test_flag -fno-pie`;;
                        -fstack-protector|-fstack-protector-all)
                                fstack-flags;;
                esac
        done

        for fset in CFLAGS CXXFLAGS; do
                # Looping over the flags instead of using a global
                # substitution ensures that we're working with flag atoms.
                # Otherwise globs like -O* have the potential to wipe out the
                # list of flags.
                for f in ${!fset}; do
                        for x in "$@"; do
                                # Note this should work with globs like -O*
                                [[ ${f} == ${x} ]] && continue 2
                        done
                        eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
                done
                eval export ${fset}=\${new_${fset}\[*]}
        done

        return 0
}

filter-lfs-flags() {
        [[ -n $@ ]] && die "filter-lfs-flags takes no arguments"
        filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
}

append-lfs-flags() {
        [[ -n $@ ]] && die "append-lfs-flags takes no arguments"
        append-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
}

append-flags() {
        [[ -z $* ]] && return 0
        export CFLAGS="${CFLAGS} $*"
        export CXXFLAGS="${CXXFLAGS} $*"
        [ -n "`is-flag -fno-stack-protector`" -o \
                -n "`is-flag -fno-stack-protector-all`" ] && fstack-flags
        return 0
}

replace-flags() {
        [[ $# != 2 ]] \
                && echo && eerror "Usage: replace-flags <old flag> <new flag>" \
                && die "replace-flags takes 2 arguments, not $#"

        local f fset
        declare -a new_CFLAGS new_CXXFLAGS

        for fset in CFLAGS CXXFLAGS; do
                # Looping over the flags instead of using a global
                # substitution ensures that we're working with flag atoms.
                # Otherwise globs like -O* have the potential to wipe out the
                # list of flags.
                for f in ${!fset}; do
                        # Note this should work with globs like -O*
                        [[ ${f} == ${1} ]] && f=${2}
                        eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
                done
                eval export ${fset}=\${new_${fset}\[*]}
        done

        return 0
}

replace-cpu-flags() {
        local newcpu="$#" ; newcpu="${!newcpu}"
        while [ $# -gt 1 ] ; do
                # quote to make sure that no globbing is done (particularly on
                # ${oldcpu} prior to calling replace-flags
                replace-flags "-march=${1}" "-march=${newcpu}"
                replace-flags "-mcpu=${1}" "-mcpu=${newcpu}"
                replace-flags "-mtune=${1}" "-mtune=${newcpu}"
                shift
        done
        return 0
}

is-flag() {
        local x

        for x in ${CFLAGS} ${CXXFLAGS} ; do
                # Note this should work with globs like -mcpu=ultrasparc*
                if [[ ${x} == ${1} ]]; then
                        echo true
                        return 0
                fi
        done
        return 1
}

filter-mfpmath() {
        local orig_mfpmath new_math prune_math

        # save the original -mfpmath flag
        orig_mfpmath="`get-flag -mfpmath`"
        # get the value of the current -mfpmath flag
        new_math=" `get-flag mfpmath | tr , ' '` "
        # figure out which math values are to be removed
        prune_math=""
        for prune_math in "$@" ; do
                new_math="${new_math/ ${prune_math} / }"
        done
        new_math="`echo ${new_math:1:${#new_math}-2} | tr ' ' ,`"

        if [ -z "${new_math}" ] ; then
                # if we're removing all user specified math values are
                # slated for removal, then we just filter the flag
                filter-flags ${orig_mfpmath}
        else
                # if we only want to filter some of the user specified
                # math values, then we replace the current flag
                replace-flags ${orig_mfpmath} -mfpmath=${new_math}
        fi
        return 0
}

strip-flags() {
        local x y flag NEW_CFLAGS NEW_CXXFLAGS

        setup-allowed-flags

        local NEW_CFLAGS=""
        local NEW_CXXFLAGS=""

        # Allow unstable C[XX]FLAGS if we are using unstable profile ...
        if has ~$(tc-arch) ${ACCEPT_KEYWORDS} ; then
                ALLOWED_FLAGS="${ALLOWED_FLAGS} ${UNSTABLE_FLAGS}"
        fi

        set -f  # disable pathname expansion

        for x in ${CFLAGS}; do
                for y in ${ALLOWED_FLAGS}; do
                        flag=${x%%=*}
                        if [ "${flag%%${y}}" = "" ] ; then
                                NEW_CFLAGS="${NEW_CFLAGS} ${x}"
                                break
                        fi
                done
        done

        for x in ${CXXFLAGS}; do
                for y in ${ALLOWED_FLAGS}; do
                        flag=${x%%=*}
                        if [ "${flag%%${y}}" = "" ] ; then
                                NEW_CXXFLAGS="${NEW_CXXFLAGS} ${x}"
                                break
                        fi
                done
        done

        # In case we filtered out all optimization flags fallback to -O2
        if [ "${CFLAGS/-O}" != "${CFLAGS}" -a "${NEW_CFLAGS/-O}" = "${NEW_CFLAGS}" ]; then
                NEW_CFLAGS="${NEW_CFLAGS} -O2"
        fi
        if [ "${CXXFLAGS/-O}" != "${CXXFLAGS}" -a "${NEW_CXXFLAGS/-O}" = "${NEW_CXXFLAGS}" ]; then
                NEW_CXXFLAGS="${NEW_CXXFLAGS} -O2"
        fi

        set +f  # re-enable pathname expansion

        export CFLAGS="${NEW_CFLAGS}"
        export CXXFLAGS="${NEW_CXXFLAGS}"
        return 0
}

test-flag-PROG() {
        local comp=$1
        local flags="$2"

        [[ -z ${comp} || -z ${flags} ]] && \
                return 1

        local PROG=$(tc-get${comp})
        ${PROG} ${flags} -S -o /dev/null -xc /dev/null \
                > /dev/null 2>&1
}

# Returns true if C compiler support given flag
test-flag-CC() { test-flag-PROG "CC" "$1"; }

# Returns true if C++ compiler support given flag
test-flag-CXX() { test-flag-PROG "CXX" "$1"; }

test-flags-PROG() {
        local comp=$1
        local flags
        local x

        shift

        [[ -z ${comp} ]] && \
                return 1

        for x in "$@" ; do
                test-flag-${comp} "${x}" && flags="${flags} ${x}"
        done

        echo "${flags}"

        # Just bail if we dont have any flags
        [[ -n ${flags} ]]
}

# Returns (echo's) the given flags supported by the C compiler
test-flags-CC() { test-flags-PROG "CC" "$@"; }

# Returns (echo's) the given flags supported by the C++ compiler
test-flags-CXX() { test-flags-PROG "CXX" "$@"; }

# Short-hand that should hopefully work for both C and C++ compiler, but
# its really only present due to the append-flags() abomination.
test-flags() { test-flags-CC "$@"; }

# Deprecated, use test-flags()
test_flag() {
        ewarn "test_flag: deprecated, please use test-flags()!" >&2

        test-flags-CC "$@"
}

test_version_info() {
        if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
                return 0
        else
                return 1
        fi
}

strip-unsupported-flags() {
        local x NEW_CFLAGS NEW_CXXFLAGS

        for x in ${CFLAGS} ; do
                NEW_CFLAGS="${NEW_CFLAGS} $(test-flags ${x})"
        done
        for x in ${CXXFLAGS} ; do
                NEW_CXXFLAGS="${NEW_CXXFLAGS} $(test-flags ${x})"
        done

        export CFLAGS=${NEW_CFLAGS}
        export CXXFLAGS=${NEW_CXXFLAGS}
}

get-flag() {
        local f findflag="$1"

        # this code looks a little flaky but seems to work for
        # everything we want ...
        # for example, if CFLAGS="-march=i686":
        # `get-flag -march` == "-march=i686"
        # `get-flag march` == "i686"
        for f in ${CFLAGS} ${CXXFLAGS} ; do
                if [ "${f/${findflag}}" != "${f}" ] ; then
                        printf "%s\n" "${f/-${findflag}=}"
                        return 0
                fi
        done
        return 1
}

# DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs
has_hardened() {
        ewarn "has_hardened: deprecated, please use gcc-specs-{relro,now}()!" >&2

        test_version_info Hardened && return 0
        # The specs file wont exist unless gcc has GCC_SPECS support
        [[ -f ${GCC_SPECS} && ${GCC_SPECS} != ${GCC_SPECS/hardened/} ]]
}

# DEPRECATED - use gcc-specs-pie from toolchain-funcs
# indicate whether PIC is set
has_pic() {
        ewarn "has_pic: deprecated, please use gcc-specs-pie()!" >&2

        [[ ${CFLAGS/-fPIC} != ${CFLAGS} || \
           ${CFLAGS/-fpic} != ${CFLAGS} || \
           -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__) ]]
}

# DEPRECATED - use gcc-specs-pie from toolchain-funcs
# indicate whether PIE is set
has_pie() {
        ewarn "has_pie: deprecated, please use gcc-specs-pie()!" >&2

        [[ ${CFLAGS/-fPIE} != ${CFLAGS} || \
           ${CFLAGS/-fpie} != ${CFLAGS} || \
           -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIE__) || \
           -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __PIC__) ]]
        # test PIC while waiting for specs to be updated to generate __PIE__
}

# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
# indicate whether code for SSP is being generated for all functions
has_ssp_all() {
        ewarn "has_ssp_all: deprecated, please use gcc-specs-ssp()!" >&2

        # note; this matches only -fstack-protector-all
        [[ ${CFLAGS/-fstack-protector-all} != ${CFLAGS} || \
           -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP_ALL__) ]] || \
        gcc-specs-ssp
}

# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
# indicate whether code for SSP is being generated
has_ssp() {
        ewarn "has_ssp: deprecated, please use gcc-specs-ssp()!" >&2

        # note; this matches both -fstack-protector and -fstack-protector-all
        [[ ${CFLAGS/-fstack-protector} != ${CFLAGS} || \
           -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP__) ]] || \
        gcc-specs-ssp
}

has_m64() {
        # this doesnt test if the flag is accepted, it tests if the flag
        # actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
        # please dont replace this function with test_flag in some future
        # clean-up!

        local temp="$(emktemp)"
        echo "int main() { return(0); }" > "${temp}".c
        MY_CC=$(tc-getCC)
        ${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
        local ret=$?
        rm -f "${temp}".c
        [[ ${ret} != 1 ]] && return 0
        return 1
}

has_m32() {
        # this doesnt test if the flag is accepted, it tests if the flag
        # actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
        # please dont replace this function with test_flag in some future
        # clean-up!

        [ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0

        local temp=$(emktemp)
        echo "int main() { return(0); }" > "${temp}".c
        MY_CC=$(tc-getCC)
        ${MY_CC/ .*/} -m32 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
        local ret=$?
        rm -f "${temp}".c
        [[ ${ret} != 1 ]] && return 0
        return 1
}

replace-sparc64-flags() {
        local SPARC64_CPUS="ultrasparc3 ultrasparc v9"

        if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
                for x in ${SPARC64_CPUS}; do
                        CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}"
                done
        else
                for x in ${SPARC64_CPUS}; do
                        CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
                done
        fi

        if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
                for x in ${SPARC64_CPUS}; do
                        CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}"
                done
        else
                for x in ${SPARC64_CPUS}; do
                        CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
                done
        fi

        export CFLAGS CXXFLAGS
}

append-ldflags() {
        export LDFLAGS="${LDFLAGS} $*"
        return 0
}

filter-ldflags() {
        local x

        # we do this fancy spacing stuff so as to not filter
        # out part of a flag ... we want flag atoms ! :D
        LDFLAGS=" ${LDFLAGS} "
        for x in "$@" ; do
                LDFLAGS=${LDFLAGS// ${x} / }
        done
        [[ -z ${LDFLAGS// } ]] \
                && LDFLAGS="" \
                || LDFLAGS=${LDFLAGS:1:${#LDFLAGS}-2}
        export LDFLAGS
        return 0
}

# Turn C style ldflags (-Wl,-foo) into straight ldflags
raw-ldflags() {
        local x input="$@"
        [[ -z ${input} ]] && input=${LDFLAGS}
        set --
        for x in ${input} ; do
                x=${x#-Wl,}
                set -- "$@" ${x//,/ }
        done
        echo "$@"
}

fstack-flags() {
        if gcc-specs-ssp; then
                [ -z "`is-flag -fno-stack-protector`" ] &&
                        export CFLAGS="${CFLAGS} `test_flag -fno-stack-protector`"
        fi
        return 0
}

# This is thanks to great work from Paul de Vrieze <gentoo-user@devrieze.net>,
# bug #9016.  Also thanks to Jukka Salmi <salmi@gmx.net> (bug #13907) for more
# fixes.
#
# Export CFLAGS and CXXFLAGS that are compadible with gcc-2.95.3
gcc2-flags() {
        if [[ $(tc-arch) == "x86" || $(tc-arch) == "amd64" ]] ; then
                CFLAGS=${CFLAGS//-mtune=/-mcpu=}
                CXXFLAGS=${CXXFLAGS//-mtune=/-mcpu=}
        fi

        replace-cpu-flags k6-{2,3} k6
        replace-cpu-flags athlon{,-{tbird,4,xp,mp}} i686

        replace-cpu-flags pentium-mmx i586
        replace-cpu-flags pentium{2,3,4} i686

        replace-cpu-flags ev6{7,8} ev6

        export CFLAGS CXXFLAGS
}

# Gets the flags needed for "NOW" binding
bindnow-flags() {
        case $($(tc-getLD) -v 2>&1 </dev/null) in
        *GNU* | *'with BFD'*) # GNU ld
                echo "-Wl,-z,now" ;;
        *Apple*) # Darwin ld
                echo "-bind_at_load" ;;
        *)
                # Some linkers just recognize -V instead of -v
                case $($(tc-getLD) -V 2>&1 </dev/null) in
                        *Solaris*) # Solaris accept almost the same GNU options
                                echo "-Wl,-z,now" ;;
                esac
                ;;
        esac
}
1	vapier	1.84	# Copyright 1999-2005 Gentoo Foundation
2	verwilst	1.1	# Distributed under the terms of the GNU General Public License v2
3	kevquinn	1.104	# $Header: /var/cvsroot/gentoo-x86/eclass/flag-o-matic.eclass,v 1.103 2006/01/10 01:14:30 vapier Exp $
4	azarah	1.8
5	vapier	1.63
6	vapier	1.72	# need access to emktemp()
7	eradicator	1.80	inherit eutils toolchain-funcs multilib
8	vapier	1.72
9	verwilst	1.2	#
10	vapier	1.18	#### filter-flags <flags> ####
11	verwilst	1.3	# Remove particular flags from C[XX]FLAGS
12	vapier	1.18	# Matches only complete flags
13	verwilst	1.2	#
14	vapier	1.18	#### append-flags <flags> ####
15	verwilst	1.3	# Add extra flags to your current C[XX]FLAGS
16			#
17	verwilst	1.4	#### replace-flags <orig.flag> <new.flag> ###
18	verwilst	1.3	# Replace a flag by another one
19			#
20	vapier	1.70	#### replace-cpu-flags <old.cpus> <new.cpu> ###
21	vapier	1.37	# Replace march/mcpu flags that specify <old.cpus>
22			# with flags that specify <new.cpu>
23			#
24	danarmak	1.7	#### is-flag <flag> ####
25			# Returns "true" if flag is set in C[XX]FLAGS
26	vapier	1.18	# Matches only complete a flag
27	danarmak	1.7	#
28	azarah	1.8	#### strip-flags ####
29			# Strip C[XX]FLAGS of everything except known
30			# good options.
31			#
32	puggy	1.29	#### strip-unsupported-flags ####
33			# Strip C[XX]FLAGS of any flags not supported by
34			# installed version of gcc
35			#
36	vapier	1.10	#### get-flag <flag> ####
37			# Find and echo the value for a particular flag
38			#
39	joker	1.16	#### replace-sparc64-flags ####
40			# Sets mcpu to v8 and uses the original value
41			# as mtune if none specified.
42			#
43	vapier	1.26	#### filter-mfpmath <math types> ####
44			# Remove specified math types from the fpmath specification
45			# If the user has -mfpmath=sse,386, running `filter-mfpmath sse`
46			# will leave the user with -mfpmath=386
47	solar	1.27	#
48			#### append-ldflags ####
49			# Add extra flags to your current LDFLAGS
50			#
51	solar	1.41	#### filter-ldflags <flags> ####
52			# Remove particular flags from LDFLAGS
53			# Matches only complete flags
54			#
55	solar	1.27	#### fstack-flags ####
56	pappy	1.50	# hooked function for hardened gcc that appends
57			# -fno-stack-protector to {C,CXX,LD}FLAGS
58			# when a package is filtering -fstack-protector, -fstack-protector-all
59			# notice: modern automatic specs files will also suppress -fstack-protector-all
60			# when only -fno-stack-protector is given
61	solar	1.27	#
62	flameeyes	1.94	#### bindnow-flags ####
63			# Returns the flags to enable "now" binding in the current selected linker.
64	kevquinn	1.92	#
65			################ DEPRECATED functions ################
66			# The following are still present to avoid breaking existing
67			# code more than necessary; however they are deprecated. Please
68			# use gcc-specs-* from toolchain-funcs.eclass instead, if you
69			# need to know which hardened techs are active in the compiler.
70			# See bug #100974
71			#
72			#### has_hardened ####
73			# Returns true if the compiler has 'Hardened' in its version string,
74			# (note; switched-spec vanilla compilers satisfy this condition) or
75			# the specs file name contains 'hardened'.
76			#
77			#### has_pie ####
78			# Returns true if the compiler by default or with current CFLAGS
79			# builds position-independent code.
80			#
81	solar	1.86	#### has_pic ####
82			# Returns true if the compiler by default or with current CFLAGS
83			# builds position-independent code.
84			#
85			#### has_ssp_all ####
86			# Returns true if the compiler by default or with current CFLAGS
87			# generates stack smash protections for all functions
88			#
89			#### has_ssp ####
90			# Returns true if the compiler by default or with current CFLAGS
91			# generates stack smash protections for most vulnerable functions
92			#
93	verwilst	1.3
94	azarah	1.17	# C[XX]FLAGS that we allow in strip-flags
95	vapier	1.36	setup-allowed-flags() {
96	vapier	1.84	if [[ -z ${ALLOWED_FLAGS} ]] ; then
97	vapier	1.76	export ALLOWED_FLAGS="-pipe"
98			export ALLOWED_FLAGS="${ALLOWED_FLAGS} -O -O0 -O1 -O2 -mcpu -march -mtune"
99	vapier	1.87	export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fstack-protector -fstack-protector-all"
100			export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fbounds-checking -fno-bounds-checking"
101	vapier	1.76	export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-pie -fno-unit-at-a-time"
102			export ALLOWED_FLAGS="${ALLOWED_FLAGS} -g -g0 -g1 -g2 -g3 -ggdb -ggdb0 -ggdb1 -ggdb2 -ggdb3"
103	vapier	1.44	fi
104	vapier	1.65	# allow a bunch of flags that negate features / control ABI
105			ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-stack-protector -fno-stack-protector-all"
106	vapier	1.87	ALLOWED_FLAGS="${ALLOWED_FLAGS} -mregparm -mno-app-regs -mapp-regs \
107			-mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow \
108			-mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 \
109			-msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
110	agriffis	1.90	-mieee -mieee-with-inexact \
111	vapier	1.91	-mtls-direct-seg-refs -mno-tls-direct-seg-refs \
112	vapier	1.87	-mflat -mno-flat -mno-faster-structs -mfaster-structs \
113			-m32 -m64 -mabi -mlittle-endian -mbig-endian -EL -EB -fPIC \
114			-mlive-g0 -mcmodel -mstack-bias -mno-stack-bias"
115	vapier	1.36
116			# C[XX]FLAGS that we are think is ok, but needs testing
117			# NOTE: currently -Os have issues with gcc3 and K6* arch's
118			export UNSTABLE_FLAGS="-Os -O3 -freorder-blocks -fprefetch-loop-arrays"
119			return 0
120	aliz	1.24	}
121	verwilst	1.13
122	vapier	1.18	filter-flags() {
123	mr_bones_	1.83	local x f fset
124	agriffis	1.61	declare -a new_CFLAGS new_CXXFLAGS
125	agriffis	1.58
126	vapier	1.36	for x in "$@" ; do
127	solar	1.27	case "${x}" in
128	solar	1.82	-fPIC\|-fpic\|-fPIE\|-fpie\|-pie)
129			append-flags `test_flag -fno-pie`;;
130			-fstack-protector\|-fstack-protector-all)
131			fstack-flags;;
132	solar	1.27	esac
133			done
134	vapier	1.36
135	agriffis	1.61	for fset in CFLAGS CXXFLAGS; do
136	agriffis	1.64	# Looping over the flags instead of using a global
137			# substitution ensures that we're working with flag atoms.
138			# Otherwise globs like -O* have the potential to wipe out the
139			# list of flags.
140	agriffis	1.61	for f in ${!fset}; do
141			for x in "$@"; do
142			# Note this should work with globs like -O*
143			[[ ${f} == ${x} ]] && continue 2
144			done
145			eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
146			done
147			eval export ${fset}=\${new_${fset}\[*]}
148	verwilst	1.1	done
149	agriffis	1.61
150	vapier	1.36	return 0
151	verwilst	1.2	}
152
153	vapier	1.40	filter-lfs-flags() {
154	vapier	1.93	[[ -n $@ ]] && die "filter-lfs-flags takes no arguments"
155	vapier	1.40	filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
156			}
157
158	vapier	1.48	append-lfs-flags() {
159	vapier	1.93	[[ -n $@ ]] && die "append-lfs-flags takes no arguments"
160	vapier	1.48	append-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
161			}
162
163	vapier	1.18	append-flags() {
164	solar	1.82	[[ -z $* ]] && return 0
165	agriffis	1.58	export CFLAGS="${CFLAGS} $*"
166			export CXXFLAGS="${CXXFLAGS} $*"
167			[ -n "`is-flag -fno-stack-protector`" -o \
168			-n "`is-flag -fno-stack-protector-all`" ] && fstack-flags
169	vapier	1.28	return 0
170	verwilst	1.1	}
171
172	vapier	1.18	replace-flags() {
173	vapier	1.93	[[ $# != 2 ]] \
174			&& echo && eerror "Usage: replace-flags <old flag> <new flag>" \
175			&& die "replace-flags takes 2 arguments, not $#"
176
177	mr_bones_	1.83	local f fset
178	agriffis	1.64	declare -a new_CFLAGS new_CXXFLAGS
179
180			for fset in CFLAGS CXXFLAGS; do
181			# Looping over the flags instead of using a global
182			# substitution ensures that we're working with flag atoms.
183			# Otherwise globs like -O* have the potential to wipe out the
184			# list of flags.
185			for f in ${!fset}; do
186			# Note this should work with globs like -O*
187			[[ ${f} == ${1} ]] && f=${2}
188			eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
189			done
190			eval export ${fset}=\${new_${fset}\[*]}
191			done
192
193	vapier	1.28	return 0
194	danarmak	1.7	}
195
196	vapier	1.37	replace-cpu-flags() {
197	vapier	1.70	local newcpu="$#" ; newcpu="${!newcpu}"
198			while [ $# -gt 1 ] ; do
199	agriffis	1.64	# quote to make sure that no globbing is done (particularly on
200			# ${oldcpu} prior to calling replace-flags
201	vapier	1.70	replace-flags "-march=${1}" "-march=${newcpu}"
202			replace-flags "-mcpu=${1}" "-mcpu=${newcpu}"
203			replace-flags "-mtune=${1}" "-mtune=${newcpu}"
204			shift
205	vapier	1.37	done
206			return 0
207			}
208
209	danarmak	1.7	is-flag() {
210	agriffis	1.58	local x
211
212	vapier	1.18	for x in ${CFLAGS} ${CXXFLAGS} ; do
213	agriffis	1.67	# Note this should work with globs like -mcpu=ultrasparc*
214			if [[ ${x} == ${1} ]]; then
215	azarah	1.8	echo true
216	vapier	1.18	return 0
217			fi
218	danarmak	1.7	done
219	vapier	1.18	return 1
220	verwilst	1.1	}
221	azarah	1.8
222	vapier	1.36	filter-mfpmath() {
223	agriffis	1.58	local orig_mfpmath new_math prune_math
224
225	vapier	1.36	# save the original -mfpmath flag
226	agriffis	1.58	orig_mfpmath="`get-flag -mfpmath`"
227	vapier	1.36	# get the value of the current -mfpmath flag
228	agriffis	1.58	new_math=" `get-flag mfpmath \| tr , ' '` "
229	vapier	1.36	# figure out which math values are to be removed
230	agriffis	1.58	prune_math=""
231	vapier	1.36	for prune_math in "$@" ; do
232			new_math="${new_math/ ${prune_math} / }"
233			done
234			new_math="`echo ${new_math:1:${#new_math}-2} \| tr ' ' ,`"
235
236			if [ -z "${new_math}" ] ; then
237			# if we're removing all user specified math values are
238			# slated for removal, then we just filter the flag
239			filter-flags ${orig_mfpmath}
240			else
241			# if we only want to filter some of the user specified
242			# math values, then we replace the current flag
243			replace-flags ${orig_mfpmath} -mfpmath=${new_math}
244			fi
245			return 0
246			}
247
248	azarah	1.8	strip-flags() {
249	agriffis	1.58	local x y flag NEW_CFLAGS NEW_CXXFLAGS
250
251	vapier	1.36	setup-allowed-flags
252
253	azarah	1.8	local NEW_CFLAGS=""
254			local NEW_CXXFLAGS=""
255
256	azarah	1.17	# Allow unstable C[XX]FLAGS if we are using unstable profile ...
257	vapier	1.84	if has ~$(tc-arch) ${ACCEPT_KEYWORDS} ; then
258	azarah	1.17	ALLOWED_FLAGS="${ALLOWED_FLAGS} ${UNSTABLE_FLAGS}"
259			fi
260
261	agriffis	1.58	set -f # disable pathname expansion
262	azarah	1.8
263	agriffis	1.58	for x in ${CFLAGS}; do
264			for y in ${ALLOWED_FLAGS}; do
265	lostlogic	1.14	flag=${x%%=*}
266	vapier	1.65	if [ "${flag%%${y}}" = "" ] ; then
267	lostlogic	1.14	NEW_CFLAGS="${NEW_CFLAGS} ${x}"
268			break
269	azarah	1.8	fi
270			done
271			done
272
273	agriffis	1.58	for x in ${CXXFLAGS}; do
274			for y in ${ALLOWED_FLAGS}; do
275	lostlogic	1.14	flag=${x%%=*}
276	vapier	1.65	if [ "${flag%%${y}}" = "" ] ; then
277	lostlogic	1.14	NEW_CXXFLAGS="${NEW_CXXFLAGS} ${x}"
278			break
279	azarah	1.8	fi
280			done
281			done
282	azarah	1.30
283			# In case we filtered out all optimization flags fallback to -O2
284			if [ "${CFLAGS/-O}" != "${CFLAGS}" -a "${NEW_CFLAGS/-O}" = "${NEW_CFLAGS}" ]; then
285			NEW_CFLAGS="${NEW_CFLAGS} -O2"
286			fi
287			if [ "${CXXFLAGS/-O}" != "${CXXFLAGS}" -a "${NEW_CXXFLAGS/-O}" = "${NEW_CXXFLAGS}" ]; then
288			NEW_CXXFLAGS="${NEW_CXXFLAGS} -O2"
289			fi
290	azarah	1.8
291	agriffis	1.58	set +f # re-enable pathname expansion
292	azarah	1.8
293			export CFLAGS="${NEW_CFLAGS}"
294			export CXXFLAGS="${NEW_CXXFLAGS}"
295	vapier	1.36	return 0
296	puggy	1.29	}
297
298	azarah	1.96	test-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
311			test-flag-CC() { test-flag-PROG "CC" "$1"; }
312
313			# Returns true if C++ compiler support given flag
314			test-flag-CXX() { test-flag-PROG "CXX" "$1"; }
315
316	azarah	1.99	test-flags-PROG() {
317			local comp=$1
318			local flags
319	azarah	1.96	local x
320	azarah	1.99
321			shift
322
323			[[ -z ${comp} ]] && \
324			return 1
325	swegener	1.101
326	azarah	1.96	for x in "$@" ; do
327	azarah	1.99	test-flag-${comp} "${x}" && flags="${flags} ${x}"
328	azarah	1.96	done
329
330	azarah	1.99	echo "${flags}"
331	azarah	1.96
332	azarah	1.99	# Just bail if we dont have any flags
333			[[ -n ${flags} ]]
334	azarah	1.96	}
335
336	azarah	1.99	# Returns (echo's) the given flags supported by the C compiler
337			test-flags-CC() { test-flags-PROG "CC" "$@"; }
338
339			# Returns (echo's) the given flags supported by the C++ compiler
340			test-flags-CXX() { test-flags-PROG "CXX" "$@"; }
341
342			# Short-hand that should hopefully work for both C and C++ compiler, but
343	azarah	1.100	# its really only present due to the append-flags() abomination.
344	azarah	1.99	test-flags() { test-flags-CC "$@"; }
345
346	kevquinn	1.104	# Deprecated, use test-flags()
347	vapier	1.36	test_flag() {
348	kevquinn	1.104	ewarn "test_flag: deprecated, please use test-flags()!" >&2
349	azarah	1.96
350	azarah	1.99	test-flags-CC "$@"
351	puggy	1.29	}
352
353	agriffis	1.58	test_version_info() {
354	vapier	1.75	if [[ $($(tc-getCC) --version 2>&1) == $1 ]]; then
355	agriffis	1.58	return 0
356			else
357			return 1
358			fi
359			}
360
361	puggy	1.29	strip-unsupported-flags() {
362	vapier	1.95	local x NEW_CFLAGS NEW_CXXFLAGS
363	agriffis	1.58
364	vapier	1.36	for x in ${CFLAGS} ; do
365	azarah	1.96	NEW_CFLAGS="${NEW_CFLAGS} $(test-flags ${x})"
366	puggy	1.29	done
367	vapier	1.36	for x in ${CXXFLAGS} ; do
368	azarah	1.96	NEW_CXXFLAGS="${NEW_CXXFLAGS} $(test-flags ${x})"
369	puggy	1.29	done
370
371	vapier	1.95	export CFLAGS=${NEW_CFLAGS}
372			export CXXFLAGS=${NEW_CXXFLAGS}
373	azarah	1.8	}
374
375	vapier	1.10	get-flag() {
376	agriffis	1.58	local f findflag="$1"
377
378	vapier	1.36	# this code looks a little flaky but seems to work for
379			# everything we want ...
380			# for example, if CFLAGS="-march=i686":
381	agriffis	1.58	# `get-flag -march` == "-march=i686"
382			# `get-flag march` == "i686"
383	vapier	1.10	for f in ${CFLAGS} ${CXXFLAGS} ; do
384			if [ "${f/${findflag}}" != "${f}" ] ; then
385	agriffis	1.58	printf "%s\n" "${f/-${findflag}=}"
386	vapier	1.28	return 0
387	vapier	1.10	fi
388			done
389	vapier	1.28	return 1
390	joker	1.16	}
391
392	kevquinn	1.92	# DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs
393	solar	1.53	has_hardened() {
394	kevquinn	1.104	ewarn "has_hardened: deprecated, please use gcc-specs-{relro,now}()!" >&2
395	swegener	1.101
396	lv	1.69	test_version_info Hardened && return 0
397	azarah	1.96	# The specs file wont exist unless gcc has GCC_SPECS support
398			[[ -f ${GCC_SPECS} && ${GCC_SPECS} != ${GCC_SPECS/hardened/} ]]
399	solar	1.53	}
400
401	kevquinn	1.92	# DEPRECATED - use gcc-specs-pie from toolchain-funcs
402	solar	1.81	# indicate whether PIC is set
403	tseng	1.42	has_pic() {
404	kevquinn	1.104	ewarn "has_pic: deprecated, please use gcc-specs-pie()!" >&2
405	swegener	1.101
406	azarah	1.96	[[ ${CFLAGS/-fPIC} != ${CFLAGS} \|\| \
407			${CFLAGS/-fpic} != ${CFLAGS} \|\| \
408			-n $(echo \| $(tc-getCC) ${CFLAGS} -E -dM - \| grep __PIC__) ]]
409	tseng	1.42	}
410
411	kevquinn	1.92	# DEPRECATED - use gcc-specs-pie from toolchain-funcs
412	solar	1.81	# indicate whether PIE is set
413	mr_bones_	1.83	has_pie() {
414	kevquinn	1.104	ewarn "has_pie: deprecated, please use gcc-specs-pie()!" >&2
415	swegener	1.101
416	azarah	1.96	[[ ${CFLAGS/-fPIE} != ${CFLAGS} \|\| \
417			${CFLAGS/-fpie} != ${CFLAGS} \|\| \
418			-n $(echo \| $(tc-getCC) ${CFLAGS} -E -dM - \| grep __PIE__) \|\| \
419			-n $(echo \| $(tc-getCC) ${CFLAGS} -E -dM - \| grep __PIC__) ]]
420	solar	1.81	# test PIC while waiting for specs to be updated to generate __PIE__
421	tseng	1.42	}
422	mr_bones_	1.83
423	kevquinn	1.92	# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
424	solar	1.86	# indicate whether code for SSP is being generated for all functions
425			has_ssp_all() {
426	kevquinn	1.104	ewarn "has_ssp_all: deprecated, please use gcc-specs-ssp()!" >&2
427	swegener	1.101
428	solar	1.86	# note; this matches only -fstack-protector-all
429	azarah	1.96	[[ ${CFLAGS/-fstack-protector-all} != ${CFLAGS} \|\| \
430			-n $(echo \| $(tc-getCC) ${CFLAGS} -E -dM - \| grep __SSP_ALL__) ]] \|\| \
431			gcc-specs-ssp
432	solar	1.86	}
433
434	kevquinn	1.92	# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
435	solar	1.81	# indicate whether code for SSP is being generated
436	tseng	1.42	has_ssp() {
437	kevquinn	1.104	ewarn "has_ssp: deprecated, please use gcc-specs-ssp()!" >&2
438	swegener	1.101
439	solar	1.81	# note; this matches both -fstack-protector and -fstack-protector-all
440	azarah	1.96	[[ ${CFLAGS/-fstack-protector} != ${CFLAGS} \|\| \
441			-n $(echo \| $(tc-getCC) ${CFLAGS} -E -dM - \| grep __SSP__) ]] \|\| \
442			gcc-specs-ssp
443	tseng	1.42	}
444
445	lv	1.56	has_m64() {
446	lv	1.62	# this doesnt test if the flag is accepted, it tests if the flag
447			# actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
448			# please dont replace this function with test_flag in some future
449			# clean-up!
450	swegener	1.101
451	vapier	1.72	local temp="$(emktemp)"
452	azarah	1.96	echo "int main() { return(0); }" > "${temp}".c
453	kugelfang	1.74	MY_CC=$(tc-getCC)
454	azarah	1.96	${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
455	vapier	1.72	local ret=$?
456	azarah	1.96	rm -f "${temp}".c
457			[[ ${ret} != 1 ]] && return 0
458	lv	1.62	return 1
459	lv	1.56	}
460
461			has_m32() {
462	lv	1.62	# this doesnt test if the flag is accepted, it tests if the flag
463			# actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
464			# please dont replace this function with test_flag in some future
465			# clean-up!
466	eradicator	1.80
467			[ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0
468
469	vapier	1.95	local temp=$(emktemp)
470			echo "int main() { return(0); }" > "${temp}".c
471	kugelfang	1.74	MY_CC=$(tc-getCC)
472	vapier	1.95	${MY_CC/ .*/} -m32 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
473	vapier	1.72	local ret=$?
474	vapier	1.95	rm -f "${temp}".c
475	azarah	1.96	[[ ${ret} != 1 ]] && return 0
476	lv	1.62	return 1
477	lv	1.56	}
478
479	vapier	1.18	replace-sparc64-flags() {
480	fmccor	1.98	local SPARC64_CPUS="ultrasparc3 ultrasparc v9"
481	joker	1.16
482	mr_bones_	1.83	if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
483	agriffis	1.58	for x in ${SPARC64_CPUS}; do
484	joker	1.16	CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}"
485			done
486	mr_bones_	1.83	else
487	agriffis	1.58	for x in ${SPARC64_CPUS}; do
488	joker	1.16	CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
489			done
490			fi
491	mr_bones_	1.83
492			if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
493	agriffis	1.58	for x in ${SPARC64_CPUS}; do
494	joker	1.16	CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}"
495			done
496			else
497	agriffis	1.58	for x in ${SPARC64_CPUS}; do
498	joker	1.16	CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
499			done
500			fi
501	vapier	1.59
502			export CFLAGS CXXFLAGS
503	solar	1.27	}
504
505			append-ldflags() {
506	vapier	1.59	export LDFLAGS="${LDFLAGS} $*"
507	vapier	1.28	return 0
508	solar	1.27	}
509
510	solar	1.41	filter-ldflags() {
511	agriffis	1.58	local x
512
513	solar	1.41	# we do this fancy spacing stuff so as to not filter
514			# out part of a flag ... we want flag atoms ! :D
515			LDFLAGS=" ${LDFLAGS} "
516			for x in "$@" ; do
517	vapier	1.84	LDFLAGS=${LDFLAGS// ${x} / }
518	solar	1.41	done
519	vapier	1.84	[[ -z ${LDFLAGS// } ]] \
520			&& LDFLAGS="" \
521			\|\| LDFLAGS=${LDFLAGS:1:${#LDFLAGS}-2}
522	vapier	1.59	export LDFLAGS
523	solar	1.41	return 0
524			}
525
526	vapier	1.102	# Turn C style ldflags (-Wl,-foo) into straight ldflags
527			raw-ldflags() {
528			local x input="$@"
529			[[ -z ${input} ]] && input=${LDFLAGS}
530			set --
531			for x in ${input} ; do
532	vapier	1.103	x=${x#-Wl,}
533			set -- "$@" ${x//,/ }
534	vapier	1.102	done
535			echo "$@"
536			}
537
538	solar	1.27	fstack-flags() {
539	kevquinn	1.92	if gcc-specs-ssp; then
540	mr_bones_	1.83	[ -z "`is-flag -fno-stack-protector`" ] &&
541	agriffis	1.58	export CFLAGS="${CFLAGS} `test_flag -fno-stack-protector`"
542	solar	1.35	fi
543	agriffis	1.58	return 0
544	vapier	1.10	}
545	vapier	1.73
546			# This is thanks to great work from Paul de Vrieze <gentoo-user@devrieze.net>,
547			# bug #9016. Also thanks to Jukka Salmi <salmi@gmx.net> (bug #13907) for more
548			# fixes.
549			#
550			# Export CFLAGS and CXXFLAGS that are compadible with gcc-2.95.3
551			gcc2-flags() {
552	vapier	1.85	if [[ $(tc-arch) == "x86" \|\| $(tc-arch) == "amd64" ]] ; then
553			CFLAGS=${CFLAGS//-mtune=/-mcpu=}
554			CXXFLAGS=${CXXFLAGS//-mtune=/-mcpu=}
555	vapier	1.73	fi
556
557	vapier	1.85	replace-cpu-flags k6-{2,3} k6
558			replace-cpu-flags athlon{,-{tbird,4,xp,mp}} i686
559
560			replace-cpu-flags pentium-mmx i586
561			replace-cpu-flags pentium{2,3,4} i686
562
563			replace-cpu-flags ev6{7,8} ev6
564
565	vapier	1.73	export CFLAGS CXXFLAGS
566			}
567	flameeyes	1.94
568			# Gets the flags needed for "NOW" binding
569			bindnow-flags() {
570			case $($(tc-getLD) -v 2>&1 </dev/null) in
571			GNU \| 'with BFD') # GNU ld
572			echo "-Wl,-z,now" ;;
573			Apple) # Darwin ld
574			echo "-bind_at_load" ;;
575			*)
576			# Some linkers just recognize -V instead of -v
577			case $($(tc-getLD) -V 2>&1 </dev/null) in
578			Solaris) # Solaris accept almost the same GNU options
579			echo "-Wl,-z,now" ;;
580			esac
581			;;
582			esac
583			}