OSDN Git Service

PR testsuite/34168
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / lib / target-supports.exp
1 #   Copyright (C) 1999, 2001, 2003, 2004, 2005, 2006, 2007
2 #    Free Software Foundation, Inc.
3
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.
8 #
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.
13 #
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/>.
17
18 # Please email any bugs, comments, and/or additions to this file to:
19 # gcc-patches@gcc.gnu.org
20
21 # This file defines procs for determining features supported by the target.
22
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.
27 #
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.
31 #
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} {
35     global tool
36
37     if { [llength $args] > 0 } {
38         set options [list "additional_flags=[lindex $args 0]"]
39     } else {
40         set options ""
41     }
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 }
46     }
47     set compile_type $type
48     switch -glob $type {
49         assembly { set output ${basename}[pid].s }
50         object { set output ${basename}[pid].o }
51         executable { set output ${basename}[pid].exe }
52         "rtl-*" {
53             set output ${basename}[pid].s
54             lappend options "additional_flags=-fdump-$type"
55             set compile_type assembly
56         }
57     }
58     set f [open $src "w"]
59     puts $f $contents
60     close $f
61     set lines [${tool}_target_compile $src $output $compile_type "$options"]
62     file delete $src
63
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]"
69         file delete $output
70     }
71
72     return [list $lines $scan_output]
73 }
74
75 proc current_target_name { } {
76     global target_info
77     if [info exists target_info(target,name)] {
78         set answer $target_info(target,name)
79     } else {
80         set answer ""
81     }
82     return $answer
83 }
84
85 # Implement an effective-target check for property PROP by invoking
86 # the Tcl command ARGS and seeing if it returns true.
87
88 proc check_cached_effective_target { prop args } {
89     global et_cache
90
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]
97     }
98     set value $et_cache($prop,value)
99     verbose "check_cached_effective_target $prop: returning $value for $target" 2
100     return $value
101 }
102
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]
111 }
112
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
119     }]
120 }
121
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.)
129 #
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} {
133     global tool
134
135     set result [eval [list check_compile $basename] $args]
136     set lines [lindex $result 0]
137     set output [lindex $result 1]
138
139     set ok 0
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 }]
144         close $chan
145     }
146
147     remote_file build delete $output
148     return $ok
149 }
150
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
157     }]
158 }
159
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} {
165     global tool
166
167     set result [eval [list check_compile $basename executable $contents] $args]
168     set lines [lindex $result 0]
169     set output [lindex $result 1]
170
171     set ok 0
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" } {
178             set ok 1
179         }
180     }
181     remote_file build delete $output
182     return $ok
183 }
184
185 # Like check_runtime_nocache, but cache the result.  PROP is the
186 # property we're checking, and doubles as a prefix for temporary
187 # filenames.
188 proc check_runtime {prop args} {
189     global tool
190
191     return [check_cached_effective_target $prop {
192         eval [list check_runtime_nocache $prop] $args
193     }]
194 }
195
196 ###############################
197 # proc check_weak_available { }
198 ###############################
199
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
202
203 proc check_weak_available { } {
204     global target_triplet
205     global target_cpu
206
207     # All mips targets should support it
208
209     if { [ string first "mips" $target_cpu ] >= 0 } {
210         return 1
211     }
212
213     # All solaris2 targets should support it
214
215     if { [regexp ".*-solaris2.*" $target_triplet] } {
216         return 1
217     }
218
219     # DEC OSF/1/Digital UNIX/Tru64 UNIX supports it
220
221     if { [regexp "alpha.*osf.*" $target_triplet] } {
222         return 1
223     }
224
225     # Windows targets Cygwin and MingW32 support it
226
227     if { [regexp ".*mingw32|.*cygwin" $target_triplet] } {
228         return 1
229     }
230
231     # HP-UX 10.X doesn't support it
232
233     if { [istarget "hppa*-*-hpux10*"] } {
234         return 0
235     }
236
237     # ELF and ECOFF support it. a.out does with gas/gld but may also with
238     # other linkers, so we should try it
239
240     set objformat [gcc_target_object_format]
241
242     switch $objformat {
243         elf      { return 1 }
244         ecoff    { return 1 }
245         a.out    { return 1 }
246         mach-o   { return 1 }
247         som      { return 1 }
248         unknown  { return -1 }
249         default  { return 0 }
250     }
251 }
252
253 ###############################
254 # proc check_visibility_available { what_kind }
255 ###############################
256
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.
260
261 proc check_visibility_available { what_kind } {
262     global tool
263     global target_triplet
264
265     # On NetWare, support makes no sense.
266     if { [istarget *-*-netware*] } {
267         return 0
268     }
269
270     if [string match "" $what_kind] { set what_kind "hidden" }
271
272     return [check_no_compiler_messages visibility_available_$what_kind object "
273         void f() __attribute__((visibility(\"$what_kind\")));
274         void f() {}
275     "]
276 }
277
278 ###############################
279 # proc check_alias_available { }
280 ###############################
281
282 # Determine if the target toolchain supports the alias attribute.
283
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
287 # be determined.
288
289 proc check_alias_available { } {
290     global alias_available_saved
291     global tool
292
293     if [info exists alias_available_saved] {
294         verbose "check_alias_available  returning saved $alias_available_saved" 2
295     } else {
296         set src alias[pid].c
297         set obj alias[pid].o
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
302         # about the program.
303         puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
304         puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
305         close $f
306         set lines [${tool}_target_compile $src $obj object ""]
307         file delete $src
308         remote_file build delete $obj
309
310         if [string match "" $lines] then {
311             # No error messages, everything is OK.
312             set alias_available_saved 2
313         } else {
314             if [regexp "alias definitions not supported" $lines] {
315                 verbose "check_alias_available  target does not support aliases" 2
316
317                 set objformat [gcc_target_object_format]
318
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
322                 } else {
323                     set alias_available_saved 0
324                 }
325             } else {
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
329                 } else {
330                     set alias_available_saved -1
331                 }
332             }
333         }
334
335         verbose "check_alias_available  returning $alias_available_saved" 2
336     }
337
338     return $alias_available_saved
339 }
340
341 # Returns true if --gc-sections is supported on the target.
342
343 proc check_gc_sections_available { } {
344     global gc_sections_available_saved
345     global tool
346
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
353             return 0
354         }
355
356         # elf2flt uses -q (--emit-relocs), which is incompatible with
357         # --gc-sections.
358         if { [board_info target exists ldflags]
359              && [regexp " -elf2flt\[ =\]" " [board_info target ldflags] "] } {
360             set gc_sections_available_saved 0
361             return 0
362         }
363
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
369             return 0
370         }
371
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
379         } else {
380             set gc_sections_available_saved 0
381         }
382     }
383     return $gc_sections_available_saved
384 }
385
386 # Return true if profiling is supported on the target.
387
388 proc check_profiling_available { test_what } {
389     global profiling_available_saved
390
391     verbose "Profiling argument is <$test_what>" 1
392
393     # These conditions depend on the argument so examine them before
394     # looking at the cache variable.
395
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" } {
401         return 0
402     }
403
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") } {
410         return 0
411     }
412
413     # MinGW does not support -p.
414     if { [istarget *-*-mingw*] && [lindex $test_what 1] == "-p" } {
415         return 0
416     }
417
418     # At present, there is no profiling support on NetWare.
419     if { [istarget *-*-netware*] } {
420         return 0
421     }
422
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") } {
427         return 0
428     }
429
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
455         } else {
456             set profiling_available_saved 1
457         }
458     }
459
460     return $profiling_available_saved
461 }
462
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
466 # false.
467
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];
472     }]
473 }
474
475 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
476 # documentation, where the test also comes from.
477
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];
485     }]
486 }
487
488 # Return 1 if thread local storage (TLS) is supported, 0 otherwise.
489 #
490 # This won't change for different subtargets so cache the result.
491
492 proc check_effective_target_tls {} {
493     return [check_no_compiler_messages tls assembly {
494         __thread int i;
495         int f (void) { return i; }
496         void g (int j) { i = j; }
497     }]
498 }
499
500 # Return 1 if *native* thread local storage (TLS) is supported, 0 otherwise.
501 #
502 # This won't change for different subtargets so cache the result.
503
504 proc check_effective_target_tls_native {} {
505     return [check_no_messages_and_pattern tls_native "!emutls" assembly {
506         __thread int i;
507         int f (void) { return i; }
508         void g (int j) { i = j; }
509     }]
510 }
511
512 # Return 1 if TLS executables can run correctly, 0 otherwise.
513 #
514 # This won't change for different subtargets so cache the result.
515
516 proc check_effective_target_tls_runtime {} {
517     return [check_runtime tls_runtime {
518         __thread int thr = 0;
519         int main (void) { return thr; }
520     }]
521 }
522
523 # Return 1 if compilation with -fopenmp is error-free for trivial
524 # code, 0 otherwise.
525
526 proc check_effective_target_fopenmp {} {
527     return [check_no_compiler_messages fopenmp object {
528         void foo (void) { }
529     } "-fopenmp"]
530 }
531
532 # Return 1 if compilation with -pthread is error-free for trivial
533 # code, 0 otherwise.
534
535 proc check_effective_target_pthread {} {
536     return [check_no_compiler_messages pthread object {
537         void foo (void) { }
538     } "-pthread"]
539 }
540
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"]
546 }
547
548 # Return 1 if compilation with -freorder-blocks-and-partition is error-free
549 # for trivial code, 0 otherwise.
550
551 proc check_effective_target_freorder {} {
552     return [check_no_compiler_messages freorder object {
553         void foo (void) { }
554     } "-freorder-blocks-and-partition"]
555 }
556
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.
560
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; }
569         } "-$arg"] {
570             return 1
571         }
572     }
573     return 0
574 }
575
576 # Return true if the target supports -mpaired-single (as used on MIPS).
577
578 proc check_effective_target_mpaired_single { } {
579     return [check_no_compiler_messages mpaired_single object {
580         void foo (void) { }
581     } "-mpaired-single"]
582 }
583
584 # Return true if the target has access to FPU instructions.
585
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)
590                 #error FOO
591                 #endif
592         }]
593     }
594
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; }
598     }]
599 }
600
601 # Return true if the target is a 64-bit MIPS target.
602
603 proc check_effective_target_mips64 { } {
604     return [check_no_compiler_messages mips64 assembly {
605         #ifndef __mips64
606         #error FOO
607         #endif
608     }]
609 }
610
611 # Return true if the target is a MIPS target that does not produce
612 # MIPS16 code.
613
614 proc check_effective_target_nomips16 { } {
615     return [check_no_compiler_messages nomips16 object {
616         #ifndef __mips
617         #error FOO
618         #else
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"); }
622         #endif
623     }]
624 }
625
626 # Add the options needed for MIPS16 function attributes.  At the moment,
627 # we don't support MIPS16 PIC.
628
629 proc add_options_for_mips16_attribute { flags } {
630     return "$flags -mno-abicalls -fno-pic"
631 }
632
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
635 # for o32 and o64.
636
637 proc check_effective_target_mips16_attribute { } {
638     return [check_no_compiler_messages mips16_attribute assembly {
639         #ifdef PIC
640         #error FOO
641         #endif
642         #if defined __mips_hard_float \
643             && (!defined _ABIO32 || _MIPS_SIM != _ABIO32) \
644             && (!defined _ABIO64 || _MIPS_SIM != _ABIO64)
645         #error FOO
646         #endif
647     } [add_options_for_mips16_attribute ""]]
648 }
649
650 # Return 1 if the current multilib does not generate PIC by default.
651
652 proc check_effective_target_nonpic { } {
653     return [check_no_compiler_messages nonpic assembly {
654         #if __PIC__
655         #error FOO
656         #endif
657     }]
658 }
659
660 # Return 1 if the target does not use a status wrapper.
661
662 proc check_effective_target_unwrapped { } {
663     if { [target_info needs_status_wrapper] != "" \
664              && [target_info needs_status_wrapper] != "0" } {
665         return 0
666     }
667     return 1
668 }
669
670 # Return true if iconv is supported on the target. In particular IBM1047.
671
672 proc check_iconv_available { test_what } {
673     global libiconv
674
675     # If the tool configuration file has not set libiconv, try "-liconv"
676     if { ![info exists libiconv] } {
677         set libiconv "-liconv"
678     }
679     set test_what [lindex $test_what 1]
680     return [check_runtime_nocache $test_what [subst {
681         #include <iconv.h>
682         int main (void)
683         {
684           iconv_t cd;
685
686           cd = iconv_open ("$test_what", "UTF-8");
687           if (cd == (iconv_t) -1)
688             return 1;
689           return 0;
690         }
691     }] $libiconv]
692 }
693
694 # Return true if named sections are supported on this target.
695
696 proc check_named_sections_available { } {
697     return [check_no_compiler_messages named_sections assembly {
698         int __attribute__ ((section("whatever"))) foo;
699     }]
700 }
701
702 # Return 1 if the target supports Fortran real kinds larger than real(8),
703 # 0 otherwise.
704 #
705 # When the target name changes, replace the cached result.
706
707 proc check_effective_target_fortran_large_real { } {
708     return [check_no_compiler_messages fortran_large_real executable {
709         ! Fortran
710         integer,parameter :: k = selected_real_kind (precision (0.0_8) + 1)
711         real(kind=k) :: x
712         x = cos (x)
713         end
714     }]
715 }
716
717 # Return 1 if the target supports Fortran integer kinds larger than
718 # integer(8), 0 otherwise.
719 #
720 # When the target name changes, replace the cached result.
721
722 proc check_effective_target_fortran_large_int { } {
723     return [check_no_compiler_messages fortran_large_int executable {
724         ! Fortran
725         integer,parameter :: k = selected_int_kind (range (0_8) + 1)
726         integer(kind=k) :: i
727         end
728     }]
729 }
730
731 # Return 1 if we can statically link libgfortran, 0 otherwise.
732 #
733 # When the target name changes, replace the cached result.
734
735 proc check_effective_target_static_libgfortran { } {
736     return [check_no_compiler_messages static_libgfortran executable {
737         ! Fortran
738         print *, 'test'
739         end
740     } "-static"]
741 }
742
743 # Return 1 if the target supports executing 750CL paired-single instructions, 0
744 # otherwise.  Cache the result.
745
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*] } {
750             expr 0
751         } else {
752             check_runtime_nocache 750cl_hw_available {
753                  int main()
754                  {
755                  #ifdef __MACH__
756                    asm volatile ("ps_mul v0,v0,v0");
757                  #else
758                    asm volatile ("ps_mul 0,0,0");
759                  #endif
760                    return 0;
761                  }
762             } "-mpaired"
763         }
764     }]
765 }
766
767 # Return 1 if the target supports executing SSE2 instructions, 0
768 # otherwise.  Cache the result.
769
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-*-*]) } {
774             expr 0
775         } else {
776             check_runtime_nocache sse2_hw_available {
777                 #include "cpuid.h"
778                 int main ()
779                 {
780                   unsigned int eax, ebx, ecx, edx = 0;
781                   if (__get_cpuid (1, &eax, &ebx, &ecx, &edx))
782                     return !(edx & bit_SSE2);
783                   return 1;
784                 }
785             } ""
786         }
787     }]
788 }
789
790 # Return 1 if the target supports executing AltiVec instructions, 0
791 # otherwise.  Cache the result.
792
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] } {
797             expr 0
798         } else {
799             # Most targets don't require special flags for this test case, but
800             # Darwin does.
801             if { [istarget *-*-darwin*]
802                  || [istarget *-*-aix*] } {
803                 set options "-maltivec"
804             } else {
805                 set options ""
806             }
807             check_runtime_nocache vmx_hw_available {
808                 int main()
809                 {
810                 #ifdef __MACH__
811                   asm volatile ("vor v0,v0,v0");
812                 #else
813                   asm volatile ("vor 0,0,0");
814                 #endif
815                   return 0;
816                 }
817             } $options
818         }
819     }]
820 }
821
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.
826 #
827 # When the target name changes, replace the cached result.
828
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*] } {
833             expr 0
834         } elseif { ![is-effective-target lp64] } {
835             expr 0
836         } else {
837             check_runtime_nocache broken_cplxf_arg {
838                 #include <complex.h>
839                 extern void abort (void);
840                 float fabsf (float);
841                 float cabsf (_Complex float);
842                 int main ()
843                 {
844                   _Complex float cf;
845                   float f;
846                   cf = 3 + 4.0fi;
847                   f = cabsf (cf);
848                   if (fabsf (f - 5.0) > 0.0001)
849                     abort ();
850                   return 0;
851                 }
852             } "-lm"
853         }
854     }]
855 }
856
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; }
860     }]
861 }
862
863 # Returns true iff the FUNCTION is available on the target system.
864 # (This is essentially a Tcl implementation of Autoconf's
865 # AC_CHECK_FUNC.)
866
867 proc check_function_available { function } {
868     return [check_no_compiler_messages ${function}_available \
869                 executable [subst {
870         #ifdef __cplusplus
871         extern "C"
872         #endif
873         char $function ();
874         int main () { $function (); }
875     }]]
876 }
877
878 # Returns true iff "fork" is available on the target system.
879
880 proc check_fork_available {} {
881     return [check_function_available "fork"]
882 }
883
884 # Returns true iff "mkfifo" is available on the target system.
885
886 proc check_mkfifo_available {} {
887     if {[istarget *-*-cygwin*]} {
888        # Cygwin has mkfifo, but support is incomplete.
889        return 0
890      }
891
892     return [check_function_available "mkfifo"]
893 }
894
895 # Returns true iff "__cxa_atexit" is used on the target system.
896
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.
901             expr 0
902         } else {
903             check_runtime_nocache cxa_atexit_available {
904                 // C++
905                 #include <stdlib.h>
906                 static unsigned int count;
907                 struct X
908                 {
909                   X() { count = 1; }
910                   ~X()
911                   {
912                     if (count != 3)
913                       exit(1);
914                     count = 4;
915                   }
916                 };
917                 void f()
918                 {
919                   static X x;
920                 }
921                 struct Y
922                 {
923                   Y() { f(); count = 2; }
924                   ~Y()
925                   {
926                     if (count != 2)
927                       exit(1);
928                     count = 3;
929                   }
930                 };
931                 Y y;
932                 int main() { return 0; }
933             }
934         }
935     }]
936 }
937
938
939 # Return 1 if we're generating 32-bit code using default options, 0
940 # otherwise.
941
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];
947     }]
948 }
949
950 # Return 1 if we're generating 32-bit or larger integers using default
951 # options, 0 otherwise.
952
953 proc check_effective_target_int32plus { } {
954     return [check_no_compiler_messages int32plus object {
955         int dummy[sizeof (int) >= 4 ? 1 : -1];
956     }]
957 }
958
959 # Return 1 if we're generating 32-bit or larger pointers using default
960 # options, 0 otherwise.
961
962 proc check_effective_target_ptr32plus { } {
963     return [check_no_compiler_messages ptr32plus object {
964         int dummy[sizeof (void *) >= 4 ? 1 : -1];
965     }]
966 }
967
968 # Return 1 if we support 32-bit or larger array and structure sizes
969 # using default options, 0 otherwise.
970
971 proc check_effective_target_size32plus { } {
972     return [check_no_compiler_messages size32plus object {
973         char dummy[65537];
974     }]
975 }
976
977 # Returns 1 if we're generating 16-bit or smaller integers with the
978 # default options, 0 otherwise.
979
980 proc check_effective_target_int16 { } {
981     return [check_no_compiler_messages int16 object {
982         int dummy[sizeof (int) < 4 ? 1 : -1];
983     }]
984 }
985
986 # Return 1 if we're generating 64-bit code using default options, 0
987 # otherwise.
988
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];
994     }]
995 }
996
997 # Return 1 if the target supports long double larger than double,
998 # 0 otherwise.
999
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];
1003     }]
1004 }
1005
1006 # Return 1 if the target supports compiling fixed-point,
1007 # 0 otherwise.
1008
1009 proc check_effective_target_fixed_point { } {
1010     return [check_no_compiler_messages fixed_point object {
1011         _Sat _Fract x; _Sat _Accum y;
1012     }]
1013 }
1014
1015 # Return 1 if the target supports compiling decimal floating point,
1016 # 0 otherwise.
1017
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;
1022     }]
1023     verbose "check_effective_target_dfp_nocache: returning $ret" 2
1024     return $ret
1025 }
1026
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; }
1031     }]
1032 }
1033
1034 # Return 1 if the target supports compiling Decimal Floating Point,
1035 # 0 otherwise.
1036 #
1037 # This won't change for different subtargets so cache the result.
1038
1039 proc check_effective_target_dfp { } {
1040     return [check_cached_effective_target dfp {
1041         check_effective_target_dfp_nocache
1042     }]
1043 }
1044
1045 # Return 1 if the target supports linking and executing Decimal Floating
1046 # Point, # 0 otherwise.
1047 #
1048 # This won't change for different subtargets so cache the result.
1049
1050 proc check_effective_target_dfprt { } {
1051     return [check_cached_effective_target dfprt {
1052         check_effective_target_dfprt_nocache
1053     }]
1054 }
1055
1056 # Return 1 if the target needs a command line argument to enable a SIMD
1057 # instruction set.
1058
1059 proc check_effective_target_vect_cmdline_needed { } {
1060     global et_vect_cmdline_needed_saved
1061     global et_vect_cmdline_needed_target_name
1062
1063     if { ![info exists et_vect_cmdline_needed_target_name] } {
1064         set et_vect_cmdline_needed_target_name ""
1065     }
1066
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
1075         }
1076     }
1077
1078     if [info exists et_vect_cmdline_needed_saved] {
1079         verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1080     } else {
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
1089         }
1090     }
1091
1092     verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1093     return $et_vect_cmdline_needed_saved
1094 }
1095
1096 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
1097 #
1098 # This won't change for different subtargets so cache the result.
1099
1100 proc check_effective_target_vect_int { } {
1101     global et_vect_int_saved
1102
1103     if [info exists et_vect_int_saved] {
1104         verbose "check_effective_target_vect_int: using cached result" 2
1105     } else {
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
1116         }
1117     }
1118
1119     verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1120     return $et_vect_int_saved
1121 }
1122
1123 # Return 1 if the target supports int->float conversion 
1124 #
1125
1126 proc check_effective_target_vect_intfloat_cvt { } {
1127     global et_vect_intfloat_cvt_saved
1128
1129     if [info exists et_vect_intfloat_cvt_saved] {
1130         verbose "check_effective_target_vect_intfloat_cvt: using cached result" 2
1131     } else {
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
1138         }
1139     }
1140
1141     verbose "check_effective_target_vect_intfloat_cvt: returning $et_vect_intfloat_cvt_saved" 2
1142     return $et_vect_intfloat_cvt_saved
1143 }
1144
1145
1146 # Return 1 if the target supports float->int conversion
1147 #
1148
1149 proc check_effective_target_vect_floatint_cvt { } {
1150     global et_vect_floatint_cvt_saved
1151
1152     if [info exists et_vect_floatint_cvt_saved] {
1153         verbose "check_effective_target_vect_floatint_cvt: using cached result" 2
1154     } else {
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
1159         }
1160     }
1161
1162     verbose "check_effective_target_vect_floatint_cvt: returning $et_vect_floatint_cvt_saved" 2
1163     return $et_vect_floatint_cvt_saved
1164 }
1165
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__))
1170         #error FOO
1171         #endif
1172     }]
1173 }
1174
1175 # Return 1 if this is an ARM target supporting -mfpu=vfp
1176 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1177 # options.
1178
1179 proc check_effective_target_arm_vfp_ok { } {
1180     if { [check_effective_target_arm32] } {
1181         return [check_no_compiler_messages arm_vfp_ok object {
1182             int dummy;
1183         } "-mfpu=vfp -mfloat-abi=softfp"]
1184     } else {
1185         return 0
1186     }
1187 }
1188
1189 # Return 1 if this is an ARM target supporting -mfpu=neon
1190 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1191 # options.
1192
1193 proc check_effective_target_arm_neon_ok { } {
1194     if { [check_effective_target_arm32] } {
1195         return [check_no_compiler_messages arm_neon_ok object {
1196             int dummy;
1197         } "-mfpu=neon -mfloat-abi=softfp"]
1198     } else {
1199         return 0
1200     }
1201 }
1202
1203 # Return 1 if the target supports executing NEON instructions, 0
1204 # otherwise.  Cache the result.
1205
1206 proc check_effective_target_arm_neon_hw { } {
1207     return [check_runtime arm_neon_hw_available {
1208         int
1209         main (void)
1210         {
1211           long long a = 0, b = 1;
1212           asm ("vorr %P0, %P1, %P2"
1213                : "=w" (a)
1214                : "0" (a), "w" (b));
1215           return (a != 1);
1216         }
1217     } "-mfpu=neon -mfloat-abi=softfp"]
1218 }
1219
1220 # Return 1 if this is a PowerPC target with floating-point registers.
1221
1222 proc check_effective_target_powerpc_fprs { } {
1223     if { [istarget powerpc*-*-*]
1224          || [istarget rs6000-*-*] } {
1225         return [check_no_compiler_messages powerpc_fprs object {
1226             #ifdef __NO_FPRS__
1227             #error no FPRs
1228             #else
1229             int dummy;
1230             #endif
1231         }]
1232     } else {
1233         return 0
1234     }
1235 }
1236
1237 # Return 1 if this is a PowerPC target supporting -maltivec.
1238
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*] } {
1247             return 0
1248         }
1249         return [check_no_compiler_messages powerpc_altivec_ok object {
1250             int dummy;
1251         } "-maltivec"]
1252     } else {
1253         return 0
1254     }
1255 }
1256
1257 # Return 1 if this is a PowerPC target that supports SPU.
1258
1259 proc check_effective_target_powerpc_spu { } {
1260     return [istarget powerpc*-*-linux*]
1261 }
1262
1263 # Return 1 if this is a PowerPC target with SPE enabled.
1264
1265 proc check_effective_target_powerpc_spe { } {
1266     if { [istarget powerpc*-*-*] } {
1267         return [check_no_compiler_messages powerpc_spe object {
1268             #ifndef __SPE__
1269             #error not SPE
1270             #else
1271             int dummy;
1272             #endif
1273         }]
1274     } else {
1275         return 0
1276     }
1277 }
1278
1279 # Return 1 if this is a PowerPC target with Altivec enabled.
1280
1281 proc check_effective_target_powerpc_altivec { } {
1282     if { [istarget powerpc*-*-*] } {
1283         return [check_no_compiler_messages powerpc_altivec object {
1284             #ifndef __ALTIVEC__
1285             #error not Altivec
1286             #else
1287             int dummy;
1288             #endif
1289         }]
1290     } else {
1291         return 0
1292     }
1293 }
1294
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.
1298
1299 proc check_effective_target_ultrasparc_hw { } {
1300     return [check_runtime ultrasparc_hw {
1301         int main() { return 0; }
1302     } "-mcpu=ultrasparc"]
1303 }
1304
1305 # Return 1 if the target supports hardware vector shift operation.
1306
1307 proc check_effective_target_vect_shift { } {
1308     global et_vect_shift_saved
1309
1310     if [info exists et_vect_shift_saved] {
1311         verbose "check_effective_target_vect_shift: using cached result" 2
1312     } else {
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
1320         }
1321     }
1322
1323     verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1324     return $et_vect_shift_saved
1325 }
1326
1327 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1328 #
1329 # This can change for different subtargets so do not cache the result.
1330
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]) } {
1338         set answer 1
1339     } else {
1340         set answer 0
1341     }
1342
1343     verbose "check_effective_target_vect_long: returning $answer" 2
1344     return $answer
1345 }
1346
1347 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1348 #
1349 # This won't change for different subtargets so cache the result.
1350
1351 proc check_effective_target_vect_float { } {
1352     global et_vect_float_saved
1353
1354     if [info exists et_vect_float_saved] {
1355         verbose "check_effective_target_vect_float: using cached result" 2
1356     } else {
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
1365         }
1366     }
1367
1368     verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1369     return $et_vect_float_saved
1370 }
1371
1372 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1373 #
1374 # This won't change for different subtargets so cache the result.
1375
1376 proc check_effective_target_vect_double { } {
1377     global et_vect_double_saved
1378
1379     if [info exists et_vect_double_saved] {
1380         verbose "check_effective_target_vect_double: using cached result" 2
1381     } else {
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
1387         }
1388     }
1389
1390     verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1391     return $et_vect_double_saved
1392 }
1393
1394 # Return 1 if the target plus current options does not support a vector
1395 # max instruction on "int", 0 otherwise.
1396 #
1397 # This won't change for different subtargets so cache the result.
1398
1399 proc check_effective_target_vect_no_int_max { } {
1400     global et_vect_no_int_max_saved
1401
1402     if [info exists et_vect_no_int_max_saved] {
1403         verbose "check_effective_target_vect_no_int_max: using cached result" 2
1404     } else {
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
1410         }
1411     }
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
1414 }
1415
1416 # Return 1 if the target plus current options does not support a vector
1417 # add instruction on "int", 0 otherwise.
1418 #
1419 # This won't change for different subtargets so cache the result.
1420
1421 proc check_effective_target_vect_no_int_add { } {
1422     global et_vect_no_int_add_saved
1423
1424     if [info exists et_vect_no_int_add_saved] {
1425         verbose "check_effective_target_vect_no_int_add: using cached result" 2
1426     } else {
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
1431         }
1432     }
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
1435 }
1436
1437 # Return 1 if the target plus current options does not support vector
1438 # bitwise instructions, 0 otherwise.
1439 #
1440 # This won't change for different subtargets so cache the result.
1441
1442 proc check_effective_target_vect_no_bitwise { } {
1443     global et_vect_no_bitwise_saved
1444
1445     if [info exists et_vect_no_bitwise_saved] {
1446         verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1447     } else {
1448         set et_vect_no_bitwise_saved 0
1449     }
1450     verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1451     return $et_vect_no_bitwise_saved
1452 }
1453
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.
1458 #
1459 # This won't change for different subtargets so cache the result.
1460                                                                                                 
1461 proc check_effective_target_vect_widen_sum_hi_to_si { } {
1462     global et_vect_widen_sum_hi_to_si
1463
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
1466     } else {
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
1471         }
1472     }
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
1475 }
1476
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.
1481 #
1482 # This won't change for different subtargets so cache the result.
1483                                                                                                 
1484 proc check_effective_target_vect_widen_sum_qi_to_hi { } {
1485     global et_vect_widen_sum_qi_to_hi
1486
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
1489     } else {
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
1494         }
1495     }
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
1498 }
1499
1500 # Return 1 if the target plus current options supports a vector
1501 # widening summation of *char* args into *int* result, 0 otherwise.
1502 #
1503 # This won't change for different subtargets so cache the result.
1504                                                                                                 
1505 proc check_effective_target_vect_widen_sum_qi_to_si { } {
1506     global et_vect_widen_sum_qi_to_si
1507
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
1510     } else {
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
1514         }
1515     }
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
1518 }
1519
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).
1525 #
1526 # This won't change for different subtargets so cache the result.
1527
1528
1529 proc check_effective_target_vect_widen_mult_qi_to_hi { } {
1530     global et_vect_widen_mult_qi_to_hi
1531
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
1534     } else {
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
1538         } else {
1539             set et_vect_widen_mult_qi_to_hi_saved 0
1540         }
1541         if { [istarget powerpc*-*-*] } {
1542             set et_vect_widen_mult_qi_to_hi_saved 1
1543         }
1544     }
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
1547 }
1548
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).
1554 #
1555 # This won't change for different subtargets so cache the result.
1556
1557
1558 proc check_effective_target_vect_widen_mult_hi_to_si { } {
1559     global et_vect_widen_mult_hi_to_si
1560
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
1563     } else {
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
1567         } else {
1568           set et_vect_widen_mult_hi_to_si_saved 0
1569         }
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
1575         }
1576     }
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
1579 }
1580
1581 # Return 1 if the target plus current options supports a vector
1582 # dot-product of signed chars, 0 otherwise.
1583 #
1584 # This won't change for different subtargets so cache the result.
1585
1586 proc check_effective_target_vect_sdot_qi { } {
1587     global et_vect_sdot_qi
1588
1589     if [info exists et_vect_sdot_qi_saved] {
1590         verbose "check_effective_target_vect_sdot_qi: using cached result" 2
1591     } else {
1592         set et_vect_sdot_qi_saved 0
1593     }
1594     verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1595     return $et_vect_sdot_qi_saved
1596 }
1597
1598 # Return 1 if the target plus current options supports a vector
1599 # dot-product of unsigned chars, 0 otherwise.
1600 #
1601 # This won't change for different subtargets so cache the result.
1602
1603 proc check_effective_target_vect_udot_qi { } {
1604     global et_vect_udot_qi
1605
1606     if [info exists et_vect_udot_qi_saved] {
1607         verbose "check_effective_target_vect_udot_qi: using cached result" 2
1608     } else {
1609         set et_vect_udot_qi_saved 0
1610         if { [istarget powerpc*-*-*] } {
1611             set et_vect_udot_qi_saved 1
1612         }
1613     }
1614     verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1615     return $et_vect_udot_qi_saved
1616 }
1617
1618 # Return 1 if the target plus current options supports a vector
1619 # dot-product of signed shorts, 0 otherwise.
1620 #
1621 # This won't change for different subtargets so cache the result.
1622
1623 proc check_effective_target_vect_sdot_hi { } {
1624     global et_vect_sdot_hi
1625
1626     if [info exists et_vect_sdot_hi_saved] {
1627         verbose "check_effective_target_vect_sdot_hi: using cached result" 2
1628     } else {
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
1634         }
1635     }
1636     verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
1637     return $et_vect_sdot_hi_saved
1638 }
1639
1640 # Return 1 if the target plus current options supports a vector
1641 # dot-product of unsigned shorts, 0 otherwise.
1642 #
1643 # This won't change for different subtargets so cache the result.
1644
1645 proc check_effective_target_vect_udot_hi { } {
1646     global et_vect_udot_hi
1647
1648     if [info exists et_vect_udot_hi_saved] {
1649         verbose "check_effective_target_vect_udot_hi: using cached result" 2
1650     } else {
1651         set et_vect_udot_hi_saved 0
1652         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*]) } {
1653             set et_vect_udot_hi_saved 1
1654         }
1655     }
1656     verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
1657     return $et_vect_udot_hi_saved
1658 }
1659
1660
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.
1664 #
1665 # This won't change for different subtargets so cache the result.
1666                                                                                 
1667 proc check_effective_target_vect_pack_trunc { } {
1668     global et_vect_pack_trunc
1669                                                                                 
1670     if [info exists et_vect_pack_trunc_saved] {
1671         verbose "check_effective_target_vect_pack_trunc: using cached result" 2
1672     } else {
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
1678         }
1679     }
1680     verbose "check_effective_target_vect_pack_trunc: returning $et_vect_pack_trunc_saved" 2
1681     return $et_vect_pack_trunc_saved
1682 }
1683
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.
1686 #
1687 # This won't change for different subtargets so cache the result.
1688                                    
1689 proc check_effective_target_vect_unpack { } {
1690     global et_vect_unpack
1691                                         
1692     if [info exists et_vect_unpack_saved] {
1693         verbose "check_effective_target_vect_unpack: using cached result" 2
1694     } else {
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
1701         }
1702     }
1703     verbose "check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2  
1704     return $et_vect_unpack_saved
1705 }
1706
1707 # Return 1 if the target plus current options does not guarantee
1708 # that its STACK_BOUNDARY is >= the reguired vector alignment.
1709 #
1710 # This won't change for different subtargets so cache the result.
1711
1712 proc check_effective_target_unaligned_stack { } {
1713     global et_unaligned_stack_saved
1714
1715     if [info exists et_unaligned_stack_saved] {
1716         verbose "check_effective_target_unaligned_stack: using cached result" 2
1717     } else {
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
1722         }
1723     }
1724     verbose "check_effective_target_unaligned_stack: returning $et_unaligned_stack_saved" 2
1725     return $et_unaligned_stack_saved
1726 }
1727
1728 # Return 1 if the target plus current options does not support a vector
1729 # alignment mechanism, 0 otherwise.
1730 #
1731 # This won't change for different subtargets so cache the result.
1732
1733 proc check_effective_target_vect_no_align { } {
1734     global et_vect_no_align_saved
1735
1736     if [info exists et_vect_no_align_saved] {
1737         verbose "check_effective_target_vect_no_align: using cached result" 2
1738     } else {
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
1744         }
1745     }
1746     verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
1747     return $et_vect_no_align_saved
1748 }
1749
1750 # Return 1 if arrays are aligned to the vector alignment
1751 # boundary, 0 otherwise.
1752 #
1753 # This won't change for different subtargets so cache the result.
1754
1755 proc check_effective_target_vect_aligned_arrays { } {
1756     global et_vect_aligned_arrays
1757
1758     if [info exists et_vect_aligned_arrays_saved] {
1759         verbose "check_effective_target_vect_aligned_arrays: using cached result" 2
1760     } else {
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
1766         }
1767     }
1768     verbose "check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
1769     return $et_vect_aligned_arrays_saved
1770 }
1771
1772 # Return 1 if types of size 32 bit or less are naturally aligned
1773 # (aligned to their type-size), 0 otherwise.
1774 #
1775 # This won't change for different subtargets so cache the result.
1776
1777 proc check_effective_target_natural_alignment_32 { } {
1778     global et_natural_alignment_32
1779
1780     if [info exists et_natural_alignment_32_saved] {
1781         verbose "check_effective_target_natural_alignment_32: using cached result" 2
1782     } else {
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
1787         }
1788     }
1789     verbose "check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
1790     return $et_natural_alignment_32_saved
1791 }
1792
1793 # Return 1 if types of size 64 bit or less are naturally aligned (aligned to their
1794 # type-size), 0 otherwise.
1795 #
1796 # This won't change for different subtargets so cache the result.
1797
1798 proc check_effective_target_natural_alignment_64 { } {
1799     global et_natural_alignment_64
1800
1801     if [info exists et_natural_alignment_64_saved] {
1802         verbose "check_effective_target_natural_alignment_64: using cached result" 2
1803     } else {
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
1808         }
1809     }
1810     verbose "check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
1811     return $et_natural_alignment_64_saved
1812 }
1813
1814 # Return 1 if vector alignment (for types of size 32 bit or less) is reachable, 0 otherwise.
1815 #
1816 # This won't change for different subtargets so cache the result.
1817
1818 proc check_effective_target_vector_alignment_reachable { } {
1819     global et_vector_alignment_reachable
1820
1821     if [info exists et_vector_alignment_reachable_saved] {
1822         verbose "check_effective_target_vector_alignment_reachable: using cached result" 2
1823     } else {
1824         if { [check_effective_target_vect_aligned_arrays]
1825              || [check_effective_target_natural_alignment_32] } {
1826             set et_vector_alignment_reachable_saved 1
1827         } else {
1828             set et_vector_alignment_reachable_saved 0
1829         }
1830     }
1831     verbose "check_effective_target_vector_alignment_reachable: returning $et_vector_alignment_reachable_saved" 2
1832     return $et_vector_alignment_reachable_saved
1833 }
1834
1835 # Return 1 if vector alignment for 64 bit is reachable, 0 otherwise.
1836 #
1837 # This won't change for different subtargets so cache the result.
1838
1839 proc check_effective_target_vector_alignment_reachable_for_64bit { } {
1840     global et_vector_alignment_reachable_for_64bit
1841
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
1844     } else {
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
1848         } else {
1849             set et_vector_alignment_reachable_for_64bit_saved 0
1850         }
1851     }
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
1854 }
1855
1856 # Return 1 if the target supports vector conditional operations, 0 otherwise.
1857
1858 proc check_effective_target_vect_condition { } {
1859     global et_vect_cond_saved
1860
1861     if [info exists et_vect_cond_saved] {
1862         verbose "check_effective_target_vect_cond: using cached result" 2
1863     } else {
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
1871         }
1872     }
1873
1874     verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
1875     return $et_vect_cond_saved
1876 }
1877
1878 # Return 1 if the target supports vector char multiplication, 0 otherwise.
1879
1880 proc check_effective_target_vect_char_mult { } {
1881     global et_vect_char_mult_saved
1882
1883     if [info exists et_vect_char_mult_saved] {
1884         verbose "check_effective_target_vect_char_mult: using cached result" 2
1885     } else {
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
1891         }
1892     }
1893
1894     verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
1895     return $et_vect_char_mult_saved
1896 }
1897
1898 # Return 1 if the target supports vector short multiplication, 0 otherwise.
1899
1900 proc check_effective_target_vect_short_mult { } {
1901     global et_vect_short_mult_saved
1902
1903     if [info exists et_vect_short_mult_saved] {
1904         verbose "check_effective_target_vect_short_mult: using cached result" 2
1905     } else {
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
1912         }
1913     }
1914
1915     verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
1916     return $et_vect_short_mult_saved
1917 }
1918
1919 # Return 1 if the target supports vector int multiplication, 0 otherwise.
1920
1921 proc check_effective_target_vect_int_mult { } {
1922     global et_vect_int_mult_saved
1923
1924     if [info exists et_vect_int_mult_saved] {
1925         verbose "check_effective_target_vect_int_mult: using cached result" 2
1926     } else {
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
1933         }
1934     }
1935
1936     verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
1937     return $et_vect_int_mult_saved
1938 }
1939
1940 # Return 1 if the target supports vector even/odd elements extraction, 0 otherwise.
1941
1942 proc check_effective_target_vect_extract_even_odd { } {
1943     global et_vect_extract_even_odd_saved
1944     
1945     if [info exists et_vect_extract_even_odd_saved] {
1946         verbose "check_effective_target_vect_extract_even_odd: using cached result" 2
1947     } else {
1948         set et_vect_extract_even_odd_saved 0 
1949         if { [istarget powerpc*-*-*] } {
1950            set et_vect_extract_even_odd_saved 1
1951         }
1952     }
1953
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
1956 }
1957
1958 # Return 1 if the target supports vector interleaving, 0 otherwise.
1959
1960 proc check_effective_target_vect_interleave { } {
1961     global et_vect_interleave_saved
1962     
1963     if [info exists et_vect_interleave_saved] {
1964         verbose "check_effective_target_vect_interleave: using cached result" 2
1965     } else {
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
1971         }
1972     }
1973
1974     verbose "check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
1975     return $et_vect_interleave_saved
1976 }
1977
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
1981
1982     if [info exists et_vect_strided_saved] {
1983         verbose "check_effective_target_vect_strided: using cached result" 2
1984     } else {
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
1989         }
1990     }
1991
1992     verbose "check_effective_target_vect_strided: returning $et_vect_strided_saved" 2
1993     return $et_vect_strided_saved
1994 }
1995
1996 # Return 1 if the target supports section-anchors
1997
1998 proc check_effective_target_section_anchors { } {
1999     global et_section_anchors_saved
2000
2001     if [info exists et_section_anchors_saved] {
2002         verbose "check_effective_target_section_anchors: using cached result" 2
2003     } else {
2004         set et_section_anchors_saved 0
2005         if { [istarget powerpc*-*-*] } {
2006            set et_section_anchors_saved 1
2007         }
2008     }
2009
2010     verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
2011     return $et_section_anchors_saved
2012 }
2013
2014 # Return 1 if the target supports atomic operations on "int" and "long".
2015
2016 proc check_effective_target_sync_int_long { } {
2017     global et_sync_int_long_saved
2018
2019     if [info exists et_sync_int_long_saved] {
2020         verbose "check_effective_target_sync_int_long: using cached result" 2
2021     } else {
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
2034         }
2035     }
2036
2037     verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2038     return $et_sync_int_long_saved
2039 }
2040
2041 # Return 1 if the target supports atomic operations on "char" and "short".
2042
2043 proc check_effective_target_sync_char_short { } {
2044     global et_sync_char_short_saved
2045
2046     if [info exists et_sync_char_short_saved] {
2047         verbose "check_effective_target_sync_char_short: using cached result" 2
2048     } else {
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
2061         }
2062     }
2063
2064     verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2065     return $et_sync_char_short_saved
2066 }
2067
2068 # Return 1 if the target uses a ColdFire FPU.
2069
2070 proc check_effective_target_coldfire_fpu { } {
2071     return [check_no_compiler_messages coldfire_fpu assembly {
2072         #ifndef __mcffpu__
2073         #error FOO
2074         #endif
2075     }]
2076 }
2077
2078 # Return true if this is a uClibc target.
2079
2080 proc check_effective_target_uclibc {} {
2081     return [check_no_compiler_messages uclibc object {
2082         #include <features.h>
2083         #if !defined (__UCLIBC__)
2084         #error FOO
2085         #endif
2086     }]
2087 }
2088
2089 # Return true if this is a uclibc target and if the uclibc feature
2090 # described by __$feature__ is not present.
2091
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}__)
2096         #error FOO
2097         #endif
2098     "]
2099 }
2100
2101 # Return true if this is a Newlib target.
2102
2103 proc check_effective_target_newlib {} {
2104     return [check_no_compiler_messages newlib object {
2105         #include <newlib.h>
2106     }]
2107 }
2108
2109 # Return 1 if
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.
2113
2114 proc check_effective_target_lax_strtofp {} {
2115     # By default, assume that all uClibc targets suffer from this.
2116     return [check_effective_target_uclibc]
2117 }
2118
2119 # Return 1 if this is a target for which wcsftime is a dummy
2120 # function that always returns 0.
2121
2122 proc check_effective_target_dummy_wcsftime {} {
2123     # By default, assume that all uClibc targets suffer from this.
2124     return [check_effective_target_uclibc]
2125 }
2126
2127 # Return 1 if constructors with initialization priority arguments are
2128 # supposed on this target.
2129
2130 proc check_effective_target_init_priority {} {
2131     return [check_no_compiler_messages init_priority assembly "
2132         void f() __attribute__((constructor (1000)));
2133         void f() \{\}
2134     "]
2135 }
2136
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.
2141
2142 proc is-effective-target { arg } {
2143     set selected 0
2144     if { [info procs check_effective_target_${arg}] != [list] } {
2145         set selected [check_effective_target_${arg}]
2146     } else {
2147         switch $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'" }
2153         }
2154     }
2155     verbose "is-effective-target: $arg $selected" 2
2156     return $selected
2157 }
2158
2159 # Return 1 if the argument is an effective-target keyword, 0 otherwise.
2160
2161 proc is-effective-target-keyword { arg } {
2162     if { [info procs check_effective_target_${arg}] != [list] } {
2163         return 1
2164     } else {
2165         # These have different names for their check_* procs.
2166         switch $arg {
2167           "vmx_hw"         { return 1 }
2168           "named_sections" { return 1 }
2169           "gc_sections"    { return 1 }
2170           "cxa_atexit"     { return 1 }
2171           default          { return 0 }
2172         }
2173     }
2174 }
2175
2176 # Return 1 if target default to short enums
2177
2178 proc check_effective_target_short_enums { } {
2179     return [check_no_compiler_messages short_enums assembly {
2180         enum foo { bar };
2181         int s[sizeof (enum foo) == 1 ? 1 : -1];
2182     }]
2183 }
2184
2185 # Return 1 if target supports merging string constants at link time.
2186
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";
2191                 } {-O2}]
2192 }
2193
2194 # Return 1 if target has the basic signed and unsigned types in
2195 # <stdint.h>, 0 otherwise.
2196
2197 proc check_effective_target_stdint_types { } {
2198     return [check_no_compiler_messages stdint_types assembly {
2199         #include <stdint.h>
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;
2202     }]
2203 }
2204
2205 # Return 1 if programs are intended to be run on a simulator
2206 # (i.e. slowly) rather than hardware (i.e. fast).
2207
2208 proc check_effective_target_simulator { } {
2209
2210     # All "src/sim" simulators set this one.
2211     if [board_info target exists is_simulator] {
2212         return [board_info target is_simulator]
2213     }
2214
2215     # The "sid" simulators don't set that one, but at least they set
2216     # this one.
2217     if [board_info target exists slow_simulator] {
2218         return [board_info target slow_simulator]
2219     }
2220
2221     return 0
2222 }
2223
2224 # Return 1 if the target is a VxWorks RTP.
2225
2226 proc check_effective_target_vxworks_kernel { } {
2227     return [check_no_compiler_messages vxworks_kernel assembly {
2228         #if !defined __vxworks || defined __RTP__
2229         #error NO
2230         #endif
2231     }]
2232 }
2233
2234 # Return 1 if the target is expected to provide wide character support.
2235
2236 proc check_effective_target_wchar { } {
2237     if {[check_missing_uclibc_feature UCLIBC_HAS_WCHAR]} {
2238         return 0
2239     }
2240     return [check_no_compiler_messages wchar assembly {
2241         #include <wchar.h>
2242     }]
2243 }
2244
2245 # Return 1 if the target has <pthread.h>.
2246
2247 proc check_effective_target_pthread_h { } {
2248     return [check_no_compiler_messages pthread_h assembly {
2249         #include <pthread.h>
2250     }]
2251 }
2252
2253 # Return 1 if the target can truncate a file from a file-descriptor,
2254 # as used by libgfortran/io/unix.c:fd_truncate; i.e. ftruncate or
2255 # chsize.  We test for a trivially functional truncation; no stubs.
2256 # As libgfortran uses _FILE_OFFSET_BITS 64, we do too; it'll cause a
2257 # different function to be used.
2258
2259 proc check_effective_target_fd_truncate { } {
2260     set prog {
2261         #define _FILE_OFFSET_BITS 64
2262         #include <unistd.h>
2263         #include <stdio.h>
2264         #include <stdlib.h>
2265         int main ()
2266         {
2267           FILE *f = fopen ("tst.tmp", "wb");
2268           int fd;
2269           const char t[] = "test writing more than ten characters";
2270           char s[11];
2271           fd =  fileno (f);
2272           write (fd, t, sizeof (t) - 1);
2273           lseek (fd, 0, 0);
2274           if (ftruncate (fd, 10) != 0)
2275             exit (1);
2276           close (fd);
2277           f = fopen ("tst.tmp", "rb");
2278           if (fread (s, 1, sizeof (s), f) != 10 || strncmp (s, t, 10) != 0)
2279             exit (1);
2280           exit (0);
2281         }
2282     }
2283
2284     if { [check_runtime ftruncate $prog] } {
2285       return 1;
2286     }
2287
2288     regsub "ftruncate" $prog "chsize" prog
2289     return [check_runtime chsize $prog]
2290 }
2291
2292 # Add to FLAGS all the target-specific flags needed to access the c99 runtime.
2293
2294 proc add_options_for_c99_runtime { flags } {
2295     if { [istarget *-*-solaris2*] } {
2296         return "$flags -std=c99"
2297     }
2298     if { [istarget powerpc-*-darwin*] } {
2299         return "$flags -mmacosx-version-min=10.3"
2300     }
2301     return $flags
2302 }
2303
2304 # Return 1 if the target provides a full C99 runtime.
2305
2306 proc check_effective_target_c99_runtime { } {
2307     return [check_cached_effective_target c99_runtime {
2308         global srcdir
2309
2310         set file [open "$srcdir/gcc.dg/builtins-config.h"]
2311         set contents [read $file]
2312         close $file
2313         append contents {
2314             #ifndef HAVE_C99_RUNTIME
2315             #error FOO
2316             #endif
2317         }
2318         check_no_compiler_messages_nocache c99_runtime assembly \
2319             $contents [add_options_for_c99_runtime ""]
2320     }]
2321 }