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.106 2006/02/19 23:18: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[q] <flag> ####
# Returns "true" if flag is set in C[XX]FLAGS
# Matches only complete a flag
# q version sets return code but doesn't echo
#
#### is-ldflag[q] <flag> ####
# Returns "true" if flag is set in LDFLAGS
# Matches only complete a flag
# q version sets return code but doesn't echo
#
#### 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
#
#### 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-pie -fno-unit-at-a-time"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -g -g0 -g1 -g2 -g3 -ggdb -ggdb0 -ggdb1 -ggdb2 -ggdb3"
                export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-ident"
        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"
        return 0
}

# inverted filters for hardened compiler.  This is trying to unpick
# the hardened compiler defaults.
_filter-hardened() {
        local f
        for f in "$@" ; do
                case "${f}" in
                        # Ideally we should only concern ourselves with PIE flags,
                        # not -fPIC or -fpic, but too many places filter -fPIC without
                        # thinking about -fPIE.
                        -fPIC|-fpic|-fPIE|-fpie|-Wl,pie|-pie)
                                gcc-specs-pie || continue
                                is-flagq -nopie || append-flags -nopie;;
                        -fstack-protector)
                                gcc-specs-ssp || continue
                                is-flagq -fno-stack-protector || append-flags -fno-stack-protector;;
                        -fstack-protector-all)
                                gcc-specs-ssp-to-all || continue
                                is-flagq -fno-stack-protector-all || append-flags -fno-stack-protector-all;;
                esac
        done
}

# Remove occurrences of strings from variable given in $1
# Strings removed are matched as globs, so for example
# '-O*' would remove -O1, -O2 etc.
_filter-var() {
        local f x VAR VAL
        declare -a new

        VAR=$1
        shift
        eval VAL=\${${VAR}}
        for f in ${VAL}; do
                for x in "$@"; do
                        # Note this should work with globs like -O*
                        [[ ${f} == ${x} ]] && continue 2
                done
                eval new\[\${\#new\[@]}]=\${f}
        done
        eval export ${VAR}=\${new\[*]}
}

filter-flags() {
        _filter-hardened "$@"
        _filter-var CFLAGS "$@"
        _filter-var CXXFLAGS "$@"
        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} $*"
        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-flagq() {
        local x

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

is-flag() {
        if is-flagq ${1}; then
                echo true
                return 0
        fi
        return 1
}

is-ldflagq() {
        local x

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

is-ldflag() {
        if is-ldflagq ${1}; then
                echo true
                return 0
        fi
        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 "$@"; }

# Depriciated, 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} ]] || \
        gcc-specs-pie
}

# 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} ]] || \
        gcc-specs-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-all
}

# 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() {
        [[ -z $* ]] && return 0
        export LDFLAGS="${LDFLAGS} $*"
        return 0
}

# Remove flags from LDFLAGS - it's up to the ebuild to filter
# CFLAGS and CXXFLAGS via filter-flags if they need to.
filter-ldflags() {
        _filter-var LDFLAGS "$@"
        return 0
}

# Turn C style ldflags (-Wl,-foo) into straight ldflags - the results
# are suitable for passing directly to 'ld'; note LDFLAGS is usually passed
# to gcc where it needs the '-Wl,'.
raw-ldflags() {
        local x input="$@"
        [[ -z ${input} ]] && input=${LDFLAGS}
        set --
        for x in ${input} ; do
                x=${x#-Wl,}
                set -- "$@" ${x//,/ }
        done
        echo "$@"
}

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