gcc/testsuite/lib/target-supports.exp

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