OSDN Git Service

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