OSDN Git Service

38eb91ad197d5a59c638fa027b188e2446c02886
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / lib / target-supports.exp
1 #   Copyright (C) 1999, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
2
3 # This program is free software; you can redistribute it and/or modify
4 # it under the terms of the GNU General Public License as published by
5 # the Free Software Foundation; either version 2 of the License, or
6 # (at your option) any later version.
7 #
8 # This program is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 # GNU General Public License for more details.
12 #
13 # You should have received a copy of the GNU General Public License
14 # along with this program; if not, write to the Free Software
15 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16
17 # Please email any bugs, comments, and/or additions to this file to:
18 # gcc-patches@gcc.gnu.org
19
20 # This file defines procs for determining features supported by the target.
21
22 # Try to compile some code and return the messages printed by the compiler.
23 #
24 # BASENAME is a basename to use for temporary files.
25 # TYPE is the type of compilation to perform (see target_compile).
26 # CONTENTS gives the contents of the input file.
27 # The rest is optional:
28 # OPTIONS: additional compiler options to use.
29 proc get_compiler_messages {basename type contents args} {
30     global tool
31
32     if { [llength $args] > 0 } {
33         set options "additional_flags=[lindex $args 0]"
34     } else {
35         set options ""
36     }
37
38     set src ${basename}[pid].c
39     switch $type {
40         assembly { set output ${basename}[pid].s }
41         object { set output ${basename}[pid].o }
42     }
43     set f [open $src "w"]
44     puts $f $contents
45     close $f
46     set lines [${tool}_target_compile $src $output $type "$options"]
47     file delete $src
48     remote_file build delete $output
49
50     return $lines
51 }
52
53 proc current_target_name { } {
54     global target_info
55     if [info exists target_info(target,name)] {
56         set answer $target_info(target,name)
57     } else {
58         set answer ""
59     }
60     return $answer
61 }
62
63 ###############################
64 # proc check_weak_available { }
65 ###############################
66
67 # weak symbols are only supported in some configs/object formats
68 # this proc returns 1 if they're supported, 0 if they're not, or -1 if unsure
69
70 proc check_weak_available { } {
71     global target_triplet
72     global target_cpu
73
74     # All mips targets should support it
75
76     if { [ string first "mips" $target_cpu ] >= 0 } {
77         return 1
78     }
79
80     # All solaris2 targets should support it
81
82     if { [regexp ".*-solaris2.*" $target_triplet] } {
83         return 1
84     }
85
86     # DEC OSF/1/Digital UNIX/Tru64 UNIX supports it
87
88     if { [regexp "alpha.*osf.*" $target_triplet] } {
89         return 1
90     }
91
92     # Windows targets Cygwin and MingW32 support it
93
94     if { [regexp ".*mingw32|.*cygwin" $target_triplet] } {
95         return 1
96     }
97
98     # HP-UX 10.X doesn't support it
99
100     if { [regexp "hppa.*hpux10" $target_triplet] } {
101         return 0
102     }
103
104     # ELF and ECOFF support it. a.out does with gas/gld but may also with
105     # other linkers, so we should try it
106
107     set objformat [gcc_target_object_format]
108
109     switch $objformat {
110         elf      { return 1 }
111         ecoff    { return 1 }
112         a.out    { return 1 }
113         mach-o   { return 1 }
114         som      { return 1 }
115         unknown  { return -1 }
116         default  { return 0 }
117     }
118 }
119
120 ###############################
121 # proc check_visibility_available { what_kind }
122 ###############################
123
124 # The visibility attribute is only support in some object formats
125 # This proc returns 1 if it is supported, 0 if not.
126 # The argument is the kind of visibility, default/protected/hidden/internal.
127
128 proc check_visibility_available { what_kind } {
129     global visibility_available_saved
130     global tool
131     global target_triplet
132
133     # On NetWare, support makes no sense.
134     if { [string match "*-*-netware*" $target_triplet] } {
135         return 0
136     }
137
138     if [string match "" $what_kind] { set what_kind "hidden" }
139
140     if { [info exists visibility_available_saved] } {
141         verbose "Saved result is <$visibility_available_saved>" 1
142         if { [ lsearch -exact $visibility_available_saved $what_kind ] != -1 } {
143             return 1
144         } elseif { [ lsearch -exact $visibility_available_saved "!$what_kind" ] != -1 } {
145             return 0
146         }
147     }
148
149     set lines [get_compiler_messages visibility object "
150         void f() __attribute__((visibility(\"$what_kind\")));
151         void f() {}
152     "]
153     if [string match "" $lines] then {
154         set answer 1
155         lappend visibility_available_saved $what_kind
156     } else {
157         set answer 0
158         lappend visibility_available_saved "!$what_kind"
159     }
160     return $answer
161 }
162
163 ###############################
164 # proc check_alias_available { }
165 ###############################
166
167 # Determine if the target toolchain supports the alias attribute.
168
169 # Returns 2 if the target supports aliases.  Returns 1 if the target
170 # only supports weak aliased.  Returns 0 if the target does not
171 # support aliases at all.  Returns -1 if support for aliases could not
172 # be determined.
173
174 proc check_alias_available { } {
175     global alias_available_saved
176     global tool
177
178     if [info exists alias_available_saved] {
179         verbose "check_alias_available  returning saved $alias_available_saved" 2
180     } else {
181         set src alias[pid].c
182         set obj alias[pid].o
183         verbose "check_alias_available  compiling testfile $src" 2
184         set f [open $src "w"]
185         # Compile a small test program.  The definition of "g" is
186         # necessary to keep the Solaris assembler from complaining
187         # about the program.
188         puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
189         puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
190         close $f
191         set lines [${tool}_target_compile $src $obj object ""]
192         file delete $src
193         remote_file build delete $obj
194
195         if [string match "" $lines] then {
196             # No error messages, everything is OK.
197             set alias_available_saved 2
198         } else {
199             if [regexp "alias definitions not supported" $lines] {
200                 verbose "check_alias_available  target does not support aliases" 2
201
202                 set objformat [gcc_target_object_format]
203
204                 if { $objformat == "elf" } {
205                     verbose "check_alias_available  but target uses ELF format, so it ought to" 2
206                     set alias_available_saved -1
207                 } else {
208                     set alias_available_saved 0
209                 }
210             } else {
211                 if [regexp "only weak aliases are supported" $lines] {
212                 verbose "check_alias_available  target supports only weak aliases" 2
213                 set alias_available_saved 1
214                 } else {
215                     set alias_available_saved -1
216                 }
217             }
218         }
219
220         verbose "check_alias_available  returning $alias_available_saved" 2
221     }
222
223     return $alias_available_saved
224 }
225
226 # Returns true if --gc-sections is supported on the target.
227
228 proc check_gc_sections_available { } {
229     global gc_sections_available_saved
230     global tool
231
232     if {![info exists gc_sections_available_saved]} {
233         # Some targets don't support gc-sections despite whatever's
234         # advertised by ld's options.
235         if { [istarget alpha*-*-*]
236              || [istarget ia64-*-*] } {
237             set gc_sections_available_saved 0
238             return 0
239         }
240
241         # Check if the ld used by gcc supports --gc-sections.
242         set gcc_spec [${tool}_target_compile "-dumpspecs" "" "none" ""]
243         regsub ".*\n\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
244         set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=$linker" "" "none" ""] 0]
245         set ld_output [remote_exec host "$gcc_ld" "--help"]
246         if { [ string first "--gc-sections" $ld_output ] >= 0 } {
247             set gc_sections_available_saved 1
248         } else {
249             set gc_sections_available_saved 0
250         }
251     }
252     return $gc_sections_available_saved
253 }
254
255 # Return true if profiling is supported on the target.
256
257 proc check_profiling_available { test_what } {
258     global profiling_available_saved
259
260     verbose "Profiling argument is <$test_what>" 1
261
262     # These conditions depend on the argument so examine them before
263     # looking at the cache variable.
264
265     # Support for -p on solaris2 relies on mcrt1.o which comes with the
266     # vendor compiler.  We cannot reliably predict the directory where the
267     # vendor compiler (and thus mcrt1.o) is installed so we can't
268     # necessarily find mcrt1.o even if we have it.
269     if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
270         return 0
271     }
272
273     # Support for -p on irix relies on libprof1.a which doesn't appear to
274     # exist on any irix6 system currently posting testsuite results.
275     # Support for -pg on irix relies on gcrt1.o which doesn't exist yet.
276     # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
277     if { [istarget mips*-*-irix*]
278     && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
279         return 0
280     }
281
282     # Now examine the cache variable.
283     if {![info exists profiling_available_saved]} {
284         # Some targets don't have any implementation of __bb_init_func or are
285         # missing other needed machinery.
286         if { [istarget mmix-*-*]
287              || [istarget arm*-*-eabi*]
288              || [istarget arm*-*-elf]
289              || [istarget arm*-*-symbianelf*]
290              || [istarget powerpc-*-eabi*]
291              || [istarget strongarm*-*-elf]
292              || [istarget xscale*-*-elf]
293              || [istarget cris-*-*]
294              || [istarget h8300-*-*]
295              || [istarget mips*-*-elf]
296              || [istarget xtensa-*-elf]
297              || [istarget *-*-windiss] } {
298             set profiling_available_saved 0
299         } else {
300             set profiling_available_saved 1
301         }
302     }
303
304     return $profiling_available_saved
305 }
306
307 # Return 1 if target has packed layout of structure members by
308 # default, 0 otherwise.  Note that this is slightly different than
309 # whether the target has "natural alignment": both attributes may be
310 # false.
311
312 proc check_effective_target_default_packed { } {
313     global et_default_packed_saved
314     global et_default_packed_target_name
315
316     if { ![info exists et_default_packed_target_name] } {
317         set et_default_packed_target_name ""
318     }
319
320     # If the target has changed since we set the cached value, clear it.
321     set current_target [current_target_name]
322     if { $current_target != $et_default_packed_target_name } {
323         verbose "check_effective_target_default_packed: `$et_default_packed_target_name'" 2
324         set et_default_packed_target_name $current_target
325         if [info exists et_default_packed_saved] {
326             verbose "check_effective_target_default_packed: removing cached result" 2
327             unset et_default_packed_saved
328         }
329     }
330
331     if [info exists et_default_packed_saved] {
332         verbose "check_effective_target_default_packed: using cached result" 2
333     } else {
334         verbose "check_effective_target_default_packed: compiling source" 2
335
336         set et_default_packed_saved \
337             [string match "" [get_compiler_messages default_packed assembly {
338             struct x { char a; long b; } c;
339             int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
340         } ]]
341
342     }
343     verbose "check_effective_target_default_packed: returning $et_default_packed_saved" 2
344     return $et_default_packed_saved
345 }
346
347 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
348 # documentation, where the test also comes from.
349
350 proc check_effective_target_pcc_bitfield_type_matters { } {
351     global et_pcc_bitfield_type_matters_saved
352     global et_pcc_bitfield_type_matters_target_name
353
354     if { ![info exists et_pcc_bitfield_type_matters_target_name] } {
355         set et_pcc_bitfield_type_matters_target_name ""
356     }
357
358     # If the target has changed since we set the cached value, clear it.
359     set current_target [current_target_name]
360     if { $current_target != $et_pcc_bitfield_type_matters_target_name } {
361         verbose "check_effective_target_pcc_bitfield_type_matters: `$et_pcc_bitfield_type_matters_target_name'" 2
362         set et_pcc_bitfield_type_matters_target_name $current_target
363         if [info exists et_pcc_bitfield_type_matters_saved] {
364             verbose "check_effective_target_pcc_bitfield_type_matters: removing cached result" 2
365             unset et_pcc_bitfield_type_matters_saved
366         }
367     }
368
369     if [info exists et_pcc_bitfield_type_matters_saved] {
370         verbose "check_effective_target_pcc_bitfield_type_matters: using cached result" 2
371     } else {
372         verbose "check_effective_target_pcc_bitfield_type_matters: compiling source" 2
373
374         # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
375         # bitfields, but let's stick to the example code from the docs.
376         set et_pcc_bitfield_type_matters_saved \
377             [string match "" [get_compiler_messages pcc_bitfield_type_matters assembly {
378             struct foo1 { char x; char :0; char y; };
379             struct foo2 { char x; int :0; char y; };
380             int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
381         } ]]
382     }
383     verbose "check_effective_target_pcc_bitfield_type_matters: returning $et_pcc_bitfield_type_matters_saved" 2
384     return $et_pcc_bitfield_type_matters_saved
385 }
386
387 # Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
388 # emitted, 0 otherwise.  Whether a shared library can actually be built is
389 # out of scope for this test.
390 #
391 # When the target name changes, replace the cached result.
392
393 proc check_effective_target_fpic { } {
394     global et_fpic_saved
395     global et_fpic_target_name
396
397     if { ![info exists et_fpic_target_name] } {
398         set et_fpic_target_name ""
399     }
400
401     # If the target has changed since we set the cached value, clear it.
402     set current_target [current_target_name]
403     if { $current_target != $et_fpic_target_name } {
404         verbose "check_effective_target_fpic: `$et_fpic_target_name'" 2
405         set et_fpic_target_name $current_target
406         if [info exists et_fpic_saved] {
407             verbose "check_effective_target_fpic: removing cached result" 2
408             unset et_fpic_saved
409         }
410     }
411
412     if [info exists et_fpic_saved] {
413         verbose "check_effective_target_fpic: using cached result" 2
414     } else {
415         verbose "check_effective_target_fpic: compiling source" 2
416
417         # Note that M68K has a multilib that supports -fpic but not
418         # -fPIC, so we need to check both.  We test with a program that
419         # requires GOT references.
420         set et_fpic_saved [string match "" [get_compiler_messages fpic object {
421             extern int foo (void); extern int bar;
422             int baz (void) { return foo () + bar; }
423         } "-fpic"]]
424
425         if { $et_fpic_saved != 0 } {
426             set et_fpic_saved [string match "" [get_compiler_messages fpic object {
427                 extern int foo (void); extern int bar;
428                 int baz (void) { return foo () + bar; }
429             } "-fPIC"]]
430         }
431     }
432     verbose "check_effective_target_fpic: returning $et_fpic_saved" 2
433     return $et_fpic_saved
434 }
435
436 # Return true if iconv is supported on the target. In particular IBM1047.
437
438 proc check_iconv_available { test_what } {
439     global tool
440     global libiconv
441
442     set result ""
443
444     set src iconv[pid].c
445     set exe iconv[pid].x
446     verbose "check_iconv_available compiling testfile $src" 2
447     set f [open $src "w"]
448     # Compile a small test program.
449     puts $f "#include <iconv.h>\n"
450     puts $f "int main (void)\n {\n iconv_t cd; \n"
451     puts $f "cd = iconv_open (\"[lindex $test_what 1]\", \"UTF-8\");\n"
452     puts $f "if (cd == (iconv_t) -1)\n return 1;\n"
453     puts $f "return 0;\n}"
454     close $f
455
456     # If the tool configuration file has not set libiconv, try "-liconv"
457     if { ![info exists libiconv] } {
458         set libiconv "-liconv"
459     }
460     set lines [${tool}_target_compile $src $exe executable "libs=$libiconv" ]
461     file delete $src
462
463     if [string match "" $lines] then {
464         # No error messages, everything is OK.
465
466         set result [${tool}_load "./$exe" "" ""]
467         set status [lindex $result 0]
468         remote_file build delete $exe
469
470         verbose "check_iconv_available status is <$status>" 2
471
472         if { $status == "pass" } then {
473             return 1
474         }
475     }
476
477     return 0
478 }
479
480 # Return true if named sections are supported on this target.
481 # This proc does not cache results, because the answer may vary
482 # when cycling over subtarget options (e.g. irix o32/n32/n64) in
483 # the same test run.
484 proc check_named_sections_available { } {
485     verbose "check_named_sections_available: compiling source" 2
486     set answer [string match "" [get_compiler_messages named object {
487         int __attribute__ ((section("whatever"))) foo;
488     }]]
489     verbose "check_named_sections_available: returning $answer" 2
490     return $answer
491 }
492
493 # Return 1 if the target supports Fortran real kinds larger than real(8),
494 # 0 otherwise.
495 #
496 # When the target name changes, replace the cached result.
497
498 proc check_effective_target_fortran_large_real { } {
499     global et_fortran_large_real_saved
500     global et_fortran_large_real_target_name
501     global tool
502
503     if { ![info exists et_fortran_large_real_target_name] } {
504         set et_fortran_large_real_target_name ""
505     }
506
507     # If the target has changed since we set the cached value, clear it.
508     set current_target [current_target_name]
509     if { $current_target != $et_fortran_large_real_target_name } {
510         verbose "check_effective_target_fortran_large_real: `$et_fortran_large_real_target_name' `$current_target'" 2
511         set et_fortran_large_real_target_name $current_target
512         if [info exists et_fortran_large_real_saved] {
513             verbose "check_effective_target_fortran_large_real: removing cached result" 2
514             unset et_fortran_large_real_saved
515         }
516     }
517
518     if [info exists et_fortran_large_real_saved] {
519         verbose "check_effective_target_fortran_large_real returning saved $et_fortran_large_real_saved" 2
520     } else {
521         set et_fortran_large_real_saved 0
522
523         # Set up, compile, and execute a test program using large real
524         # kinds.  Include the current process ID in the file names to
525         # prevent conflicts with invocations for multiple testsuites.
526         set src real[pid].f90
527         set exe real[pid].x
528
529         set f [open $src "w"]
530         puts $f "integer,parameter :: k = &"
531         puts $f "  selected_real_kind (precision (0.0_8) + 1)"
532         puts $f "real(kind=k) :: x"
533         puts $f "end"
534         close $f
535
536         verbose "check_effective_target_fortran_large_real compiling testfile $src" 2
537         set lines [${tool}_target_compile $src $exe executable ""]
538         file delete $src
539
540         if [string match "" $lines] then {
541             # No error message, compilation succeeded.
542             set et_fortran_large_real_saved 1
543         }
544     }
545
546     return $et_fortran_large_real_saved
547 }
548
549 # Return 1 if the target supports Fortran integer kinds larger than
550 # integer(8), 0 otherwise.
551 #
552 # When the target name changes, replace the cached result.
553
554 proc check_effective_target_fortran_large_int { } {
555     global et_fortran_large_int_saved
556     global et_fortran_large_int_target_name
557     global tool
558
559     if { ![info exists et_fortran_large_int_target_name] } {
560         set et_fortran_large_int_target_name ""
561     }
562
563     # If the target has changed since we set the cached value, clear it.
564     set current_target [current_target_name]
565     if { $current_target != $et_fortran_large_int_target_name } {
566         verbose "check_effective_target_fortran_large_int: `$et_fortran_large_int_target_name' `$current_target'" 2
567         set et_fortran_large_int_target_name $current_target
568         if [info exists et_fortran_large_int_saved] {
569             verbose "check_effective_target_fortran_large_int: removing cached result" 2
570             unset et_fortran_large_int_saved
571         }
572     }
573
574     if [info exists et_fortran_large_int_saved] {
575         verbose "check_effective_target_fortran_large_int returning saved $et_fortran_large_int_saved" 2
576     } else {
577         set et_fortran_large_int_saved 0
578
579         # Set up, compile, and execute a test program using large integer
580         # kinds.  Include the current process ID in the file names to
581         # prevent conflicts with invocations for multiple testsuites.
582         set src int[pid].f90
583         set exe int[pid].x
584
585         set f [open $src "w"]
586         puts $f "integer,parameter :: k = &"
587         puts $f "  selected_int_kind (range (0_8) + 1)"
588         puts $f "integer(kind=k) :: i"
589         puts $f "end"
590         close $f
591
592         verbose "check_effective_target_fortran_large_int compiling testfile $src" 2
593         set lines [${tool}_target_compile $src $exe executable ""]
594         file delete $src
595
596         if [string match "" $lines] then {
597             # No error message, compilation succeeded.
598             set et_fortran_large_int_saved 1
599         }
600     }
601
602     return $et_fortran_large_int_saved
603 }
604
605 # Return 1 if we can statically link libgfortran, 0 otherwise.
606 #
607 # When the target name changes, replace the cached result.
608
609 proc check_effective_target_static_libgfortran { } {
610     global et_static_libgfortran
611     global et_static_libgfortran_target_name
612     global tool
613
614     if { ![info exists et_static_libgfortran_target_name] } {
615        set et_static_libgfortran_target_name ""
616     }
617
618     # If the target has changed since we set the cached value, clear it.
619     set current_target [current_target_name]
620     if { $current_target != $et_static_libgfortran_target_name } {
621        verbose "check_effective_target_static_libgfortran: `$et_static_libgfortran_target_name' `$current_target'" 2
622        set et_static_libgfortran_target_name $current_target
623        if [info exists et_static_libgfortran_saved] {
624            verbose "check_effective_target_static_libgfortran: removing cached result" 2
625            unset et_static_libgfortran_saved
626        }
627     }
628
629     if [info exists et_static_libgfortran_saved] {
630        verbose "check_effective_target_static_libgfortran returning saved $et_static_libgfortran_saved" 2
631     } else {
632        set et_static_libgfortran_saved 0
633
634        # Set up, compile, and execute a test program using static linking.
635        # Include the current process ID in the file names to prevent
636        # conflicts with invocations for multiple testsuites.
637        set src static[pid].f
638         set exe static[pid].x
639
640        set f [open $src "w"]
641        puts $f "      print *, 'test'"
642        puts $f "      end"
643        close $f
644
645        verbose "check_effective_target_static_libgfortran compiling testfile $src" 2
646        set lines [${tool}_target_compile $src $exe executable "-static"]
647        file delete $src
648
649        if [string match "" $lines] then {
650            # No error message, compilation succeeded.
651            set et_static_libgfortran_saved 1
652        }
653     }
654
655     return $et_static_libgfortran_saved
656 }
657
658 # Return 1 if the target supports executing AltiVec instructions, 0
659 # otherwise.  Cache the result.
660
661 proc check_vmx_hw_available { } {
662     global vmx_hw_available_saved
663     global tool
664
665     if [info exists vmx_hw_available_saved] {
666         verbose "check_hw_available  returning saved $vmx_hw_available_saved" 2
667     } else {
668         set vmx_hw_available_saved 0
669
670         # Some simulators are known to not support VMX instructions.
671         if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
672             verbose "check_hw_available  returning 0" 2
673             return $vmx_hw_available_saved
674         }
675
676         # Set up, compile, and execute a test program containing VMX
677         # instructions.  Include the current process ID in the file
678         # names to prevent conflicts with invocations for multiple
679         # testsuites.
680         set src vmx[pid].c
681         set exe vmx[pid].x
682
683         set f [open $src "w"]
684         puts $f "int main() {"
685         puts $f "#ifdef __MACH__"
686         puts $f "  asm volatile (\"vor v0,v0,v0\");"
687         puts $f "#else"
688         puts $f "  asm volatile (\"vor 0,0,0\");"
689         puts $f "#endif"
690         puts $f "  return 0; }"
691         close $f
692
693         # Most targets don't require special flags for this test case, but
694         # Darwin does.
695         if [istarget *-*-darwin*] {
696           set opts "additional_flags=-maltivec"
697         } else {
698           set opts ""
699         }
700
701         verbose "check_vmx_hw_available  compiling testfile $src" 2
702         set lines [${tool}_target_compile $src $exe executable "$opts"]
703         file delete $src
704
705         if [string match "" $lines] then {
706             # No error message, compilation succeeded.
707             set result [${tool}_load "./$exe" "" ""]
708             set status [lindex $result 0]
709             remote_file build delete $exe
710             verbose "check_vmx_hw_available testfile status is <$status>" 2
711
712             if { $status == "pass" } then {
713                 set vmx_hw_available_saved 1
714             }
715         } else {
716             verbose "check_vmx_hw_availalble testfile compilation failed" 2
717         }
718     }
719
720     return $vmx_hw_available_saved
721 }
722
723 # GCC 3.4.0 for powerpc64-*-linux* included an ABI fix for passing
724 # complex float arguments.  This affects gfortran tests that call cabsf
725 # in libm built by an earlier compiler.  Return 1 if libm uses the same
726 # argument passing as the compiler under test, 0 otherwise.
727 #
728 # When the target name changes, replace the cached result.
729
730 proc check_effective_target_broken_cplxf_arg { } {
731     global et_broken_cplxf_arg_saved
732     global et_broken_cplxf_arg_target_name
733     global tool
734
735     # Skip the work for targets known not to be affected.
736     if { ![istarget powerpc64-*-linux*] } {
737         return 0
738     } elseif { [is-effective-target ilp32] } {
739         return 0
740     }
741
742     if { ![info exists et_broken_cplxf_arg_target_name] } {
743         set et_broken_cplxf_arg_target_name ""
744     }
745
746     # If the target has changed since we set the cached value, clear it.
747     set current_target [current_target_name]
748     if { $current_target != $et_broken_cplxf_arg_target_name } {
749         verbose "check_effective_target_broken_cplxf_arg: `$et_broken_cplxf_arg_target_name'" 2
750         set et_broken_cplxf_arg_target_name $current_target
751         if [info exists et_broken_cplxf_arg_saved] {
752             verbose "check_effective_target_broken_cplxf_arg: removing cached result" 2
753             unset et_broken_cplxf_arg_saved
754         }
755     }
756
757     if [info exists et_broken_cplxf_arg_saved] {
758         verbose "check_effective_target_broken_cplxf_arg: using cached result" 2
759     } else {
760         set et_broken_cplxf_arg_saved 0
761         # This is only known to affect one target.
762         if { ![istarget powerpc64-*-linux*] || ![is-effective-target lp64] } {
763             set et_broken_cplxf_arg_saved 0
764             verbose "check_effective_target_broken_cplxf_arg: caching 0" 2
765             return $et_broken_cplxf_arg_saved
766         }
767
768         # Set up, compile, and execute a C test program that calls cabsf.
769         set src cabsf[pid].c
770         set exe cabsf[pid].x
771
772         set f [open $src "w"]
773         puts $f "#include <complex.h>"
774         puts $f "extern void abort (void);"
775         puts $f "float fabsf (float);"
776         puts $f "float cabsf (_Complex float);"
777         puts $f "int main ()"
778         puts $f "{"
779         puts $f "  _Complex float cf;"
780         puts $f "  float f;"
781         puts $f "  cf = 3 + 4.0fi;"
782         puts $f "  f = cabsf (cf);"
783         puts $f "  if (fabsf (f - 5.0) > 0.0001) abort ();"
784         puts $f "  return 0;"
785         puts $f "}"
786         close $f
787
788         set lines [${tool}_target_compile $src $exe executable "-lm"]
789         file delete $src
790
791         if [string match "" $lines] {
792             # No error message, compilation succeeded.
793             set result [${tool}_load "./$exe" "" ""]
794             set status [lindex $result 0]
795             remote_file build delete $exe
796
797             verbose "check_effective_target_broken_cplxf_arg: status is <$status>" 2
798
799             if { $status != "pass" } {
800                 set et_broken_cplxf_arg_saved 1
801             }
802         } else {
803             verbose "check_effective_target_broken_cplxf_arg: compilation failed" 2
804         }
805     }
806     return $et_broken_cplxf_arg_saved
807 }
808
809 proc check_alpha_max_hw_available { } {
810     global alpha_max_hw_available_saved
811     global tool
812
813     if [info exists alpha_max_hw_available_saved] {
814         verbose "check_alpha_max_hw_available returning saved $alpha_max_hw_available_saved" 2
815     } else {
816         set alpha_max_hw_available_saved 0
817
818         # Set up, compile, and execute a test program probing bit 8 of the
819         # architecture mask, which indicates presence of MAX instructions.
820         set src max[pid].c
821         set exe max[pid].x
822
823         set f [open $src "w"]
824         puts $f "int main() { return __builtin_alpha_amask(1<<8) != 0; }"
825         close $f
826
827         verbose "check_alpha_max_hw_available compiling testfile $src" 2
828         set lines [${tool}_target_compile $src $exe executable ""]
829         file delete $src
830
831         if [string match "" $lines] then {
832             # No error message, compilation succeeded.
833             set result [${tool}_load "./$exe" "" ""]
834             set status [lindex $result 0]
835             remote_file build delete $exe
836             verbose "check_alpha_max_hw_available testfile status is <$status>" 2
837
838             if { $status == "pass" } then {
839                 set alpha_max_hw_available_saved 1
840             }
841         } else {
842             verbose "check_alpha_max_hw_availalble testfile compilation failed" 2
843         }
844     }
845
846     return $alpha_max_hw_available_saved
847 }
848
849 # Returns true iff the FUNCTION is available on the target system.
850 # (This is essentially a Tcl implementation of Autoconf's
851 # AC_CHECK_FUNC.)
852
853 proc check_function_available { function } {
854     set var "${function}_available_saved"
855     global $var
856     global tool
857
858     if {![info exists $var]} {
859         # Assume it exists.
860         set $var 1
861         # Check to make sure.
862         set src "function[pid].c"
863         set exe "function[pid].exe"
864
865         set f [open $src "w"]
866         puts $f "int main () { $function (); }"
867         close $f
868
869         set lines [${tool}_target_compile $src $exe executable ""]
870         file delete $src
871         file delete $exe
872
873         if {![string match "" $lines]} then {
874             set $var 0
875             verbose -log "$function is not available"
876         } else {
877             verbose -log "$function is available"
878         }
879     }
880
881     eval return \$$var
882 }
883
884 # Returns true iff "fork" is available on the target system.
885
886 proc check_fork_available {} {
887     return [check_function_available "fork"]
888 }
889
890 # Returns true iff "mkfifo" is available on the target system.
891
892 proc check_mkfifo_available {} {
893     if {[istarget *-*-cygwin*]} {
894        # Cygwin has mkfifo, but support is incomplete.
895        return 0
896      }
897
898     return [check_function_available "mkfifo"]
899 }
900
901 # Return 1 if we're generating 32-bit code using default options, 0
902 # otherwise.
903 #
904 # When the target name changes, replace the cached result.
905
906 proc check_effective_target_ilp32 { } {
907     global et_ilp32_saved
908     global et_ilp32_target_name
909
910     if { ![info exists et_ilp32_target_name] } {
911         set et_ilp32_target_name ""
912     }
913
914     # If the target has changed since we set the cached value, clear it.
915     set current_target [current_target_name]
916     if { $current_target != $et_ilp32_target_name } {
917         verbose "check_effective_target_ilp32: `$et_ilp32_target_name' `$current_target'" 2
918         set et_ilp32_target_name $current_target
919         if { [info exists et_ilp32_saved] } {
920             verbose "check_effective_target_ilp32: removing cached result" 2
921             unset et_ilp32_saved
922         }
923     }
924
925     if [info exists et_ilp32_saved] {
926         verbose "check-effective_target_ilp32: using cached result" 2
927     } else {
928         verbose "check_effective_target_ilp32: compiling source" 2
929         set et_ilp32_saved [string match "" [get_compiler_messages ilp32 object {
930             int dummy[(sizeof (int) == 4 && sizeof (void *) == 4 && sizeof (long) == 4 ) ? 1 : -1];
931         }]]
932     }
933     verbose "check_effective_target_ilp32: returning $et_ilp32_saved" 2
934     return $et_ilp32_saved
935 }
936
937 # Return 1 if we're generating 64-bit code using default options, 0
938 # otherwise.
939 #
940 # When the target name changes, replace the cached result.
941
942 proc check_effective_target_lp64 { } {
943     global et_lp64_saved
944     global et_lp64_target_name
945
946     if { ![info exists et_lp64_target_name] } {
947         set et_lp64_target_name ""
948     }
949
950     # If the target has changed since we set the cached value, clear it.
951     set current_target [current_target_name]
952     if { $current_target != $et_lp64_target_name } {
953         verbose "check_effective_target_lp64: `$et_lp64_target_name' `$current_target'" 2
954         set et_lp64_target_name $current_target
955         if [info exists et_lp64_saved] {
956             verbose "check_effective_target_lp64: removing cached result" 2
957             unset et_lp64_saved
958         }
959     }
960
961     if [info exists et_lp64_saved] {
962         verbose "check_effective_target_lp64: using cached result" 2
963     } else {
964         verbose "check_effective_target_lp64: compiling source" 2
965         set et_lp64_saved [string match "" [get_compiler_messages lp64 object {
966             int dummy[(sizeof (int) == 4 && sizeof (void *) == 8 && sizeof (long) == 8 ) ? 1 : -1];
967         }]]
968     }
969     verbose "check_effective_target_lp64: returning $et_lp64_saved" 2
970     return $et_lp64_saved
971 }
972
973 # Return 1 if the target needs a command line argument to enable a SIMD
974 # instruction set.
975 #
976 # This won't change for different subtargets so cache the result.
977
978 proc check_effective_target_vect_cmdline_needed { } {
979     global et_vect_cmdline_needed_saved
980
981     if [info exists et_vect_cmdline_needed_saved] {
982         verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
983     } else {
984         set et_vect_cmdline_needed_saved 1
985         if { [istarget ia64-*-*]
986               || [istarget x86_64-*-*] } {
987            set et_vect_cmdline_needed_saved 0
988         }
989     }
990
991     verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
992     return $et_vect_cmdline_needed_saved
993 }
994
995 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
996 #
997 # This won't change for different subtargets so cache the result.
998
999 proc check_effective_target_vect_int { } {
1000     global et_vect_int_saved
1001
1002     if [info exists et_vect_int_saved] {
1003         verbose "check_effective_target_vect_int: using cached result" 2
1004     } else {
1005         set et_vect_int_saved 0
1006         if { [istarget i?86-*-*]
1007               || [istarget powerpc*-*-*]
1008               || [istarget x86_64-*-*]
1009               || [istarget sparc*-*-*]
1010               || [istarget alpha*-*-*]
1011               || [istarget ia64-*-*] } {
1012            set et_vect_int_saved 1
1013         }
1014     }
1015
1016     verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1017     return $et_vect_int_saved
1018 }
1019
1020 # Return 1 is this is an arm target using 32-bit instructions
1021 proc check_effective_target_arm32 { } {
1022     global et_arm32_saved
1023     global et_arm32_target_name
1024     global compiler_flags
1025
1026     if { ![info exists et_arm32_target_name] } {
1027         set et_arm32_target_name ""
1028     }
1029
1030     # If the target has changed since we set the cached value, clear it.
1031     set current_target [current_target_name]
1032     if { $current_target != $et_arm32_target_name } {
1033         verbose "check_effective_target_arm32: `$et_arm32_target_name' `$current_target'" 2
1034         set et_arm32_target_name $current_target
1035         if { [info exists et_arm32_saved] } {
1036             verbose "check_effective_target_arm32: removing cached result" 2
1037             unset et_arm32_saved
1038         }
1039     }
1040
1041     if [info exists et_arm32_saved] {
1042         verbose "check-effective_target_arm32: using cached result" 2
1043     } else {
1044         set et_arm32_saved 0
1045         if { [istarget arm-*-*]
1046               || [istarget strongarm*-*-*]
1047               || [istarget xscale-*-*] } {
1048             if ![string match "*-mthumb *" $compiler_flags] {
1049                 set et_arm32_saved 1
1050             }
1051         }
1052     }
1053     verbose "check_effective_target_arm32: returning $et_arm32_saved" 2
1054     return $et_arm32_saved
1055 }
1056
1057 # Return 1 if the target supports hardware vector shift operation.
1058
1059 proc check_effective_target_vect_shift { } {
1060     global et_vect_shift_saved
1061
1062     if [info exists et_vect_shift_saved] {
1063         verbose "check_effective_target_vect_shift: using cached result" 2
1064     } else {
1065         set et_vect_shift_saved 0
1066         if { [istarget powerpc*-*-*]
1067              || [istarget ia64-*-*]
1068              || [istarget i?86-*-*]
1069              || [istarget x86_64-*-*] } {
1070            set et_vect_shift_saved 1
1071         }
1072     }
1073
1074     verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1075     return $et_vect_shift_saved
1076 }
1077
1078 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1079 #
1080 # This can change for different subtargets so do not cache the result.
1081
1082 proc check_effective_target_vect_long { } {
1083     if { [istarget i?86-*-*]
1084          || ([istarget powerpc*-*-*] && [check_effective_target_ilp32])
1085          || [istarget x86_64-*-*]
1086          || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1087         set answer 1
1088     } else {
1089         set answer 0
1090     }
1091
1092     verbose "check_effective_target_vect_long: returning $answer" 2
1093     return $answer
1094 }
1095
1096 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1097 #
1098 # This won't change for different subtargets so cache the result.
1099
1100 proc check_effective_target_vect_float { } {
1101     global et_vect_float_saved
1102
1103     if [info exists et_vect_float_saved] {
1104         verbose "check_effective_target_vect_float: using cached result" 2
1105     } else {
1106         set et_vect_float_saved 0
1107         if { [istarget i?86-*-*]
1108               || [istarget powerpc*-*-*]
1109               || [istarget mipsisa64*-*-*]
1110               || [istarget x86_64-*-*]
1111               || [istarget ia64-*-*] } {
1112            set et_vect_float_saved 1
1113         }
1114     }
1115
1116     verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1117     return $et_vect_float_saved
1118 }
1119
1120 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1121 #
1122 # This won't change for different subtargets so cache the result.
1123
1124 proc check_effective_target_vect_double { } {
1125     global et_vect_double_saved
1126
1127     if [info exists et_vect_double_saved] {
1128         verbose "check_effective_target_vect_double: using cached result" 2
1129     } else {
1130         set et_vect_double_saved 0
1131         if { [istarget i?86-*-*]
1132               || [istarget x86_64-*-*] } {
1133            set et_vect_double_saved 1
1134         }
1135     }
1136
1137     verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1138     return $et_vect_double_saved
1139 }
1140
1141 # Return 1 if the target plus current options does not support a vector
1142 # max instruction on "int", 0 otherwise.
1143 #
1144 # This won't change for different subtargets so cache the result.
1145
1146 proc check_effective_target_vect_no_int_max { } {
1147     global et_vect_no_int_max_saved
1148
1149     if [info exists et_vect_no_int_max_saved] {
1150         verbose "check_effective_target_vect_no_int_max: using cached result" 2
1151     } else {
1152         set et_vect_no_int_max_saved 0
1153         if { [istarget sparc*-*-*]
1154              || [istarget alpha*-*-*] } {
1155             set et_vect_no_int_max_saved 1
1156         }
1157     }
1158     verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1159     return $et_vect_no_int_max_saved
1160 }
1161
1162 # Return 1 if the target plus current options does not support a vector
1163 # add instruction on "int", 0 otherwise.
1164 #
1165 # This won't change for different subtargets so cache the result.
1166
1167 proc check_effective_target_vect_no_int_add { } {
1168     global et_vect_no_int_add_saved
1169
1170     if [info exists et_vect_no_int_add_saved] {
1171         verbose "check_effective_target_vect_no_int_add: using cached result" 2
1172     } else {
1173         set et_vect_no_int_add_saved 0
1174         # Alpha only supports vector add on V8QI and V4HI.
1175         if { [istarget alpha*-*-*] } {
1176             set et_vect_no_int_add_saved 1
1177         }
1178     }
1179     verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1180     return $et_vect_no_int_add_saved
1181 }
1182
1183 # Return 1 if the target plus current options does not support vector
1184 # bitwise instructions, 0 otherwise.
1185 #
1186 # This won't change for different subtargets so cache the result.
1187
1188 proc check_effective_target_vect_no_bitwise { } {
1189     global et_vect_no_bitwise_saved
1190
1191     if [info exists et_vect_no_bitwise_saved] {
1192         verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1193     } else {
1194         set et_vect_no_bitwise_saved 0
1195     }
1196     verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1197     return $et_vect_no_bitwise_saved
1198 }
1199
1200 # Return 1 if the target plus current options does not support a vector
1201 # alignment mechanism, 0 otherwise.
1202 #
1203 # This won't change for different subtargets so cache the result.
1204
1205 proc check_effective_target_vect_no_align { } {
1206     global et_vect_no_align_saved
1207
1208     if [info exists et_vect_no_align_saved] {
1209         verbose "check_effective_target_vect_no_align: using cached result" 2
1210     } else {
1211         set et_vect_no_align_saved 0
1212         if { [istarget mipsisa64*-*-*]
1213              || [istarget sparc*-*-*]
1214              || [istarget ia64-*-*] } {
1215             set et_vect_no_align_saved 1
1216         }
1217     }
1218     verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
1219     return $et_vect_no_align_saved
1220 }
1221
1222 # Return 1 if the target supports vector conditional operations, 0 otherwise.
1223
1224 proc check_effective_target_vect_condition { } {
1225     global et_vect_cond_saved
1226
1227     if [info exists et_vect_cond_saved] {
1228         verbose "check_effective_target_vect_cond: using cached result" 2
1229     } else {
1230         set et_vect_cond_saved 0
1231         if { [istarget powerpc*-*-*]
1232              || [istarget ia64-*-*]
1233              || [istarget i?86-*-*]
1234              || [istarget x86_64-*-*] } {
1235            set et_vect_cond_saved 1
1236         }
1237     }
1238
1239     verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
1240     return $et_vect_cond_saved
1241 }
1242
1243 # Return 1 if the target supports vector int multiplication, 0 otherwise.
1244
1245 proc check_effective_target_vect_int_mult { } {
1246     global et_vect_int_mult_saved
1247
1248     if [info exists et_vect_int_mult_saved] {
1249         verbose "check_effective_target_vect_int_mult: using cached result" 2
1250     } else {
1251         set et_vect_int_mult_saved 0
1252         if { [istarget powerpc*-*-*]
1253              || [istarget i?86-*-*]
1254              || [istarget x86_64-*-*] } {
1255            set et_vect_int_mult_saved 1
1256         }
1257     }
1258
1259     verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
1260     return $et_vect_int_mult_saved
1261 }
1262
1263 # Return 1 if the target supports atomic operations on "int" and "long".
1264
1265 proc check_effective_target_sync_int_long { } {
1266     global et_sync_int_long_saved
1267
1268     if [info exists et_sync_int_long_saved] {
1269         verbose "check_effective_target_sync_int_long: using cached result" 2
1270     } else {
1271         set et_sync_int_long_saved 0
1272 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
1273 # load-reserved/store-conditional instructions.
1274         if { [istarget ia64-*-*]
1275              || [istarget i?86-*-*]
1276              || [istarget x86_64-*-*]
1277              || [istarget alpha*-*-*] 
1278              || [istarget s390*-*-*] 
1279              || [istarget powerpc*-*-*] } {
1280            set et_sync_int_long_saved 1
1281         }
1282     }
1283
1284     verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
1285     return $et_sync_int_long_saved
1286 }
1287
1288 # Return 1 if the target supports atomic operations on "char" and "short".
1289
1290 proc check_effective_target_sync_char_short { } {
1291     global et_sync_char_short_saved
1292
1293     if [info exists et_sync_char_short_saved] {
1294         verbose "check_effective_target_sync_char_short: using cached result" 2
1295     } else {
1296         set et_sync_char_short_saved 0
1297 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
1298 # load-reserved/store-conditional instructions.
1299         if { [istarget ia64-*-*]
1300              || [istarget i?86-*-*]
1301              || [istarget x86_64-*-*]
1302              || [istarget alpha*-*-*] 
1303              || [istarget powerpc*-*-*] } {
1304            set et_sync_char_short_saved 1
1305         }
1306     }
1307
1308     verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
1309     return $et_sync_char_short_saved
1310 }
1311
1312 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
1313 # This can be used with any check_* proc that takes no argument and
1314 # returns only 1 or 0.  It could be used with check_* procs that take
1315 # arguments with keywords that pass particular arguments.
1316
1317 proc is-effective-target { arg } {
1318     set selected 0
1319     if { [info procs check_effective_target_${arg}] != [list] } {
1320         set selected [check_effective_target_${arg}]
1321     } else {
1322         switch $arg {
1323           "vmx_hw"         { set selected [check_vmx_hw_available] }
1324           "named_sections" { set selected [check_named_sections_available] }
1325           "gc_sections"    { set selected [check_gc_sections_available] }
1326           default          { error "unknown effective target keyword `$arg'" }
1327         }
1328     }
1329     verbose "is-effective-target: $arg $selected" 2
1330     return $selected
1331 }
1332
1333 # Return 1 if the argument is an effective-target keyword, 0 otherwise.
1334
1335 proc is-effective-target-keyword { arg } {
1336     if { [info procs check_effective_target_${arg}] != [list] } {
1337         return 1
1338     } else {
1339         # These have different names for their check_* procs.
1340         switch $arg {
1341           "vmx_hw"         { return 1 }
1342           "named_sections" { return 1 }
1343           "gc_sections"    { return 1 }
1344           default          { return 0 }
1345         }
1346     }
1347 }