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

# Copyright 1999-2012 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.170 2012/05/26 02:55:02 vapier Exp $

# @ECLASS: flag-o-matic.eclass
# @MAINTAINER:
# toolchain@gentoo.org
# @BLURB: common functions to manipulate and query toolchain flags
# @DESCRIPTION:
# This eclass contains a suite of functions to help developers sanely
# and safely manage toolchain flags in their builds.

if [[ ${___ECLASS_ONCE_FLAG_O_MATIC} != "recur -_+^+_- spank" ]] ; then
___ECLASS_ONCE_FLAG_O_MATIC="recur -_+^+_- spank"

inherit eutils toolchain-funcs multilib

# Return all the flag variables that our high level funcs operate on.
all-flag-vars() {
        echo {C,CPP,CXX,CCAS,F,FC,LD}FLAGS
}

# {C,CXX,F,FC}FLAGS that we allow in strip-flags
# Note: shell globs and character lists are allowed
setup-allowed-flags() {
        ALLOWED_FLAGS="-pipe"
        ALLOWED_FLAGS+=" -O -O1 -O2 -Os -mcpu -march -mtune"
        ALLOWED_FLAGS+=" -fstack-protector -fstack-protector-all"
        ALLOWED_FLAGS+=" -fbounds-checking -fno-strict-overflow"
        ALLOWED_FLAGS+=" -fno-PIE -fno-pie -fno-unit-at-a-time"
        ALLOWED_FLAGS+=" -g -g[0-9] -ggdb -ggdb[0-9] -gstabs -gstabs+"
        ALLOWED_FLAGS+=" -fno-ident -fpermissive"
        ALLOWED_FLAGS+=" -W* -w"

        # allow a bunch of flags that negate features / control ABI
        ALLOWED_FLAGS+=" -fno-stack-protector -fno-stack-protector-all \
                -fno-strict-aliasing -fno-bounds-checking -fstrict-overflow \
                -fno-omit-frame-pointer"
        ALLOWED_FLAGS+=" -mregparm -mno-app-regs -mapp-regs -mno-mmx -mno-sse \
                -mno-sse2 -mno-sse3 -mno-ssse3 -mno-sse4 -mno-sse4.1 -mno-sse4.2 \
                -mno-avx -mno-aes -mno-pclmul -mno-sse4a -mno-3dnow -mno-popcnt \
                -mno-abm -mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 -mplt \
                -msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
                -mieee -mieee-with-inexact -mschedule -mfloat-gprs -mspe -mno-spe \
                -mtls-direct-seg-refs -mno-tls-direct-seg-refs -mflat -mno-flat \
                -mno-faster-structs -mfaster-structs -m32 -m64 -mx32 -mabi \
                -mlittle-endian -mbig-endian -EL -EB -fPIC -mlive-g0 -mcmodel \
                -mstack-bias -mno-stack-bias -msecure-plt -m*-toc -D* -U*"

        # 4.5
        ALLOWED_FLAGS+=" -mno-fma4 -mno-movbe -mno-xop -mno-lwp"
        # 4.6
        ALLOWED_FLAGS+=" -mno-fsgsbase -mno-rdrnd -mno-f16c -mno-bmi -mno-tbm"

        export ALLOWED_FLAGS
        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 $(test-flags -fno-stack-protector);;
                        -fstack-protector-all)
                                gcc-specs-ssp-to-all || continue
                                is-flagq -fno-stack-protector-all || append-flags $(test-flags -fno-stack-protector-all);;
                        -fno-strict-overflow)
                                gcc-specs-nostrict || continue
                                is-flagq -fstrict-overflow || append-flags $(test-flags -fstrict-overflow);;
                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=$1 new=()
        shift

        for f in ${!var} ; do
                for x in "$@" ; do
                        # Note this should work with globs like -O*
                        [[ ${f} == ${x} ]] && continue 2
                done
                new+=( "${f}" )
        done
        eval export ${var}=\""${new[*]}"\"
}

# @FUNCTION: filter-flags
# @USAGE: <flags>
# @DESCRIPTION:
# Remove particular <flags> from {C,CPP,CXX,CCAS,F,FC,LD}FLAGS.  Accepts shell globs.
filter-flags() {
        _filter-hardened "$@"
        local v
        for v in $(all-flag-vars) ; do
                _filter-var ${v} "$@"
        done
        return 0
}

# @FUNCTION: filter-lfs-flags
# @DESCRIPTION:
# Remove flags that enable Large File Support.
filter-lfs-flags() {
        [[ $# -ne 0 ]] && die "filter-lfs-flags takes no arguments"
        # http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
        # _LARGEFILE_SOURCE: enable support for new LFS funcs (ftello/etc...)
        # _LARGEFILE64_SOURCE: enable support for 64bit variants (off64_t/fseeko64/etc...)
        # _FILE_OFFSET_BITS: default to 64bit variants (off_t is defined as off64_t)
        filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
}

# @FUNCTION: filter-ldflags
# @USAGE: <flags>
# @DESCRIPTION:
# Remove particular <flags> from LDFLAGS.  Accepts shell globs.
filter-ldflags() {
        _filter-var LDFLAGS "$@"
        return 0
}

# @FUNCTION: append-cppflags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to the current CPPFLAGS.
append-cppflags() {
        [[ $# -eq 0 ]] && return 0
        export CPPFLAGS="${CPPFLAGS} $*"
        return 0
}

# @FUNCTION: append-cflags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to the current CFLAGS.
append-cflags() {
        [[ $# -eq 0 ]] && return 0
        export CFLAGS=$(test-flags-CC ${CFLAGS} "$@")
        return 0
}

# @FUNCTION: append-cxxflags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to the current CXXFLAGS.
append-cxxflags() {
        [[ $# -eq 0 ]] && return 0
        export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS} "$@")
        return 0
}

# @FUNCTION: append-fflags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to the current {F,FC}FLAGS.
append-fflags() {
        [[ $# -eq 0 ]] && return 0
        export FFLAGS=$(test-flags-F77 ${FFLAGS} "$@")
        export FCFLAGS=$(test-flags-FC ${FCFLAGS} "$@")
        return 0
}

# @FUNCTION: append-lfs-flags
# @DESCRIPTION:
# Add flags that enable Large File Support.
append-lfs-flags() {
        [[ $# -ne 0 ]] && die "append-lfs-flags takes no arguments"
        # see comments in filter-lfs-flags func for meaning of these
        append-cppflags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
}

# @FUNCTION: append-ldflags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to the current LDFLAGS.
append-ldflags() {
        [[ $# -eq 0 ]] && return 0
        local flag
        for flag in "$@"; do
                [[ ${flag} == -l* ]] && \
                        ewarn "Appending a library link instruction (${flag}); libraries to link to should not be passed through LDFLAGS"
        done

        export LDFLAGS="${LDFLAGS} $*"
        return 0
}

# @FUNCTION: append-flags
# @USAGE: <flags>
# @DESCRIPTION:
# Add extra <flags> to your current {C,CXX,F,FC}FLAGS.
append-flags() {
        [[ $# -eq 0 ]] && return 0
        case " $* " in
        *' '-[DIU]*) eqawarn 'please use append-cppflags for preprocessor flags' ;;
        *' '-L*)     eqawarn 'please use append-ldflags for linker flags' ;;
        esac
        append-cflags "$@"
        append-cxxflags "$@"
        append-fflags "$@"
        return 0
}

# @FUNCTION: replace-flags
# @USAGE: <old> <new>
# @DESCRIPTION:
# Replace the <old> flag with <new>.  Accepts shell globs for <old>.
replace-flags() {
        [[ $# != 2 ]] && die "Usage: replace-flags <old flag> <new flag>"

        local f var new
        for var in $(all-flag-vars) ; 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.
                new=()
                for f in ${!var} ; do
                        # Note this should work with globs like -O*
                        [[ ${f} == ${1} ]] && f=${2}
                        new+=( "${f}" )
                done
                eval export ${var}=\""${new[*]}"\"
        done

        return 0
}

# @FUNCTION: replace-cpu-flags
# @USAGE: <old> <new>
# @DESCRIPTION:
# Replace cpu flags (like -march/-mcpu/-mtune) that select the <old> cpu
# with flags that select the <new> cpu.  Accepts shell globs for <old>.
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 ${!1} ; do
                [[ ${x} == $2 ]] && return 0
        done
        return 1
}

# @FUNCTION: is-flagq
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is in {C,CXX,F,FC}FLAGS, else returns shell false.  Accepts shell globs.
is-flagq() {
        [[ -n $2 ]] && die "Usage: is-flag <flag>"

        local var
        for var in $(all-flag-vars) ; do
                _is_flagq ${var} "$1" && return 0
        done
        return 1
}

# @FUNCTION: is-flag
# @USAGE: <flag>
# @DESCRIPTION:
# Echo's "true" if flag is set in {C,CXX,F,FC}FLAGS.  Accepts shell globs.
is-flag() {
        is-flagq "$@" && echo true
}

# @FUNCTION: is-ldflagq
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is in LDFLAGS, else returns shell false.  Accepts shell globs.
is-ldflagq() {
        [[ -n $2 ]] && die "Usage: is-ldflag <flag>"
        _is_flagq LDFLAGS $1
}

# @FUNCTION: is-ldflag
# @USAGE: <flag>
# @DESCRIPTION:
# Echo's "true" if flag is set in LDFLAGS.  Accepts shell globs.
is-ldflag() {
        is-ldflagq "$@" && echo true
}

# @FUNCTION: filter-mfpmath
# @USAGE: <math types>
# @DESCRIPTION:
# Remove specified math types from the fpmath flag.  For example, if the user
# has -mfpmath=sse,386, running `filter-mfpmath sse` will leave the user with
# -mfpmath=386.
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)
        new_math=" ${new_math//,/ } "
        # 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})
        new_math=${new_math// /,}

        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
}

# @FUNCTION: strip-flags
# @DESCRIPTION:
# Strip C[XX]FLAGS of everything except known good/safe flags.
strip-flags() {
        local x y var

        setup-allowed-flags

        set -f  # disable pathname expansion

        for var in $(all-flag-vars) ; do
                local new=()

                for x in ${!var} ; do
                        local flag=${x%%=*}
                        for y in ${ALLOWED_FLAGS} ; do
                                if [[ -z ${flag%%${y}} ]] ; then
                                        new+=( "${x}" )
                                        break
                                fi
                        done
                done

                # In case we filtered out all optimization flags fallback to -O2
                if _is_flagq ${var} "-O*" && ! _is_flagq new "-O*" ; then
                        new+=( -O2 )
                fi

                eval export ${var}=\""${new[*]}"\"
        done

        set +f  # re-enable pathname expansion

        return 0
}

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

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

        # use -c so we can test the assembler as well
        local PROG=$(tc-get${comp})
        ${PROG} "${flag}" -c -o /dev/null -xc /dev/null \
                > /dev/null 2>&1
}

# @FUNCTION: test-flag-CC
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is supported by the C compiler, else returns shell false.
test-flag-CC() { test-flag-PROG "CC" "$1"; }

# @FUNCTION: test-flag-CXX
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is supported by the C++ compiler, else returns shell false.
test-flag-CXX() { test-flag-PROG "CXX" "$1"; }

# @FUNCTION: test-flag-F77
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is supported by the Fortran 77 compiler, else returns shell false.
test-flag-F77() { test-flag-PROG "F77" "$1"; }

# @FUNCTION: test-flag-FC
# @USAGE: <flag>
# @DESCRIPTION:
# Returns shell true if <flag> is supported by the Fortran 90 compiler, else returns shell false.
test-flag-FC() { test-flag-PROG "FC" "$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}${flags:+ }${x}"
        done

        echo "${flags}"

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

# @FUNCTION: test-flags-CC
# @USAGE: <flags>
# @DESCRIPTION:
# Returns shell true if <flags> are supported by the C compiler, else returns shell false.
test-flags-CC() { test-flags-PROG "CC" "$@"; }

# @FUNCTION: test-flags-CXX
# @USAGE: <flags>
# @DESCRIPTION:
# Returns shell true if <flags> are supported by the C++ compiler, else returns shell false.
test-flags-CXX() { test-flags-PROG "CXX" "$@"; }

# @FUNCTION: test-flags-F77
# @USAGE: <flags>
# @DESCRIPTION:
# Returns shell true if <flags> are supported by the Fortran 77 compiler, else returns shell false.
test-flags-F77() { test-flags-PROG "F77" "$@"; }

# @FUNCTION: test-flags-FC
# @USAGE: <flags>
# @DESCRIPTION:
# Returns shell true if <flags> are supported by the Fortran 90 compiler, else returns shell false.
test-flags-FC() { test-flags-PROG "FC" "$@"; }

# @FUNCTION: test-flags
# @USAGE: <flags>
# @DESCRIPTION:
# 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 "$@"; }

# @FUNCTION: test_version_info
# @USAGE: <version>
# @DESCRIPTION:
# Returns shell true if the current C compiler version matches <version>, else returns shell false.
# Accepts shell globs.
test_version_info() {
        if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
                return 0
        else
                return 1
        fi
}

# @FUNCTION: strip-unsupported-flags
# @DESCRIPTION:
# Strip {C,CXX,F,FC}FLAGS of any flags not supported by the active toolchain.
strip-unsupported-flags() {
        export CFLAGS=$(test-flags-CC ${CFLAGS})
        export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS})
        export FFLAGS=$(test-flags-F77 ${FFLAGS})
        export FCFLAGS=$(test-flags-FC ${FCFLAGS})
}

# @FUNCTION: get-flag
# @USAGE: <flag>
# @DESCRIPTION:
# Find and echo the value for a particular flag.  Accepts shell globs.
get-flag() {
        local f var 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 var in $(all-flag-vars) ; do
                for f in ${!var} ; do
                        if [ "${f/${findflag}}" != "${f}" ] ; then
                                printf "%s\n" "${f/-${findflag}=}"
                                return 0
                        fi
                done
        done
        return 1
}

# @FUNCTION: has_m64
# @DESCRIPTION:
# This doesn't test if the flag is accepted, it tests if the flag actually
# WORKS. Non-multilib gcc will take both -m32 and -m64. If the flag works
# return code is 0, else the return code is 1.
has_m64() {
        eqawarn "${FUNCNAME}: don't use this anymore"

        # 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() {
        die "${FUNCNAME}: don't use this anymore"
}

# @FUNCTION: replace-sparc64-flags
# @DESCRIPTION:
# Sets mcpu to v8 and uses the original value as mtune if none specified.
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
}

# @FUNCTION: append-libs
# @USAGE: <libs>
# @DESCRIPTION:
# Add extra <libs> to the current LIBS.
append-libs() {
        [[ $# -eq 0 ]] && return 0
        local flag
        for flag in "$@"; do
                [[ ${flag} == -l* ]] && flag=${flag#-l}
                export LIBS="${LIBS} -l${flag}"
        done

        return 0
}

# @FUNCTION: raw-ldflags
# @USAGE: [flags]
# @DESCRIPTION:
# 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,'.
#
# If no flags are specified, then default to ${LDFLAGS}.
raw-ldflags() {
        local x input="$@"
        [[ -z ${input} ]] && input=${LDFLAGS}
        set --
        for x in ${input} ; do
                x=${x#-Wl,}
                set -- "$@" ${x//,/ }
        done
        echo "$@"
}

# @FUNCTION: no-as-needed
# @RETURN: Flag to disable asneeded behavior for use with append-ldflags.
no-as-needed() {
        case $($(tc-getLD) -v 2>&1 </dev/null) in
                *GNU*) # GNU ld
                echo "-Wl,--no-as-needed" ;;
        esac
}

fi
1	# Copyright 1999-2012 Gentoo Foundation
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.170 2012/05/26 02:55:02 vapier Exp $
4
5	# @ECLASS: flag-o-matic.eclass
6	# @MAINTAINER:
7	# toolchain@gentoo.org
8	# @BLURB: common functions to manipulate and query toolchain flags
9	# @DESCRIPTION:
10	# This eclass contains a suite of functions to help developers sanely
11	# and safely manage toolchain flags in their builds.
12
13	if [[ ${___ECLASS_ONCE_FLAG_O_MATIC} != "recur -_+^+_- spank" ]] ; then
14	___ECLASS_ONCE_FLAG_O_MATIC="recur -_+^+_- spank"
15
16	inherit eutils toolchain-funcs multilib
17
18	# Return all the flag variables that our high level funcs operate on.
19	all-flag-vars() {
20	echo {C,CPP,CXX,CCAS,F,FC,LD}FLAGS
21	}
22
23	# {C,CXX,F,FC}FLAGS that we allow in strip-flags
24	# Note: shell globs and character lists are allowed
25	setup-allowed-flags() {
26	ALLOWED_FLAGS="-pipe"
27	ALLOWED_FLAGS+=" -O -O1 -O2 -Os -mcpu -march -mtune"
28	ALLOWED_FLAGS+=" -fstack-protector -fstack-protector-all"
29	ALLOWED_FLAGS+=" -fbounds-checking -fno-strict-overflow"
30	ALLOWED_FLAGS+=" -fno-PIE -fno-pie -fno-unit-at-a-time"
31	ALLOWED_FLAGS+=" -g -g[0-9] -ggdb -ggdb[0-9] -gstabs -gstabs+"
32	ALLOWED_FLAGS+=" -fno-ident -fpermissive"
33	ALLOWED_FLAGS+=" -W* -w"
34
35	# allow a bunch of flags that negate features / control ABI
36	ALLOWED_FLAGS+=" -fno-stack-protector -fno-stack-protector-all \
37	-fno-strict-aliasing -fno-bounds-checking -fstrict-overflow \
38	-fno-omit-frame-pointer"
39	ALLOWED_FLAGS+=" -mregparm -mno-app-regs -mapp-regs -mno-mmx -mno-sse \
40	-mno-sse2 -mno-sse3 -mno-ssse3 -mno-sse4 -mno-sse4.1 -mno-sse4.2 \
41	-mno-avx -mno-aes -mno-pclmul -mno-sse4a -mno-3dnow -mno-popcnt \
42	-mno-abm -mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 -mplt \
43	-msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
44	-mieee -mieee-with-inexact -mschedule -mfloat-gprs -mspe -mno-spe \
45	-mtls-direct-seg-refs -mno-tls-direct-seg-refs -mflat -mno-flat \
46	-mno-faster-structs -mfaster-structs -m32 -m64 -mx32 -mabi \
47	-mlittle-endian -mbig-endian -EL -EB -fPIC -mlive-g0 -mcmodel \
48	-mstack-bias -mno-stack-bias -msecure-plt -m-toc -D -U*"
49
50	# 4.5
51	ALLOWED_FLAGS+=" -mno-fma4 -mno-movbe -mno-xop -mno-lwp"
52	# 4.6
53	ALLOWED_FLAGS+=" -mno-fsgsbase -mno-rdrnd -mno-f16c -mno-bmi -mno-tbm"
54
55	export ALLOWED_FLAGS
56	return 0
57	}
58
59	# inverted filters for hardened compiler. This is trying to unpick
60	# the hardened compiler defaults.
61	_filter-hardened() {
62	local f
63	for f in "$@" ; do
64	case "${f}" in
65	# Ideally we should only concern ourselves with PIE flags,
66	# not -fPIC or -fpic, but too many places filter -fPIC without
67	# thinking about -fPIE.
68	-fPIC\|-fpic\|-fPIE\|-fpie\|-Wl,pie\|-pie)
69	gcc-specs-pie \|\| continue
70	is-flagq -nopie \|\| append-flags -nopie;;
71	-fstack-protector)
72	gcc-specs-ssp \|\| continue
73	is-flagq -fno-stack-protector \|\| append-flags $(test-flags -fno-stack-protector);;
74	-fstack-protector-all)
75	gcc-specs-ssp-to-all \|\| continue
76	is-flagq -fno-stack-protector-all \|\| append-flags $(test-flags -fno-stack-protector-all);;
77	-fno-strict-overflow)
78	gcc-specs-nostrict \|\| continue
79	is-flagq -fstrict-overflow \|\| append-flags $(test-flags -fstrict-overflow);;
80	esac
81	done
82	}
83
84	# Remove occurrences of strings from variable given in $1
85	# Strings removed are matched as globs, so for example
86	# '-O*' would remove -O1, -O2 etc.
87	_filter-var() {
88	local f x var=$1 new=()
89	shift
90
91	for f in ${!var} ; do
92	for x in "$@" ; do
93	# Note this should work with globs like -O*
94	[[ ${f} == ${x} ]] && continue 2
95	done
96	new+=( "${f}" )
97	done
98	eval export ${var}=\""${new[*]}"\"
99	}
100
101	# @FUNCTION: filter-flags
102	# @USAGE: <flags>
103	# @DESCRIPTION:
104	# Remove particular <flags> from {C,CPP,CXX,CCAS,F,FC,LD}FLAGS. Accepts shell globs.
105	filter-flags() {
106	_filter-hardened "$@"
107	local v
108	for v in $(all-flag-vars) ; do
109	_filter-var ${v} "$@"
110	done
111	return 0
112	}
113
114	# @FUNCTION: filter-lfs-flags
115	# @DESCRIPTION:
116	# Remove flags that enable Large File Support.
117	filter-lfs-flags() {
118	[[ $# -ne 0 ]] && die "filter-lfs-flags takes no arguments"
119	# http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
120	# _LARGEFILE_SOURCE: enable support for new LFS funcs (ftello/etc...)
121	# _LARGEFILE64_SOURCE: enable support for 64bit variants (off64_t/fseeko64/etc...)
122	# _FILE_OFFSET_BITS: default to 64bit variants (off_t is defined as off64_t)
123	filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
124	}
125
126	# @FUNCTION: filter-ldflags
127	# @USAGE: <flags>
128	# @DESCRIPTION:
129	# Remove particular <flags> from LDFLAGS. Accepts shell globs.
130	filter-ldflags() {
131	_filter-var LDFLAGS "$@"
132	return 0
133	}
134
135	# @FUNCTION: append-cppflags
136	# @USAGE: <flags>
137	# @DESCRIPTION:
138	# Add extra <flags> to the current CPPFLAGS.
139	append-cppflags() {
140	[[ $# -eq 0 ]] && return 0
141	export CPPFLAGS="${CPPFLAGS} $*"
142	return 0
143	}
144
145	# @FUNCTION: append-cflags
146	# @USAGE: <flags>
147	# @DESCRIPTION:
148	# Add extra <flags> to the current CFLAGS.
149	append-cflags() {
150	[[ $# -eq 0 ]] && return 0
151	export CFLAGS=$(test-flags-CC ${CFLAGS} "$@")
152	return 0
153	}
154
155	# @FUNCTION: append-cxxflags
156	# @USAGE: <flags>
157	# @DESCRIPTION:
158	# Add extra <flags> to the current CXXFLAGS.
159	append-cxxflags() {
160	[[ $# -eq 0 ]] && return 0
161	export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS} "$@")
162	return 0
163	}
164
165	# @FUNCTION: append-fflags
166	# @USAGE: <flags>
167	# @DESCRIPTION:
168	# Add extra <flags> to the current {F,FC}FLAGS.
169	append-fflags() {
170	[[ $# -eq 0 ]] && return 0
171	export FFLAGS=$(test-flags-F77 ${FFLAGS} "$@")
172	export FCFLAGS=$(test-flags-FC ${FCFLAGS} "$@")
173	return 0
174	}
175
176	# @FUNCTION: append-lfs-flags
177	# @DESCRIPTION:
178	# Add flags that enable Large File Support.
179	append-lfs-flags() {
180	[[ $# -ne 0 ]] && die "append-lfs-flags takes no arguments"
181	# see comments in filter-lfs-flags func for meaning of these
182	append-cppflags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
183	}
184
185	# @FUNCTION: append-ldflags
186	# @USAGE: <flags>
187	# @DESCRIPTION:
188	# Add extra <flags> to the current LDFLAGS.
189	append-ldflags() {
190	[[ $# -eq 0 ]] && return 0
191	local flag
192	for flag in "$@"; do
193	[[ ${flag} == -l* ]] && \
194	ewarn "Appending a library link instruction (${flag}); libraries to link to should not be passed through LDFLAGS"
195	done
196
197	export LDFLAGS="${LDFLAGS} $*"
198	return 0
199	}
200
201	# @FUNCTION: append-flags
202	# @USAGE: <flags>
203	# @DESCRIPTION:
204	# Add extra <flags> to your current {C,CXX,F,FC}FLAGS.
205	append-flags() {
206	[[ $# -eq 0 ]] && return 0
207	case " $* " in
208	' '-[DIU]) eqawarn 'please use append-cppflags for preprocessor flags' ;;
209	' '-L) eqawarn 'please use append-ldflags for linker flags' ;;
210	esac
211	append-cflags "$@"
212	append-cxxflags "$@"
213	append-fflags "$@"
214	return 0
215	}
216
217	# @FUNCTION: replace-flags
218	# @USAGE: <old> <new>
219	# @DESCRIPTION:
220	# Replace the <old> flag with <new>. Accepts shell globs for <old>.
221	replace-flags() {
222	[[ $# != 2 ]] && die "Usage: replace-flags <old flag> <new flag>"
223
224	local f var new
225	for var in $(all-flag-vars) ; do
226	# Looping over the flags instead of using a global
227	# substitution ensures that we're working with flag atoms.
228	# Otherwise globs like -O* have the potential to wipe out the
229	# list of flags.
230	new=()
231	for f in ${!var} ; do
232	# Note this should work with globs like -O*
233	[[ ${f} == ${1} ]] && f=${2}
234	new+=( "${f}" )
235	done
236	eval export ${var}=\""${new[*]}"\"
237	done
238
239	return 0
240	}
241
242	# @FUNCTION: replace-cpu-flags
243	# @USAGE: <old> <new>
244	# @DESCRIPTION:
245	# Replace cpu flags (like -march/-mcpu/-mtune) that select the <old> cpu
246	# with flags that select the <new> cpu. Accepts shell globs for <old>.
247	replace-cpu-flags() {
248	local newcpu="$#" ; newcpu="${!newcpu}"
249	while [ $# -gt 1 ] ; do
250	# quote to make sure that no globbing is done (particularly on
251	# ${oldcpu}) prior to calling replace-flags
252	replace-flags "-march=${1}" "-march=${newcpu}"
253	replace-flags "-mcpu=${1}" "-mcpu=${newcpu}"
254	replace-flags "-mtune=${1}" "-mtune=${newcpu}"
255	shift
256	done
257	return 0
258	}
259
260	_is_flagq() {
261	local x
262	for x in ${!1} ; do
263	[[ ${x} == $2 ]] && return 0
264	done
265	return 1
266	}
267
268	# @FUNCTION: is-flagq
269	# @USAGE: <flag>
270	# @DESCRIPTION:
271	# Returns shell true if <flag> is in {C,CXX,F,FC}FLAGS, else returns shell false. Accepts shell globs.
272	is-flagq() {
273	[[ -n $2 ]] && die "Usage: is-flag <flag>"
274
275	local var
276	for var in $(all-flag-vars) ; do
277	_is_flagq ${var} "$1" && return 0
278	done
279	return 1
280	}
281
282	# @FUNCTION: is-flag
283	# @USAGE: <flag>
284	# @DESCRIPTION:
285	# Echo's "true" if flag is set in {C,CXX,F,FC}FLAGS. Accepts shell globs.
286	is-flag() {
287	is-flagq "$@" && echo true
288	}
289
290	# @FUNCTION: is-ldflagq
291	# @USAGE: <flag>
292	# @DESCRIPTION:
293	# Returns shell true if <flag> is in LDFLAGS, else returns shell false. Accepts shell globs.
294	is-ldflagq() {
295	[[ -n $2 ]] && die "Usage: is-ldflag <flag>"
296	_is_flagq LDFLAGS $1
297	}
298
299	# @FUNCTION: is-ldflag
300	# @USAGE: <flag>
301	# @DESCRIPTION:
302	# Echo's "true" if flag is set in LDFLAGS. Accepts shell globs.
303	is-ldflag() {
304	is-ldflagq "$@" && echo true
305	}
306
307	# @FUNCTION: filter-mfpmath
308	# @USAGE: <math types>
309	# @DESCRIPTION:
310	# Remove specified math types from the fpmath flag. For example, if the user
311	# has -mfpmath=sse,386, running `filter-mfpmath sse` will leave the user with
312	# -mfpmath=386.
313	filter-mfpmath() {
314	local orig_mfpmath new_math prune_math
315
316	# save the original -mfpmath flag
317	orig_mfpmath=$(get-flag -mfpmath)
318	# get the value of the current -mfpmath flag
319	new_math=$(get-flag mfpmath)
320	new_math=" ${new_math//,/ } "
321	# figure out which math values are to be removed
322	prune_math=""
323	for prune_math in "$@" ; do
324	new_math=${new_math/ ${prune_math} / }
325	done
326	new_math=$(echo ${new_math})
327	new_math=${new_math// /,}
328
329	if [[ -z ${new_math} ]] ; then
330	# if we're removing all user specified math values are
331	# slated for removal, then we just filter the flag
332	filter-flags ${orig_mfpmath}
333	else
334	# if we only want to filter some of the user specified
335	# math values, then we replace the current flag
336	replace-flags ${orig_mfpmath} -mfpmath=${new_math}
337	fi
338	return 0
339	}
340
341	# @FUNCTION: strip-flags
342	# @DESCRIPTION:
343	# Strip C[XX]FLAGS of everything except known good/safe flags.
344	strip-flags() {
345	local x y var
346
347	setup-allowed-flags
348
349	set -f # disable pathname expansion
350
351	for var in $(all-flag-vars) ; do
352	local new=()
353
354	for x in ${!var} ; do
355	local flag=${x%%=*}
356	for y in ${ALLOWED_FLAGS} ; do
357	if [[ -z ${flag%%${y}} ]] ; then
358	new+=( "${x}" )
359	break
360	fi
361	done
362	done
363
364	# In case we filtered out all optimization flags fallback to -O2
365	if _is_flagq ${var} "-O" && ! _is_flagq new "-O" ; then
366	new+=( -O2 )
367	fi
368
369	eval export ${var}=\""${new[*]}"\"
370	done
371
372	set +f # re-enable pathname expansion
373
374	return 0
375	}
376
377	test-flag-PROG() {
378	local comp=$1
379	local flag=$2
380
381	[[ -z ${comp} \|\| -z ${flag} ]] && return 1
382
383	# use -c so we can test the assembler as well
384	local PROG=$(tc-get${comp})
385	${PROG} "${flag}" -c -o /dev/null -xc /dev/null \
386	> /dev/null 2>&1
387	}
388
389	# @FUNCTION: test-flag-CC
390	# @USAGE: <flag>
391	# @DESCRIPTION:
392	# Returns shell true if <flag> is supported by the C compiler, else returns shell false.
393	test-flag-CC() { test-flag-PROG "CC" "$1"; }
394
395	# @FUNCTION: test-flag-CXX
396	# @USAGE: <flag>
397	# @DESCRIPTION:
398	# Returns shell true if <flag> is supported by the C++ compiler, else returns shell false.
399	test-flag-CXX() { test-flag-PROG "CXX" "$1"; }
400
401	# @FUNCTION: test-flag-F77
402	# @USAGE: <flag>
403	# @DESCRIPTION:
404	# Returns shell true if <flag> is supported by the Fortran 77 compiler, else returns shell false.
405	test-flag-F77() { test-flag-PROG "F77" "$1"; }
406
407	# @FUNCTION: test-flag-FC
408	# @USAGE: <flag>
409	# @DESCRIPTION:
410	# Returns shell true if <flag> is supported by the Fortran 90 compiler, else returns shell false.
411	test-flag-FC() { test-flag-PROG "FC" "$1"; }
412
413	test-flags-PROG() {
414	local comp=$1
415	local flags
416	local x
417
418	shift
419
420	[[ -z ${comp} ]] && return 1
421
422	for x in "$@" ; do
423	test-flag-${comp} "${x}" && flags="${flags}${flags:+ }${x}"
424	done
425
426	echo "${flags}"
427
428	# Just bail if we dont have any flags
429	[[ -n ${flags} ]]
430	}
431
432	# @FUNCTION: test-flags-CC
433	# @USAGE: <flags>
434	# @DESCRIPTION:
435	# Returns shell true if <flags> are supported by the C compiler, else returns shell false.
436	test-flags-CC() { test-flags-PROG "CC" "$@"; }
437
438	# @FUNCTION: test-flags-CXX
439	# @USAGE: <flags>
440	# @DESCRIPTION:
441	# Returns shell true if <flags> are supported by the C++ compiler, else returns shell false.
442	test-flags-CXX() { test-flags-PROG "CXX" "$@"; }
443
444	# @FUNCTION: test-flags-F77
445	# @USAGE: <flags>
446	# @DESCRIPTION:
447	# Returns shell true if <flags> are supported by the Fortran 77 compiler, else returns shell false.
448	test-flags-F77() { test-flags-PROG "F77" "$@"; }
449
450	# @FUNCTION: test-flags-FC
451	# @USAGE: <flags>
452	# @DESCRIPTION:
453	# Returns shell true if <flags> are supported by the Fortran 90 compiler, else returns shell false.
454	test-flags-FC() { test-flags-PROG "FC" "$@"; }
455
456	# @FUNCTION: test-flags
457	# @USAGE: <flags>
458	# @DESCRIPTION:
459	# Short-hand that should hopefully work for both C and C++ compiler, but
460	# its really only present due to the append-flags() abomination.
461	test-flags() { test-flags-CC "$@"; }
462
463	# @FUNCTION: test_version_info
464	# @USAGE: <version>
465	# @DESCRIPTION:
466	# Returns shell true if the current C compiler version matches <version>, else returns shell false.
467	# Accepts shell globs.
468	test_version_info() {
469	if [[ $($(tc-getCC) --version 2>&1) == $1 ]]; then
470	return 0
471	else
472	return 1
473	fi
474	}
475
476	# @FUNCTION: strip-unsupported-flags
477	# @DESCRIPTION:
478	# Strip {C,CXX,F,FC}FLAGS of any flags not supported by the active toolchain.
479	strip-unsupported-flags() {
480	export CFLAGS=$(test-flags-CC ${CFLAGS})
481	export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS})
482	export FFLAGS=$(test-flags-F77 ${FFLAGS})
483	export FCFLAGS=$(test-flags-FC ${FCFLAGS})
484	}
485
486	# @FUNCTION: get-flag
487	# @USAGE: <flag>
488	# @DESCRIPTION:
489	# Find and echo the value for a particular flag. Accepts shell globs.
490	get-flag() {
491	local f var findflag="$1"
492
493	# this code looks a little flaky but seems to work for
494	# everything we want ...
495	# for example, if CFLAGS="-march=i686":
496	# `get-flag -march` == "-march=i686"
497	# `get-flag march` == "i686"
498	for var in $(all-flag-vars) ; do
499	for f in ${!var} ; do
500	if [ "${f/${findflag}}" != "${f}" ] ; then
501	printf "%s\n" "${f/-${findflag}=}"
502	return 0
503	fi
504	done
505	done
506	return 1
507	}
508
509	# @FUNCTION: has_m64
510	# @DESCRIPTION:
511	# This doesn't test if the flag is accepted, it tests if the flag actually
512	# WORKS. Non-multilib gcc will take both -m32 and -m64. If the flag works
513	# return code is 0, else the return code is 1.
514	has_m64() {
515	eqawarn "${FUNCNAME}: don't use this anymore"
516
517	# this doesnt test if the flag is accepted, it tests if the flag
518	# actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
519	# please dont replace this function with test_flag in some future
520	# clean-up!
521
522	local temp="$(emktemp)"
523	echo "int main() { return(0); }" > "${temp}".c
524	MY_CC=$(tc-getCC)
525	${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
526	local ret=$?
527	rm -f "${temp}".c
528	[[ ${ret} != 1 ]] && return 0
529	return 1
530	}
531
532	has_m32() {
533	die "${FUNCNAME}: don't use this anymore"
534	}
535
536	# @FUNCTION: replace-sparc64-flags
537	# @DESCRIPTION:
538	# Sets mcpu to v8 and uses the original value as mtune if none specified.
539	replace-sparc64-flags() {
540	local SPARC64_CPUS="ultrasparc3 ultrasparc v9"
541
542	if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
543	for x in ${SPARC64_CPUS}; do
544	CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}"
545	done
546	else
547	for x in ${SPARC64_CPUS}; do
548	CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
549	done
550	fi
551
552	if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
553	for x in ${SPARC64_CPUS}; do
554	CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}"
555	done
556	else
557	for x in ${SPARC64_CPUS}; do
558	CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
559	done
560	fi
561
562	export CFLAGS CXXFLAGS
563	}
564
565	# @FUNCTION: append-libs
566	# @USAGE: <libs>
567	# @DESCRIPTION:
568	# Add extra <libs> to the current LIBS.
569	append-libs() {
570	[[ $# -eq 0 ]] && return 0
571	local flag
572	for flag in "$@"; do
573	[[ ${flag} == -l* ]] && flag=${flag#-l}
574	export LIBS="${LIBS} -l${flag}"
575	done
576
577	return 0
578	}
579
580	# @FUNCTION: raw-ldflags
581	# @USAGE: [flags]
582	# @DESCRIPTION:
583	# Turn C style ldflags (-Wl,-foo) into straight ldflags - the results
584	# are suitable for passing directly to 'ld'; note LDFLAGS is usually passed
585	# to gcc where it needs the '-Wl,'.
586	#
587	# If no flags are specified, then default to ${LDFLAGS}.
588	raw-ldflags() {
589	local x input="$@"
590	[[ -z ${input} ]] && input=${LDFLAGS}
591	set --
592	for x in ${input} ; do
593	x=${x#-Wl,}
594	set -- "$@" ${x//,/ }
595	done
596	echo "$@"
597	}
598
599	# @FUNCTION: no-as-needed
600	# @RETURN: Flag to disable asneeded behavior for use with append-ldflags.
601	no-as-needed() {
602	case $($(tc-getLD) -v 2>&1 </dev/null) in
603	GNU) # GNU ld
604	echo "-Wl,--no-as-needed" ;;
605	esac
606	}
607
608	fi