1 # Copyright
(C
) 1999, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
2 # Free Software Foundation
, Inc.
4 # This
program is free software
; you can redistribute it and
/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation
; either version
3 of the License
, or
7 #
(at your option
) any later version.
9 # This
program is distributed in the hope that it will be useful
,
10 # but WITHOUT
ANY WARRANTY
; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License
for more details.
14 # You should have received a copy of the GNU General Public License
15 # along with GCC
; see the file COPYING3.
If not see
16 #
<http
://www.gnu.org
/licenses
/>.
18 # Please email
any bugs
, comments
, and
/or additions to this file to
:
19 # gcc
-patches@gcc.gnu.org
21 # This file defines procs
for determining features supported by the target.
23 # Try to
compile the code given by CONTENTS into an output file of
24 # type TYPE
, where TYPE is as
for target_compile.
Return a list
25 # whose first element contains the compiler messages and whose
26 # second element is the
name of the output file.
28 # BASENAME is a prefix to use
for source and output files.
29 #
If ARGS is not empty
, its first element is a string that
30 # should be added to the command line.
32 # Assume by default that CONTENTS is C code. C
++ code should contain
33 #
"// C++" and Fortran code should contain "! Fortran".
34 proc check_compile
{basename type contents
args} {
37 if { [llength $
args] > 0 } {
38 set options
[list
"additional_flags=[lindex $args 0]"]
42 switch -glob
-- $contents
{
43 "*! Fortran*" { set src ${basename}[pid].f90 }
44 "*// C++*" { set src ${basename}[pid].cc }
45 default
{ set src $
{basename
}[pid
].c
}
47 set compile_type $type
49 assembly
{ set output $
{basename
}[pid
].s
}
50 object
{ set output $
{basename
}[pid
].o
}
51 executable
{ set output $
{basename
}[pid
].exe
}
53 set output $
{basename
}[pid
].s
54 lappend options
"additional_flags=-fdump-$type"
55 set compile_type assembly
61 set lines
[$
{tool
}_target_compile $src $output $compile_type
"$options"]
64 set scan_output $output
65 # Don
't try folding this into the switch above; calling "glob" before the
66 # file is created won't work.
67 if [regexp
"rtl-(.*)" $type dummy rtl_type] {
68 set scan_output
"[glob $src.\[0-9\]\[0-9\]\[0-9\]r.$rtl_type]"
72 return [list $lines $scan_output
]
75 proc current_target_name
{ } {
77 if [info exists target_info
(target
,name)] {
78 set answer $target_info
(target
,name)
85 # Implement an effective
-target check
for property PROP by invoking
86 # the Tcl command
ARGS and seeing
if it returns true.
88 proc check_cached_effective_target
{ prop
args } {
91 set target
[current_target_name
]
92 if {![info exists et_cache
($prop
,target
)]
93 || $et_cache
($prop
,target
) != $target
} {
94 verbose
"check_cached_effective_target $prop: checking $target" 2
95 set et_cache
($prop
,target
) $target
96 set et_cache
($prop
,value
) [uplevel eval $
args]
98 set value $et_cache
($prop
,value
)
99 verbose
"check_cached_effective_target $prop: returning $value for $target" 2
103 # Like check_compile
, but
delete the output file and
return true
if the
104 # compiler printed no messages.
105 proc check_no_compiler_messages_nocache
{args} {
106 set result
[eval check_compile $
args]
107 set lines
[lindex $result
0]
108 set output
[lindex $result
1]
109 remote_file build
delete $output
110 return [string match
"" $lines]
113 # Like check_no_compiler_messages_nocache
, but
cache the result.
114 # PROP is the
property we
're checking, and doubles as a prefix for
115 # temporary filenames.
116 proc check_no_compiler_messages {prop args} {
117 return [check_cached_effective_target $prop {
118 eval [list check_no_compiler_messages_nocache $prop] $args
122 # Like check_compile, but return true if the compiler printed no
123 # messages and if the contents of the output file satisfy PATTERN.
124 # If PATTERN has the form "!REGEXP", the contents satisfy it if they
125 # don't match regular expression REGEXP
, otherwise they satisfy it
126 #
if they
do match regular expression PATTERN.
(PATTERN can start
127 # with something like
"[!]" if the regular expression needs to match
128 #
"!" as the first character.)
130 #
Delete the output file before returning. The other arguments are
131 # as
for check_compile.
132 proc check_no_messages_and_pattern_nocache
{basename pattern
args} {
135 set result
[eval
[list check_compile $basename
] $
args]
136 set lines
[lindex $result
0]
137 set output
[lindex $result
1]
140 if { [string match
"" $lines] } {
141 set chan
[open
"$output"]
142 set invert
[regexp
{^
!(.
*)} $pattern dummy pattern
]
143 set ok
[expr
{ [regexp $pattern
[read $chan
]] != $invert
}]
147 remote_file build
delete $output
151 # Like check_no_messages_and_pattern_nocache
, but
cache the result.
152 # PROP is the
property we
're checking, and doubles as a prefix for
153 # temporary filenames.
154 proc check_no_messages_and_pattern {prop pattern args} {
155 return [check_cached_effective_target $prop {
156 eval [list check_no_messages_and_pattern_nocache $prop $pattern] $args
160 # Try to compile and run an executable from code CONTENTS. Return true
161 # if the compiler reports no messages and if execution "passes" in the
162 # usual DejaGNU sense. The arguments are as for check_compile, with
163 # TYPE implicitly being "executable".
164 proc check_runtime_nocache {basename contents args} {
167 set result [eval [list check_compile $basename executable $contents] $args]
168 set lines [lindex $result 0]
169 set output [lindex $result 1]
172 if { [string match "" $lines] } {
173 # No error messages, everything is OK.
174 set result [remote_load target "./$output" "" ""]
175 set status [lindex $result 0]
176 verbose "check_runtime_nocache $basename: status is <$status>" 2
177 if { $status == "pass" } {
181 remote_file build delete $output
185 # Like check_runtime_nocache, but cache the result. PROP is the
186 # property we're checking
, and doubles as a prefix
for temporary
188 proc check_runtime
{prop
args} {
191 return [check_cached_effective_target $prop
{
192 eval
[list check_runtime_nocache $prop
] $
args
196 ###############################
197 # proc check_weak_available
{ }
198 ###############################
200 # weak symbols are only supported in some configs
/object formats
201 # this proc returns
1 if they
're supported, 0 if they're not
, or
-1 if unsure
203 proc check_weak_available
{ } {
204 global target_triplet
207 # All mips targets should support it
209 if { [ string first
"mips" $target_cpu ] >= 0 } {
213 # All solaris2 targets should support it
215 if { [regexp
".*-solaris2.*" $target_triplet] } {
219 # DEC OSF
/1/Digital UNIX
/Tru64 UNIX supports it
221 if { [regexp
"alpha.*osf.*" $target_triplet] } {
225 # Windows targets Cygwin and MingW32 support it
227 if { [regexp
".*mingw32|.*cygwin" $target_triplet] } {
231 # HP
-UX
10.X doesn
't support it
233 if { [istarget "hppa*-*-hpux10*"] } {
237 # ELF and ECOFF support it. a.out does with gas/gld but may also with
238 # other linkers, so we should try it
240 set objformat [gcc_target_object_format]
248 unknown { return -1 }
253 ###############################
254 # proc check_weak_override_available { }
255 ###############################
257 # Like check_weak_available, but return 0 if weak symbol definitions
258 # cannot be overridden.
260 proc check_weak_override_available { } {
261 if { [istarget "*-*-mingw*"] } {
264 return [check_weak_available]
267 ###############################
268 # proc check_visibility_available { what_kind }
269 ###############################
271 # The visibility attribute is only support in some object formats
272 # This proc returns 1 if it is supported, 0 if not.
273 # The argument is the kind of visibility, default/protected/hidden/internal.
275 proc check_visibility_available { what_kind } {
277 global target_triplet
279 # On NetWare, support makes no sense.
280 if { [istarget *-*-netware*] } {
284 if [string match "" $what_kind] { set what_kind "hidden" }
286 return [check_no_compiler_messages visibility_available_$what_kind object "
287 void f() __attribute__((visibility(\"$what_kind\")));
292 ###############################
293 # proc check_alias_available { }
294 ###############################
296 # Determine if the target toolchain supports the alias attribute.
298 # Returns 2 if the target supports aliases. Returns 1 if the target
299 # only supports weak aliased. Returns 0 if the target does not
300 # support aliases at all. Returns -1 if support for aliases could not
303 proc check_alias_available { } {
304 global alias_available_saved
307 if [info exists alias_available_saved] {
308 verbose "check_alias_available returning saved $alias_available_saved" 2
312 verbose "check_alias_available compiling testfile $src" 2
313 set f [open $src "w"]
314 # Compile a small test program. The definition of "g" is
315 # necessary to keep the Solaris assembler from complaining
317 puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
318 puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
320 set lines [${tool}_target_compile $src $obj object ""]
322 remote_file build delete $obj
324 if [string match "" $lines] then {
325 # No error messages, everything is OK.
326 set alias_available_saved 2
328 if [regexp "alias definitions not supported" $lines] {
329 verbose "check_alias_available target does not support aliases" 2
331 set objformat [gcc_target_object_format]
333 if { $objformat == "elf" } {
334 verbose "check_alias_available but target uses ELF format, so it ought to" 2
335 set alias_available_saved -1
337 set alias_available_saved 0
340 if [regexp "only weak aliases are supported" $lines] {
341 verbose "check_alias_available target supports only weak aliases" 2
342 set alias_available_saved 1
344 set alias_available_saved -1
349 verbose "check_alias_available returning $alias_available_saved" 2
352 return $alias_available_saved
355 # Returns true if --gc-sections is supported on the target.
357 proc check_gc_sections_available { } {
358 global gc_sections_available_saved
361 if {![info exists gc_sections_available_saved]} {
362 # Some targets don't support gc
-sections despite whatever
's
363 # advertised by ld's options.
364 if { [istarget alpha
*-*-*]
365 ||
[istarget ia64
-*-*] } {
366 set gc_sections_available_saved
0
370 # elf2flt uses
-q
(--emit
-relocs
), which is incompatible with
372 if { [board_info target
exists ldflags
]
373 && [regexp
" -elf2flt\[ =\]" " [board_info target ldflags] "] } {
374 set gc_sections_available_saved
0
378 # VxWorks kernel modules are relocatable objects linked with
-r
,
379 #
while RTP executables are linked with
-q
(--emit
-relocs
).
380 # Both of these options are incompatible with
--gc
-sections.
381 if { [istarget
*-*-vxworks
*] } {
382 set gc_sections_available_saved
0
386 # Check
if the
ld used by gcc supports
--gc
-sections.
387 set gcc_spec
[$
{tool
}_target_compile
"-dumpspecs" "" "none" ""]
388 regsub
".*\n\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
389 set gcc_ld
[lindex
[$
{tool
}_target_compile
"-print-prog-name=$linker" "" "none" ""] 0]
390 set ld_output
[remote_exec host
"$gcc_ld" "--help"]
391 if { [ string first
"--gc-sections" $ld_output ] >= 0 } {
392 set gc_sections_available_saved
1
394 set gc_sections_available_saved
0
397 return $gc_sections_available_saved
400 #
Return 1 if according to target_info struct and explicit target list
401 # target is supposed to support trampolines.
403 proc check_effective_target_trampolines
{ } {
404 if [target_info
exists no_trampolines
] {
407 if { [istarget avr
-*-*]
408 ||
[istarget hppa2.0w
-hp
-hpux11.23
]
409 ||
[istarget hppa64
-hp
-hpux11.23
] } {
415 #
Return 1 if according to target_info struct and explicit target list
416 # target is supposed to keep null pointer checks. This could be due to
417 # use of option fno
-delete-null
-pointer
-checks or hardwired in target.
419 proc check_effective_target_keeps_null_pointer_checks
{ } {
420 if [target_info
exists keeps_null_pointer_checks
] {
423 if { [istarget avr
-*-*] } {
429 #
Return true
if profiling is supported
on the target.
431 proc check_profiling_available
{ test_what
} {
432 global profiling_available_saved
434 verbose
"Profiling argument is <$test_what>" 1
436 # These conditions depend
on the
argument so examine them before
437 # looking at the
cache variable.
439 # Support
for -p
on solaris2 relies
on mcrt1.o which comes with the
440 # vendor compiler. We cannot reliably predict the directory where the
441 # vendor compiler
(and thus mcrt1.o
) is installed so we can
't
442 # necessarily find mcrt1.o even if we have it.
443 if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
447 # Support for -p on irix relies on libprof1.a which doesn't appear to
448 # exist
on any irix6
system currently posting testsuite results.
449 # Support
for -pg
on irix relies
on gcrt1.o which doesn
't exist yet.
450 # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
451 if { [istarget mips*-*-irix*]
452 && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
456 # We don't yet support profiling
for MIPS16.
457 if { [istarget mips
*-*-*]
458 && ![check_effective_target_nomips16
]
459 && ([lindex $test_what
1] == "-p"
460 ||
[lindex $test_what
1] == "-pg") } {
464 # MinGW does not support
-p.
465 if { [istarget
*-*-mingw
*] && [lindex $test_what
1] == "-p" } {
469 # uClibc does not have gcrt1.o.
470 if { [check_effective_target_uclibc
]
471 && ([lindex $test_what
1] == "-p"
472 ||
[lindex $test_what
1] == "-pg") } {
476 # Now examine the
cache variable.
477 if {![info exists profiling_available_saved
]} {
478 # Some targets don
't have any implementation of __bb_init_func or are
479 # missing other needed machinery.
480 if { [istarget mmix-*-*]
481 || [istarget arm*-*-eabi*]
482 || [istarget picochip-*-*]
483 || [istarget *-*-netware*]
484 || [istarget arm*-*-elf]
485 || [istarget arm*-*-symbianelf*]
486 || [istarget avr-*-*]
487 || [istarget bfin-*-*]
488 || [istarget powerpc-*-eabi*]
489 || [istarget cris-*-*]
490 || [istarget crisv32-*-*]
491 || [istarget fido-*-elf]
492 || [istarget h8300-*-*]
493 || [istarget m32c-*-elf]
494 || [istarget m68k-*-elf]
495 || [istarget m68k-*-uclinux*]
496 || [istarget mips*-*-elf*]
497 || [istarget xstormy16-*]
498 || [istarget xtensa*-*-elf]
499 || [istarget *-*-rtems*]
500 || [istarget *-*-vxworks*] } {
501 set profiling_available_saved 0
503 set profiling_available_saved 1
507 return $profiling_available_saved
510 # Check to see if a target is "freestanding". This is as per the definition
511 # in Section 4 of C99 standard. Effectively, it is a target which supports no
512 # extra headers or libraries other than what is considered essential.
513 proc check_effective_target_freestanding { } {
514 if { [istarget picochip-*-*] } then {
521 # Return 1 if target has packed layout of structure members by
522 # default, 0 otherwise. Note that this is slightly different than
523 # whether the target has "natural alignment": both attributes may be
526 proc check_effective_target_default_packed { } {
527 return [check_no_compiler_messages default_packed assembly {
528 struct x { char a; long b; } c;
529 int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
533 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined. See
534 # documentation, where the test also comes from.
536 proc check_effective_target_pcc_bitfield_type_matters { } {
537 # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
538 # bitfields
, but let
's stick to the example code from the docs.
539 return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
540 struct foo1 { char x; char :0; char y; };
541 struct foo2 { char x; int :0; char y; };
542 int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
546 # Return 1 if thread local storage (TLS) is supported, 0 otherwise.
548 # This won't change
for different subtargets so
cache the result.
550 proc check_effective_target_tls
{} {
551 return [check_no_compiler_messages tls assembly
{
553 int f
(void
) { return i
; }
554 void g
(int j
) { i
= j
; }
558 #
Return 1 if *native
* thread local storage
(TLS
) is supported
, 0 otherwise.
560 # This won
't change for different subtargets so cache the result.
562 proc check_effective_target_tls_native {} {
563 # VxWorks uses emulated TLS machinery, but with non-standard helper
564 # functions, so we fail to automatically detect it.
565 global target_triplet
566 if { [regexp ".*-.*-vxworks.*" $target_triplet] } {
570 return [check_no_messages_and_pattern tls_native "!emutls" assembly {
572 int f (void) { return i; }
573 void g (int j) { i = j; }
577 # Return 1 if TLS executables can run correctly, 0 otherwise.
579 # This won't change
for different subtargets so
cache the result.
581 proc check_effective_target_tls_runtime
{} {
582 return [check_runtime tls_runtime
{
583 __thread
int thr
= 0;
584 int main
(void
) { return thr
; }
588 #
Return 1 if compilation with
-fgraphite is error
-free
for trivial
591 proc check_effective_target_fgraphite
{} {
592 return [check_no_compiler_messages fgraphite object
{
597 #
Return 1 if compilation with
-fopenmp is error
-free
for trivial
600 proc check_effective_target_fopenmp
{} {
601 return [check_no_compiler_messages fopenmp object
{
606 #
Return 1 if compilation with
-pthread is error
-free
for trivial
609 proc check_effective_target_pthread
{} {
610 return [check_no_compiler_messages pthread object
{
615 #
Return 1 if the target supports
-fstack
-protector
616 proc check_effective_target_fstack_protector
{} {
617 return [check_runtime fstack_protector
{
618 int main
(void
) { return 0; }
619 } "-fstack-protector"]
622 #
Return 1 if compilation with
-freorder
-blocks
-and
-partition is error
-free
623 #
for trivial code
, 0 otherwise.
625 proc check_effective_target_freorder
{} {
626 return [check_no_compiler_messages freorder object
{
628 } "-freorder-blocks-and-partition"]
631 #
Return 1 if -fpic and
-fPIC are supported
, as in no warnings or errors
632 # emitted
, 0 otherwise. Whether a shared library can actually be built is
633 # out of scope
for this test.
635 proc check_effective_target_fpic
{ } {
636 # Note that M68K has a multilib that supports
-fpic but not
637 #
-fPIC
, so we need to check both. We test with a
program that
638 # requires GOT references.
639 foreach
arg {fpic fPIC
} {
640 if [check_no_compiler_messages $
arg object
{
641 extern
int foo
(void
); extern
int bar
;
642 int baz
(void
) { return foo
() + bar
; }
650 #
Return true
if the target supports
-mpaired
-single
(as used
on MIPS
).
652 proc check_effective_target_mpaired_single
{ } {
653 return [check_no_compiler_messages mpaired_single object
{
658 #
Return true
if the target has access to FPU instructions.
660 proc check_effective_target_hard_float
{ } {
661 if { [istarget mips
*-*-*] } {
662 return [check_no_compiler_messages hard_float assembly
{
663 #
if (defined __mips_soft_float || defined __mips16
)
669 # The generic test equates hard_float with
"no call for adding doubles".
670 return [check_no_messages_and_pattern hard_float
"!\\(call" rtl-expand {
671 double a
(double b
, double c
) { return b
+ c
; }
675 #
Return true
if the target is a
64-bit MIPS target.
677 proc check_effective_target_mips64
{ } {
678 return [check_no_compiler_messages mips64 assembly
{
685 #
Return true
if the target is a MIPS target that does not produce
688 proc check_effective_target_nomips16
{ } {
689 return [check_no_compiler_messages nomips16 object
{
693 /* A cheap way of testing
for -mflip
-mips16.
*/
694 void foo
(void
) { asm
("addiu $20,$20,1"); }
695 void bar
(void
) { asm
("addiu $20,$20,1"); }
700 # Add the options needed
for MIPS16 function attributes. At the moment
,
701 # we don
't support MIPS16 PIC.
703 proc add_options_for_mips16_attribute { flags } {
704 return "$flags -mno-abicalls -fno-pic -DMIPS16=__attribute__((mips16))"
707 # Return true if we can force a mode that allows MIPS16 code generation.
708 # We don't support MIPS16 PIC
, and only support MIPS16
-mhard
-float
711 proc check_effective_target_mips16_attribute
{ } {
712 return [check_no_compiler_messages mips16_attribute assembly
{
716 #
if defined __mips_hard_float \
717 && (!defined _ABIO32 || _MIPS_SIM
!= _ABIO32
) \
718 && (!defined _ABIO64 || _MIPS_SIM
!= _ABIO64
)
721 } [add_options_for_mips16_attribute
""]]
724 #
Return 1 if the current multilib does not generate PIC by default.
726 proc check_effective_target_nonpic
{ } {
727 return [check_no_compiler_messages nonpic assembly
{
734 #
Return 1 if the target does not use a
status wrapper.
736 proc check_effective_target_unwrapped
{ } {
737 if { [target_info needs_status_wrapper
] != "" \
738 && [target_info needs_status_wrapper
] != "0" } {
744 #
Return true
if iconv is supported
on the target. In particular IBM1047.
746 proc check_iconv_available
{ test_what
} {
749 #
If the tool configuration file has not
set libiconv
, try
"-liconv"
750 if { ![info exists libiconv
] } {
751 set libiconv
"-liconv"
753 set test_what
[lindex $test_what
1]
754 return [check_runtime_nocache $test_what
[subst
{
760 cd
= iconv_open
("$test_what", "UTF-8");
761 if (cd
== (iconv_t
) -1)
768 #
Return true
if named sections are supported
on this target.
770 proc check_named_sections_available
{ } {
771 return [check_no_compiler_messages named_sections assembly
{
772 int __attribute__
((section
("whatever"))) foo;
776 #
Return 1 if the target supports Fortran real kinds larger than real
(8),
779 # When the target
name changes
, replace the cached result.
781 proc check_effective_target_fortran_large_real
{ } {
782 return [check_no_compiler_messages fortran_large_real executable
{
784 integer,parameter
:: k
= selected_real_kind
(precision
(0.0_8
) + 1)
791 #
Return 1 if the target supports Fortran
integer kinds larger than
792 #
integer(8), 0 otherwise.
794 # When the target
name changes
, replace the cached result.
796 proc check_effective_target_fortran_large_int
{ } {
797 return [check_no_compiler_messages fortran_large_int executable
{
799 integer,parameter
:: k
= selected_int_kind
(range
(0_8
) + 1)
805 #
Return 1 if the target supports Fortran
integer(16), 0 otherwise.
807 # When the target
name changes
, replace the cached result.
809 proc check_effective_target_fortran_integer_16
{ } {
810 return [check_no_compiler_messages fortran_integer_16 executable
{
817 #
Return 1 if we can statically link libgfortran
, 0 otherwise.
819 # When the target
name changes
, replace the cached result.
821 proc check_effective_target_static_libgfortran
{ } {
822 return [check_no_compiler_messages static_libgfortran executable
{
829 #
Return 1 if the target supports executing
750CL paired
-single instructions
, 0
830 # otherwise.
Cache the result.
832 proc check_750cl_hw_available
{ } {
833 return [check_cached_effective_target
750cl_hw_available
{
834 #
If this is not the right target
then we can skip the test.
835 if { ![istarget powerpc
-*paired
*] } {
838 check_runtime_nocache
750cl_hw_available
{
842 asm volatile
("ps_mul v0,v0,v0");
844 asm volatile
("ps_mul 0,0,0");
853 #
Return 1 if the target supports executing SSE2 instructions
, 0
854 # otherwise.
Cache the result.
856 proc check_sse2_hw_available
{ } {
857 return [check_cached_effective_target sse2_hw_available
{
858 #
If this is not the right target
then we can skip the test.
859 if { !([istarget x86_64
-*-*] ||
[istarget i?
86-*-*]) } {
862 check_runtime_nocache sse2_hw_available
{
866 unsigned
int eax
, ebx
, ecx
, edx
= 0;
867 if (__get_cpuid
(1, &eax
, &ebx
, &ecx
, &edx
))
868 return !(edx
& bit_SSE2
);
876 #
Return 1 if the target supports executing AltiVec instructions
, 0
877 # otherwise.
Cache the result.
879 proc check_vmx_hw_available
{ } {
880 return [check_cached_effective_target vmx_hw_available
{
881 # Some simulators are known to not support VMX instructions.
882 if { [istarget powerpc
-*-eabi
] ||
[istarget powerpc
*-*-eabispe
] } {
885 # Most targets don
't require special flags for this test case, but
887 if { [istarget *-*-darwin*]
888 || [istarget *-*-aix*] } {
889 set options "-maltivec"
893 check_runtime_nocache vmx_hw_available {
897 asm volatile ("vor v0,v0,v0");
899 asm volatile ("vor 0,0,0");
908 # Return 1 if the target supports executing AltiVec and Cell PPU
909 # instructions, 0 otherwise. Cache the result.
911 proc check_effective_target_cell_hw { } {
912 return [check_cached_effective_target cell_hw_available {
913 # Some simulators are known to not support VMX and PPU instructions.
914 if { [istarget powerpc-*-eabi*] } {
917 # Most targets don't require special flags
for this test
918 # case
, but Darwin and AIX
do.
919 if { [istarget
*-*-darwin
*]
920 ||
[istarget
*-*-aix
*] } {
921 set options
"-maltivec -mcpu=cell"
923 set options
"-mcpu=cell"
925 check_runtime_nocache cell_hw_available
{
929 asm volatile
("vor v0,v0,v0");
930 asm volatile
("lvlx v0,r0,r0");
932 asm volatile
("vor 0,0,0");
933 asm volatile
("lvlx 0,0,0");
942 #
Return 1 if the target supports executing
64-bit instructions
, 0
943 # otherwise.
Cache the result.
945 proc check_effective_target_powerpc64
{ } {
946 global powerpc64_available_saved
949 if [info exists powerpc64_available_saved
] {
950 verbose
"check_effective_target_powerpc64 returning saved $powerpc64_available_saved" 2
952 set powerpc64_available_saved
0
954 # Some simulators are known to not support powerpc64 instructions.
955 if { [istarget powerpc
-*-eabi
*] ||
[istarget powerpc
-ibm
-aix
*] } {
956 verbose
"check_effective_target_powerpc64 returning 0" 2
957 return $powerpc64_available_saved
960 #
Set up
, compile, and
execute a test
program containing a
64-bit
961 # instruction.
Include the current process ID in the file
962 # names to prevent conflicts with invocations
for multiple
967 set f
[open $src
"w"]
968 puts $f
"int main() {"
969 puts $f
"#ifdef __MACH__"
970 puts $f
" asm volatile (\"extsw r0,r0\");"
972 puts $f
" asm volatile (\"extsw 0,0\");"
974 puts $f
" return 0; }"
977 set opts
"additional_flags=-mcpu=G5"
979 verbose
"check_effective_target_powerpc64 compiling testfile $src" 2
980 set lines
[$
{tool
}_target_compile $src $exe executable
"$opts"]
983 if [string match
"" $lines] then {
984 # No error message
, compilation succeeded.
985 set result
[$
{tool
}_load
"./$exe" "" ""]
986 set status [lindex $result
0]
987 remote_file build
delete $exe
988 verbose
"check_effective_target_powerpc64 testfile status is <$status>" 2
990 if { $
status == "pass" } then {
991 set powerpc64_available_saved
1
994 verbose
"check_effective_target_powerpc64 testfile compilation failed" 2
998 return $powerpc64_available_saved
1001 # GCC
3.4.0 for powerpc64
-*-linux
* included an ABI fix
for passing
1002 # complex float arguments. This affects gfortran tests that
call cabsf
1003 # in libm built by an earlier compiler.
Return 1 if libm uses the same
1004 #
argument passing as the compiler under test
, 0 otherwise.
1006 # When the target
name changes
, replace the cached result.
1008 proc check_effective_target_broken_cplxf_arg
{ } {
1009 return [check_cached_effective_target broken_cplxf_arg
{
1010 # Skip the work
for targets known not to be affected.
1011 if { ![istarget powerpc64
-*-linux
*] } {
1013 } elseif
{ ![is
-effective
-target lp64
] } {
1016 check_runtime_nocache broken_cplxf_arg
{
1017 #
include <complex.h
>
1018 extern void abort
(void
);
1019 float fabsf
(float
);
1020 float cabsf
(_Complex float
);
1027 if (fabsf
(f
- 5.0) > 0.0001)
1036 proc check_alpha_max_hw_available
{ } {
1037 return [check_runtime alpha_max_hw_available
{
1038 int main
() { return __builtin_alpha_amask
(1<<8) != 0; }
1042 # Returns true iff the FUNCTION is available
on the target
system.
1043 #
(This is essentially a Tcl implementation of Autoconf
's
1046 proc check_function_available { function } {
1047 return [check_no_compiler_messages ${function}_available \
1053 int main () { $function (); }
1057 # Returns true iff "fork" is available on the target system.
1059 proc check_fork_available {} {
1060 return [check_function_available "fork"]
1063 # Returns true iff "mkfifo" is available on the target system.
1065 proc check_mkfifo_available {} {
1066 if {[istarget *-*-cygwin*]} {
1067 # Cygwin has mkfifo, but support is incomplete.
1071 return [check_function_available "mkfifo"]
1074 # Returns true iff "__cxa_atexit" is used on the target system.
1076 proc check_cxa_atexit_available { } {
1077 return [check_cached_effective_target cxa_atexit_available {
1078 if { [istarget "hppa*-*-hpux10*"] } {
1079 # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
1082 check_runtime_nocache cxa_atexit_available
{
1085 static unsigned
int count;
1102 Y
() { f
(); count = 2; }
1111 int main
() { return 0; }
1118 #
Return 1 if we
're generating 32-bit code using default options, 0
1121 proc check_effective_target_ilp32 { } {
1122 return [check_no_compiler_messages ilp32 object {
1123 int dummy[sizeof (int) == 4
1124 && sizeof (void *) == 4
1125 && sizeof (long) == 4 ? 1 : -1];
1129 # Return 1 if we're generating
32-bit or larger integers using default
1130 # options
, 0 otherwise.
1132 proc check_effective_target_int32plus
{ } {
1133 return [check_no_compiler_messages int32plus object
{
1134 int dummy
[sizeof
(int) >= 4 ?
1 : -1];
1138 #
Return 1 if we
're generating 32-bit or larger pointers using default
1139 # options, 0 otherwise.
1141 proc check_effective_target_ptr32plus { } {
1142 return [check_no_compiler_messages ptr32plus object {
1143 int dummy[sizeof (void *) >= 4 ? 1 : -1];
1147 # Return 1 if we support 32-bit or larger array and structure sizes
1148 # using default options, 0 otherwise.
1150 proc check_effective_target_size32plus { } {
1151 return [check_no_compiler_messages size32plus object {
1156 # Returns 1 if we're generating
16-bit or smaller integers with the
1157 # default options
, 0 otherwise.
1159 proc check_effective_target_int16
{ } {
1160 return [check_no_compiler_messages int16 object
{
1161 int dummy
[sizeof
(int) < 4 ?
1 : -1];
1165 #
Return 1 if we
're generating 64-bit code using default options, 0
1168 proc check_effective_target_lp64 { } {
1169 return [check_no_compiler_messages lp64 object {
1170 int dummy[sizeof (int) == 4
1171 && sizeof (void *) == 8
1172 && sizeof (long) == 8 ? 1 : -1];
1176 # Return 1 if we're generating
64-bit code using default llp64 options
,
1179 proc check_effective_target_llp64
{ } {
1180 return [check_no_compiler_messages llp64 object
{
1181 int dummy
[sizeof
(int) == 4
1182 && sizeof
(void
*) == 8
1183 && sizeof
(long long
) == 8
1184 && sizeof
(long
) == 4 ?
1 : -1];
1188 #
Return 1 if the target supports long double larger than double
,
1191 proc check_effective_target_large_long_double
{ } {
1192 return [check_no_compiler_messages large_long_double object
{
1193 int dummy
[sizeof
(long double
) > sizeof
(double
) ?
1 : -1];
1197 #
Return 1 if the target supports compiling fixed
-point
,
1200 proc check_effective_target_fixed_point
{ } {
1201 return [check_no_compiler_messages fixed_point object
{
1202 _Sat _Fract x
; _Sat _Accum y
;
1206 #
Return 1 if the target supports compiling decimal floating point
,
1209 proc check_effective_target_dfp_nocache
{ } {
1210 verbose
"check_effective_target_dfp_nocache: compiling source" 2
1211 set ret
[check_no_compiler_messages_nocache dfp object
{
1212 _Decimal32 x
; _Decimal64 y
; _Decimal128 z
;
1214 verbose
"check_effective_target_dfp_nocache: returning $ret" 2
1218 proc check_effective_target_dfprt_nocache
{ } {
1219 return [check_runtime_nocache dfprt
{
1220 _Decimal32 x
= 1.2df
; _Decimal64 y
= 2.3dd
; _Decimal128 z
;
1221 int main
() { z
= x
+ y
; return 0; }
1225 #
Return 1 if the target supports compiling Decimal Floating Point
,
1228 # This won
't change for different subtargets so cache the result.
1230 proc check_effective_target_dfp { } {
1231 return [check_cached_effective_target dfp {
1232 check_effective_target_dfp_nocache
1236 # Return 1 if the target supports linking and executing Decimal Floating
1237 # Point, # 0 otherwise.
1239 # This won't change
for different subtargets so
cache the result.
1241 proc check_effective_target_dfprt
{ } {
1242 return [check_cached_effective_target dfprt
{
1243 check_effective_target_dfprt_nocache
1247 #
Return 1 if the target needs a command line
argument to enable a SIMD
1250 proc check_effective_target_vect_cmdline_needed
{ } {
1251 global et_vect_cmdline_needed_saved
1252 global et_vect_cmdline_needed_target_name
1254 if { ![info exists et_vect_cmdline_needed_target_name
] } {
1255 set et_vect_cmdline_needed_target_name
""
1258 #
If the target has changed since we
set the cached value
, clear it.
1259 set current_target
[current_target_name
]
1260 if { $current_target
!= $et_vect_cmdline_needed_target_name
} {
1261 verbose
"check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target'" 2
1262 set et_vect_cmdline_needed_target_name $current_target
1263 if { [info exists et_vect_cmdline_needed_saved
] } {
1264 verbose
"check_effective_target_vect_cmdline_needed: removing cached result" 2
1265 unset et_vect_cmdline_needed_saved
1269 if [info exists et_vect_cmdline_needed_saved
] {
1270 verbose
"check_effective_target_vect_cmdline_needed: using cached result" 2
1272 set et_vect_cmdline_needed_saved
1
1273 if { [istarget ia64
-*-*]
1274 ||
(([istarget x86_64
-*-*] ||
[istarget i?
86-*-*])
1275 && [check_effective_target_lp64
])
1276 ||
([istarget powerpc
*-*-*]
1277 && ([check_effective_target_powerpc_spe
]
1278 ||
[check_effective_target_powerpc_altivec
]))
1279 ||
[istarget spu
-*-*]
1280 ||
([istarget arm
*-*-*] && [check_effective_target_arm_neon
]) } {
1281 set et_vect_cmdline_needed_saved
0
1285 verbose
"check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1286 return $et_vect_cmdline_needed_saved
1289 #
Return 1 if the target supports hardware vectors of
int, 0 otherwise.
1291 # This won
't change for different subtargets so cache the result.
1293 proc check_effective_target_vect_int { } {
1294 global et_vect_int_saved
1296 if [info exists et_vect_int_saved] {
1297 verbose "check_effective_target_vect_int: using cached result" 2
1299 set et_vect_int_saved 0
1300 if { [istarget i?86-*-*]
1301 || ([istarget powerpc*-*-*]
1302 && ![istarget powerpc-*-linux*paired*])
1303 || [istarget spu-*-*]
1304 || [istarget x86_64-*-*]
1305 || [istarget sparc*-*-*]
1306 || [istarget alpha*-*-*]
1307 || [istarget ia64-*-*]
1308 || [check_effective_target_arm32] } {
1309 set et_vect_int_saved 1
1313 verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1314 return $et_vect_int_saved
1317 # Return 1 if the target supports int->float conversion
1320 proc check_effective_target_vect_intfloat_cvt { } {
1321 global et_vect_intfloat_cvt_saved
1323 if [info exists et_vect_intfloat_cvt_saved] {
1324 verbose "check_effective_target_vect_intfloat_cvt: using cached result" 2
1326 set et_vect_intfloat_cvt_saved 0
1327 if { [istarget i?86-*-*]
1328 || ([istarget powerpc*-*-*]
1329 && ![istarget powerpc-*-linux*paired*])
1330 || [istarget x86_64-*-*] } {
1331 set et_vect_intfloat_cvt_saved 1
1335 verbose "check_effective_target_vect_intfloat_cvt: returning $et_vect_intfloat_cvt_saved" 2
1336 return $et_vect_intfloat_cvt_saved
1340 # Return 1 if the target supports float->int conversion
1343 proc check_effective_target_vect_floatint_cvt { } {
1344 global et_vect_floatint_cvt_saved
1346 if [info exists et_vect_floatint_cvt_saved] {
1347 verbose "check_effective_target_vect_floatint_cvt: using cached result" 2
1349 set et_vect_floatint_cvt_saved 0
1350 if { [istarget i?86-*-*]
1351 || ([istarget powerpc*-*-*]
1352 && ![istarget powerpc-*-linux*paired*])
1353 || [istarget x86_64-*-*] } {
1354 set et_vect_floatint_cvt_saved 1
1358 verbose "check_effective_target_vect_floatint_cvt: returning $et_vect_floatint_cvt_saved" 2
1359 return $et_vect_floatint_cvt_saved
1362 # Return 1 is this is an arm target using 32-bit instructions
1363 proc check_effective_target_arm32 { } {
1364 return [check_no_compiler_messages arm32 assembly {
1365 #if !defined(__arm__) || (defined(__thumb__) && !defined(__thumb2__))
1371 # Return 1 if this is an ARM target supporting -mfpu=vfp
1372 # -mfloat-abi=softfp. Some multilibs may be incompatible with these
1375 proc check_effective_target_arm_vfp_ok { } {
1376 if { [check_effective_target_arm32] } {
1377 return [check_no_compiler_messages arm_vfp_ok object {
1379 } "-mfpu=vfp -mfloat-abi=softfp"]
1385 # Return 1 if this is an ARM target supporting -mfpu=neon
1386 # -mfloat-abi=softfp. Some multilibs may be incompatible with these
1389 proc check_effective_target_arm_neon_ok { } {
1390 if { [check_effective_target_arm32] } {
1391 return [check_no_compiler_messages arm_neon_ok object {
1393 } "-mfpu=neon -mfloat-abi=softfp"]
1399 # Return 1 is this is an ARM target where -mthumb causes Thumb-1 to be
1402 proc check_effective_target_arm_thumb1_ok { } {
1403 return [check_no_compiler_messages arm_thumb1_ok assembly {
1404 #if !defined(__arm__) || !defined(__thumb__) || defined(__thumb2__)
1410 # Return 1 if the target supports executing NEON instructions, 0
1411 # otherwise. Cache the result.
1413 proc check_effective_target_arm_neon_hw { } {
1414 return [check_runtime arm_neon_hw_available {
1418 long long a = 0, b = 1;
1419 asm ("vorr %P0, %P1, %P2"
1421 : "0" (a), "w" (b));
1424 } "-mfpu=neon -mfloat-abi=softfp"]
1427 # Return 1 if this is a ARM target with NEON enabled.
1429 proc check_effective_target_arm_neon { } {
1430 if { [check_effective_target_arm32] } {
1431 return [check_no_compiler_messages arm_neon object {
1432 #ifndef __ARM_NEON__
1443 # Return 1 if this a Loongson-2E or -2F target using an ABI that supports
1444 # the Loongson vector modes.
1446 proc check_effective_target_mips_loongson { } {
1447 return [check_no_compiler_messages loongson assembly {
1448 #if !defined(__mips_loongson_vector_rev)
1454 # Return 1 if this is an ARM target that adheres to the ABI for the ARM
1457 proc check_effective_target_arm_eabi { } {
1458 return [check_no_compiler_messages arm_eabi object {
1459 #ifndef __ARM_EABI__
1467 # Return 1 if this is a PowerPC target with floating-point registers.
1469 proc check_effective_target_powerpc_fprs { } {
1470 if { [istarget powerpc*-*-*]
1471 || [istarget rs6000-*-*] } {
1472 return [check_no_compiler_messages powerpc_fprs object {
1484 # Return 1 if this is a PowerPC target with hardware double-precision
1487 proc check_effective_target_powerpc_hard_double { } {
1488 if { [istarget powerpc*-*-*]
1489 || [istarget rs6000-*-*] } {
1490 return [check_no_compiler_messages powerpc_hard_double object {
1502 # Return 1 if this is a PowerPC target supporting -maltivec.
1504 proc check_effective_target_powerpc_altivec_ok { } {
1505 if { ([istarget powerpc*-*-*]
1506 && ![istarget powerpc-*-linux*paired*])
1507 || [istarget rs6000-*-*] } {
1508 # AltiVec is not supported on AIX before 5.3.
1509 if { [istarget powerpc*-*-aix4*]
1510 || [istarget powerpc*-*-aix5.1*]
1511 || [istarget powerpc*-*-aix5.2*] } {
1514 return [check_no_compiler_messages powerpc_altivec_ok object {
1522 # Return 1 if this is a PowerPC target supporting -mcpu=cell.
1524 proc check_effective_target_powerpc_ppu_ok { } {
1525 if [check_effective_target_powerpc_altivec_ok] {
1526 return [check_no_compiler_messages cell_asm_available object {
1529 asm volatile ("lvlx v0,v0,v0");
1531 asm volatile ("lvlx 0,0,0");
1541 # Return 1 if this is a PowerPC target that supports SPU.
1543 proc check_effective_target_powerpc_spu { } {
1544 if [istarget powerpc*-*-linux*] {
1545 return [check_effective_target_powerpc_altivec_ok]
1551 # Return 1 if this is a PowerPC SPE target. The check includes options
1552 # specified by dg-options for this test, so don't
cache the result.
1554 proc check_effective_target_powerpc_spe_nocache
{ } {
1555 if { [istarget powerpc
*-*-*] } {
1556 return [check_no_compiler_messages_nocache powerpc_spe object
{
1562 } [current_compiler_flags
]]
1568 #
Return 1 if this is a PowerPC target with SPE enabled.
1570 proc check_effective_target_powerpc_spe
{ } {
1571 if { [istarget powerpc
*-*-*] } {
1572 return [check_no_compiler_messages powerpc_spe object
{
1584 #
Return 1 if this is a PowerPC target with Altivec enabled.
1586 proc check_effective_target_powerpc_altivec
{ } {
1587 if { [istarget powerpc
*-*-*] } {
1588 return [check_no_compiler_messages powerpc_altivec object
{
1600 #
Return 1 if this is a PowerPC
405 target. The check includes options
1601 # specified by dg
-options
for this test
, so don
't cache the result.
1603 proc check_effective_target_powerpc_405_nocache { } {
1604 if { [istarget powerpc*-*-*] || [istarget rs6000-*-*] } {
1605 return [check_no_compiler_messages_nocache powerpc_405 object {
1611 } [current_compiler_flags]]
1617 # Return 1 if this is a SPU target with a toolchain that
1618 # supports automatic overlay generation.
1620 proc check_effective_target_spu_auto_overlay { } {
1621 if { [istarget spu*-*-elf*] } {
1622 return [check_no_compiler_messages spu_auto_overlay executable {
1624 } "-Wl,--auto-overlay" ]
1630 # The VxWorks SPARC simulator accepts only EM_SPARC executables and
1631 # chokes on EM_SPARC32PLUS or EM_SPARCV9 executables. Return 1 if the
1632 # test environment appears to run executables on such a simulator.
1634 proc check_effective_target_ultrasparc_hw { } {
1635 return [check_runtime ultrasparc_hw {
1636 int main() { return 0; }
1637 } "-mcpu=ultrasparc"]
1640 # Return 1 if the target supports hardware vector shift operation.
1642 proc check_effective_target_vect_shift { } {
1643 global et_vect_shift_saved
1645 if [info exists et_vect_shift_saved] {
1646 verbose "check_effective_target_vect_shift: using cached result" 2
1648 set et_vect_shift_saved 0
1649 if { ([istarget powerpc*-*-*]
1650 && ![istarget powerpc-*-linux*paired*])
1651 || [istarget ia64-*-*]
1652 || [istarget i?86-*-*]
1653 || [istarget x86_64-*-*]
1654 || [check_effective_target_arm32] } {
1655 set et_vect_shift_saved 1
1659 verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1660 return $et_vect_shift_saved
1663 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1665 # This can change for different subtargets so do not cache the result.
1667 proc check_effective_target_vect_long { } {
1668 if { [istarget i?86-*-*]
1669 || (([istarget powerpc*-*-*]
1670 && ![istarget powerpc-*-linux*paired*])
1671 && [check_effective_target_ilp32])
1672 || [istarget x86_64-*-*]
1673 || [check_effective_target_arm32]
1674 || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1680 verbose "check_effective_target_vect_long: returning $answer" 2
1684 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1686 # This won't change
for different subtargets so
cache the result.
1688 proc check_effective_target_vect_float
{ } {
1689 global et_vect_float_saved
1691 if [info exists et_vect_float_saved
] {
1692 verbose
"check_effective_target_vect_float: using cached result" 2
1694 set et_vect_float_saved
0
1695 if { [istarget i?
86-*-*]
1696 ||
[istarget powerpc
*-*-*]
1697 ||
[istarget spu
-*-*]
1698 ||
[istarget mipsisa64
*-*-*]
1699 ||
[istarget x86_64
-*-*]
1700 ||
[istarget ia64
-*-*]
1701 ||
[check_effective_target_arm32
] } {
1702 set et_vect_float_saved
1
1706 verbose
"check_effective_target_vect_float: returning $et_vect_float_saved" 2
1707 return $et_vect_float_saved
1710 #
Return 1 if the target supports hardware vectors of double
, 0 otherwise.
1712 # This won
't change for different subtargets so cache the result.
1714 proc check_effective_target_vect_double { } {
1715 global et_vect_double_saved
1717 if [info exists et_vect_double_saved] {
1718 verbose "check_effective_target_vect_double: using cached result" 2
1720 set et_vect_double_saved 0
1721 if { [istarget i?86-*-*]
1722 || [istarget x86_64-*-*]
1723 || [istarget spu-*-*] } {
1724 set et_vect_double_saved 1
1728 verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1729 return $et_vect_double_saved
1732 # Return 1 if the target supports hardware vectors of long long, 0 otherwise.
1734 # This won't change
for different subtargets so
cache the result.
1736 proc check_effective_target_vect_long_long
{ } {
1737 global et_vect_long_long_saved
1739 if [info exists et_vect_long_long_saved
] {
1740 verbose
"check_effective_target_vect_long_long: using cached result" 2
1742 set et_vect_long_long_saved
0
1743 if { [istarget i?
86-*-*]
1744 ||
[istarget x86_64
-*-*] } {
1745 set et_vect_long_long_saved
1
1749 verbose
"check_effective_target_vect_long_long: returning $et_vect_long_long_saved" 2
1750 return $et_vect_long_long_saved
1754 #
Return 1 if the target plus current options does not support a vector
1755 #
max instruction
on "int", 0 otherwise.
1757 # This won
't change for different subtargets so cache the result.
1759 proc check_effective_target_vect_no_int_max { } {
1760 global et_vect_no_int_max_saved
1762 if [info exists et_vect_no_int_max_saved] {
1763 verbose "check_effective_target_vect_no_int_max: using cached result" 2
1765 set et_vect_no_int_max_saved 0
1766 if { [istarget sparc*-*-*]
1767 || [istarget spu-*-*]
1768 || [istarget alpha*-*-*] } {
1769 set et_vect_no_int_max_saved 1
1772 verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1773 return $et_vect_no_int_max_saved
1776 # Return 1 if the target plus current options does not support a vector
1777 # add instruction on "int", 0 otherwise.
1779 # This won't change
for different subtargets so
cache the result.
1781 proc check_effective_target_vect_no_int_add
{ } {
1782 global et_vect_no_int_add_saved
1784 if [info exists et_vect_no_int_add_saved
] {
1785 verbose
"check_effective_target_vect_no_int_add: using cached result" 2
1787 set et_vect_no_int_add_saved
0
1788 # Alpha only supports vector add
on V8QI and V4HI.
1789 if { [istarget alpha
*-*-*] } {
1790 set et_vect_no_int_add_saved
1
1793 verbose
"check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1794 return $et_vect_no_int_add_saved
1797 #
Return 1 if the target plus current options does not support vector
1798 # bitwise instructions
, 0 otherwise.
1800 # This won
't change for different subtargets so cache the result.
1802 proc check_effective_target_vect_no_bitwise { } {
1803 global et_vect_no_bitwise_saved
1805 if [info exists et_vect_no_bitwise_saved] {
1806 verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1808 set et_vect_no_bitwise_saved 0
1810 verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1811 return $et_vect_no_bitwise_saved
1814 # Return 1 if the target plus current options supports vector permutation,
1817 # This won't change
for different subtargets so
cache the result.
1819 proc check_effective_target_vect_perm
{ } {
1822 if [info exists et_vect_perm_saved
] {
1823 verbose
"check_effective_target_vect_perm: using cached result" 2
1825 set et_vect_perm_saved
0
1826 if { [istarget powerpc
*-*-*]
1827 ||
[istarget spu
-*-*] } {
1828 set et_vect_perm_saved
1
1831 verbose
"check_effective_target_vect_perm: returning $et_vect_perm_saved" 2
1832 return $et_vect_perm_saved
1836 #
Return 1 if the target plus current options supports a vector
1837 # widening summation of
*short
* args into
*int* result
, 0 otherwise.
1838 # A target can also support this widening summation
if it can support
1839 # promotion
(unpacking
) from shorts to ints.
1841 # This won
't change for different subtargets so cache the result.
1843 proc check_effective_target_vect_widen_sum_hi_to_si { } {
1844 global et_vect_widen_sum_hi_to_si
1846 if [info exists et_vect_widen_sum_hi_to_si_saved] {
1847 verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
1849 set et_vect_widen_sum_hi_to_si_saved [check_effective_target_vect_unpack]
1850 if { [istarget powerpc*-*-*]
1851 || [istarget ia64-*-*] } {
1852 set et_vect_widen_sum_hi_to_si_saved 1
1855 verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
1856 return $et_vect_widen_sum_hi_to_si_saved
1859 # Return 1 if the target plus current options supports a vector
1860 # widening summation of *char* args into *short* result, 0 otherwise.
1861 # A target can also support this widening summation if it can support
1862 # promotion (unpacking) from chars to shorts.
1864 # This won't change
for different subtargets so
cache the result.
1866 proc check_effective_target_vect_widen_sum_qi_to_hi
{ } {
1867 global et_vect_widen_sum_qi_to_hi
1869 if [info exists et_vect_widen_sum_qi_to_hi_saved
] {
1870 verbose
"check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
1872 set et_vect_widen_sum_qi_to_hi_saved
0
1873 if { [check_effective_target_vect_unpack
]
1874 ||
[istarget ia64
-*-*] } {
1875 set et_vect_widen_sum_qi_to_hi_saved
1
1878 verbose
"check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
1879 return $et_vect_widen_sum_qi_to_hi_saved
1882 #
Return 1 if the target plus current options supports a vector
1883 # widening summation of
*char
* args into
*int* result
, 0 otherwise.
1885 # This won
't change for different subtargets so cache the result.
1887 proc check_effective_target_vect_widen_sum_qi_to_si { } {
1888 global et_vect_widen_sum_qi_to_si
1890 if [info exists et_vect_widen_sum_qi_to_si_saved] {
1891 verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
1893 set et_vect_widen_sum_qi_to_si_saved 0
1894 if { [istarget powerpc*-*-*] } {
1895 set et_vect_widen_sum_qi_to_si_saved 1
1898 verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
1899 return $et_vect_widen_sum_qi_to_si_saved
1902 # Return 1 if the target plus current options supports a vector
1903 # widening multiplication of *char* args into *short* result, 0 otherwise.
1904 # A target can also support this widening multplication if it can support
1905 # promotion (unpacking) from chars to shorts, and vect_short_mult (non-widening
1906 # multiplication of shorts).
1908 # This won't change
for different subtargets so
cache the result.
1911 proc check_effective_target_vect_widen_mult_qi_to_hi
{ } {
1912 global et_vect_widen_mult_qi_to_hi
1914 if [info exists et_vect_widen_mult_qi_to_hi_saved
] {
1915 verbose
"check_effective_target_vect_widen_mult_qi_to_hi: using cached result" 2
1917 if { [check_effective_target_vect_unpack
]
1918 && [check_effective_target_vect_short_mult
] } {
1919 set et_vect_widen_mult_qi_to_hi_saved
1
1921 set et_vect_widen_mult_qi_to_hi_saved
0
1923 if { [istarget powerpc
*-*-*] } {
1924 set et_vect_widen_mult_qi_to_hi_saved
1
1927 verbose
"check_effective_target_vect_widen_mult_qi_to_hi: returning $et_vect_widen_mult_qi_to_hi_saved" 2
1928 return $et_vect_widen_mult_qi_to_hi_saved
1931 #
Return 1 if the target plus current options supports a vector
1932 # widening multiplication of
*short
* args into
*int* result
, 0 otherwise.
1933 # A target can also support this widening multplication
if it can support
1934 # promotion
(unpacking
) from shorts to ints
, and vect_int_mult
(non
-widening
1935 # multiplication of ints
).
1937 # This won
't change for different subtargets so cache the result.
1940 proc check_effective_target_vect_widen_mult_hi_to_si { } {
1941 global et_vect_widen_mult_hi_to_si
1943 if [info exists et_vect_widen_mult_hi_to_si_saved] {
1944 verbose "check_effective_target_vect_widen_mult_hi_to_si: using cached result" 2
1946 if { [check_effective_target_vect_unpack]
1947 && [check_effective_target_vect_int_mult] } {
1948 set et_vect_widen_mult_hi_to_si_saved 1
1950 set et_vect_widen_mult_hi_to_si_saved 0
1952 if { [istarget powerpc*-*-*]
1953 || [istarget spu-*-*]
1954 || [istarget i?86-*-*]
1955 || [istarget x86_64-*-*] } {
1956 set et_vect_widen_mult_hi_to_si_saved 1
1959 verbose "check_effective_target_vect_widen_mult_hi_to_si: returning $et_vect_widen_mult_hi_to_si_saved" 2
1960 return $et_vect_widen_mult_hi_to_si_saved
1963 # Return 1 if the target plus current options supports a vector
1964 # dot-product of signed chars, 0 otherwise.
1966 # This won't change
for different subtargets so
cache the result.
1968 proc check_effective_target_vect_sdot_qi
{ } {
1969 global et_vect_sdot_qi
1971 if [info exists et_vect_sdot_qi_saved
] {
1972 verbose
"check_effective_target_vect_sdot_qi: using cached result" 2
1974 set et_vect_sdot_qi_saved
0
1976 verbose
"check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1977 return $et_vect_sdot_qi_saved
1980 #
Return 1 if the target plus current options supports a vector
1981 # dot
-product of unsigned chars
, 0 otherwise.
1983 # This won
't change for different subtargets so cache the result.
1985 proc check_effective_target_vect_udot_qi { } {
1986 global et_vect_udot_qi
1988 if [info exists et_vect_udot_qi_saved] {
1989 verbose "check_effective_target_vect_udot_qi: using cached result" 2
1991 set et_vect_udot_qi_saved 0
1992 if { [istarget powerpc*-*-*] } {
1993 set et_vect_udot_qi_saved 1
1996 verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1997 return $et_vect_udot_qi_saved
2000 # Return 1 if the target plus current options supports a vector
2001 # dot-product of signed shorts, 0 otherwise.
2003 # This won't change
for different subtargets so
cache the result.
2005 proc check_effective_target_vect_sdot_hi
{ } {
2006 global et_vect_sdot_hi
2008 if [info exists et_vect_sdot_hi_saved
] {
2009 verbose
"check_effective_target_vect_sdot_hi: using cached result" 2
2011 set et_vect_sdot_hi_saved
0
2012 if { ([istarget powerpc
*-*-*] && ![istarget powerpc
-*-linux
*paired
*])
2013 ||
[istarget i?
86-*-*]
2014 ||
[istarget x86_64
-*-*] } {
2015 set et_vect_sdot_hi_saved
1
2018 verbose
"check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
2019 return $et_vect_sdot_hi_saved
2022 #
Return 1 if the target plus current options supports a vector
2023 # dot
-product of unsigned shorts
, 0 otherwise.
2025 # This won
't change for different subtargets so cache the result.
2027 proc check_effective_target_vect_udot_hi { } {
2028 global et_vect_udot_hi
2030 if [info exists et_vect_udot_hi_saved] {
2031 verbose "check_effective_target_vect_udot_hi: using cached result" 2
2033 set et_vect_udot_hi_saved 0
2034 if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*]) } {
2035 set et_vect_udot_hi_saved 1
2038 verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
2039 return $et_vect_udot_hi_saved
2043 # Return 1 if the target plus current options supports a vector
2044 # demotion (packing) of shorts (to chars) and ints (to shorts)
2045 # using modulo arithmetic, 0 otherwise.
2047 # This won't change
for different subtargets so
cache the result.
2049 proc check_effective_target_vect_pack_trunc
{ } {
2050 global et_vect_pack_trunc
2052 if [info exists et_vect_pack_trunc_saved
] {
2053 verbose
"check_effective_target_vect_pack_trunc: using cached result" 2
2055 set et_vect_pack_trunc_saved
0
2056 if { ([istarget powerpc
*-*-*] && ![istarget powerpc
-*-linux
*paired
*])
2057 ||
[istarget i?
86-*-*]
2058 ||
[istarget x86_64
-*-*]
2059 ||
[istarget spu
-*-*] } {
2060 set et_vect_pack_trunc_saved
1
2063 verbose
"check_effective_target_vect_pack_trunc: returning $et_vect_pack_trunc_saved" 2
2064 return $et_vect_pack_trunc_saved
2067 #
Return 1 if the target plus current options supports a vector
2068 # promotion
(unpacking
) of chars
(to shorts
) and shorts
(to ints
), 0 otherwise.
2070 # This won
't change for different subtargets so cache the result.
2072 proc check_effective_target_vect_unpack { } {
2073 global et_vect_unpack
2075 if [info exists et_vect_unpack_saved] {
2076 verbose "check_effective_target_vect_unpack: using cached result" 2
2078 set et_vect_unpack_saved 0
2079 if { ([istarget powerpc*-*-*] && ![istarget powerpc-*paired*])
2080 || [istarget i?86-*-*]
2081 || [istarget x86_64-*-*]
2082 || [istarget spu-*-*] } {
2083 set et_vect_unpack_saved 1
2086 verbose "check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2
2087 return $et_vect_unpack_saved
2090 # Return 1 if the target plus current options does not guarantee
2091 # that its STACK_BOUNDARY is >= the reguired vector alignment.
2093 # This won't change
for different subtargets so
cache the result.
2095 proc check_effective_target_unaligned_stack
{ } {
2096 global et_unaligned_stack_saved
2098 if [info exists et_unaligned_stack_saved
] {
2099 verbose
"check_effective_target_unaligned_stack: using cached result" 2
2101 set et_unaligned_stack_saved
0
2103 verbose
"check_effective_target_unaligned_stack: returning $et_unaligned_stack_saved" 2
2104 return $et_unaligned_stack_saved
2107 #
Return 1 if the target plus current options does not support a vector
2108 # alignment mechanism
, 0 otherwise.
2110 # This won
't change for different subtargets so cache the result.
2112 proc check_effective_target_vect_no_align { } {
2113 global et_vect_no_align_saved
2115 if [info exists et_vect_no_align_saved] {
2116 verbose "check_effective_target_vect_no_align: using cached result" 2
2118 set et_vect_no_align_saved 0
2119 if { [istarget mipsisa64*-*-*]
2120 || [istarget sparc*-*-*]
2121 || [istarget ia64-*-*]
2122 || [check_effective_target_arm32] } {
2123 set et_vect_no_align_saved 1
2126 verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
2127 return $et_vect_no_align_saved
2130 # Return 1 if arrays are aligned to the vector alignment
2131 # boundary, 0 otherwise.
2133 # This won't change
for different subtargets so
cache the result.
2135 proc check_effective_target_vect_aligned_arrays
{ } {
2136 global et_vect_aligned_arrays
2138 if [info exists et_vect_aligned_arrays_saved
] {
2139 verbose
"check_effective_target_vect_aligned_arrays: using cached result" 2
2141 set et_vect_aligned_arrays_saved
0
2142 if { (([istarget x86_64
-*-*]
2143 ||
[istarget i?
86-*-*]) && [is
-effective
-target lp64
])
2144 ||
[istarget spu
-*-*] } {
2145 set et_vect_aligned_arrays_saved
1
2148 verbose
"check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
2149 return $et_vect_aligned_arrays_saved
2152 #
Return 1 if types of size
32 bit or less are naturally aligned
2153 #
(aligned to their type
-size
), 0 otherwise.
2155 # This won
't change for different subtargets so cache the result.
2157 proc check_effective_target_natural_alignment_32 { } {
2158 global et_natural_alignment_32
2160 if [info exists et_natural_alignment_32_saved] {
2161 verbose "check_effective_target_natural_alignment_32: using cached result" 2
2163 # FIXME: 32bit powerpc: guaranteed only if MASK_ALIGN_NATURAL/POWER.
2164 set et_natural_alignment_32_saved 1
2165 if { ([istarget *-*-darwin*] && [is-effective-target lp64]) } {
2166 set et_natural_alignment_32_saved 0
2169 verbose "check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
2170 return $et_natural_alignment_32_saved
2173 # Return 1 if types of size 64 bit or less are naturally aligned (aligned to their
2174 # type-size), 0 otherwise.
2176 # This won't change
for different subtargets so
cache the result.
2178 proc check_effective_target_natural_alignment_64
{ } {
2179 global et_natural_alignment_64
2181 if [info exists et_natural_alignment_64_saved
] {
2182 verbose
"check_effective_target_natural_alignment_64: using cached result" 2
2184 set et_natural_alignment_64_saved
0
2185 if { ([is
-effective
-target lp64
] && ![istarget
*-*-darwin
*])
2186 ||
[istarget spu
-*-*] } {
2187 set et_natural_alignment_64_saved
1
2190 verbose
"check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
2191 return $et_natural_alignment_64_saved
2194 #
Return 1 if vector alignment
(for types of size
32 bit or less
) is reachable
, 0 otherwise.
2196 # This won
't change for different subtargets so cache the result.
2198 proc check_effective_target_vector_alignment_reachable { } {
2199 global et_vector_alignment_reachable
2201 if [info exists et_vector_alignment_reachable_saved] {
2202 verbose "check_effective_target_vector_alignment_reachable: using cached result" 2
2204 if { [check_effective_target_vect_aligned_arrays]
2205 || [check_effective_target_natural_alignment_32] } {
2206 set et_vector_alignment_reachable_saved 1
2208 set et_vector_alignment_reachable_saved 0
2211 verbose "check_effective_target_vector_alignment_reachable: returning $et_vector_alignment_reachable_saved" 2
2212 return $et_vector_alignment_reachable_saved
2215 # Return 1 if vector alignment for 64 bit is reachable, 0 otherwise.
2217 # This won't change
for different subtargets so
cache the result.
2219 proc check_effective_target_vector_alignment_reachable_for_64bit
{ } {
2220 global et_vector_alignment_reachable_for_64bit
2222 if [info exists et_vector_alignment_reachable_for_64bit_saved
] {
2223 verbose
"check_effective_target_vector_alignment_reachable_for_64bit: using cached result" 2
2225 if { [check_effective_target_vect_aligned_arrays
]
2226 ||
[check_effective_target_natural_alignment_64
] } {
2227 set et_vector_alignment_reachable_for_64bit_saved
1
2229 set et_vector_alignment_reachable_for_64bit_saved
0
2232 verbose
"check_effective_target_vector_alignment_reachable_for_64bit: returning $et_vector_alignment_reachable_for_64bit_saved" 2
2233 return $et_vector_alignment_reachable_for_64bit_saved
2236 #
Return 1 if the target supports vector conditional operations
, 0 otherwise.
2238 proc check_effective_target_vect_condition
{ } {
2239 global et_vect_cond_saved
2241 if [info exists et_vect_cond_saved
] {
2242 verbose
"check_effective_target_vect_cond: using cached result" 2
2244 set et_vect_cond_saved
0
2245 if { [istarget powerpc
*-*-*]
2246 ||
[istarget ia64
-*-*]
2247 ||
[istarget i?
86-*-*]
2248 ||
[istarget spu
-*-*]
2249 ||
[istarget x86_64
-*-*] } {
2250 set et_vect_cond_saved
1
2254 verbose
"check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
2255 return $et_vect_cond_saved
2258 #
Return 1 if the target supports vector char multiplication
, 0 otherwise.
2260 proc check_effective_target_vect_char_mult
{ } {
2261 global et_vect_char_mult_saved
2263 if [info exists et_vect_char_mult_saved
] {
2264 verbose
"check_effective_target_vect_char_mult: using cached result" 2
2266 set et_vect_char_mult_saved
0
2267 if { [istarget ia64
-*-*]
2268 ||
[istarget i?
86-*-*]
2269 ||
[istarget x86_64
-*-*] } {
2270 set et_vect_char_mult_saved
1
2274 verbose
"check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
2275 return $et_vect_char_mult_saved
2278 #
Return 1 if the target supports vector short multiplication
, 0 otherwise.
2280 proc check_effective_target_vect_short_mult
{ } {
2281 global et_vect_short_mult_saved
2283 if [info exists et_vect_short_mult_saved
] {
2284 verbose
"check_effective_target_vect_short_mult: using cached result" 2
2286 set et_vect_short_mult_saved
0
2287 if { [istarget ia64
-*-*]
2288 ||
[istarget spu
-*-*]
2289 ||
[istarget i?
86-*-*]
2290 ||
[istarget x86_64
-*-*]
2291 ||
[istarget powerpc
*-*-*]
2292 ||
[check_effective_target_arm32
] } {
2293 set et_vect_short_mult_saved
1
2297 verbose
"check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
2298 return $et_vect_short_mult_saved
2301 #
Return 1 if the target supports vector
int multiplication
, 0 otherwise.
2303 proc check_effective_target_vect_int_mult
{ } {
2304 global et_vect_int_mult_saved
2306 if [info exists et_vect_int_mult_saved
] {
2307 verbose
"check_effective_target_vect_int_mult: using cached result" 2
2309 set et_vect_int_mult_saved
0
2310 if { ([istarget powerpc
*-*-*] && ![istarget powerpc
-*-linux
*paired
*])
2311 ||
[istarget spu
-*-*]
2312 ||
[istarget i?
86-*-*]
2313 ||
[istarget x86_64
-*-*]
2314 ||
[check_effective_target_arm32
] } {
2315 set et_vect_int_mult_saved
1
2319 verbose
"check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
2320 return $et_vect_int_mult_saved
2323 #
Return 1 if the target supports vector even
/odd elements extraction
, 0 otherwise.
2325 proc check_effective_target_vect_extract_even_odd
{ } {
2326 global et_vect_extract_even_odd_saved
2328 if [info exists et_vect_extract_even_odd_saved
] {
2329 verbose
"check_effective_target_vect_extract_even_odd: using cached result" 2
2331 set et_vect_extract_even_odd_saved
0
2332 if { [istarget powerpc
*-*-*]
2333 ||
[istarget spu
-*-*] } {
2334 set et_vect_extract_even_odd_saved
1
2338 verbose
"check_effective_target_vect_extract_even_odd: returning $et_vect_extract_even_odd_saved" 2
2339 return $et_vect_extract_even_odd_saved
2342 #
Return 1 if the target supports vector even
/odd elements extraction of
2343 # vectors with SImode elements or larger
, 0 otherwise.
2345 proc check_effective_target_vect_extract_even_odd_wide
{ } {
2346 global et_vect_extract_even_odd_wide_saved
2348 if [info exists et_vect_extract_even_odd_wide_saved
] {
2349 verbose
"check_effective_target_vect_extract_even_odd_wide: using cached result" 2
2351 set et_vect_extract_even_odd_wide_saved
0
2352 if { [istarget powerpc
*-*-*]
2353 ||
[istarget i?
86-*-*]
2354 ||
[istarget x86_64
-*-*]
2355 ||
[istarget spu
-*-*] } {
2356 set et_vect_extract_even_odd_wide_saved
1
2360 verbose
"check_effective_target_vect_extract_even_wide_odd: returning $et_vect_extract_even_odd_wide_saved" 2
2361 return $et_vect_extract_even_odd_wide_saved
2364 #
Return 1 if the target supports vector interleaving
, 0 otherwise.
2366 proc check_effective_target_vect_interleave
{ } {
2367 global et_vect_interleave_saved
2369 if [info exists et_vect_interleave_saved
] {
2370 verbose
"check_effective_target_vect_interleave: using cached result" 2
2372 set et_vect_interleave_saved
0
2373 if { [istarget powerpc
*-*-*]
2374 ||
[istarget i?
86-*-*]
2375 ||
[istarget x86_64
-*-*]
2376 ||
[istarget spu
-*-*] } {
2377 set et_vect_interleave_saved
1
2381 verbose
"check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
2382 return $et_vect_interleave_saved
2385 #
Return 1 if the target supports vector interleaving and extract even
/odd
, 0 otherwise.
2386 proc check_effective_target_vect_strided
{ } {
2387 global et_vect_strided_saved
2389 if [info exists et_vect_strided_saved
] {
2390 verbose
"check_effective_target_vect_strided: using cached result" 2
2392 set et_vect_strided_saved
0
2393 if { [check_effective_target_vect_interleave
]
2394 && [check_effective_target_vect_extract_even_odd
] } {
2395 set et_vect_strided_saved
1
2399 verbose
"check_effective_target_vect_strided: returning $et_vect_strided_saved" 2
2400 return $et_vect_strided_saved
2403 #
Return 1 if the target supports vector interleaving and extract even
/odd
2404 #
for wide element types
, 0 otherwise.
2405 proc check_effective_target_vect_strided_wide
{ } {
2406 global et_vect_strided_wide_saved
2408 if [info exists et_vect_strided_wide_saved
] {
2409 verbose
"check_effective_target_vect_strided_wide: using cached result" 2
2411 set et_vect_strided_wide_saved
0
2412 if { [check_effective_target_vect_interleave
]
2413 && [check_effective_target_vect_extract_even_odd_wide
] } {
2414 set et_vect_strided_wide_saved
1
2418 verbose
"check_effective_target_vect_strided_wide: returning $et_vect_strided_wide_saved" 2
2419 return $et_vect_strided_wide_saved
2422 #
Return 1 if the target supports section
-anchors
2424 proc check_effective_target_section_anchors
{ } {
2425 global et_section_anchors_saved
2427 if [info exists et_section_anchors_saved
] {
2428 verbose
"check_effective_target_section_anchors: using cached result" 2
2430 set et_section_anchors_saved
0
2431 if { [istarget powerpc
*-*-*] } {
2432 set et_section_anchors_saved
1
2436 verbose
"check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
2437 return $et_section_anchors_saved
2440 #
Return 1 if the target supports atomic operations
on "int" and "long".
2442 proc check_effective_target_sync_int_long
{ } {
2443 global et_sync_int_long_saved
2445 if [info exists et_sync_int_long_saved
] {
2446 verbose
"check_effective_target_sync_int_long: using cached result" 2
2448 set et_sync_int_long_saved
0
2449 # This is intentionally powerpc but not rs6000
, rs6000 doesn
't have the
2450 # load-reserved/store-conditional instructions.
2451 if { [istarget ia64-*-*]
2452 || [istarget i?86-*-*]
2453 || [istarget x86_64-*-*]
2454 || [istarget alpha*-*-*]
2455 || [istarget s390*-*-*]
2456 || [istarget powerpc*-*-*]
2457 || [istarget sparc64-*-*]
2458 || [istarget sparcv9-*-*]
2459 || [istarget mips*-*-*] } {
2460 set et_sync_int_long_saved 1
2464 verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2465 return $et_sync_int_long_saved
2468 # Return 1 if the target supports atomic operations on "char" and "short".
2470 proc check_effective_target_sync_char_short { } {
2471 global et_sync_char_short_saved
2473 if [info exists et_sync_char_short_saved] {
2474 verbose "check_effective_target_sync_char_short: using cached result" 2
2476 set et_sync_char_short_saved 0
2477 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2478 #
load-reserved/store
-conditional instructions.
2479 if { [istarget ia64
-*-*]
2480 ||
[istarget i?
86-*-*]
2481 ||
[istarget x86_64
-*-*]
2482 ||
[istarget alpha
*-*-*]
2483 ||
[istarget s390
*-*-*]
2484 ||
[istarget powerpc
*-*-*]
2485 ||
[istarget sparc64
-*-*]
2486 ||
[istarget sparcv9
-*-*]
2487 ||
[istarget mips
*-*-*] } {
2488 set et_sync_char_short_saved
1
2492 verbose
"check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2493 return $et_sync_char_short_saved
2496 #
Return 1 if the target uses a ColdFire FPU.
2498 proc check_effective_target_coldfire_fpu
{ } {
2499 return [check_no_compiler_messages coldfire_fpu assembly
{
2506 #
Return true
if this is a uClibc target.
2508 proc check_effective_target_uclibc
{} {
2509 return [check_no_compiler_messages uclibc object
{
2510 #
include <features.h
>
2511 #
if !defined
(__UCLIBC__
)
2517 #
Return true
if this is a uclibc target and
if the uclibc feature
2518 # described by __$feature__ is not present.
2520 proc check_missing_uclibc_feature
{feature
} {
2521 return [check_no_compiler_messages $feature object
"
2522 #
include <features.h
>
2523 #
if !defined
(__UCLIBC
) || defined
(__$
{feature
}__
)
2529 #
Return true
if this is a Newlib target.
2531 proc check_effective_target_newlib
{} {
2532 return [check_no_compiler_messages newlib object
{
2538 #
(a
) an error of a few ULP is expected in string to floating
-point
2539 # conversion functions
; and
2540 #
(b
) overflow is not always detected correctly by those functions.
2542 proc check_effective_target_lax_strtofp
{} {
2543 # By default
, assume that all uClibc targets suffer from this.
2544 return [check_effective_target_uclibc
]
2547 #
Return 1 if this is a target
for which wcsftime is a dummy
2548 # function that always returns
0.
2550 proc check_effective_target_dummy_wcsftime
{} {
2551 # By default
, assume that all uClibc targets suffer from this.
2552 return [check_effective_target_uclibc
]
2555 #
Return 1 if constructors with initialization priority arguments are
2556 # supposed
on this target.
2558 proc check_effective_target_init_priority
{} {
2559 return [check_no_compiler_messages init_priority assembly
"
2560 void f
() __attribute__
((constructor
(1000)));
2565 #
Return 1 if the target matches the effective target
'arg', 0 otherwise.
2566 # This can be used with
any check_
* proc that takes no
argument and
2567 # returns only
1 or
0. It could be used with check_
* procs that take
2568 # arguments with keywords that pass particular arguments.
2570 proc is
-effective
-target
{ arg } {
2572 if { [info procs check_effective_target_$
{arg}] != [list
] } {
2573 set selected
[check_effective_target_$
{arg}]
2576 "vmx_hw" { set selected [check_vmx_hw_available] }
2577 "named_sections" { set selected [check_named_sections_available] }
2578 "gc_sections" { set selected [check_gc_sections_available] }
2579 "cxa_atexit" { set selected [check_cxa_atexit_available] }
2580 default
{ error
"unknown effective target keyword `$arg'" }
2583 verbose
"is-effective-target: $arg $selected" 2
2587 #
Return 1 if the
argument is an effective
-target keyword
, 0 otherwise.
2589 proc is
-effective
-target
-keyword
{ arg } {
2590 if { [info procs check_effective_target_$
{arg}] != [list
] } {
2593 # These have different names
for their check_
* procs.
2595 "vmx_hw" { return 1 }
2596 "named_sections" { return 1 }
2597 "gc_sections" { return 1 }
2598 "cxa_atexit" { return 1 }
2599 default
{ return 0 }
2604 #
Return 1 if target default to short enums
2606 proc check_effective_target_short_enums
{ } {
2607 return [check_no_compiler_messages short_enums assembly
{
2609 int s
[sizeof
(enum foo
) == 1 ?
1 : -1];
2613 #
Return 1 if target supports merging string constants at link time.
2615 proc check_effective_target_string_merging
{ } {
2616 return [check_no_messages_and_pattern string_merging \
2617 "rodata\\.str" assembly {
2618 const char
*var
= "String";
2622 #
Return 1 if target has the basic signed and unsigned types in
2623 #
<stdint.h
>, 0 otherwise.
2625 proc check_effective_target_stdint_types
{ } {
2626 return [check_no_compiler_messages stdint_types assembly
{
2628 int8_t a
; int16_t b
; int32_t c
; int64_t d
;
2629 uint8_t e
; uint16_t f
; uint32_t g
; uint64_t h
;
2633 #
Return 1 if programs are intended to be run
on a simulator
2634 #
(i.e. slowly
) rather than hardware
(i.e. fast
).
2636 proc check_effective_target_simulator
{ } {
2638 # All
"src/sim" simulators set this one.
2639 if [board_info target
exists is_simulator
] {
2640 return [board_info target is_simulator
]
2643 # The
"sid" simulators don't set that one, but at least they set
2645 if [board_info target
exists slow_simulator
] {
2646 return [board_info target slow_simulator
]
2652 #
Return 1 if the target is a VxWorks kernel.
2654 proc check_effective_target_vxworks_kernel
{ } {
2655 return [check_no_compiler_messages vxworks_kernel assembly
{
2656 #
if !defined __vxworks || defined __RTP__
2662 #
Return 1 if the target is a VxWorks RTP.
2664 proc check_effective_target_vxworks_rtp
{ } {
2665 return [check_no_compiler_messages vxworks_rtp assembly
{
2666 #
if !defined __vxworks ||
!defined __RTP__
2672 #
Return 1 if the target is expected to provide wide character support.
2674 proc check_effective_target_wchar
{ } {
2675 if {[check_missing_uclibc_feature UCLIBC_HAS_WCHAR
]} {
2678 return [check_no_compiler_messages wchar assembly
{
2683 #
Return 1 if the target has
<pthread.h
>.
2685 proc check_effective_target_pthread_h
{ } {
2686 return [check_no_compiler_messages pthread_h assembly
{
2687 #
include <pthread.h
>
2691 #
Return 1 if the target can truncate a file from a file
-descriptor
,
2692 # as used by libgfortran
/io
/unix.c
:fd_truncate
; i.e. ftruncate or
2693 # chsize. We test
for a trivially functional truncation
; no stubs.
2694 # As libgfortran uses _FILE_OFFSET_BITS
64, we
do too
; it
'll cause a
2695 # different function to be used.
2697 proc check_effective_target_fd_truncate { } {
2699 #define _FILE_OFFSET_BITS 64
2705 FILE *f = fopen ("tst.tmp", "wb");
2707 const char t[] = "test writing more than ten characters";
2710 write (fd, t, sizeof (t) - 1);
2712 if (ftruncate (fd, 10) != 0)
2715 f = fopen ("tst.tmp", "rb");
2716 if (fread (s, 1, sizeof (s), f) != 10 || strncmp (s, t, 10) != 0)
2722 if { [check_runtime ftruncate $prog] } {
2726 regsub "ftruncate" $prog "chsize" prog
2727 return [check_runtime chsize $prog]
2730 # Add to FLAGS all the target-specific flags needed to access the c99 runtime.
2732 proc add_options_for_c99_runtime { flags } {
2733 if { [istarget *-*-solaris2*] } {
2734 return "$flags -std=c99"
2736 if { [istarget powerpc-*-darwin*] } {
2737 return "$flags -mmacosx-version-min=10.3"
2742 # Return 1 if the target provides a full C99 runtime.
2744 proc check_effective_target_c99_runtime { } {
2745 return [check_cached_effective_target c99_runtime {
2748 set file [open "$srcdir/gcc.dg/builtins-config.h"]
2749 set contents [read $file]
2752 #ifndef HAVE_C99_RUNTIME
2756 check_no_compiler_messages_nocache c99_runtime assembly \
2757 $contents [add_options_for_c99_runtime ""]
2761 # Return 1 if target wchar_t is at least 4 bytes.
2763 proc check_effective_target_4byte_wchar_t { } {
2764 return [check_no_compiler_messages 4byte_wchar_t object {
2765 int dummy[sizeof (__WCHAR_TYPE__) >= 4 ? 1 : -1];
2769 # Return 1 if the target supports automatic stack alignment.
2771 proc check_effective_target_automatic_stack_alignment { } {
2772 if { [istarget i?86*-*-*]
2773 || [istarget x86_64-*-*] } then {
2780 # Return 1 if avx instructions can be compiled.
2782 proc check_effective_target_avx { } {
2783 return [check_no_compiler_messages avx object {
2784 void _mm256_zeroall (void)
2786 __builtin_ia32_vzeroall ();
2791 # Return 1 if C wchar_t type is compatible with char16_t.
2793 proc check_effective_target_wchar_t_char16_t_compatible { } {
2794 return [check_no_compiler_messages wchar_t_char16_t object {
2796 __CHAR16_TYPE__ *p16 = &wc;
2797 char t[(((__CHAR16_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
2801 # Return 1 if C wchar_t type is compatible with char32_t.
2803 proc check_effective_target_wchar_t_char32_t_compatible { } {
2804 return [check_no_compiler_messages wchar_t_char32_t object {
2806 __CHAR32_TYPE__ *p32 = &wc;
2807 char t[(((__CHAR32_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
2811 # Return 1 if pow10 function exists.
2813 proc check_effective_target_pow10 { } {
2814 return [check_runtime pow10 {
2824 # Return 1 if current options generate DFP instructions, 0 otherwise.
2826 proc check_effective_target_hard_dfp {} {
2827 return [check_no_messages_and_pattern hard_dfp "!adddd3" assembly {
2829 void foo (void) { z = x + y; }
2833 # Return 1 if string.h and wchar.h headers provide C++ requires overloads
2834 # for strchr etc. functions.
2836 proc check_effective_target_correct_iso_cpp_string_wchar_protos { } {
2837 return [check_no_compiler_messages correct_iso_cpp_string_wchar_protos assembly {
2840 #if !defined(__cplusplus) \
2841 || !defined(__CORRECT_ISO_CPP_STRING_H_PROTO) \
2842 || !defined(__CORRECT_ISO_CPP_WCHAR_H_PROTO)
2843 ISO C++ correct string.h and wchar.h protos not supported.
2850 # Return 1 if the target supports IEEE arithmetic.
2852 proc check_effective_target_ieee { } {
2853 global et_ieee_saved
2855 if { ![info exists et_ieee_saved] } {
2857 if { [istarget vax-*-*]
2858 || [istarget powerpc-*-*spe*] } {
2863 return $et_ieee_saved