1 # Copyright
(C
) 1999, 2001, 2003, 2004, 2005, 2006, 2007
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_visibility_available { what_kind }
255 ###############################
257 # The visibility attribute is only support in some object formats
258 # This proc returns 1 if it is supported, 0 if not.
259 # The argument is the kind of visibility, default/protected/hidden/internal.
261 proc check_visibility_available { what_kind } {
263 global target_triplet
265 # On NetWare, support makes no sense.
266 if { [istarget *-*-netware*] } {
270 if [string match "" $what_kind] { set what_kind "hidden" }
272 return [check_no_compiler_messages visibility_available_$what_kind object "
273 void f() __attribute__((visibility(\"$what_kind\")));
278 ###############################
279 # proc check_alias_available { }
280 ###############################
282 # Determine if the target toolchain supports the alias attribute.
284 # Returns 2 if the target supports aliases. Returns 1 if the target
285 # only supports weak aliased. Returns 0 if the target does not
286 # support aliases at all. Returns -1 if support for aliases could not
289 proc check_alias_available { } {
290 global alias_available_saved
293 if [info exists alias_available_saved] {
294 verbose "check_alias_available returning saved $alias_available_saved" 2
298 verbose "check_alias_available compiling testfile $src" 2
299 set f [open $src "w"]
300 # Compile a small test program. The definition of "g" is
301 # necessary to keep the Solaris assembler from complaining
303 puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
304 puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
306 set lines [${tool}_target_compile $src $obj object ""]
308 remote_file build delete $obj
310 if [string match "" $lines] then {
311 # No error messages, everything is OK.
312 set alias_available_saved 2
314 if [regexp "alias definitions not supported" $lines] {
315 verbose "check_alias_available target does not support aliases" 2
317 set objformat [gcc_target_object_format]
319 if { $objformat == "elf" } {
320 verbose "check_alias_available but target uses ELF format, so it ought to" 2
321 set alias_available_saved -1
323 set alias_available_saved 0
326 if [regexp "only weak aliases are supported" $lines] {
327 verbose "check_alias_available target supports only weak aliases" 2
328 set alias_available_saved 1
330 set alias_available_saved -1
335 verbose "check_alias_available returning $alias_available_saved" 2
338 return $alias_available_saved
341 # Returns true if --gc-sections is supported on the target.
343 proc check_gc_sections_available { } {
344 global gc_sections_available_saved
347 if {![info exists gc_sections_available_saved]} {
348 # Some targets don't support gc
-sections despite whatever
's
349 # advertised by ld's options.
350 if { [istarget alpha
*-*-*]
351 ||
[istarget ia64
-*-*] } {
352 set gc_sections_available_saved
0
356 # elf2flt uses
-q
(--emit
-relocs
), which is incompatible with
358 if { [board_info target
exists ldflags
]
359 && [regexp
" -elf2flt\[ =\]" " [board_info target ldflags] "] } {
360 set gc_sections_available_saved
0
364 # VxWorks kernel modules are relocatable objects linked with
-r
,
365 #
while RTP executables are linked with
-q
(--emit
-relocs
).
366 # Both of these options are incompatible with
--gc
-sections.
367 if { [istarget
*-*-vxworks
*] } {
368 set gc_sections_available_saved
0
372 # Check
if the
ld used by gcc supports
--gc
-sections.
373 set gcc_spec
[$
{tool
}_target_compile
"-dumpspecs" "" "none" ""]
374 regsub
".*\n\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
375 set gcc_ld
[lindex
[$
{tool
}_target_compile
"-print-prog-name=$linker" "" "none" ""] 0]
376 set ld_output
[remote_exec host
"$gcc_ld" "--help"]
377 if { [ string first
"--gc-sections" $ld_output ] >= 0 } {
378 set gc_sections_available_saved
1
380 set gc_sections_available_saved
0
383 return $gc_sections_available_saved
386 #
Return true
if profiling is supported
on the target.
388 proc check_profiling_available
{ test_what
} {
389 global profiling_available_saved
391 verbose
"Profiling argument is <$test_what>" 1
393 # These conditions depend
on the
argument so examine them before
394 # looking at the
cache variable.
396 # Support
for -p
on solaris2 relies
on mcrt1.o which comes with the
397 # vendor compiler. We cannot reliably predict the directory where the
398 # vendor compiler
(and thus mcrt1.o
) is installed so we can
't
399 # necessarily find mcrt1.o even if we have it.
400 if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
404 # Support for -p on irix relies on libprof1.a which doesn't appear to
405 # exist
on any irix6
system currently posting testsuite results.
406 # Support
for -pg
on irix relies
on gcrt1.o which doesn
't exist yet.
407 # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
408 if { [istarget mips*-*-irix*]
409 && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
413 # MinGW does not support -p.
414 if { [istarget *-*-mingw*] && [lindex $test_what 1] == "-p" } {
418 # At present, there is no profiling support on NetWare.
419 if { [istarget *-*-netware*] } {
423 # uClibc does not have gcrt1.o.
424 if { [check_effective_target_uclibc]
425 && ([lindex $test_what 1] == "-p"
426 || [lindex $test_what 1] == "-pg") } {
430 # Now examine the cache variable.
431 if {![info exists profiling_available_saved]} {
432 # Some targets don't have
any implementation of __bb_init_func or are
433 # missing other needed machinery.
434 if { [istarget mmix
-*-*]
435 ||
[istarget arm
*-*-eabi
*]
436 ||
[istarget arm
*-*-elf
]
437 ||
[istarget arm
*-*-symbianelf
*]
438 ||
[istarget bfin
-*-*]
439 ||
[istarget powerpc
-*-eabi
*]
440 ||
[istarget strongarm
*-*-elf
]
441 ||
[istarget xscale
*-*-elf
]
442 ||
[istarget cris
-*-*]
443 ||
[istarget crisv32
-*-*]
444 ||
[istarget fido
-*-elf
]
445 ||
[istarget h8300
-*-*]
446 ||
[istarget m32c
-*-elf
]
447 ||
[istarget m68k
-*-elf
]
448 ||
[istarget m68k
-*-uclinux
*]
449 ||
[istarget mips
*-*-elf
*]
450 ||
[istarget xstormy16
-*]
451 ||
[istarget xtensa
-*-elf
]
452 ||
[istarget
*-*-vxworks
*]
453 ||
[istarget
*-*-windiss
] } {
454 set profiling_available_saved
0
456 set profiling_available_saved
1
460 return $profiling_available_saved
463 #
Return 1 if target has packed layout of structure members by
464 # default
, 0 otherwise. Note that this is slightly different than
465 # whether the target has
"natural alignment": both attributes may be
468 proc check_effective_target_default_packed
{ } {
469 return [check_no_compiler_messages default_packed assembly
{
470 struct x
{ char a
; long b
; } c
;
471 int s
[sizeof
(c
) == sizeof
(char
) + sizeof
(long
) ?
1 : -1];
475 #
Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined. See
476 # documentation
, where the test also comes from.
478 proc check_effective_target_pcc_bitfield_type_matters
{ } {
479 # PCC_BITFIELD_TYPE_MATTERS isn
't just about unnamed or empty
480 # bitfields, but let's stick to the example code from the docs.
481 return [check_no_compiler_messages pcc_bitfield_type_matters assembly
{
482 struct foo1
{ char x
; char
:0; char y
; };
483 struct foo2
{ char x
; int :0; char y
; };
484 int s
[sizeof
(struct foo1
) != sizeof
(struct foo2
) ?
1 : -1];
488 #
Return 1 if thread local storage
(TLS
) is supported
, 0 otherwise.
490 # This won
't change for different subtargets so cache the result.
492 proc check_effective_target_tls {} {
493 return [check_no_compiler_messages tls assembly {
495 int f (void) { return i; }
496 void g (int j) { i = j; }
500 # Return 1 if *native* thread local storage (TLS) is supported, 0 otherwise.
502 # This won't change
for different subtargets so
cache the result.
504 proc check_effective_target_tls_native
{} {
505 return [check_no_messages_and_pattern tls_native
"!emutls" assembly {
507 int f
(void
) { return i
; }
508 void g
(int j
) { i
= j
; }
512 #
Return 1 if TLS executables can run correctly
, 0 otherwise.
514 # This won
't change for different subtargets so cache the result.
516 proc check_effective_target_tls_runtime {} {
517 return [check_runtime tls_runtime {
518 __thread int thr = 0;
519 int main (void) { return thr; }
523 # Return 1 if compilation with -fopenmp is error-free for trivial
526 proc check_effective_target_fopenmp {} {
527 return [check_no_compiler_messages fopenmp object {
532 # Return 1 if compilation with -pthread is error-free for trivial
535 proc check_effective_target_pthread {} {
536 return [check_no_compiler_messages pthread object {
541 # Return 1 if the target supports -fstack-protector
542 proc check_effective_target_fstack_protector {} {
543 return [check_runtime fstack_protector {
544 int main (void) { return 0; }
545 } "-fstack-protector"]
548 # Return 1 if compilation with -freorder-blocks-and-partition is error-free
549 # for trivial code, 0 otherwise.
551 proc check_effective_target_freorder {} {
552 return [check_no_compiler_messages freorder object {
554 } "-freorder-blocks-and-partition"]
557 # Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
558 # emitted, 0 otherwise. Whether a shared library can actually be built is
559 # out of scope for this test.
561 proc check_effective_target_fpic { } {
562 # Note that M68K has a multilib that supports -fpic but not
563 # -fPIC, so we need to check both. We test with a program that
564 # requires GOT references.
565 foreach arg {fpic fPIC} {
566 if [check_no_compiler_messages $arg object {
567 extern int foo (void); extern int bar;
568 int baz (void) { return foo () + bar; }
576 # Return true if the target supports -mpaired-single (as used on MIPS).
578 proc check_effective_target_mpaired_single { } {
579 return [check_no_compiler_messages mpaired_single object {
584 # Return true if the target has access to FPU instructions.
586 proc check_effective_target_hard_float { } {
587 if { [istarget mips*-*-*] } {
588 return [check_no_compiler_messages hard_float assembly {
589 #if (defined __mips_soft_float || defined __mips16)
595 # The generic test equates hard_float with "no call for adding doubles".
596 return [check_no_messages_and_pattern hard_float "!\\(call" rtl-expand {
597 double a (double b, double c) { return b + c; }
601 # Return true if the target is a 64-bit MIPS target.
603 proc check_effective_target_mips64 { } {
604 return [check_no_compiler_messages mips64 assembly {
611 # Return true if the target is a MIPS target that does not produce
614 proc check_effective_target_nomips16 { } {
615 return [check_no_compiler_messages nomips16 object {
619 /* A cheap way of testing for -mflip-mips16. */
620 void foo (void) { asm ("addiu $20,$20,1"); }
621 void bar (void) { asm ("addiu $20,$20,1"); }
626 # Add the options needed for MIPS16 function attributes. At the moment,
627 # we don't support MIPS16 PIC.
629 proc add_options_for_mips16_attribute
{ flags
} {
630 return "$flags -mno-abicalls -fno-pic"
633 #
Return true
if we can force a
mode that allows MIPS16 code generation.
634 # We don
't support MIPS16 PIC, and only support MIPS16 -mhard-float
637 proc check_effective_target_mips16_attribute { } {
638 return [check_no_compiler_messages mips16_attribute assembly {
642 #if defined __mips_hard_float \
643 && (!defined _ABIO32 || _MIPS_SIM != _ABIO32) \
644 && (!defined _ABIO64 || _MIPS_SIM != _ABIO64)
647 } [add_options_for_mips16_attribute ""]]
650 # Return 1 if the current multilib does not generate PIC by default.
652 proc check_effective_target_nonpic { } {
653 return [check_no_compiler_messages nonpic assembly {
660 # Return 1 if the target does not use a status wrapper.
662 proc check_effective_target_unwrapped { } {
663 if { [target_info needs_status_wrapper] != "" \
664 && [target_info needs_status_wrapper] != "0" } {
670 # Return true if iconv is supported on the target. In particular IBM1047.
672 proc check_iconv_available { test_what } {
675 # If the tool configuration file has not set libiconv, try "-liconv"
676 if { ![info exists libiconv] } {
677 set libiconv "-liconv"
679 set test_what [lindex $test_what 1]
680 return [check_runtime_nocache $test_what [subst {
686 cd = iconv_open ("$test_what", "UTF-8");
687 if (cd == (iconv_t) -1)
694 # Return true if named sections are supported on this target.
696 proc check_named_sections_available { } {
697 return [check_no_compiler_messages named_sections assembly {
698 int __attribute__ ((section("whatever"))) foo;
702 # Return 1 if the target supports Fortran real kinds larger than real(8),
705 # When the target name changes, replace the cached result.
707 proc check_effective_target_fortran_large_real { } {
708 return [check_no_compiler_messages fortran_large_real executable {
710 integer,parameter :: k = selected_real_kind (precision (0.0_8) + 1)
717 # Return 1 if the target supports Fortran integer kinds larger than
718 # integer(8), 0 otherwise.
720 # When the target name changes, replace the cached result.
722 proc check_effective_target_fortran_large_int { } {
723 return [check_no_compiler_messages fortran_large_int executable {
725 integer,parameter :: k = selected_int_kind (range (0_8) + 1)
731 # Return 1 if we can statically link libgfortran, 0 otherwise.
733 # When the target name changes, replace the cached result.
735 proc check_effective_target_static_libgfortran { } {
736 return [check_no_compiler_messages static_libgfortran executable {
743 # Return 1 if the target supports executing 750CL paired-single instructions, 0
744 # otherwise. Cache the result.
746 proc check_750cl_hw_available { } {
747 return [check_cached_effective_target 750cl_hw_available {
748 # If this is not the right target then we can skip the test.
749 if { ![istarget powerpc-*paired*] } {
752 check_runtime_nocache 750cl_hw_available {
756 asm volatile ("ps_mul v0,v0,v0");
758 asm volatile ("ps_mul 0,0,0");
767 # Return 1 if the target supports executing SSE2 instructions, 0
768 # otherwise. Cache the result.
770 proc check_sse2_hw_available { } {
771 return [check_cached_effective_target sse2_hw_available {
772 # If this is not the right target then we can skip the test.
773 if { !([istarget x86_64-*-*] || [istarget i?86-*-*]) } {
776 check_runtime_nocache sse2_hw_available {
780 unsigned int eax, ebx, ecx, edx = 0;
781 if (__get_cpuid (1, &eax, &ebx, &ecx, &edx))
782 return !(edx & bit_SSE2);
790 # Return 1 if the target supports executing AltiVec instructions, 0
791 # otherwise. Cache the result.
793 proc check_vmx_hw_available { } {
794 return [check_cached_effective_target vmx_hw_available {
795 # Some simulators are known to not support VMX instructions.
796 if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
799 # Most targets don't require special flags
for this test case
, but
801 if { [istarget
*-*-darwin
*]
802 ||
[istarget
*-*-aix
*] } {
803 set options
"-maltivec"
807 check_runtime_nocache vmx_hw_available
{
811 asm volatile
("vor v0,v0,v0");
813 asm volatile
("vor 0,0,0");
822 # GCC
3.4.0 for powerpc64
-*-linux
* included an ABI fix
for passing
823 # complex float arguments. This affects gfortran tests that
call cabsf
824 # in libm built by an earlier compiler.
Return 1 if libm uses the same
825 #
argument passing as the compiler under test
, 0 otherwise.
827 # When the target
name changes
, replace the cached result.
829 proc check_effective_target_broken_cplxf_arg
{ } {
830 return [check_cached_effective_target broken_cplxf_arg
{
831 # Skip the work
for targets known not to be affected.
832 if { ![istarget powerpc64
-*-linux
*] } {
834 } elseif
{ ![is
-effective
-target lp64
] } {
837 check_runtime_nocache broken_cplxf_arg
{
839 extern void abort
(void
);
841 float cabsf
(_Complex float
);
848 if (fabsf
(f
- 5.0) > 0.0001)
857 proc check_alpha_max_hw_available
{ } {
858 return [check_runtime alpha_max_hw_available
{
859 int main
() { return __builtin_alpha_amask
(1<<8) != 0; }
863 # Returns true iff the FUNCTION is available
on the target
system.
864 #
(This is essentially a Tcl implementation of Autoconf
's
867 proc check_function_available { function } {
868 return [check_no_compiler_messages ${function}_available \
874 int main () { $function (); }
878 # Returns true iff "fork" is available on the target system.
880 proc check_fork_available {} {
881 return [check_function_available "fork"]
884 # Returns true iff "mkfifo" is available on the target system.
886 proc check_mkfifo_available {} {
887 if {[istarget *-*-cygwin*]} {
888 # Cygwin has mkfifo, but support is incomplete.
892 return [check_function_available "mkfifo"]
895 # Returns true iff "__cxa_atexit" is used on the target system.
897 proc check_cxa_atexit_available { } {
898 return [check_cached_effective_target cxa_atexit_available {
899 if { [istarget "hppa*-*-hpux10*"] } {
900 # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
903 check_runtime_nocache cxa_atexit_available
{
906 static unsigned
int count;
923 Y
() { f
(); count = 2; }
932 int main
() { return 0; }
939 #
Return 1 if we
're generating 32-bit code using default options, 0
942 proc check_effective_target_ilp32 { } {
943 return [check_no_compiler_messages ilp32 object {
944 int dummy[sizeof (int) == 4
945 && sizeof (void *) == 4
946 && sizeof (long) == 4 ? 1 : -1];
950 # Return 1 if we're generating
32-bit or larger integers using default
951 # options
, 0 otherwise.
953 proc check_effective_target_int32plus
{ } {
954 return [check_no_compiler_messages int32plus object
{
955 int dummy
[sizeof
(int) >= 4 ?
1 : -1];
959 #
Return 1 if we
're generating 32-bit or larger pointers using default
960 # options, 0 otherwise.
962 proc check_effective_target_ptr32plus { } {
963 return [check_no_compiler_messages ptr32plus object {
964 int dummy[sizeof (void *) >= 4 ? 1 : -1];
968 # Return 1 if we support 32-bit or larger array and structure sizes
969 # using default options, 0 otherwise.
971 proc check_effective_target_size32plus { } {
972 return [check_no_compiler_messages size32plus object {
977 # Returns 1 if we're generating
16-bit or smaller integers with the
978 # default options
, 0 otherwise.
980 proc check_effective_target_int16
{ } {
981 return [check_no_compiler_messages int16 object
{
982 int dummy
[sizeof
(int) < 4 ?
1 : -1];
986 #
Return 1 if we
're generating 64-bit code using default options, 0
989 proc check_effective_target_lp64 { } {
990 return [check_no_compiler_messages lp64 object {
991 int dummy[sizeof (int) == 4
992 && sizeof (void *) == 8
993 && sizeof (long) == 8 ? 1 : -1];
997 # Return 1 if the target supports long double larger than double,
1000 proc check_effective_target_large_long_double { } {
1001 return [check_no_compiler_messages large_long_double object {
1002 int dummy[sizeof(long double) > sizeof(double) ? 1 : -1];
1006 # Return 1 if the target supports compiling fixed-point,
1009 proc check_effective_target_fixed_point { } {
1010 return [check_no_compiler_messages fixed_point object {
1011 _Sat _Fract x; _Sat _Accum y;
1015 # Return 1 if the target supports compiling decimal floating point,
1018 proc check_effective_target_dfp_nocache { } {
1019 verbose "check_effective_target_dfp_nocache: compiling source" 2
1020 set ret [check_no_compiler_messages_nocache dfp object {
1021 _Decimal32 x; _Decimal64 y; _Decimal128 z;
1023 verbose "check_effective_target_dfp_nocache: returning $ret" 2
1027 proc check_effective_target_dfprt_nocache { } {
1028 return [check_runtime_nocache dfprt {
1029 _Decimal32 x = 1.2df; _Decimal64 y = 2.3dd; _Decimal128 z;
1030 int main () { z = x + y; return 0; }
1034 # Return 1 if the target supports compiling Decimal Floating Point,
1037 # This won't change
for different subtargets so
cache the result.
1039 proc check_effective_target_dfp
{ } {
1040 return [check_cached_effective_target dfp
{
1041 check_effective_target_dfp_nocache
1045 #
Return 1 if the target supports linking and executing Decimal Floating
1046 # Point
, #
0 otherwise.
1048 # This won
't change for different subtargets so cache the result.
1050 proc check_effective_target_dfprt { } {
1051 return [check_cached_effective_target dfprt {
1052 check_effective_target_dfprt_nocache
1056 # Return 1 if the target needs a command line argument to enable a SIMD
1059 proc check_effective_target_vect_cmdline_needed { } {
1060 global et_vect_cmdline_needed_saved
1061 global et_vect_cmdline_needed_target_name
1063 if { ![info exists et_vect_cmdline_needed_target_name] } {
1064 set et_vect_cmdline_needed_target_name ""
1067 # If the target has changed since we set the cached value, clear it.
1068 set current_target [current_target_name]
1069 if { $current_target != $et_vect_cmdline_needed_target_name } {
1070 verbose "check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target
'" 2
1071 set et_vect_cmdline_needed_target_name $current_target
1072 if { [info exists et_vect_cmdline_needed_saved] } {
1073 verbose "check_effective_target_vect_cmdline_needed: removing cached result" 2
1074 unset et_vect_cmdline_needed_saved
1078 if [info exists et_vect_cmdline_needed_saved] {
1079 verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1081 set et_vect_cmdline_needed_saved 1
1082 if { [istarget ia64-*-*]
1083 || (([istarget x86_64-*-*] || [istarget i?86-*-*])
1084 && [check_effective_target_lp64])
1085 || ([istarget powerpc*-*-*]
1086 && ([check_effective_target_powerpc_spe]
1087 || [check_effective_target_powerpc_altivec]))} {
1088 set et_vect_cmdline_needed_saved 0
1092 verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1093 return $et_vect_cmdline_needed_saved
1096 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
1098 # This won't change
for different subtargets so
cache the result.
1100 proc check_effective_target_vect_int
{ } {
1101 global et_vect_int_saved
1103 if [info exists et_vect_int_saved
] {
1104 verbose
"check_effective_target_vect_int: using cached result" 2
1106 set et_vect_int_saved
0
1107 if { [istarget i?
86-*-*]
1108 ||
([istarget powerpc
*-*-*]
1109 && ![istarget powerpc
-*-linux
*paired
*])
1110 ||
[istarget spu
-*-*]
1111 ||
[istarget x86_64
-*-*]
1112 ||
[istarget sparc
*-*-*]
1113 ||
[istarget alpha
*-*-*]
1114 ||
[istarget ia64
-*-*] } {
1115 set et_vect_int_saved
1
1119 verbose
"check_effective_target_vect_int: returning $et_vect_int_saved" 2
1120 return $et_vect_int_saved
1123 #
Return 1 if the target supports
int->float conversion
1126 proc check_effective_target_vect_intfloat_cvt
{ } {
1127 global et_vect_intfloat_cvt_saved
1129 if [info exists et_vect_intfloat_cvt_saved
] {
1130 verbose
"check_effective_target_vect_intfloat_cvt: using cached result" 2
1132 set et_vect_intfloat_cvt_saved
0
1133 if { [istarget i?
86-*-*]
1134 ||
([istarget powerpc
*-*-*]
1135 && ![istarget powerpc
-*-linux
*paired
*])
1136 ||
[istarget x86_64
-*-*] } {
1137 set et_vect_intfloat_cvt_saved
1
1141 verbose
"check_effective_target_vect_intfloat_cvt: returning $et_vect_intfloat_cvt_saved" 2
1142 return $et_vect_intfloat_cvt_saved
1146 #
Return 1 if the target supports float
->int conversion
1149 proc check_effective_target_vect_floatint_cvt
{ } {
1150 global et_vect_floatint_cvt_saved
1152 if [info exists et_vect_floatint_cvt_saved
] {
1153 verbose
"check_effective_target_vect_floatint_cvt: using cached result" 2
1155 set et_vect_floatint_cvt_saved
0
1156 if { [istarget i?
86-*-*]
1157 ||
[istarget x86_64
-*-*] } {
1158 set et_vect_floatint_cvt_saved
1
1162 verbose
"check_effective_target_vect_floatint_cvt: returning $et_vect_floatint_cvt_saved" 2
1163 return $et_vect_floatint_cvt_saved
1166 #
Return 1 is this is an arm target using
32-bit instructions
1167 proc check_effective_target_arm32
{ } {
1168 return [check_no_compiler_messages arm32 assembly
{
1169 #
if !defined
(__arm__
) ||
(defined
(__thumb__
) && !defined
(__thumb2__
))
1175 #
Return 1 if this is an ARM target supporting
-mfpu
=vfp
1176 #
-mfloat
-abi
=softfp. Some multilibs may be incompatible with these
1179 proc check_effective_target_arm_vfp_ok
{ } {
1180 if { [check_effective_target_arm32
] } {
1181 return [check_no_compiler_messages arm_vfp_ok object
{
1183 } "-mfpu=vfp -mfloat-abi=softfp"]
1189 #
Return 1 if this is an ARM target supporting
-mfpu
=neon
1190 #
-mfloat
-abi
=softfp. Some multilibs may be incompatible with these
1193 proc check_effective_target_arm_neon_ok
{ } {
1194 if { [check_effective_target_arm32
] } {
1195 return [check_no_compiler_messages arm_neon_ok object
{
1197 } "-mfpu=neon -mfloat-abi=softfp"]
1203 #
Return 1 if the target supports executing NEON instructions
, 0
1204 # otherwise.
Cache the result.
1206 proc check_effective_target_arm_neon_hw
{ } {
1207 return [check_runtime arm_neon_hw_available
{
1211 long long a
= 0, b
= 1;
1212 asm
("vorr %P0, %P1, %P2"
1214 : "0" (a), "w" (b));
1217 } "-mfpu=neon -mfloat-abi=softfp"]
1220 #
Return 1 if this is a PowerPC target with floating
-point registers.
1222 proc check_effective_target_powerpc_fprs
{ } {
1223 if { [istarget powerpc
*-*-*]
1224 ||
[istarget rs6000
-*-*] } {
1225 return [check_no_compiler_messages powerpc_fprs object
{
1237 #
Return 1 if this is a PowerPC target supporting
-maltivec.
1239 proc check_effective_target_powerpc_altivec_ok
{ } {
1240 if { ([istarget powerpc
*-*-*]
1241 && ![istarget powerpc
-*-linux
*paired
*])
1242 ||
[istarget rs6000
-*-*] } {
1243 # AltiVec is not supported
on AIX before
5.3.
1244 if { [istarget powerpc
*-*-aix4
*]
1245 ||
[istarget powerpc
*-*-aix5.1
*]
1246 ||
[istarget powerpc
*-*-aix5.2
*] } {
1249 return [check_no_compiler_messages powerpc_altivec_ok object
{
1257 #
Return 1 if this is a PowerPC target that supports SPU.
1259 proc check_effective_target_powerpc_spu
{ } {
1260 return [istarget powerpc
*-*-linux
*]
1263 #
Return 1 if this is a PowerPC target with SPE enabled.
1265 proc check_effective_target_powerpc_spe
{ } {
1266 if { [istarget powerpc
*-*-*] } {
1267 return [check_no_compiler_messages powerpc_spe object
{
1279 #
Return 1 if this is a PowerPC target with Altivec enabled.
1281 proc check_effective_target_powerpc_altivec
{ } {
1282 if { [istarget powerpc
*-*-*] } {
1283 return [check_no_compiler_messages powerpc_altivec object
{
1295 # The VxWorks SPARC simulator accepts only EM_SPARC executables and
1296 # chokes
on EM_SPARC32PLUS or EM_SPARCV9 executables.
Return 1 if the
1297 # test environment appears to run executables
on such a simulator.
1299 proc check_effective_target_ultrasparc_hw
{ } {
1300 return [check_runtime ultrasparc_hw
{
1301 int main
() { return 0; }
1302 } "-mcpu=ultrasparc"]
1305 #
Return 1 if the target supports hardware vector shift operation.
1307 proc check_effective_target_vect_shift
{ } {
1308 global et_vect_shift_saved
1310 if [info exists et_vect_shift_saved
] {
1311 verbose
"check_effective_target_vect_shift: using cached result" 2
1313 set et_vect_shift_saved
0
1314 if { ([istarget powerpc
*-*-*]
1315 && ![istarget powerpc
-*-linux
*paired
*])
1316 ||
[istarget ia64
-*-*]
1317 ||
[istarget i?
86-*-*]
1318 ||
[istarget x86_64
-*-*] } {
1319 set et_vect_shift_saved
1
1323 verbose
"check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1324 return $et_vect_shift_saved
1327 #
Return 1 if the target supports hardware vectors of long
, 0 otherwise.
1329 # This can change
for different subtargets so
do not
cache the result.
1331 proc check_effective_target_vect_long
{ } {
1332 if { [istarget i?
86-*-*]
1333 ||
(([istarget powerpc
*-*-*]
1334 && ![istarget powerpc
-*-linux
*paired
*])
1335 && [check_effective_target_ilp32
])
1336 ||
[istarget x86_64
-*-*]
1337 ||
([istarget sparc
*-*-*] && [check_effective_target_ilp32
]) } {
1343 verbose
"check_effective_target_vect_long: returning $answer" 2
1347 #
Return 1 if the target supports hardware vectors of float
, 0 otherwise.
1349 # This won
't change for different subtargets so cache the result.
1351 proc check_effective_target_vect_float { } {
1352 global et_vect_float_saved
1354 if [info exists et_vect_float_saved] {
1355 verbose "check_effective_target_vect_float: using cached result" 2
1357 set et_vect_float_saved 0
1358 if { [istarget i?86-*-*]
1359 || [istarget powerpc*-*-*]
1360 || [istarget spu-*-*]
1361 || [istarget mipsisa64*-*-*]
1362 || [istarget x86_64-*-*]
1363 || [istarget ia64-*-*] } {
1364 set et_vect_float_saved 1
1368 verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1369 return $et_vect_float_saved
1372 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1374 # This won't change
for different subtargets so
cache the result.
1376 proc check_effective_target_vect_double
{ } {
1377 global et_vect_double_saved
1379 if [info exists et_vect_double_saved
] {
1380 verbose
"check_effective_target_vect_double: using cached result" 2
1382 set et_vect_double_saved
0
1383 if { [istarget i?
86-*-*]
1384 ||
[istarget x86_64
-*-*]
1385 ||
[istarget spu
-*-*] } {
1386 set et_vect_double_saved
1
1390 verbose
"check_effective_target_vect_double: returning $et_vect_double_saved" 2
1391 return $et_vect_double_saved
1394 #
Return 1 if the target plus current options does not support a vector
1395 #
max instruction
on "int", 0 otherwise.
1397 # This won
't change for different subtargets so cache the result.
1399 proc check_effective_target_vect_no_int_max { } {
1400 global et_vect_no_int_max_saved
1402 if [info exists et_vect_no_int_max_saved] {
1403 verbose "check_effective_target_vect_no_int_max: using cached result" 2
1405 set et_vect_no_int_max_saved 0
1406 if { [istarget sparc*-*-*]
1407 || [istarget spu-*-*]
1408 || [istarget alpha*-*-*] } {
1409 set et_vect_no_int_max_saved 1
1412 verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1413 return $et_vect_no_int_max_saved
1416 # Return 1 if the target plus current options does not support a vector
1417 # add instruction on "int", 0 otherwise.
1419 # This won't change
for different subtargets so
cache the result.
1421 proc check_effective_target_vect_no_int_add
{ } {
1422 global et_vect_no_int_add_saved
1424 if [info exists et_vect_no_int_add_saved
] {
1425 verbose
"check_effective_target_vect_no_int_add: using cached result" 2
1427 set et_vect_no_int_add_saved
0
1428 # Alpha only supports vector add
on V8QI and V4HI.
1429 if { [istarget alpha
*-*-*] } {
1430 set et_vect_no_int_add_saved
1
1433 verbose
"check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1434 return $et_vect_no_int_add_saved
1437 #
Return 1 if the target plus current options does not support vector
1438 # bitwise instructions
, 0 otherwise.
1440 # This won
't change for different subtargets so cache the result.
1442 proc check_effective_target_vect_no_bitwise { } {
1443 global et_vect_no_bitwise_saved
1445 if [info exists et_vect_no_bitwise_saved] {
1446 verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1448 set et_vect_no_bitwise_saved 0
1450 verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1451 return $et_vect_no_bitwise_saved
1454 # Return 1 if the target plus current options supports a vector
1455 # widening summation of *short* args into *int* result, 0 otherwise.
1456 # A target can also support this widening summation if it can support
1457 # promotion (unpacking) from shorts to ints.
1459 # This won't change
for different subtargets so
cache the result.
1461 proc check_effective_target_vect_widen_sum_hi_to_si
{ } {
1462 global et_vect_widen_sum_hi_to_si
1464 if [info exists et_vect_widen_sum_hi_to_si_saved
] {
1465 verbose
"check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
1467 set et_vect_widen_sum_hi_to_si_saved
[check_effective_target_vect_unpack
]
1468 if { [istarget powerpc
*-*-*]
1469 ||
[istarget ia64
-*-*] } {
1470 set et_vect_widen_sum_hi_to_si_saved
1
1473 verbose
"check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
1474 return $et_vect_widen_sum_hi_to_si_saved
1477 #
Return 1 if the target plus current options supports a vector
1478 # widening summation of
*char
* args into
*short
* result
, 0 otherwise.
1479 # A target can also support this widening summation
if it can support
1480 # promotion
(unpacking
) from chars to shorts.
1482 # This won
't change for different subtargets so cache the result.
1484 proc check_effective_target_vect_widen_sum_qi_to_hi { } {
1485 global et_vect_widen_sum_qi_to_hi
1487 if [info exists et_vect_widen_sum_qi_to_hi_saved] {
1488 verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
1490 set et_vect_widen_sum_qi_to_hi_saved 0
1491 if { [check_effective_target_vect_unpack]
1492 || [istarget ia64-*-*] } {
1493 set et_vect_widen_sum_qi_to_hi_saved 1
1496 verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
1497 return $et_vect_widen_sum_qi_to_hi_saved
1500 # Return 1 if the target plus current options supports a vector
1501 # widening summation of *char* args into *int* result, 0 otherwise.
1503 # This won't change
for different subtargets so
cache the result.
1505 proc check_effective_target_vect_widen_sum_qi_to_si
{ } {
1506 global et_vect_widen_sum_qi_to_si
1508 if [info exists et_vect_widen_sum_qi_to_si_saved
] {
1509 verbose
"check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
1511 set et_vect_widen_sum_qi_to_si_saved
0
1512 if { [istarget powerpc
*-*-*] } {
1513 set et_vect_widen_sum_qi_to_si_saved
1
1516 verbose
"check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
1517 return $et_vect_widen_sum_qi_to_si_saved
1520 #
Return 1 if the target plus current options supports a vector
1521 # widening multiplication of
*char
* args into
*short
* result
, 0 otherwise.
1522 # A target can also support this widening multplication
if it can support
1523 # promotion
(unpacking
) from chars to shorts
, and vect_short_mult
(non
-widening
1524 # multiplication of shorts
).
1526 # This won
't change for different subtargets so cache the result.
1529 proc check_effective_target_vect_widen_mult_qi_to_hi { } {
1530 global et_vect_widen_mult_qi_to_hi
1532 if [info exists et_vect_widen_mult_qi_to_hi_saved] {
1533 verbose "check_effective_target_vect_widen_mult_qi_to_hi: using cached result" 2
1535 if { [check_effective_target_vect_unpack]
1536 && [check_effective_target_vect_short_mult] } {
1537 set et_vect_widen_mult_qi_to_hi_saved 1
1539 set et_vect_widen_mult_qi_to_hi_saved 0
1541 if { [istarget powerpc*-*-*] } {
1542 set et_vect_widen_mult_qi_to_hi_saved 1
1545 verbose "check_effective_target_vect_widen_mult_qi_to_hi: returning $et_vect_widen_mult_qi_to_hi_saved" 2
1546 return $et_vect_widen_mult_qi_to_hi_saved
1549 # Return 1 if the target plus current options supports a vector
1550 # widening multiplication of *short* args into *int* result, 0 otherwise.
1551 # A target can also support this widening multplication if it can support
1552 # promotion (unpacking) from shorts to ints, and vect_int_mult (non-widening
1553 # multiplication of ints).
1555 # This won't change
for different subtargets so
cache the result.
1558 proc check_effective_target_vect_widen_mult_hi_to_si
{ } {
1559 global et_vect_widen_mult_hi_to_si
1561 if [info exists et_vect_widen_mult_hi_to_si_saved
] {
1562 verbose
"check_effective_target_vect_widen_mult_hi_to_si: using cached result" 2
1564 if { [check_effective_target_vect_unpack
]
1565 && [check_effective_target_vect_int_mult
] } {
1566 set et_vect_widen_mult_hi_to_si_saved
1
1568 set et_vect_widen_mult_hi_to_si_saved
0
1570 if { [istarget powerpc
*-*-*]
1571 ||
[istarget spu
-*-*]
1572 ||
[istarget i?
86-*-*]
1573 ||
[istarget x86_64
-*-*] } {
1574 set et_vect_widen_mult_hi_to_si_saved
1
1577 verbose
"check_effective_target_vect_widen_mult_hi_to_si: returning $et_vect_widen_mult_hi_to_si_saved" 2
1578 return $et_vect_widen_mult_hi_to_si_saved
1581 #
Return 1 if the target plus current options supports a vector
1582 # dot
-product of signed chars
, 0 otherwise.
1584 # This won
't change for different subtargets so cache the result.
1586 proc check_effective_target_vect_sdot_qi { } {
1587 global et_vect_sdot_qi
1589 if [info exists et_vect_sdot_qi_saved] {
1590 verbose "check_effective_target_vect_sdot_qi: using cached result" 2
1592 set et_vect_sdot_qi_saved 0
1594 verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1595 return $et_vect_sdot_qi_saved
1598 # Return 1 if the target plus current options supports a vector
1599 # dot-product of unsigned chars, 0 otherwise.
1601 # This won't change
for different subtargets so
cache the result.
1603 proc check_effective_target_vect_udot_qi
{ } {
1604 global et_vect_udot_qi
1606 if [info exists et_vect_udot_qi_saved
] {
1607 verbose
"check_effective_target_vect_udot_qi: using cached result" 2
1609 set et_vect_udot_qi_saved
0
1610 if { [istarget powerpc
*-*-*] } {
1611 set et_vect_udot_qi_saved
1
1614 verbose
"check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1615 return $et_vect_udot_qi_saved
1618 #
Return 1 if the target plus current options supports a vector
1619 # dot
-product of signed shorts
, 0 otherwise.
1621 # This won
't change for different subtargets so cache the result.
1623 proc check_effective_target_vect_sdot_hi { } {
1624 global et_vect_sdot_hi
1626 if [info exists et_vect_sdot_hi_saved] {
1627 verbose "check_effective_target_vect_sdot_hi: using cached result" 2
1629 set et_vect_sdot_hi_saved 0
1630 if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
1631 || [istarget i?86-*-*]
1632 || [istarget x86_64-*-*] } {
1633 set et_vect_sdot_hi_saved 1
1636 verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
1637 return $et_vect_sdot_hi_saved
1640 # Return 1 if the target plus current options supports a vector
1641 # dot-product of unsigned shorts, 0 otherwise.
1643 # This won't change
for different subtargets so
cache the result.
1645 proc check_effective_target_vect_udot_hi
{ } {
1646 global et_vect_udot_hi
1648 if [info exists et_vect_udot_hi_saved
] {
1649 verbose
"check_effective_target_vect_udot_hi: using cached result" 2
1651 set et_vect_udot_hi_saved
0
1652 if { ([istarget powerpc
*-*-*] && ![istarget powerpc
-*-linux
*paired
*]) } {
1653 set et_vect_udot_hi_saved
1
1656 verbose
"check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
1657 return $et_vect_udot_hi_saved
1661 #
Return 1 if the target plus current options supports a vector
1662 # demotion
(packing
) of shorts
(to chars
) and ints
(to shorts
)
1663 # using modulo arithmetic
, 0 otherwise.
1665 # This won
't change for different subtargets so cache the result.
1667 proc check_effective_target_vect_pack_trunc { } {
1668 global et_vect_pack_trunc
1670 if [info exists et_vect_pack_trunc_saved] {
1671 verbose "check_effective_target_vect_pack_trunc: using cached result" 2
1673 set et_vect_pack_trunc_saved 0
1674 if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
1675 || [istarget i?86-*-*]
1676 || [istarget x86_64-*-*] } {
1677 set et_vect_pack_trunc_saved 1
1680 verbose "check_effective_target_vect_pack_trunc: returning $et_vect_pack_trunc_saved" 2
1681 return $et_vect_pack_trunc_saved
1684 # Return 1 if the target plus current options supports a vector
1685 # promotion (unpacking) of chars (to shorts) and shorts (to ints), 0 otherwise.
1687 # This won't change
for different subtargets so
cache the result.
1689 proc check_effective_target_vect_unpack
{ } {
1690 global et_vect_unpack
1692 if [info exists et_vect_unpack_saved
] {
1693 verbose
"check_effective_target_vect_unpack: using cached result" 2
1695 set et_vect_unpack_saved
0
1696 if { ([istarget powerpc
*-*-*] && ![istarget powerpc
-*paired
*])
1697 ||
[istarget i?
86-*-*]
1698 ||
[istarget x86_64
-*-*]
1699 ||
[istarget spu
-*-*] } {
1700 set et_vect_unpack_saved
1
1703 verbose
"check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2
1704 return $et_vect_unpack_saved
1707 #
Return 1 if the target plus current options does not guarantee
1708 # that its STACK_BOUNDARY is
>= the reguired vector alignment.
1710 # This won
't change for different subtargets so cache the result.
1712 proc check_effective_target_unaligned_stack { } {
1713 global et_unaligned_stack_saved
1715 if [info exists et_unaligned_stack_saved] {
1716 verbose "check_effective_target_unaligned_stack: using cached result" 2
1718 set et_unaligned_stack_saved 0
1719 if { ( [istarget i?86-*-*] || [istarget x86_64-*-*] )
1720 && (! [istarget *-*-darwin*] ) } {
1721 set et_unaligned_stack_saved 1
1724 verbose "check_effective_target_unaligned_stack: returning $et_unaligned_stack_saved" 2
1725 return $et_unaligned_stack_saved
1728 # Return 1 if the target plus current options does not support a vector
1729 # alignment mechanism, 0 otherwise.
1731 # This won't change
for different subtargets so
cache the result.
1733 proc check_effective_target_vect_no_align
{ } {
1734 global et_vect_no_align_saved
1736 if [info exists et_vect_no_align_saved
] {
1737 verbose
"check_effective_target_vect_no_align: using cached result" 2
1739 set et_vect_no_align_saved
0
1740 if { [istarget mipsisa64
*-*-*]
1741 ||
[istarget sparc
*-*-*]
1742 ||
[istarget ia64
-*-*] } {
1743 set et_vect_no_align_saved
1
1746 verbose
"check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
1747 return $et_vect_no_align_saved
1750 #
Return 1 if arrays are aligned to the vector alignment
1751 # boundary
, 0 otherwise.
1753 # This won
't change for different subtargets so cache the result.
1755 proc check_effective_target_vect_aligned_arrays { } {
1756 global et_vect_aligned_arrays
1758 if [info exists et_vect_aligned_arrays_saved] {
1759 verbose "check_effective_target_vect_aligned_arrays: using cached result" 2
1761 set et_vect_aligned_arrays_saved 0
1762 if { (([istarget x86_64-*-*]
1763 || [istarget i?86-*-*]) && [is-effective-target lp64])
1764 || [istarget spu-*-*] } {
1765 set et_vect_aligned_arrays_saved 1
1768 verbose "check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
1769 return $et_vect_aligned_arrays_saved
1772 # Return 1 if types of size 32 bit or less are naturally aligned
1773 # (aligned to their type-size), 0 otherwise.
1775 # This won't change
for different subtargets so
cache the result.
1777 proc check_effective_target_natural_alignment_32
{ } {
1778 global et_natural_alignment_32
1780 if [info exists et_natural_alignment_32_saved
] {
1781 verbose
"check_effective_target_natural_alignment_32: using cached result" 2
1783 # FIXME
: 32bit powerpc
: guaranteed only
if MASK_ALIGN_NATURAL
/POWER.
1784 set et_natural_alignment_32_saved
1
1785 if { ([istarget
*-*-darwin
*] && [is
-effective
-target lp64
]) } {
1786 set et_natural_alignment_32_saved
0
1789 verbose
"check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
1790 return $et_natural_alignment_32_saved
1793 #
Return 1 if types of size
64 bit or less are naturally aligned
(aligned to their
1794 # type
-size
), 0 otherwise.
1796 # This won
't change for different subtargets so cache the result.
1798 proc check_effective_target_natural_alignment_64 { } {
1799 global et_natural_alignment_64
1801 if [info exists et_natural_alignment_64_saved] {
1802 verbose "check_effective_target_natural_alignment_64: using cached result" 2
1804 set et_natural_alignment_64_saved 0
1805 if { ([is-effective-target lp64] && ![istarget *-*-darwin*])
1806 || [istarget spu-*-*] } {
1807 set et_natural_alignment_64_saved 1
1810 verbose "check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
1811 return $et_natural_alignment_64_saved
1814 # Return 1 if vector alignment (for types of size 32 bit or less) is reachable, 0 otherwise.
1816 # This won't change
for different subtargets so
cache the result.
1818 proc check_effective_target_vector_alignment_reachable
{ } {
1819 global et_vector_alignment_reachable
1821 if [info exists et_vector_alignment_reachable_saved
] {
1822 verbose
"check_effective_target_vector_alignment_reachable: using cached result" 2
1824 if { [check_effective_target_vect_aligned_arrays
]
1825 ||
[check_effective_target_natural_alignment_32
] } {
1826 set et_vector_alignment_reachable_saved
1
1828 set et_vector_alignment_reachable_saved
0
1831 verbose
"check_effective_target_vector_alignment_reachable: returning $et_vector_alignment_reachable_saved" 2
1832 return $et_vector_alignment_reachable_saved
1835 #
Return 1 if vector alignment
for 64 bit is reachable
, 0 otherwise.
1837 # This won
't change for different subtargets so cache the result.
1839 proc check_effective_target_vector_alignment_reachable_for_64bit { } {
1840 global et_vector_alignment_reachable_for_64bit
1842 if [info exists et_vector_alignment_reachable_for_64bit_saved] {
1843 verbose "check_effective_target_vector_alignment_reachable_for_64bit: using cached result" 2
1845 if { [check_effective_target_vect_aligned_arrays]
1846 || [check_effective_target_natural_alignment_64] } {
1847 set et_vector_alignment_reachable_for_64bit_saved 1
1849 set et_vector_alignment_reachable_for_64bit_saved 0
1852 verbose "check_effective_target_vector_alignment_reachable_for_64bit: returning $et_vector_alignment_reachable_for_64bit_saved" 2
1853 return $et_vector_alignment_reachable_for_64bit_saved
1856 # Return 1 if the target supports vector conditional operations, 0 otherwise.
1858 proc check_effective_target_vect_condition { } {
1859 global et_vect_cond_saved
1861 if [info exists et_vect_cond_saved] {
1862 verbose "check_effective_target_vect_cond: using cached result" 2
1864 set et_vect_cond_saved 0
1865 if { [istarget powerpc*-*-*]
1866 || [istarget ia64-*-*]
1867 || [istarget i?86-*-*]
1868 || [istarget spu-*-*]
1869 || [istarget x86_64-*-*] } {
1870 set et_vect_cond_saved 1
1874 verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
1875 return $et_vect_cond_saved
1878 # Return 1 if the target supports vector char multiplication, 0 otherwise.
1880 proc check_effective_target_vect_char_mult { } {
1881 global et_vect_char_mult_saved
1883 if [info exists et_vect_char_mult_saved] {
1884 verbose "check_effective_target_vect_char_mult: using cached result" 2
1886 set et_vect_char_mult_saved 0
1887 if { [istarget ia64-*-*]
1888 || [istarget i?86-*-*]
1889 || [istarget x86_64-*-*] } {
1890 set et_vect_char_mult_saved 1
1894 verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
1895 return $et_vect_char_mult_saved
1898 # Return 1 if the target supports vector short multiplication, 0 otherwise.
1900 proc check_effective_target_vect_short_mult { } {
1901 global et_vect_short_mult_saved
1903 if [info exists et_vect_short_mult_saved] {
1904 verbose "check_effective_target_vect_short_mult: using cached result" 2
1906 set et_vect_short_mult_saved 0
1907 if { [istarget ia64-*-*]
1908 || [istarget spu-*-*]
1909 || [istarget i?86-*-*]
1910 || [istarget x86_64-*-*] } {
1911 set et_vect_short_mult_saved 1
1915 verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
1916 return $et_vect_short_mult_saved
1919 # Return 1 if the target supports vector int multiplication, 0 otherwise.
1921 proc check_effective_target_vect_int_mult { } {
1922 global et_vect_int_mult_saved
1924 if [info exists et_vect_int_mult_saved] {
1925 verbose "check_effective_target_vect_int_mult: using cached result" 2
1927 set et_vect_int_mult_saved 0
1928 if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
1929 || [istarget spu-*-*]
1930 || [istarget i?86-*-*]
1931 || [istarget x86_64-*-*] } {
1932 set et_vect_int_mult_saved 1
1936 verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
1937 return $et_vect_int_mult_saved
1940 # Return 1 if the target supports vector even/odd elements extraction, 0 otherwise.
1942 proc check_effective_target_vect_extract_even_odd { } {
1943 global et_vect_extract_even_odd_saved
1945 if [info exists et_vect_extract_even_odd_saved] {
1946 verbose "check_effective_target_vect_extract_even_odd: using cached result" 2
1948 set et_vect_extract_even_odd_saved 0
1949 if { [istarget powerpc*-*-*] } {
1950 set et_vect_extract_even_odd_saved 1
1954 verbose "check_effective_target_vect_extract_even_odd: returning $et_vect_extract_even_odd_saved" 2
1955 return $et_vect_extract_even_odd_saved
1958 # Return 1 if the target supports vector interleaving, 0 otherwise.
1960 proc check_effective_target_vect_interleave { } {
1961 global et_vect_interleave_saved
1963 if [info exists et_vect_interleave_saved] {
1964 verbose "check_effective_target_vect_interleave: using cached result" 2
1966 set et_vect_interleave_saved 0
1967 if { [istarget powerpc*-*-*]
1968 || [istarget i?86-*-*]
1969 || [istarget x86_64-*-*] } {
1970 set et_vect_interleave_saved 1
1974 verbose "check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
1975 return $et_vect_interleave_saved
1978 # Return 1 if the target supports vector interleaving and extract even/odd, 0 otherwise.
1979 proc check_effective_target_vect_strided { } {
1980 global et_vect_strided_saved
1982 if [info exists et_vect_strided_saved] {
1983 verbose "check_effective_target_vect_strided: using cached result" 2
1985 set et_vect_strided_saved 0
1986 if { [check_effective_target_vect_interleave]
1987 && [check_effective_target_vect_extract_even_odd] } {
1988 set et_vect_strided_saved 1
1992 verbose "check_effective_target_vect_strided: returning $et_vect_strided_saved" 2
1993 return $et_vect_strided_saved
1996 # Return 1 if the target supports section-anchors
1998 proc check_effective_target_section_anchors { } {
1999 global et_section_anchors_saved
2001 if [info exists et_section_anchors_saved] {
2002 verbose "check_effective_target_section_anchors: using cached result" 2
2004 set et_section_anchors_saved 0
2005 if { [istarget powerpc*-*-*] } {
2006 set et_section_anchors_saved 1
2010 verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
2011 return $et_section_anchors_saved
2014 # Return 1 if the target supports atomic operations on "int" and "long".
2016 proc check_effective_target_sync_int_long { } {
2017 global et_sync_int_long_saved
2019 if [info exists et_sync_int_long_saved] {
2020 verbose "check_effective_target_sync_int_long: using cached result" 2
2022 set et_sync_int_long_saved 0
2023 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2024 #
load-reserved/store
-conditional instructions.
2025 if { [istarget ia64
-*-*]
2026 ||
[istarget i?
86-*-*]
2027 ||
[istarget x86_64
-*-*]
2028 ||
[istarget alpha
*-*-*]
2029 ||
[istarget s390
*-*-*]
2030 ||
[istarget powerpc
*-*-*]
2031 ||
[istarget sparc64
-*-*]
2032 ||
[istarget sparcv9
-*-*] } {
2033 set et_sync_int_long_saved
1
2037 verbose
"check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2038 return $et_sync_int_long_saved
2041 #
Return 1 if the target supports atomic operations
on "char" and "short".
2043 proc check_effective_target_sync_char_short
{ } {
2044 global et_sync_char_short_saved
2046 if [info exists et_sync_char_short_saved
] {
2047 verbose
"check_effective_target_sync_char_short: using cached result" 2
2049 set et_sync_char_short_saved
0
2050 # This is intentionally powerpc but not rs6000
, rs6000 doesn
't have the
2051 # load-reserved/store-conditional instructions.
2052 if { [istarget ia64-*-*]
2053 || [istarget i?86-*-*]
2054 || [istarget x86_64-*-*]
2055 || [istarget alpha*-*-*]
2056 || [istarget s390*-*-*]
2057 || [istarget powerpc*-*-*]
2058 || [istarget sparc64-*-*]
2059 || [istarget sparcv9-*-*] } {
2060 set et_sync_char_short_saved 1
2064 verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2065 return $et_sync_char_short_saved
2068 # Return 1 if the target uses a ColdFire FPU.
2070 proc check_effective_target_coldfire_fpu { } {
2071 return [check_no_compiler_messages coldfire_fpu assembly {
2078 # Return true if this is a uClibc target.
2080 proc check_effective_target_uclibc {} {
2081 return [check_no_compiler_messages uclibc object {
2082 #include <features.h>
2083 #if !defined (__UCLIBC__)
2089 # Return true if this is a uclibc target and if the uclibc feature
2090 # described by __$feature__ is not present.
2092 proc check_missing_uclibc_feature {feature} {
2093 return [check_no_compiler_messages $feature object "
2094 #include <features.h>
2095 #if !defined (__UCLIBC) || defined (__${feature}__)
2101 # Return true if this is a Newlib target.
2103 proc check_effective_target_newlib {} {
2104 return [check_no_compiler_messages newlib object {
2110 # (a) an error of a few ULP is expected in string to floating-point
2111 # conversion functions; and
2112 # (b) overflow is not always detected correctly by those functions.
2114 proc check_effective_target_lax_strtofp {} {
2115 # By default, assume that all uClibc targets suffer from this.
2116 return [check_effective_target_uclibc]
2119 # Return 1 if this is a target for which wcsftime is a dummy
2120 # function that always returns 0.
2122 proc check_effective_target_dummy_wcsftime {} {
2123 # By default, assume that all uClibc targets suffer from this.
2124 return [check_effective_target_uclibc]
2127 # Return 1 if constructors with initialization priority arguments are
2128 # supposed on this target.
2130 proc check_effective_target_init_priority {} {
2131 return [check_no_compiler_messages init_priority assembly "
2132 void f() __attribute__((constructor (1000)));
2137 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
2138 # This can be used with any check_* proc that takes no argument and
2139 # returns only 1 or 0. It could be used with check_* procs that take
2140 # arguments with keywords that pass particular arguments.
2142 proc is-effective-target { arg } {
2144 if { [info procs check_effective_target_${arg}] != [list] } {
2145 set selected [check_effective_target_${arg}]
2148 "vmx_hw" { set selected [check_vmx_hw_available] }
2149 "named_sections" { set selected [check_named_sections_available] }
2150 "gc_sections" { set selected [check_gc_sections_available] }
2151 "cxa_atexit" { set selected [check_cxa_atexit_available] }
2152 default { error "unknown effective target keyword `$arg'" }
2155 verbose
"is-effective-target: $arg $selected" 2
2159 #
Return 1 if the
argument is an effective
-target keyword
, 0 otherwise.
2161 proc is
-effective
-target
-keyword
{ arg } {
2162 if { [info procs check_effective_target_$
{arg}] != [list
] } {
2165 # These have different names
for their check_
* procs.
2167 "vmx_hw" { return 1 }
2168 "named_sections" { return 1 }
2169 "gc_sections" { return 1 }
2170 "cxa_atexit" { return 1 }
2171 default
{ return 0 }
2176 #
Return 1 if target default to short enums
2178 proc check_effective_target_short_enums
{ } {
2179 return [check_no_compiler_messages short_enums assembly
{
2181 int s
[sizeof
(enum foo
) == 1 ?
1 : -1];
2185 #
Return 1 if target supports merging string constants at link time.
2187 proc check_effective_target_string_merging
{ } {
2188 return [check_no_messages_and_pattern string_merging \
2189 "rodata\\.str" assembly {
2190 const char
*var
= "String";
2194 #
Return 1 if target has the basic signed and unsigned types in
2195 #
<stdint.h
>, 0 otherwise.
2197 proc check_effective_target_stdint_types
{ } {
2198 return [check_no_compiler_messages stdint_types assembly
{
2200 int8_t a
; int16_t b
; int32_t c
; int64_t d
;
2201 uint8_t e
; uint16_t f
; uint32_t g
; uint64_t h
;
2205 #
Return 1 if programs are intended to be run
on a simulator
2206 #
(i.e. slowly
) rather than hardware
(i.e. fast
).
2208 proc check_effective_target_simulator
{ } {
2210 # All
"src/sim" simulators set this one.
2211 if [board_info target
exists is_simulator
] {
2212 return [board_info target is_simulator
]
2215 # The
"sid" simulators don't set that one, but at least they set
2217 if [board_info target
exists slow_simulator
] {
2218 return [board_info target slow_simulator
]
2224 #
Return 1 if the target is a VxWorks kernel.
2226 proc check_effective_target_vxworks_kernel
{ } {
2227 return [check_no_compiler_messages vxworks_kernel assembly
{
2228 #
if !defined __vxworks || defined __RTP__
2234 #
Return 1 if the target is a VxWorks RTP.
2236 proc check_effective_target_vxworks_rtp
{ } {
2237 return [check_no_compiler_messages vxworks_rtp assembly
{
2238 #
if !defined __vxworks ||
!defined __RTP__
2244 #
Return 1 if the target is expected to provide wide character support.
2246 proc check_effective_target_wchar
{ } {
2247 if {[check_missing_uclibc_feature UCLIBC_HAS_WCHAR
]} {
2250 return [check_no_compiler_messages wchar assembly
{
2255 #
Return 1 if the target has
<pthread.h
>.
2257 proc check_effective_target_pthread_h
{ } {
2258 return [check_no_compiler_messages pthread_h assembly
{
2259 #
include <pthread.h
>
2263 #
Return 1 if the target can truncate a file from a file
-descriptor
,
2264 # as used by libgfortran
/io
/unix.c
:fd_truncate
; i.e. ftruncate or
2265 # chsize. We test
for a trivially functional truncation
; no stubs.
2266 # As libgfortran uses _FILE_OFFSET_BITS
64, we
do too
; it
'll cause a
2267 # different function to be used.
2269 proc check_effective_target_fd_truncate { } {
2271 #define _FILE_OFFSET_BITS 64
2277 FILE *f = fopen ("tst.tmp", "wb");
2279 const char t[] = "test writing more than ten characters";
2282 write (fd, t, sizeof (t) - 1);
2284 if (ftruncate (fd, 10) != 0)
2287 f = fopen ("tst.tmp", "rb");
2288 if (fread (s, 1, sizeof (s), f) != 10 || strncmp (s, t, 10) != 0)
2294 if { [check_runtime ftruncate $prog] } {
2298 regsub "ftruncate" $prog "chsize" prog
2299 return [check_runtime chsize $prog]
2302 # Add to FLAGS all the target-specific flags needed to access the c99 runtime.
2304 proc add_options_for_c99_runtime { flags } {
2305 if { [istarget *-*-solaris2*] } {
2306 return "$flags -std=c99"
2308 if { [istarget powerpc-*-darwin*] } {
2309 return "$flags -mmacosx-version-min=10.3"
2314 # Return 1 if the target provides a full C99 runtime.
2316 proc check_effective_target_c99_runtime { } {
2317 return [check_cached_effective_target c99_runtime {
2320 set file [open "$srcdir/gcc.dg/builtins-config.h"]
2321 set contents [read $file]
2324 #ifndef HAVE_C99_RUNTIME
2328 check_no_compiler_messages_nocache c99_runtime assembly \
2329 $contents [add_options_for_c99_runtime ""]