OSDN Git Service

786f1fc5726116d3ecc42b9c57047178058d8a43
[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 2 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 this program; if not, write to the Free Software
16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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 some code and return the messages printed by the compiler,
24 # and optionally the contents for assembly files.  Either a string or
25 # a list of two strings are returned, depending on WANT_OUTPUT.
26 #
27 # BASENAME is a basename to use for temporary files.
28 # WANT_OUTPUT is a flag which is 0 to request returning just the
29 #   compiler messages, or 1 to return the messages and the contents
30 #   of the assembly file.  TYPE should be "assembly" if WANT_OUTPUT
31 #   is set.
32 # TYPE is the type of compilation to perform (see target_compile).
33 # CONTENTS gives the contents of the input file.
34 # The rest is optional:
35 # OPTIONS: additional compiler options to use.
36 proc get_compiler_messages {basename want_output type contents args} {
37     global tool
38
39     if { [llength $args] > 0 } {
40         set options [list "additional_flags=[lindex $args 0]"]
41     } else {
42         set options ""
43     }
44
45     set src ${basename}[pid].c
46     switch $type {
47         assembly { set output ${basename}[pid].s }
48         object { set output ${basename}[pid].o }
49     }
50     set f [open $src "w"]
51     puts $f $contents
52     close $f
53     set lines [${tool}_target_compile $src $output $type "$options"]
54     file delete $src
55
56     if { $want_output } {
57         if { $type != "assembly" } {
58             error "WANT_OUTPUT can only be used with assembly output"
59         } elseif { ![string match "" $lines] } {
60             # An error occurred.
61             set result [list $lines ""]
62         } else {
63             set text ""
64             set chan [open "$output"]
65             while {[gets $chan line] >= 0} {
66                 append text "$line\n"
67             }
68             close $chan
69             set result [list $lines $text]
70         }
71     } else {
72         set result $lines
73     }
74
75     remote_file build delete $output
76     return $result
77 }
78
79 proc current_target_name { } {
80     global target_info
81     if [info exists target_info(target,name)] {
82         set answer $target_info(target,name)
83     } else {
84         set answer ""
85     }
86     return $answer
87 }
88
89 # Implement an effective-target check for property PROP by invoking
90 # the compiler and seeing if it prints any messages.  Assume that the
91 # property holds if the compiler doesn't print anything.  The other
92 # arguments are as for get_compiler_messages, starting with TYPE.
93 proc check_no_compiler_messages {prop args} {
94     global et_cache
95
96     set target [current_target_name]
97     if {![info exists et_cache($prop,target)]
98         || $et_cache($prop,target) != $target} {
99         verbose "check_no_compiler_messages $prop: compiling source for $target" 2
100         set et_cache($prop,target) $target
101         set et_cache($prop,value) \
102             [string match "" [eval get_compiler_messages $prop 0 $args]]
103     }
104     set value $et_cache($prop,value)
105     verbose "check_no_compiler_messages $prop: returning $value for $target" 2
106     return $value
107 }
108
109 # Similar to check_no_compiler_messages, but also verify that the regular
110 # expression PATTERN matches the compiler's output.
111 proc check_no_messages_and_pattern {prop pattern args} {
112     global et_cache
113
114     set target [current_target_name]
115     if {![info exists et_cache($prop,target)]
116         || $et_cache($prop,target) != $target} {
117         verbose "check_no_messages_and_pattern $prop: compiling source for $target" 2
118         set et_cache($prop,target) $target
119         set results [eval get_compiler_messages $prop 1 $args]
120         set et_cache($prop,value) \
121             [expr [string match "" [lindex $results 0]] \
122                  && [regexp $pattern [lindex $results 1]]]
123     }
124     set value $et_cache($prop,value)
125     verbose "check_no_messages_and_pattern $prop: returning $value for $target" 2
126     return $value
127 }
128
129 ###############################
130 # proc check_weak_available { }
131 ###############################
132
133 # weak symbols are only supported in some configs/object formats
134 # this proc returns 1 if they're supported, 0 if they're not, or -1 if unsure
135
136 proc check_weak_available { } {
137     global target_triplet
138     global target_cpu
139
140     # All mips targets should support it
141
142     if { [ string first "mips" $target_cpu ] >= 0 } {
143         return 1
144     }
145
146     # All solaris2 targets should support it
147
148     if { [regexp ".*-solaris2.*" $target_triplet] } {
149         return 1
150     }
151
152     # DEC OSF/1/Digital UNIX/Tru64 UNIX supports it
153
154     if { [regexp "alpha.*osf.*" $target_triplet] } {
155         return 1
156     }
157
158     # Windows targets Cygwin and MingW32 support it
159
160     if { [regexp ".*mingw32|.*cygwin" $target_triplet] } {
161         return 1
162     }
163
164     # HP-UX 10.X doesn't support it
165
166     if { [istarget "hppa*-*-hpux10*"] } {
167         return 0
168     }
169
170     # ELF and ECOFF support it. a.out does with gas/gld but may also with
171     # other linkers, so we should try it
172
173     set objformat [gcc_target_object_format]
174
175     switch $objformat {
176         elf      { return 1 }
177         ecoff    { return 1 }
178         a.out    { return 1 }
179         mach-o   { return 1 }
180         som      { return 1 }
181         unknown  { return -1 }
182         default  { return 0 }
183     }
184 }
185
186 ###############################
187 # proc check_visibility_available { what_kind }
188 ###############################
189
190 # The visibility attribute is only support in some object formats
191 # This proc returns 1 if it is supported, 0 if not.
192 # The argument is the kind of visibility, default/protected/hidden/internal.
193
194 proc check_visibility_available { what_kind } {
195     global tool
196     global target_triplet
197
198     # On NetWare, support makes no sense.
199     if { [istarget *-*-netware*] } {
200         return 0
201     }
202
203     if [string match "" $what_kind] { set what_kind "hidden" }
204
205     return [check_no_compiler_messages visibility_available_$what_kind object "
206         void f() __attribute__((visibility(\"$what_kind\")));
207         void f() {}
208     "]
209 }
210
211 ###############################
212 # proc check_alias_available { }
213 ###############################
214
215 # Determine if the target toolchain supports the alias attribute.
216
217 # Returns 2 if the target supports aliases.  Returns 1 if the target
218 # only supports weak aliased.  Returns 0 if the target does not
219 # support aliases at all.  Returns -1 if support for aliases could not
220 # be determined.
221
222 proc check_alias_available { } {
223     global alias_available_saved
224     global tool
225
226     if [info exists alias_available_saved] {
227         verbose "check_alias_available  returning saved $alias_available_saved" 2
228     } else {
229         set src alias[pid].c
230         set obj alias[pid].o
231         verbose "check_alias_available  compiling testfile $src" 2
232         set f [open $src "w"]
233         # Compile a small test program.  The definition of "g" is
234         # necessary to keep the Solaris assembler from complaining
235         # about the program.
236         puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
237         puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
238         close $f
239         set lines [${tool}_target_compile $src $obj object ""]
240         file delete $src
241         remote_file build delete $obj
242
243         if [string match "" $lines] then {
244             # No error messages, everything is OK.
245             set alias_available_saved 2
246         } else {
247             if [regexp "alias definitions not supported" $lines] {
248                 verbose "check_alias_available  target does not support aliases" 2
249
250                 set objformat [gcc_target_object_format]
251
252                 if { $objformat == "elf" } {
253                     verbose "check_alias_available  but target uses ELF format, so it ought to" 2
254                     set alias_available_saved -1
255                 } else {
256                     set alias_available_saved 0
257                 }
258             } else {
259                 if [regexp "only weak aliases are supported" $lines] {
260                 verbose "check_alias_available  target supports only weak aliases" 2
261                 set alias_available_saved 1
262                 } else {
263                     set alias_available_saved -1
264                 }
265             }
266         }
267
268         verbose "check_alias_available  returning $alias_available_saved" 2
269     }
270
271     return $alias_available_saved
272 }
273
274 # Returns true if --gc-sections is supported on the target.
275
276 proc check_gc_sections_available { } {
277     global gc_sections_available_saved
278     global tool
279
280     if {![info exists gc_sections_available_saved]} {
281         # Some targets don't support gc-sections despite whatever's
282         # advertised by ld's options.
283         if { [istarget alpha*-*-*]
284              || [istarget ia64-*-*] } {
285             set gc_sections_available_saved 0
286             return 0
287         }
288
289         # Check if the ld used by gcc supports --gc-sections.
290         set gcc_spec [${tool}_target_compile "-dumpspecs" "" "none" ""]
291         regsub ".*\n\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
292         set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=$linker" "" "none" ""] 0]
293         set ld_output [remote_exec host "$gcc_ld" "--help"]
294         if { [ string first "--gc-sections" $ld_output ] >= 0 } {
295             set gc_sections_available_saved 1
296         } else {
297             set gc_sections_available_saved 0
298         }
299     }
300     return $gc_sections_available_saved
301 }
302
303 # Return true if profiling is supported on the target.
304
305 proc check_profiling_available { test_what } {
306     global profiling_available_saved
307
308     verbose "Profiling argument is <$test_what>" 1
309
310     # These conditions depend on the argument so examine them before
311     # looking at the cache variable.
312
313     # Support for -p on solaris2 relies on mcrt1.o which comes with the
314     # vendor compiler.  We cannot reliably predict the directory where the
315     # vendor compiler (and thus mcrt1.o) is installed so we can't
316     # necessarily find mcrt1.o even if we have it.
317     if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
318         return 0
319     }
320
321     # Support for -p on irix relies on libprof1.a which doesn't appear to
322     # exist on any irix6 system currently posting testsuite results.
323     # Support for -pg on irix relies on gcrt1.o which doesn't exist yet.
324     # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
325     if { [istarget mips*-*-irix*]
326     && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
327         return 0
328     }
329
330     # At present, there is no profiling support on NetWare.
331     if { [istarget *-*-netware*] } {
332         return 0
333     }
334
335     # Now examine the cache variable.
336     if {![info exists profiling_available_saved]} {
337         # Some targets don't have any implementation of __bb_init_func or are
338         # missing other needed machinery.
339         if { [istarget mmix-*-*]
340              || [istarget arm*-*-eabi*]
341              || [istarget arm*-*-elf]
342              || [istarget arm*-*-symbianelf*]
343              || [istarget powerpc-*-eabi*]
344              || [istarget strongarm*-*-elf]
345              || [istarget xscale*-*-elf]
346              || [istarget cris-*-*]
347              || [istarget h8300-*-*]
348              || [istarget m32c-*-elf]
349              || [istarget m68k-*-elf]
350              || [istarget mips*-*-elf]
351              || [istarget xtensa-*-elf]
352              || [istarget *-*-windiss] } {
353             set profiling_available_saved 0
354         } else {
355             set profiling_available_saved 1
356         }
357     }
358
359     return $profiling_available_saved
360 }
361
362 # Return 1 if target has packed layout of structure members by
363 # default, 0 otherwise.  Note that this is slightly different than
364 # whether the target has "natural alignment": both attributes may be
365 # false.
366
367 proc check_effective_target_default_packed { } {
368     return [check_no_compiler_messages default_packed assembly {
369         struct x { char a; long b; } c;
370         int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
371     }]
372 }
373
374 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
375 # documentation, where the test also comes from.
376
377 proc check_effective_target_pcc_bitfield_type_matters { } {
378     # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
379     # bitfields, but let's stick to the example code from the docs.
380     return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
381         struct foo1 { char x; char :0; char y; };
382         struct foo2 { char x; int :0; char y; };
383         int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
384     }]
385 }
386
387 # Return 1 if *native* thread local storage (TLS) is supported, 0 otherwise.
388 #
389 # This won't change for different subtargets so cache the result.
390
391 proc check_effective_target_tls {} {
392     global et_tls_saved
393     global tool
394
395     if [info exists et_tls_saved] {
396         verbose "check_effective_target_tls: using cached result" 2
397     } else {
398         set et_tls_saved 1
399
400         set src tls[pid].c
401         set asm tls[pid].S
402         verbose "check_effective_target_tls: compiling testfile $src" 2
403         set f [open $src "w"]
404         # Compile a small test program.
405         puts $f "__thread int i;\n"
406         close $f
407
408         # Test for thread-local data supported by the platform.
409         set comp_output [${tool}_target_compile $src $asm assembly ""]
410         file delete $src
411         if { [string match "*not supported*" $comp_output] } {
412             set et_tls_saved 0
413         } else {
414             set fd [open $asm r]
415             set text [read $fd]
416             close $fd
417             if { [string match "*emutls*" $text]} {
418                 set et_tls_saved 0
419             } else {
420                 set et_tls_saved 1
421             }
422         }
423         remove-build-file $asm
424     }
425     verbose "check_effective_target_tls: returning $et_tls_saved" 2
426     return $et_tls_saved
427 }
428
429 # Return 1 if TLS executables can run correctly, 0 otherwise.
430 #
431 # This won't change for different subtargets so cache the result.
432
433 proc check_effective_target_tls_runtime {} {
434     global et_tls_runtime_saved
435     global tool
436
437     if [info exists et_tls_runtime_saved] {
438         verbose "check_effective_target_tls_runtime: using cached result" 2
439     } else {
440         set et_tls_runtime_saved 0
441
442         set src tls_runtime[pid].c
443         set exe tls_runtime[pid].x
444         verbose "check_effective_target_tls_runtime: compiling testfile $src" 2
445         set f [open $src "w"]
446         # Compile a small test program.
447         puts $f "__thread int thr = 0;\n"
448         puts $f "int main(void)\n {\n return thr;\n}"
449         close $f
450
451         set comp_output \
452             [${tool}_target_compile $src $exe executable ""]
453         file delete $src
454
455         if [string match "" $comp_output] then {
456             # No error messages, everything is OK.
457
458             set result [remote_load target "./$exe" "" ""]
459             set status [lindex $result 0]
460             remote_file build delete $exe
461
462             verbose "check_effective_target_tls_runtime status is <$status>" 2
463
464             if { $status == "pass" } {
465                 set et_tls_runtime_saved 1
466             }
467
468             verbose "check_effective_target_tls_runtime: returning $et_tls_runtime_saved" 2
469         }
470     }
471
472     return $et_tls_runtime_saved
473 }
474
475 # Return 1 if compilation with -fopenmp is error-free for trivial
476 # code, 0 otherwise.
477
478 proc check_effective_target_fopenmp {} {
479     return [check_no_compiler_messages fopenmp object {
480         void foo (void) { }
481     } "-fopenmp"]
482 }
483
484 # Return 1 if compilation with -freorder-blocks-and-partition is error-free
485 # for trivial code, 0 otherwise.
486
487 proc check_effective_target_freorder {} {
488     return [check_no_compiler_messages freorder object {
489         void foo (void) { }
490     } "-freorder-blocks-and-partition"]
491 }
492
493 # Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
494 # emitted, 0 otherwise.  Whether a shared library can actually be built is
495 # out of scope for this test.
496
497 proc check_effective_target_fpic { } {
498     # Note that M68K has a multilib that supports -fpic but not
499     # -fPIC, so we need to check both.  We test with a program that
500     # requires GOT references.
501     foreach arg {fpic fPIC} {
502         if [check_no_compiler_messages $arg object {
503             extern int foo (void); extern int bar;
504             int baz (void) { return foo () + bar; }
505         } "-$arg"] {
506             return 1
507         }
508     }
509     return 0
510 }
511
512 # Return true if the target supports -mpaired-single (as used on MIPS).
513
514 proc check_effective_target_mpaired_single { } {
515     return [check_no_compiler_messages mpaired_single object {
516         void foo (void) { }
517     } "-mpaired-single"]
518 }
519
520 # Return true if iconv is supported on the target. In particular IBM1047.
521
522 proc check_iconv_available { test_what } {
523     global tool
524     global libiconv
525
526     set result ""
527
528     set src iconv[pid].c
529     set exe iconv[pid].x
530     verbose "check_iconv_available compiling testfile $src" 2
531     set f [open $src "w"]
532     # Compile a small test program.
533     puts $f "#include <iconv.h>\n"
534     puts $f "int main (void)\n {\n iconv_t cd; \n"
535     puts $f "cd = iconv_open (\"[lindex $test_what 1]\", \"UTF-8\");\n"
536     puts $f "if (cd == (iconv_t) -1)\n return 1;\n"
537     puts $f "return 0;\n}"
538     close $f
539
540     # If the tool configuration file has not set libiconv, try "-liconv"
541     if { ![info exists libiconv] } {
542         set libiconv "-liconv"
543     }
544     set lines [${tool}_target_compile $src $exe executable "libs=$libiconv" ]
545     file delete $src
546
547     if [string match "" $lines] then {
548         # No error messages, everything is OK.
549
550         set result [${tool}_load "./$exe" "" ""]
551         set status [lindex $result 0]
552         remote_file build delete $exe
553
554         verbose "check_iconv_available status is <$status>" 2
555
556         if { $status == "pass" } then {
557             return 1
558         }
559     }
560
561     return 0
562 }
563
564 # Return true if named sections are supported on this target.
565
566 proc check_named_sections_available { } {
567     return [check_no_compiler_messages named_sections assembly {
568         int __attribute__ ((section("whatever"))) foo;
569     }]
570 }
571
572 # Return 1 if the target supports Fortran real kinds larger than real(8),
573 # 0 otherwise.
574 #
575 # When the target name changes, replace the cached result.
576
577 proc check_effective_target_fortran_large_real { } {
578     global et_fortran_large_real_saved
579     global et_fortran_large_real_target_name
580     global tool
581
582     if { ![info exists et_fortran_large_real_target_name] } {
583         set et_fortran_large_real_target_name ""
584     }
585
586     # If the target has changed since we set the cached value, clear it.
587     set current_target [current_target_name]
588     if { $current_target != $et_fortran_large_real_target_name } {
589         verbose "check_effective_target_fortran_large_real: `$et_fortran_large_real_target_name' `$current_target'" 2
590         set et_fortran_large_real_target_name $current_target
591         if [info exists et_fortran_large_real_saved] {
592             verbose "check_effective_target_fortran_large_real: removing cached result" 2
593             unset et_fortran_large_real_saved
594         }
595     }
596
597     if [info exists et_fortran_large_real_saved] {
598         verbose "check_effective_target_fortran_large_real returning saved $et_fortran_large_real_saved" 2
599     } else {
600         set et_fortran_large_real_saved 0
601
602         # Set up, compile, and execute a test program using large real
603         # kinds.  Include the current process ID in the file names to
604         # prevent conflicts with invocations for multiple testsuites.
605         set src real[pid].f90
606         set exe real[pid].x
607
608         set f [open $src "w"]
609         puts $f "integer,parameter :: k = &"
610         puts $f "  selected_real_kind (precision (0.0_8) + 1)"
611         puts $f "real(kind=k) :: x"
612         puts $f "x = cos (x);"
613         puts $f "end"
614         close $f
615
616         verbose "check_effective_target_fortran_large_real compiling testfile $src" 2
617         set lines [${tool}_target_compile $src $exe executable ""]
618         file delete $src
619
620         if [string match "" $lines] then {
621             # No error message, compilation succeeded.
622             set et_fortran_large_real_saved 1
623         }
624     }
625
626     return $et_fortran_large_real_saved
627 }
628
629 # Return 1 if the target supports Fortran integer kinds larger than
630 # integer(8), 0 otherwise.
631 #
632 # When the target name changes, replace the cached result.
633
634 proc check_effective_target_fortran_large_int { } {
635     global et_fortran_large_int_saved
636     global et_fortran_large_int_target_name
637     global tool
638
639     if { ![info exists et_fortran_large_int_target_name] } {
640         set et_fortran_large_int_target_name ""
641     }
642
643     # If the target has changed since we set the cached value, clear it.
644     set current_target [current_target_name]
645     if { $current_target != $et_fortran_large_int_target_name } {
646         verbose "check_effective_target_fortran_large_int: `$et_fortran_large_int_target_name' `$current_target'" 2
647         set et_fortran_large_int_target_name $current_target
648         if [info exists et_fortran_large_int_saved] {
649             verbose "check_effective_target_fortran_large_int: removing cached result" 2
650             unset et_fortran_large_int_saved
651         }
652     }
653
654     if [info exists et_fortran_large_int_saved] {
655         verbose "check_effective_target_fortran_large_int returning saved $et_fortran_large_int_saved" 2
656     } else {
657         set et_fortran_large_int_saved 0
658
659         # Set up, compile, and execute a test program using large integer
660         # kinds.  Include the current process ID in the file names to
661         # prevent conflicts with invocations for multiple testsuites.
662         set src int[pid].f90
663         set exe int[pid].x
664
665         set f [open $src "w"]
666         puts $f "integer,parameter :: k = &"
667         puts $f "  selected_int_kind (range (0_8) + 1)"
668         puts $f "integer(kind=k) :: i"
669         puts $f "end"
670         close $f
671
672         verbose "check_effective_target_fortran_large_int compiling testfile $src" 2
673         set lines [${tool}_target_compile $src $exe executable ""]
674         file delete $src
675
676         if [string match "" $lines] then {
677             # No error message, compilation succeeded.
678             set et_fortran_large_int_saved 1
679         }
680     }
681
682     return $et_fortran_large_int_saved
683 }
684
685 # Return 1 if we can statically link libgfortran, 0 otherwise.
686 #
687 # When the target name changes, replace the cached result.
688
689 proc check_effective_target_static_libgfortran { } {
690     global et_static_libgfortran
691     global et_static_libgfortran_target_name
692     global tool
693
694     if { ![info exists et_static_libgfortran_target_name] } {
695        set et_static_libgfortran_target_name ""
696     }
697
698     # If the target has changed since we set the cached value, clear it.
699     set current_target [current_target_name]
700     if { $current_target != $et_static_libgfortran_target_name } {
701        verbose "check_effective_target_static_libgfortran: `$et_static_libgfortran_target_name' `$current_target'" 2
702        set et_static_libgfortran_target_name $current_target
703        if [info exists et_static_libgfortran_saved] {
704            verbose "check_effective_target_static_libgfortran: removing cached result" 2
705            unset et_static_libgfortran_saved
706        }
707     }
708
709     if [info exists et_static_libgfortran_saved] {
710        verbose "check_effective_target_static_libgfortran returning saved $et_static_libgfortran_saved" 2
711     } else {
712        set et_static_libgfortran_saved 0
713
714        # Set up, compile, and execute a test program using static linking.
715        # Include the current process ID in the file names to prevent
716        # conflicts with invocations for multiple testsuites.
717        set opts "additional_flags=-static"
718        set src static[pid].f
719        set exe static[pid].x
720
721        set f [open $src "w"]
722        puts $f "      print *, 'test'"
723        puts $f "      end"
724        close $f
725
726        verbose "check_effective_target_static_libgfortran compiling testfile $src" 2
727        set lines [${tool}_target_compile $src $exe executable "$opts"]
728        file delete $src
729
730        if [string match "" $lines] then {
731            # No error message, compilation succeeded.
732            set et_static_libgfortran_saved 1
733        }
734     }
735
736     return $et_static_libgfortran_saved
737 }
738
739 # Return 1 if the target supports executing AltiVec instructions, 0
740 # otherwise.  Cache the result.
741
742 proc check_vmx_hw_available { } {
743     global vmx_hw_available_saved
744     global tool
745
746     if [info exists vmx_hw_available_saved] {
747         verbose "check_hw_available  returning saved $vmx_hw_available_saved" 2
748     } else {
749         set vmx_hw_available_saved 0
750
751         # Some simulators are known to not support VMX instructions.
752         if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
753             verbose "check_hw_available  returning 0" 2
754             return $vmx_hw_available_saved
755         }
756
757         # Set up, compile, and execute a test program containing VMX
758         # instructions.  Include the current process ID in the file
759         # names to prevent conflicts with invocations for multiple
760         # testsuites.
761         set src vmx[pid].c
762         set exe vmx[pid].x
763
764         set f [open $src "w"]
765         puts $f "int main() {"
766         puts $f "#ifdef __MACH__"
767         puts $f "  asm volatile (\"vor v0,v0,v0\");"
768         puts $f "#else"
769         puts $f "  asm volatile (\"vor 0,0,0\");"
770         puts $f "#endif"
771         puts $f "  return 0; }"
772         close $f
773
774         # Most targets don't require special flags for this test case, but
775         # Darwin does.
776         if [istarget *-*-darwin*] {
777           set opts "additional_flags=-maltivec"
778         } else {
779           set opts ""
780         }
781
782         verbose "check_vmx_hw_available  compiling testfile $src" 2
783         set lines [${tool}_target_compile $src $exe executable "$opts"]
784         file delete $src
785
786         if [string match "" $lines] then {
787             # No error message, compilation succeeded.
788             set result [${tool}_load "./$exe" "" ""]
789             set status [lindex $result 0]
790             remote_file build delete $exe
791             verbose "check_vmx_hw_available testfile status is <$status>" 2
792
793             if { $status == "pass" } then {
794                 set vmx_hw_available_saved 1
795             }
796         } else {
797             verbose "check_vmx_hw_availalble testfile compilation failed" 2
798         }
799     }
800
801     return $vmx_hw_available_saved
802 }
803
804 # GCC 3.4.0 for powerpc64-*-linux* included an ABI fix for passing
805 # complex float arguments.  This affects gfortran tests that call cabsf
806 # in libm built by an earlier compiler.  Return 1 if libm uses the same
807 # argument passing as the compiler under test, 0 otherwise.
808 #
809 # When the target name changes, replace the cached result.
810
811 proc check_effective_target_broken_cplxf_arg { } {
812     global et_broken_cplxf_arg_saved
813     global et_broken_cplxf_arg_target_name
814     global tool
815
816     # Skip the work for targets known not to be affected.
817     if { ![istarget powerpc64-*-linux*] } {
818         return 0
819     } elseif { [is-effective-target ilp32] } {
820         return 0
821     }
822
823     if { ![info exists et_broken_cplxf_arg_target_name] } {
824         set et_broken_cplxf_arg_target_name ""
825     }
826
827     # If the target has changed since we set the cached value, clear it.
828     set current_target [current_target_name]
829     if { $current_target != $et_broken_cplxf_arg_target_name } {
830         verbose "check_effective_target_broken_cplxf_arg: `$et_broken_cplxf_arg_target_name'" 2
831         set et_broken_cplxf_arg_target_name $current_target
832         if [info exists et_broken_cplxf_arg_saved] {
833             verbose "check_effective_target_broken_cplxf_arg: removing cached result" 2
834             unset et_broken_cplxf_arg_saved
835         }
836     }
837
838     if [info exists et_broken_cplxf_arg_saved] {
839         verbose "check_effective_target_broken_cplxf_arg: using cached result" 2
840     } else {
841         set et_broken_cplxf_arg_saved 0
842         # This is only known to affect one target.
843         if { ![istarget powerpc64-*-linux*] || ![is-effective-target lp64] } {
844             set et_broken_cplxf_arg_saved 0
845             verbose "check_effective_target_broken_cplxf_arg: caching 0" 2
846             return $et_broken_cplxf_arg_saved
847         }
848
849         # Set up, compile, and execute a C test program that calls cabsf.
850         set src cabsf[pid].c
851         set exe cabsf[pid].x
852
853         set f [open $src "w"]
854         puts $f "#include <complex.h>"
855         puts $f "extern void abort (void);"
856         puts $f "float fabsf (float);"
857         puts $f "float cabsf (_Complex float);"
858         puts $f "int main ()"
859         puts $f "{"
860         puts $f "  _Complex float cf;"
861         puts $f "  float f;"
862         puts $f "  cf = 3 + 4.0fi;"
863         puts $f "  f = cabsf (cf);"
864         puts $f "  if (fabsf (f - 5.0) > 0.0001) abort ();"
865         puts $f "  return 0;"
866         puts $f "}"
867         close $f
868
869         set lines [${tool}_target_compile $src $exe executable "-lm"]
870         file delete $src
871
872         if [string match "" $lines] {
873             # No error message, compilation succeeded.
874             set result [${tool}_load "./$exe" "" ""]
875             set status [lindex $result 0]
876             remote_file build delete $exe
877
878             verbose "check_effective_target_broken_cplxf_arg: status is <$status>" 2
879
880             if { $status != "pass" } {
881                 set et_broken_cplxf_arg_saved 1
882             }
883         } else {
884             verbose "check_effective_target_broken_cplxf_arg: compilation failed" 2
885         }
886     }
887     return $et_broken_cplxf_arg_saved
888 }
889
890 proc check_alpha_max_hw_available { } {
891     global alpha_max_hw_available_saved
892     global tool
893
894     if [info exists alpha_max_hw_available_saved] {
895         verbose "check_alpha_max_hw_available returning saved $alpha_max_hw_available_saved" 2
896     } else {
897         set alpha_max_hw_available_saved 0
898
899         # Set up, compile, and execute a test program probing bit 8 of the
900         # architecture mask, which indicates presence of MAX instructions.
901         set src max[pid].c
902         set exe max[pid].x
903
904         set f [open $src "w"]
905         puts $f "int main() { return __builtin_alpha_amask(1<<8) != 0; }"
906         close $f
907
908         verbose "check_alpha_max_hw_available compiling testfile $src" 2
909         set lines [${tool}_target_compile $src $exe executable ""]
910         file delete $src
911
912         if [string match "" $lines] then {
913             # No error message, compilation succeeded.
914             set result [${tool}_load "./$exe" "" ""]
915             set status [lindex $result 0]
916             remote_file build delete $exe
917             verbose "check_alpha_max_hw_available testfile status is <$status>" 2
918
919             if { $status == "pass" } then {
920                 set alpha_max_hw_available_saved 1
921             }
922         } else {
923             verbose "check_alpha_max_hw_availalble testfile compilation failed" 2
924         }
925     }
926
927     return $alpha_max_hw_available_saved
928 }
929
930 # Returns true iff the FUNCTION is available on the target system.
931 # (This is essentially a Tcl implementation of Autoconf's
932 # AC_CHECK_FUNC.)
933
934 proc check_function_available { function } {
935     set var "${function}_available_saved"
936     global $var
937     global tool
938
939     if {![info exists $var]} {
940         # Assume it exists.
941         set $var 1
942         # Check to make sure.
943         set src "function[pid].c"
944         set exe "function[pid].exe"
945
946         set f [open $src "w"]
947         puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
948         puts $f "char $function ();\n"
949         puts $f "int main () { $function (); }"
950         close $f
951
952         set lines [${tool}_target_compile $src $exe executable ""]
953         file delete $src
954         file delete $exe
955
956         if {![string match "" $lines]} then {
957             set $var 0
958             verbose -log "$function is not available"
959         } else {
960             verbose -log "$function is available"
961         }
962     }
963
964     eval return \$$var
965 }
966
967 # Returns true iff "fork" is available on the target system.
968
969 proc check_fork_available {} {
970     return [check_function_available "fork"]
971 }
972
973 # Returns true iff "mkfifo" is available on the target system.
974
975 proc check_mkfifo_available {} {
976     if {[istarget *-*-cygwin*]} {
977        # Cygwin has mkfifo, but support is incomplete.
978        return 0
979      }
980
981     return [check_function_available "mkfifo"]
982 }
983
984 # Returns true iff "__cxa_atexit" is used on the target system.
985
986 proc check_cxa_atexit_available { } {
987     global et_cxa_atexit
988     global et_cxa_atexit_target_name
989     global tool 
990
991     if { ![info exists et_cxa_atexit_target_name] } {
992         set et_cxa_atexit_target_name ""
993     }
994
995     # If the target has changed since we set the cached value, clear it.
996     set current_target [current_target_name]
997     if { $current_target != $et_cxa_atexit_target_name } {
998         verbose "check_cxa_atexit_available: `$et_cxa_atexit_target_name'" 2
999         set et_cxa_atexit_target_name $current_target
1000         if [info exists et_cxa_atexit] {
1001             verbose "check_cxa_atexit_available: removing cached result" 2
1002             unset et_cxa_atexit
1003         }
1004     }
1005
1006     if [info exists et_cxa_atexit] {
1007         verbose "check_cxa_atexit_available: using cached result" 2
1008     } elseif { [istarget "hppa*-*-hpux10*"] } {
1009         # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
1010         set et_cxa_atexit 0
1011     } else {
1012         set et_cxa_atexit 0
1013
1014         # Set up, compile, and execute a C++ test program that depends
1015         # on correct ordering of static object destructors. This is
1016         # indicative of the presence and use of __cxa_atexit.
1017         set src cxaatexit[pid].cc
1018         set exe cxaatexit[pid].x
1019
1020         set f [open $src "w"]
1021         puts $f "#include <stdlib.h>"
1022         puts $f "static unsigned int count;"
1023         puts $f "struct X"
1024         puts $f "{"
1025         puts $f "  X() { count = 1; }"
1026         puts $f "  ~X()"
1027         puts $f "  {"
1028         puts $f "    if (count != 3)"
1029         puts $f "      exit(1);"
1030         puts $f "    count = 4;"
1031         puts $f "  }"
1032         puts $f "};"
1033         puts $f "void f()"
1034         puts $f "{"
1035         puts $f "  static X x;"
1036         puts $f "}"
1037         puts $f "struct Y"
1038         puts $f "{"
1039         puts $f "  Y() { f(); count = 2; }"
1040         puts $f "  ~Y()"
1041         puts $f "  {"
1042         puts $f "    if (count != 2)"
1043         puts $f "      exit(1);"
1044         puts $f "    count = 3;"
1045         puts $f "  }"
1046         puts $f "};"
1047         puts $f "Y y;"
1048         puts $f "int main()"
1049         puts $f "{ return 0; }"
1050         close $f
1051
1052         set lines [${tool}_target_compile $src $exe executable ""]
1053         file delete $src
1054
1055         if [string match "" $lines] {
1056             # No error message, compilation succeeded.
1057             set result [${tool}_load "./$exe" "" ""]
1058             set status [lindex $result 0]
1059             remote_file build delete $exe
1060
1061             verbose "check_cxa_atexit_available: status is <$status>" 2
1062
1063             if { $status == "pass" } {
1064                 set et_cxa_atexit 1
1065             }
1066         } else {
1067             verbose "check_cxa_atexit_available: compilation failed" 2
1068         }
1069     }
1070     return $et_cxa_atexit
1071 }
1072
1073
1074 # Return 1 if we're generating 32-bit code using default options, 0
1075 # otherwise.
1076
1077 proc check_effective_target_ilp32 { } {
1078     return [check_no_compiler_messages ilp32 object {
1079         int dummy[sizeof (int) == 4
1080                   && sizeof (void *) == 4
1081                   && sizeof (long) == 4 ? 1 : -1];
1082     }]
1083 }
1084
1085 # Return 1 if we're generating 32-bit or larger integers using default
1086 # options, 0 otherwise.
1087
1088 proc check_effective_target_int32plus { } {
1089     return [check_no_compiler_messages int32plus object {
1090         int dummy[sizeof (int) >= 4 ? 1 : -1];
1091     }]
1092 }
1093
1094 # Return 1 if we're generating 32-bit or larger pointers using default
1095 # options, 0 otherwise.
1096
1097 proc check_effective_target_ptr32plus { } {
1098     return [check_no_compiler_messages ptr32plus object {
1099         int dummy[sizeof (void *) >= 4 ? 1 : -1];
1100     }]
1101 }
1102
1103 # Return 1 if we support 32-bit or larger array and structure sizes
1104 # using default options, 0 otherwise.
1105
1106 proc check_effective_target_size32plus { } {
1107     return [check_no_compiler_messages size32plus object {
1108         char dummy[65537];
1109     }]
1110 }
1111
1112 # Returns 1 if we're generating 16-bit or smaller integers with the
1113 # default options, 0 otherwise.
1114
1115 proc check_effective_target_int16 { } {
1116     return [check_no_compiler_messages int16 object {
1117         int dummy[sizeof (int) < 4 ? 1 : -1];
1118     }]
1119 }
1120
1121 # Return 1 if we're generating 64-bit code using default options, 0
1122 # otherwise.
1123
1124 proc check_effective_target_lp64 { } {
1125     return [check_no_compiler_messages lp64 object {
1126         int dummy[sizeof (int) == 4
1127                   && sizeof (void *) == 8
1128                   && sizeof (long) == 8 ? 1 : -1];
1129     }]
1130 }
1131
1132 # Return 1 if the target supports long double larger than double,
1133 # 0 otherwise.
1134
1135 proc check_effective_target_large_long_double { } {
1136     return [check_no_compiler_messages large_long_double object {
1137         int dummy[sizeof(long double) > sizeof(double) ? 1 : -1];
1138     }]
1139 }
1140
1141
1142 # Return 1 if the target supports compiling decimal floating point,
1143 # 0 otherwise.
1144
1145 proc check_effective_target_dfp_nocache { } {
1146     verbose "check_effective_target_dfp_nocache: compiling source" 2
1147     set ret [string match "" [get_compiler_messages dfp 0 object {
1148         _Decimal32 x; _Decimal64 y; _Decimal128 z;
1149     }]]
1150     verbose "check_effective_target_dfp_nocache: returning $ret" 2
1151     return $ret
1152 }
1153
1154 proc check_effective_target_dfprt_nocache { } {
1155     global tool
1156
1157     set ret 0
1158
1159     verbose "check_effective_target_dfprt_nocache: compiling source" 2
1160     # Set up, compile, and execute a test program containing decimal
1161     # float operations.
1162     set src dfprt[pid].c
1163     set exe dfprt[pid].x
1164
1165     set f [open $src "w"]
1166     puts $f "_Decimal32 x = 1.2df; _Decimal64 y = 2.3dd; _Decimal128 z;"
1167     puts $f "int main () { z = x + y; return 0; }"
1168     close $f
1169
1170     verbose "check_effective_target_dfprt_nocache: compiling testfile $src" 2
1171     set lines [${tool}_target_compile $src $exe executable ""]
1172     file delete $src
1173
1174     if [string match "" $lines] then {
1175         # No error message, compilation succeeded.
1176         set result [${tool}_load "./$exe" "" ""]
1177         set status [lindex $result 0]
1178         remote_file build delete $exe
1179         verbose "check_effective_target_dfprt_nocache: testfile status is <$status>" 2
1180         if { $status == "pass" } then {
1181             set ret 1
1182         }
1183     }
1184     return $ret
1185     verbose "check_effective_target_dfprt_nocache: returning $ret" 2
1186 }
1187
1188 # Return 1 if the target supports compiling Decimal Floating Point,
1189 # 0 otherwise.
1190 #
1191 # This won't change for different subtargets so cache the result.
1192
1193 proc check_effective_target_dfp { } {
1194     global et_dfp_saved
1195
1196     if [info exists et_dfp_saved] {
1197         verbose "check_effective_target_dfp: using cached result" 2
1198     } else {
1199         set et_dfp_saved [check_effective_target_dfp_nocache]
1200     }
1201     verbose "check_effective_target_dfp: returning $et_dfp_saved" 2
1202     return $et_dfp_saved
1203 }
1204
1205 # Return 1 if the target supports linking and executing Decimal Floating
1206 # Point, # 0 otherwise.
1207 #
1208 # This won't change for different subtargets so cache the result.
1209
1210 proc check_effective_target_dfprt { } {
1211     global et_dfprt_saved
1212     global tool
1213
1214     if [info exists et_dfprt_saved] {
1215         verbose "check_effective_target_dfprt: using cached result" 2
1216     } else {
1217         set et_dfprt_saved [check_effective_target_dfprt_nocache]
1218     }
1219     verbose "check_effective_target_dfprt: returning $et_dfprt_saved" 2
1220     return $et_dfprt_saved
1221 }
1222
1223 # Return 1 if the target needs a command line argument to enable a SIMD
1224 # instruction set.
1225
1226 proc check_effective_target_vect_cmdline_needed { } {
1227     global et_vect_cmdline_needed_saved
1228     global et_vect_cmdline_needed_target_name
1229
1230     if { ![info exists et_vect_cmdline_needed_target_name] } {
1231         set et_vect_cmdline_needed_target_name ""
1232     }
1233
1234     # If the target has changed since we set the cached value, clear it.
1235     set current_target [current_target_name]
1236     if { $current_target != $et_vect_cmdline_needed_target_name } {
1237         verbose "check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target'" 2
1238         set et_vect_cmdline_needed_target_name $current_target
1239         if { [info exists et_vect_cmdline_needed_saved] } {
1240             verbose "check_effective_target_vect_cmdline_needed: removing cached result" 2
1241             unset et_vect_cmdline_needed_saved
1242         }
1243     }
1244
1245     if [info exists et_vect_cmdline_needed_saved] {
1246         verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1247     } else {
1248         set et_vect_cmdline_needed_saved 1
1249         if { [istarget ia64-*-*]
1250              || (([istarget x86_64-*-*] || [istarget i?86-*-*])
1251                  && [check_effective_target_lp64])
1252              || ([istarget powerpc*-*-*]
1253                  && ([check_effective_target_powerpc_spe]
1254                      || [check_effective_target_powerpc_altivec]))} {
1255            set et_vect_cmdline_needed_saved 0
1256         }
1257     }
1258
1259     verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1260     return $et_vect_cmdline_needed_saved
1261 }
1262
1263 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
1264 #
1265 # This won't change for different subtargets so cache the result.
1266
1267 proc check_effective_target_vect_int { } {
1268     global et_vect_int_saved
1269
1270     if [info exists et_vect_int_saved] {
1271         verbose "check_effective_target_vect_int: using cached result" 2
1272     } else {
1273         set et_vect_int_saved 0
1274         if { [istarget i?86-*-*]
1275               || [istarget powerpc*-*-*]
1276               || [istarget spu-*-*]
1277               || [istarget x86_64-*-*]
1278               || [istarget sparc*-*-*]
1279               || [istarget alpha*-*-*]
1280               || [istarget ia64-*-*] } {
1281            set et_vect_int_saved 1
1282         }
1283     }
1284
1285     verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1286     return $et_vect_int_saved
1287 }
1288
1289 # Return 1 is this is an arm target using 32-bit instructions
1290 proc check_effective_target_arm32 { } {
1291     global et_arm32_saved
1292     global et_arm32_target_name
1293     global compiler_flags
1294
1295     if { ![info exists et_arm32_target_name] } {
1296         set et_arm32_target_name ""
1297     }
1298
1299     # If the target has changed since we set the cached value, clear it.
1300     set current_target [current_target_name]
1301     if { $current_target != $et_arm32_target_name } {
1302         verbose "check_effective_target_arm32: `$et_arm32_target_name' `$current_target'" 2
1303         set et_arm32_target_name $current_target
1304         if { [info exists et_arm32_saved] } {
1305             verbose "check_effective_target_arm32: removing cached result" 2
1306             unset et_arm32_saved
1307         }
1308     }
1309
1310     if [info exists et_arm32_saved] {
1311         verbose "check-effective_target_arm32: using cached result" 2
1312     } else {
1313         set et_arm32_saved 0
1314         if { [istarget arm-*-*]
1315               || [istarget strongarm*-*-*]
1316               || [istarget xscale-*-*] } {
1317             if ![string match "*-mthumb *" $compiler_flags] {
1318                 set et_arm32_saved 1
1319             }
1320         }
1321     }
1322     verbose "check_effective_target_arm32: returning $et_arm32_saved" 2
1323     return $et_arm32_saved
1324 }
1325
1326 # Return 1 if this is an ARM target supporting -mfpu=vfp
1327 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1328 # options.
1329
1330 proc check_effective_target_arm_vfp_ok { } {
1331     if { [check_effective_target_arm32] } {
1332         return [check_no_compiler_messages arm_vfp_ok object {
1333             int dummy;
1334         } "-mfpu=vfp -mfloat-abi=softfp"]
1335     } else {
1336         return 0
1337     }
1338 }
1339
1340 # Return 1 if this is a PowerPC target with floating-point registers.
1341
1342 proc check_effective_target_powerpc_fprs { } {
1343     if { [istarget powerpc*-*-*]
1344          || [istarget rs6000-*-*] } {
1345         return [check_no_compiler_messages powerpc_fprs object {
1346             #ifdef __NO_FPRS__
1347             #error no FPRs
1348             #else
1349             int dummy;
1350             #endif
1351         }]
1352     } else {
1353         return 0
1354     }
1355 }
1356
1357 # Return 1 if this is a PowerPC target supporting -maltivec.
1358
1359 proc check_effective_target_powerpc_altivec_ok { } {
1360     if { [istarget powerpc*-*-*]
1361          || [istarget rs6000-*-*] } {
1362         # AltiVec is not supported on Aix.
1363         if { [istarget powerpc*-*-aix*] } {
1364             return 0
1365         }
1366         return [check_no_compiler_messages powerpc_altivec_ok object {
1367             int dummy;
1368         } "-maltivec"]
1369     } else {
1370         return 0
1371     }
1372 }
1373
1374 # Return 1 if this is a PowerPC target with SPE enabled.
1375
1376 proc check_effective_target_powerpc_spe { } {
1377     if { [istarget powerpc*-*-*] } {
1378         return [check_no_compiler_messages powerpc_spe object {
1379             #ifndef __SPE__
1380             #error not SPE
1381             #else
1382             int dummy;
1383             #endif
1384         }]
1385     } else {
1386         return 0
1387     }
1388 }
1389
1390 # Return 1 if this is a PowerPC target with Altivec enabled.
1391
1392 proc check_effective_target_powerpc_altivec { } {
1393     if { [istarget powerpc*-*-*] } {
1394         return [check_no_compiler_messages powerpc_altivec object {
1395             #ifndef __ALTIVEC__
1396             #error not Altivec
1397             #else
1398             int dummy;
1399             #endif
1400         }]
1401     } else {
1402         return 0
1403     }
1404 }
1405
1406 # Return 1 if the target supports hardware vector shift operation.
1407
1408 proc check_effective_target_vect_shift { } {
1409     global et_vect_shift_saved
1410
1411     if [info exists et_vect_shift_saved] {
1412         verbose "check_effective_target_vect_shift: using cached result" 2
1413     } else {
1414         set et_vect_shift_saved 0
1415         if { [istarget powerpc*-*-*]
1416              || [istarget ia64-*-*]
1417              || [istarget i?86-*-*]
1418              || [istarget x86_64-*-*] } {
1419            set et_vect_shift_saved 1
1420         }
1421     }
1422
1423     verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1424     return $et_vect_shift_saved
1425 }
1426
1427 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1428 #
1429 # This can change for different subtargets so do not cache the result.
1430
1431 proc check_effective_target_vect_long { } {
1432     if { [istarget i?86-*-*]
1433          || ([istarget powerpc*-*-*] && [check_effective_target_ilp32])
1434          || [istarget x86_64-*-*]
1435          || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1436         set answer 1
1437     } else {
1438         set answer 0
1439     }
1440
1441     verbose "check_effective_target_vect_long: returning $answer" 2
1442     return $answer
1443 }
1444
1445 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1446 #
1447 # This won't change for different subtargets so cache the result.
1448
1449 proc check_effective_target_vect_float { } {
1450     global et_vect_float_saved
1451
1452     if [info exists et_vect_float_saved] {
1453         verbose "check_effective_target_vect_float: using cached result" 2
1454     } else {
1455         set et_vect_float_saved 0
1456         if { [istarget i?86-*-*]
1457               || [istarget powerpc*-*-*]
1458               || [istarget spu-*-*]
1459               || [istarget mipsisa64*-*-*]
1460               || [istarget x86_64-*-*]
1461               || [istarget ia64-*-*] } {
1462            set et_vect_float_saved 1
1463         }
1464     }
1465
1466     verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1467     return $et_vect_float_saved
1468 }
1469
1470 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1471 #
1472 # This won't change for different subtargets so cache the result.
1473
1474 proc check_effective_target_vect_double { } {
1475     global et_vect_double_saved
1476
1477     if [info exists et_vect_double_saved] {
1478         verbose "check_effective_target_vect_double: using cached result" 2
1479     } else {
1480         set et_vect_double_saved 0
1481         if { [istarget i?86-*-*]
1482               || [istarget x86_64-*-*] 
1483               || [istarget spu-*-*] } {
1484            set et_vect_double_saved 1
1485         }
1486     }
1487
1488     verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1489     return $et_vect_double_saved
1490 }
1491
1492 # Return 0 if the target supports hardware comparison of vectors of double, 0 otherwise.
1493 #
1494 # This won't change for different subtargets so cache the result.
1495
1496 proc check_effective_target_vect_no_compare_double { } {
1497     global et_vect_no_compare_double_saved
1498
1499     if [info exists et_vect_no_compare_double_saved] {
1500         verbose "check_effective_target_vect_no_compare_double: using cached result" 2
1501     } else {
1502         set et_vect_no_compare_double_saved 0
1503         if { [istarget spu-*-*] } {
1504            set et_vect_no_compare_double_saved 1
1505         }
1506     }
1507
1508     verbose "check_effective_target_vect_no_compare_double: returning $et_vect_no_compare_double_saved" 2
1509     return $et_vect_no_compare_double_saved
1510 }
1511
1512 # Return 1 if the target plus current options does not support a vector
1513 # max instruction on "int", 0 otherwise.
1514 #
1515 # This won't change for different subtargets so cache the result.
1516
1517 proc check_effective_target_vect_no_int_max { } {
1518     global et_vect_no_int_max_saved
1519
1520     if [info exists et_vect_no_int_max_saved] {
1521         verbose "check_effective_target_vect_no_int_max: using cached result" 2
1522     } else {
1523         set et_vect_no_int_max_saved 0
1524         if { [istarget sparc*-*-*]
1525              || [istarget spu-*-*]
1526              || [istarget alpha*-*-*] } {
1527             set et_vect_no_int_max_saved 1
1528         }
1529     }
1530     verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1531     return $et_vect_no_int_max_saved
1532 }
1533
1534 # Return 1 if the target plus current options does not support a vector
1535 # add instruction on "int", 0 otherwise.
1536 #
1537 # This won't change for different subtargets so cache the result.
1538
1539 proc check_effective_target_vect_no_int_add { } {
1540     global et_vect_no_int_add_saved
1541
1542     if [info exists et_vect_no_int_add_saved] {
1543         verbose "check_effective_target_vect_no_int_add: using cached result" 2
1544     } else {
1545         set et_vect_no_int_add_saved 0
1546         # Alpha only supports vector add on V8QI and V4HI.
1547         if { [istarget alpha*-*-*] } {
1548             set et_vect_no_int_add_saved 1
1549         }
1550     }
1551     verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1552     return $et_vect_no_int_add_saved
1553 }
1554
1555 # Return 1 if the target plus current options does not support vector
1556 # bitwise instructions, 0 otherwise.
1557 #
1558 # This won't change for different subtargets so cache the result.
1559
1560 proc check_effective_target_vect_no_bitwise { } {
1561     global et_vect_no_bitwise_saved
1562
1563     if [info exists et_vect_no_bitwise_saved] {
1564         verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1565     } else {
1566         set et_vect_no_bitwise_saved 0
1567     }
1568     verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1569     return $et_vect_no_bitwise_saved
1570 }
1571
1572 # Return 1 if the target plus current options supports a vector
1573 # widening summation of *short* args into *int* result, 0 otherwise.
1574 # A target can also support this widening summation if it can support
1575 # promotion (unpacking) from shorts to ints.
1576 #
1577 # This won't change for different subtargets so cache the result.
1578                                                                                                 
1579 proc check_effective_target_vect_widen_sum_hi_to_si { } {
1580     global et_vect_widen_sum_hi_to_si
1581
1582     if [info exists et_vect_widen_sum_hi_to_si_saved] {
1583         verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
1584     } else {
1585         set et_vect_widen_sum_hi_to_si_saved [check_effective_target_vect_unpack]
1586         if { [istarget powerpc*-*-*] } {
1587             set et_vect_widen_sum_hi_to_si_saved 1
1588         }
1589     }
1590     verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
1591     return $et_vect_widen_sum_hi_to_si_saved
1592 }
1593
1594 # Return 1 if the target plus current options supports a vector
1595 # widening summation of *char* args into *short* result, 0 otherwise.
1596 # A target can also support this widening summation if it can support
1597 # promotion (unpacking) from chars to shorts.
1598 #
1599 # This won't change for different subtargets so cache the result.
1600                                                                                                 
1601 proc check_effective_target_vect_widen_sum_qi_to_hi { } {
1602     global et_vect_widen_sum_qi_to_hi
1603
1604     if [info exists et_vect_widen_sum_qi_to_hi_saved] {
1605         verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
1606     } else {
1607         set et_vect_widen_sum_qi_to_hi_saved 0
1608         if { [check_effective_target_vect_unpack] } {
1609             set et_vect_widen_sum_qi_to_hi_saved 1
1610         }
1611     }
1612     verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
1613     return $et_vect_widen_sum_qi_to_hi_saved
1614 }
1615
1616 # Return 1 if the target plus current options supports a vector
1617 # widening summation of *char* args into *int* result, 0 otherwise.
1618 #
1619 # This won't change for different subtargets so cache the result.
1620                                                                                                 
1621 proc check_effective_target_vect_widen_sum_qi_to_si { } {
1622     global et_vect_widen_sum_qi_to_si
1623
1624     if [info exists et_vect_widen_sum_qi_to_si_saved] {
1625         verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
1626     } else {
1627         set et_vect_widen_sum_qi_to_si_saved 0
1628         if { [istarget powerpc*-*-*] } {
1629             set et_vect_widen_sum_qi_to_si_saved 1
1630         }
1631     }
1632     verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
1633     return $et_vect_widen_sum_qi_to_si_saved
1634 }
1635
1636 # Return 1 if the target plus current options supports a vector
1637 # widening multiplication of *char* args into *short* result, 0 otherwise.
1638 # A target can also support this widening multplication if it can support
1639 # promotion (unpacking) from chars to shorts, and vect_short_mult (non-widening
1640 # multiplication of shorts).
1641 #
1642 # This won't change for different subtargets so cache the result.
1643
1644
1645 proc check_effective_target_vect_widen_mult_qi_to_hi { } {
1646     global et_vect_widen_mult_qi_to_hi
1647
1648     if [info exists et_vect_widen_mult_qi_to_hi_saved] {
1649         verbose "check_effective_target_vect_widen_mult_qi_to_hi: using cached result" 2
1650     } else {
1651         if { [check_effective_target_vect_unpack]
1652              && [check_effective_target_vect_short_mult] } {
1653             set et_vect_widen_mult_qi_to_hi_saved 1
1654         } else {
1655             set et_vect_widen_mult_qi_to_hi_saved 0
1656         }
1657         if { [istarget powerpc*-*-*] } {
1658             set et_vect_widen_mult_qi_to_hi_saved 1
1659         }
1660     }
1661     verbose "check_effective_target_vect_widen_mult_qi_to_hi: returning $et_vect_widen_mult_qi_to_hi_saved" 2
1662     return $et_vect_widen_mult_qi_to_hi_saved
1663 }
1664
1665 # Return 1 if the target plus current options supports a vector
1666 # widening multiplication of *short* args into *int* result, 0 otherwise.
1667 # A target can also support this widening multplication if it can support
1668 # promotion (unpacking) from shorts to ints, and vect_int_mult (non-widening
1669 # multiplication of ints).
1670 #
1671 # This won't change for different subtargets so cache the result.
1672
1673
1674 proc check_effective_target_vect_widen_mult_hi_to_si { } {
1675     global et_vect_widen_mult_hi_to_si
1676
1677     if [info exists et_vect_widen_mult_hi_to_si_saved] {
1678         verbose "check_effective_target_vect_widen_mult_hi_to_si: using cached result" 2
1679     } else {
1680         if { [check_effective_target_vect_unpack]
1681              && [check_effective_target_vect_int_mult] } {
1682           set et_vect_widen_mult_hi_to_si_saved 1
1683         } else {
1684           set et_vect_widen_mult_hi_to_si_saved 0
1685         }
1686         if { [istarget powerpc*-*-*]
1687               || [istarget spu-*-*]
1688               || [istarget i?86-*-*]
1689               || [istarget x86_64-*-*] } {
1690             set et_vect_widen_mult_hi_to_si_saved 1
1691         }
1692     }
1693     verbose "check_effective_target_vect_widen_mult_hi_to_si: returning $et_vect_widen_mult_hi_to_si_saved" 2
1694     return $et_vect_widen_mult_hi_to_si_saved
1695 }
1696
1697 # Return 1 if the target plus current options supports a vector
1698 # dot-product of signed chars, 0 otherwise.
1699 #
1700 # This won't change for different subtargets so cache the result.
1701
1702 proc check_effective_target_vect_sdot_qi { } {
1703     global et_vect_sdot_qi
1704
1705     if [info exists et_vect_sdot_qi_saved] {
1706         verbose "check_effective_target_vect_sdot_qi: using cached result" 2
1707     } else {
1708         set et_vect_sdot_qi_saved 0
1709     }
1710     verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1711     return $et_vect_sdot_qi_saved
1712 }
1713
1714 # Return 1 if the target plus current options supports a vector
1715 # dot-product of unsigned chars, 0 otherwise.
1716 #
1717 # This won't change for different subtargets so cache the result.
1718
1719 proc check_effective_target_vect_udot_qi { } {
1720     global et_vect_udot_qi
1721
1722     if [info exists et_vect_udot_qi_saved] {
1723         verbose "check_effective_target_vect_udot_qi: using cached result" 2
1724     } else {
1725         set et_vect_udot_qi_saved 0
1726         if { [istarget powerpc*-*-*] } {
1727             set et_vect_udot_qi_saved 1
1728         }
1729     }
1730     verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1731     return $et_vect_udot_qi_saved
1732 }
1733
1734 # Return 1 if the target plus current options supports a vector
1735 # dot-product of signed shorts, 0 otherwise.
1736 #
1737 # This won't change for different subtargets so cache the result.
1738
1739 proc check_effective_target_vect_sdot_hi { } {
1740     global et_vect_sdot_hi
1741
1742     if [info exists et_vect_sdot_hi_saved] {
1743         verbose "check_effective_target_vect_sdot_hi: using cached result" 2
1744     } else {
1745         set et_vect_sdot_hi_saved 0
1746         if { [istarget powerpc*-*-*] 
1747              || [istarget i?86-*-*]
1748              || [istarget x86_64-*-*] } {
1749             set et_vect_sdot_hi_saved 1
1750         }
1751     }
1752     verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
1753     return $et_vect_sdot_hi_saved
1754 }
1755
1756 # Return 1 if the target plus current options supports a vector
1757 # dot-product of unsigned shorts, 0 otherwise.
1758 #
1759 # This won't change for different subtargets so cache the result.
1760
1761 proc check_effective_target_vect_udot_hi { } {
1762     global et_vect_udot_hi
1763
1764     if [info exists et_vect_udot_hi_saved] {
1765         verbose "check_effective_target_vect_udot_hi: using cached result" 2
1766     } else {
1767         set et_vect_udot_hi_saved 0
1768         if { [istarget powerpc*-*-*] } {
1769             set et_vect_udot_hi_saved 1
1770         }
1771     }
1772     verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
1773     return $et_vect_udot_hi_saved
1774 }
1775
1776
1777 # Return 1 if the target plus current options supports a vector
1778 # demotion (packing) of shorts (to chars) and ints (to shorts) 
1779 # using modulo arithmetic, 0 otherwise.
1780 #
1781 # This won't change for different subtargets so cache the result.
1782                                                                                 
1783 proc check_effective_target_vect_pack_mod { } {
1784     global et_vect_pack_mod
1785                                                                                 
1786     if [info exists et_vect_pack_mod_saved] {
1787         verbose "check_effective_target_vect_pack_mod: using cached result" 2
1788     } else {
1789         set et_vect_pack_mod_saved 0
1790         if { [istarget powerpc*-*-*]
1791              || [istarget i?86-*-*]
1792              || [istarget x86_64-*-*] } {
1793             set et_vect_pack_mod_saved 1
1794         }
1795     }
1796     verbose "check_effective_target_vect_pack_mod: returning $et_vect_pack_mod_saved" 2
1797     return $et_vect_pack_mod_saved
1798 }
1799
1800 # Return 1 if the target plus current options supports a vector
1801 # promotion (unpacking) of chars (to shorts) and shorts (to ints), 0 otherwise.
1802 #
1803 # This won't change for different subtargets so cache the result.
1804                                    
1805 proc check_effective_target_vect_unpack { } {
1806     global et_vect_unpack
1807                                         
1808     if [info exists et_vect_unpack_saved] {
1809         verbose "check_effective_target_vect_unpack: using cached result" 2
1810     } else {
1811         set et_vect_unpack_saved 0
1812         if { [istarget powerpc*-*-*]
1813              || [istarget i?86-*-*]
1814              || [istarget x86_64-*-*] } {
1815             set et_vect_unpack_saved 1
1816         }
1817     }
1818     verbose "check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2  
1819     return $et_vect_unpack_saved
1820 }
1821
1822 # Return 1 if the target plus current options does not support a vector
1823 # alignment mechanism, 0 otherwise.
1824 #
1825 # This won't change for different subtargets so cache the result.
1826
1827 proc check_effective_target_vect_no_align { } {
1828     global et_vect_no_align_saved
1829
1830     if [info exists et_vect_no_align_saved] {
1831         verbose "check_effective_target_vect_no_align: using cached result" 2
1832     } else {
1833         set et_vect_no_align_saved 0
1834         if { [istarget mipsisa64*-*-*]
1835              || [istarget sparc*-*-*]
1836              || [istarget ia64-*-*] } {
1837             set et_vect_no_align_saved 1
1838         }
1839     }
1840     verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
1841     return $et_vect_no_align_saved
1842 }
1843
1844 # Return 1 if the target supports vector conditional operations, 0 otherwise.
1845
1846 proc check_effective_target_vect_condition { } {
1847     global et_vect_cond_saved
1848
1849     if [info exists et_vect_cond_saved] {
1850         verbose "check_effective_target_vect_cond: using cached result" 2
1851     } else {
1852         set et_vect_cond_saved 0
1853         if { [istarget powerpc*-*-*]
1854              || [istarget ia64-*-*]
1855              || [istarget i?86-*-*]
1856              || [istarget x86_64-*-*] } {
1857            set et_vect_cond_saved 1
1858         }
1859     }
1860
1861     verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
1862     return $et_vect_cond_saved
1863 }
1864
1865 # Return 1 if the target supports vector char multiplication, 0 otherwise.
1866
1867 proc check_effective_target_vect_char_mult { } {
1868     global et_vect_char_mult_saved
1869
1870     if [info exists et_vect_char_mult_saved] {
1871         verbose "check_effective_target_vect_char_mult: using cached result" 2
1872     } else {
1873         set et_vect_char_mult_saved 0
1874         if { [istarget ia64-*-*]
1875              || [istarget i?86-*-*]
1876              || [istarget x86_64-*-*] } {
1877            set et_vect_char_mult_saved 1
1878         }
1879     }
1880
1881     verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
1882     return $et_vect_char_mult_saved
1883 }
1884
1885 # Return 1 if the target supports vector short multiplication, 0 otherwise.
1886
1887 proc check_effective_target_vect_short_mult { } {
1888     global et_vect_short_mult_saved
1889
1890     if [info exists et_vect_short_mult_saved] {
1891         verbose "check_effective_target_vect_short_mult: using cached result" 2
1892     } else {
1893         set et_vect_short_mult_saved 0
1894         if { [istarget ia64-*-*]
1895              || [istarget i?86-*-*]
1896              || [istarget x86_64-*-*] } {
1897            set et_vect_short_mult_saved 1
1898         }
1899     }
1900
1901     verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
1902     return $et_vect_short_mult_saved
1903 }
1904
1905 # Return 1 if the target supports vector int multiplication, 0 otherwise.
1906
1907 proc check_effective_target_vect_int_mult { } {
1908     global et_vect_int_mult_saved
1909
1910     if [info exists et_vect_int_mult_saved] {
1911         verbose "check_effective_target_vect_int_mult: using cached result" 2
1912     } else {
1913         set et_vect_int_mult_saved 0
1914         if { [istarget powerpc*-*-*]
1915              || [istarget i?86-*-*]
1916              || [istarget x86_64-*-*] } {
1917            set et_vect_int_mult_saved 1
1918         }
1919     }
1920
1921     verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
1922     return $et_vect_int_mult_saved
1923 }
1924
1925 # Return 1 if the target supports vector even/odd elements extraction, 0 otherwise.
1926
1927 proc check_effective_target_vect_extract_even_odd { } {
1928     global et_vect_extract_even_odd_saved
1929     
1930     if [info exists et_vect_extract_even_odd_saved] {
1931         verbose "check_effective_target_vect_extract_even_odd: using cached result" 2
1932     } else {
1933         set et_vect_extract_even_odd_saved 0 
1934         if { [istarget powerpc*-*-*] } {
1935            set et_vect_extract_even_odd_saved 1
1936         }
1937     }
1938
1939     verbose "check_effective_target_vect_extract_even_odd: returning $et_vect_extract_even_odd_saved" 2
1940     return $et_vect_extract_even_odd_saved
1941 }
1942
1943 # Return 1 if the target supports vector interleaving, 0 otherwise.
1944
1945 proc check_effective_target_vect_interleave { } {
1946     global et_vect_interleave_saved
1947     
1948     if [info exists et_vect_interleave_saved] {
1949         verbose "check_effective_target_vect_interleave: using cached result" 2
1950     } else {
1951         set et_vect_interleave_saved 0
1952         if { [istarget powerpc*-*-*]
1953              || [istarget i?86-*-*]
1954              || [istarget x86_64-*-*] } {
1955            set et_vect_interleave_saved 1
1956         }
1957     }
1958
1959     verbose "check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
1960     return $et_vect_interleave_saved
1961 }
1962
1963 # Return 1 if the target supports section-anchors
1964
1965 proc check_effective_target_section_anchors { } {
1966     global et_section_anchors_saved
1967
1968     if [info exists et_section_anchors_saved] {
1969         verbose "check_effective_target_section_anchors: using cached result" 2
1970     } else {
1971         set et_section_anchors_saved 0
1972         if { [istarget powerpc*-*-*] } {
1973            set et_section_anchors_saved 1
1974         }
1975     }
1976
1977     verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
1978     return $et_section_anchors_saved
1979 }
1980
1981 # Return 1 if the target supports atomic operations on "int" and "long".
1982
1983 proc check_effective_target_sync_int_long { } {
1984     global et_sync_int_long_saved
1985
1986     if [info exists et_sync_int_long_saved] {
1987         verbose "check_effective_target_sync_int_long: using cached result" 2
1988     } else {
1989         set et_sync_int_long_saved 0
1990 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
1991 # load-reserved/store-conditional instructions.
1992         if { [istarget ia64-*-*]
1993              || [istarget i?86-*-*]
1994              || [istarget x86_64-*-*]
1995              || [istarget alpha*-*-*] 
1996              || [istarget s390*-*-*] 
1997              || [istarget powerpc*-*-*]
1998              || [istarget sparc64-*-*]
1999              || [istarget sparcv9-*-*] } {
2000            set et_sync_int_long_saved 1
2001         }
2002     }
2003
2004     verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2005     return $et_sync_int_long_saved
2006 }
2007
2008 # Return 1 if the target supports atomic operations on "char" and "short".
2009
2010 proc check_effective_target_sync_char_short { } {
2011     global et_sync_char_short_saved
2012
2013     if [info exists et_sync_char_short_saved] {
2014         verbose "check_effective_target_sync_char_short: using cached result" 2
2015     } else {
2016         set et_sync_char_short_saved 0
2017 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2018 # load-reserved/store-conditional instructions.
2019         if { [istarget ia64-*-*]
2020              || [istarget i?86-*-*]
2021              || [istarget x86_64-*-*]
2022              || [istarget alpha*-*-*] 
2023              || [istarget s390*-*-*] 
2024              || [istarget powerpc*-*-*]
2025              || [istarget sparc64-*-*]
2026              || [istarget sparcv9-*-*] } {
2027            set et_sync_char_short_saved 1
2028         }
2029     }
2030
2031     verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2032     return $et_sync_char_short_saved
2033 }
2034
2035 # Return 1 if the target uses a ColdFire FPU.
2036
2037 proc check_effective_target_coldfire_fpu { } {
2038     return [check_no_compiler_messages coldfire_fpu assembly {
2039         #ifndef __mcffpu__
2040         #error FOO
2041         #endif
2042     }]
2043 }
2044
2045 # Return true if this is a uClibc target.
2046
2047 proc check_effective_target_uclibc {} {
2048     return [check_no_compiler_messages uclibc object {
2049         #include <features.h>
2050         #if !defined (__UCLIBC__)
2051         #error FOO
2052         #endif
2053     }]
2054 }
2055
2056 # Return true if this is a Newlib target.
2057
2058 proc check_effective_target_newlib {} {
2059     return [check_no_compiler_messages newlib object {
2060         #include <newlib.h>
2061     }]
2062 }
2063
2064 # Return 1 if
2065 #   (a) an error of a few ULP is expected in string to floating-point
2066 #       conversion functions; and
2067 #   (b) overflow is not always detected correctly by those functions.
2068
2069 proc check_effective_target_lax_strtofp {} {
2070     # By default, assume that all uClibc targets suffer from this.
2071     return [check_effective_target_uclibc]
2072 }
2073
2074 # Return 1 if this is a target for which wcsftime is a dummy
2075 # function that always returns 0.
2076
2077 proc check_effective_target_dummy_wcsftime {} {
2078     # By default, assume that all uClibc targets suffer from this.
2079     return [check_effective_target_uclibc]
2080 }
2081
2082 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
2083 # This can be used with any check_* proc that takes no argument and
2084 # returns only 1 or 0.  It could be used with check_* procs that take
2085 # arguments with keywords that pass particular arguments.
2086
2087 proc is-effective-target { arg } {
2088     set selected 0
2089     if { [info procs check_effective_target_${arg}] != [list] } {
2090         set selected [check_effective_target_${arg}]
2091     } else {
2092         switch $arg {
2093           "vmx_hw"         { set selected [check_vmx_hw_available] }
2094           "named_sections" { set selected [check_named_sections_available] }
2095           "gc_sections"    { set selected [check_gc_sections_available] }
2096           "cxa_atexit"     { set selected [check_cxa_atexit_available] }
2097           default          { error "unknown effective target keyword `$arg'" }
2098         }
2099     }
2100     verbose "is-effective-target: $arg $selected" 2
2101     return $selected
2102 }
2103
2104 # Return 1 if the argument is an effective-target keyword, 0 otherwise.
2105
2106 proc is-effective-target-keyword { arg } {
2107     if { [info procs check_effective_target_${arg}] != [list] } {
2108         return 1
2109     } else {
2110         # These have different names for their check_* procs.
2111         switch $arg {
2112           "vmx_hw"         { return 1 }
2113           "named_sections" { return 1 }
2114           "gc_sections"    { return 1 }
2115           "cxa_atexit"     { return 1 }
2116           default          { return 0 }
2117         }
2118     }
2119 }
2120
2121 # Return 1 if target default to short enums
2122
2123 proc check_effective_target_short_enums { } {
2124     return [check_no_compiler_messages short_enums assembly {
2125         enum foo { bar };
2126         int s[sizeof (enum foo) == 1 ? 1 : -1];
2127     }]
2128 }
2129
2130 # Return 1 if target supports merging string constants at link time.
2131
2132 proc check_effective_target_string_merging { } {
2133     return [check_no_messages_and_pattern string_merging \
2134                 "rodata\\.str" assembly {
2135                     const char *var = "String";
2136                 } {-O2}]
2137 }
2138
2139 # Return 1 if target has the basic signed and unsigned types in
2140 # <stdint.h>, 0 otherwise.
2141
2142 proc check_effective_target_stdint_types { } {
2143     return [check_no_compiler_messages stdint_types assembly {
2144         #include <stdint.h>
2145         int8_t a; int16_t b; int32_t c; int64_t d;
2146         uint8_t e; uint16_t f; uint32_t g; uint64_t h;
2147     }]
2148 }
2149
2150 # Return 1 if programs are intended to be run on a simulator
2151 # (i.e. slowly) rather than hardware (i.e. fast).
2152
2153 proc check_effective_target_simulator { } {
2154
2155     # All "src/sim" simulators set this one.
2156     if [board_info target exists is_simulator] {
2157         return [board_info target is_simulator]
2158     }
2159
2160     # The "sid" simulators don't set that one, but at least they set
2161     # this one.
2162     if [board_info target exists slow_simulator] {
2163         return [board_info target slow_simulator]
2164     }
2165
2166     return 0
2167 }