# libstdc++ "tool init file" for DejaGNU
-# Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+# 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
global env
global v3-sharedlib
global srcdir blddir objdir tool_root_dir
- global cxx cxxflags cxxldflags
+ global cc cxx cxxflags cxxpchflags cxxldflags
global includes
global gluefile wrap_flags
global ld_library_path
global target_triplet
+ global flags_file
# We set LC_ALL and LANG to C so that we get the same error
# messages as expected.
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
- # Look for shared library. (ie libstdc++.so.)
+ # Locate libgomp. This is only required for parallel mode.
+ set libgompdir [lookfor_file $blddir/../libgomp .libs/libgomp.so]
+ if {$libgompdir != ""} {
+ set libgompdir [file dirname $libgompdir]
+ append ld_library_path_tmp ":${libgompdir}"
+ }
+ v3track libgompdir 3
+
+ # Locate libstdc++ shared library. (ie libstdc++.so.)
set v3-sharedlib 0
set sharedlibdir [lookfor_file $blddir src/.libs/libstdc++.so]
if {$sharedlibdir != ""} {
# Compute what needs to be added to the existing LD_LIBRARY_PATH.
if {$gccdir != ""} {
- set ld_library_path ""
- append ld_library_path ":${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 } {
set compiler [transform "g++"]
}
- # Do a bunch of handstands and backflips for cross compiling and
- # finding simulators...
+ # 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] {
- set header [remote_download host ${blddir}/testsuite/util/testsuite_hooks.h]
- if { $header == "" } {
- verbose -log "Unable to download ${blddir}/testsuite/util/testsuite_hooks.h to host."
- return "untested"
- }
- set cxx [transform "g++"]
- set cxxflags "-ggdb3"
- set cxxldflags ""
- set includes "-I./"
- } else {
+ # 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/*/*.hpp" \
+ "${srcdir}/util/*/*.cc" \
+ "${srcdir}/util/*/*.hpp" \
+ "${srcdir}/util/*/*/*.cc" \
+ "${srcdir}/util/*/*/*.hpp" \
+ "${srcdir}/util/*/*/*/*.cc" \
+ "${srcdir}/util/*/*/*/*.hpp" \
+ "${srcdir}/util/*/*/*/*/*.cc" \
+ "${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.
- if { [file exists $flags_file] } {
- set cxx [exec sh $flags_file --build-cxx]
- set cxxflags [exec sh $flags_file --cxxflags]
- set cxxldflags [exec sh $flags_file --cxxldflags]
- set includes [exec sh $flags_file --build-includes]
- } else {
- set cxx [transform "g++"]
- set includes "-I${srcdir}/util"
- set cxxldflags ""
- set cxxflags "-g -O2 -D_GLIBCXX_ASSERT -fmessage-length=0"
- }
+ 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.)
- global PCH_CXXFLAGS
- if ![info exists PCH_CXXFLAGS] then {
+ 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 == "" } {
- set PCH_CXXFLAGS "-include bits/stdc++.h"
- } else {
- set PCH_CXXFLAGS ""
- }
+ 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"
+ libstdc++_maybe_build_wrapper "${objdir}/testglue.o" "-fexceptions"
}
# Callback for cleanup routines.
}
}
+ # 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 } {
- # Short-circut a bunch of complicated goo here for the
- # special case of compiling a test file as a "C" file, not
- # as C++: just use target_compile, instead of the usual
- # gimmicks.
verbose -log "compiling and executing as C, not C++"
- set compile_type "executable"
- set output_file "./[file rootname [file tail $prog]].exe"
- remote_file build delete $output_file;
- lappend options "additional_flags=$extra_tool_flags"
- set comp_output [target_compile "$prog" "$output_file" "$compile_type" $options];
- set comp_output [ prune_g++_output $comp_output ];
- return [list $comp_output $output_file]
+ 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 [v3_target_compile "$prog" "$output_file" "$compile_type" $options];
+ set comp_output [$select_compile "$prog" "$output_file" "$compile_type" $options];
set comp_output [ prune_g++_output $comp_output ];
return [list $comp_output $output_file]
# True if the library supports symbol versioning.
set v3-symver 0
-# A string naming object files to be linked into all tests.
-set v3-test_objs ""
-
# 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 cxxflags
global cxxldflags
global includes
- global blddir
- global v3-test_objs
if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } {
lappend options "libs=${gluefile}"
# Flag setting based on type argument.
if { $type == "executable" } {
# Link the support objects into executables.
- set cxx_final [concat $cxx_final ${v3-test_objs}]
set cxx_final [concat $cxx_final $cxxldflags]
+ lappend options "additional_flags=./libtestc++.a"
} else {
if { $type == "sharedlib" } {
# Don't link in anything.
}
lappend options "compiler=$cxx_final"
+ lappend options "timeout=600"
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
+
+ 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 $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=600"
+
+ 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, v3-test_objs, and v3-symver
-# appropriately.
+# 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-test_objs
global v3-symver
global v3-sharedlib
set v3-wchar_t 0
set v3-threads 0
set v3-symver 0
- set v3-test_objs ""
+ 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
- set preprocessed [v3_target_compile $config_src "" \
- preprocess "additional_flags=-dN"]
+ 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
set source_files [list testsuite_abi.cc testsuite_allocator.cc \
testsuite_character.cc testsuite_hooks.cc \
rng/twister_rand_gen.cc io/verified_cmd_line_input.cc \
- io/prog_bar.cc regression/res_mng/dbg_ex_allocator_base.cc \
- performance/time/elapsed_timer.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]
!= "" } {
error "could not compile $f"
}
- append v3-test_objs "$object_file "
+ append libtest_objs "$object_file "
}
# Collect into libtestc++.a
- set arcommand "ar -rc ./libtestc++.a ${v3-test_objs}"
- set result [lindex [local_exec "$arcommand" "" "" 300] 0]
+ 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 } {
- set ranlibcommand "ranlib ./libtestc++.a"
- set result [lindex [local_exec "$ranlibcommand" "" "" 300] 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"
-
- # We cannot actually use libtestc++.a because it's hard to
- # position this library after the test file being compiled
- # on the constructed compile line. However, we use this as
- # a convenience for performance testing.
- #set v3-test_objs "./libtestc++.a"
}
}
}
}
+proc check_v3_target_fileio { } {
+ global et_fileio_saved
+ global et_fileio_target_name
+ global tool
+
+ 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 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 "using namespace std;"
+ puts $f "int main ()"
+ puts $f "{"
+ puts $f " int fd = open (\".\", O_RDONLY);"
+ puts $f " int ret = 0;"
+ puts $f " if (fd == -1)"
+ puts $f " {"
+ puts $f " int err = errno;"
+ puts $f " if (err == EIO || err == ENOSYS)"
+ puts $f " ret = 1;"
+ puts $f " }"
+ puts $f " else"
+ puts $f " {"
+ puts $f " if (lseek (fd, 0, SEEK_CUR) == -1)"
+ 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 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.
+ 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_rvalref { } {
+ global et_rvalref_saved
+ global et_rvalref_target_name
+ global tool
+
+ if { ![info exists et_rvalref_target_name] } {
+ set et_rvalref_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_rvalref_target_name } {
+ verbose "check_v3_target_rvalref: `$et_rvalref_target_name'" 2
+ set et_rvalref_target_name $current_target
+ if [info exists et_rvalref_saved] {
+ verbose "check_v3_target_rvalref: removing cached result" 2
+ unset et_rvalref_saved
+ }
+ }
+
+ if [info exists et_rvalref_saved] {
+ verbose "check_v3_target_rvalref: using cached result" 2
+ } else {
+ set et_rvalref_saved 0
+
+ # Set up and compile a C++ test program that tries to use
+ # the library components of rval references
+ set src rvalref[pid].cc
+ set exe rvalref[pid].x
+
+ set f [open $src "w"]
+ puts $f "#include <iterator>"
+ puts $f "#include <utility>"
+ puts $f "using std::move;"
+ puts $f "using std::identity;"
+ puts $f "using std::forward;"
+ puts $f "using std::move_iterator;"
+ puts $f "using std::make_move_iterator;"
+ 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_rvalref: compilation succeeded" 2
+ remote_file build delete $exe
+ set et_rvalref_saved 1
+ } else {
+ verbose "check_v3_target_rvalref: compilation failed" 2
+ }
+ }
+ return $et_rvalref_saved
+}
+
proc check_v3_target_namedlocale { } {
global et_namedlocale_saved
global et_namedlocale_target_name
proc check_v3_target_debug_mode { } {
global cxxflags
global et_debug_mode
-
global tool
if { ![info exists et_debug_mode_target_name] } {
verbose "check_v3_target_debug_mode: $et_debug_mode" 2
return $et_debug_mode
}
+
+proc check_v3_target_parallel_mode { } {
+ global cxxflags
+ global DEFAULT_CXXFLAGS
+ 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
+
+ # Set up, compile, and execute a C++ test program that depends
+ # on parallel mode working.
+ set src parallel_mode[pid].cc
+ set exe parallel_mode[pid].exe
+
+ set f [open $src "w"]
+ puts $f "#include <omp.h>"
+ puts $f "int main()"
+ puts $f "{ return 0; }"
+ 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_parallel_mode 1
+ } else {
+ verbose "check_v3_target_parallel_mode: compilation failed" 2
+ }
+ }
+ verbose "check_v3_target_parallel_mode: $et_parallel_mode" 2
+ return $et_parallel_mode
+}
OSDN Git Service
