OSDN Git Service

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