diff options
Diffstat (limited to 'libstdc++-v3/testsuite/lib')
| -rw-r--r-- | libstdc++-v3/testsuite/lib/dg-options.exp | 176 | ||||
| -rw-r--r-- | libstdc++-v3/testsuite/lib/libstdc++.exp | 1554 | ||||
| -rw-r--r-- | libstdc++-v3/testsuite/lib/prune.exp | 66 |
3 files changed, 1796 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/lib/dg-options.exp b/libstdc++-v3/testsuite/lib/dg-options.exp new file mode 100644 index 000000000..b75f516c4 --- /dev/null +++ b/libstdc++-v3/testsuite/lib/dg-options.exp @@ -0,0 +1,176 @@ +# Handlers for additional dg-xxx keywords in tests. + +# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 +# 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 +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +proc dg-require-c-std { args } { + if { ![ check_v3_target_c_std ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-debug-mode { args } { + if { ![ check_v3_target_debug_mode ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-profile-mode { args } { + if { ![ check_v3_target_profile_mode ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-normal-mode { args } { + if { ![ check_v3_target_normal_mode ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-parallel-mode { args } { + if { ![ check_v3_target_parallel_mode ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-fileio { args } { + if { ![ check_v3_target_fileio ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-namedlocale { args } { + if { ![ check_v3_target_namedlocale [lindex $args 1] ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-sharedlib { args } { + if { ![ check_v3_target_sharedlib ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-time { args } { + if { ![ check_v3_target_time ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-cstdint { args } { + if { ![ check_v3_target_cstdint ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-atomic-builtins { args } { + if { ![ check_v3_target_atomic_builtins ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-gthreads { args } { + if { ![ check_v3_target_gthreads ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-nanosleep { args } { + if { ![ check_v3_target_nanosleep ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-sched-yield { args } { + if { ![ check_v3_target_sched_yield ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-string-conversions { args } { + if { ![ check_v3_target_string_conversions ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-swprintf { args } { + if { ![ check_v3_target_swprintf ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc dg-require-binary-io { args } { + if { ![ check_v3_target_binary_io ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + +proc add_options_for_no_pch { flags } { + # This forces any generated and possibly included PCH to be invalid. + return "-D__GLIBCXX__=99999999" +} diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp new file mode 100644 index 000000000..2b96e2904 --- /dev/null +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -0,0 +1,1554 @@ +# libstdc++ "tool init file" for DejaGNU + +# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +# 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 +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + + +# Define callbacks and load other libraries. This file is loaded relatively +# early, and before any other file we write ourselves. "load_lib" will +# find anything in the DejaGNU installation tree, or in our lib directory. +# "load_gcc_lib" will search the core compiler's .exp collection instead. +# +# The naming rule is that dg.exp looks for "tool-" and runtest.exp looks +# for "tool_" when finding callbacks. Utility routines we define for +# our callbacks begin with "v3-". +# +# libstdc++_* callbacks we don't define, but could: +# ..._option_help prints additional --help output +# ..._option_proc (--foo) process our own options +# ..._init (normal.exp) called once per test file +# ..._finish bracketing function for libstdc++_init +# ...-dg-prune removing output text, see top of system dg.exp +# +# Useful hook: if ${hostname}_init exists, it will be called, almost +# the last thing before testing begins. This can be defined in, e.g., +# ~/.dejagnurc or $DEJAGNU. + +proc load_gcc_lib { filename } { + global srcdir + load_file $srcdir/../../gcc/testsuite/lib/$filename +} + +# system routines +load_lib dg.exp +load_lib libgloss.exp +# compiler routines, then ours +load_gcc_lib target-supports.exp +load_gcc_lib target-supports-dg.exp +load_lib prune.exp +load_lib dg-options.exp +load_gcc_lib scanasm.exp +load_gcc_lib target-libpath.exp +load_gcc_lib timeout.exp +load_gcc_lib timeout-dg.exp +load_gcc_lib wrapper.exp + +# Useful for debugging. Pass the name of a variable and the verbosity +# threshold (number of -v's on the command line). +proc v3track { var n } { + upvar $var val + verbose "++ $var is $val" $n +} + +# Called by v3-init below. "Static" to this file. +proc v3-copy-files {srcfiles} { + foreach f $srcfiles { + if { [catch { set symlink [file readlink $f] } x] } then { + remote_download target $f + } else { + if { [regexp "^/" "$symlink"] } then { + remote_download target $symlink + } else { + set dirname [file dirname $f] + remote_download target $dirname/$symlink + } + } + } +} + +# Called once, during runtest.exp setup. +proc libstdc++_init { testfile } { + global env + global v3-sharedlib v3-libgomp + global srcdir blddir objdir tool_root_dir + global cc cxx cxxflags cxxpchflags cxxldflags + global includes + global gluefile wrap_flags + global ld_library_path + global target_triplet + global flags_file + global tool_timeout + global DEFAULT_CXXFLAGS + global STATIC_LIBCXXFLAGS + + # We set LC_ALL and LANG to C so that we get the same error + # messages as expected. + setenv LC_ALL C + setenv LANG C + + # Many hosts now default to a non-ASCII C locale, however, so + # they can set a charset encoding here if they need. + if { [ishost "*-*-cygwin*"] } { + setenv LC_ALL C.ASCII + setenv LANG C.ASCII + } + + set blddir [lookfor_file [get_multilibs] libstdc++-v3] + set flags_file "${blddir}/scripts/testsuite_flags" + set shlib_ext [get_shlib_extension] + v3track flags_file 2 + + # If a test doesn't have special options, use DEFAULT_CXXFLAGS. + # Use this variable if the behavior + # 1) only applies to libstdc++ testing + # 2) might need to be negated + # In particular, some tests have to be run without precompiled + # headers, or without assertions. + + if ![info exists DEFAULT_CXXFLAGS] then { + set DEFAULT_CXXFLAGS "" + # Host specific goo here. + if { [string match "powerpc-*-darwin*" $target_triplet] } { + append DEFAULT_CXXFLAGS " -multiply_defined suppress" + } + } + v3track DEFAULT_CXXFLAGS 2 + + # By default, we assume we want to run program images. + global dg-do-what-default + set dg-do-what-default run + + # Copy any required data files. + v3-copy-files [glob -nocomplain "$srcdir/data/*.tst"] + v3-copy-files [glob -nocomplain "$srcdir/data/*.txt"] + + set ld_library_path_tmp "" + + # Locate libgcc.a so we don't need to account for different values of + # SHLIB_EXT on different platforms + set gccdir [lookfor_file $tool_root_dir gcc/libgcc.a] + if {$gccdir != ""} { + set gccdir [file dirname $gccdir] + append ld_library_path_tmp ":${gccdir}" + } + v3track gccdir 3 + + # Locate libgomp. This is only required for parallel mode. + set v3-libgomp 0 + set libgompdir [lookfor_file $blddir/../libgomp .libs/libgomp.$shlib_ext] + if {$libgompdir != ""} { + set v3-libgomp 1 + set libgompdir [file dirname $libgompdir] + append ld_library_path_tmp ":${libgompdir}" + verbose -log "libgomp support detected" + } + v3track libgompdir 3 + + # Locate libstdc++ shared library. (ie libstdc++.so.) + set v3-sharedlib 0 + set sharedlibdir [lookfor_file $blddir src/.libs/libstdc++.$shlib_ext] + if {$sharedlibdir != ""} { + if { [string match "*-*-linux*" $target_triplet] && [isnative] } { + set v3-sharedlib 1 + verbose -log "shared library support detected" + } + } + v3track v3-sharedlib 3 + + set STATIC_LIBCXXFLAGS "" + set staticlibdir [lookfor_file $blddir src/.libs/libstdc++.a] + if {$staticlibdir != ""} { + set staticlibdir [file dirname $staticlibdir] + # Some targets use libstdc++.a%s in their specs, so they need a + # -B option for uninstalled testing. + set STATIC_LIBCXXFLAGS " -B${staticlibdir} " + } + + # Compute what needs to be added to the existing LD_LIBRARY_PATH. + if {$gccdir != ""} { + set compiler ${gccdir}/g++ + set ld_library_path ${ld_library_path_tmp} + append ld_library_path ":${blddir}/src/.libs" + + if { [is_remote host] == 0 && [which $compiler] != 0 } { + foreach i "[exec $compiler --print-multi-lib]" { + set mldir "" + regexp -- "\[a-z0-9=_/\.-\]*;" $i mldir + set mldir [string trimright $mldir "\;@"] + if { "$mldir" == "." } { + continue + } + if { [llength [glob -nocomplain ${gccdir}/${mldir}/libgcc_s*.so.*]] >= 1 } { + append ld_library_path ":${gccdir}/${mldir}" + } + } + } + + set_ld_library_path_env_vars + if [info exists env(LD_LIBRARY_PATH)] { + verbose -log "LD_LIBRARY_PATH = $env(LD_LIBRARY_PATH)" + } + } else { + set compiler [transform "g++"] + } + + # Set the default timeout for v3 tests. + set tool_timeout 600 + + # Default settings. + set cxx [transform "g++"] + set cxxflags "-g -O2 -D_GLIBCXX_ASSERT -fmessage-length=0" + set cxxpchflags "" + set cxxldflags "" + set cc [transform "gcc"] + # Locate testsuite_hooks.h and other testsuite headers. + set includes "-I${srcdir}/util" + # Adapt the defaults for special circumstances. + if [is_remote host] { + # A remote host does not, in general, have access to the + # $srcdir so we copy the testsuite headers into the current + # directory, and then add that to the search path. + foreach src [glob "${srcdir}/util/*.h" \ + "${srcdir}/util/*.cc" \ + "${srcdir}/util/*.tcc" \ + "${srcdir}/util/*.hpp" \ + "${srcdir}/util/*/*.h" \ + "${srcdir}/util/*/*.cc" \ + "${srcdir}/util/*/*.tcc" \ + "${srcdir}/util/*/*.hpp" \ + "${srcdir}/util/*/*/*.h" \ + "${srcdir}/util/*/*/*.cc" \ + "${srcdir}/util/*/*/*.tcc" \ + "${srcdir}/util/*/*/*.hpp" \ + "${srcdir}/util/*/*/*/*.h" \ + "${srcdir}/util/*/*/*/*.cc" \ + "${srcdir}/util/*/*/*/*.tcc" \ + "${srcdir}/util/*/*/*/*.hpp" \ + "${srcdir}/util/*/*/*/*/*.h" \ + "${srcdir}/util/*/*/*/*/*.cc" \ + "${srcdir}/util/*/*/*/*/*.tcc" \ + "${srcdir}/util/*/*/*/*/*.hpp" ] { + # Remove everything up to "util/..." + set dst [string range $src [string length "${srcdir}/"] end] + # Create the directory containing the file. + set dir [file dirname $dst] + remote_exec host "mkdir" [list "-p" "$dir"] + # Download the file. + set result [remote_download host $src $dst] + if { $result == "" } { + verbose -log "Unable to download ${srcdir}/${src} to host." + return "untested" + } + } + set includes "-Iutil" + } elseif { [file exists $flags_file] } { + # If we find a testsuite_flags file, we're testing in the build dir. + set cxx [exec sh $flags_file --build-cxx] + set cxxflags [exec sh $flags_file --cxxflags] + set cxxpchflags [exec sh $flags_file --cxxpchflags] + set cxxldflags [exec sh $flags_file --cxxldflags] + set cc [exec sh $flags_file --build-cc] + set includes [exec sh $flags_file --build-includes] + } + append cxxflags " " + append cxxflags [getenv CXXFLAGS] + v3track cxxflags 2 + + # Always use MO files built by this test harness. + set cxxflags "$cxxflags -DLOCALEDIR=\".\"" + set ccflags "$cxxflags -DLOCALEDIR=\".\"" + + # If a PCH file is available, use it. We must delay performing + # this check until $cxx and such have been initialized because we + # perform a test compilation. (Ideally, gcc --print-file-name would + # list PCH files, but it does not.) + if { $cxxpchflags != "" } { + set src "config[pid].cc" + set f [open $src "w"] + puts $f "int main () {}" + close $f + + # Fixme: "additional_flags=$cxxpchflags" fails, but would be + # useful as then the requested variant of the pre-build PCH + # files could be tested to see if it works. + set lines [v3_target_compile $src "config[pid].o" object \ + "additional_flags=-include additional_flags=bits/stdc++.h"] + if { $lines != "" } { + verbose -log "Requested PCH file: $cxxpchflags" + verbose -log "is not working, and will not be used." + set cxxpchflags "" + } + file delete $src + } + v3track cxxpchflags 2 + + global PCH_CXXFLAGS + if ![info exists PCH_CXXFLAGS] then { + set PCH_CXXFLAGS $cxxpchflags + v3track PCH_CXXFLAGS 2 + } + + libstdc++_maybe_build_wrapper "${objdir}/testglue.o" "-fexceptions" +} + +# Callback for cleanup routines. +proc libstdc++_exit { } { + global gluefile; + + if [info exists gluefile] { + file_on_build delete $gluefile; + unset gluefile; + } +} + +# Callback from system dg-test. +proc libstdc++-dg-test { prog do_what extra_tool_flags } { + # Set up the compiler flags, based on what we're going to do. + switch $do_what { + "preprocess" { + set compile_type "preprocess" + set output_file "[file rootname [file tail $prog]].i" + } + "compile" { + set compile_type "assembly" + set output_file "[file rootname [file tail $prog]].s" + } + "assemble" { + set compile_type "object" + set output_file "[file rootname [file tail $prog]].o" + } + "link" { + set compile_type "executable" + set output_file "./[file rootname [file tail $prog]].exe" + } + "run" { + set compile_type "executable" + # FIXME: "./" is to cope with "." not being in $PATH. + # Should this be handled elsewhere? + # YES. + set output_file "./[file rootname [file tail $prog]].exe" + # This is the only place where we care if an executable was + # created or not. If it was, dg.exp will try to run it. + catch { remote_file build delete $output_file } + } + default { + perror "$do_what: not a valid dg-do keyword" + return "" + } + } + + # Short-circut a bunch of complicated goo here for the special + # case of compiling a test file as a "C" file, not as C++. Why? So + # -nostdc++ doesn't trip us up. So all the extra object files + # don't trip us up. So automatically linking in libstdc++ doesn't + # happen. So CXXFLAGS don't error. + set select_compile "v3_target_compile" + set options "" + if { $extra_tool_flags != "" } { + verbose -log "extra_tool_flags are:" + verbose -log $extra_tool_flags + if { [string first "-x c" $extra_tool_flags ] != -1 } { + verbose -log "compiling and executing as C, not C++" + set edit_tool_flags $extra_tool_flags + regsub -all ".x c" $edit_tool_flags "" edit_tool_flags + lappend options "additional_flags=$edit_tool_flags" + set select_compile "v3_target_compile_as_c" + } else { + lappend options "additional_flags=$extra_tool_flags" + } + } + + # There is a libstdc++_compile made for us by default (via the tool- + # and-target file), but the defaults are lacking in goodness. + set comp_output [$select_compile "$prog" "$output_file" "$compile_type" $options]; + + return [list $comp_output $output_file] +} + +# Override the DejaGnu dg-test in order to clear flags after a test, as +# is done for compiler tests in gcc-dg.exp. + +if { [info procs saved-dg-test] == [list] } { + rename dg-test saved-dg-test + + proc dg-test { args } { + global additional_prunes + global errorInfo + + if { [ catch { eval saved-dg-test $args } errmsg ] } { + set saved_info $errorInfo + set additional_prunes "" + unset_timeout_vars + error $errmsg $saved_info + } + set additional_prunes "" + unset_timeout_vars + } +} + +# True if the library supports wchar_t. +set v3-wchar_t 0 + +# True if the library supports threads. +set v3-threads 0 + +# True if the library supports symbol versioning. +set v3-symver 0 + +# Called from libstdc++-dg-test above. Calls back into system's +# target_compile to actually do the work. +proc v3_target_compile { source dest type options } { + global gluefile + global wrap_flags + global cxx + global cxxflags + global cxxldflags + global includes + global STATIC_LIBCXXFLAGS + + if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } { + lappend options "libs=${gluefile}" + lappend options "ldflags=${wrap_flags}" + } + + set cxx_final $cxx + set cxxlibglossflags [libgloss_link_flags] + set cxx_final [concat $cxx_final $cxxlibglossflags] + set cxx_final [concat $cxx_final $STATIC_LIBCXXFLAGS] + set cxx_final [concat $cxx_final $cxxflags] + set cxx_final [concat $cxx_final $includes] + + # Flag setting based on type argument. + if { $type == "executable" } { + # Link the support objects into executables. + lappend options "additional_flags=./libtestc++.a $cxxldflags" + } else { + if { $type == "sharedlib" } { + # Don't link in anything. + set type "executable" + } + } + + lappend options "compiler=$cxx_final" + lappend options "timeout=[timeout_value]" + + return [target_compile $source $dest $type $options] +} + + +# Called from libstdc++-dg-test above, but only for "C" compilation. +# Calls back into system's target_compile to actually do the work. +proc v3_target_compile_as_c { source dest type options } { + global gluefile + global wrap_flags + global includes + global flags_file + global blddir + global cc + global cxxflags + global STATIC_LIBCXXFLAGS + + if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } { + lappend options "libs=${gluefile}" + lappend options "ldflags=${wrap_flags}" + } + + set tname [target_info name] + set cc_final $cc + set cxxlibglossflags [libgloss_link_flags] + set cc_final [concat $cc_final $cxxlibglossflags] + set cc_final [concat $cc_final $STATIC_LIBCXXFLAGS] + set cc_final [concat $cc_final $cxxflags] + set cc_final [concat $cc_final $includes] + regsub -all {\s[-]nostdinc[+][+]} $cc_final "" cc_final + + # This is needed for "C" tests, as this type of test may need the + # C++ includes. And if we're not testing in the build directory, + # the includes variable is not likely to include the necessary + # info. + if { ![file exists $flags_file] } { + # ??? We need a --print-include-dirs option to GCC, so that + # we can avoid these hacks. The heuristics here will not + # work with non-standard --with-includedir= options. + set version [remote_exec host ${cc} -dumpversion] + # Remove the trailing newline from the output. + set version [string trimright [lindex $version 1]] + set machine [remote_exec host ${cc} -dumpmachine] + set machine [string trimright [lindex $machine 1]] + set comp_base_dir [remote_exec host ${cc} --print-prog-name=cc1] + set comp_base_dir [lindex $comp_base_dir 1] + set comp_base_dir [file dirname [file dirname [file dirname [file dirname [file dirname $comp_base_dir]]]]] + # For a cross compiler, the header files will be located in a + # machine-specific subdirectory. + set crossbase "${comp_base_dir}/${machine}/include/c++/${version}" + set crosstarget "${crossbase}/${machine}" + set cc_final [concat $cc_final "-I$crossbase -I$crosstarget"] + # For a native compiler, the header files will be located at + # the top level. + set includesbase "${comp_base_dir}/include/c++/${version}" + set includestarget "${includesbase}/${machine}" + set cc_final [concat $cc_final "-I$includesbase -I$includestarget"] + + set libdir "-L${comp_base_dir}/lib" + } else { + set libdir "-L${blddir}/libsupc++/.libs" + set libdir [concat $libdir "-L${blddir}/src/.libs"] + } + + set cc_final [concat $cc_final "$libdir"] + + lappend options "compiler=$cc_final" + lappend options "timeout=[timeout_value]" + + return [target_compile $source $dest $type $options] +} + +# Build the support objects linked in with the libstdc++ tests. In +# addition, set v3-wchar_t, v3-threads, and v3-symver appropriately. +proc v3-build_support { } { + global env + global srcdir + global v3-wchar_t + global v3-threads + global v3-symver + global v3-sharedlib + + # Figure out whether or not the library supports certain features. + set v3-wchar_t 0 + set v3-threads 0 + set v3-symver 0 + set libtest_objs "" + + set config_src "config.cc" + set config_out "config.ii" + set f [open $config_src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "#include <bits/gthr.h>" + close $f + v3_target_compile $config_src $config_out preprocess "additional_flags=-dN" + set file [open $config_out r] + set preprocessed [read $file] + close $file + if { [string first "_GLIBCXX_USE_WCHAR_T" $preprocessed] != -1 } { + verbose -log "wchar_t support detected" + set v3-wchar_t 1 + } + if { [string first "_GLIBCXX_SYMVER" $preprocessed] != -1 } { + verbose -log "symbol versioning support detected" + set v3-symver 1 + } + if { [string first "__GTHREADS" $preprocessed] != -1 } { + verbose -log "thread support detected" + set v3-threads 1 + } + + # Try to build the MO files that are used by some of the locale + # tests. If we can't build them, that's OK; it just means that + # those tests will fail. + foreach lang [list "fr" "de"] { + catch { + file mkdir "$lang/LC_MESSAGES" + remote_exec "build" "msgfmt" "-o $lang/LC_MESSAGES/libstdc++.mo $srcdir/../po/$lang.po" + if [is_remote host] { + remote_exec "host" "mkdir" "-p $lang/LC_MESSAGES" + remote_download "host" "$lang/LC_MESSAGES/libstdc++.mo" "$lang/LC_MESSAGES/libstdc++.mo" + } + } + } + + # Build the support objects. + set source_files [list testsuite_abi.cc testsuite_allocator.cc \ + testsuite_character.cc testsuite_hooks.cc \ + io/verified_cmd_line_input.cc \ + io/prog_bar.cc performance/time/elapsed_timer.cc ] + foreach f $source_files { + set obj [file rootname $f].o + set object_file [file tail $obj] + # Compile with "-w" so that warnings issued by the compiler + # do not prevent compilation. + if { [v3_target_compile $srcdir/util/$f $object_file "object" \ + [list "incdir=$srcdir" "additional_flags=-w"]] + != "" } { + error "could not compile $f" + } + append libtest_objs "$object_file " + } + + # Collect into libtestc++.a + # Delete libtestc++.a first. Mixed 32 and 64-bit archives cannot be + # linked on IRIX 6. + # Use same procedure as gcc-dg.exp (remove-build-file). + if [is_remote host] { + # Ensure the host knows the file is gone by deleting there + # first. + remote_file host delete "./libtestc++.a" + } + remote_file build delete "./libtestc++.a" + if [info exists env(AR)] { + set ar $env(AR) + } else { + set ar [transform "ar"] + } + set arargs "-rc ./libtestc++.a ${libtest_objs}" + verbose -log "$ar $arargs" + set result [lindex [remote_exec host "$ar" "$arargs"] 0] + verbose "link result is $result" + if { $result == 0 } { + if [info exists env(RANLIB)] { + set ranlib $env(RANLIB) + } else { + set ranlib [transform "ranlib"] + } + set ranlibargs "./libtestc++.a" + verbose -log "$ranlib $ranlibargs" + set result [lindex [remote_exec host "$ranlib" "$ranlibargs"] 0] + if { $result != 0 } { + error "could not link libtestc++.a" + } + } + + # Build any shared objects needed for regression testing. + if { ${v3-sharedlib} == 1 } { + set source_files [list testsuite_shared.cc] + foreach f $source_files { + set object_file [file rootname $f].so + # Compile with "-w" so that warnings issued by the compiler + # do not prevent compilation. + if { [v3_target_compile $srcdir/util/$f $object_file "sharedlib" \ + [list "incdir=$srcdir" "additional_flags=-w -shared -fPIC -DPIC"]] + != "" } { + error "could not compile $f" + } + } + } +} + +proc check_v3_target_fileio { } { + global et_fileio_saved + global et_fileio_target_name + global tool + global srcdir + + if { ![info exists et_fileio_target_name] } { + set et_fileio_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_fileio_target_name } { + verbose "check_v3_target_fileio: `$et_fileio_target_name'" 2 + set et_fileio_target_name $current_target + if [info exists et_fileio_saved] { + verbose "check_v3_target_fileio: removing cached result" 2 + unset et_fileio_saved + } + } + + if [info exists et_fileio_saved] { + verbose "check_v3_target_fileio: using cached result" 2 + } else { + set et_fileio_saved 0 + + # Set up, compile, and execute a C++ test program that tries to use + # the file functions + set src fileio[pid].cc + set exe fileio[pid].x + set testfile "cin_unget-1.txt" + v3-copy-files "$srcdir/data/$testfile" + + set f [open $src "w"] + puts $f "#include <sys/types.h>" + puts $f "#include <sys/stat.h>" + puts $f "#include <fcntl.h>" + puts $f "#include <unistd.h>" + puts $f "#include <errno.h>" + puts $f "#include <string.h>" + puts $f "using namespace std;" + puts $f "int main ()" + puts $f "{" + puts $f " int fd = open (\"$testfile\", O_RDONLY);" + puts $f " int ret = 0;" + puts $f " char buf\[10\];" + puts $f " if (fd == -1)" + puts $f " ret = 1;" + puts $f " else" + puts $f " {" + puts $f " if (lseek (fd, -1, SEEK_CUR) != -1 || errno != EINVAL)" + puts $f " ret = 1;" + puts $f " errno = 0;" + puts $f " if (lseek (fd, 0, SEEK_CUR) != 0" + puts $f " || read (fd, buf, 4) != 4" + puts $f " || memcmp (buf, \"1234\", 4) != 0" + puts $f " || lseek (fd, -2, SEEK_CUR) != 2" + puts $f " || read (fd, buf, 2) != 2" + puts $f " || memcmp (buf, \"34\", 2) != 0)" + puts $f " ret = 1;" + puts $f " close (fd);" + puts $f " }" + puts $f " return ret;" + puts $f "}" + close $f + + set lines [v3_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_v3_target_fileio: status is <$status>" 2 + + if { $status == "pass" } { + set et_fileio_saved 1 + } + } else { + verbose "check_v3_target_fileio: compilation failed" 2 + } + } + return $et_fileio_saved +} + +# Eventually we want C90/C99 determining and switching from this. +proc check_v3_target_c_std { } { + global et_c_std_saved + global et_c_std_target_name + global tool + + if { ![info exists et_c_std_target_name] } { + set et_c_std_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_c_std_target_name } { + verbose "check_v3_target_c_std: `$et_c_std_target_name'" 2 + set et_c_std_target_name $current_target + if [info exists et_c_std_saved] { + verbose "check_v3_target_c_std: removing cached result" 2 + unset et_c_std_saved + } + } + + if [info exists et_c_std_saved] { + verbose "check_v3_target_c_std: using cached result" 2 + } else { + set et_c_std_saved 0 + + # Set up, compile, and execute a C++ test program that tries to use + # C99 functionality. + # For math bits, could use check_effective_target_c99_math. + set src fileio[pid].cc + set exe fileio[pid].x + + set f [open $src "w"] + puts $f "#include <tr1/cmath>" + puts $f "#include <cstdlib>" + puts $f "int main ()" + puts $f "{" + puts $f " float f = 45.55;" + puts $f " int i = std::tr1::isnan(f);" + puts $f " " + puts $f " using std::wctomb;" + puts $f " return i;" + puts $f "}" + close $f + + set lines [v3_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_v3_target_c_std: status is <$status>" 2 + + if { $status == "pass" } { + set et_c_std_saved 1 + } + } else { + verbose "check_v3_target_c_std: compilation failed" 2 + } + } + return $et_c_std_saved +} + +proc check_v3_target_sharedlib { } { + global v3-sharedlib + return ${v3-sharedlib} +} + +proc check_v3_target_time { } { + global et_time_saved + global et_time_target_name + global tool + + if { ![info exists et_time_target_name] } { + set et_time_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_time_target_name } { + verbose "check_v3_target_time: `$et_time_target_name'" 2 + set et_time_target_name $current_target + if [info exists et_time_saved] { + verbose "check_v3_target_time: removing cached result" 2 + unset et_time_saved + } + } + + if [info exists et_time_saved] { + verbose "check_v3_target_time: using cached result" 2 + } else { + set et_time_saved 0 + + # Set up and compile a C++ test program that tries to use + # the time function + set src time[pid].cc + set exe time[pid].x + + set f [open $src "w"] + puts $f "#include <time.h>" + puts $f "using namespace std;" + puts $f "int main ()" + puts $f "{" + puts $f " time (0);" + puts $f "}" + close $f + + set lines [v3_target_compile $src $exe executable ""] + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + verbose "check_v3_target_time: compilation succeeded" 2 + remote_file build delete $exe + set et_time_saved 1 + } else { + verbose "check_v3_target_time: compilation failed" 2 + } + } + return $et_time_saved +} + +proc check_v3_target_namedlocale { args } { + global et_namedlocale + global tool + + set et_namedlocale 0 + + # Set up, compile, and execute a C++ test program that tries to use + # the required named locale. + set exe nlocale[pid].x + + if ![file exists ./$exe] { + set src nlocale[pid].cc + + set f [open $src "w"] + puts $f "#include <locale>" + puts $f "#include <cstdio>" + puts $f "using namespace std;" + puts $f "int main (int argc, char** argv)" + puts $f "{" + puts $f " try" + puts $f " {" + puts $f " locale(*(argv + 1));" + puts $f " return 0;" + puts $f " }" + puts $f " catch(...)" + puts $f " {" + puts $f " printf(\"locale '%s' not supported\\n\", *(argv + 1));" + puts $f " return 1;" + puts $f " }" + puts $f "}" + close $f + + set lines [v3_target_compile $src $exe executable ""] + file delete $src + + if ![string match "" $lines] { + verbose "check_v3_target_namedlocale: compilation failed" 2 + return $et_namedlocale + } + # else No error message, compilation succeeded. + } + + set result [${tool}_load "./$exe" "$args" ""] + set status [lindex $result 0] + + verbose "check_v3_target_namedlocale <$args>: status is <$status>" 2 + + if { $status == "pass" } { + set et_namedlocale 1 + } + return $et_namedlocale +} + +proc check_v3_target_debug_mode { } { + global et_debug_mode + global tool + + if { ![info exists et_debug_mode_target_name] } { + set et_debug_mode_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_debug_mode_target_name } { + verbose "check_v3_target_debug_mode: `$et_debug_mode_target_name'" 2 + set et_debug_mode_target_name $current_target + if [info exists et_debug_mode] { + verbose "check_v3_target_debug_mode: removing cached result" 2 + unset et_debug_mode + } + } + + if [info exists et_debug_mode] { + verbose "check_v3_target_debug_mode: using cached result" 2 + } else { + set et_debug_mode 0 + + # Set up and compile a C++ test program that depends + # on debug mode activated. + set src debug_mode[pid].cc + set exe debug_mode[pid].exe + + set f [open $src "w"] + puts $f "#ifndef _GLIBCXX_DEBUG" + puts $f "# error No debug mode" + puts $f "#endif" + puts $f "int main()" + puts $f "{ return 0; }" + close $f + + set lines [v3_target_compile $src $exe executable ""] + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + remote_file build delete $exe + set et_debug_mode 1 + } + } + verbose "check_v3_target_debug_mode: $et_debug_mode" 2 + return $et_debug_mode +} + +proc check_v3_target_profile_mode { } { + global et_profile_mode + global tool + + if { ![info exists et_profile_mode_target_name] } { + set et_profile_mode_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_profile_mode_target_name } { + verbose "check_v3_target_profile_mode: `$et_profile_mode_target_name'" 2 + set et_profile_mode_target_name $current_target + if [info exists et_profile_mode] { + verbose "check_v3_target_profile_mode: removing cached result" 2 + unset et_profile_mode + } + } + + if [info exists et_profile_mode] { + verbose "check_v3_target_profile_mode: using cached result" 2 + } else { + set et_profile_mode 0 + + # Set up and compile a C++ test program that depends + # on profile mode activated. + set src profile_mode[pid].cc + set exe profile_mode[pid].exe + + set f [open $src "w"] + puts $f "#ifndef _GLIBCXX_PROFILE" + puts $f "# error No profile mode" + puts $f "#endif" + puts $f "int main()" + puts $f "{ return 0; }" + close $f + + set lines [v3_target_compile $src $exe executable ""] + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + remote_file build delete $exe + set et_profile_mode 1 + } + } + verbose "check_v3_target_profile_mode: $et_profile_mode" 2 + return $et_profile_mode +} + +proc check_v3_target_normal_mode { } { + global et_normal_mode + global tool + + if { ![info exists et_normal_mode_target_name] } { + set et_normal_mode_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_normal_mode_target_name } { + verbose "check_v3_target_normal_mode: `$et_normal_mode_target_name'" 2 + set et_normal_mode_target_name $current_target + if [info exists et_normal_mode] { + verbose "check_v3_target_normal_mode: removing cached result" 2 + unset et_normal_mode + } + } + + if [info exists et_normal_mode] { + verbose "check_v3_target_normal_mode: using cached result" 2 + } else { + set et_normal_mode 0 + + # Set up and compile a C++ test program that depends + # on normal mode activated. + set src normal_mode[pid].cc + set exe normal_mode[pid].exe + + set f [open $src "w"] + puts $f "#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE) || defined(_GLIBCXX_PARALLEL)" + puts $f "# error No normal mode" + puts $f "#endif" + puts $f "int main()" + puts $f "{ return 0; }" + close $f + + set lines [v3_target_compile $src $exe executable ""] + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_normal_mode 1 + } + } + verbose "check_v3_target_normal_mode: $et_normal_mode" 2 + return $et_normal_mode +} + +proc check_v3_target_parallel_mode { } { + global cxxflags + global v3-libgomp + global et_parallel_mode + + global tool + + if { ![info exists et_parallel_mode_target_name] } { + set et_parallel_mode_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_parallel_mode_target_name } { + verbose "check_v3_target_parallel_mode: `$et_parallel_mode_target_name'" 2 + set et_parallel_mode_target_name $current_target + if [info exists et_parallel_mode] { + verbose "check_v3_target_parallel_mode: removing cached result" 2 + unset et_parallel_mode + } + } + + if [info exists et_parallel_mode] { + verbose "check_v3_target_parallel_mode: using cached result" 2 + } else { + set et_parallel_mode 0 + + # If 'make check-parallel' is running the test succeeds. + if { ${v3-libgomp} == 1 && [regexp "libgomp" $cxxflags] } { + set et_parallel_mode 1 + } + } + verbose "check_v3_target_parallel_mode: $et_parallel_mode" 2 + return $et_parallel_mode +} + +proc check_v3_target_cstdint { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_cstdint + + global tool + + if { ![info exists et_cstdint_target_name] } { + set et_cstdint_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_cstdint_target_name } { + verbose "check_v3_target_cstdint: `$et_cstdint_target_name'" 2 + set et_cstdint_target_name $current_target + if [info exists et_cstdint] { + verbose "check_v3_target_cstdint: removing cached result" 2 + unset et_cstdint + } + } + + if [info exists et_cstdint] { + verbose "check_v3_target_cstdint: using cached result" 2 + } else { + set et_cstdint 0 + + # Set up and compile a C++0x test program that depends + # on the C99 stdint facilities to be available. + set src cstdint[pid].cc + set exe cstdint[pid].exe + + set f [open $src "w"] + puts $f "#include <tr1/cstdint>" + puts $f "int main()" + puts $f "#ifdef _GLIBCXX_USE_C99_STDINT_TR1" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_cstdint 1 + } else { + verbose "check_v3_target_cstdint: compilation failed" 2 + } + } + verbose "check_v3_target_cstdint: $et_cstdint" 2 + return $et_cstdint +} + +proc check_v3_target_atomic_builtins { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_cstdint + + global tool + + if { ![info exists et_atomic_builtins_target_name] } { + set et_atomic_builtins_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_atomic_builtins_target_name } { + verbose "check_v3_target_atomic_builtins: `$et_atomic_builtins_target_name'" 2 + set et_atomic_builtins_target_name $current_target + if [info exists et_atomic_builtins] { + verbose "check_v3_target_atomic_builtins: removing cached result" 2 + unset et_atomic_builtins + } + } + + if [info exists et_atomic_builtins] { + verbose "check_v3_target_atomic_builtins: using cached result" 2 + } else { + set et_atomic_builtins 0 + + # Set up and compile a C++0x test program that depends + # on the atomic builtin facilities to be available. + set src atomic_builtins[pid].cc + set exe atomic_builtins[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#ifdef _GLIBCXX_ATOMIC_BUILTINS_4" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_atomic_builtins 1 + } else { + verbose "check_v3_target_atomic_builtins: compilation failed" 2 + } + } + verbose "check_v3_target_atomic_builtins: $et_atomic_builtins" 2 + return $et_atomic_builtins +} + +proc check_v3_target_gthreads { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_gthreads + + global tool + + if { ![info exists et_gthreads_target_name] } { + set et_gthreads_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_gthreads_target_name } { + verbose "check_v3_target_gthreads: `$et_gthreads_target_name'" 2 + set et_gthreads_target_name $current_target + if [info exists et_gthreads] { + verbose "check_v3_target_gthreads: removing cached result" 2 + unset et_gthreads + } + } + + if [info exists et_gthreads] { + verbose "check_v3_target_gthreads: using cached result" 2 + } else { + set et_gthreads 0 + + # Set up and compile a C++0x test program that depends + # on the gthreads facilities to be available. + set src gthreads[pid].cc + set exe gthreads[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#ifdef _GLIBCXX_HAS_GTHREADS" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_gthreads 1 + } else { + verbose "check_v3_target_gthreads: compilation failed" 2 + } + } + verbose "check_v3_target_gthreads: $et_gthreads" 2 + return $et_gthreads +} + +proc check_v3_target_nanosleep { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_nanosleep + + global tool + + if { ![info exists et_nanosleep_target_name] } { + set et_nanosleep_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_nanosleep_target_name } { + verbose "check_v3_target_nanosleep: `$et_nanosleep_target_name'" 2 + set et_nanosleep_target_name $current_target + if [info exists et_nanosleep] { + verbose "check_v3_target_nanosleep: removing cached result" 2 + unset et_nanosleep + } + } + + if [info exists et_nanosleep] { + verbose "check_v3_target_nanosleep: using cached result" 2 + } else { + set et_nanosleep 0 + + # Set up and compile a C++0x test program that depends + # on the nanosleep facilities to be available. + set src nanosleep[pid].cc + set exe nanosleep[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#ifdef _GLIBCXX_USE_NANOSLEEP" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_nanosleep 1 + } else { + verbose "check_v3_target_nanosleep: compilation failed" 2 + } + } + verbose "check_v3_target_nanosleep: $et_nanosleep" 2 + return $et_nanosleep +} + +proc check_v3_target_sched_yield { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_sched_yield + + global tool + + if { ![info exists et_sched_yield_target_name] } { + set et_sched_yield_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_sched_yield_target_name } { + verbose "check_v3_target_sched_yield: `$et_sched_yield_target_name'" 2 + set et_sched_yield_target_name $current_target + if [info exists et_sched_yield] { + verbose "check_v3_target_sched_yield: removing cached result" 2 + unset et_sched_yield + } + } + + if [info exists et_sched_yield] { + verbose "check_v3_target_sched_yield: using cached result" 2 + } else { + set et_sched_yield 0 + + # Set up and compile a C++0x test program that depends + # on the sched_yield facility to be available. + set src sched_yield[pid].cc + set exe sched_yield[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#ifdef _GLIBCXX_USE_SCHED_YIELD" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_sched_yield 1 + } else { + verbose "check_v3_target_sched_yield: compilation failed" 2 + } + } + verbose "check_v3_target_sched_yield: $et_sched_yield" 2 + return $et_sched_yield +} + +proc check_v3_target_string_conversions { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_string_conversions + + global tool + + if { ![info exists et_string_conversions_target_name] } { + set et_string_conversions_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_string_conversions_target_name } { + verbose "check_v3_target_string_conversions: `$et_string_conversions_target_name'" 2 + set et_string_conversions_target_name $current_target + if [info exists et_string_conversions] { + verbose "check_v3_target_string_conversions: removing cached result" 2 + unset et_string_conversions + } + } + + if [info exists et_string_conversions] { + verbose "check_v3_target_string_conversions: using cached result" 2 + } else { + set et_string_conversions 0 + + # Set up and compile a C++0x test program that depends + # on the string_conversions facilities to be available. + set src string_conversions[pid].cc + set exe string_conversions[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#if defined(_GLIBCXX_USE_C99) && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_string_conversions 1 + } else { + verbose "check_v3_target_string_conversions: compilation failed" 2 + } + } + verbose "check_v3_target_string_conversions: $et_string_conversions" 2 + return $et_string_conversions +} + +proc check_v3_target_swprintf { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_swprintf + + global tool + + if { ![info exists et_swprintf_target_name] } { + set et_swprintf_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_swprintf_target_name } { + verbose "check_v3_target_swprintf: `$et_swprintf_target_name'" 2 + set et_swprintf_target_name $current_target + if [info exists et_swprintf] { + verbose "check_v3_target_swprintf: removing cached result" 2 + unset et_swprintf + } + } + + if [info exists et_swprintf] { + verbose "check_v3_target_swprintf: using cached result" 2 + } else { + set et_swprintf 0 + + # Set up and compile a C++0x test program that depends + # on a standard swprintf function to be available. + set src swprintf[pid].cc + set exe swprintf[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#if !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_swprintf 1 + } else { + verbose "check_v3_target_swprintf: compilation failed" 2 + } + } + verbose "check_v3_target_swprintf: $et_swprintf" 2 + return $et_swprintf +} + +proc check_v3_target_binary_io { } { + global cxxflags + global DEFAULT_CXXFLAGS + global et_binary_io + + global tool + + if { ![info exists et_binary_io_target_name] } { + set et_binary_io_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_binary_io_target_name } { + verbose "check_v3_target_binary_io: `$et_binary_io_target_name'" 2 + set et_binary_io_target_name $current_target + if [info exists et_binary_io] { + verbose "check_v3_target_binary_io: removing cached result" 2 + unset et_binary_io + } + } + + if [info exists et_binary_io] { + verbose "check_v3_target_binary_io: using cached result" 2 + } else { + set et_binary_io 0 + + # Set up and compile a C++0x test program that depends + # on text and binary I/O being the same. + set src binary_io[pid].cc + set exe binary_io[pid].exe + + set f [open $src "w"] + puts $f "#include <bits/c++config.h>" + puts $f "int main()" + puts $f "#if !defined(_GLIBCXX_HAVE_DOS_BASED_FILESYSTEM)" + puts $f "{ return 0; }" + puts $f "#endif" + close $f + + set cxxflags_saved $cxxflags + set cxxflags "$cxxflags $DEFAULT_CXXFLAGS -Werror" + + set lines [v3_target_compile $src $exe executable ""] + set cxxflags $cxxflags_saved + file delete $src + + if [string match "" $lines] { + # No error message, compilation succeeded. + set et_binary_io 1 + } else { + verbose "check_v3_target_binary_io: compilation failed" 2 + } + } + verbose "check_v3_target_binary_io: $et_binary_io" 2 + return $et_binary_io +} + +set additional_prunes "" diff --git a/libstdc++-v3/testsuite/lib/prune.exp b/libstdc++-v3/testsuite/lib/prune.exp new file mode 100644 index 000000000..a1d8d083e --- /dev/null +++ b/libstdc++-v3/testsuite/lib/prune.exp @@ -0,0 +1,66 @@ +# Copyright (C) 1997, 1999, 2000, 2001, 2004, 2009 +# 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 +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +# Prune messages from g++ that aren't useful. + +# Prune any messages matching ARGS[1] (a regexp) from test output. +proc dg-prune-output { args } { + global additional_prunes + + if { [llength $args] != 2 } { + error "[lindex $args 1]: need one argument" + return + } + + lappend additional_prunes [lindex $args 1] +} + +proc libstdc++-dg-prune { system text } { + global additional_prunes + + # Cygwin warns about -ffunction-sections + regsub -all "(^|\n)\[^\n\]*: -ffunction-sections may affect debugging on some targets\[^\n\]*" $text "" text + + # Remove parts of warnings that refer to location of previous + # definitions, etc as these confuse dejagnu + regsub -all "(^|\n)(\[^\n\]*: )?In ((static member |lambda )?function|member|method|(copy )?constructor|destructor|instantiation|program|subroutine|block-data)\[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*(: )?At (top level|global scope):\[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*: (recursively )?instantiated from \[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*: . skipping \[0-9\]* instantiation contexts \[^\n\]*" $text "" text + regsub -all "(^|\n) inlined from \[^\n\]*" $text "" text + # Why doesn't GCC need these to strip header context? + regsub -all "(^|\n)In file included from \[^\n\]*" $text "" text + regsub -all "(^|\n)\[ \t\]*from \[^\n\]*" $text "" text + + # Ignore errata warning from IA64 assembler. + regsub -all "(^|\n)\[^\n\]*: Additional NOP may be necessary to workaround Itanium processor A/B step errata" $text "" text + regsub -all "(^|\n)\[^\n*\]*: Assembler messages:\[^\n\]*" $text "" text + + # Ignore harmless warnings from Xcode 3.2.x. + regsub -all "(^|\n)\[^\n\]*ld: warning: can't add line info to anonymous symbol\[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*warning: DWARFDebugInfoEntry::AppendDependants\[^\n\]*AT_\[^\n\]*_bound\[^\n\]*FORM_ref4\[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*warning:\[^\n\]*TAG_variable: AT_location\[^\n\]*didn't have valid function low pc\[^\n\]*" $text "" text + + foreach p $additional_prunes { + if { [string length $p] > 0 } { + # Following regexp matches a complete line containing $p. + regsub -all "(^|\n)\[^\n\]*$p\[^\n\]*" $text "" text + } + } + + return $text +} |