OSDN Git Service

af806be6dd181dd4a35b798b3b45002f9c87e075
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / lib / target-supports.exp
1 #   Copyright (C) 1999, 2001, 2003, 2004, 2005, 2006, 2007, 2008
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     # uClibc does not have gcrt1.o.
470     if { [check_effective_target_uclibc]
471          && ([lindex $test_what 1] == "-p"
472              || [lindex $test_what 1] == "-pg") } {
473         return 0
474     }
475
476     # Now examine the cache variable.
477     if {![info exists profiling_available_saved]} {
478         # Some targets don't have any implementation of __bb_init_func or are
479         # missing other needed machinery.
480         if { [istarget mmix-*-*]
481              || [istarget arm*-*-eabi*]
482              || [istarget picochip-*-*]
483              || [istarget *-*-netware*]
484              || [istarget arm*-*-elf]
485              || [istarget arm*-*-symbianelf*]
486              || [istarget avr-*-*]
487              || [istarget bfin-*-*]
488              || [istarget powerpc-*-eabi*]
489              || [istarget cris-*-*]
490              || [istarget crisv32-*-*]
491              || [istarget fido-*-elf]
492              || [istarget h8300-*-*]
493              || [istarget m32c-*-elf]
494              || [istarget m68k-*-elf]
495              || [istarget m68k-*-uclinux*]
496              || [istarget mips*-*-elf*]
497              || [istarget xstormy16-*]
498              || [istarget xtensa*-*-elf]
499              || [istarget *-*-rtems*]
500              || [istarget *-*-vxworks*] } {
501             set profiling_available_saved 0
502         } else {
503             set profiling_available_saved 1
504         }
505     }
506
507     return $profiling_available_saved
508 }
509
510 # Check to see if a target is "freestanding". This is as per the definition
511 # in Section 4 of C99 standard. Effectively, it is a target which supports no
512 # extra headers or libraries other than what is considered essential.
513 proc check_effective_target_freestanding { } {
514     if { [istarget picochip-*-*] } then {
515         return 1
516     } else {
517         return 0
518     }
519 }
520
521 # Return 1 if target has packed layout of structure members by
522 # default, 0 otherwise.  Note that this is slightly different than
523 # whether the target has "natural alignment": both attributes may be
524 # false.
525
526 proc check_effective_target_default_packed { } {
527     return [check_no_compiler_messages default_packed assembly {
528         struct x { char a; long b; } c;
529         int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
530     }]
531 }
532
533 # Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
534 # documentation, where the test also comes from.
535
536 proc check_effective_target_pcc_bitfield_type_matters { } {
537     # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
538     # bitfields, but let's stick to the example code from the docs.
539     return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
540         struct foo1 { char x; char :0; char y; };
541         struct foo2 { char x; int :0; char y; };
542         int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
543     }]
544 }
545
546 # Return 1 if thread local storage (TLS) is supported, 0 otherwise.
547 #
548 # This won't change for different subtargets so cache the result.
549
550 proc check_effective_target_tls {} {
551     return [check_no_compiler_messages tls assembly {
552         __thread int i;
553         int f (void) { return i; }
554         void g (int j) { i = j; }
555     }]
556 }
557
558 # Return 1 if *native* thread local storage (TLS) is supported, 0 otherwise.
559 #
560 # This won't change for different subtargets so cache the result.
561
562 proc check_effective_target_tls_native {} {
563     # VxWorks uses emulated TLS machinery, but with non-standard helper
564     # functions, so we fail to automatically detect it.
565     global target_triplet
566     if { [regexp ".*-.*-vxworks.*" $target_triplet] } {
567         return 0
568     }
569     
570     return [check_no_messages_and_pattern tls_native "!emutls" assembly {
571         __thread int i;
572         int f (void) { return i; }
573         void g (int j) { i = j; }
574     }]
575 }
576
577 # Return 1 if TLS executables can run correctly, 0 otherwise.
578 #
579 # This won't change for different subtargets so cache the result.
580
581 proc check_effective_target_tls_runtime {} {
582     return [check_runtime tls_runtime {
583         __thread int thr = 0;
584         int main (void) { return thr; }
585     }]
586 }
587
588 # Return 1 if compilation with -fgraphite is error-free for trivial 
589 # code, 0 otherwise.
590
591 proc check_effective_target_fgraphite {} {
592     return [check_no_compiler_messages fgraphite object {
593         void foo (void) { }
594     } "-O1 -fgraphite"]
595 }
596
597 # Return 1 if compilation with -fopenmp is error-free for trivial
598 # code, 0 otherwise.
599
600 proc check_effective_target_fopenmp {} {
601     return [check_no_compiler_messages fopenmp object {
602         void foo (void) { }
603     } "-fopenmp"]
604 }
605
606 # Return 1 if compilation with -pthread is error-free for trivial
607 # code, 0 otherwise.
608
609 proc check_effective_target_pthread {} {
610     return [check_no_compiler_messages pthread object {
611         void foo (void) { }
612     } "-pthread"]
613 }
614
615 # Return 1 if the target supports -fstack-protector
616 proc check_effective_target_fstack_protector {} {
617     return [check_runtime fstack_protector {
618         int main (void) { return 0; }
619     } "-fstack-protector"]
620 }
621
622 # Return 1 if compilation with -freorder-blocks-and-partition is error-free
623 # for trivial code, 0 otherwise.
624
625 proc check_effective_target_freorder {} {
626     return [check_no_compiler_messages freorder object {
627         void foo (void) { }
628     } "-freorder-blocks-and-partition"]
629 }
630
631 # Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
632 # emitted, 0 otherwise.  Whether a shared library can actually be built is
633 # out of scope for this test.
634
635 proc check_effective_target_fpic { } {
636     # Note that M68K has a multilib that supports -fpic but not
637     # -fPIC, so we need to check both.  We test with a program that
638     # requires GOT references.
639     foreach arg {fpic fPIC} {
640         if [check_no_compiler_messages $arg object {
641             extern int foo (void); extern int bar;
642             int baz (void) { return foo () + bar; }
643         } "-$arg"] {
644             return 1
645         }
646     }
647     return 0
648 }
649
650 # Return true if the target supports -mpaired-single (as used on MIPS).
651
652 proc check_effective_target_mpaired_single { } {
653     return [check_no_compiler_messages mpaired_single object {
654         void foo (void) { }
655     } "-mpaired-single"]
656 }
657
658 # Return true if the target has access to FPU instructions.
659
660 proc check_effective_target_hard_float { } {
661     if { [istarget mips*-*-*] } {
662         return [check_no_compiler_messages hard_float assembly {
663                 #if (defined __mips_soft_float || defined __mips16)
664                 #error FOO
665                 #endif
666         }]
667     }
668
669     # The generic test equates hard_float with "no call for adding doubles".
670     return [check_no_messages_and_pattern hard_float "!\\(call" rtl-expand {
671         double a (double b, double c) { return b + c; }
672     }]
673 }
674
675 # Return true if the target is a 64-bit MIPS target.
676
677 proc check_effective_target_mips64 { } {
678     return [check_no_compiler_messages mips64 assembly {
679         #ifndef __mips64
680         #error FOO
681         #endif
682     }]
683 }
684
685 # Return true if the target is a MIPS target that does not produce
686 # MIPS16 code.
687
688 proc check_effective_target_nomips16 { } {
689     return [check_no_compiler_messages nomips16 object {
690         #ifndef __mips
691         #error FOO
692         #else
693         /* A cheap way of testing for -mflip-mips16.  */
694         void foo (void) { asm ("addiu $20,$20,1"); }
695         void bar (void) { asm ("addiu $20,$20,1"); }
696         #endif
697     }]
698 }
699
700 # Add the options needed for MIPS16 function attributes.  At the moment,
701 # we don't support MIPS16 PIC.
702
703 proc add_options_for_mips16_attribute { flags } {
704     return "$flags -mno-abicalls -fno-pic -DMIPS16=__attribute__((mips16))"
705 }
706
707 # Return true if we can force a mode that allows MIPS16 code generation.
708 # We don't support MIPS16 PIC, and only support MIPS16 -mhard-float
709 # for o32 and o64.
710
711 proc check_effective_target_mips16_attribute { } {
712     return [check_no_compiler_messages mips16_attribute assembly {
713         #ifdef PIC
714         #error FOO
715         #endif
716         #if defined __mips_hard_float \
717             && (!defined _ABIO32 || _MIPS_SIM != _ABIO32) \
718             && (!defined _ABIO64 || _MIPS_SIM != _ABIO64)
719         #error FOO
720         #endif
721     } [add_options_for_mips16_attribute ""]]
722 }
723
724 # Return 1 if the current multilib does not generate PIC by default.
725
726 proc check_effective_target_nonpic { } {
727     return [check_no_compiler_messages nonpic assembly {
728         #if __PIC__
729         #error FOO
730         #endif
731     }]
732 }
733
734 # Return 1 if the target does not use a status wrapper.
735
736 proc check_effective_target_unwrapped { } {
737     if { [target_info needs_status_wrapper] != "" \
738              && [target_info needs_status_wrapper] != "0" } {
739         return 0
740     }
741     return 1
742 }
743
744 # Return true if iconv is supported on the target. In particular IBM1047.
745
746 proc check_iconv_available { test_what } {
747     global libiconv
748
749     # If the tool configuration file has not set libiconv, try "-liconv"
750     if { ![info exists libiconv] } {
751         set libiconv "-liconv"
752     }
753     set test_what [lindex $test_what 1]
754     return [check_runtime_nocache $test_what [subst {
755         #include <iconv.h>
756         int main (void)
757         {
758           iconv_t cd;
759
760           cd = iconv_open ("$test_what", "UTF-8");
761           if (cd == (iconv_t) -1)
762             return 1;
763           return 0;
764         }
765     }] $libiconv]
766 }
767
768 # Return true if named sections are supported on this target.
769
770 proc check_named_sections_available { } {
771     return [check_no_compiler_messages named_sections assembly {
772         int __attribute__ ((section("whatever"))) foo;
773     }]
774 }
775
776 # Return 1 if the target supports Fortran real kinds larger than real(8),
777 # 0 otherwise.
778 #
779 # When the target name changes, replace the cached result.
780
781 proc check_effective_target_fortran_large_real { } {
782     return [check_no_compiler_messages fortran_large_real executable {
783         ! Fortran
784         integer,parameter :: k = selected_real_kind (precision (0.0_8) + 1)
785         real(kind=k) :: x
786         x = cos (x)
787         end
788     }]
789 }
790
791 # Return 1 if the target supports Fortran integer kinds larger than
792 # integer(8), 0 otherwise.
793 #
794 # When the target name changes, replace the cached result.
795
796 proc check_effective_target_fortran_large_int { } {
797     return [check_no_compiler_messages fortran_large_int executable {
798         ! Fortran
799         integer,parameter :: k = selected_int_kind (range (0_8) + 1)
800         integer(kind=k) :: i
801         end
802     }]
803 }
804
805 # Return 1 if the target supports Fortran integer(16), 0 otherwise.
806 #
807 # When the target name changes, replace the cached result.
808
809 proc check_effective_target_fortran_integer_16 { } {
810     return [check_no_compiler_messages fortran_integer_16 executable {
811         ! Fortran
812         integer(16) :: i
813         end
814     }]
815 }
816
817 # Return 1 if we can statically link libgfortran, 0 otherwise.
818 #
819 # When the target name changes, replace the cached result.
820
821 proc check_effective_target_static_libgfortran { } {
822     return [check_no_compiler_messages static_libgfortran executable {
823         ! Fortran
824         print *, 'test'
825         end
826     } "-static"]
827 }
828
829 # Return 1 if the target supports executing 750CL paired-single instructions, 0
830 # otherwise.  Cache the result.
831
832 proc check_750cl_hw_available { } {
833     return [check_cached_effective_target 750cl_hw_available {
834         # If this is not the right target then we can skip the test.
835         if { ![istarget powerpc-*paired*] } {
836             expr 0
837         } else {
838             check_runtime_nocache 750cl_hw_available {
839                  int main()
840                  {
841                  #ifdef __MACH__
842                    asm volatile ("ps_mul v0,v0,v0");
843                  #else
844                    asm volatile ("ps_mul 0,0,0");
845                  #endif
846                    return 0;
847                  }
848             } "-mpaired"
849         }
850     }]
851 }
852
853 # Return 1 if the target supports executing SSE2 instructions, 0
854 # otherwise.  Cache the result.
855
856 proc check_sse2_hw_available { } {
857     return [check_cached_effective_target sse2_hw_available {
858         # If this is not the right target then we can skip the test.
859         if { !([istarget x86_64-*-*] || [istarget i?86-*-*]) } {
860             expr 0
861         } else {
862             check_runtime_nocache sse2_hw_available {
863                 #include "cpuid.h"
864                 int main ()
865                 {
866                   unsigned int eax, ebx, ecx, edx = 0;
867                   if (__get_cpuid (1, &eax, &ebx, &ecx, &edx))
868                     return !(edx & bit_SSE2);
869                   return 1;
870                 }
871             } ""
872         }
873     }]
874 }
875
876 # Return 1 if the target supports executing AltiVec instructions, 0
877 # otherwise.  Cache the result.
878
879 proc check_vmx_hw_available { } {
880     return [check_cached_effective_target vmx_hw_available {
881         # Some simulators are known to not support VMX instructions.
882         if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
883             expr 0
884         } else {
885             # Most targets don't require special flags for this test case, but
886             # Darwin does.
887             if { [istarget *-*-darwin*]
888                  || [istarget *-*-aix*] } {
889                 set options "-maltivec"
890             } else {
891                 set options ""
892             }
893             check_runtime_nocache vmx_hw_available {
894                 int main()
895                 {
896                 #ifdef __MACH__
897                   asm volatile ("vor v0,v0,v0");
898                 #else
899                   asm volatile ("vor 0,0,0");
900                 #endif
901                   return 0;
902                 }
903             } $options
904         }
905     }]
906 }
907
908 # Return 1 if the target supports executing AltiVec and Cell PPU
909 # instructions, 0 otherwise.  Cache the result.
910
911 proc check_effective_target_cell_hw { } {
912     return [check_cached_effective_target cell_hw_available {
913         # Some simulators are known to not support VMX and PPU instructions.
914         if { [istarget powerpc-*-eabi*] } {
915             expr 0
916         } else {
917             # Most targets don't require special flags for this test
918             # case, but Darwin and AIX do.
919             if { [istarget *-*-darwin*]
920                  || [istarget *-*-aix*] } {
921                 set options "-maltivec -mcpu=cell"
922             } else {
923                 set options "-mcpu=cell"
924             }
925             check_runtime_nocache cell_hw_available {
926                 int main()
927                 {
928                 #ifdef __MACH__
929                   asm volatile ("vor v0,v0,v0");
930                   asm volatile ("lvlx v0,r0,r0");
931                 #else
932                   asm volatile ("vor 0,0,0");
933                   asm volatile ("lvlx 0,0,0");
934                 #endif
935                   return 0;
936                 }
937             } $options
938         }
939     }]
940 }
941
942 # Return 1 if the target supports executing 64-bit instructions, 0
943 # otherwise.  Cache the result.
944
945 proc check_effective_target_powerpc64 { } {
946     global powerpc64_available_saved
947     global tool
948
949     if [info exists powerpc64_available_saved] {
950         verbose "check_effective_target_powerpc64 returning saved $powerpc64_available_saved" 2
951     } else {
952         set powerpc64_available_saved 0
953
954         # Some simulators are known to not support powerpc64 instructions.
955         if { [istarget powerpc-*-eabi*] || [istarget powerpc-ibm-aix*] } {
956             verbose "check_effective_target_powerpc64 returning 0" 2
957             return $powerpc64_available_saved
958         }
959
960         # Set up, compile, and execute a test program containing a 64-bit
961         # instruction.  Include the current process ID in the file
962         # names to prevent conflicts with invocations for multiple
963         # testsuites.
964         set src ppc[pid].c
965         set exe ppc[pid].x
966
967         set f [open $src "w"]
968         puts $f "int main() {"
969         puts $f "#ifdef __MACH__"
970         puts $f "  asm volatile (\"extsw r0,r0\");"
971         puts $f "#else"
972         puts $f "  asm volatile (\"extsw 0,0\");"
973         puts $f "#endif"
974         puts $f "  return 0; }"
975         close $f
976
977         set opts "additional_flags=-mcpu=G5"
978
979         verbose "check_effective_target_powerpc64 compiling testfile $src" 2
980         set lines [${tool}_target_compile $src $exe executable "$opts"]
981         file delete $src
982
983         if [string match "" $lines] then {
984             # No error message, compilation succeeded.
985             set result [${tool}_load "./$exe" "" ""]
986             set status [lindex $result 0]
987             remote_file build delete $exe
988             verbose "check_effective_target_powerpc64 testfile status is <$status>" 2
989
990             if { $status == "pass" } then {
991                 set powerpc64_available_saved 1
992             }
993         } else {
994             verbose "check_effective_target_powerpc64 testfile compilation failed" 2
995         }
996     }
997
998     return $powerpc64_available_saved
999 }
1000
1001 # GCC 3.4.0 for powerpc64-*-linux* included an ABI fix for passing
1002 # complex float arguments.  This affects gfortran tests that call cabsf
1003 # in libm built by an earlier compiler.  Return 1 if libm uses the same
1004 # argument passing as the compiler under test, 0 otherwise.
1005 #
1006 # When the target name changes, replace the cached result.
1007
1008 proc check_effective_target_broken_cplxf_arg { } {
1009     return [check_cached_effective_target broken_cplxf_arg {
1010         # Skip the work for targets known not to be affected.
1011         if { ![istarget powerpc64-*-linux*] } {
1012             expr 0
1013         } elseif { ![is-effective-target lp64] } {
1014             expr 0
1015         } else {
1016             check_runtime_nocache broken_cplxf_arg {
1017                 #include <complex.h>
1018                 extern void abort (void);
1019                 float fabsf (float);
1020                 float cabsf (_Complex float);
1021                 int main ()
1022                 {
1023                   _Complex float cf;
1024                   float f;
1025                   cf = 3 + 4.0fi;
1026                   f = cabsf (cf);
1027                   if (fabsf (f - 5.0) > 0.0001)
1028                     abort ();
1029                   return 0;
1030                 }
1031             } "-lm"
1032         }
1033     }]
1034 }
1035
1036 proc check_alpha_max_hw_available { } {
1037     return [check_runtime alpha_max_hw_available {
1038         int main() { return __builtin_alpha_amask(1<<8) != 0; }
1039     }]
1040 }
1041
1042 # Returns true iff the FUNCTION is available on the target system.
1043 # (This is essentially a Tcl implementation of Autoconf's
1044 # AC_CHECK_FUNC.)
1045
1046 proc check_function_available { function } {
1047     return [check_no_compiler_messages ${function}_available \
1048                 executable [subst {
1049         #ifdef __cplusplus
1050         extern "C"
1051         #endif
1052         char $function ();
1053         int main () { $function (); }
1054     }]]
1055 }
1056
1057 # Returns true iff "fork" is available on the target system.
1058
1059 proc check_fork_available {} {
1060     return [check_function_available "fork"]
1061 }
1062
1063 # Returns true iff "mkfifo" is available on the target system.
1064
1065 proc check_mkfifo_available {} {
1066     if {[istarget *-*-cygwin*]} {
1067        # Cygwin has mkfifo, but support is incomplete.
1068        return 0
1069      }
1070
1071     return [check_function_available "mkfifo"]
1072 }
1073
1074 # Returns true iff "__cxa_atexit" is used on the target system.
1075
1076 proc check_cxa_atexit_available { } {
1077     return [check_cached_effective_target cxa_atexit_available {
1078         if { [istarget "hppa*-*-hpux10*"] } {
1079             # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
1080             expr 0
1081         } else {
1082             check_runtime_nocache cxa_atexit_available {
1083                 // C++
1084                 #include <stdlib.h>
1085                 static unsigned int count;
1086                 struct X
1087                 {
1088                   X() { count = 1; }
1089                   ~X()
1090                   {
1091                     if (count != 3)
1092                       exit(1);
1093                     count = 4;
1094                   }
1095                 };
1096                 void f()
1097                 {
1098                   static X x;
1099                 }
1100                 struct Y
1101                 {
1102                   Y() { f(); count = 2; }
1103                   ~Y()
1104                   {
1105                     if (count != 2)
1106                       exit(1);
1107                     count = 3;
1108                   }
1109                 };
1110                 Y y;
1111                 int main() { return 0; }
1112             }
1113         }
1114     }]
1115 }
1116
1117
1118 # Return 1 if we're generating 32-bit code using default options, 0
1119 # otherwise.
1120
1121 proc check_effective_target_ilp32 { } {
1122     return [check_no_compiler_messages ilp32 object {
1123         int dummy[sizeof (int) == 4
1124                   && sizeof (void *) == 4
1125                   && sizeof (long) == 4 ? 1 : -1];
1126     }]
1127 }
1128
1129 # Return 1 if we're generating 32-bit or larger integers using default
1130 # options, 0 otherwise.
1131
1132 proc check_effective_target_int32plus { } {
1133     return [check_no_compiler_messages int32plus object {
1134         int dummy[sizeof (int) >= 4 ? 1 : -1];
1135     }]
1136 }
1137
1138 # Return 1 if we're generating 32-bit or larger pointers using default
1139 # options, 0 otherwise.
1140
1141 proc check_effective_target_ptr32plus { } {
1142     return [check_no_compiler_messages ptr32plus object {
1143         int dummy[sizeof (void *) >= 4 ? 1 : -1];
1144     }]
1145 }
1146
1147 # Return 1 if we support 32-bit or larger array and structure sizes
1148 # using default options, 0 otherwise.
1149
1150 proc check_effective_target_size32plus { } {
1151     return [check_no_compiler_messages size32plus object {
1152         char dummy[65537];
1153     }]
1154 }
1155
1156 # Returns 1 if we're generating 16-bit or smaller integers with the
1157 # default options, 0 otherwise.
1158
1159 proc check_effective_target_int16 { } {
1160     return [check_no_compiler_messages int16 object {
1161         int dummy[sizeof (int) < 4 ? 1 : -1];
1162     }]
1163 }
1164
1165 # Return 1 if we're generating 64-bit code using default options, 0
1166 # otherwise.
1167
1168 proc check_effective_target_lp64 { } {
1169     return [check_no_compiler_messages lp64 object {
1170         int dummy[sizeof (int) == 4
1171                   && sizeof (void *) == 8
1172                   && sizeof (long) == 8 ? 1 : -1];
1173     }]
1174 }
1175
1176 # Return 1 if we're generating 64-bit code using default llp64 options,
1177 # 0 otherwise.
1178
1179 proc check_effective_target_llp64 { } {
1180     return [check_no_compiler_messages llp64 object {
1181         int dummy[sizeof (int) == 4
1182                   && sizeof (void *) == 8
1183                   && sizeof (long long) == 8
1184                   && sizeof (long) == 4 ? 1 : -1];
1185     }]
1186 }
1187
1188 # Return 1 if the target supports long double larger than double,
1189 # 0 otherwise.
1190
1191 proc check_effective_target_large_long_double { } {
1192     return [check_no_compiler_messages large_long_double object {
1193         int dummy[sizeof(long double) > sizeof(double) ? 1 : -1];
1194     }]
1195 }
1196
1197 # Return 1 if the target supports compiling fixed-point,
1198 # 0 otherwise.
1199
1200 proc check_effective_target_fixed_point { } {
1201     return [check_no_compiler_messages fixed_point object {
1202         _Sat _Fract x; _Sat _Accum y;
1203     }]
1204 }
1205
1206 # Return 1 if the target supports compiling decimal floating point,
1207 # 0 otherwise.
1208
1209 proc check_effective_target_dfp_nocache { } {
1210     verbose "check_effective_target_dfp_nocache: compiling source" 2
1211     set ret [check_no_compiler_messages_nocache dfp object {
1212         _Decimal32 x; _Decimal64 y; _Decimal128 z;
1213     }]
1214     verbose "check_effective_target_dfp_nocache: returning $ret" 2
1215     return $ret
1216 }
1217
1218 proc check_effective_target_dfprt_nocache { } {
1219     return [check_runtime_nocache dfprt {
1220         _Decimal32 x = 1.2df; _Decimal64 y = 2.3dd; _Decimal128 z;
1221         int main () { z = x + y; return 0; }
1222     }]
1223 }
1224
1225 # Return 1 if the target supports compiling Decimal Floating Point,
1226 # 0 otherwise.
1227 #
1228 # This won't change for different subtargets so cache the result.
1229
1230 proc check_effective_target_dfp { } {
1231     return [check_cached_effective_target dfp {
1232         check_effective_target_dfp_nocache
1233     }]
1234 }
1235
1236 # Return 1 if the target supports linking and executing Decimal Floating
1237 # Point, # 0 otherwise.
1238 #
1239 # This won't change for different subtargets so cache the result.
1240
1241 proc check_effective_target_dfprt { } {
1242     return [check_cached_effective_target dfprt {
1243         check_effective_target_dfprt_nocache
1244     }]
1245 }
1246
1247 # Return 1 if the target needs a command line argument to enable a SIMD
1248 # instruction set.
1249
1250 proc check_effective_target_vect_cmdline_needed { } {
1251     global et_vect_cmdline_needed_saved
1252     global et_vect_cmdline_needed_target_name
1253
1254     if { ![info exists et_vect_cmdline_needed_target_name] } {
1255         set et_vect_cmdline_needed_target_name ""
1256     }
1257
1258     # If the target has changed since we set the cached value, clear it.
1259     set current_target [current_target_name]
1260     if { $current_target != $et_vect_cmdline_needed_target_name } {
1261         verbose "check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target'" 2
1262         set et_vect_cmdline_needed_target_name $current_target
1263         if { [info exists et_vect_cmdline_needed_saved] } {
1264             verbose "check_effective_target_vect_cmdline_needed: removing cached result" 2
1265             unset et_vect_cmdline_needed_saved
1266         }
1267     }
1268
1269     if [info exists et_vect_cmdline_needed_saved] {
1270         verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1271     } else {
1272         set et_vect_cmdline_needed_saved 1
1273         if { [istarget ia64-*-*]
1274              || (([istarget x86_64-*-*] || [istarget i?86-*-*])
1275                  && [check_effective_target_lp64])
1276              || ([istarget powerpc*-*-*]
1277                  && ([check_effective_target_powerpc_spe]
1278                      || [check_effective_target_powerpc_altivec]))
1279              || [istarget spu-*-*]
1280              || ([istarget arm*-*-*] && [check_effective_target_arm_neon]) } {
1281            set et_vect_cmdline_needed_saved 0
1282         }
1283     }
1284
1285     verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1286     return $et_vect_cmdline_needed_saved
1287 }
1288
1289 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
1290 #
1291 # This won't change for different subtargets so cache the result.
1292
1293 proc check_effective_target_vect_int { } {
1294     global et_vect_int_saved
1295
1296     if [info exists et_vect_int_saved] {
1297         verbose "check_effective_target_vect_int: using cached result" 2
1298     } else {
1299         set et_vect_int_saved 0
1300         if { [istarget i?86-*-*]
1301              || ([istarget powerpc*-*-*]
1302                   && ![istarget powerpc-*-linux*paired*])
1303               || [istarget spu-*-*]
1304               || [istarget x86_64-*-*]
1305               || [istarget sparc*-*-*]
1306               || [istarget alpha*-*-*]
1307               || [istarget ia64-*-*] 
1308               || [check_effective_target_arm32] } {
1309            set et_vect_int_saved 1
1310         }
1311     }
1312
1313     verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1314     return $et_vect_int_saved
1315 }
1316
1317 # Return 1 if the target supports int->float conversion 
1318 #
1319
1320 proc check_effective_target_vect_intfloat_cvt { } {
1321     global et_vect_intfloat_cvt_saved
1322
1323     if [info exists et_vect_intfloat_cvt_saved] {
1324         verbose "check_effective_target_vect_intfloat_cvt: using cached result" 2
1325     } else {
1326         set et_vect_intfloat_cvt_saved 0
1327         if { [istarget i?86-*-*]
1328               || ([istarget powerpc*-*-*]
1329                    && ![istarget powerpc-*-linux*paired*])
1330               || [istarget x86_64-*-*] } {
1331            set et_vect_intfloat_cvt_saved 1
1332         }
1333     }
1334
1335     verbose "check_effective_target_vect_intfloat_cvt: returning $et_vect_intfloat_cvt_saved" 2
1336     return $et_vect_intfloat_cvt_saved
1337 }
1338
1339
1340 # Return 1 if the target supports float->int conversion
1341 #
1342
1343 proc check_effective_target_vect_floatint_cvt { } {
1344     global et_vect_floatint_cvt_saved
1345
1346     if [info exists et_vect_floatint_cvt_saved] {
1347         verbose "check_effective_target_vect_floatint_cvt: using cached result" 2
1348     } else {
1349         set et_vect_floatint_cvt_saved 0
1350         if { [istarget i?86-*-*]
1351               || ([istarget powerpc*-*-*]
1352                    && ![istarget powerpc-*-linux*paired*])
1353               || [istarget x86_64-*-*] } {
1354            set et_vect_floatint_cvt_saved 1
1355         }
1356     }
1357
1358     verbose "check_effective_target_vect_floatint_cvt: returning $et_vect_floatint_cvt_saved" 2
1359     return $et_vect_floatint_cvt_saved
1360 }
1361
1362 # Return 1 is this is an arm target using 32-bit instructions
1363 proc check_effective_target_arm32 { } {
1364     return [check_no_compiler_messages arm32 assembly {
1365         #if !defined(__arm__) || (defined(__thumb__) && !defined(__thumb2__))
1366         #error FOO
1367         #endif
1368     }]
1369 }
1370
1371 # Return 1 if this is an ARM target supporting -mfpu=vfp
1372 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1373 # options.
1374
1375 proc check_effective_target_arm_vfp_ok { } {
1376     if { [check_effective_target_arm32] } {
1377         return [check_no_compiler_messages arm_vfp_ok object {
1378             int dummy;
1379         } "-mfpu=vfp -mfloat-abi=softfp"]
1380     } else {
1381         return 0
1382     }
1383 }
1384
1385 # Return 1 if this is an ARM target supporting -mfpu=neon
1386 # -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1387 # options.
1388
1389 proc check_effective_target_arm_neon_ok { } {
1390     if { [check_effective_target_arm32] } {
1391         return [check_no_compiler_messages arm_neon_ok object {
1392             int dummy;
1393         } "-mfpu=neon -mfloat-abi=softfp"]
1394     } else {
1395         return 0
1396     }
1397 }
1398
1399 # Return 1 is this is an ARM target where -mthumb causes Thumb-1 to be
1400 # used.
1401
1402 proc check_effective_target_arm_thumb1_ok { } {
1403     return [check_no_compiler_messages arm_thumb1_ok assembly {
1404         #if !defined(__arm__) || !defined(__thumb__) || defined(__thumb2__)
1405         #error FOO
1406         #endif
1407     } "-mthumb"]
1408 }
1409
1410 # Return 1 if the target supports executing NEON instructions, 0
1411 # otherwise.  Cache the result.
1412
1413 proc check_effective_target_arm_neon_hw { } {
1414     return [check_runtime arm_neon_hw_available {
1415         int
1416         main (void)
1417         {
1418           long long a = 0, b = 1;
1419           asm ("vorr %P0, %P1, %P2"
1420                : "=w" (a)
1421                : "0" (a), "w" (b));
1422           return (a != 1);
1423         }
1424     } "-mfpu=neon -mfloat-abi=softfp"]
1425 }
1426
1427 # Return 1 if this is a ARM target with NEON enabled.
1428
1429 proc check_effective_target_arm_neon { } {
1430     if { [check_effective_target_arm32] } {
1431         return [check_no_compiler_messages arm_neon object {
1432             #ifndef __ARM_NEON__
1433             #error not NEON
1434             #else
1435             int dummy;
1436             #endif
1437         }]
1438     } else {
1439         return 0
1440     }
1441 }
1442
1443 # Return 1 if this a Loongson-2E or -2F target using an ABI that supports
1444 # the Loongson vector modes.
1445
1446 proc check_effective_target_mips_loongson { } {
1447     return [check_no_compiler_messages loongson assembly {
1448         #if !defined(__mips_loongson_vector_rev)
1449         #error FOO
1450         #endif
1451     }]
1452 }
1453
1454 # Return 1 if this is a PowerPC target with floating-point registers.
1455
1456 proc check_effective_target_powerpc_fprs { } {
1457     if { [istarget powerpc*-*-*]
1458          || [istarget rs6000-*-*] } {
1459         return [check_no_compiler_messages powerpc_fprs object {
1460             #ifdef __NO_FPRS__
1461             #error no FPRs
1462             #else
1463             int dummy;
1464             #endif
1465         }]
1466     } else {
1467         return 0
1468     }
1469 }
1470
1471 # Return 1 if this is a PowerPC target with hardware double-precision
1472 # floating point.
1473
1474 proc check_effective_target_powerpc_hard_double { } {
1475     if { [istarget powerpc*-*-*]
1476          || [istarget rs6000-*-*] } {
1477         return [check_no_compiler_messages powerpc_hard_double object {
1478             #ifdef _SOFT_DOUBLE
1479             #error soft double
1480             #else
1481             int dummy;
1482             #endif
1483         }]
1484     } else {
1485         return 0
1486     }
1487 }
1488
1489 # Return 1 if this is a PowerPC target supporting -maltivec.
1490
1491 proc check_effective_target_powerpc_altivec_ok { } {
1492     if { ([istarget powerpc*-*-*]
1493          && ![istarget powerpc-*-linux*paired*])
1494          || [istarget rs6000-*-*] } {
1495         # AltiVec is not supported on AIX before 5.3.
1496         if { [istarget powerpc*-*-aix4*]
1497              || [istarget powerpc*-*-aix5.1*] 
1498              || [istarget powerpc*-*-aix5.2*] } {
1499             return 0
1500         }
1501         return [check_no_compiler_messages powerpc_altivec_ok object {
1502             int dummy;
1503         } "-maltivec"]
1504     } else {
1505         return 0
1506     }
1507 }
1508
1509 # Return 1 if this is a PowerPC target supporting -mcpu=cell.
1510
1511 proc check_effective_target_powerpc_ppu_ok { } {
1512     if [check_effective_target_powerpc_altivec_ok] {
1513         return [check_no_compiler_messages cell_asm_available object {
1514             int main (void) {
1515 #ifdef __MACH__
1516                 asm volatile ("lvlx v0,v0,v0");
1517 #else
1518                 asm volatile ("lvlx 0,0,0");
1519 #endif
1520                 return 0;
1521             }
1522         }]
1523     } else {
1524         return 0
1525     }
1526 }
1527
1528 # Return 1 if this is a PowerPC target that supports SPU.
1529
1530 proc check_effective_target_powerpc_spu { } {
1531     if [istarget powerpc*-*-linux*] {
1532         return [check_effective_target_powerpc_altivec_ok]
1533     } else {
1534         return 0
1535     }
1536 }
1537
1538 # Return 1 if this is a PowerPC target with SPE enabled.
1539
1540 proc check_effective_target_powerpc_spe { } {
1541     if { [istarget powerpc*-*-*] } {
1542         return [check_no_compiler_messages powerpc_spe object {
1543             #ifndef __SPE__
1544             #error not SPE
1545             #else
1546             int dummy;
1547             #endif
1548         }]
1549     } else {
1550         return 0
1551     }
1552 }
1553
1554 # Return 1 if this is a PowerPC target with Altivec enabled.
1555
1556 proc check_effective_target_powerpc_altivec { } {
1557     if { [istarget powerpc*-*-*] } {
1558         return [check_no_compiler_messages powerpc_altivec object {
1559             #ifndef __ALTIVEC__
1560             #error not Altivec
1561             #else
1562             int dummy;
1563             #endif
1564         }]
1565     } else {
1566         return 0
1567     }
1568 }
1569
1570 # Return 1 if this is a PowerPC 405 target.  The check includes options
1571 # specified by dg-options for this test, so don't cache the result.
1572
1573 proc check_effective_target_powerpc_405_nocache { } {
1574     if { [istarget powerpc*-*-*] || [istarget rs6000-*-*] } {
1575         return [check_no_compiler_messages_nocache powerpc_405 object {
1576             #ifdef __PPC405__
1577             int dummy;
1578             #else
1579             #error not a PPC405
1580             #endif
1581         } [current_compiler_flags]]
1582     } else {
1583         return 0
1584     }
1585 }
1586
1587 # Return 1 if this is a SPU target with a toolchain that
1588 # supports automatic overlay generation.
1589
1590 proc check_effective_target_spu_auto_overlay { } {
1591     if { [istarget spu*-*-elf*] } {
1592         return [check_no_compiler_messages spu_auto_overlay executable {
1593                 int main (void) { }
1594                 } "-Wl,--auto-overlay" ]
1595     } else {
1596         return 0
1597     }
1598 }
1599
1600 # The VxWorks SPARC simulator accepts only EM_SPARC executables and
1601 # chokes on EM_SPARC32PLUS or EM_SPARCV9 executables.  Return 1 if the
1602 # test environment appears to run executables on such a simulator.
1603
1604 proc check_effective_target_ultrasparc_hw { } {
1605     return [check_runtime ultrasparc_hw {
1606         int main() { return 0; }
1607     } "-mcpu=ultrasparc"]
1608 }
1609
1610 # Return 1 if the target supports hardware vector shift operation.
1611
1612 proc check_effective_target_vect_shift { } {
1613     global et_vect_shift_saved
1614
1615     if [info exists et_vect_shift_saved] {
1616         verbose "check_effective_target_vect_shift: using cached result" 2
1617     } else {
1618         set et_vect_shift_saved 0
1619         if { ([istarget powerpc*-*-*]
1620              && ![istarget powerpc-*-linux*paired*])
1621              || [istarget ia64-*-*]
1622              || [istarget i?86-*-*]
1623              || [istarget x86_64-*-*]
1624              || [check_effective_target_arm32] } {
1625            set et_vect_shift_saved 1
1626         }
1627     }
1628
1629     verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1630     return $et_vect_shift_saved
1631 }
1632
1633 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
1634 #
1635 # This can change for different subtargets so do not cache the result.
1636
1637 proc check_effective_target_vect_long { } {
1638     if { [istarget i?86-*-*]
1639          || (([istarget powerpc*-*-*] 
1640               && ![istarget powerpc-*-linux*paired*]) 
1641               && [check_effective_target_ilp32])
1642          || [istarget x86_64-*-*]
1643          || [check_effective_target_arm32]
1644          || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1645         set answer 1
1646     } else {
1647         set answer 0
1648     }
1649
1650     verbose "check_effective_target_vect_long: returning $answer" 2
1651     return $answer
1652 }
1653
1654 # Return 1 if the target supports hardware vectors of float, 0 otherwise.
1655 #
1656 # This won't change for different subtargets so cache the result.
1657
1658 proc check_effective_target_vect_float { } {
1659     global et_vect_float_saved
1660
1661     if [info exists et_vect_float_saved] {
1662         verbose "check_effective_target_vect_float: using cached result" 2
1663     } else {
1664         set et_vect_float_saved 0
1665         if { [istarget i?86-*-*]
1666               || [istarget powerpc*-*-*]
1667               || [istarget spu-*-*]
1668               || [istarget mipsisa64*-*-*]
1669               || [istarget x86_64-*-*]
1670               || [istarget ia64-*-*]
1671               || [check_effective_target_arm32] } {
1672            set et_vect_float_saved 1
1673         }
1674     }
1675
1676     verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1677     return $et_vect_float_saved
1678 }
1679
1680 # Return 1 if the target supports hardware vectors of double, 0 otherwise.
1681 #
1682 # This won't change for different subtargets so cache the result.
1683
1684 proc check_effective_target_vect_double { } {
1685     global et_vect_double_saved
1686
1687     if [info exists et_vect_double_saved] {
1688         verbose "check_effective_target_vect_double: using cached result" 2
1689     } else {
1690         set et_vect_double_saved 0
1691         if { [istarget i?86-*-*]
1692               || [istarget x86_64-*-*] 
1693               || [istarget spu-*-*] } {
1694            set et_vect_double_saved 1
1695         }
1696     }
1697
1698     verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1699     return $et_vect_double_saved
1700 }
1701
1702 # Return 1 if the target supports hardware vectors of long long, 0 otherwise.
1703 #
1704 # This won't change for different subtargets so cache the result.
1705
1706 proc check_effective_target_vect_long_long { } {
1707     global et_vect_long_long_saved
1708
1709     if [info exists et_vect_long_long_saved] {
1710         verbose "check_effective_target_vect_long_long: using cached result" 2
1711     } else {
1712         set et_vect_long_long_saved 0
1713         if { [istarget i?86-*-*]
1714               || [istarget x86_64-*-*] } {
1715            set et_vect_long_long_saved 1
1716         }
1717     }
1718
1719     verbose "check_effective_target_vect_long_long: returning $et_vect_long_long_saved" 2
1720     return $et_vect_long_long_saved
1721 }
1722
1723
1724 # Return 1 if the target plus current options does not support a vector
1725 # max instruction on "int", 0 otherwise.
1726 #
1727 # This won't change for different subtargets so cache the result.
1728
1729 proc check_effective_target_vect_no_int_max { } {
1730     global et_vect_no_int_max_saved
1731
1732     if [info exists et_vect_no_int_max_saved] {
1733         verbose "check_effective_target_vect_no_int_max: using cached result" 2
1734     } else {
1735         set et_vect_no_int_max_saved 0
1736         if { [istarget sparc*-*-*]
1737              || [istarget spu-*-*]
1738              || [istarget alpha*-*-*] } {
1739             set et_vect_no_int_max_saved 1
1740         }
1741     }
1742     verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1743     return $et_vect_no_int_max_saved
1744 }
1745
1746 # Return 1 if the target plus current options does not support a vector
1747 # add instruction on "int", 0 otherwise.
1748 #
1749 # This won't change for different subtargets so cache the result.
1750
1751 proc check_effective_target_vect_no_int_add { } {
1752     global et_vect_no_int_add_saved
1753
1754     if [info exists et_vect_no_int_add_saved] {
1755         verbose "check_effective_target_vect_no_int_add: using cached result" 2
1756     } else {
1757         set et_vect_no_int_add_saved 0
1758         # Alpha only supports vector add on V8QI and V4HI.
1759         if { [istarget alpha*-*-*] } {
1760             set et_vect_no_int_add_saved 1
1761         }
1762     }
1763     verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1764     return $et_vect_no_int_add_saved
1765 }
1766
1767 # Return 1 if the target plus current options does not support vector
1768 # bitwise instructions, 0 otherwise.
1769 #
1770 # This won't change for different subtargets so cache the result.
1771
1772 proc check_effective_target_vect_no_bitwise { } {
1773     global et_vect_no_bitwise_saved
1774
1775     if [info exists et_vect_no_bitwise_saved] {
1776         verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1777     } else {
1778         set et_vect_no_bitwise_saved 0
1779     }
1780     verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1781     return $et_vect_no_bitwise_saved
1782 }
1783
1784 # Return 1 if the target plus current options supports vector permutation,
1785 # 0 otherwise.
1786 #
1787 # This won't change for different subtargets so cache the result.
1788
1789 proc check_effective_target_vect_perm { } {
1790     global et_vect_perm
1791
1792     if [info exists et_vect_perm_saved] {
1793         verbose "check_effective_target_vect_perm: using cached result" 2
1794     } else {
1795         set et_vect_perm_saved 0
1796         if { [istarget powerpc*-*-*]
1797              || [istarget spu-*-*] } {
1798             set et_vect_perm_saved 1
1799         }
1800     }
1801     verbose "check_effective_target_vect_perm: returning $et_vect_perm_saved" 2
1802     return $et_vect_perm_saved
1803 }
1804
1805
1806 # Return 1 if the target plus current options supports a vector
1807 # widening summation of *short* args into *int* result, 0 otherwise.
1808 # A target can also support this widening summation if it can support
1809 # promotion (unpacking) from shorts to ints.
1810 #
1811 # This won't change for different subtargets so cache the result.
1812                                                                                                 
1813 proc check_effective_target_vect_widen_sum_hi_to_si { } {
1814     global et_vect_widen_sum_hi_to_si
1815
1816     if [info exists et_vect_widen_sum_hi_to_si_saved] {
1817         verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
1818     } else {
1819         set et_vect_widen_sum_hi_to_si_saved [check_effective_target_vect_unpack]
1820         if { [istarget powerpc*-*-*] 
1821              || [istarget ia64-*-*] } {
1822             set et_vect_widen_sum_hi_to_si_saved 1
1823         }
1824     }
1825     verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
1826     return $et_vect_widen_sum_hi_to_si_saved
1827 }
1828
1829 # Return 1 if the target plus current options supports a vector
1830 # widening summation of *char* args into *short* result, 0 otherwise.
1831 # A target can also support this widening summation if it can support
1832 # promotion (unpacking) from chars to shorts.
1833 #
1834 # This won't change for different subtargets so cache the result.
1835                                                                                                 
1836 proc check_effective_target_vect_widen_sum_qi_to_hi { } {
1837     global et_vect_widen_sum_qi_to_hi
1838
1839     if [info exists et_vect_widen_sum_qi_to_hi_saved] {
1840         verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
1841     } else {
1842         set et_vect_widen_sum_qi_to_hi_saved 0
1843         if { [check_effective_target_vect_unpack] 
1844              || [istarget ia64-*-*] } {
1845             set et_vect_widen_sum_qi_to_hi_saved 1
1846         }
1847     }
1848     verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
1849     return $et_vect_widen_sum_qi_to_hi_saved
1850 }
1851
1852 # Return 1 if the target plus current options supports a vector
1853 # widening summation of *char* args into *int* result, 0 otherwise.
1854 #
1855 # This won't change for different subtargets so cache the result.
1856                                                                                                 
1857 proc check_effective_target_vect_widen_sum_qi_to_si { } {
1858     global et_vect_widen_sum_qi_to_si
1859
1860     if [info exists et_vect_widen_sum_qi_to_si_saved] {
1861         verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
1862     } else {
1863         set et_vect_widen_sum_qi_to_si_saved 0
1864         if { [istarget powerpc*-*-*] } {
1865             set et_vect_widen_sum_qi_to_si_saved 1
1866         }
1867     }
1868     verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
1869     return $et_vect_widen_sum_qi_to_si_saved
1870 }
1871
1872 # Return 1 if the target plus current options supports a vector
1873 # widening multiplication of *char* args into *short* result, 0 otherwise.
1874 # A target can also support this widening multplication if it can support
1875 # promotion (unpacking) from chars to shorts, and vect_short_mult (non-widening
1876 # multiplication of shorts).
1877 #
1878 # This won't change for different subtargets so cache the result.
1879
1880
1881 proc check_effective_target_vect_widen_mult_qi_to_hi { } {
1882     global et_vect_widen_mult_qi_to_hi
1883
1884     if [info exists et_vect_widen_mult_qi_to_hi_saved] {
1885         verbose "check_effective_target_vect_widen_mult_qi_to_hi: using cached result" 2
1886     } else {
1887         if { [check_effective_target_vect_unpack]
1888              && [check_effective_target_vect_short_mult] } {
1889             set et_vect_widen_mult_qi_to_hi_saved 1
1890         } else {
1891             set et_vect_widen_mult_qi_to_hi_saved 0
1892         }
1893         if { [istarget powerpc*-*-*] } {
1894             set et_vect_widen_mult_qi_to_hi_saved 1
1895         }
1896     }
1897     verbose "check_effective_target_vect_widen_mult_qi_to_hi: returning $et_vect_widen_mult_qi_to_hi_saved" 2
1898     return $et_vect_widen_mult_qi_to_hi_saved
1899 }
1900
1901 # Return 1 if the target plus current options supports a vector
1902 # widening multiplication of *short* args into *int* result, 0 otherwise.
1903 # A target can also support this widening multplication if it can support
1904 # promotion (unpacking) from shorts to ints, and vect_int_mult (non-widening
1905 # multiplication of ints).
1906 #
1907 # This won't change for different subtargets so cache the result.
1908
1909
1910 proc check_effective_target_vect_widen_mult_hi_to_si { } {
1911     global et_vect_widen_mult_hi_to_si
1912
1913     if [info exists et_vect_widen_mult_hi_to_si_saved] {
1914         verbose "check_effective_target_vect_widen_mult_hi_to_si: using cached result" 2
1915     } else {
1916         if { [check_effective_target_vect_unpack]
1917              && [check_effective_target_vect_int_mult] } {
1918           set et_vect_widen_mult_hi_to_si_saved 1
1919         } else {
1920           set et_vect_widen_mult_hi_to_si_saved 0
1921         }
1922         if { [istarget powerpc*-*-*]
1923               || [istarget spu-*-*]
1924               || [istarget i?86-*-*]
1925               || [istarget x86_64-*-*] } {
1926             set et_vect_widen_mult_hi_to_si_saved 1
1927         }
1928     }
1929     verbose "check_effective_target_vect_widen_mult_hi_to_si: returning $et_vect_widen_mult_hi_to_si_saved" 2
1930     return $et_vect_widen_mult_hi_to_si_saved
1931 }
1932
1933 # Return 1 if the target plus current options supports a vector
1934 # dot-product of signed chars, 0 otherwise.
1935 #
1936 # This won't change for different subtargets so cache the result.
1937
1938 proc check_effective_target_vect_sdot_qi { } {
1939     global et_vect_sdot_qi
1940
1941     if [info exists et_vect_sdot_qi_saved] {
1942         verbose "check_effective_target_vect_sdot_qi: using cached result" 2
1943     } else {
1944         set et_vect_sdot_qi_saved 0
1945     }
1946     verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1947     return $et_vect_sdot_qi_saved
1948 }
1949
1950 # Return 1 if the target plus current options supports a vector
1951 # dot-product of unsigned chars, 0 otherwise.
1952 #
1953 # This won't change for different subtargets so cache the result.
1954
1955 proc check_effective_target_vect_udot_qi { } {
1956     global et_vect_udot_qi
1957
1958     if [info exists et_vect_udot_qi_saved] {
1959         verbose "check_effective_target_vect_udot_qi: using cached result" 2
1960     } else {
1961         set et_vect_udot_qi_saved 0
1962         if { [istarget powerpc*-*-*] } {
1963             set et_vect_udot_qi_saved 1
1964         }
1965     }
1966     verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1967     return $et_vect_udot_qi_saved
1968 }
1969
1970 # Return 1 if the target plus current options supports a vector
1971 # dot-product of signed shorts, 0 otherwise.
1972 #
1973 # This won't change for different subtargets so cache the result.
1974
1975 proc check_effective_target_vect_sdot_hi { } {
1976     global et_vect_sdot_hi
1977
1978     if [info exists et_vect_sdot_hi_saved] {
1979         verbose "check_effective_target_vect_sdot_hi: using cached result" 2
1980     } else {
1981         set et_vect_sdot_hi_saved 0
1982         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
1983              || [istarget i?86-*-*]
1984              || [istarget x86_64-*-*] } {
1985             set et_vect_sdot_hi_saved 1
1986         }
1987     }
1988     verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
1989     return $et_vect_sdot_hi_saved
1990 }
1991
1992 # Return 1 if the target plus current options supports a vector
1993 # dot-product of unsigned shorts, 0 otherwise.
1994 #
1995 # This won't change for different subtargets so cache the result.
1996
1997 proc check_effective_target_vect_udot_hi { } {
1998     global et_vect_udot_hi
1999
2000     if [info exists et_vect_udot_hi_saved] {
2001         verbose "check_effective_target_vect_udot_hi: using cached result" 2
2002     } else {
2003         set et_vect_udot_hi_saved 0
2004         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*]) } {
2005             set et_vect_udot_hi_saved 1
2006         }
2007     }
2008     verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
2009     return $et_vect_udot_hi_saved
2010 }
2011
2012
2013 # Return 1 if the target plus current options supports a vector
2014 # demotion (packing) of shorts (to chars) and ints (to shorts) 
2015 # using modulo arithmetic, 0 otherwise.
2016 #
2017 # This won't change for different subtargets so cache the result.
2018                                                                                 
2019 proc check_effective_target_vect_pack_trunc { } {
2020     global et_vect_pack_trunc
2021                                                                                 
2022     if [info exists et_vect_pack_trunc_saved] {
2023         verbose "check_effective_target_vect_pack_trunc: using cached result" 2
2024     } else {
2025         set et_vect_pack_trunc_saved 0
2026         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
2027              || [istarget i?86-*-*]
2028              || [istarget x86_64-*-*]
2029              || [istarget spu-*-*] } {
2030             set et_vect_pack_trunc_saved 1
2031         }
2032     }
2033     verbose "check_effective_target_vect_pack_trunc: returning $et_vect_pack_trunc_saved" 2
2034     return $et_vect_pack_trunc_saved
2035 }
2036
2037 # Return 1 if the target plus current options supports a vector
2038 # promotion (unpacking) of chars (to shorts) and shorts (to ints), 0 otherwise.
2039 #
2040 # This won't change for different subtargets so cache the result.
2041                                    
2042 proc check_effective_target_vect_unpack { } {
2043     global et_vect_unpack
2044                                         
2045     if [info exists et_vect_unpack_saved] {
2046         verbose "check_effective_target_vect_unpack: using cached result" 2
2047     } else {
2048         set et_vect_unpack_saved 0
2049         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*paired*])
2050              || [istarget i?86-*-*]
2051              || [istarget x86_64-*-*] 
2052              || [istarget spu-*-*] } {
2053             set et_vect_unpack_saved 1
2054         }
2055     }
2056     verbose "check_effective_target_vect_unpack: returning $et_vect_unpack_saved" 2  
2057     return $et_vect_unpack_saved
2058 }
2059
2060 # Return 1 if the target plus current options does not guarantee
2061 # that its STACK_BOUNDARY is >= the reguired vector alignment.
2062 #
2063 # This won't change for different subtargets so cache the result.
2064
2065 proc check_effective_target_unaligned_stack { } {
2066     global et_unaligned_stack_saved
2067
2068     if [info exists et_unaligned_stack_saved] {
2069         verbose "check_effective_target_unaligned_stack: using cached result" 2
2070     } else {
2071         set et_unaligned_stack_saved 0
2072     }
2073     verbose "check_effective_target_unaligned_stack: returning $et_unaligned_stack_saved" 2
2074     return $et_unaligned_stack_saved
2075 }
2076
2077 # Return 1 if the target plus current options does not support a vector
2078 # alignment mechanism, 0 otherwise.
2079 #
2080 # This won't change for different subtargets so cache the result.
2081
2082 proc check_effective_target_vect_no_align { } {
2083     global et_vect_no_align_saved
2084
2085     if [info exists et_vect_no_align_saved] {
2086         verbose "check_effective_target_vect_no_align: using cached result" 2
2087     } else {
2088         set et_vect_no_align_saved 0
2089         if { [istarget mipsisa64*-*-*]
2090              || [istarget sparc*-*-*]
2091              || [istarget ia64-*-*]
2092              || [check_effective_target_arm32] } { 
2093             set et_vect_no_align_saved 1
2094         }
2095     }
2096     verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
2097     return $et_vect_no_align_saved
2098 }
2099
2100 # Return 1 if arrays are aligned to the vector alignment
2101 # boundary, 0 otherwise.
2102 #
2103 # This won't change for different subtargets so cache the result.
2104
2105 proc check_effective_target_vect_aligned_arrays { } {
2106     global et_vect_aligned_arrays
2107
2108     if [info exists et_vect_aligned_arrays_saved] {
2109         verbose "check_effective_target_vect_aligned_arrays: using cached result" 2
2110     } else {
2111         set et_vect_aligned_arrays_saved 0
2112         if { (([istarget x86_64-*-*]
2113               || [istarget i?86-*-*]) && [is-effective-target lp64])
2114               || [istarget spu-*-*] } {
2115             set et_vect_aligned_arrays_saved 1
2116         }
2117     }
2118     verbose "check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
2119     return $et_vect_aligned_arrays_saved
2120 }
2121
2122 # Return 1 if types of size 32 bit or less are naturally aligned
2123 # (aligned to their type-size), 0 otherwise.
2124 #
2125 # This won't change for different subtargets so cache the result.
2126
2127 proc check_effective_target_natural_alignment_32 { } {
2128     global et_natural_alignment_32
2129
2130     if [info exists et_natural_alignment_32_saved] {
2131         verbose "check_effective_target_natural_alignment_32: using cached result" 2
2132     } else {
2133         # FIXME: 32bit powerpc: guaranteed only if MASK_ALIGN_NATURAL/POWER.
2134         set et_natural_alignment_32_saved 1
2135         if { ([istarget *-*-darwin*] && [is-effective-target lp64]) } {
2136             set et_natural_alignment_32_saved 0
2137         }
2138     }
2139     verbose "check_effective_target_natural_alignment_32: returning $et_natural_alignment_32_saved" 2
2140     return $et_natural_alignment_32_saved
2141 }
2142
2143 # Return 1 if types of size 64 bit or less are naturally aligned (aligned to their
2144 # type-size), 0 otherwise.
2145 #
2146 # This won't change for different subtargets so cache the result.
2147
2148 proc check_effective_target_natural_alignment_64 { } {
2149     global et_natural_alignment_64
2150
2151     if [info exists et_natural_alignment_64_saved] {
2152         verbose "check_effective_target_natural_alignment_64: using cached result" 2
2153     } else {
2154         set et_natural_alignment_64_saved 0
2155         if { ([is-effective-target lp64] && ![istarget *-*-darwin*])
2156              || [istarget spu-*-*] } {
2157             set et_natural_alignment_64_saved 1
2158         }
2159     }
2160     verbose "check_effective_target_natural_alignment_64: returning $et_natural_alignment_64_saved" 2
2161     return $et_natural_alignment_64_saved
2162 }
2163
2164 # Return 1 if vector alignment (for types of size 32 bit or less) is reachable, 0 otherwise.
2165 #
2166 # This won't change for different subtargets so cache the result.
2167
2168 proc check_effective_target_vector_alignment_reachable { } {
2169     global et_vector_alignment_reachable
2170
2171     if [info exists et_vector_alignment_reachable_saved] {
2172         verbose "check_effective_target_vector_alignment_reachable: using cached result" 2
2173     } else {
2174         if { [check_effective_target_vect_aligned_arrays]
2175              || [check_effective_target_natural_alignment_32] } {
2176             set et_vector_alignment_reachable_saved 1
2177         } else {
2178             set et_vector_alignment_reachable_saved 0
2179         }
2180     }
2181     verbose "check_effective_target_vector_alignment_reachable: returning $et_vector_alignment_reachable_saved" 2
2182     return $et_vector_alignment_reachable_saved
2183 }
2184
2185 # Return 1 if vector alignment for 64 bit is reachable, 0 otherwise.
2186 #
2187 # This won't change for different subtargets so cache the result.
2188
2189 proc check_effective_target_vector_alignment_reachable_for_64bit { } {
2190     global et_vector_alignment_reachable_for_64bit
2191
2192     if [info exists et_vector_alignment_reachable_for_64bit_saved] {
2193         verbose "check_effective_target_vector_alignment_reachable_for_64bit: using cached result" 2
2194     } else {
2195         if { [check_effective_target_vect_aligned_arrays] 
2196              || [check_effective_target_natural_alignment_64] } {
2197             set et_vector_alignment_reachable_for_64bit_saved 1
2198         } else {
2199             set et_vector_alignment_reachable_for_64bit_saved 0
2200         }
2201     }
2202     verbose "check_effective_target_vector_alignment_reachable_for_64bit: returning $et_vector_alignment_reachable_for_64bit_saved" 2
2203     return $et_vector_alignment_reachable_for_64bit_saved
2204 }
2205
2206 # Return 1 if the target supports vector conditional operations, 0 otherwise.
2207
2208 proc check_effective_target_vect_condition { } {
2209     global et_vect_cond_saved
2210
2211     if [info exists et_vect_cond_saved] {
2212         verbose "check_effective_target_vect_cond: using cached result" 2
2213     } else {
2214         set et_vect_cond_saved 0
2215         if { [istarget powerpc*-*-*]
2216              || [istarget ia64-*-*]
2217              || [istarget i?86-*-*]
2218              || [istarget spu-*-*]
2219              || [istarget x86_64-*-*] } {
2220            set et_vect_cond_saved 1
2221         }
2222     }
2223
2224     verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
2225     return $et_vect_cond_saved
2226 }
2227
2228 # Return 1 if the target supports vector char multiplication, 0 otherwise.
2229
2230 proc check_effective_target_vect_char_mult { } {
2231     global et_vect_char_mult_saved
2232
2233     if [info exists et_vect_char_mult_saved] {
2234         verbose "check_effective_target_vect_char_mult: using cached result" 2
2235     } else {
2236         set et_vect_char_mult_saved 0
2237         if { [istarget ia64-*-*]
2238              || [istarget i?86-*-*]
2239              || [istarget x86_64-*-*] } {
2240            set et_vect_char_mult_saved 1
2241         }
2242     }
2243
2244     verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
2245     return $et_vect_char_mult_saved
2246 }
2247
2248 # Return 1 if the target supports vector short multiplication, 0 otherwise.
2249
2250 proc check_effective_target_vect_short_mult { } {
2251     global et_vect_short_mult_saved
2252
2253     if [info exists et_vect_short_mult_saved] {
2254         verbose "check_effective_target_vect_short_mult: using cached result" 2
2255     } else {
2256         set et_vect_short_mult_saved 0
2257         if { [istarget ia64-*-*]
2258              || [istarget spu-*-*]
2259              || [istarget i?86-*-*]
2260              || [istarget x86_64-*-*] 
2261              || [istarget powerpc*-*-*] } {
2262            set et_vect_short_mult_saved 1
2263         }
2264     }
2265
2266     verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
2267     return $et_vect_short_mult_saved
2268 }
2269
2270 # Return 1 if the target supports vector int multiplication, 0 otherwise.
2271
2272 proc check_effective_target_vect_int_mult { } {
2273     global et_vect_int_mult_saved
2274
2275     if [info exists et_vect_int_mult_saved] {
2276         verbose "check_effective_target_vect_int_mult: using cached result" 2
2277     } else {
2278         set et_vect_int_mult_saved 0
2279         if { ([istarget powerpc*-*-*] && ![istarget powerpc-*-linux*paired*])
2280              || [istarget spu-*-*]
2281              || [istarget i?86-*-*]
2282              || [istarget x86_64-*-*]
2283              || [check_effective_target_arm32] } {
2284            set et_vect_int_mult_saved 1
2285         }
2286     }
2287
2288     verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
2289     return $et_vect_int_mult_saved
2290 }
2291
2292 # Return 1 if the target supports vector even/odd elements extraction, 0 otherwise.
2293
2294 proc check_effective_target_vect_extract_even_odd { } {
2295     global et_vect_extract_even_odd_saved
2296     
2297     if [info exists et_vect_extract_even_odd_saved] {
2298         verbose "check_effective_target_vect_extract_even_odd: using cached result" 2
2299     } else {
2300         set et_vect_extract_even_odd_saved 0 
2301         if { [istarget powerpc*-*-*]
2302              || [istarget spu-*-*] } {
2303            set et_vect_extract_even_odd_saved 1
2304         }
2305     }
2306
2307     verbose "check_effective_target_vect_extract_even_odd: returning $et_vect_extract_even_odd_saved" 2
2308     return $et_vect_extract_even_odd_saved
2309 }
2310
2311 # Return 1 if the target supports vector even/odd elements extraction of
2312 # vectors with SImode elements or larger, 0 otherwise.
2313
2314 proc check_effective_target_vect_extract_even_odd_wide { } {
2315     global et_vect_extract_even_odd_wide_saved
2316     
2317     if [info exists et_vect_extract_even_odd_wide_saved] {
2318         verbose "check_effective_target_vect_extract_even_odd_wide: using cached result" 2
2319     } else {
2320         set et_vect_extract_even_odd_wide_saved 0 
2321         if { [istarget powerpc*-*-*] 
2322              || [istarget i?86-*-*]
2323              || [istarget x86_64-*-*]
2324              || [istarget spu-*-*] } {
2325            set et_vect_extract_even_odd_wide_saved 1
2326         }
2327     }
2328
2329     verbose "check_effective_target_vect_extract_even_wide_odd: returning $et_vect_extract_even_odd_wide_saved" 2
2330     return $et_vect_extract_even_odd_wide_saved
2331 }
2332
2333 # Return 1 if the target supports vector interleaving, 0 otherwise.
2334
2335 proc check_effective_target_vect_interleave { } {
2336     global et_vect_interleave_saved
2337     
2338     if [info exists et_vect_interleave_saved] {
2339         verbose "check_effective_target_vect_interleave: using cached result" 2
2340     } else {
2341         set et_vect_interleave_saved 0
2342         if { [istarget powerpc*-*-*]
2343              || [istarget i?86-*-*]
2344              || [istarget x86_64-*-*]
2345              || [istarget spu-*-*] } {
2346            set et_vect_interleave_saved 1
2347         }
2348     }
2349
2350     verbose "check_effective_target_vect_interleave: returning $et_vect_interleave_saved" 2
2351     return $et_vect_interleave_saved
2352 }
2353
2354 # Return 1 if the target supports vector interleaving and extract even/odd, 0 otherwise.
2355 proc check_effective_target_vect_strided { } {
2356     global et_vect_strided_saved
2357
2358     if [info exists et_vect_strided_saved] {
2359         verbose "check_effective_target_vect_strided: using cached result" 2
2360     } else {
2361         set et_vect_strided_saved 0
2362         if { [check_effective_target_vect_interleave]
2363              && [check_effective_target_vect_extract_even_odd] } {
2364            set et_vect_strided_saved 1
2365         }
2366     }
2367
2368     verbose "check_effective_target_vect_strided: returning $et_vect_strided_saved" 2
2369     return $et_vect_strided_saved
2370 }
2371
2372 # Return 1 if the target supports vector interleaving and extract even/odd
2373 # for wide element types, 0 otherwise.
2374 proc check_effective_target_vect_strided_wide { } {
2375     global et_vect_strided_wide_saved
2376
2377     if [info exists et_vect_strided_wide_saved] {
2378         verbose "check_effective_target_vect_strided_wide: using cached result" 2
2379     } else {
2380         set et_vect_strided_wide_saved 0
2381         if { [check_effective_target_vect_interleave]
2382              && [check_effective_target_vect_extract_even_odd_wide] } {
2383            set et_vect_strided_wide_saved 1
2384         }
2385     }
2386
2387     verbose "check_effective_target_vect_strided_wide: returning $et_vect_strided_wide_saved" 2
2388     return $et_vect_strided_wide_saved
2389 }
2390
2391 # Return 1 if the target supports section-anchors
2392
2393 proc check_effective_target_section_anchors { } {
2394     global et_section_anchors_saved
2395
2396     if [info exists et_section_anchors_saved] {
2397         verbose "check_effective_target_section_anchors: using cached result" 2
2398     } else {
2399         set et_section_anchors_saved 0
2400         if { [istarget powerpc*-*-*] } {
2401            set et_section_anchors_saved 1
2402         }
2403     }
2404
2405     verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
2406     return $et_section_anchors_saved
2407 }
2408
2409 # Return 1 if the target supports atomic operations on "int" and "long".
2410
2411 proc check_effective_target_sync_int_long { } {
2412     global et_sync_int_long_saved
2413
2414     if [info exists et_sync_int_long_saved] {
2415         verbose "check_effective_target_sync_int_long: using cached result" 2
2416     } else {
2417         set et_sync_int_long_saved 0
2418 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2419 # load-reserved/store-conditional instructions.
2420         if { [istarget ia64-*-*]
2421              || [istarget i?86-*-*]
2422              || [istarget x86_64-*-*]
2423              || [istarget alpha*-*-*] 
2424              || [istarget s390*-*-*] 
2425              || [istarget powerpc*-*-*]
2426              || [istarget sparc64-*-*]
2427              || [istarget sparcv9-*-*]
2428              || [istarget mips*-*-*] } {
2429            set et_sync_int_long_saved 1
2430         }
2431     }
2432
2433     verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
2434     return $et_sync_int_long_saved
2435 }
2436
2437 # Return 1 if the target supports atomic operations on "char" and "short".
2438
2439 proc check_effective_target_sync_char_short { } {
2440     global et_sync_char_short_saved
2441
2442     if [info exists et_sync_char_short_saved] {
2443         verbose "check_effective_target_sync_char_short: using cached result" 2
2444     } else {
2445         set et_sync_char_short_saved 0
2446 # This is intentionally powerpc but not rs6000, rs6000 doesn't have the
2447 # load-reserved/store-conditional instructions.
2448         if { [istarget ia64-*-*]
2449              || [istarget i?86-*-*]
2450              || [istarget x86_64-*-*]
2451              || [istarget alpha*-*-*] 
2452              || [istarget s390*-*-*] 
2453              || [istarget powerpc*-*-*]
2454              || [istarget sparc64-*-*]
2455              || [istarget sparcv9-*-*]
2456              || [istarget mips*-*-*] } {
2457            set et_sync_char_short_saved 1
2458         }
2459     }
2460
2461     verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
2462     return $et_sync_char_short_saved
2463 }
2464
2465 # Return 1 if the target uses a ColdFire FPU.
2466
2467 proc check_effective_target_coldfire_fpu { } {
2468     return [check_no_compiler_messages coldfire_fpu assembly {
2469         #ifndef __mcffpu__
2470         #error FOO
2471         #endif
2472     }]
2473 }
2474
2475 # Return true if this is a uClibc target.
2476
2477 proc check_effective_target_uclibc {} {
2478     return [check_no_compiler_messages uclibc object {
2479         #include <features.h>
2480         #if !defined (__UCLIBC__)
2481         #error FOO
2482         #endif
2483     }]
2484 }
2485
2486 # Return true if this is a uclibc target and if the uclibc feature
2487 # described by __$feature__ is not present.
2488
2489 proc check_missing_uclibc_feature {feature} {
2490     return [check_no_compiler_messages $feature object "
2491         #include <features.h>
2492         #if !defined (__UCLIBC) || defined (__${feature}__)
2493         #error FOO
2494         #endif
2495     "]
2496 }
2497
2498 # Return true if this is a Newlib target.
2499
2500 proc check_effective_target_newlib {} {
2501     return [check_no_compiler_messages newlib object {
2502         #include <newlib.h>
2503     }]
2504 }
2505
2506 # Return 1 if
2507 #   (a) an error of a few ULP is expected in string to floating-point
2508 #       conversion functions; and
2509 #   (b) overflow is not always detected correctly by those functions.
2510
2511 proc check_effective_target_lax_strtofp {} {
2512     # By default, assume that all uClibc targets suffer from this.
2513     return [check_effective_target_uclibc]
2514 }
2515
2516 # Return 1 if this is a target for which wcsftime is a dummy
2517 # function that always returns 0.
2518
2519 proc check_effective_target_dummy_wcsftime {} {
2520     # By default, assume that all uClibc targets suffer from this.
2521     return [check_effective_target_uclibc]
2522 }
2523
2524 # Return 1 if constructors with initialization priority arguments are
2525 # supposed on this target.
2526
2527 proc check_effective_target_init_priority {} {
2528     return [check_no_compiler_messages init_priority assembly "
2529         void f() __attribute__((constructor (1000)));
2530         void f() \{\}
2531     "]
2532 }
2533
2534 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
2535 # This can be used with any check_* proc that takes no argument and
2536 # returns only 1 or 0.  It could be used with check_* procs that take
2537 # arguments with keywords that pass particular arguments.
2538
2539 proc is-effective-target { arg } {
2540     set selected 0
2541     if { [info procs check_effective_target_${arg}] != [list] } {
2542         set selected [check_effective_target_${arg}]
2543     } else {
2544         switch $arg {
2545           "vmx_hw"         { set selected [check_vmx_hw_available] }
2546           "named_sections" { set selected [check_named_sections_available] }
2547           "gc_sections"    { set selected [check_gc_sections_available] }
2548           "cxa_atexit"     { set selected [check_cxa_atexit_available] }
2549           default          { error "unknown effective target keyword `$arg'" }
2550         }
2551     }
2552     verbose "is-effective-target: $arg $selected" 2
2553     return $selected
2554 }
2555
2556 # Return 1 if the argument is an effective-target keyword, 0 otherwise.
2557
2558 proc is-effective-target-keyword { arg } {
2559     if { [info procs check_effective_target_${arg}] != [list] } {
2560         return 1
2561     } else {
2562         # These have different names for their check_* procs.
2563         switch $arg {
2564           "vmx_hw"         { return 1 }
2565           "named_sections" { return 1 }
2566           "gc_sections"    { return 1 }
2567           "cxa_atexit"     { return 1 }
2568           default          { return 0 }
2569         }
2570     }
2571 }
2572
2573 # Return 1 if target default to short enums
2574
2575 proc check_effective_target_short_enums { } {
2576     return [check_no_compiler_messages short_enums assembly {
2577         enum foo { bar };
2578         int s[sizeof (enum foo) == 1 ? 1 : -1];
2579     }]
2580 }
2581
2582 # Return 1 if target supports merging string constants at link time.
2583
2584 proc check_effective_target_string_merging { } {
2585     return [check_no_messages_and_pattern string_merging \
2586                 "rodata\\.str" assembly {
2587                     const char *var = "String";
2588                 } {-O2}]
2589 }
2590
2591 # Return 1 if target has the basic signed and unsigned types in
2592 # <stdint.h>, 0 otherwise.
2593
2594 proc check_effective_target_stdint_types { } {
2595     return [check_no_compiler_messages stdint_types assembly {
2596         #include <stdint.h>
2597         int8_t a; int16_t b; int32_t c; int64_t d;
2598         uint8_t e; uint16_t f; uint32_t g; uint64_t h;
2599     }]
2600 }
2601
2602 # Return 1 if programs are intended to be run on a simulator
2603 # (i.e. slowly) rather than hardware (i.e. fast).
2604
2605 proc check_effective_target_simulator { } {
2606
2607     # All "src/sim" simulators set this one.
2608     if [board_info target exists is_simulator] {
2609         return [board_info target is_simulator]
2610     }
2611
2612     # The "sid" simulators don't set that one, but at least they set
2613     # this one.
2614     if [board_info target exists slow_simulator] {
2615         return [board_info target slow_simulator]
2616     }
2617
2618     return 0
2619 }
2620
2621 # Return 1 if the target is a VxWorks kernel.
2622
2623 proc check_effective_target_vxworks_kernel { } {
2624     return [check_no_compiler_messages vxworks_kernel assembly {
2625         #if !defined __vxworks || defined __RTP__
2626         #error NO
2627         #endif
2628     }]
2629 }
2630
2631 # Return 1 if the target is a VxWorks RTP.
2632
2633 proc check_effective_target_vxworks_rtp { } {
2634     return [check_no_compiler_messages vxworks_rtp assembly {
2635         #if !defined __vxworks || !defined __RTP__
2636         #error NO
2637         #endif
2638     }]
2639 }
2640
2641 # Return 1 if the target is expected to provide wide character support.
2642
2643 proc check_effective_target_wchar { } {
2644     if {[check_missing_uclibc_feature UCLIBC_HAS_WCHAR]} {
2645         return 0
2646     }
2647     return [check_no_compiler_messages wchar assembly {
2648         #include <wchar.h>
2649     }]
2650 }
2651
2652 # Return 1 if the target has <pthread.h>.
2653
2654 proc check_effective_target_pthread_h { } {
2655     return [check_no_compiler_messages pthread_h assembly {
2656         #include <pthread.h>
2657     }]
2658 }
2659
2660 # Return 1 if the target can truncate a file from a file-descriptor,
2661 # as used by libgfortran/io/unix.c:fd_truncate; i.e. ftruncate or
2662 # chsize.  We test for a trivially functional truncation; no stubs.
2663 # As libgfortran uses _FILE_OFFSET_BITS 64, we do too; it'll cause a
2664 # different function to be used.
2665
2666 proc check_effective_target_fd_truncate { } {
2667     set prog {
2668         #define _FILE_OFFSET_BITS 64
2669         #include <unistd.h>
2670         #include <stdio.h>
2671         #include <stdlib.h>
2672         int main ()
2673         {
2674           FILE *f = fopen ("tst.tmp", "wb");
2675           int fd;
2676           const char t[] = "test writing more than ten characters";
2677           char s[11];
2678           fd =  fileno (f);
2679           write (fd, t, sizeof (t) - 1);
2680           lseek (fd, 0, 0);
2681           if (ftruncate (fd, 10) != 0)
2682             exit (1);
2683           close (fd);
2684           f = fopen ("tst.tmp", "rb");
2685           if (fread (s, 1, sizeof (s), f) != 10 || strncmp (s, t, 10) != 0)
2686             exit (1);
2687           exit (0);
2688         }
2689     }
2690
2691     if { [check_runtime ftruncate $prog] } {
2692       return 1;
2693     }
2694
2695     regsub "ftruncate" $prog "chsize" prog
2696     return [check_runtime chsize $prog]
2697 }
2698
2699 # Add to FLAGS all the target-specific flags needed to access the c99 runtime.
2700
2701 proc add_options_for_c99_runtime { flags } {
2702     if { [istarget *-*-solaris2*] } {
2703         return "$flags -std=c99"
2704     }
2705     if { [istarget powerpc-*-darwin*] } {
2706         return "$flags -mmacosx-version-min=10.3"
2707     }
2708     return $flags
2709 }
2710
2711 # Return 1 if the target provides a full C99 runtime.
2712
2713 proc check_effective_target_c99_runtime { } {
2714     return [check_cached_effective_target c99_runtime {
2715         global srcdir
2716
2717         set file [open "$srcdir/gcc.dg/builtins-config.h"]
2718         set contents [read $file]
2719         close $file
2720         append contents {
2721             #ifndef HAVE_C99_RUNTIME
2722             #error FOO
2723             #endif
2724         }
2725         check_no_compiler_messages_nocache c99_runtime assembly \
2726             $contents [add_options_for_c99_runtime ""]
2727     }]
2728 }
2729
2730 # Return 1 if  target wchar_t is at least 4 bytes.
2731
2732 proc check_effective_target_4byte_wchar_t { } {
2733     return [check_no_compiler_messages 4byte_wchar_t object {
2734         int dummy[sizeof (__WCHAR_TYPE__) >= 4 ? 1 : -1];
2735     }]
2736 }
2737
2738 # Return 1 if the target supports automatic stack alignment.
2739
2740 proc check_effective_target_automatic_stack_alignment  { } {
2741     if { [istarget i?86*-*-*]
2742          || [istarget x86_64-*-*] } then {
2743         return 1
2744     } else {
2745         return 0
2746     }
2747 }
2748
2749 # Return 1 if avx instructions can be compiled.
2750
2751 proc check_effective_target_avx { } {
2752     return [check_no_compiler_messages avx object {
2753         void _mm256_zeroall (void)
2754         {
2755            __builtin_ia32_vzeroall ();
2756         }
2757     } "-O2 -mavx" ]
2758 }
2759
2760 # Return 1 if C wchar_t type is compatible with char16_t.
2761
2762 proc check_effective_target_wchar_t_char16_t_compatible { } {
2763     return [check_no_compiler_messages wchar_t_char16_t object {
2764         __WCHAR_TYPE__ wc;
2765         __CHAR16_TYPE__ *p16 = &wc;
2766         char t[(((__CHAR16_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
2767     }]
2768 }
2769
2770 # Return 1 if C wchar_t type is compatible with char32_t.
2771
2772 proc check_effective_target_wchar_t_char32_t_compatible { } {
2773     return [check_no_compiler_messages wchar_t_char32_t object {
2774         __WCHAR_TYPE__ wc;
2775         __CHAR32_TYPE__ *p32 = &wc;
2776         char t[(((__CHAR32_TYPE__) -1) < 0 == ((__WCHAR_TYPE__) -1) < 0) ? 1 : -1];
2777     }]
2778 }
2779
2780 # Return 1 if pow10 function exists.
2781
2782 proc check_effective_target_pow10 { } {
2783     return [check_runtime pow10 {
2784         #include <math.h>
2785         int main () {
2786         double x;
2787         x = pow10 (1);
2788         return 0;
2789         }
2790     } "-lm" ]
2791 }
2792
2793 # Return 1 if current options generate DFP instructions, 0 otherwise.
2794
2795 proc check_effective_target_hard_dfp {} {
2796     return [check_no_messages_and_pattern hard_dfp "!adddd3" assembly {
2797         _Decimal64 x, y, z;
2798         void foo (void) { z = x + y; }
2799     }]
2800 }