OSDN Git Service

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