OSDN Git Service

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