OSDN Git Service

2009-10-26 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / lib / target-supports.exp
1 #   Copyright (C) 1999, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
2 #    Free Software Foundation, Inc.
3
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with GCC; see the file COPYING3.  If not see
16 # <http://www.gnu.org/licenses/>.
17
18 # Please email any bugs, comments, and/or additions to this file to:
19 # gcc-patches@gcc.gnu.org
20
21 # This file defines procs for determining features supported by the target.
22
23 # Try to compile the code given by CONTENTS into an output file of
24 # type TYPE, where TYPE is as for target_compile.  Return a list
25 # whose first element contains the compiler messages and whose
26 # second element is the name of the output file.
27 #
28 # BASENAME is a prefix to use for source and output files.
29 # If ARGS is not empty, its first element is a string that
30 # should be added to the command line.
31 #
32 # Assume by default that CONTENTS is C code.  C++ code should contain
33 # "// C++" and Fortran code should contain "! Fortran".
34 proc check_compile {basename type contents args} {
35     global tool
36
37     if { [llength $args] > 0 } {
38         set options [list "additional_flags=[lindex $args 0]"]
39     } else {
40         set options ""
41     }
42     switch -glob -- $contents {
43         "*! Fortran*" { set src ${basename}[pid].f90 }
44         "*// C++*" { set src ${basename}[pid].cc }
45         default { set src ${basename}[pid].c }
46     }
47     set compile_type $type
48     switch -glob $type {
49         assembly { set output ${basename}[pid].s }
50         object { set output ${basename}[pid].o }
51         executable { set output ${basename}[pid].exe }
52         "rtl-*" {
53             set output ${basename}[pid].s
54             lappend options "additional_flags=-fdump-$type"
55             set compile_type assembly
56         }
57     }
58     set f [open $src "w"]
59     puts $f $contents
60     close $f
61     set lines [${tool}_target_compile $src $output $compile_type "$options"]
62     file delete $src
63
64     set scan_output $output
65     # Don't try folding this into the switch above; calling "glob" before the
66     # file is created won't work.
67     if [regexp "rtl-(.*)" $type dummy rtl_type] {
68         set scan_output "[glob $src.\[0-9\]\[0-9\]\[0-9\]r.$rtl_type]"
69         file delete $output
70     }
71
72     return [list $lines $scan_output]
73 }
74
75 proc current_target_name { } {
76     global target_info
77     if [info exists target_info(target,name)] {
78         set answer $target_info(target,name)
79     } else {
80         set answer ""
81     }
82     return $answer
83 }
84
85 # Implement an effective-target check for property PROP by invoking
86 # the Tcl command ARGS and seeing if it returns true.
87
88 proc check_cached_effective_target { prop args } {
89     global et_cache
90
91     set target [current_target_name]
92     if {![info exists et_cache($prop,target)]
93         || $et_cache($prop,target) != $target} {
94         verbose "check_cached_effective_target $prop: checking $target" 2
95         set et_cache($prop,target) $target
96         set et_cache($prop,value) [uplevel eval $args]
97     }
98     set value $et_cache($prop,value)
99     verbose "check_cached_effective_target $prop: returning $value for $target" 2
100     return $value
101 }
102
103 # Like check_compile, but delete the output file and return true if the
104 # compiler printed no messages.
105 proc check_no_compiler_messages_nocache {args} {
106     set result [eval check_compile $args]
107     set lines [lindex $result 0]
108     set output [lindex $result 1]
109     remote_file build delete $output
110     return [string match "" $lines]
111 }
112
113 # Like check_no_compiler_messages_nocache, but cache the result.
114 # PROP is the property we're checking, and doubles as a prefix for
115 # temporary filenames.
116 proc check_no_compiler_messages {prop args} {
117     return [check_cached_effective_target $prop {
118         eval [list check_no_compiler_messages_nocache $prop] $args
119     }]
120 }
121
122 # Like check_compile, but return true if the compiler printed no
123 # messages and if the contents of the output file satisfy PATTERN.
124 # If PATTERN has the form "!REGEXP", the contents satisfy it if they
125 # don't match regular expression REGEXP, otherwise they satisfy it
126 # if they do match regular expression PATTERN.  (PATTERN can start
127 # with something like "[!]" if the regular expression needs to match
128 # "!" as the first character.)
129 #
130 # Delete the output file before returning.  The other arguments are
131 # as for check_compile.
132 proc check_no_messages_and_pattern_nocache {basename pattern args} {
133     global tool
134
135     set result [eval [list check_compile $basename] $args]
136     set lines [lindex $result 0]
137     set output [lindex $result 1]
138
139     set ok 0
140     if { [string match "" $lines] } {
141         set chan [open "$output"]
142         set invert [regexp {^!(.*)} $pattern dummy pattern]
143         set ok [expr { [regexp $pattern [read $chan]] != $invert }]
144         close $chan
145     }
146
147     remote_file build delete $output
148     return $ok
149 }
150
151 # Like check_no_messages_and_pattern_nocache, but cache the result.
152 # PROP is the property we're checking, and doubles as a prefix for
153 # temporary filenames.
154 proc check_no_messages_and_pattern {prop pattern args} {
155     return [check_cached_effective_target $prop {
156         eval [list check_no_messages_and_pattern_nocache $prop $pattern] $args
157     }]
158 }
159
160 # Try to compile and run an executable from code CONTENTS.  Return true
161 # if the compiler reports no messages and if execution "passes" in the
162 # usual DejaGNU sense.  The arguments are as for check_compile, with
163 # TYPE implicitly being "executable".
164 proc check_runtime_nocache {basename contents args} {
165     global tool
166
167     set result [eval [list check_compile $basename executable $contents] $args]
168     set lines [lindex $result 0]
169     set output [lindex $result 1]
170
171     set ok 0
172     if { [string match "" $lines] } {
173         # No error messages, everything is OK.
174         set result [remote_load target "./$output" "" ""]
175         set status [lindex $result 0]
176         verbose "check_runtime_nocache $basename: status is <$status>" 2
177         if { $status == "pass" } {
178             set ok 1
179         }
180     }
181     remote_file build delete $output
182     return $ok
183 }
184
185 # Like check_runtime_nocache, but cache the result.  PROP is the
186 # property we're checking, and doubles as a prefix for temporary
187 # filenames.
188 proc check_runtime {prop args} {
189     global tool
190
191     return [check_cached_effective_target $prop {
192         eval [list check_runtime_nocache $prop] $args
193     }]
194 }
195
196 ###############################
197 # proc check_weak_available { }
198 ###############################
199
200 # weak symbols are only supported in some configs/object formats
201 # this proc returns 1 if they're supported, 0 if they're not, or -1 if unsure
202
203 proc check_weak_available { } {
204     global target_triplet
205     global target_cpu
206
207     # All mips targets should support it
208
209     if { [ string first "mips" $target_cpu ] >= 0 } {
210         return 1
211     }
212
213     # All solaris2 targets should support it
214
215     if { [regexp ".*-solaris2.*" $target_triplet] } {
216         return 1
217     }
218
219     # DEC OSF/1/Digital UNIX/Tru64 UNIX supports it
220
221     if { [regexp "alpha.*osf.*" $target_triplet] } {
222         return 1
223     }
224
225     # Windows targets Cygwin and MingW32 support it
226
227     if { [regexp ".*mingw32|.*cygwin" $target_triplet] } {
228         return 1
229     }
230
231     # HP-UX 10.X doesn't support it
232
233     if { [istarget "hppa*-*-hpux10*"] } {
234         return 0
235     }
236
237     # ELF and ECOFF support it. a.out does with gas/gld but may also with
238     # other linkers, so we should try it
239
240     set objformat [gcc_target_object_format]
241
242     switch $objformat {
243         elf      { return 1 }
244         ecoff    { return 1 }
245         a.out    { return 1 }
246         mach-o   { return 1 }
247         som      { return 1 }
248         unknown  { return -1 }
249         default  { return 0 }
250     }
251 }
252
253 ###############################
254 # proc check_weak_override_available { }
255 ###############################
256
257 # Like check_weak_available, but return 0 if weak symbol definitions
258 # cannot be overridden.
259
260 proc check_weak_override_available { } {
261     if { [istarget "*-*-mingw*"] } {
262         return 0
263     }
264     return [check_weak_available]
265 }
266
267 ###############################
268 # proc check_visibility_available { what_kind }
269 ###############################
270
271 # The visibility attribute is only support in some object formats
272 # This proc returns 1 if it is supported, 0 if not.
273 # The argument is the kind of visibility, default/protected/hidden/internal.
274
275 proc check_visibility_available { what_kind } {
276     global tool
277     global target_triplet
278
279     # On NetWare, support makes no sense.
280     if { [istarget *-*-netware*] } {
281         return 0
282     }
283
284     if [string match "" $what_kind] { set what_kind "hidden" }
285
286     return [check_no_compiler_messages visibility_available_$what_kind object "
287         void f() __attribute__((visibility(\"$what_kind\")));
288         void f() {}
289     "]
290 }
291
292 ###############################
293 # proc check_alias_available { }
294 ###############################
295
296 # Determine if the target toolchain supports the alias attribute.
297
298 # Returns 2 if the target supports aliases.  Returns 1 if the target
299 # only supports weak aliased.  Returns 0 if the target does not
300 # support aliases at all.  Returns -1 if support for aliases could not
301 # be determined.
302
303 proc check_alias_available { } {
304     global alias_available_saved
305     global tool
306
307     if [info exists alias_available_saved] {
308         verbose "check_alias_available  returning saved $alias_available_saved" 2
309     } else {
310         set src alias[pid].c
311         set obj alias[pid].o
312         verbose "check_alias_available  compiling testfile $src" 2
313         set f [open $src "w"]
314         # Compile a small test program.  The definition of "g" is
315         # necessary to keep the Solaris assembler from complaining
316         # about the program.
317         puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
318         puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
319         close $f
320         set lines [${tool}_target_compile $src $obj object ""]
321         file delete $src
322         remote_file build delete $obj
323
324         if [string match "" $lines] then {
325             # No error messages, everything is OK.
326             set alias_available_saved 2
327         } else {
328             if [regexp "alias definitions not supported" $lines] {
329                 verbose "check_alias_available  target does not support aliases" 2
330
331                 set objformat [gcc_target_object_format]
332
333                 if { $objformat == "elf" } {
334                     verbose "check_alias_available  but target uses ELF format, so it ought to" 2
335                     set alias_available_saved -1
336                 } else {
337                     set alias_available_saved 0
338                 }
339             } else {
340                 if [regexp "only weak aliases are supported" $lines] {
341                 verbose "check_alias_available  target supports only weak aliases" 2
342                 set alias_available_saved 1
343                 } else {
344                     set alias_available_saved -1
345                 }
346             }
347         }
348
349         verbose "check_alias_available  returning $alias_available_saved" 2
350     }
351
352     return $alias_available_saved
353 }
354
355 # Returns true if --gc-sections is supported on the target.
356
357 proc check_gc_sections_available { } {
358     global gc_sections_available_saved
359     global tool
360
361     if {![info exists gc_sections_available_saved]} {
362         # Some targets don't support gc-sections despite whatever's
363         # advertised by ld's options.
364         if { [istarget alpha*-*-*]
365              || [istarget ia64-*-*] } {
366             set gc_sections_available_saved 0
367             return 0
368         }
369
370         # elf2flt uses -q (--emit-relocs), which is incompatible with
371         # --gc-sections.
372         if { [board_info target exists ldflags]
373              && [regexp " -elf2flt\[ =\]" " [board_info target ldflags] "] } {
374             set gc_sections_available_saved 0
375             return 0
376         }
377
378         # VxWorks kernel modules are relocatable objects linked with -r,
379         # while RTP executables are linked with -q (--emit-relocs).
380         # Both of these options are incompatible with --gc-sections.
381         if { [istarget *-*-vxworks*] } {
382             set gc_sections_available_saved 0
383             return 0
384         }
385
386         # Check if the ld used by gcc supports --gc-sections.
387         set gcc_spec [${tool}_target_compile "-dumpspecs" "" "none" ""]
388         regsub ".*\n\\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
389         set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=$linker" "" "none" ""] 0]
390         set ld_output [remote_exec host "$gcc_ld" "--help"]
391         if { [ string first "--gc-sections" $ld_output ] >= 0 } {
392             set gc_sections_available_saved 1
393         } else {
394             set gc_sections_available_saved 0
395         }
396     }
397     return $gc_sections_available_saved
398 }
399
400 # Return 1 if according to target_info struct and explicit target list
401 # target is supposed to support trampolines.
402  
403 proc check_effective_target_trampolines { } {
404     if [target_info exists no_trampolines] {
405       return 0
406     }
407     if { [istarget avr-*-*]
408          || [istarget hppa2.0w-hp-hpux11.23]
409         || [istarget hppa64-hp-hpux11.23] } {
410         return 0;   
411     }
412     return 1
413 }
414
415 # Return 1 if according to target_info struct and explicit target list
416 # target is supposed to keep null pointer checks. This could be due to 
417 # use of option fno-delete-null-pointer-checks or hardwired in target.
418  
419 proc check_effective_target_keeps_null_pointer_checks { } {
420     if [target_info exists keeps_null_pointer_checks] {
421       return 1
422     }
423     if { [istarget avr-*-*] } {
424         return 1;   
425     }
426     return 0
427 }
428
429 # Return true if profiling is supported on the target.
430
431 proc check_profiling_available { test_what } {
432     global profiling_available_saved
433
434     verbose "Profiling argument is <$test_what>" 1
435
436     # These conditions depend on the argument so examine them before
437     # looking at the cache variable.
438
439     # Support for -p on solaris2 relies on mcrt1.o which comes with the
440     # vendor compiler.  We cannot reliably predict the directory where the
441     # vendor compiler (and thus mcrt1.o) is installed so we can't
442     # necessarily find mcrt1.o even if we have it.
443     if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
444         return 0
445     }
446
447     # Support for -p on irix relies on libprof1.a which doesn't appear to
448     # exist on any irix6 system currently posting testsuite results.
449     # Support for -pg on irix relies on gcrt1.o which doesn't exist yet.
450     # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
451     if { [istarget mips*-*-irix*]
452     && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
453         return 0
454     }
455
456     # We don't yet support profiling for MIPS16.
457     if { [istarget mips*-*-*]
458          && ![check_effective_target_nomips16]
459          && ([lindex $test_what 1] == "-p"
460              || [lindex $test_what 1] == "-pg") } {
461         return 0
462     }
463
464     # MinGW does not support -p.
465     if { [istarget *-*-mingw*] && [lindex $test_what 1] == "-p" } {
466         return 0
467     }
468
469     # cygwin does not support -p.
470     if { [istarget *-*-cygwin*] && [lindex $test_what 1] == "-p" } {
471         return 0
472     }
473
474     # uClibc does not have gcrt1.o.
475     if { [check_effective_target_uclibc]
476          && ([lindex $test_what 1] == "-p"
477              || [lindex $test_what 1] == "-pg") } {
478         return 0
479     }
480
481     # Now examine the cache variable.
482     if {![info exists profiling_available_saved]} {
483         # Some targets don't have any implementation of __bb_init_func or are
484         # missing other needed machinery.
485         if { [istarget mmix-*-*]
486              || [istarget arm*-*-eabi*]
487              || [istarget picochip-*-*]
488              || [istarget *-*-netware*]
489              || [istarget arm*-*-elf]
490              || [istarget arm*-*-symbianelf*]
491              || [istarget avr-*-*]
492              || [istarget bfin-*-*]
493              || [istarget powerpc-*-eabi*]
494              || [istarget cris-*-*]
495              || [istarget crisv32-*-*]
496              || [istarget fido-*-elf]
497              || [istarget h8300-*-*]
498              || [istarget m32c-*-elf]
499              || [istarget m68k-*-elf]
500              || [istarget m68k-*-uclinux*]
501              || [istarget mep-*-elf]
502              || [istarget mips*-*-elf*]
503              || [istarget moxie-*-elf*]
504              || [istarget xstormy16-*]
505              || [istarget xtensa*-*-elf]
506              || [istarget *-*-rtems*]
507              || [istarget *-*-vxworks*] } {
508             set profiling_available_saved 0
509         } else {
510             set profiling_available_saved 1
511         }
512     }
513
514     return $profiling_available_saved
515 }
516
517 # Check to see if a target is "freestanding". This is as per the definition
518 # in Section 4 of C99 standard. Effectively, it is a target which supports no
519 # extra headers or libraries other than what is considered essential.
520 proc check_effective_target_freestanding { } {
521     if { [istarget picochip-*-*] } then {
522         return 1
523     } else {
524         return 0
525     }
526 }
527
528 # Return 1 if target has packed layout of structure members by
529 # default, 0 otherwise.  Note that this is slightly different than
530 # whether the target has "natural alignment": both attributes may be
531 # false.
532
533 proc check_effective_target_default_packed { } {
534     return [check_no_compiler_messages default_packed assembly {
535         struct x { char a; long b; } c;
536         int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
537     }]
538 }
539
540 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
541 # documentation, where the test also comes from.
542
543 proc check_effective_target_pcc_bitfield_type_matters { } {
544     # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
545     # bitfields, but let's stick to the example code from the docs.
546     return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
547         struct foo1 { char x; char :0; char y; };
548         struct foo2 { char x; int :0; char y; };
549         int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
550     }]
551 }
552
553 # Return 1 if thread local storage (TLS) is supported, 0 otherwise.
554
555 proc check_effective_target_tls {} {
556     return [check_no_compiler_messages tls assembly {
557         __thread int i;
558         int f (void) { return i; }
559         void g (int j) { i = j; }
560     }]
561 }
562
563 # Return 1 if *native* thread local storage (TLS) is supported, 0 otherwise.
564
565 proc check_effective_target_tls_native {} {
566     # VxWorks uses emulated TLS machinery, but with non-standard helper
567     # functions, so we fail to automatically detect it.
568     global target_triplet
569     if { [regexp ".*-.*-vxworks.*" $target_triplet] } {
570         return 0
571     }
572     
573     return [check_no_messages_and_pattern tls_native "!emutls" assembly {
574         __thread int i;
575         int f (void) { return i; }
576         void g (int j) { i = j; }
577     }]
578 }
579
580 # Return 1 if TLS executables can run correctly, 0 otherwise.
581
582 proc check_effective_target_tls_runtime {} {
583     return [check_runtime tls_runtime {
584         __thread int thr = 0;
585         int main (void) { return thr; }
586     }]
587 }
588
589 # Return 1 if compilation with -fgraphite is error-free for trivial 
590 # code, 0 otherwise.
591
592 proc check_effective_target_fgraphite {} {
593     return [check_no_compiler_messages fgraphite object {
594         void foo (void) { }
595     } "-O1 -fgraphite"]
596 }
597
598 # Return 1 if compilation with -fopenmp is error-free for trivial
599 # code, 0 otherwise.
600
601 proc check_effective_target_fopenmp {} {
602     return [check_no_compiler_messages fopenmp object {
603         void foo (void) { }
604     } "-fopenmp"]
605 }
606
607 # Return 1 if compilation with -pthread is error-free for trivial
608 # code, 0 otherwise.
609
610 proc check_effective_target_pthread {} {
611     return [check_no_compiler_messages pthread object {
612         void foo (void) { }
613     } "-pthread"]
614 }
615
616 # Return 1 if compilation with -mpe-aligned-commons is error-free
617 # for trivial code, 0 otherwise.
618
619 proc check_effective_target_pe_aligned_commons {} {
620     if { [istarget *-*-cygwin*] || [istarget *-*-mingw*] } {
621         return [check_no_compiler_messages pe_aligned_commons object {
622             int foo;
623         } "-mpe-aligned-commons"]
624     }
625     return 0
626 }
627
628 # Return 1 if the target supports -static
629 proc check_effective_target_static {} {
630     return [check_no_compiler_messages static executable {
631         int main (void) { return 0; }
632     } "-static"]
633 }
634
635 # Return 1 if the target supports -fstack-protector
636 proc check_effective_target_fstack_protector {} {
637     return [check_runtime fstack_protector {
638         int main (void) { return 0; }
639     } "-fstack-protector"]
640 }
641
642 # Return 1 if compilation with -freorder-blocks-and-partition is error-free
643 # for trivial code, 0 otherwise.
644
645 proc check_effective_target_freorder {} {
646     return [check_no_compiler_messages freorder object {
647         void foo (void) { }
648     } "-freorder-blocks-and-partition"]
649 }
650
651 # Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
652 # emitted, 0 otherwise.  Whether a shared library can actually be built is
653 # out of scope for this test.
654
655 proc check_effective_target_fpic { } {
656     # Note that M68K has a multilib that supports -fpic but not
657     # -fPIC, so we need to check both.  We test with a program that
658     # requires GOT references.
659     foreach arg {fpic fPIC} {
660         if [check_no_compiler_messages $arg object {
661             extern int foo (void); extern int bar;
662             int baz (void) { return foo () + bar; }
663         } "-$arg"] {
664             return 1
665         }
666     }
667     return 0
668 }
669
670 # Return true if the target supports -mpaired-single (as used on MIPS).
671
672 proc check_effective_target_mpaired_single { } {
673     return [check_no_compiler_messages mpaired_single object {
674         void foo (void) { }
675     } "-mpaired-single"]
676 }
677
678 # Return true if the target has access to FPU instructions.
679
680 proc check_effective_target_hard_float { } {
681     if { [istarget mips*-*-*] } {
682         return [check_no_compiler_messages hard_float assembly {
683                 #if (defined __mips_soft_float || defined __mips16)
684                 #error FOO
685                 #endif
686         }]
687     }
688
689     # The generic test equates hard_float with "no call for adding doubles".
690     return [check_no_messages_and_pattern hard_float "!\\(call" rtl-expand {
691         double a (double b, double c) { return b + c; }
692     }]
693 }
694
695 # Return true if the target is a 64-bit MIPS target.
696
697 proc check_effective_target_mips64 { } {
698     return [check_no_compiler_messages mips64 assembly {
699         #ifndef __mips64
700         #error FOO
701         #endif
702     }]
703 }
704
705 # Return true if the target is a MIPS target that does not produce
706 # MIPS16 code.
707
708 proc check_effective_target_nomips16 { } {
709     return [check_no_compiler_messages nomips16 object {
710         #ifndef __mips
711         #error FOO
712         #else
713         /* A cheap way of testing for -mflip-mips16.  */
714         void foo (void) { asm ("addiu $20,$20,1"); }
715         void bar (void) { asm ("addiu $20,$20,1"); }
716         #endif
717     }]
718 }
719
720 # Add the options needed for MIPS16 function attributes.  At the moment,
721 # we don't support MIPS16 PIC.
722
723 proc add_options_for_mips16_attribute { flags } {
724     return "$flags -mno-abicalls -fno-pic -DMIPS16=__attribute__((mips16))"
725 }
726
727 # Return true if we can force a mode that allows MIPS16 code generation.
728 # We don't support MIPS16 PIC, and only support MIPS16 -mhard-float
729 # for o32 and o64.
730
731 proc check_effective_target_mips16_attribute { } {
732     return [check_no_compiler_messages mips16_attribute assembly {
733         #ifdef PIC
734         #error FOO
735         #endif
736         #if defined __mips_hard_float \
737             && (!defined _ABIO32 || _MIPS_SIM != _ABIO32) \
738             && (!defined _ABIO64 || _MIPS_SIM != _ABIO64)
739         #error FOO
740         #endif
741     } [add_options_for_mips16_attribute ""]]
742 }
743
744 # Return 1 if the target supports long double larger than double when
745 # using the new ABI, 0 otherwise.
746
747 proc check_effective_target_mips_newabi_large_long_double { } {
748     return [check_no_compiler_messages mips_newabi_large_long_double object {
749         int dummy[sizeof(long double) > sizeof(double) ? 1 : -1];
750     } "-mabi=64"]
751 }
752
753 # Return 1 if the current multilib does not generate PIC by default.
754
755 proc check_effective_target_nonpic { } {
756     return [check_no_compiler_messages nonpic assembly {
757         #if __PIC__
758         #error FOO
759         #endif
760     }]
761 }
762
763 # Return 1 if the target does not use a status wrapper.
764
765 proc check_effective_target_unwrapped { } {
766     if { [target_info needs_status_wrapper] != "" \
767              && [target_info needs_status_wrapper] != "0" } {
768         return 0
769     }
770     return 1
771 }
772
773 # Return true if iconv is supported on the target. In particular IBM1047.
774
775 proc check_iconv_available { test_what } {
776     global libiconv
777
778     # If the tool configuration file has not set libiconv, try "-liconv"
779     if { ![info exists libiconv] } {
780         set libiconv "-liconv"
781     }
782     set test_what [lindex $test_what 1]
783     return [check_runtime_nocache $test_what [subst {
784         #include <iconv.h>
785         int main (void)
786         {
787           iconv_t cd;
788
789           cd = iconv_open ("$test_what", "UTF-8");
790           if (cd == (iconv_t) -1)
791             return 1;
792           return 0;
793         }
794     }] $libiconv]
795 }
796
797 # Return true if named sections are supported on this target.
798
799 proc check_named_sections_available { } {
800     return [check_no_compiler_messages named_sections assembly {
801         int __attribute__ ((section("whatever"))) foo;
802     }]
803 }
804
805 # Return 1 if the target supports Fortran real kinds larger than real(8),
806 # 0 otherwise.
807 #
808 # When the target name changes, replace the cached result.
809
810 proc check_effective_target_fortran_large_real { } {
811     return [check_no_compiler_messages fortran_large_real executable {
812         ! Fortran
813         integer,parameter :: k = selected_real_kind (precision (0.0_8) + 1)
814         real(kind=k) :: x
815         x = cos (x)
816         end
817     }]
818 }
819
820 # Return 1 if the target supports Fortran integer kinds larger than
821 # integer(8), 0 otherwise.
822 #
823 # When the target name changes, replace the cached result.
824
825 proc check_effective_target_fortran_large_int { } {
826     return [check_no_compiler_messages fortran_large_int executable {
827         ! Fortran
828         integer,parameter :: k = selected_int_kind (range (0_8) + 1)
829         integer(kind=k) :: i
830         end
831     }]
832 }
833
834 # Return 1 if the target supports Fortran integer(16), 0 otherwise.
835 #
836 # When the target name changes, replace the cached result.
837
838 proc check_effective_target_fortran_integer_16 { } {
839     return [check_no_compiler_messages fortran_integer_16 executable {
840         ! Fortran
841         integer(16) :: i
842         end
843     }]
844 }
845
846 # Return 1 if we can statically link libgfortran, 0 otherwise.
847 #
848 # When the target name changes, replace the cached result.
849
850 proc check_effective_target_static_libgfortran { } {
851     return [check_no_compiler_messages static_libgfortran executable {
852         ! Fortran
853         print *, 'test'
854         end
855     } "-static"]
856 }
857
858 # Return 1 if the target supports executing 750CL paired-single instructions, 0
859 # otherwise.  Cache the result.
860
861 proc check_750cl_hw_available { } {
862     return [check_cached_effective_target 750cl_hw_available {
863         # If this is not the right target then we can skip the test.
864         if { ![istarget powerpc-*paired*] } {
865             expr 0
866         } else {
867             check_runtime_nocache 750cl_hw_available {
868                  int main()
869                  {
870                  #ifdef __MACH__
871                    asm volatile ("ps_mul v0,v0,v0");
872                  #else
873                    asm volatile ("ps_mul 0,0,0");
874                  #endif
875                    return 0;
876                  }
877             } "-mpaired"
878         }
879     }]
880 }
881
882 # Return 1 if the target supports executing SSE2 instructions, 0
883 # otherwise.  Cache the result.
884
885 proc check_sse2_hw_available { } {
886     return [check_cached_effective_target sse2_hw_available {
887         # If this is not the right target then we can skip the test.
888         if { !([istarget x86_64-*-*] || [istarget i?86-*-*]) } {
889             expr 0
890         } else {
891             check_runtime_nocache sse2_hw_available {
892                 #include "cpuid.h"
893                 int main ()
894                 {
895                   unsigned int eax, ebx, ecx, edx = 0;
896                   if (__get_cpuid (1, &eax, &ebx, &ecx, &edx))
897                     return !(edx & bit_SSE2);
898                   return 1;
899                 }
900             } ""
901         }
902     }]
903 }
904
905 # Return 1 if the target supports executing VSX instructions, 0
906 # otherwise.  Cache the result.
907
908 proc check_vsx_hw_available { } {
909     return [check_cached_effective_target vsx_hw_available {
910         # Some simulators are known to not support VSX instructions.
911         # For now, disable on Darwin
912         if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] || [istarget *-*-darwin*]} {
913             expr 0
914         } else {
915             set options "-mvsx"
916             check_runtime_nocache vsx_hw_available {
917                 int main()
918                 {
919                 #ifdef __MACH__
920                   asm volatile ("xxlor vs0,vs0,vs0");
921                 #else
922                   asm volatile ("xxlor 0,0,0");
923                 #endif
924                   return 0;
925                 }
926             } $options
927         }
928     }]
929 }
930
931 # Return 1 if the target supports executing AltiVec instructions, 0
932 # otherwise.  Cache the result.
933
934 proc check_vmx_hw_available { } {
935     return [check_cached_effective_target vmx_hw_available {
936         # Some simulators are known to not support VMX instructions.
937         if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
938             expr 0
939         } else {
940             # Most targets don't require special flags for this test case, but
941             # Darwin does.  Just to be sure, make sure VSX is not enabled for
942             # the altivec tests.
943             if { [istarget *-*-darwin*]
944                  || [istarget *-*-aix*] } {
945                 set options "-maltivec -mno-vsx"
946             } else {
947                 set options "-mno-vsx"
948             }
949             check_runtime_nocache vmx_hw_available {
950                 int main()
951                 {
952                 #ifdef __MACH__
953                   asm volatile ("vor v0,v0,v0");
954                 #else
955                   asm volatile ("vor 0,0,0");
956                 #endif
957                   return 0;
958                 }
959             } $options
960         }
961     }]
962 }
963
964 # Return 1 if the target supports executing AltiVec and Cell PPU
965 # instructions, 0 otherwise.  Cache the result.
966
967 proc check_effective_target_cell_hw { } {
968     return [check_cached_effective_target cell_hw_available {
969         # Some simulators are known to not support VMX and PPU instructions.
970         if { [istarget powerpc-*-eabi*] } {
971             expr 0
972         } else {
973             # Most targets don't require special flags for this test
974             # case, but Darwin and AIX do.
975             if { [istarget *-*-darwin*]
976                  || [istarget *-*-aix*] } {
977                 set options "-maltivec -mcpu=cell"
978             } else {
979                 set options "-mcpu=cell"
980             }
981             check_runtime_nocache cell_hw_available {
982                 int main()
983                 {
984                 #ifdef __MACH__
985                   asm volatile ("vor v0,v0,v0");
986                   asm volatile ("lvlx v0,r0,r0");
987                 #else
988                   asm volatile ("vor 0,0,0");
989                   asm volatile ("lvlx 0,0,0");
990                 #endif
991                   return 0;
992                 }
993             } $options
994         }
995     }]
996 }
997
998 # Return 1 if the target supports executing 64-bit instructions, 0
999 # otherwise.  Cache the result.
1000
1001 proc check_effective_target_powerpc64 { } {
1002     global powerpc64_available_saved
1003     global tool
1004
1005     if [info exists powerpc64_available_saved] {
1006         verbose "check_effective_target_powerpc64 returning saved $powerpc64_available_saved" 2
1007     } else {
1008         set powerpc64_available_saved 0
1009
1010         # Some simulators are known to not support powerpc64 instructions.
1011         if { [istarget powerpc-*-eabi*] || [istarget powerpc-ibm-aix*] } {
1012             verbose "check_effective_target_powerpc64 returning 0" 2
1013             return $powerpc64_available_saved
1014         }
1015
1016         # Set up, compile, and execute a test program containing a 64-bit
1017         # instruction.  Include the current process ID in the file
1018         # names to prevent conflicts with invocations for multiple
1019         # testsuites.
1020         set src ppc[pid].c
1021         set exe ppc[pid].x
1022
1023         set f [open $src "w"]
1024         puts $f "int main() {"
1025         puts $f "#ifdef __MACH__"
1026         puts $f "  asm volatile (\"extsw r0,r0\");"
1027         puts $f "#else"
1028         puts $f "  asm volatile (\"extsw 0,0\");"
1029         puts $f "#endif"
1030         puts $f "  return 0; }"
1031         close $f
1032
1033         set opts "additional_flags=-mcpu=G5"
1034
1035         verbose "check_effective_target_powerpc64 compiling testfile $src" 2
1036         set lines [${tool}_target_compile $src $exe executable "$opts"]
1037         file delete $src
1038
1039         if [string match "" $lines] then {
1040             # No error message, compilation succeeded.
1041             set result [${tool}_load "./$exe" "" ""]
1042             set status [lindex $result 0]
1043             remote_file build delete $exe
1044             verbose "check_effective_target_powerpc64 testfile status is <$status>" 2
1045
1046             if { $status == "pass" } then {
1047                 set powerpc64_available_saved 1
1048             }
1049         } else {
1050             verbose "check_effective_target_powerpc64 testfile compilation failed" 2
1051         }
1052     }
1053
1054     return $powerpc64_available_saved
1055 }
1056
1057 # GCC 3.4.0 for powerpc64-*-linux* included an ABI fix for passing
1058 # complex float arguments.  This affects gfortran tests that call cabsf
1059 # in libm built by an earlier compiler.  Return 1 if libm uses the same
1060 # argument passing as the compiler under test, 0 otherwise.
1061 #
1062 # When the target name changes, replace the cached result.
1063
1064 proc check_effective_target_broken_cplxf_arg { } {
1065     return [check_cached_effective_target broken_cplxf_arg {
1066         # Skip the work for targets known not to be affected.
1067         if { ![istarget powerpc64-*-linux*] } {
1068             expr 0
1069         } elseif { ![is-effective-target lp64] } {
1070             expr 0
1071         } else {
1072             check_runtime_nocache broken_cplxf_arg {
1073                 #include <complex.h>
1074                 extern void abort (void);
1075                 float fabsf (float);
1076                 float cabsf (_Complex float);
1077                 int main ()
1078                 {
1079                   _Complex float cf;
1080                   float f;
1081                   cf = 3 + 4.0fi;
1082                   f = cabsf (cf);
1083                   if (fabsf (f - 5.0) > 0.0001)
1084                     abort ();
1085                   return 0;
1086                 }
1087             } "-lm"
1088         }
1089     }]
1090 }
1091
1092 proc check_alpha_max_hw_available { } {
1093     return [check_runtime alpha_max_hw_available {
1094         int main() { return __builtin_alpha_amask(1<<8) != 0; }
1095     }]
1096 }
1097
1098 # Returns true iff the FUNCTION is available on the target system.
1099 # (This is essentially a Tcl implementation of Autoconf's
1100 # AC_CHECK_FUNC.)
1101
1102 proc check_function_available { function } {
1103     return [check_no_compiler_messages ${function}_available \
1104                 executable [subst {
1105         #ifdef __cplusplus
1106         extern "C"
1107         #endif
1108         char $function ();
1109         int main () { $function (); }
1110     }]]
1111 }
1112
1113 # Returns true iff "fork" is available on the target system.
1114
1115 proc check_fork_available {} {
1116     return [check_function_available "fork"]
1117 }
1118
1119 # Returns true iff "mkfifo" is available on the target system.
1120
1121 proc check_mkfifo_available {} {
1122     if {[istarget *-*-cygwin*]} {
1123        # Cygwin has mkfifo, but support is incomplete.
1124        return 0
1125      }
1126
1127     return [check_function_available "mkfifo"]
1128 }
1129
1130 # Returns true iff "__cxa_atexit" is used on the target system.
1131
1132 proc check_cxa_atexit_available { } {
1133     return [check_cached_effective_target cxa_atexit_available {
1134         if { [istarget "hppa*-*-hpux10*"] } {
1135             # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
1136             expr 0
1137         } elseif { [istarget "*-*-vxworks"] } {
1138             # vxworks doesn't have __cxa_atexit but subsequent test passes.
1139             expr 0
1140         } else {
1141             check_runtime_nocache cxa_atexit_available {
1142                 // C++
1143                 #include <stdlib.h>
1144                 static unsigned int count;
1145                 struct X
1146                 {
1147                   X() { count = 1; }
1148                   ~X()
1149                   {
1150                     if (count != 3)
1151                       exit(1);
1152                     count = 4;
1153                   }
1154                 };
1155                 void f()
1156                 {
1157                   static X x;
1158                 }
1159                 struct Y
1160                 {
1161                   Y() { f(); count = 2; }
1162                   ~Y()
1163                   {
1164                     if (count != 2)
1165                       exit(1);
1166                     count = 3;
1167                   }
1168                 };
1169                 Y y;
1170                 int main() { return 0; }
1171             }
1172         }
1173     }]
1174 }
1175
1176
1177 # Return 1 if we're generating 32-bit code using default options, 0
1178 # otherwise.
1179
1180 proc check_effective_target_ilp32 { } {
1181     return [check_no_compiler_messages ilp32 object {
1182         int dummy[sizeof (int) == 4
1183                   && sizeof (void *) == 4
1184                   && sizeof (long) == 4 ? 1 : -1];
1185     }]
1186 }
1187
1188 # Return 1 if we're generating 32-bit or larger integers using default
1189 # options, 0 otherwise.
1190
1191 proc check_effective_target_int32plus { } {
1192     return [check_no_compiler_messages int32plus object {
1193         int dummy[sizeof (int) >= 4 ? 1 : -1];
1194     }]
1195 }
1196
1197 # Return 1 if we're generating 32-bit or larger pointers using default
1198 # options, 0 otherwise.
1199
1200 proc check_effective_target_ptr32plus { } {
1201     return [check_no_compiler_messages ptr32plus object {
1202         int dummy[sizeof (void *) >= 4 ? 1 : -1];
1203     }]
1204 }
1205
1206 # Return 1 if we support 32-bit or larger array and structure sizes
1207 # using default options, 0 otherwise.
1208
1209 proc check_effective_target_size32plus { } {
1210     return [check_no_compiler_messages size32plus object {
1211         char dummy[65537];
1212     }]
1213 }
1214
1215 # Returns 1 if we're generating 16-bit or smaller integers with the
1216 # default options, 0 otherwise.
1217
1218 proc check_effective_target_int16 { } {
1219     return [check_no_compiler_messages int16 object {
1220         int dummy[sizeof (int) < 4 ? 1 : -1];
1221     }]
1222 }
1223
1224 # Return 1 if we're generating 64-bit code using default options, 0
1225 # otherwise.
1226
1227 proc check_effective_target_lp64 { } {
1228     return [check_no_compiler_messages lp64 object {
1229         int dummy[sizeof (int) == 4
1230                   && sizeof (void *) == 8
1231                   && sizeof (long) == 8 ? 1 : -1];
1232     }]
1233 }
1234
1235 # Return 1 if we're generating 64-bit code using default llp64 options,
1236 # 0 otherwise.
1237
1238 proc check_effective_target_llp64 { } {
1239     return [check_no_compiler_messages llp64 object {
1240         int dummy[sizeof (int) == 4
1241                   && sizeof (void *) == 8
1242                   && sizeof (long long) == 8
1243                   && sizeof (long) == 4 ? 1 : -1];
1244     }]
1245 }
1246
1247 # Return 1 if the target supports long double larger than double,
1248 # 0 otherwise.
1249
1250 proc check_effective_target_large_long_double { } {
1251     return [check_no_compiler_messages large_long_double object {
1252         int dummy[sizeof(long double) > sizeof(double) ? 1 : -1];
1253     }]
1254 }
1255
1256 # Return 1 if the target supports double larger than float,
1257 # 0 otherwise.
1258
1259 proc check_effective_target_large_double { } {
1260     return [check_no_compiler_messages large_double object {
1261         int dummy[sizeof(double) > sizeof(float) ? 1 : -1];
1262     }]
1263 }
1264
1265 # Return 1 if the target supports double of 64 bits,
1266 # 0 otherwise.
1267
1268 proc check_effective_target_double64 { } {
1269     return [check_no_compiler_messages double64 object {
1270         int dummy[sizeof(double) == 8 ? 1 : -1];
1271     }]
1272 }
1273
1274 # Return 1 if the target supports double of at least 64 bits,
1275 # 0 otherwise.
1276
1277 proc check_effective_target_double64plus { } {
1278     return [check_no_compiler_messages double64plus object {
1279         int dummy[sizeof(double) >= 8 ? 1 : -1];
1280     }]
1281 }
1282
1283 # Return 1 if the target supports compiling fixed-point,
1284 # 0 otherwise.
1285
1286 proc check_effective_target_fixed_point { } {
1287     return [check_no_compiler_messages fixed_point object {
1288         _Sat _Fract x; _Sat _Accum y;
1289     }]
1290 }
1291
1292 # Return 1 if the target supports compiling decimal floating point,
1293 # 0 otherwise.
1294
1295 proc check_effective_target_dfp_nocache { } {
1296     verbose "check_effective_target_dfp_nocache: compiling source" 2
1297     set ret [check_no_compiler_messages_nocache dfp object {
1298         float x __attribute__((mode(DD)));
1299     }]
1300     verbose "check_effective_target_dfp_nocache: returning $ret" 2
1301     return $ret
1302 }
1303
1304 proc check_effective_target_dfprt_nocache { } {
1305     return [check_runtime_nocache dfprt {
1306         typedef float d64 __attribute__((mode(DD)));
1307         d64 x = 1.2df, y = 2.3dd, z;
1308         int main () { z = x + y; return 0; }
1309     }]
1310 }
1311
1312 # Return 1 if the target supports compiling Decimal Floating Point,
1313 # 0 otherwise.
1314 #
1315 # This won't change for different subtargets so cache the result.
1316
1317 proc check_effective_target_dfp { } {
1318     return [check_cached_effective_target dfp {
1319         check_effective_target_dfp_nocache
1320     }]
1321 }
1322
1323 # Return 1 if the target supports linking and executing Decimal Floating
1324 # Point, # 0 otherwise.
1325 #
1326 # This won't change for different subtargets so cache the result.
1327
1328 proc check_effective_target_dfprt { } {
1329     return [check_cached_effective_target dfprt {
1330         check_effective_target_dfprt_nocache
1331     }]
1332 }
1333
1334 # Return 1 if the target needs a command line argument to enable a SIMD
1335 # instruction set.
1336
1337 proc check_effective_target_vect_cmdline_needed { } {
1338     global et_vect_cmdline_needed_saved
1339     global et_vect_cmdline_needed_target_name
1340
1341     if { ![info exists et_vect_cmdline_needed_target_name] } {
1342         set et_vect_cmdline_needed_target_name ""
1343     }
1344
1345     # If the target has changed since we set the cached value, clear it.
1346     set current_target [current_target_name]
1347     if { $current_target != $et_vect_cmdline_needed_target_name } {
1348         verbose "check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target'" 2
1349         set et_vect_cmdline_needed_target_name $current_target
1350         if { [info exists et_vect_cmdline_needed_saved] } {
1351             verbose "check_effective_target_vect_cmdline_needed: removing cached result" 2
1352             unset et_vect_cmdline_needed_saved
1353         }
1354     }
1355
1356     if [info exists et_vect_cmdline_needed_saved] {
1357         verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1358     } else {
1359         set et_vect_cmdline_needed_saved 1
1360         if { [istarget alpha*-*-*]
1361              || [istarget ia64-*-*]
1362              || (([istarget x86_64-*-*] || [istarget i?86-*-*])
1363                  && [check_effective_target_lp64])
1364              || ([istarget powerpc*-*-*]
1365                  && ([check_effective_target_powerpc_spe]
1366                      || [check_effective_target_powerpc_altivec]))
1367              || [istarget spu-*-*]
1368              || ([istarget arm*-*-*] && [check_effective_target_arm_neon]) } {
1369            set et_vect_cmdline_needed_saved 0
1370         }
1371     }
1372
1373     verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1374     return $et_vect_cmdline_needed_saved
1375 }
1376
1377 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
1378 #
1379 # This won't change for different subtargets so cache the result.
1380
1381 proc check_effective_target_vect_int { } {
1382     global et_vect_int_saved
1383
1384     if [info exists et_vect_int_saved] {
1385         verbose "check_effective_target_vect_int: using cached result" 2
1386     } else {
1387         set et_vect_int_saved 0
1388         if { [istarget i?86-*-*]
1389              || ([istarget powerpc*-*-*]
1390                   && ![istarget powerpc-*-linux*paired*])
1391               || [istarget spu-*-*]
1392               || [istarget x86_64-*-*]
1393               || [istarget sparc*-*-*]
1394               || [istarget alpha*-*-*]
1395               || [istarget ia64-*-*] 
1396               || [check_effective_target_arm32] } {
1397            set et_vect_int_saved 1
1398         }
1399     }
1400
1401     verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1402     return $et_vect_int_saved
1403 }
1404
1405 # Return 1 if the target supports signed int->float conversion 
1406 #
1407
1408 proc check_effective_target_vect_intfloat_cvt { } {
1409     global et_vect_intfloat_cvt_saved
1410
1411     if [info exists et_vect_intfloat_cvt_saved] {
1412         verbose "check_effective_target_vect_intfloat_cvt: using cached result" 2
1413     } else {
1414         set et_vect_intfloat_cvt_saved 0
1415         if { [istarget i?86-*-*]
1416               || ([istarget powerpc*-*-*]
1417                    && ![istarget powerpc-*-linux*paired*])
1418               || [istarget x86_64-*-*] } {
1419            set et_vect_intfloat_cvt_saved 1
1420         }
1421     }
1422
1423     verbose "check_effective_target_vect_intfloat_cvt: returning $et_vect_intfloat_cvt_saved" 2
1424     return $et_vect_intfloat_cvt_saved
1425 }
1426
1427
1428 # Return 1 if the target supports unsigned int->float conversion 
1429 #
1430
1431 proc check_effective_target_vect_uintfloat_cvt { } {
1432     global et_vect_uintfloat_cvt_saved
1433
1434     if [info exists et_vect_uintfloat_cvt_saved] {
1435         verbose "check_effective_target_vect_uintfloat_cvt: using cached result" 2
1436     } else {
1437         set et_vect_uintfloat_cvt_saved 0
1438         if { [istarget i?86-*-*]
1439               || ([istarget powerpc*-*-*]
1440                   && ![istarget powerpc-*-linux*paired*])
1441               || [istarget x86_64-*-*] } {
1442            set et_vect_uintfloat_cvt_saved 1
1443         }
1444     }
1445
1446     verbose "check_effective_target_vect_uintfloat_cvt: returning $et_vect_uintfloat_cvt_saved" 2
1447     return $et_vect_uintfloat_cvt_saved
1448 }
1449
1450
1451 # Return 1 if the target supports signed float->int conversion
1452 #
1453
1454 proc check_effective_target_vect_floatint_cvt { } {
1455     global et_vect_floatint_cvt_saved
1456
1457     if [info exists et_vect_floatint_cvt_saved] {
1458         verbose "check_effective_target_vect_floatint_cvt: using cached result" 2
1459     } else {
1460         set et_vect_floatint_cvt_saved 0
1461         if { [istarget i?86-*-*]
1462               || ([istarget powerpc*-*-*]
1463                    && ![istarget powerpc-*-linux*paired*])
1464               || [istarget x86_64-*-*] } {
1465            set et_vect_floatint_cvt_saved 1
1466         }
1467     }
1468
1469     verbose "check_effective_target_vect_floatint_cvt: returning $et_vect_floatint_cvt_saved" 2
1470     return $et_vect_floatint_cvt_saved
1471 }
1472
1473 # Return 1 if the target supports unsigned float->int conversion
1474 #
1475
1476 proc check_effective_target_vect_floatuint_cvt { } {
1477     global et_vect_floatuint_cvt_saved
1478
1479     if [info exists et_vect_floatuint_cvt_saved] {
1480         verbose "check_effective_target_vect_floatuint_cvt: using cached result" 2
1481     } else {
1482         set et_vect_floatuint_cvt_saved 0
1483         if { ([istarget powerpc*-*-*]
1484               && ![istarget powerpc-*-linux*paired*]) } {
1485            set et_vect_floatuint_cvt_saved 1
1486         }
1487     }
1488
1489     verbose "check_effective_target_vect_floatuint_cvt: returning $et_vect_floatuint_cvt_saved" 2
1490     return $et_vect_floatuint_cvt_saved
1491 }
1492
1493 # Return 1 is this is an arm target using 32-bit instructions
1494 proc check_effective_target_arm32 { } {
1495     return [check_no_compiler_messages arm32 assembly {
1496         #if !defined(__arm__) || (defined(__thumb__) && !defined(__thumb2__))
1497         #error FOO
1498         #endif
1499     }]
1500 }
1501
1502 # Return 1 if this is an ARM target supporting -mfpu=vfp
1503 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1504 # options.
1505
1506 proc check_effective_target_arm_vfp_ok { } {
1507     if { [check_effective_target_arm32] } {
1508         return [check_no_compiler_messages arm_vfp_ok object {
1509             int dummy;
1510         } "-mfpu=vfp -mfloat-abi=softfp"]
1511     } else {
1512         return 0
1513     }
1514 }
1515
1516 # Return 1 if this is an ARM target supporting -mfpu=vfp
1517 # -mfloat-abi=hard.  Some multilibs may be incompatible with these
1518 # options.
1519
1520 proc check_effective_target_arm_hard_vfp_ok { } {
1521     if { [check_effective_target_arm32] } {
1522         return [check_no_compiler_messages arm_hard_vfp_ok executable {
1523             int main() { return 0;}
1524         } "-mfpu=vfp -mfloat-abi=hard"]
1525     } else {
1526         return 0
1527     }
1528 }
1529
1530 # Return 1 if this is an ARM target supporting -mfpu=neon
1531 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1532 # options.
1533
1534 proc check_effective_target_arm_neon_ok { } {
1535     if { [check_effective_target_arm32] } {
1536         return [check_no_compiler_messages arm_neon_ok object {
1537             #include "arm_neon.h"
1538             int dummy;
1539         } "-mfpu=neon -mfloat-abi=softfp"]
1540     } else {
1541         return 0
1542     }
1543 }
1544
1545 # Return 1 is this is an ARM target where -mthumb causes Thumb-1 to be
1546 # used.
1547
1548 proc check_effective_target_arm_thumb1_ok { } {
1549     return [check_no_compiler_messages arm_thumb1_ok assembly {
1550         #if !defined(__arm__) || !defined(__thumb__) || defined(__thumb2__)
1551         #error FOO
1552         #endif
1553     } "-mthumb"]
1554 }
1555
1556 # Return 1 is this is an ARM target where -mthumb causes Thumb-2 to be
1557 # used.
1558
1559 proc check_effective_target_arm_thumb2_ok { } {
1560     return [check_no_compiler_messages arm_thumb2_ok assembly {
1561         #if !defined(__thumb2__)
1562         #error FOO
1563         #endif
1564     } "-mthumb"]
1565 }
1566
1567 # Return 1 if the target supports executing NEON instructions, 0
1568 # otherwise.  Cache the result.
1569
1570 proc check_effective_target_arm_neon_hw { } {
1571     return [check_runtime arm_neon_hw_available {
1572         int
1573         main (void)
1574         {
1575           long long a = 0, b = 1;
1576           asm ("vorr %P0, %P1, %P2"
1577                : "=w" (a)
1578                : "0" (a), "w" (b));
1579           return (a != 1);
1580         }
1581     } "-mfpu=neon -mfloat-abi=softfp"]
1582 }
1583
1584 # Return 1 if this is a ARM target with NEON enabled.
1585
1586 proc check_effective_target_arm_neon { } {
1587     if { [check_effective_target_arm32] } {
1588         return [check_no_compiler_messages arm_neon object {
1589             #ifndef __ARM_NEON__
1590             #error not NEON
1591             #else
1592             int dummy;
1593             #endif
1594         }]
1595     } else {
1596         return 0
1597     }
1598 }
1599
1600 # Return 1 if this a Loongson-2E or -2F target using an ABI that supports
1601 # the Loongson vector modes.
1602
1603 proc check_effective_target_mips_loongson { } {
1604     return [check_no_compiler_messages loongson assembly {
1605         #if !defined(__mips_loongson_vector_rev)
1606         #error FOO
1607         #endif
1608     }]
1609 }
1610
1611 # Return 1 if this is an ARM target that adheres to the ABI for the ARM
1612 # Architecture.
1613
1614 proc check_effective_target_arm_eabi { } {
1615     return [check_no_compiler_messages arm_eabi object {
1616         #ifndef __ARM_EABI__
1617         #error not EABI
1618         #else
1619         int dummy;
1620         #endif
1621     }]
1622 }
1623
1624 # Return 1 if this is an ARM target supporting -mcpu=iwmmxt.
1625 # Some multilibs may be incompatible with this option.
1626
1627 proc check_effective_target_arm_iwmmxt_ok { } {
1628     if { [check_effective_target_arm32] } {
1629         return [check_no_compiler_messages arm_iwmmxt_ok object {
1630             int dummy;
1631         } "-mcpu=iwmmxt"]
1632     } else {
1633         return 0
1634     }
1635 }
1636
1637 # Return 1 if this is a PowerPC target with floating-point registers.
1638
1639 proc check_effective_target_powerpc_fprs { } {
1640     if { [istarget powerpc*-*-*]
1641          || [istarget rs6000-*-*] } {
1642         return [check_no_compiler_messages powerpc_fprs object {
1643             #ifdef __NO_FPRS__
1644             #error no FPRs
1645             #else
1646             int dummy;
1647             #endif
1648         }]
1649     } else {
1650         return 0
1651     }
1652 }
1653
1654 # Return 1 if this is a PowerPC target with hardware double-precision
1655 # floating point.
1656
1657 proc check_effective_target_powerpc_hard_double { } {
1658     if { [istarget powerpc*-*-*]
1659          || [istarget rs6000-*-*] } {
1660         return [check_no_compiler_messages powerpc_hard_double object {
1661             #ifdef _SOFT_DOUBLE
1662             #error soft double
1663             #else
1664             int dummy;
1665             #endif
1666         }]
1667     } else {
1668         return 0
1669     }
1670 }
1671
1672 # Return 1 if this is a PowerPC target supporting -maltivec.
1673
1674 proc check_effective_target_powerpc_altivec_ok { } {
1675     if { ([istarget powerpc*-*-*]
1676          && ![istarget powerpc-*-linux*paired*])
1677          || [istarget rs6000-*-*] } {
1678         # AltiVec is not supported on AIX before 5.3.
1679         if { [istarget powerpc*-*-aix4*]
1680              || [istarget powerpc*-*-aix5.1*] 
1681              || [istarget powerpc*-*-aix5.2*] } {
1682             return 0
1683         }
1684         return [check_no_compiler_messages powerpc_altivec_ok object {
1685             int dummy;
1686         } "-maltivec"]
1687     } else {
1688         return 0
1689     }
1690 }
1691
1692 # Return 1 if this is a PowerPC target supporting -mvsx
1693
1694 proc check_effective_target_powerpc_vsx_ok { } {
1695     if { ([istarget powerpc*-*-*]
1696          && ![istarget powerpc-*-linux*paired*])
1697          || [istarget rs6000-*-*] } {
1698         # AltiVec is not supported on AIX before 5.3.
1699         if { [istarget powerpc*-*-aix4*]
1700              || [istarget powerpc*-*-aix5.1*] 
1701              || [istarget powerpc*-*-aix5.2*] } {
1702             return 0
1703         }
1704         return [check_no_compiler_messages powerpc_vsx_ok object {
1705             int main (void) {
1706 #ifdef __MACH__
1707                 asm volatile ("xxlor vs0,vs0,vs0");
1708 #else
1709                 asm volatile ("xxlor 0,0,0");
1710 #endif
1711                 return 0;
1712             }
1713         } "-mvsx"]
1714     } else {
1715         return 0
1716     }
1717 }
1718
1719 # Return 1 if this is a PowerPC target supporting -mcpu=cell.
1720
1721 proc check_effective_target_powerpc_ppu_ok { } {
1722     if [check_effective_target_powerpc_altivec_ok] {
1723         return [check_no_compiler_messages cell_asm_available object {
1724             int main (void) {
1725 #ifdef __MACH__
1726                 asm volatile ("lvlx v0,v0,v0");
1727 #else
1728                 asm volatile ("lvlx 0,0,0");
1729 #endif
1730                 return 0;
1731             }
1732         }]
1733     } else {
1734         return 0
1735     }
1736 }
1737
1738 # Return 1 if this is a PowerPC target that supports SPU.
1739
1740 proc check_effective_target_powerpc_spu { } {
1741     if [istarget powerpc*-*-linux*] {
1742         return [check_effective_target_powerpc_altivec_ok]
1743     } else {
1744         return 0
1745     }
1746 }
1747
1748 # Return 1 if this is a PowerPC SPE target.  The check includes options
1749 # specified by dg-options for this test, so don't cache the result.
1750
1751 proc check_effective_target_powerpc_spe_nocache { } {
1752     if { [istarget powerpc*-*-*] } {
1753         return [check_no_compiler_messages_nocache powerpc_spe object {
1754             #ifndef __SPE__
1755             #error not SPE
1756             #else
1757             int dummy;
1758             #endif
1759         } [current_compiler_flags]]
1760     } else {
1761         return 0
1762     }
1763 }
1764
1765 # Return 1 if this is a PowerPC target with SPE enabled.
1766
1767 proc check_effective_target_powerpc_spe { } {
1768     if { [istarget powerpc*-*-*] } {
1769         return [check_no_compiler_messages powerpc_spe object {
1770             #ifndef __SPE__
1771             #error not SPE
1772             #else
1773             int dummy;
1774             #endif
1775         }]
1776     } else {
1777         return 0
1778     }
1779 }
1780
1781 # Return 1 if this is a PowerPC target with Altivec enabled.
1782
1783 proc check_effective_target_powerpc_altivec { } {
1784     if { [istarget powerpc*-*-*] } {
1785         return [check_no_compiler_messages powerpc_altivec object {
1786             #ifndef __ALTIVEC__
1787             #error not Altivec
1788             #else
1789             int dummy;
1790             #endif
1791         }]
1792     } else {
1793         return 0
1794     }
1795 }
1796
1797 # Return 1 if this is a PowerPC 405 target.  The check includes options
1798 # specified by dg-options for this test, so don't cache the result.
1799
1800 proc check_effective_target_powerpc_405_nocache { } {
1801     if { [istarget powerpc*-*-*] || [istarget rs6000-*-*] } {
1802         return [check_no_compiler_messages_nocache powerpc_405 object {
1803             #ifdef __PPC405__
1804             int dummy;
1805             #else
1806             #error not a PPC405
1807             #endif
1808         } [current_compiler_flags]]
1809     } else {
1810         return 0
1811     }
1812 }
1813
1814 # Return 1 if this is a SPU target with a toolchain that
1815 # supports automatic overlay generation.
1816
1817 proc check_effective_target_spu_auto_overlay { } {
1818     if { [istarget spu*-*-elf*] } {
1819         return [check_no_compiler_messages spu_auto_overlay executable {
1820                 int main (void) { }
1821                 } "-Wl,--auto-overlay" ]
1822     } else {
1823         return 0
1824     }
1825 }
1826
1827 # The VxWorks SPARC simulator accepts only EM_SPARC executables and
1828 # chokes on EM_SPARC32PLUS or EM_SPARCV9 executables.  Return 1 if the
1829 # test environment appears to run executables on such a simulator.
1830
1831 proc check_effective_target_ultrasparc_hw { } {
1832     return [check_runtime ultrasparc_hw {
1833         int main() { return 0; }
1834     } "-mcpu=ultrasparc"]
1835 }
1836
1837 # Return 1 if the target supports hardware vector shift operation.
1838
1839 proc check_effective_target_vect_shift { } {
1840     global et_vect_shift_saved
1841
1842     if [info exists et_vect_shift_saved] {
1843         verbose "check_effective_target_vect_shift: using cached result" 2
1844     } else {
1845         set et_vect_shift_saved 0
1846         if { ([istarget powerpc*-*-*]
1847              && ![istarget powerpc-*-linux*paired*])
1848              || [istarget ia64-*-*]
1849              || [istarget i?86-*-*]
1850              || [istarget x86_64-*-*]
1851              || [check_effective_target_arm32] } {
1852            set et_vect_shift_saved 1
1853         }
1854     }
1855
1856     verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1857     return $et_vect_shift_saved
1858 }
1859
1860 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1861 #
1862 # This can change for different subtargets so do not cache the result.
1863
1864 proc check_effective_target_vect_long { } {
1865     if { [istarget i?86-*-*]
1866          || (([istarget powerpc*-*-*] 
1867               && ![istarget powerpc-*-linux*paired*]) 
1868               && [check_effective_target_ilp32])
1869          || [istarget x86_64-*-*]
1870          || [check_effective_target_arm32]
1871          || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1872         set answer 1
1873     } else {
1874         set answer 0
1875     }
1876
1877     verbose "check_effective_target_vect_long: returning $answer" 2
1878     return $answer
1879 }
1880
1881 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1882 #
1883 # This won't change for different subtargets so cache the result.
1884
1885 proc check_effective_target_vect_float { } {
1886     global et_vect_float_saved
1887
1888     if [info exists et_vect_float_saved] {
1889         verbose "check_effective_target_vect_float: using cached result" 2
1890     } else {
1891         set et_vect_float_saved 0
1892         if { [istarget i?86-*-*]
1893               || [istarget powerpc*-*-*]
1894               || [istarget spu-*-*]
1895               || [istarget mipsisa64*-*-*]
1896               || [istarget x86_64-*-*]
1897               || [istarget ia64-*-*]
1898               || [check_effective_target_arm32] } {
1899            set et_vect_float_saved 1
1900         }
1901     }
1902
1903     verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1904     return $et_vect_float_saved
1905 }
1906
1907 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1908 #
1909 # This won't change for different subtargets so cache the result.
1910
1911 proc check_effective_target_vect_double { } {
1912     global et_vect_double_saved
1913
1914     if [info exists et_vect_double_saved] {
1915         verbose "check_effective_target_vect_double: using cached result" 2
1916     } else {
1917         set et_vect_double_saved 0
1918         if { [istarget i?86-*-*]
1919               || [istarget x86_64-*-*] 
1920               || [istarget spu-*-*] } {
1921            set et_vect_double_saved 1
1922         }
1923     }
1924
1925     verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1926     return $et_vect_double_saved
1927 }
1928
1929 # Return 1 if the target supports hardware vectors of long long, 0 otherwise.
1930 #
1931 # This won't change for different subtargets so cache the result.
1932
1933 proc check_effective_target_vect_long_long { } {
1934     global et_vect_long_long_saved
1935
1936     if [info exists et_vect_long_long_saved] {
1937         verbose "check_effective_target_vect_long_long: using cached result" 2
1938     } else {
1939         set et_vect_long_long_saved 0
1940         if { [istarget i?86-*-*]
1941               || [istarget x86_64-*-*] } {
1942            set et_vect_long_long_saved 1
1943         }
1944     }
1945
1946     verbose "check_effective_target_vect_long_long: returning $et_vect_long_long_saved" 2
1947     return $et_vect_long_long_saved
1948 }
1949
1950
1951 # Return 1 if the target plus current options does not support a vector
1952 # max instruction on "int", 0 otherwise.
1953 #
1954 # This won't change for different subtargets so cache the result.
1955
1956 proc check_effective_target_vect_no_int_max { } {
1957     global et_vect_no_int_max_saved
1958
1959     if [info exists et_vect_no_int_max_saved] {
1960         verbose "check_effective_target_vect_no_int_max: using cached result" 2
1961     } else {
1962         set et_vect_no_int_max_saved 0
1963         if { [istarget sparc*-*-*]
1964              || [istarget spu-*-*]
1965              || [istarget alpha*-*-*] } {
1966             set et_vect_no_int_max_saved 1
1967         }
1968     }
1969     verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1970     return $et_vect_no_int_max_saved
1971 }
1972
1973 # Return 1 if the target plus current options does not support a vector
1974 # add instruction on "int", 0 otherwise.
1975 #
1976 # This won't change for different subtargets so cache the result.
1977
1978 proc check_effective_target_vect_no_int_add { } {
1979     global et_vect_no_int_add_saved
1980
1981     if [info exists et_vect_no_int_add_saved] {
1982         verbose "check_effective_target_vect_no_int_add: using cached result" 2
1983     } else {
1984         set et_vect_no_int_add_saved 0
1985         # Alpha only supports vector add on V8QI and V4HI.
1986         if { [istarget alpha*-*-*] } {
1987             set et_vect_no_int_add_saved 1
1988         }
1989     }
1990     verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1991     return $et_vect_no_int_add_saved
1992 }
1993
1994 # Return 1 if the target plus current options does not support vector
1995 # bitwise instructions, 0 otherwise.
1996 #
1997 # This won't change for different subtargets so cache the result.
1998
1999 proc check_effective_target_vect_no_bitwise { } {
2000     global et_vect_no_bitwise_saved
2001
2002     if [info exists et_vect_no_bitwise_saved] {
2003         verbose "check_effective_target_vect_no_bitwise: using cached result" 2
2004     } else {
2005         set et_vect_no_bitwise_saved 0
2006     }
2007     verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
2008     return $et_vect_no_bitwise_saved
2009 }
2010
2011 # Return 1 if the target plus current options supports vector permutation,
2012 # 0 otherwise.
2013 #
2014 # This won't change for different subtargets so cache the result.
2015
2016 proc check_effective_target_vect_perm { } {
2017     global et_vect_perm
2018
2019     if [info exists et_vect_perm_saved] {
2020         verbose "check_effective_target_vect_perm: using cached result" 2
2021     } else {
2022         set et_vect_perm_saved 0
2023         if { [istarget powerpc*-*-*]
2024              || [istarget spu-*-*] } {
2025             set et_vect_perm_saved 1
2026         }
2027     }
2028     verbose "check_effective_target_vect_perm: returning $et_vect_perm_saved" 2
2029     return $et_vect_perm_saved
2030 }
2031
2032
2033 # Return 1 if the target plus current options supports a vector
2034 # widening summation of *short* args into *int* result, 0 otherwise.
2035 # A target can also support this widening summation if it can support
2036 # promotion (unpacking) from shorts to ints.
2037 #
2038 # This won't change for different subtargets so cache the result.
2039                                                                                                 
2040 proc check_effective_target_vect_widen_sum_hi_to_si { } {
2041     global et_vect_widen_sum_hi_to_si
2042
2043     if [info exists et_vect_widen_sum_hi_to_si_saved] {
2044         verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
2045     } else {
2046         set et_vect_widen_sum_hi_to_si_saved [check_effective_target_vect_unpack]
2047         if { [istarget powerpc*-*-*] 
2048              || [istarget ia64-*-*] } {
2049             set et_vect_widen_sum_hi_to_si_saved 1
2050         }
2051     }
2052     verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
2053     return $et_vect_widen_sum_hi_to_si_saved
2054 }
2055
2056 # Return 1 if the target plus current options supports a vector
2057 # widening summation of *char* args into *short* result, 0 otherwise.
2058 # A target can also support this widening summation if it can support
2059 # promotion (unpacking) from chars to shorts.
2060 #
2061 # This won't change for different subtargets so cache the result.
2062                                                                                                 
2063 proc check_effective_target_vect_widen_sum_qi_to_hi { } {
2064     global et_vect_widen_sum_qi_to_hi
2065
2066     if [info exists et_vect_widen_sum_qi_to_hi_saved] {
2067         verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
2068     } else {
2069         set et_vect_widen_sum_qi_to_hi_saved 0
2070         if { [check_effective_target_vect_unpack] 
2071              || [istarget ia64-*-*] } {
2072             set et_vect_widen_sum_qi_to_hi_saved 1
2073         }
2074     }
2075     verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
2076     return $et_vect_widen_sum_qi_to_hi_saved
2077 }
2078
2079 # Return 1 if the target plus current options supports a vector
2080 # widening summation of *char* args into *int* result, 0 otherwise.
2081 #
2082 # This won't change for different subtargets so cache the result.
2083                                                                                                 
2084 proc check_effective_target_vect_widen_sum_qi_to_si { } {
2085     global et_vect_widen_sum_qi_to_si
2086
2087     if [info exists et_vect_widen_sum_qi_to_si_saved] {
2088         verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
2089     } else {
2090         set et_vect_widen_sum_qi_to_si_saved 0
2091         if { [istarget powerpc*-*-*] } {
2092             set et_vect_widen_sum_qi_to_si_saved 1
2093         }
2094     }
2095     verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
2096     return $et_vect_widen_sum_qi_to_si_saved
2097 }
2098
2099 # Return 1 if the target plus current options supports a vector
2100 # widening multiplication of *char* args into *short* result, 0 otherwise.
2101 # A target can also support this widening multplication if it can support
2102 # promotion (unpacking) from chars to shorts, and vect_short_mult (non-widening
2103 # multiplication of shorts).
2104 #
2105 # This won't change for different subtargets so cache the result.
2106
2107
2108 proc check_effective_target_vect_widen_mult_qi_to_hi { } {
2109     global et_vect_widen_mult_qi_to_hi
2110
2111     if [info exists et_vect_widen_mult_qi_to_hi_saved] {
2112         verbose "check_effective_target_vect_widen_mult_qi_to_hi: using cached result" 2
2113     } else {
2114         if { [check_effective_target_vect_unpack]
2115              && [check_effective_target_vect_short_mult] } {
2116             set et_vect_widen_mult_qi_to_hi_saved 1
2117         } else {
2118             set et_vect_widen_mult_qi_to_hi_saved 0
2119         }
2120         if { [istarget powerpc*-*-*] } {
2121             set et_vect_widen_mult_qi_to_hi_saved 1
2122         }
2123     }
2124     verbose "check_effective_target_vect_widen_mult_qi_to_hi: returning $et_vect_widen_mult_qi_to_hi_saved" 2
2125     return $et_vect_widen_mult_qi_to_hi_saved
2126 }
2127
2128 # Return 1 if the target plus current options supports a vector
2129 # widening multiplication of *short* args into *int* result, 0 otherwise.
2130 # A target can also support this widening multplication if it can support
2131 # promotion (unpacking) from shorts to ints, and vect_int_mult (non-widening
2132 # multiplication of ints).
2133 #
2134 # This won't change for different subtargets so cache the result.
2135
2136
2137 proc check_effective_target_vect_widen_mult_hi_to_si { } {
2138     global et_vect_widen_mult_hi_to_si
2139
2140     if [info exists et_vect_widen_mult_hi_to_si_saved] {
2141         verbose "check_effective_target_vect_widen_mult_hi_to_si: using cached result" 2
2142     } else {
2143         if { [check_effective_target_vect_unpack]
2144              && [check_effective_target_vect_int_mult] } {
2145           set et_vect_widen_mult_hi_to_si_saved 1
2146         } else {
2147           set et_vect_widen_mult_hi_to_si_saved 0
2148         }
2149         if { [istarget powerpc*-*-*]
2150               || [istarget spu-*-*]
2151               || [istarget i?86-*-*]
2152               || [istarget x86_64-*-*] } {
2153             set et_vect_widen_mult_hi_to_si_saved 1
2154         }
2155     }
2156     verbose "check_effective_target_vect_widen_mult_hi_to_si: returning $et_vect_widen_mult_hi_to_si_saved" 2
2157     return $et_vect_widen_mult_hi_to_si_saved
2158 }
2159
2160 # Return 1 if the target plus current options supports a vector
2161 # dot-product of signed chars, 0 otherwise.
2162 #
2163 # This won't change for different subtargets so cache the result.
2164
2165 proc check_effective_target_vect_sdot_qi { } {
2166     global et_vect_sdot_qi
2167
2168     if [info exists et_vect_sdot_qi_saved] {
2169         verbose "check_effective_target_vect_sdot_qi: using cached result" 2
2170     } else {
2171         set et_vect_sdot_qi_saved 0
2172     }
2173     verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
2174     return $et_vect_sdot_qi_saved
2175 }
2176
2177 # Return 1 if the target plus current options supports a vector
2178 # dot-product of unsigned chars, 0 otherwise.
2179 #
2180 # This won't change for different subtargets so cache the result.
2181
2182 proc check_effective_target_vect_udot_qi { } {
2183     global et_vect_udot_qi
2184
2185     if [info exists et_vect_udot_qi_saved] {
2186         verbose "check_effective_target_vect_udot_qi: using cached result" 2
2187     } else {
2188         set et_vect_udot_qi_saved 0
2189         if { [istarget powerpc*-*-*] } {
2190             set et_vect_udot_qi_saved 1
2191         }
2192     }
2193     verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
2194     return $et_vect_udot_qi_saved
2195 }
2196
2197 # Return 1 if the target plus current options supports a vector
2198 # dot-product of signed shorts, 0 otherwise.
2199 #
2200 # This won't change for different subtargets so cache the result.
2201
2202 proc check_effective_target_vect_sdot_hi { } {
2203     global et_vect_sdot_hi
2204
2205     if [info exists et_vect_sdot_hi_saved] {
2206         verbose "check_effective_target_vect_sdot_hi: using cached result" 2
2207     } else {
2208         set et_vect_sdot_hi_saved 0
2209         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
2210              || [istarget i?86-*-*]
2211              || [istarget x86_64-*-*] } {
2212             set et_vect_sdot_hi_saved 1
2213         }
2214     }
2215     verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
2216     return $et_vect_sdot_hi_saved
2217 }
2218
2219 # Return 1 if the target plus current options supports a vector
2220 # dot-product of unsigned shorts, 0 otherwise.
2221 #
2222 # This won't change for different subtargets so cache the result.
2223
2224 proc check_effective_target_vect_udot_hi { } {
2225     global et_vect_udot_hi
2226
2227     if [info exists et_vect_udot_hi_saved] {
2228         verbose "check_effective_target_vect_udot_hi: using cached result" 2
2229     } else {
2230         set et_vect_udot_hi_saved 0
2231         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*]) } {
2232             set et_vect_udot_hi_saved 1
2233         }
2234     }
2235     verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
2236     return $et_vect_udot_hi_saved
2237 }
2238
2239
2240 # Return 1 if the target plus current options supports a vector
2241 # demotion (packing) of shorts (to chars) and ints (to shorts) 
2242 # using modulo arithmetic, 0 otherwise.
2243 #
2244 # This won't change for different subtargets so cache the result.
2245                                                                                 
2246 proc check_effective_target_vect_pack_trunc { } {
2247     global et_vect_pack_trunc
2248                                                                                 
2249     if [info exists et_vect_pack_trunc_saved] {
2250         verbose "check_effective_target_vect_pack_trunc: using cached result" 2
2251     } else {
2252         set et_vect_pack_trunc_saved 0
2253         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
2254              || [istarget i?86-*-*]
2255              || [istarget x86_64-*-*]
2256              || [istarget spu-*-*] } {
2257             set et_vect_pack_trunc_saved 1
2258         }
2259     }
2260     verbose "check_effective_target_vect_pack_trunc: returning $et_vect_pack_trunc_saved" 2
2261     return $et_vect_pack_trunc_saved
2262 }
2263
2264 # Return 1 if the target plus current options supports a vector
2265 # promotion (unpacking) of chars (to shorts) and shorts (to ints), 0 otherwise.
2266 #
2267 # This won't change for different subtargets so cache the result.
2268                                    
2269 proc check_effective_target_vect_unpack { } {
2270     global et_vect_unpack
2271                                         
2272     if [info exists et_vect_unpack_saved] {
2273         verbose "check_effective_target_vect_unpack: using cached result" 2
2274     } else {
2275         set et_vect_unpack_saved 0
2276         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*paired*])
2277              || [istarget i?86-*-*]
2278              || [istarget x86_64-*-*] 
2279              || [istarget spu-*-*] } {
2280             set et_vect_unpack_saved 1
2281         }
2282     }
2283     verbose "check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2  
2284     return $et_vect_unpack_saved
2285 }
2286
2287 # Return 1 if the target plus current options does not guarantee
2288 # that its STACK_BOUNDARY is >= the reguired vector alignment.
2289 #
2290 # This won't change for different subtargets so cache the result.
2291
2292 proc check_effective_target_unaligned_stack { } {
2293     global et_unaligned_stack_saved
2294
2295     if [info exists et_unaligned_stack_saved] {
2296         verbose "check_effective_target_unaligned_stack: using cached result" 2
2297     } else {
2298         set et_unaligned_stack_saved 0
2299     }
2300     verbose "check_effective_target_unaligned_stack: returning $et_unaligned_stack_saved" 2
2301     return $et_unaligned_stack_saved
2302 }
2303
2304 # Return 1 if the target plus current options does not support a vector
2305 # alignment mechanism, 0 otherwise.
2306 #
2307 # This won't change for different subtargets so cache the result.
2308
2309 proc check_effective_target_vect_no_align { } {
2310     global et_vect_no_align_saved
2311
2312     if [info exists et_vect_no_align_saved] {
2313         verbose "check_effective_target_vect_no_align: using cached result" 2
2314     } else {
2315         set et_vect_no_align_saved 0
2316         if { [istarget mipsisa64*-*-*]
2317              || [istarget sparc*-*-*]
2318              || [istarget ia64-*-*]
2319              || [check_effective_target_arm32] } { 
2320             set et_vect_no_align_saved 1
2321         }
2322     }
2323     verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
2324     return $et_vect_no_align_saved
2325 }
2326
2327 # Return 1 if the target supports a vector misalign access, 0 otherwise.
2328 #
2329 # This won't change for different subtargets so cache the result.
2330
2331 proc check_effective_target_vect_hw_misalign { } {
2332     global et_vect_hw_misalign_saved
2333
2334     if [info exists et_vect_hw_misalign_saved] {
2335         verbose "check_effective_target_vect_hw_misalign: using cached result" 2
2336     } else {
2337         set et_vect_hw_misalign_saved 0
2338        if { ([istarget x86_64-*-*] 
2339             || [istarget i?86-*-*]) } {
2340           set et_vect_hw_misalign_saved 1
2341        }
2342     }
2343     verbose "check_effective_target_vect_hw_misalign: returning $et_vect_hw_misalign_saved" 2
2344     return $et_vect_hw_misalign_saved
2345 }
2346
2347
2348 # Return 1 if arrays are aligned to the vector alignment
2349 # boundary, 0 otherwise.
2350 #
2351 # This won't change for different subtargets so cache the result.
2352
2353 proc check_effective_target_vect_aligned_arrays { } {
2354     global et_vect_aligned_arrays
2355
2356     if [info exists et_vect_aligned_arrays_saved] {
2357         verbose "check_effective_target_vect_aligned_arrays: using cached result" 2
2358     } else {
2359         set et_vect_aligned_arrays_saved 0
2360         if { (([istarget x86_64-*-*]
2361               || [istarget i?86-*-*]) && [is-effective-target lp64])
2362               || [istarget spu-*-*] } {
2363             set et_vect_aligned_arrays_saved 1
2364         }
2365     }
2366     verbose "check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
2367     return $et_vect_aligned_arrays_saved
2368 }
2369
2370 # Return 1 if types of size 32 bit or less are naturally aligned
2371 # (aligned to their type-size), 0 otherwise.
2372 #
2373 # This won't change for different subtargets so cache the result.
2374
2375 proc check_effective_target_natural_alignment_32 { } {
2376     global et_natural_alignment_32
2377
2378     if [info exists et_natural_alignment_32_saved] {
2379         verbose "check_effective_target_natural_alignment_32: using cached result" 2
2380     } else {
2381         # FIXME: 32bit powerpc: guaranteed only if MASK_ALIGN_NATURAL/POWER.
2382         set et_natural_alignment_32_saved 1
2383         if { ([istarget *-*-darwin*] && [is-effective-target lp64]) } {
2384             set et_natural_alignment_32_saved 0
2385         }
2386     }
2387     verbose "check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
2388     return $et_natural_alignment_32_saved
2389 }
2390
2391 # Return 1 if types of size 64 bit or less are naturally aligned (aligned to their
2392 # type-size), 0 otherwise.
2393 #
2394 # This won't change for different subtargets so cache the result.
2395
2396 proc check_effective_target_natural_alignment_64 { } {
2397     global et_natural_alignment_64
2398
2399     if [info exists et_natural_alignment_64_saved] {
2400         verbose "check_effective_target_natural_alignment_64: using cached result" 2
2401     } else {
2402         set et_natural_alignment_64_saved 0
2403         if { ([is-effective-target lp64] && ![istarget *-*-darwin*])
2404              || [istarget spu-*-*] } {
2405             set et_natural_alignment_64_saved 1
2406         }
2407     }
2408     verbose "check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
2409     return $et_natural_alignment_64_saved
2410 }
2411
2412 # Return 1 if vector alignment (for types of size 32 bit or less) is reachable, 0 otherwise.
2413 #
2414 # This won't change for different subtargets so cache the result.
2415
2416 proc check_effective_target_vector_alignment_reachable { } {
2417     global et_vector_alignment_reachable
2418
2419     if [info exists et_vector_alignment_reachable_saved] {
2420         verbose "check_effective_target_vector_alignment_reachable: using cached result" 2
2421     } else {
2422         if { [check_effective_target_vect_aligned_arrays]
2423              || [check_effective_target_natural_alignment_32] } {
2424             set et_vector_alignment_reachable_saved 1
2425         } else {
2426             set et_vector_alignment_reachable_saved 0
2427         }
2428     }
2429     verbose "check_effective_target_vector_alignment_reachable: returning $et_vector_alignment_reachable_saved" 2
2430     return $et_vector_alignment_reachable_saved
2431 }
2432
2433 # Return 1 if vector alignment for 64 bit is reachable, 0 otherwise.
2434 #
2435 # This won't change for different subtargets so cache the result.
2436
2437 proc check_effective_target_vector_alignment_reachable_for_64bit { } {
2438     global et_vector_alignment_reachable_for_64bit
2439
2440     if [info exists et_vector_alignment_reachable_for_64bit_saved] {
2441         verbose "check_effective_target_vector_alignment_reachable_for_64bit: using cached result" 2
2442     } else {
2443         if { [check_effective_target_vect_aligned_arrays] 
2444              || [check_effective_target_natural_alignment_64] } {
2445             set et_vector_alignment_reachable_for_64bit_saved 1
2446         } else {
2447             set et_vector_alignment_reachable_for_64bit_saved 0
2448         }
2449     }
2450     verbose "check_effective_target_vector_alignment_reachable_for_64bit: returning $et_vector_alignment_reachable_for_64bit_saved" 2
2451     return $et_vector_alignment_reachable_for_64bit_saved
2452 }
2453
2454 # Return 1 if the target supports vector conditional operations, 0 otherwise.
2455
2456 proc check_effective_target_vect_condition { } {
2457     global et_vect_cond_saved
2458
2459     if [info exists et_vect_cond_saved] {
2460         verbose "check_effective_target_vect_cond: using cached result" 2
2461     } else {
2462         set et_vect_cond_saved 0
2463         if { [istarget powerpc*-*-*]
2464              || [istarget ia64-*-*]
2465              || [istarget i?86-*-*]
2466              || [istarget spu-*-*]
2467              || [istarget x86_64-*-*] } {
2468            set et_vect_cond_saved 1
2469         }
2470     }
2471
2472     verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
2473     return $et_vect_cond_saved
2474 }
2475
2476 # Return 1 if the target supports vector char multiplication, 0 otherwise.
2477
2478 proc check_effective_target_vect_char_mult { } {
2479     global et_vect_char_mult_saved
2480
2481     if [info exists et_vect_char_mult_saved] {
2482         verbose "check_effective_target_vect_char_mult: using cached result" 2
2483     } else {
2484         set et_vect_char_mult_saved 0
2485         if { [istarget ia64-*-*]
2486              || [istarget i?86-*-*]
2487              || [istarget x86_64-*-*] } {
2488            set et_vect_char_mult_saved 1
2489         }
2490     }
2491
2492     verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
2493     return $et_vect_char_mult_saved
2494 }
2495
2496 # Return 1 if the target supports vector short multiplication, 0 otherwise.
2497
2498 proc check_effective_target_vect_short_mult { } {
2499     global et_vect_short_mult_saved
2500
2501     if [info exists et_vect_short_mult_saved] {
2502         verbose "check_effective_target_vect_short_mult: using cached result" 2
2503     } else {
2504         set et_vect_short_mult_saved 0
2505         if { [istarget ia64-*-*]
2506              || [istarget spu-*-*]
2507              || [istarget i?86-*-*]
2508              || [istarget x86_64-*-*] 
2509              || [istarget powerpc*-*-*] 
2510              || [check_effective_target_arm32] } {
2511            set et_vect_short_mult_saved 1
2512         }
2513     }
2514
2515     verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
2516     return $et_vect_short_mult_saved
2517 }
2518
2519 # Return 1 if the target supports vector int multiplication, 0 otherwise.
2520
2521 proc check_effective_target_vect_int_mult { } {
2522     global et_vect_int_mult_saved
2523
2524     if [info exists et_vect_int_mult_saved] {
2525         verbose "check_effective_target_vect_int_mult: using cached result" 2
2526     } else {
2527         set et_vect_int_mult_saved 0
2528         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
2529              || [istarget spu-*-*]
2530              || [istarget i?86-*-*]
2531              || [istarget x86_64-*-*]
2532              || [check_effective_target_arm32] } {
2533            set et_vect_int_mult_saved 1
2534         }
2535     }
2536
2537     verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
2538     return $et_vect_int_mult_saved
2539 }
2540
2541 # Return 1 if the target supports vector even/odd elements extraction, 0 otherwise.
2542
2543 proc check_effective_target_vect_extract_even_odd { } {
2544     global et_vect_extract_even_odd_saved
2545     
2546     if [info exists et_vect_extract_even_odd_saved] {
2547         verbose "check_effective_target_vect_extract_even_odd: using cached result" 2
2548     } else {
2549         set et_vect_extract_even_odd_saved 0 
2550         if { [istarget powerpc*-*-*]
2551              || [istarget spu-*-*] } {
2552            set et_vect_extract_even_odd_saved 1
2553         }
2554     }
2555
2556     verbose "check_effective_target_vect_extract_even_odd: returning $et_vect_extract_even_odd_saved" 2
2557     return $et_vect_extract_even_odd_saved
2558 }
2559
2560 # Return 1 if the target supports vector even/odd elements extraction of
2561 # vectors with SImode elements or larger, 0 otherwise.
2562
2563 proc check_effective_target_vect_extract_even_odd_wide { } {
2564     global et_vect_extract_even_odd_wide_saved
2565     
2566     if [info exists et_vect_extract_even_odd_wide_saved] {
2567         verbose "check_effective_target_vect_extract_even_odd_wide: using cached result" 2
2568     } else {
2569         set et_vect_extract_even_odd_wide_saved 0 
2570         if { [istarget powerpc*-*-*] 
2571              || [istarget i?86-*-*]
2572              || [istarget x86_64-*-*]
2573              || [istarget spu-*-*] } {
2574            set et_vect_extract_even_odd_wide_saved 1
2575         }
2576     }
2577
2578     verbose "check_effective_target_vect_extract_even_wide_odd: returning $et_vect_extract_even_odd_wide_saved" 2
2579     return $et_vect_extract_even_odd_wide_saved
2580 }
2581
2582 # Return 1 if the target supports vector interleaving, 0 otherwise.
2583
2584 proc check_effective_target_vect_interleave { } {
2585     global et_vect_interleave_saved
2586     
2587     if [info exists et_vect_interleave_saved] {
2588         verbose "check_effective_target_vect_interleave: using cached result" 2
2589     } else {
2590         set et_vect_interleave_saved 0
2591         if { [istarget powerpc*-*-*]
2592              || [istarget i?86-*-*]
2593              || [istarget x86_64-*-*]
2594              || [istarget spu-*-*] } {
2595            set et_vect_interleave_saved 1
2596         }
2597     }
2598
2599     verbose "check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
2600     return $et_vect_interleave_saved
2601 }
2602
2603 # Return 1 if the target supports vector interleaving and extract even/odd, 0 otherwise.
2604 proc check_effective_target_vect_strided { } {
2605     global et_vect_strided_saved
2606
2607     if [info exists et_vect_strided_saved] {
2608         verbose "check_effective_target_vect_strided: using cached result" 2
2609     } else {
2610         set et_vect_strided_saved 0
2611         if { [check_effective_target_vect_interleave]
2612              && [check_effective_target_vect_extract_even_odd] } {
2613            set et_vect_strided_saved 1
2614         }
2615     }
2616
2617     verbose "check_effective_target_vect_strided: returning $et_vect_strided_saved" 2
2618     return $et_vect_strided_saved
2619 }
2620
2621 # Return 1 if the target supports vector interleaving and extract even/odd
2622 # for wide element types, 0 otherwise.
2623 proc check_effective_target_vect_strided_wide { } {
2624     global et_vect_strided_wide_saved
2625
2626     if [info exists et_vect_strided_wide_saved] {
2627         verbose "check_effective_target_vect_strided_wide: using cached result" 2
2628     } else {
2629         set et_vect_strided_wide_saved 0
2630         if { [check_effective_target_vect_interleave]
2631              && [check_effective_target_vect_extract_even_odd_wide] } {
2632            set et_vect_strided_wide_saved 1
2633         }
2634     }
2635
2636     verbose "check_effective_target_vect_strided_wide: returning $et_vect_strided_wide_saved" 2
2637     return $et_vect_strided_wide_saved
2638 }
2639
2640 # Return 1 if the target supports section-anchors
2641
2642 proc check_effective_target_section_anchors { } {
2643     global et_section_anchors_saved
2644
2645     if [info exists et_section_anchors_saved] {
2646         verbose "check_effective_target_section_anchors: using cached result" 2
2647     } else {
2648         set et_section_anchors_saved 0
2649         if { [istarget powerpc*-*-*] 
2650               || [istarget arm*-*-*] } {
2651            set et_section_anchors_saved 1
2652         }
2653     }
2654
2655     verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
2656     return $et_section_anchors_saved
2657 }
2658
2659 # Return 1 if the target supports atomic operations on "int" and "long".
2660
2661 proc check_effective_target_sync_int_long { } {
2662     global et_sync_int_long_saved
2663
2664     if [info exists et_sync_int_long_saved] {
2665         verbose "check_effective_target_sync_int_long: using cached result" 2
2666     } else {
2667         set et_sync_int_long_saved 0
2668 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2669 # load-reserved/store-conditional instructions.
2670         if { [istarget ia64-*-*]
2671              || [istarget i?86-*-*]
2672              || [istarget x86_64-*-*]
2673              || [istarget alpha*-*-*] 
2674              || [istarget bfin*-*linux*]
2675              || [istarget s390*-*-*] 
2676              || [istarget powerpc*-*-*]
2677              || [istarget sparc64-*-*]
2678              || [istarget sparcv9-*-*]
2679              || [istarget mips*-*-*] } {
2680            set et_sync_int_long_saved 1
2681         }
2682     }
2683
2684     verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2685     return $et_sync_int_long_saved
2686 }
2687
2688 # Return 1 if the target supports atomic operations on "char" and "short".
2689
2690 proc check_effective_target_sync_char_short { } {
2691     global et_sync_char_short_saved
2692
2693     if [info exists et_sync_char_short_saved] {
2694         verbose "check_effective_target_sync_char_short: using cached result" 2
2695     } else {
2696         set et_sync_char_short_saved 0
2697 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2698 # load-reserved/store-conditional instructions.
2699         if { [istarget ia64-*-*]
2700              || [istarget i?86-*-*]
2701              || [istarget x86_64-*-*]
2702              || [istarget alpha*-*-*] 
2703              || [istarget s390*-*-*] 
2704              || [istarget powerpc*-*-*]
2705              || [istarget sparc64-*-*]
2706              || [istarget sparcv9-*-*]
2707              || [istarget mips*-*-*] } {
2708            set et_sync_char_short_saved 1
2709         }
2710     }
2711
2712     verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2713     return $et_sync_char_short_saved
2714 }
2715
2716 # Return 1 if the target uses a ColdFire FPU.
2717
2718 proc check_effective_target_coldfire_fpu { } {
2719     return [check_no_compiler_messages coldfire_fpu assembly {
2720         #ifndef __mcffpu__
2721         #error FOO
2722         #endif
2723     }]
2724 }
2725
2726 # Return true if this is a uClibc target.
2727
2728 proc check_effective_target_uclibc {} {
2729     return [check_no_compiler_messages uclibc object {
2730         #include <features.h>
2731         #if !defined (__UCLIBC__)
2732         #error FOO
2733         #endif
2734     }]
2735 }
2736
2737 # Return true if this is a uclibc target and if the uclibc feature
2738 # described by __$feature__ is not present.
2739
2740 proc check_missing_uclibc_feature {feature} {
2741     return [check_no_compiler_messages $feature object "
2742         #include <features.h>
2743         #if !defined (__UCLIBC) || defined (__${feature}__)
2744         #error FOO
2745         #endif
2746     "]
2747 }
2748
2749 # Return true if this is a Newlib target.
2750
2751 proc check_effective_target_newlib {} {
2752     return [check_no_compiler_messages newlib object {
2753         #include <newlib.h>
2754     }]
2755 }
2756
2757 # Return 1 if
2758 #   (a) an error of a few ULP is expected in string to floating-point
2759 #       conversion functions; and
2760 #   (b) overflow is not always detected correctly by those functions.
2761
2762 proc check_effective_target_lax_strtofp {} {
2763     # By default, assume that all uClibc targets suffer from this.
2764     return [check_effective_target_uclibc]
2765 }
2766
2767 # Return 1 if this is a target for which wcsftime is a dummy
2768 # function that always returns 0.
2769
2770 proc check_effective_target_dummy_wcsftime {} {
2771     # By default, assume that all uClibc targets suffer from this.
2772     return [check_effective_target_uclibc]
2773 }
2774
2775 # Return 1 if constructors with initialization priority arguments are
2776 # supposed on this target.
2777
2778 proc check_effective_target_init_priority {} {
2779     return [check_no_compiler_messages init_priority assembly "
2780         void f() __attribute__((constructor (1000)));
2781         void f() \{\}
2782     "]
2783 }
2784
2785 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
2786 # This can be used with any check_* proc that takes no argument and
2787 # returns only 1 or 0.  It could be used with check_* procs that take
2788 # arguments with keywords that pass particular arguments.
2789
2790 proc is-effective-target { arg } {
2791     set selected 0
2792     if { [info procs check_effective_target_${arg}] != [list] } {
2793         set selected [check_effective_target_${arg}]
2794     } else {
2795         switch $arg {
2796           "vmx_hw"         { set selected [check_vmx_hw_available] }
2797           "named_sections" { set selected [check_named_sections_available] }
2798           "gc_sections"    { set selected [check_gc_sections_available] }
2799           "cxa_atexit"     { set selected [check_cxa_atexit_available] }
2800           default          { error "unknown effective target keyword `$arg'" }
2801         }
2802     }
2803     verbose "is-effective-target: $arg $selected" 2
2804     return $selected
2805 }
2806
2807 # Return 1 if the argument is an effective-target keyword, 0 otherwise.
2808
2809 proc is-effective-target-keyword { arg } {
2810     if { [info procs check_effective_target_${arg}] != [list] } {
2811         return 1
2812     } else {
2813         # These have different names for their check_* procs.
2814         switch $arg {
2815           "vmx_hw"         { return 1 }
2816           "named_sections" { return 1 }
2817           "gc_sections"    { return 1 }
2818           "cxa_atexit"     { return 1 }
2819           default          { return 0 }
2820         }
2821     }
2822 }
2823
2824 # Return 1 if target default to short enums
2825
2826 proc check_effective_target_short_enums { } {
2827     return [check_no_compiler_messages short_enums assembly {
2828         enum foo { bar };
2829         int s[sizeof (enum foo) == 1 ? 1 : -1];
2830     }]
2831 }
2832
2833 # Return 1 if target supports merging string constants at link time.
2834
2835 proc check_effective_target_string_merging { } {
2836     return [check_no_messages_and_pattern string_merging \
2837                 "rodata\\.str" assembly {
2838                     const char *var = "String";
2839                 } {-O2}]
2840 }
2841
2842 # Return 1 if target has the basic signed and unsigned types in
2843 # <stdint.h>, 0 otherwise.  This will be obsolete when GCC ensures a
2844 # working <stdint.h> for all targets.
2845
2846 proc check_effective_target_stdint_types { } {
2847     return [check_no_compiler_messages stdint_types assembly {
2848         #include <stdint.h>
2849         int8_t a; int16_t b; int32_t c; int64_t d;
2850         uint8_t e; uint16_t f; uint32_t g; uint64_t h;
2851     }]
2852 }
2853
2854 # Return 1 if target has the basic signed and unsigned types in
2855 # <inttypes.h>, 0 otherwise.  This is for tests that GCC's notions of
2856 # these types agree with those in the header, as some systems have
2857 # only <inttypes.h>.
2858
2859 proc check_effective_target_inttypes_types { } {
2860     return [check_no_compiler_messages inttypes_types assembly {
2861         #include <inttypes.h>
2862         int8_t a; int16_t b; int32_t c; int64_t d;
2863         uint8_t e; uint16_t f; uint32_t g; uint64_t h;
2864     }]
2865 }
2866
2867 # Return 1 if programs are intended to be run on a simulator
2868 # (i.e. slowly) rather than hardware (i.e. fast).
2869
2870 proc check_effective_target_simulator { } {
2871
2872     # All "src/sim" simulators set this one.
2873     if [board_info target exists is_simulator] {
2874         return [board_info target is_simulator]
2875     }
2876
2877     # The "sid" simulators don't set that one, but at least they set
2878     # this one.
2879     if [board_info target exists slow_simulator] {
2880         return [board_info target slow_simulator]
2881     }
2882
2883     return 0
2884 }
2885
2886 # Return 1 if the target is a VxWorks kernel.
2887
2888 proc check_effective_target_vxworks_kernel { } {
2889     return [check_no_compiler_messages vxworks_kernel assembly {
2890         #if !defined __vxworks || defined __RTP__
2891         #error NO
2892         #endif
2893     }]
2894 }
2895
2896 # Return 1 if the target is a VxWorks RTP.
2897
2898 proc check_effective_target_vxworks_rtp { } {
2899     return [check_no_compiler_messages vxworks_rtp assembly {
2900         #if !defined __vxworks || !defined __RTP__
2901         #error NO
2902         #endif
2903     }]
2904 }
2905
2906 # Return 1 if the target is expected to provide wide character support.
2907
2908 proc check_effective_target_wchar { } {
2909     if {[check_missing_uclibc_feature UCLIBC_HAS_WCHAR]} {
2910         return 0
2911     }
2912     return [check_no_compiler_messages wchar assembly {
2913         #include <wchar.h>
2914     }]
2915 }
2916
2917 # Return 1 if the target has <pthread.h>.
2918
2919 proc check_effective_target_pthread_h { } {
2920     return [check_no_compiler_messages pthread_h assembly {
2921         #include <pthread.h>
2922     }]
2923 }
2924
2925 # Return 1 if the target can truncate a file from a file-descriptor,
2926 # as used by libgfortran/io/unix.c:fd_truncate; i.e. ftruncate or
2927 # chsize.  We test for a trivially functional truncation; no stubs.
2928 # As libgfortran uses _FILE_OFFSET_BITS 64, we do too; it'll cause a
2929 # different function to be used.
2930
2931 proc check_effective_target_fd_truncate { } {
2932     set prog {
2933         #define _FILE_OFFSET_BITS 64
2934         #include <unistd.h>
2935         #include <stdio.h>
2936         #include <stdlib.h>
2937         int main ()
2938         {
2939           FILE *f = fopen ("tst.tmp", "wb");
2940           int fd;
2941           const char t[] = "test writing more than ten characters";
2942           char s[11];
2943           fd =  fileno (f);
2944           write (fd, t, sizeof (t) - 1);
2945           lseek (fd, 0, 0);
2946           if (ftruncate (fd, 10) != 0)
2947             exit (1);
2948           close (fd);
2949           f = fopen ("tst.tmp", "rb");
2950           if (fread (s, 1, sizeof (s), f) != 10 || strncmp (s, t, 10) != 0)
2951             exit (1);
2952           exit (0);
2953         }
2954     }
2955
2956     if { [check_runtime ftruncate $prog] } {
2957       return 1;
2958     }
2959
2960     regsub "ftruncate" $prog "chsize" prog
2961     return [check_runtime chsize $prog]
2962 }
2963
2964 # Add to FLAGS all the target-specific flags needed to access the c99 runtime.
2965
2966 proc add_options_for_c99_runtime { flags } {
2967     if { [istarget *-*-solaris2*] } {
2968         return "$flags -std=c99"
2969     }
2970     if { [istarget powerpc-*-darwin*] } {
2971         return "$flags -mmacosx-version-min=10.3"
2972     }
2973     return $flags
2974 }
2975
2976 # Add to FLAGS all the target-specific flags needed to enable
2977 # full IEEE compliance mode.
2978
2979 proc add_options_for_ieee { flags } {
2980     if { [istarget "alpha*-*-*"]
2981          || [istarget "sh*-*-*"] } {
2982        return "$flags -mieee"
2983     }
2984     return $flags
2985 }
2986
2987 # Add to FLAGS the flags needed to enable functions to bind locally
2988 # when using pic/PIC passes in the testsuite.
2989
2990 proc add_options_for_bind_pic_locally { flags } {
2991     if {[check_no_compiler_messages using_pic2 assembly {
2992         #if __PIC__ != 2
2993         #error FOO
2994         #endif
2995     }]} {
2996         return "$flags -fPIE"
2997     }
2998     if {[check_no_compiler_messages using_pic1 assembly {
2999         #if __PIC__ != 1
3000         #error FOO
3001         #endif
3002     }]} {
3003         return "$flags -fpie"
3004     }
3005
3006     return $flags
3007 }
3008
3009 # Return 1 if the target provides a full C99 runtime.
3010
3011 proc check_effective_target_c99_runtime { } {
3012     return [check_cached_effective_target c99_runtime {
3013         global srcdir
3014
3015         set file [open "$srcdir/gcc.dg/builtins-config.h"]
3016         set contents [read $file]
3017         close $file
3018         append contents {
3019             #ifndef HAVE_C99_RUNTIME
3020             #error FOO
3021             #endif
3022         }
3023         check_no_compiler_messages_nocache c99_runtime assembly \
3024             $contents [add_options_for_c99_runtime ""]
3025     }]
3026 }
3027
3028 # Return 1 if  target wchar_t is at least 4 bytes.
3029
3030 proc check_effective_target_4byte_wchar_t { } {
3031     return [check_no_compiler_messages 4byte_wchar_t object {
3032         int dummy[sizeof (__WCHAR_TYPE__) >= 4 ? 1 : -1];
3033     }]
3034 }
3035
3036 # Return 1 if the target supports automatic stack alignment.
3037
3038 proc check_effective_target_automatic_stack_alignment  { } {
3039     if { [istarget i?86*-*-*]
3040          || [istarget x86_64-*-*] } then {
3041         return 1
3042     } else {
3043         return 0
3044     }
3045 }
3046
3047 # Return 1 if avx instructions can be compiled.
3048
3049 proc check_effective_target_avx { } {
3050     return [check_no_compiler_messages avx object {
3051         void _mm256_zeroall (void)
3052         {
3053            __builtin_ia32_vzeroall ();
3054         }
3055     } "-O2 -mavx" ]
3056 }
3057
3058 # Return 1 if C wchar_t type is compatible with char16_t.
3059
3060 proc check_effective_target_wchar_t_char16_t_compatible { } {
3061     return [check_no_compiler_messages wchar_t_char16_t object {
3062         __WCHAR_TYPE__ wc;
3063         __CHAR16_TYPE__ *p16 = &wc;
3064         char t[(((__CHAR16_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
3065     }]
3066 }
3067
3068 # Return 1 if C wchar_t type is compatible with char32_t.
3069
3070 proc check_effective_target_wchar_t_char32_t_compatible { } {
3071     return [check_no_compiler_messages wchar_t_char32_t object {
3072         __WCHAR_TYPE__ wc;
3073         __CHAR32_TYPE__ *p32 = &wc;
3074         char t[(((__CHAR32_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
3075     }]
3076 }
3077
3078 # Return 1 if pow10 function exists.
3079
3080 proc check_effective_target_pow10 { } {
3081     return [check_runtime pow10 {
3082         #include <math.h>
3083         int main () {
3084         double x;
3085         x = pow10 (1);
3086         return 0;
3087         }
3088     } "-lm" ]
3089 }
3090
3091 # Return 1 if current options generate DFP instructions, 0 otherwise.
3092
3093 proc check_effective_target_hard_dfp {} {
3094     return [check_no_messages_and_pattern hard_dfp "!adddd3" assembly {
3095         typedef float d64 __attribute__((mode(DD)));
3096         d64 x, y, z;
3097         void foo (void) { z = x + y; }
3098     }]
3099 }
3100
3101 # Return 1 if string.h and wchar.h headers provide C++ requires overloads
3102 # for strchr etc. functions.
3103
3104 proc check_effective_target_correct_iso_cpp_string_wchar_protos { } {
3105     return [check_no_compiler_messages correct_iso_cpp_string_wchar_protos assembly {
3106         #include <string.h>
3107         #include <wchar.h>
3108         #if !defined(__cplusplus) \
3109             || !defined(__CORRECT_ISO_CPP_STRING_H_PROTO) \
3110             || !defined(__CORRECT_ISO_CPP_WCHAR_H_PROTO)
3111         ISO C++ correct string.h and wchar.h protos not supported.
3112         #else
3113         int i;
3114         #endif
3115     }]
3116 }
3117
3118 # Return 1 if the compiler has been configure with link-time optimization
3119 # (LTO) support.
3120
3121 proc check_effective_target_lto { } {
3122     global ENABLE_LTO
3123     return [info exists ENABLE_LTO]
3124 }
3125
3126 # Return 1 if the MPC library is integrated with GCC, 0 otherwise.
3127
3128 proc check_effective_target_mpc { } {
3129     return [check_no_compiler_messages mpc executable {
3130         extern void link_error(void);
3131         int main ()
3132         {
3133           if (__builtin_csin(0) != 0)
3134             link_error();
3135         }
3136     }]
3137 }
3138
3139 # Return 1 if the MPC library with mpc_pow is integrated with GCC, 0 otherwise.
3140
3141 proc check_effective_target_mpc_pow { } {
3142     return [check_no_compiler_messages mpc_pow executable {
3143         extern void link_error(void);
3144         int main ()
3145         {
3146           if (__builtin_cpow(1,1) != 1)
3147             link_error();
3148         }
3149     }]
3150 }
3151
3152 # Return 1 if the MPC library with "arc" functions is integrated with GCC, 0 otherwise.
3153
3154 proc check_effective_target_mpc_arc { } {
3155     return [check_no_compiler_messages mpc_arc executable {
3156         extern void link_error(void);
3157         int main ()
3158         {
3159           if (__builtin_cacos(1) != 0)
3160             link_error();
3161           if (__builtin_casin(0) != 0)
3162             link_error();
3163           if (__builtin_catan(0) != 0)
3164             link_error();
3165           if (__builtin_cacosh(1) != 0)
3166             link_error();
3167           if (__builtin_casinh(0) != 0)
3168             link_error();
3169           if (__builtin_catanh(0) != 0)
3170             link_error();
3171         }
3172     }]
3173 }
3174
3175 # Return 1 if the language for the compiler under test is C.
3176
3177 proc check_effective_target_c { } {
3178  global tool
3179     if [string match $tool "gcc"] {
3180    return 1
3181     }
3182  return 0
3183 }
3184
3185 # Return 1 if the language for the compiler under test is C++.
3186
3187 proc check_effective_target_c++ { } {
3188  global tool
3189     if [string match $tool "g++"] {
3190    return 1
3191     }
3192  return 0
3193 }