X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftestsuite%2Flib%2Ftarget-supports.exp;h=68b6206ff59994100d3063438c327814ca4e889c;hp=ac6dda5fd5787bde87dffece8128b28c2f7b605a;hb=b52ed5f34c059fd91bfd4339b913b9f9f5c5d295;hpb=c195473ea3f66882856994a2400f3acfbb82745e

diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
index ac6dda5fd57..68b6206ff59 100644
--- a/gcc/testsuite/lib/target-supports.exp
+++ b/gcc/testsuite/lib/target-supports.exp
@@ -1,4 +1,5 @@
-#   Copyright (C) 1999, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
+#   Copyright (C) 1999, 2001, 2003, 2004, 2005, 2006
+#   Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -12,7 +13,7 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 # Please email any bugs, comments, and/or additions to this file to:
 # gcc-patches@gcc.gnu.org
@@ -60,6 +61,26 @@ proc current_target_name { } {
     return $answer
 }
 
+# Implement an effective-target check for property PROP by invoking
+# the compiler and seeing if it prints any messages.  Assume that the
+# property holds if the compiler doesn't print anything.  The other
+# arguments are as for get_compiler_messages, starting with TYPE.
+proc check_no_compiler_messages {prop args} {
+    global et_cache
+
+    set target [current_target_name]
+    if {![info exists et_cache($prop,target)]
+	|| $et_cache($prop,target) != $target} {
+	verbose "check_effective_target $prop: compiling source for $target" 2
+	set et_cache($prop,target) $target
+	set et_cache($prop,value) \
+	    [string match "" [eval get_compiler_messages $prop $args]]
+    }
+    set value $et_cache($prop,value)
+    verbose "check_effective_target $prop: returning $value for $target" 2
+    return $value
+}
+
 ###############################
 # proc check_weak_available { }
 ###############################
@@ -126,38 +147,20 @@ proc check_weak_available { } {
 # The argument is the kind of visibility, default/protected/hidden/internal.
 
 proc check_visibility_available { what_kind } {
-    global visibility_available_saved
     global tool
     global target_triplet
 
     # On NetWare, support makes no sense.
-    if { [string match "*-*-netware*" $target_triplet] } {
+    if { [istarget *-*-netware*] } {
         return 0
     }
 
     if [string match "" $what_kind] { set what_kind "hidden" }
 
-    if { [info exists visibility_available_saved] } {
-	verbose "Saved result is <$visibility_available_saved>" 1
-	if { [ lsearch -exact $visibility_available_saved $what_kind ] != -1 } {
-	    return 1
-	} elseif { [ lsearch -exact $visibility_available_saved "!$what_kind" ] != -1 } {
-	    return 0
-	}
-    }
-
-    set lines [get_compiler_messages visibility object "
+    return [check_no_compiler_messages visibility_available_$what_kind object "
 	void f() __attribute__((visibility(\"$what_kind\")));
 	void f() {}
     "]
-    if [string match "" $lines] then {
-	set answer 1
-	lappend visibility_available_saved $what_kind
-    } else {
-	set answer 0
-	lappend visibility_available_saved "!$what_kind"
-    }
-    return $answer
 }
 
 ###############################
@@ -279,6 +282,11 @@ proc check_profiling_available { test_what } {
 	return 0
     }
 
+    # At present, there is no profiling support on NetWare.
+    if { [istarget *-*-netware*] } {
+	return 0
+    }
+
     # Now examine the cache variable.
     if {![info exists profiling_available_saved]} {
 	# Some targets don't have any implementation of __bb_init_func or are
@@ -292,6 +300,8 @@ proc check_profiling_available { test_what } {
 	     || [istarget xscale*-*-elf]
 	     || [istarget cris-*-*]
 	     || [istarget h8300-*-*]
+	     || [istarget m32c-*-elf]
+	     || [istarget m68k-*-elf]
 	     || [istarget mips*-*-elf]
 	     || [istarget xtensa-*-elf]
 	     || [istarget *-*-windiss] } {
@@ -304,53 +314,152 @@ proc check_profiling_available { test_what } {
     return $profiling_available_saved
 }
 
-# Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
-# emitted, 0 otherwise.  Whether a shared library can actually be built is
-# out of scope for this test.
+# Return 1 if target has packed layout of structure members by
+# default, 0 otherwise.  Note that this is slightly different than
+# whether the target has "natural alignment": both attributes may be
+# false.
+
+proc check_effective_target_default_packed { } {
+    return [check_no_compiler_messages default_packed assembly {
+	struct x { char a; long b; } c;
+	int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
+    }]
+}
+
+# Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
+# documentation, where the test also comes from.
+
+proc check_effective_target_pcc_bitfield_type_matters { } {
+    # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
+    # bitfields, but let's stick to the example code from the docs.
+    return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
+	struct foo1 { char x; char :0; char y; };
+	struct foo2 { char x; int :0; char y; };
+	int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
+    }]
+}
+
+# Return 1 if thread local storage (TLS) is supported, 0 otherwise.
 #
-# When the target name changes, replace the cached result.
+# This won't change for different subtargets so cache the result.
 
-proc check_effective_target_fpic { } {
-    global et_fpic_saved
-    global et_fpic_target_name
+proc check_effective_target_tls {} {
+    global et_tls_saved
 
-    if { ![info exists et_fpic_target_name] } {
-	set et_fpic_target_name ""
-    }
+    if [info exists et_tls_saved] {
+	verbose "check_effective_target_tls: using cached result" 2
+    } else {
+	set et_tls_saved 1
 
-    # If the target has changed since we set the cached value, clear it.
-    set current_target [current_target_name]
-    if { $current_target != $et_fpic_target_name } {
-	verbose "check_effective_target_fpic: `$et_fpic_target_name'" 2
-	set et_fpic_target_name $current_target
-	if [info exists et_fpic_saved] {
-	    verbose "check_effective_target_fpic: removing cached result" 2
-	    unset et_fpic_saved
+	set src tls[pid].c
+	set asm tls[pid].S
+	verbose "check_effective_target_tls: compiling testfile $src" 2
+	set f [open $src "w"]
+	# Compile a small test program.
+	puts $f "__thread int i;\n"
+	close $f
+
+	# Test for thread-local data supported by the platform.
+	set comp_output \
+	    [target_compile $src $asm assembly ""]
+	file delete $src
+	if { [string match "*not supported*" $comp_output] } {
+	    set et_tls_saved 0
 	}
+	remove-build-file $asm
     }
+    verbose "check_effective_target_tls: returning $et_tls_saved" 2
+    return $et_tls_saved
+}
 
-    if [info exists et_fpic_saved] {
-	verbose "check_effective_target_fpic: using cached result" 2
+# Return 1 if TLS executables can run correctly, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_tls_runtime {} {
+    global et_tls_runtime_saved
+
+    if [info exists et_tls_runtime_saved] {
+	verbose "check_effective_target_tls_runtime: using cached result" 2
     } else {
-	verbose "check_effective_target_fpic: compiling source" 2
+	set et_tls_runtime_saved 0
+
+	set src tls_runtime[pid].c
+	set exe tls_runtime[pid].x
+	verbose "check_effective_target_tls_runtime: compiling testfile $src" 2
+	set f [open $src "w"]
+	# Compile a small test program.
+	puts $f "__thread int thr = 0;\n"
+	puts $f "int main(void)\n {\n return thr;\n}"
+	close $f
+
+	set comp_output \
+	    [target_compile $src $exe executable ""]
+	file delete $src
 
-	# Note that M68K has a multilib that supports -fpic but not
-	# -fPIC, so we need to check both.  We test with a program that
-	# requires GOT references.
-	set et_fpic_saved [string match "" [get_compiler_messages fpic object {
+	if [string match "" $comp_output] then {
+	    # No error messages, everything is OK.
+
+	    set result [remote_load target "./$exe" "" ""]
+	    set status [lindex $result 0]
+	    remote_file build delete $exe
+
+	    verbose "check_effective_target_tls_runtime status is <$status>" 2
+
+	    if { $status == "pass" } {
+		set et_tls_runtime_saved 1
+	    }
+
+	    verbose "check_effective_target_tls_runtime: returning $et_tls_runtime_saved" 2
+	}
+    }
+
+    return $et_tls_runtime_saved
+}
+
+# Return 1 if compilation with -fopenmp is error-free for trivial
+# code, 0 otherwise.
+
+proc check_effective_target_fopenmp {} {
+    return [check_no_compiler_messages fopenmp object {
+	void foo (void) { }
+    } "-fopenmp"]
+}
+
+# Return 1 if compilation with -freorder-blocks-and-partition is error-free
+# for trivial code, 0 otherwise.
+
+proc check_effective_target_freorder {} {
+    return [check_no_compiler_messages freorder object {
+	void foo (void) { }
+    } "-freorder-blocks-and-partition"]
+}
+
+# Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
+# emitted, 0 otherwise.  Whether a shared library can actually be built is
+# out of scope for this test.
+
+proc check_effective_target_fpic { } {
+    # Note that M68K has a multilib that supports -fpic but not
+    # -fPIC, so we need to check both.  We test with a program that
+    # requires GOT references.
+    foreach arg {fpic fPIC} {
+	if [check_no_compiler_messages $arg object {
 	    extern int foo (void); extern int bar;
 	    int baz (void) { return foo () + bar; }
-	} "-fpic"]]
-
-	if { $et_fpic_saved != 0 } {
-	    set et_fpic_saved [string match "" [get_compiler_messages fpic object {
-		extern int foo (void); extern int bar;
-		int baz (void) { return foo () + bar; }
-	    } "-fPIC"]]
+	} "-$arg"] {
+	    return 1
 	}
     }
-    verbose "check_effective_target_fpic: returning $et_fpic_saved" 2
-    return $et_fpic_saved
+    return 0
+}
+
+# Return true if the target supports -mpaired-single (as used on MIPS).
+
+proc check_effective_target_mpaired_single { } {
+    return [check_no_compiler_messages freorder object {
+	void foo (void) { }
+    } "-mpaired-single"]
 }
 
 # Return true if iconv is supported on the target. In particular IBM1047.
@@ -398,16 +507,178 @@ proc check_iconv_available { test_what } {
 }
 
 # Return true if named sections are supported on this target.
-# This proc does not cache results, because the answer may vary
-# when cycling over subtarget options (e.g. irix o32/n32/n64) in
-# the same test run.
+
 proc check_named_sections_available { } {
-    verbose "check_named_sections_available: compiling source" 2
-    set answer [string match "" [get_compiler_messages named object {
+    return [check_no_compiler_messages named_sections assembly {
 	int __attribute__ ((section("whatever"))) foo;
-    }]]
-    verbose "check_named_sections_available: returning $answer" 2
-    return $answer
+    }]
+}
+
+# Return 1 if the target supports Fortran real kinds larger than real(8),
+# 0 otherwise.
+#
+# When the target name changes, replace the cached result.
+
+proc check_effective_target_fortran_large_real { } {
+    global et_fortran_large_real_saved
+    global et_fortran_large_real_target_name
+    global tool
+
+    if { ![info exists et_fortran_large_real_target_name] } {
+	set et_fortran_large_real_target_name ""
+    }
+
+    # If the target has changed since we set the cached value, clear it.
+    set current_target [current_target_name]
+    if { $current_target != $et_fortran_large_real_target_name } {
+	verbose "check_effective_target_fortran_large_real: `$et_fortran_large_real_target_name' `$current_target'" 2
+	set et_fortran_large_real_target_name $current_target
+	if [info exists et_fortran_large_real_saved] {
+	    verbose "check_effective_target_fortran_large_real: removing cached result" 2
+	    unset et_fortran_large_real_saved
+	}
+    }
+
+    if [info exists et_fortran_large_real_saved] {
+	verbose "check_effective_target_fortran_large_real returning saved $et_fortran_large_real_saved" 2
+    } else {
+	set et_fortran_large_real_saved 0
+
+	# Set up, compile, and execute a test program using large real
+	# kinds.  Include the current process ID in the file names to
+	# prevent conflicts with invocations for multiple testsuites.
+	set src real[pid].f90
+        set exe real[pid].x
+
+	set f [open $src "w"]
+	puts $f "integer,parameter :: k = &"
+        puts $f "  selected_real_kind (precision (0.0_8) + 1)"
+        puts $f "real(kind=k) :: x"
+        puts $f "x = cos (x);"
+	puts $f "end"
+	close $f
+
+	verbose "check_effective_target_fortran_large_real compiling testfile $src" 2
+	set lines [${tool}_target_compile $src $exe executable ""]
+	file delete $src
+
+	if [string match "" $lines] then {
+	    # No error message, compilation succeeded.
+  	    set et_fortran_large_real_saved 1
+	}
+    }
+
+    return $et_fortran_large_real_saved
+}
+
+# Return 1 if the target supports Fortran integer kinds larger than
+# integer(8), 0 otherwise.
+#
+# When the target name changes, replace the cached result.
+
+proc check_effective_target_fortran_large_int { } {
+    global et_fortran_large_int_saved
+    global et_fortran_large_int_target_name
+    global tool
+
+    if { ![info exists et_fortran_large_int_target_name] } {
+	set et_fortran_large_int_target_name ""
+    }
+
+    # If the target has changed since we set the cached value, clear it.
+    set current_target [current_target_name]
+    if { $current_target != $et_fortran_large_int_target_name } {
+	verbose "check_effective_target_fortran_large_int: `$et_fortran_large_int_target_name' `$current_target'" 2
+	set et_fortran_large_int_target_name $current_target
+	if [info exists et_fortran_large_int_saved] {
+	    verbose "check_effective_target_fortran_large_int: removing cached result" 2
+	    unset et_fortran_large_int_saved
+	}
+    }
+
+    if [info exists et_fortran_large_int_saved] {
+	verbose "check_effective_target_fortran_large_int returning saved $et_fortran_large_int_saved" 2
+    } else {
+	set et_fortran_large_int_saved 0
+
+	# Set up, compile, and execute a test program using large integer
+	# kinds.  Include the current process ID in the file names to
+	# prevent conflicts with invocations for multiple testsuites.
+	set src int[pid].f90
+        set exe int[pid].x
+
+	set f [open $src "w"]
+	puts $f "integer,parameter :: k = &"
+        puts $f "  selected_int_kind (range (0_8) + 1)"
+        puts $f "integer(kind=k) :: i"
+	puts $f "end"
+	close $f
+
+	verbose "check_effective_target_fortran_large_int compiling testfile $src" 2
+	set lines [${tool}_target_compile $src $exe executable ""]
+	file delete $src
+
+	if [string match "" $lines] then {
+	    # No error message, compilation succeeded.
+	    set et_fortran_large_int_saved 1
+	}
+    }
+
+    return $et_fortran_large_int_saved
+}
+
+# Return 1 if we can statically link libgfortran, 0 otherwise.
+#
+# When the target name changes, replace the cached result.
+
+proc check_effective_target_static_libgfortran { } {
+    global et_static_libgfortran
+    global et_static_libgfortran_target_name
+    global tool
+
+    if { ![info exists et_static_libgfortran_target_name] } {
+       set et_static_libgfortran_target_name ""
+    }
+
+    # If the target has changed since we set the cached value, clear it.
+    set current_target [current_target_name]
+    if { $current_target != $et_static_libgfortran_target_name } {
+       verbose "check_effective_target_static_libgfortran: `$et_static_libgfortran_target_name' `$current_target'" 2
+       set et_static_libgfortran_target_name $current_target
+       if [info exists et_static_libgfortran_saved] {
+           verbose "check_effective_target_static_libgfortran: removing cached result" 2
+           unset et_static_libgfortran_saved
+       }
+    }
+
+    if [info exists et_static_libgfortran_saved] {
+       verbose "check_effective_target_static_libgfortran returning saved $et_static_libgfortran_saved" 2
+    } else {
+       set et_static_libgfortran_saved 0
+
+       # Set up, compile, and execute a test program using static linking.
+       # Include the current process ID in the file names to prevent
+       # conflicts with invocations for multiple testsuites.
+       set opts "additional_flags=-static"
+       set src static[pid].f
+       set exe static[pid].x
+
+       set f [open $src "w"]
+       puts $f "      print *, 'test'"
+       puts $f "      end"
+       close $f
+
+       verbose "check_effective_target_static_libgfortran compiling testfile $src" 2
+       set lines [${tool}_target_compile $src $exe executable "$opts"]
+       file delete $src
+
+       if [string match "" $lines] then {
+           # No error message, compilation succeeded.
+           set et_static_libgfortran_saved 1
+       }
+    }
+
+    return $et_static_libgfortran_saved
 }
 
 # Return 1 if the target supports executing AltiVec instructions, 0
@@ -653,76 +924,252 @@ proc check_mkfifo_available {} {
     return [check_function_available "mkfifo"]
 }
 
-# Return 1 if we're generating 32-bit code using default options, 0
-# otherwise.
-#
-# When the target name changes, replace the cached result.
+# Returns true iff "__cxa_atexit" is used on the target system.
 
-proc check_effective_target_ilp32 { } {
-    global et_ilp32_saved
-    global et_ilp32_target_name
+proc check_cxa_atexit_available { } {
+    global et_cxa_atexit
+    global et_cxa_atexit_target_name
+    global tool	
 
-    if { ![info exists et_ilp32_target_name] } {
-	set et_ilp32_target_name ""
+    if { ![info exists et_cxa_atexit_target_name] } {
+	set et_cxa_atexit_target_name ""
     }
 
     # If the target has changed since we set the cached value, clear it.
     set current_target [current_target_name]
-    if { $current_target != $et_ilp32_target_name } {
-	verbose "check_effective_target_ilp32: `$et_ilp32_target_name' `$current_target'" 2
-	set et_ilp32_target_name $current_target
-	if { [info exists et_ilp32_saved] } {
-	    verbose "check_effective_target_ilp32: removing cached result" 2
-	    unset et_ilp32_saved
+    if { $current_target != $et_cxa_atexit_target_name } {
+	verbose "check_cxa_atexit_available: `$et_cxa_atexit_target_name'" 2
+	set et_cxa_atexit_target_name $current_target
+	if [info exists et_cxa_atexit] {
+	    verbose "check_cxa_atexit_available: removing cached result" 2
+	    unset et_cxa_atexit
 	}
     }
 
-    if [info exists et_ilp32_saved] {
-	verbose "check-effective_target_ilp32: using cached result" 2
+    if [info exists et_cxa_atexit] {
+	verbose "check_cxa_atexit_available: using cached result" 2
     } else {
-	verbose "check_effective_target_ilp32: compiling source" 2
-	set et_ilp32_saved [string match "" [get_compiler_messages ilp32 object {
-	    int dummy[(sizeof (int) == 4 && sizeof (void *) == 4 && sizeof (long) == 4 ) ? 1 : -1];
-	}]]
+	set et_cxa_atexit 0
+
+	# Set up, compile, and execute a C++ test program that depends
+	# on correct ordering of static object destructors. This is
+	# indicative of the presence and use of __cxa_atexit.
+	set src cxaatexit[pid].cc
+	set exe cxaatexit[pid].x
+
+	set f [open $src "w"]
+	puts $f "#include <stdlib.h>"
+	puts $f "static unsigned int count;"
+	puts $f "struct X"
+	puts $f "{"
+	puts $f "  X() { count = 1; }"
+	puts $f "  ~X()"
+	puts $f "  {"
+	puts $f "    if (count != 3)"
+	puts $f "      exit(1);"
+	puts $f "    count = 4;"
+        puts $f "  }"
+        puts $f "};"
+	puts $f "void f()"
+	puts $f "{"
+	puts $f "  static X x;"
+        puts $f "}"
+	puts $f "struct Y"
+	puts $f "{"
+	puts $f "  Y() { f(); count = 2; }"
+	puts $f "  ~Y()"
+	puts $f "  {"
+	puts $f "    if (count != 2)"
+	puts $f "      exit(1);"
+	puts $f "    count = 3;"
+        puts $f "  }"
+        puts $f "};"
+	puts $f "Y y;"
+	puts $f "int main()"
+	puts $f "{ return 0; }"
+	close $f
+
+	set lines [${tool}_target_compile $src $exe executable ""]
+	file delete $src
+
+	if [string match "" $lines] {
+	    # No error message, compilation succeeded.
+	    set result [${tool}_load "./$exe" "" ""]
+	    set status [lindex $result 0]
+	    remote_file build delete $exe
+
+	    verbose "check_cxa_atexit_available: status is <$status>" 2
+
+	    if { $status == "pass" } {
+		set et_cxa_atexit 1
+	    }
+	} else {
+	    verbose "check_cxa_atexit_available: compilation failed" 2
+	}
     }
-    verbose "check_effective_target_ilp32: returning $et_ilp32_saved" 2
-    return $et_ilp32_saved
+    return $et_cxa_atexit
+}
+
+
+# Return 1 if we're generating 32-bit code using default options, 0
+# otherwise.
+
+proc check_effective_target_ilp32 { } {
+    return [check_no_compiler_messages ilp32 object {
+	int dummy[sizeof (int) == 4
+		  && sizeof (void *) == 4
+		  && sizeof (long) == 4 ? 1 : -1];
+    }]
+}
+
+# Return 1 if we're generating 32-bit or larger integers using default
+# options, 0 otherwise.
+
+proc check_effective_target_int32plus { } {
+    return [check_no_compiler_messages int32plus object {
+	int dummy[sizeof (int) >= 4 ? 1 : -1];
+    }]
+}
+
+# Return 1 if we're generating 32-bit or larger pointers using default
+# options, 0 otherwise.
+
+proc check_effective_target_ptr32plus { } {
+    return [check_no_compiler_messages ptr32plus object {
+	int dummy[sizeof (void *) >= 4 ? 1 : -1];
+    }]
+}
+
+# Return 1 if we support 32-bit or larger array and structure sizes
+# using default options, 0 otherwise.
+
+proc check_effective_target_size32plus { } {
+    return [check_no_compiler_messages size32plus object {
+	char dummy[65537];
+    }]
+}
+
+# Returns 1 if we're generating 16-bit or smaller integers with the
+# default options, 0 otherwise.
+
+proc check_effective_target_int16 { } {
+    return [check_no_compiler_messages int16 object {
+	int dummy[sizeof (int) < 4 ? 1 : -1];
+    }]
 }
 
 # Return 1 if we're generating 64-bit code using default options, 0
 # otherwise.
-#
-# When the target name changes, replace the cached result.
 
 proc check_effective_target_lp64 { } {
-    global et_lp64_saved
-    global et_lp64_target_name
+    return [check_no_compiler_messages lp64 object {
+	int dummy[sizeof (int) == 4
+		  && sizeof (void *) == 8
+		  && sizeof (long) == 8 ? 1 : -1];
+    }]
+}
 
-    if { ![info exists et_lp64_target_name] } {
-	set et_lp64_target_name ""
-    }
+# Return 1 if the target supports compiling decimal floating point,
+# 0 otherwise.
 
-    # If the target has changed since we set the cached value, clear it.
-    set current_target [current_target_name]
-    if { $current_target != $et_lp64_target_name } {
-	verbose "check_effective_target_lp64: `$et_lp64_target_name' `$current_target'" 2
-	set et_lp64_target_name $current_target
-	if [info exists et_lp64_saved] {
-	    verbose "check_effective_target_lp64: removing cached result" 2
-	    unset et_lp64_saved
+proc check_effective_target_dfp_nocache { } {
+    verbose "check_effective_target_dfp_nocache: compiling source" 2
+    set ret [string match "" [get_compiler_messages dfp object {
+        _Decimal32 x; _Decimal64 y; _Decimal128 z;
+    }]]
+    verbose "check_effective_target_dfp_nocache: returning $ret" 2
+    return $ret
+}
+
+proc check_effective_target_dfprt_nocache { } {
+    global tool
+
+    set ret 0
+
+    verbose "check_effective_target_dfprt_nocache: compiling source" 2
+    # Set up, compile, and execute a test program containing decimal
+    # float operations.
+    set src dfprt[pid].c
+    set exe dfprt[pid].x
+
+    set f [open $src "w"]
+    puts $f "_Decimal32 x = 1.2df; _Decimal64 y = 2.3dd; _Decimal128 z;"
+    puts $f "int main () { z = x + y; return 0; }"
+    close $f
+
+    verbose "check_effective_target_dfprt_nocache: compiling testfile $src" 2
+    set lines [${tool}_target_compile $src $exe executable ""]
+    file delete $src
+
+    if [string match "" $lines] then {
+	# No error message, compilation succeeded.
+	set result [${tool}_load "./$exe" "" ""]
+	set status [lindex $result 0]
+	remote_file build delete $exe
+	verbose "check_effective_target_dfprt_nocache: testfile status is <$status>" 2
+	if { $status == "pass" } then {
+	    set ret 1
 	}
     }
+    return $ret
+    verbose "check_effective_target_dfprt_nocache: returning $ret" 2
+}
+
+# Return 1 if the target supports compiling Decimal Floating Point,
+# 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_dfp { } {
+    global et_dfp_saved
+
+    if [info exists et_dfp_saved] {
+	verbose "check_effective_target_dfp: using cached result" 2
+    } else {
+	set et_dfp_saved [check_effective_target_dfp_nocache]
+    }
+    verbose "check_effective_target_dfp: returning $et_dfp_saved" 2
+    return $et_dfp_saved
+}
+
+# Return 1 if the target supports linking and executing Decimal Floating
+# Point, # 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_dfprt { } {
+    global et_dfprt_saved
+    global tool
+
+    if [info exists et_dfprt_saved] {
+	verbose "check_effective_target_dfprt: using cached result" 2
+    } else {
+	set et_dfprt_saved [check_effective_target_dfprt_nocache]
+    }
+    verbose "check_effective_target_dfprt: returning $et_dfprt_saved" 2
+    return $et_dfprt_saved
+}
+
+# Return 1 if the target needs a command line argument to enable a SIMD
+# instruction set.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_cmdline_needed { } {
+    global et_vect_cmdline_needed_saved
 
-    if [info exists et_lp64_saved] {
-	verbose "check_effective_target_lp64: using cached result" 2
+    if [info exists et_vect_cmdline_needed_saved] {
+	verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
     } else {
-	verbose "check_effective_target_lp64: compiling source" 2
-	set et_lp64_saved [string match "" [get_compiler_messages lp64 object {
-	    int dummy[(sizeof (int) == 4 && sizeof (void *) == 8 && sizeof (long) == 8 ) ? 1 : -1];
-	}]]
+	set et_vect_cmdline_needed_saved 1
+	if { [istarget ia64-*-*]
+	      || [istarget x86_64-*-*] } {
+	   set et_vect_cmdline_needed_saved 0
+	}
     }
-    verbose "check_effective_target_lp64: returning $et_lp64_saved" 2
-    return $et_lp64_saved
+
+    verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
+    return $et_vect_cmdline_needed_saved
 }
 
 # Return 1 if the target supports hardware vectors of int, 0 otherwise.
@@ -787,17 +1234,59 @@ proc check_effective_target_arm32 { } {
     return $et_arm32_saved
 }
 
+# Return 1 if this is a PowerPC target with floating-point registers.
+
+proc check_effective_target_powerpc_fprs { } {
+    if { [istarget powerpc*-*-*]
+	 || [istarget rs6000-*-*] } {
+	return [check_no_compiler_messages powerpc_fprs object {
+	    #ifdef __NO_FPRS__
+	    #error no FPRs
+	    #else
+	    int dummy;
+	    #endif
+	}]
+    } else {
+	return 0
+    }
+}
+
+# Return 1 if this is a PowerPC target supporting -maltivec.
+
+proc check_effective_target_powerpc_altivec_ok { } {
+    if { [istarget powerpc*-*-*]
+	 || [istarget rs6000-*-*] } {
+	# AltiVec is not supported on Aix.
+	if { [istarget powerpc*-*-aix*] } {
+	    return 0
+	}
+	return [check_no_compiler_messages powerpc_altivec_ok object {
+	    int dummy;
+	} "-maltivec"]
+    } else {
+	return 0
+    }
+}
+
 # Return 1 if the target supports hardware vector shift operation.
 
 proc check_effective_target_vect_shift { } {
-    if { [istarget powerpc*-*-*] } {
-	set answer 1
+    global et_vect_shift_saved
+
+    if [info exists et_vect_shift_saved] {
+	verbose "check_effective_target_vect_shift: using cached result" 2
     } else {
-	set answer 0
+	set et_vect_shift_saved 0
+	if { [istarget powerpc*-*-*]
+	     || [istarget ia64-*-*]
+	     || [istarget i?86-*-*]
+	     || [istarget x86_64-*-*] } {
+	   set et_vect_shift_saved 1
+	}
     }
 
-    verbose "check_effective_target_vect_shift: returning $answer" 2
-    return $answer
+    verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
+    return $et_vect_shift_saved
 }
 
 # Return 1 if the target supports hardware vectors of long, 0 otherwise.
@@ -864,26 +1353,45 @@ proc check_effective_target_vect_double { } {
 }
 
 # Return 1 if the target plus current options does not support a vector
-# max instruction, 0 otherwise.
+# max instruction on "int", 0 otherwise.
 #
 # This won't change for different subtargets so cache the result.
 
-proc check_effective_target_vect_no_max { } {
-    global et_vect_no_max_saved
+proc check_effective_target_vect_no_int_max { } {
+    global et_vect_no_int_max_saved
 
-    if [info exists et_vect_no_max_saved] {
-	verbose "check_effective_target_vect_no_max: using cached result" 2
+    if [info exists et_vect_no_int_max_saved] {
+	verbose "check_effective_target_vect_no_int_max: using cached result" 2
     } else {
-	set et_vect_no_max_saved 0
-	if { [istarget i?86-*-*]
-	     || [istarget x86_64-*-*]
-	     || [istarget sparc*-*-*]
+	set et_vect_no_int_max_saved 0
+	if { [istarget sparc*-*-*]
 	     || [istarget alpha*-*-*] } {
-	    set et_vect_no_max_saved 1
+	    set et_vect_no_int_max_saved 1
+	}
+    }
+    verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
+    return $et_vect_no_int_max_saved
+}
+
+# Return 1 if the target plus current options does not support a vector
+# add instruction on "int", 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_no_int_add { } {
+    global et_vect_no_int_add_saved
+
+    if [info exists et_vect_no_int_add_saved] {
+	verbose "check_effective_target_vect_no_int_add: using cached result" 2
+    } else {
+	set et_vect_no_int_add_saved 0
+	# Alpha only supports vector add on V8QI and V4HI.
+	if { [istarget alpha*-*-*] } {
+	    set et_vect_no_int_add_saved 1
 	}
     }
-    verbose "check_effective_target_vect_no_max: returning $et_vect_no_max_saved" 2
-    return $et_vect_no_max_saved
+    verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
+    return $et_vect_no_int_add_saved
 }
 
 # Return 1 if the target plus current options does not support vector
@@ -903,6 +1411,173 @@ proc check_effective_target_vect_no_bitwise { } {
     return $et_vect_no_bitwise_saved
 }
 
+# Return 1 if the target plus current options supports a vector
+# widening summation of *short* args into *int* result, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+                                                                                                
+proc check_effective_target_vect_widen_sum_hi_to_si { } {
+    global et_vect_widen_sum_hi_to_si
+                                                                                                
+    if [info exists et_vect_widen_sum_hi_to_si_saved] {
+        verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
+    } else {
+        set et_vect_widen_sum_hi_to_si_saved 0
+        if { [istarget powerpc*-*-*]
+	     || [istarget ia64-*-*] } {
+            set et_vect_widen_sum_hi_to_si_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
+    return $et_vect_widen_sum_hi_to_si_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# widening summation of *char* args into *short* result, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+                                                                                                
+proc check_effective_target_vect_widen_sum_qi_to_hi { } {
+    global et_vect_widen_sum_qi_to_hi
+                                                                                                
+    if [info exists et_vect_widen_sum_qi_to_hi_saved] {
+        verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
+    } else {
+        set et_vect_widen_sum_qi_to_hi_saved 0
+        if { [istarget ia64-*-*] } {
+            set et_vect_widen_sum_qi_to_hi_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
+    return $et_vect_widen_sum_qi_to_hi_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# widening summation of *char* args into *int* result, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+                                                                                                
+proc check_effective_target_vect_widen_sum_qi_to_si { } {
+    global et_vect_widen_sum_qi_to_si
+                                                                                                
+    if [info exists et_vect_widen_sum_qi_to_si_saved] {
+        verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
+    } else {
+        set et_vect_widen_sum_qi_to_si_saved 0
+        if { [istarget powerpc*-*-*] } {
+            set et_vect_widen_sum_qi_to_si_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
+    return $et_vect_widen_sum_qi_to_si_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# widening summation, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+                                                                                                
+proc check_effective_target_vect_widen_sum { } {
+    global et_vect_widen_sum
+                                                                                                
+    if [info exists et_vect_widen_sum_saved] {
+        verbose "check_effective_target_vect_widen_sum: using cached result" 2
+    } else {
+        set et_vect_widen_sum_saved 0
+        if { [istarget powerpc*-*-*]
+	     || [istarget ia64-*-*] } {
+            set et_vect_widen_sum_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_widen_sum: returning $et_vect_widen_sum_saved" 2
+    return $et_vect_widen_sum_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# dot-product of signed chars, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_sdot_qi { } {
+    global et_vect_sdot_qi
+
+    if [info exists et_vect_sdot_qi_saved] {
+        verbose "check_effective_target_vect_sdot_qi: using cached result" 2
+    } else {
+        set et_vect_sdot_qi_saved 0
+        if { [istarget ia64-*-*] } {
+            set et_vect_sdot_qi_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
+    return $et_vect_sdot_qi_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# dot-product of unsigned chars, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_udot_qi { } {
+    global et_vect_udot_qi
+
+    if [info exists et_vect_udot_qi_saved] {
+        verbose "check_effective_target_vect_udot_qi: using cached result" 2
+    } else {
+        set et_vect_udot_qi_saved 0
+        if { [istarget powerpc*-*-*]
+             || [istarget ia64-*-*] } {
+            set et_vect_udot_qi_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
+    return $et_vect_udot_qi_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# dot-product of signed shorts, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_sdot_hi { } {
+    global et_vect_sdot_hi
+
+    if [info exists et_vect_sdot_hi_saved] {
+        verbose "check_effective_target_vect_sdot_hi: using cached result" 2
+    } else {
+        set et_vect_sdot_hi_saved 0
+        if { [istarget powerpc*-*-*] 
+	     || [istarget i?86-*-*]
+             || [istarget x86_64-*-*]
+             || [istarget ia64-*-*] } {
+            set et_vect_sdot_hi_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
+    return $et_vect_sdot_hi_saved
+}
+
+# Return 1 if the target plus current options supports a vector
+# dot-product of unsigned shorts, 0 otherwise.
+#
+# This won't change for different subtargets so cache the result.
+
+proc check_effective_target_vect_udot_hi { } {
+    global et_vect_udot_hi
+
+    if [info exists et_vect_udot_hi_saved] {
+        verbose "check_effective_target_vect_udot_hi: using cached result" 2
+    } else {
+        set et_vect_udot_hi_saved 0
+        if { [istarget powerpc*-*-*] } {
+            set et_vect_udot_hi_saved 1
+        }
+    }
+    verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
+    return $et_vect_udot_hi_saved
+}
+
+
 # Return 1 if the target plus current options does not support a vector
 # alignment mechanism, 0 otherwise.
 #
@@ -930,7 +1605,7 @@ proc check_effective_target_vect_no_align { } {
 proc check_effective_target_vect_condition { } {
     global et_vect_cond_saved
 
-    if [info exists et_vect_int_cond] {
+    if [info exists et_vect_cond_saved] {
 	verbose "check_effective_target_vect_cond: using cached result" 2
     } else {
 	set et_vect_cond_saved 0
@@ -946,6 +1621,46 @@ proc check_effective_target_vect_condition { } {
     return $et_vect_cond_saved
 }
 
+# Return 1 if the target supports vector char multiplication, 0 otherwise.
+
+proc check_effective_target_vect_char_mult { } {
+    global et_vect_char_mult_saved
+
+    if [info exists et_vect_char_mult_saved] {
+	verbose "check_effective_target_vect_char_mult: using cached result" 2
+    } else {
+	set et_vect_char_mult_saved 0
+	if { [istarget ia64-*-*]
+	     || [istarget i?86-*-*]
+	     || [istarget x86_64-*-*] } {
+	   set et_vect_char_mult_saved 1
+	}
+    }
+
+    verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
+    return $et_vect_char_mult_saved
+}
+
+# Return 1 if the target supports vector short multiplication, 0 otherwise.
+
+proc check_effective_target_vect_short_mult { } {
+    global et_vect_short_mult_saved
+
+    if [info exists et_vect_short_mult_saved] {
+	verbose "check_effective_target_vect_short_mult: using cached result" 2
+    } else {
+	set et_vect_short_mult_saved 0
+	if { [istarget ia64-*-*]
+	     || [istarget i?86-*-*]
+	     || [istarget x86_64-*-*] } {
+	   set et_vect_short_mult_saved 1
+	}
+    }
+
+    verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
+    return $et_vect_short_mult_saved
+}
+
 # Return 1 if the target supports vector int multiplication, 0 otherwise.
 
 proc check_effective_target_vect_int_mult { } {
@@ -981,7 +1696,10 @@ proc check_effective_target_sync_int_long { } {
 	     || [istarget i?86-*-*]
 	     || [istarget x86_64-*-*]
 	     || [istarget alpha*-*-*] 
-	     || [istarget powerpc*-*-*] } {
+	     || [istarget s390*-*-*] 
+	     || [istarget powerpc*-*-*]
+	     || [istarget sparc64-*-*]
+	     || [istarget sparcv9-*-*] } {
            set et_sync_int_long_saved 1
         }
     }
@@ -990,6 +1708,33 @@ proc check_effective_target_sync_int_long { } {
     return $et_sync_int_long_saved
 }
 
+# Return 1 if the target supports atomic operations on "char" and "short".
+
+proc check_effective_target_sync_char_short { } {
+    global et_sync_char_short_saved
+
+    if [info exists et_sync_char_short_saved] {
+        verbose "check_effective_target_sync_char_short: using cached result" 2
+    } else {
+        set et_sync_char_short_saved 0
+# This is intentionally powerpc but not rs6000, rs6000 doesn't have the
+# load-reserved/store-conditional instructions.
+        if { [istarget ia64-*-*]
+	     || [istarget i?86-*-*]
+	     || [istarget x86_64-*-*]
+	     || [istarget alpha*-*-*] 
+	     || [istarget s390*-*-*] 
+	     || [istarget powerpc*-*-*]
+	     || [istarget sparc64-*-*]
+	     || [istarget sparcv9-*-*] } {
+           set et_sync_char_short_saved 1
+        }
+    }
+
+    verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
+    return $et_sync_char_short_saved
+}
+
 # Return 1 if the target matches the effective target 'arg', 0 otherwise.
 # This can be used with any check_* proc that takes no argument and
 # returns only 1 or 0.  It could be used with check_* procs that take
@@ -1026,3 +1771,13 @@ proc is-effective-target-keyword { arg } {
 	}
     }
 }
+
+# Return 1 if target default to short enums
+
+proc check_effective_target_short_enums { } {
+    return [check_no_compiler_messages short_enums assembly {
+	enum foo { bar };
+	int s[sizeof (enum foo) == 1 ? 1 : -1];
+    }]
+}
+