OSDN Git Service

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