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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.123 - (show annotations) (download)
Sat Jun 7 16:42:32 2008 UTC (6 years, 1 month ago) by flameeyes
Branch: MAIN
Changes since 1.122: +7 -1 lines
Warn when using append-ldflags to pass libraries to link to.

Libraries shouldn't be passed as LDFLAGS, the flags should be passed
before the object files to link, while libraries should be passed
after. Passing libraries through LDFLAGS is one of the causes of
--as-needed failures.

1 # Copyright 1999-2008 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.122 2008/02/18 18:20:47 swegener 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 inherit eutils toolchain-funcs multilib
14
15 ################ DEPRECATED functions ################
16 # The following are still present to avoid breaking existing
17 # code more than necessary; however they are deprecated. Please
18 # use gcc-specs-* from toolchain-funcs.eclass instead, if you
19 # need to know which hardened techs are active in the compiler.
20 # See bug #100974
21 #
22 # has_hardened
23 # has_pie
24 # has_pic
25 # has_ssp_all
26 # has_ssp
27
28
29 # C[XX]FLAGS that we allow in strip-flags
30 # Note: shell globs and character lists are allowed
31 setup-allowed-flags() {
32 if [[ -z ${ALLOWED_FLAGS} ]] ; then
33 export ALLOWED_FLAGS="-pipe"
34 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -O -O0 -O1 -O2 -mcpu -march -mtune"
35 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fstack-protector -fstack-protector-all"
36 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fbounds-checking"
37 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-PIE -fno-pie -fno-unit-at-a-time"
38 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -g -g[0-9] -ggdb -ggdb[0-9] -gstabs -gstabs+"
39 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-ident"
40 export ALLOWED_FLAGS="${ALLOWED_FLAGS} -W* -w"
41 fi
42 # allow a bunch of flags that negate features / control ABI
43 ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-stack-protector -fno-stack-protector-all \
44 -fno-strict-aliasing -fno-bounds-checking"
45 ALLOWED_FLAGS="${ALLOWED_FLAGS} -mregparm -mno-app-regs -mapp-regs \
46 -mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow \
47 -mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 \
48 -msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
49 -mieee -mieee-with-inexact -mschedule \
50 -mtls-direct-seg-refs -mno-tls-direct-seg-refs \
51 -mflat -mno-flat -mno-faster-structs -mfaster-structs \
52 -m32 -m64 -mabi -mlittle-endian -mbig-endian -EL -EB -fPIC \
53 -mlive-g0 -mcmodel -mstack-bias -mno-stack-bias \
54 -msecure-plt -D*"
55
56 # C[XX]FLAGS that we are think is ok, but needs testing
57 # NOTE: currently -Os have issues with gcc3 and K6* arch's
58 export UNSTABLE_FLAGS="-Os -O3 -freorder-blocks"
59 return 0
60 }
61
62 # inverted filters for hardened compiler. This is trying to unpick
63 # the hardened compiler defaults.
64 _filter-hardened() {
65 local f
66 for f in "$@" ; do
67 case "${f}" in
68 # Ideally we should only concern ourselves with PIE flags,
69 # not -fPIC or -fpic, but too many places filter -fPIC without
70 # thinking about -fPIE.
71 -fPIC|-fpic|-fPIE|-fpie|-Wl,pie|-pie)
72 gcc-specs-pie || continue
73 is-flagq -nopie || append-flags -nopie;;
74 -fstack-protector)
75 gcc-specs-ssp || continue
76 is-flagq -fno-stack-protector || append-flags -fno-stack-protector;;
77 -fstack-protector-all)
78 gcc-specs-ssp-to-all || continue
79 is-flagq -fno-stack-protector-all || append-flags -fno-stack-protector-all;;
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 VAL
89 declare -a new
90
91 VAR=$1
92 shift
93 eval VAL=\${${VAR}}
94 for f in ${VAL}; do
95 for x in "$@"; do
96 # Note this should work with globs like -O*
97 [[ ${f} == ${x} ]] && continue 2
98 done
99 eval new\[\${\#new\[@]}]=\${f}
100 done
101 eval export ${VAR}=\${new\[*]}
102 }
103
104 # @FUNCTION: filter-flags
105 # @USAGE: <flags>
106 # @DESCRIPTION:
107 # Remove particular <flags> from {C,CPP,CXX}FLAGS. Accepts shell globs.
108 filter-flags() {
109 _filter-hardened "$@"
110 _filter-var CFLAGS "$@"
111 _filter-var CPPFLAGS "$@"
112 _filter-var CXXFLAGS "$@"
113 return 0
114 }
115
116 # @FUNCTION: filter-lfs-flags
117 # @DESCRIPTION:
118 # Remove flags that enable Large File Support.
119 filter-lfs-flags() {
120 [[ -n $@ ]] && die "filter-lfs-flags takes no arguments"
121 filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
122 }
123
124 # @FUNCTION: append-cppflags
125 # @USAGE: <flags>
126 # @DESCRIPTION:
127 # Add extra <flags> to the current CPPFLAGS.
128 append-cppflags() {
129 [[ -z $* ]] && return 0
130 export CPPFLAGS="${CPPFLAGS} $*"
131 return 0
132 }
133
134 # @FUNCTION: append-lfs-flags
135 # @DESCRIPTION:
136 # Add flags that enable Large File Support.
137 append-lfs-flags() {
138 [[ -n $@ ]] && die "append-lfs-flags takes no arguments"
139 append-cppflags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE
140 }
141
142 # @FUNCTION: append-flags
143 # @USAGE: <flags>
144 # @DESCRIPTION:
145 # Add extra <flags> to your current C[XX]FLAGS.
146 append-flags() {
147 [[ -z $* ]] && return 0
148 export CFLAGS="${CFLAGS} $*"
149 export CXXFLAGS="${CXXFLAGS} $*"
150 return 0
151 }
152
153 # @FUNCTION: replace-flags
154 # @USAGE: <old> <new>
155 # @DESCRIPTION:
156 # Replace the <old> flag with <new>. Accepts shell globs for <old>.
157 replace-flags() {
158 [[ $# != 2 ]] \
159 && echo && eerror "Usage: replace-flags <old flag> <new flag>" \
160 && die "replace-flags takes 2 arguments, not $#"
161
162 local f fset
163 declare -a new_CFLAGS new_CXXFLAGS
164
165 for fset in CFLAGS CXXFLAGS; do
166 # Looping over the flags instead of using a global
167 # substitution ensures that we're working with flag atoms.
168 # Otherwise globs like -O* have the potential to wipe out the
169 # list of flags.
170 for f in ${!fset}; do
171 # Note this should work with globs like -O*
172 [[ ${f} == ${1} ]] && f=${2}
173 eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
174 done
175 eval export ${fset}=\${new_${fset}\[*]}
176 done
177
178 return 0
179 }
180
181 # @FUNCTION: replace-cpu-flags
182 # @USAGE: <old> <new>
183 # @DESCRIPTION:
184 # Replace cpu flags (like -march/-mcpu/-mtune) that select the <old> cpu
185 # with flags that select the <new> cpu. Accepts shell globs for <old>.
186 replace-cpu-flags() {
187 local newcpu="$#" ; newcpu="${!newcpu}"
188 while [ $# -gt 1 ] ; do
189 # quote to make sure that no globbing is done (particularly on
190 # ${oldcpu}) prior to calling replace-flags
191 replace-flags "-march=${1}" "-march=${newcpu}"
192 replace-flags "-mcpu=${1}" "-mcpu=${newcpu}"
193 replace-flags "-mtune=${1}" "-mtune=${newcpu}"
194 shift
195 done
196 return 0
197 }
198
199 _is_flagq() {
200 local x
201 for x in ${!1} ; do
202 [[ ${x} == $2 ]] && return 0
203 done
204 return 1
205 }
206
207 # @FUNCTION: is-flagq
208 # @USAGE: <flag>
209 # @DESCRIPTION:
210 # Returns shell true if <flag> is in C[XX]FLAGS, else returns shell false. Accepts shell globs.
211 is-flagq() {
212 [[ -n $2 ]] && die "Usage: is-flag <flag>"
213 _is_flagq CFLAGS $1 || _is_flagq CXXFLAGS $1
214 }
215
216 # @FUNCTION: is-flag
217 # @USAGE: <flag>
218 # @DESCRIPTION:
219 # Echo's "true" if flag is set in C[XX]FLAGS. Accepts shell globs.
220 is-flag() {
221 is-flagq "$@" && echo true
222 }
223
224 # @FUNCTION: is-ldflagq
225 # @USAGE: <flag>
226 # @DESCRIPTION:
227 # Returns shell true if <flag> is in LDFLAGS, else returns shell false. Accepts shell globs.
228 is-ldflagq() {
229 [[ -n $2 ]] && die "Usage: is-ldflag <flag>"
230 _is_flagq LDFLAGS $1
231 }
232
233 # @FUNCTION: is-ldflag
234 # @USAGE: <flag>
235 # @DESCRIPTION:
236 # Echo's "true" if flag is set in LDFLAGS. Accepts shell globs.
237 is-ldflag() {
238 is-ldflagq "$@" && echo true
239 }
240
241 # @FUNCTION: filter-mfpmath
242 # @USAGE: <math types>
243 # @DESCRIPTION:
244 # Remove specified math types from the fpmath flag. For example, if the user
245 # has -mfpmath=sse,386, running `filter-mfpmath sse` will leave the user with
246 # -mfpmath=386.
247 filter-mfpmath() {
248 local orig_mfpmath new_math prune_math
249
250 # save the original -mfpmath flag
251 orig_mfpmath=$(get-flag -mfpmath)
252 # get the value of the current -mfpmath flag
253 new_math=$(get-flag mfpmath)
254 new_math=" ${new_math//,/ } "
255 # figure out which math values are to be removed
256 prune_math=""
257 for prune_math in "$@" ; do
258 new_math=${new_math/ ${prune_math} / }
259 done
260 new_math=$(echo ${new_math})
261 new_math=${new_math// /,}
262
263 if [[ -z ${new_math} ]] ; then
264 # if we're removing all user specified math values are
265 # slated for removal, then we just filter the flag
266 filter-flags ${orig_mfpmath}
267 else
268 # if we only want to filter some of the user specified
269 # math values, then we replace the current flag
270 replace-flags ${orig_mfpmath} -mfpmath=${new_math}
271 fi
272 return 0
273 }
274
275 # @FUNCTION: strip-flags
276 # @DESCRIPTION:
277 # Strip C[XX]FLAGS of everything except known good/safe flags.
278 strip-flags() {
279 local x y flag NEW_CFLAGS NEW_CXXFLAGS
280
281 setup-allowed-flags
282
283 local NEW_CFLAGS=""
284 local NEW_CXXFLAGS=""
285
286 # Allow unstable C[XX]FLAGS if we are using unstable profile ...
287 if has ~$(tc-arch) ${ACCEPT_KEYWORDS} ; then
288 ALLOWED_FLAGS="${ALLOWED_FLAGS} ${UNSTABLE_FLAGS}"
289 fi
290
291 set -f # disable pathname expansion
292
293 for x in ${CFLAGS}; do
294 for y in ${ALLOWED_FLAGS}; do
295 flag=${x%%=*}
296 if [ "${flag%%${y}}" = "" ] ; then
297 NEW_CFLAGS="${NEW_CFLAGS} ${x}"
298 break
299 fi
300 done
301 done
302
303 for x in ${CXXFLAGS}; do
304 for y in ${ALLOWED_FLAGS}; do
305 flag=${x%%=*}
306 if [ "${flag%%${y}}" = "" ] ; then
307 NEW_CXXFLAGS="${NEW_CXXFLAGS} ${x}"
308 break
309 fi
310 done
311 done
312
313 # In case we filtered out all optimization flags fallback to -O2
314 if [ "${CFLAGS/-O}" != "${CFLAGS}" -a "${NEW_CFLAGS/-O}" = "${NEW_CFLAGS}" ]; then
315 NEW_CFLAGS="${NEW_CFLAGS} -O2"
316 fi
317 if [ "${CXXFLAGS/-O}" != "${CXXFLAGS}" -a "${NEW_CXXFLAGS/-O}" = "${NEW_CXXFLAGS}" ]; then
318 NEW_CXXFLAGS="${NEW_CXXFLAGS} -O2"
319 fi
320
321 set +f # re-enable pathname expansion
322
323 export CFLAGS="${NEW_CFLAGS}"
324 export CXXFLAGS="${NEW_CXXFLAGS}"
325 return 0
326 }
327
328 test-flag-PROG() {
329 local comp=$1
330 local flags="$2"
331
332 [[ -z ${comp} || -z ${flags} ]] && \
333 return 1
334
335 local PROG=$(tc-get${comp})
336 ${PROG} ${flags} -S -o /dev/null -xc /dev/null \
337 > /dev/null 2>&1
338 }
339
340 # @FUNCTION: test-flag-CC
341 # @USAGE: <flag>
342 # @DESCRIPTION:
343 # Returns shell true if <flag> is supported by the C compiler, else returns shell false.
344 test-flag-CC() { test-flag-PROG "CC" "$1"; }
345
346 # @FUNCTION: test-flag-CXX
347 # @USAGE: <flag>
348 # @DESCRIPTION:
349 # Returns shell true if <flag> is supported by the C++ compiler, else returns shell false.
350 test-flag-CXX() { test-flag-PROG "CXX" "$1"; }
351
352 test-flags-PROG() {
353 local comp=$1
354 local flags
355 local x
356
357 shift
358
359 [[ -z ${comp} ]] && return 1
360
361 x=""
362 for x in "$@" ; do
363 test-flag-${comp} "${x}" && flags="${flags}${flags:+ }${x}"
364 done
365
366 echo "${flags}"
367
368 # Just bail if we dont have any flags
369 [[ -n ${flags} ]]
370 }
371
372 # @FUNCTION: test-flags-CC
373 # @USAGE: <flags>
374 # @DESCRIPTION:
375 # Returns shell true if <flags> are supported by the C compiler, else returns shell false.
376 test-flags-CC() { test-flags-PROG "CC" "$@"; }
377
378 # @FUNCTION: test-flags-CXX
379 # @USAGE: <flags>
380 # @DESCRIPTION:
381 # Returns shell true if <flags> are supported by the C++ compiler, else returns shell false.
382 test-flags-CXX() { test-flags-PROG "CXX" "$@"; }
383
384 # @FUNCTION: test-flags
385 # @USAGE: <flags>
386 # @DESCRIPTION:
387 # Short-hand that should hopefully work for both C and C++ compiler, but
388 # its really only present due to the append-flags() abomination.
389 test-flags() { test-flags-CC "$@"; }
390
391 # @FUNCTION: test_flag
392 # @DESCRIPTION:
393 # DEPRICIATED, use test-flags()
394 test_flag() {
395 ewarn "test_flag: deprecated, please use test-flags()!" >&2
396
397 test-flags-CC "$@"
398 }
399
400 # @FUNCTION: test_version_info
401 # @USAGE: <version>
402 # @DESCRIPTION:
403 # Returns shell true if the current C compiler version matches <version>, else returns shell false.
404 # Accepts shell globs.
405 test_version_info() {
406 if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
407 return 0
408 else
409 return 1
410 fi
411 }
412
413 # @FUNCTION: strip-unsupported-flags
414 # @DESCRIPTION:
415 # Strip C[XX]FLAGS of any flags not supported by the active toolchain.
416 strip-unsupported-flags() {
417 export CFLAGS=$(test-flags-CC ${CFLAGS})
418 export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS})
419 }
420
421 # @FUNCTION: get-flag
422 # @USAGE: <flag>
423 # @DESCRIPTION:
424 # Find and echo the value for a particular flag. Accepts shell globs.
425 get-flag() {
426 local f findflag="$1"
427
428 # this code looks a little flaky but seems to work for
429 # everything we want ...
430 # for example, if CFLAGS="-march=i686":
431 # `get-flag -march` == "-march=i686"
432 # `get-flag march` == "i686"
433 for f in ${CFLAGS} ${CXXFLAGS} ; do
434 if [ "${f/${findflag}}" != "${f}" ] ; then
435 printf "%s\n" "${f/-${findflag}=}"
436 return 0
437 fi
438 done
439 return 1
440 }
441
442 # @FUNCTION: has_hardened
443 # @DESCRIPTION:
444 # DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs
445 has_hardened() {
446 ewarn "has_hardened: deprecated, please use gcc-specs-{relro,now}()!" >&2
447
448 test_version_info Hardened && return 0
449 # The specs file wont exist unless gcc has GCC_SPECS support
450 [[ -f ${GCC_SPECS} && ${GCC_SPECS} != ${GCC_SPECS/hardened/} ]]
451 }
452
453 # @FUNCTION: has_pic
454 # @DESCRIPTION:
455 # DEPRECATED - use gcc-specs-pie from toolchain-funcs
456 # indicate whether PIC is set
457 has_pic() {
458 ewarn "has_pic: deprecated, please use gcc-specs-pie()!" >&2
459
460 [[ ${CFLAGS/-fPIC} != ${CFLAGS} || \
461 ${CFLAGS/-fpic} != ${CFLAGS} ]] || \
462 gcc-specs-pie
463 }
464
465 # @FUNCTION: has_pie
466 # @DESCRIPTION:
467 # DEPRECATED - use gcc-specs-pie from toolchain-funcs
468 # indicate whether PIE is set
469 has_pie() {
470 ewarn "has_pie: deprecated, please use gcc-specs-pie()!" >&2
471
472 [[ ${CFLAGS/-fPIE} != ${CFLAGS} || \
473 ${CFLAGS/-fpie} != ${CFLAGS} ]] || \
474 gcc-specs-pie
475 }
476
477 # @FUNCTION: has_ssp_all
478 # @DESCRIPTION:
479 # DEPRECATED - use gcc-specs-ssp from toolchain-funcs
480 # indicate whether code for SSP is being generated for all functions
481 has_ssp_all() {
482 ewarn "has_ssp_all: deprecated, please use gcc-specs-ssp()!" >&2
483
484 # note; this matches only -fstack-protector-all
485 [[ ${CFLAGS/-fstack-protector-all} != ${CFLAGS} || \
486 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP_ALL__) ]] || \
487 gcc-specs-ssp-all
488 }
489
490 # @FUNCTION: has_ssp
491 # @DESCRIPTION:
492 # DEPRECATED - use gcc-specs-ssp from toolchain-funcs
493 # indicate whether code for SSP is being generated
494 has_ssp() {
495 ewarn "has_ssp: deprecated, please use gcc-specs-ssp()!" >&2
496
497 # note; this matches both -fstack-protector and -fstack-protector-all
498 [[ ${CFLAGS/-fstack-protector} != ${CFLAGS} || \
499 -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP__) ]] || \
500 gcc-specs-ssp
501 }
502
503 # @FUNCTION: has_m64
504 # @DESCRIPTION:
505 # This doesn't test if the flag is accepted, it tests if the flag actually
506 # WORKS. Non-multilib gcc will take both -m32 and -m64. If the flag works
507 # return code is 0, else the return code is 1.
508 has_m64() {
509 # this doesnt test if the flag is accepted, it tests if the flag
510 # actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
511 # please dont replace this function with test_flag in some future
512 # clean-up!
513
514 local temp="$(emktemp)"
515 echo "int main() { return(0); }" > "${temp}".c
516 MY_CC=$(tc-getCC)
517 ${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
518 local ret=$?
519 rm -f "${temp}".c
520 [[ ${ret} != 1 ]] && return 0
521 return 1
522 }
523
524 # @FUNCTION: has_m32
525 # @DESCRIPTION:
526 # This doesn't test if the flag is accepted, it tests if the flag actually
527 # WORKS. Non-mulilib gcc will take both -m32 and -64. If the flag works return
528 # code is 0, else return code is 1.
529 has_m32() {
530 # this doesnt test if the flag is accepted, it tests if the flag
531 # actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
532 # please dont replace this function with test_flag in some future
533 # clean-up!
534
535 [ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0
536
537 local temp=$(emktemp)
538 echo "int main() { return(0); }" > "${temp}".c
539 MY_CC=$(tc-getCC)
540 ${MY_CC/ .*/} -m32 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
541 local ret=$?
542 rm -f "${temp}".c
543 [[ ${ret} != 1 ]] && return 0
544 return 1
545 }
546
547 # @FUNCTION: replace-sparc64-flags
548 # @DESCRIPTION:
549 # Sets mcpu to v8 and uses the original value as mtune if none specified.
550 replace-sparc64-flags() {
551 local SPARC64_CPUS="ultrasparc3 ultrasparc v9"
552
553 if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
554 for x in ${SPARC64_CPUS}; do
555 CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}"
556 done
557 else
558 for x in ${SPARC64_CPUS}; do
559 CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
560 done
561 fi
562
563 if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
564 for x in ${SPARC64_CPUS}; do
565 CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}"
566 done
567 else
568 for x in ${SPARC64_CPUS}; do
569 CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
570 done
571 fi
572
573 export CFLAGS CXXFLAGS
574 }
575
576 # @FUNCTION: append-ldflags
577 # @USAGE: <flags>
578 # @DESCRIPTION:
579 # Add extra <flags> to the current LDFLAGS.
580 append-ldflags() {
581 [[ -z $* ]] && return 0
582 local flag
583 for flag in "$@"; do
584 [[ ${flag} == -l* ]] && \
585 ewarn "Appending a library link instruction (${flag}); libraries to link to should not be passed through LDFLAGS"
586 done
587
588 export LDFLAGS="${LDFLAGS} $*"
589 return 0
590 }
591
592 # @FUNCTION: filter-ldflags
593 # @USAGE: <flags>
594 # @DESCRIPTION:
595 # Remove particular <flags> from LDFLAGS. Accepts shell globs.
596 filter-ldflags() {
597 _filter-var LDFLAGS "$@"
598 return 0
599 }
600
601 # @FUNCTION: raw-ldflags
602 # @USAGE: <flags>
603 # @DESCRIPTION:
604 # Turn C style ldflags (-Wl,-foo) into straight ldflags - the results
605 # are suitable for passing directly to 'ld'; note LDFLAGS is usually passed
606 # to gcc where it needs the '-Wl,'.
607 raw-ldflags() {
608 local x input="$@"
609 [[ -z ${input} ]] && input=${LDFLAGS}
610 set --
611 for x in ${input} ; do
612 x=${x#-Wl,}
613 set -- "$@" ${x//,/ }
614 done
615 echo "$@"
616 }
617
618 # @FUNCTION: bindnow-flags
619 # @RETURN: Returns the flags to enable "now" binding in the current selected linker.
620 # @DESCRIPTION:
621 # DEPRECATED - Gets the flags needed for "NOW" binding
622 bindnow-flags() {
623 ewarn "QA: stop using the bindnow-flags function ... simply drop it from your ebuild" >&2
624
625 case $($(tc-getLD) -v 2>&1 </dev/null) in
626 *GNU* | *'with BFD'*) # GNU ld
627 echo "-Wl,-z,now" ;;
628 *Apple*) # Darwin ld
629 echo "-bind_at_load" ;;
630 *)
631 # Some linkers just recognize -V instead of -v
632 case $($(tc-getLD) -V 2>&1 </dev/null) in
633 *Solaris*) # Solaris accept almost the same GNU options
634 echo "-Wl,-z,now" ;;
635 esac
636 ;;
637 esac
638 }
639
640
641 # Some tests for when we screw with things and want to make
642 # sure we didn't break anything
643 #TESTS() {
644 # CFLAGS="-a -b -c=1"
645 # CXXFLAGS="-x -y -z=2"
646 # LDFLAGS="-l -m -n=3"
647 #
648 # die() { exit 1; }
649 # (is-flag 1 2 3) && die
650 # (is-ldflag 1 2 3) && die
651 #
652 # is-flagq -l && die
653 # is-ldflagq -a && die
654 # is-flagq -a || die
655 # is-flagq -x || die
656 # is-ldflagq -n=* || die
657 # is-ldflagq -n && die
658 #
659 # strip-unsupported-flags
660 # [[ ${CFLAGS} == "-c=1" ]] || die
661 # [[ ${CXXFLAGS} == "-y -z=2" ]] || die
662 #
663 # echo "All tests pass"
664 #}
665 #TESTS

  ViewVC Help
Powered by ViewVC 1.1.20