gcc/testsuite/libgdiagnostics.dg/libgdiagnostics.exp - gcc.git - Git at Google

 # Test code for libgdiagnostics.so
 #
 # We will compile each of libgdiagnostics.dg/test-*.{c,cc} into an executable
 # dynamically linked against libgdiagnostics.so, and then run each
 # such executable.
 #
 # These executables call into the libgdiagnostics.so API to emit diagnostics,
 # sometimes in text form, and other times in SARIF form.

 # Kludge alert:
 # We need g++_init so that it can find the stdlib include path.
 #
 # g++_init (in lib/g++.exp) uses g++_maybe_build_wrapper,
 # which normally comes from the definition of
 # ${tool}_maybe_build_wrapper within lib/wrapper.exp.
 #
 # However, for us, ${tool} is "libgdiagnostics".
 # Hence we load wrapper.exp with tool == "g++", so that
 # g++_maybe_build_wrapper is defined.
 set tool g++
 load_lib wrapper.exp
 set tool libgdiagnostics

 load_lib dg.exp
 load_lib prune.exp
 load_lib target-supports.exp
 load_lib gcc-defs.exp
 load_lib timeout.exp
 load_lib target-libpath.exp
 load_lib gcc.exp
 load_lib g++.exp
 load_lib dejagnu.exp
 load_lib target-supports-dg.exp
 load_lib valgrind.exp
 load_lib scansarif.exp
 load_lib dg-test-cleanup.exp

 # The default do-what keyword.
 set dg-do-what-default compile

 # Adapted from jit.exp.
 #
 # Execute the executable file.
 #    Returns:
 #	A "" (empty) string if everything worked, or an error message
 #	if there was a problem.
 #
 proc fixed_host_execute {args} {
     global env
     global text
     global spawn_id

     verbose "fixed_host_execute: $args"

     set timeoutmsg "Timed out: Never got started, "
     set timeout 100
     set file all
     set timetol 0
     set arguments ""

     if { [llength $args] == 0} {
 	set executable $args
     } else {
 	set executable [lindex $args 0]
 	set params [lindex $args 1]
     }

     verbose "The executable is $executable" 2
     if {![file exists ${executable}]} {
 	perror "The executable, \"$executable\" is missing" 0
 	return "No source file found"
     } elseif {![file executable ${executable}]} {
 	perror "The executable, \"$executable\" is not usable" 0
 	return "Bad executable found"
     }

     verbose "params: $params" 2

     # spawn the executable and look for the DejaGnu output messages from the
     # test case.
     # spawn -noecho -open [open "|./${executable}" "r"]

     # Run under valgrind if RUN_UNDER_VALGRIND is present in the environment.
     # Note that it's best to configure gcc with --enable-valgrind-annotations
     # when testing under valgrind.
     set run_under_valgrind [info exists env(RUN_UNDER_VALGRIND)]
     if $run_under_valgrind {
 	set valgrind_logfile "${executable}.valgrind.txt"
 	set valgrind_params {"valgrind"}
 	lappend valgrind_params "--leak-check=full"
 	lappend valgrind_params "--log-file=${valgrind_logfile}"
     } else {
 	set valgrind_params {}
     }
     verbose "valgrind_params: $valgrind_params" 2

     set args ${valgrind_params}
     lappend args "./${executable}"
     set args [concat $args ${params}]
     verbose "args: $args" 2

     set status [catch "exec -keepnewline $args" exe_output]
     verbose "Test program returned $exe_output" 2

     if $run_under_valgrind {
 	upvar 2 name name
 	parse_valgrind_logfile $name $valgrind_logfile fail
     }

     # We don't do prune_gcc_output here, as we want
     # to check *exactly* what we get from libgdiagnostics

     return $exe_output
 }

 # (end of code from dejagnu.exp)

 # GCC_UNDER_TEST is needed by gcc_target_compile
 global GCC_UNDER_TEST
 if ![info exists GCC_UNDER_TEST] {
     set GCC_UNDER_TEST "[find_gcc]"
 }

 g++_init

 # Initialize dg.
 dg-init

 # Gather a list of all tests.

 # C and C++ tests within the testsuite: gcc/testsuite/libgdiagnostics.dg/test-*.{c,c++}
 set c_tests [find $srcdir/$subdir test-*.c]
 set cxx_tests [find $srcdir/$subdir test-*.cc]
 set tests [concat $c_tests $cxx_tests]

 verbose "tests: $tests"

 # Expand "SRCDIR" within ARG to the location of the top-level
 # src directory

 proc diagnostics-expand-vars {arg} {
     verbose "diagnostics-expand-vars: $arg"
     global srcdir
     verbose " srcdir: $srcdir"
     # "srcdir" is that of the gcc/testsuite directory, so
     # we need to go up two levels.
     set arg [string map [list "SRCDIR" $srcdir/../..] $arg]
     verbose " new arg: $arg"
     return $arg
 }

 # Parameters used when invoking the executables built from the test cases.

 global diagnostics-exe-params
 set diagnostics-exe-params {}

 # Set "diagnostics-exe-params", expanding "SRCDIR" in each arg to the location of
 # the top-level srcdir.

 proc dg-diagnostics-set-exe-params { args } {
     verbose "dg-diagnostics-set-exe-params: $args"

     global diagnostics-exe-params
     set diagnostics-exe-params {}
     # Skip initial arg (line number)
     foreach arg [lrange $args 1 [llength $args] ] {
 	lappend diagnostics-exe-params [diagnostics-expand-vars $arg]
     }
 }

 proc libgdiagnostics-dg-test { prog do_what extra_tool_flags } {
     verbose "within libgdiagnostics-dg-test..."
     verbose "  prog: $prog"
     verbose "  do_what: $do_what"
     verbose "  extra_tool_flags: $extra_tool_flags"

     global dg-do-what-default
     set dg-do-what [list ${dg-do-what-default} "" P]

     # If we're not supposed to try this test on this target, we're done.
     if { [lindex ${dg-do-what} 1] == "N" } {
 	unsupported "$name"
 	verbose "$name not supported on this target, skipping it" 3
 	return
     }

     # Determine what to name the built executable.
     #
     # We simply append .exe to the filename, e.g.
     #  "test-foo.c.exe"
     # since some testcases exist in both
     #  "test-foo.c" and
     #  "test-foo.cc"
     # variants, and we don't want them to clobber each other's
     # executables.
     #
     # This also ensures that the source name makes it into the
     # pass/fail output, so that we can distinguish e.g. which test-foo
     # is failing.
     set output_file "[file tail $prog].exe"
     verbose "output_file: $output_file"

     # Create the test executable:
     set extension [file extension $prog]
     if {$extension == ".cc"} {
 	set compilation_function "g++_target_compile"
     } else {
 	set compilation_function "gcc_target_compile"
     }
     set options "{additional_flags=$extra_tool_flags}"
     verbose "compilation_function=$compilation_function"
     verbose "options=$options"

     set comp_output [$compilation_function $prog $output_file \
 			 "executable" $options]
     upvar 1 name name
     if ![libgdiagnostics_check_compile "$name" "initial compilation" \
 	    $output_file $comp_output] then {
       return
     }

     # Run the test executable.

     # We need to set LD_LIBRARY_PATH so that the test files can find
     # libgdiagnostics.so
     # Do this using set_ld_library_path_env_vars from target-libpath.exp
     # We will restore the old value later using
     # restore_ld_library_path_env_vars.

     # Unfortunately this API only supports a single saved value, rather
     # than a stack, and g++_init has already called into this API,
     # injecting the appropriate value for LD_LIBRARY_PATH for finding
     # the built copy of libstdc++.
     # Hence the call to restore_ld_library_path_env_vars would restore
     # the *initial* value of LD_LIBRARY_PATH, and attempts to run
     # a C++ testcase after running any prior testcases would thus look
     # in the wrong place for libstdc++.  This led to failures at startup
     # of the form:
     #   ./tut01-hello-world.cc.exe: /lib64/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by ./tut01-hello-world.cc.exe)
     # when the built libstdc++ is more recent that the system libstdc++.
     #
     # As a workaround, reset the variable "orig_environment_saved" within
     # target-libpath.exp, so that the {set|restore}_ld_library_path_env_vars
     # API saves/restores the current value of LD_LIBRARY_PATH (as set up
     # by g++_init).
     global orig_environment_saved
     set orig_environment_saved 0

     global ld_library_path
     global base_dir
     set ld_library_path "$base_dir/../../"
     set_ld_library_path_env_vars

     global diagnostics-exe-params
     set args ${diagnostics-exe-params}
     set diagnostics-exe-params {}

     set exe_output [fixed_host_execute $output_file $args ]
     verbose "exe_output: $exe_output"

     restore_ld_library_path_env_vars

     # Analyze the output from the executable.  To some what extent this
     # is duplicating prune_gcc_output, but we're looking for *precise*
     # output, so we can't reuse prune_gcc_output.

     global testname_with_flags
     set testname_with_flags $name

     # Handle any freeform regexps.
     set exe_output [handle-dg-regexps $exe_output]

     # Call into multiline.exp to handle any multiline output directives.
     set exe_output [handle-multiline-outputs $exe_output]

     # Normally we would return $exe_output and $output_file to the
     # caller, which would delete $output_file, the generated executable.
     # If we need to debug, it's handy to be able to suppress this behavior,
     # keeping the executable around.

     global env
     set preserve_executables [info exists env(PRESERVE_EXECUTABLES)]
     if $preserve_executables {
 	set output_file ""
     }

     return [list $exe_output $output_file]
 }

 set DEFAULT_CFLAGS "-I$srcdir/.. -lgdiagnostics -g -Wall -Werror"

 # Main loop.  This will invoke jig-dg-test on each test-*.c file.
 dg-runtest $tests "" $DEFAULT_CFLAGS

 # All done.
 dg-finish
	# Test code for libgdiagnostics.so
	#
	# We will compile each of libgdiagnostics.dg/test-*.{c,cc} into an executable
	# dynamically linked against libgdiagnostics.so, and then run each
	# such executable.
	#
	# These executables call into the libgdiagnostics.so API to emit diagnostics,
	# sometimes in text form, and other times in SARIF form.

	# Kludge alert:
	# We need g++_init so that it can find the stdlib include path.
	#
	# g++_init (in lib/g++.exp) uses g++_maybe_build_wrapper,
	# which normally comes from the definition of
	# ${tool}_maybe_build_wrapper within lib/wrapper.exp.
	#
	# However, for us, ${tool} is "libgdiagnostics".
	# Hence we load wrapper.exp with tool == "g++", so that
	# g++_maybe_build_wrapper is defined.
	set tool g++
	load_lib wrapper.exp
	set tool libgdiagnostics

	load_lib dg.exp
	load_lib prune.exp
	load_lib target-supports.exp
	load_lib gcc-defs.exp
	load_lib timeout.exp
	load_lib target-libpath.exp
	load_lib gcc.exp
	load_lib g++.exp
	load_lib dejagnu.exp
	load_lib target-supports-dg.exp
	load_lib valgrind.exp
	load_lib scansarif.exp
	load_lib dg-test-cleanup.exp

	# The default do-what keyword.
	set dg-do-what-default compile

	# Adapted from jit.exp.
	#
	# Execute the executable file.
	# Returns:
	# A "" (empty) string if everything worked, or an error message
	# if there was a problem.
	#
	proc fixed_host_execute {args} {
	global env
	global text
	global spawn_id

	verbose "fixed_host_execute: $args"

	set timeoutmsg "Timed out: Never got started, "
	set timeout 100
	set file all
	set timetol 0
	set arguments ""

	if { [llength $args] == 0} {
	set executable $args
	} else {
	set executable [lindex $args 0]
	set params [lindex $args 1]
	}

	verbose "The executable is $executable" 2
	if {![file exists ${executable}]} {
	perror "The executable, \"$executable\" is missing" 0
	return "No source file found"
	} elseif {![file executable ${executable}]} {
	perror "The executable, \"$executable\" is not usable" 0
	return "Bad executable found"
	}

	verbose "params: $params" 2

	# spawn the executable and look for the DejaGnu output messages from the
	# test case.
	# spawn -noecho -open [open "\|./${executable}" "r"]

	# Run under valgrind if RUN_UNDER_VALGRIND is present in the environment.
	# Note that it's best to configure gcc with --enable-valgrind-annotations
	# when testing under valgrind.
	set run_under_valgrind [info exists env(RUN_UNDER_VALGRIND)]
	if $run_under_valgrind {
	set valgrind_logfile "${executable}.valgrind.txt"
	set valgrind_params {"valgrind"}
	lappend valgrind_params "--leak-check=full"
	lappend valgrind_params "--log-file=${valgrind_logfile}"
	} else {
	set valgrind_params {}
	}
	verbose "valgrind_params: $valgrind_params" 2

	set args ${valgrind_params}
	lappend args "./${executable}"
	set args [concat $args ${params}]
	verbose "args: $args" 2

	set status [catch "exec -keepnewline $args" exe_output]
	verbose "Test program returned $exe_output" 2

	if $run_under_valgrind {
	upvar 2 name name
	parse_valgrind_logfile $name $valgrind_logfile fail
	}

	# We don't do prune_gcc_output here, as we want
	# to check exactly what we get from libgdiagnostics

	return $exe_output
	}

	# (end of code from dejagnu.exp)

	# GCC_UNDER_TEST is needed by gcc_target_compile
	global GCC_UNDER_TEST
	if ![info exists GCC_UNDER_TEST] {
	set GCC_UNDER_TEST "[find_gcc]"
	}

	g++_init

	# Initialize dg.
	dg-init

	# Gather a list of all tests.

	# C and C++ tests within the testsuite: gcc/testsuite/libgdiagnostics.dg/test-*.{c,c++}
	set c_tests [find $srcdir/$subdir test-*.c]
	set cxx_tests [find $srcdir/$subdir test-*.cc]
	set tests [concat $c_tests $cxx_tests]

	verbose "tests: $tests"

	# Expand "SRCDIR" within ARG to the location of the top-level
	# src directory

	proc diagnostics-expand-vars {arg} {
	verbose "diagnostics-expand-vars: $arg"
	global srcdir
	verbose " srcdir: $srcdir"
	# "srcdir" is that of the gcc/testsuite directory, so
	# we need to go up two levels.
	set arg [string map [list "SRCDIR" $srcdir/../..] $arg]
	verbose " new arg: $arg"
	return $arg
	}

	# Parameters used when invoking the executables built from the test cases.

	global diagnostics-exe-params
	set diagnostics-exe-params {}

	# Set "diagnostics-exe-params", expanding "SRCDIR" in each arg to the location of
	# the top-level srcdir.

	proc dg-diagnostics-set-exe-params { args } {
	verbose "dg-diagnostics-set-exe-params: $args"

	global diagnostics-exe-params
	set diagnostics-exe-params {}
	# Skip initial arg (line number)
	foreach arg [lrange $args 1 [llength $args] ] {
	lappend diagnostics-exe-params [diagnostics-expand-vars $arg]
	}
	}

	proc libgdiagnostics-dg-test { prog do_what extra_tool_flags } {
	verbose "within libgdiagnostics-dg-test..."
	verbose " prog: $prog"
	verbose " do_what: $do_what"
	verbose " extra_tool_flags: $extra_tool_flags"

	global dg-do-what-default
	set dg-do-what [list ${dg-do-what-default} "" P]

	# If we're not supposed to try this test on this target, we're done.
	if { [lindex ${dg-do-what} 1] == "N" } {
	unsupported "$name"
	verbose "$name not supported on this target, skipping it" 3
	return
	}

	# Determine what to name the built executable.
	#
	# We simply append .exe to the filename, e.g.
	# "test-foo.c.exe"
	# since some testcases exist in both
	# "test-foo.c" and
	# "test-foo.cc"
	# variants, and we don't want them to clobber each other's
	# executables.
	#
	# This also ensures that the source name makes it into the
	# pass/fail output, so that we can distinguish e.g. which test-foo
	# is failing.
	set output_file "[file tail $prog].exe"
	verbose "output_file: $output_file"

	# Create the test executable:
	set extension [file extension $prog]
	if {$extension == ".cc"} {
	set compilation_function "g++_target_compile"
	} else {
	set compilation_function "gcc_target_compile"
	}
	set options "{additional_flags=$extra_tool_flags}"
	verbose "compilation_function=$compilation_function"
	verbose "options=$options"

	set comp_output [$compilation_function $prog $output_file \
	"executable" $options]
	upvar 1 name name
	if ![libgdiagnostics_check_compile "$name" "initial compilation" \
	$output_file $comp_output] then {
	return
	}

	# Run the test executable.

	# We need to set LD_LIBRARY_PATH so that the test files can find
	# libgdiagnostics.so
	# Do this using set_ld_library_path_env_vars from target-libpath.exp
	# We will restore the old value later using
	# restore_ld_library_path_env_vars.

	# Unfortunately this API only supports a single saved value, rather
	# than a stack, and g++_init has already called into this API,
	# injecting the appropriate value for LD_LIBRARY_PATH for finding
	# the built copy of libstdc++.
	# Hence the call to restore_ld_library_path_env_vars would restore
	# the initial value of LD_LIBRARY_PATH, and attempts to run
	# a C++ testcase after running any prior testcases would thus look
	# in the wrong place for libstdc++. This led to failures at startup
	# of the form:
	# ./tut01-hello-world.cc.exe: /lib64/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by ./tut01-hello-world.cc.exe)
	# when the built libstdc++ is more recent that the system libstdc++.
	#
	# As a workaround, reset the variable "orig_environment_saved" within
	# target-libpath.exp, so that the {set\|restore}_ld_library_path_env_vars
	# API saves/restores the current value of LD_LIBRARY_PATH (as set up
	# by g++_init).
	global orig_environment_saved
	set orig_environment_saved 0

	global ld_library_path
	global base_dir
	set ld_library_path "$base_dir/../../"
	set_ld_library_path_env_vars

	global diagnostics-exe-params
	set args ${diagnostics-exe-params}
	set diagnostics-exe-params {}

	set exe_output [fixed_host_execute $output_file $args ]
	verbose "exe_output: $exe_output"

	restore_ld_library_path_env_vars

	# Analyze the output from the executable. To some what extent this
	# is duplicating prune_gcc_output, but we're looking for precise
	# output, so we can't reuse prune_gcc_output.

	global testname_with_flags
	set testname_with_flags $name

	# Handle any freeform regexps.
	set exe_output [handle-dg-regexps $exe_output]

	# Call into multiline.exp to handle any multiline output directives.
	set exe_output [handle-multiline-outputs $exe_output]

	# Normally we would return $exe_output and $output_file to the
	# caller, which would delete $output_file, the generated executable.
	# If we need to debug, it's handy to be able to suppress this behavior,
	# keeping the executable around.

	global env
	set preserve_executables [info exists env(PRESERVE_EXECUTABLES)]
	if $preserve_executables {
	set output_file ""
	}

	return [list $exe_output $output_file]
	}

	set DEFAULT_CFLAGS "-I$srcdir/.. -lgdiagnostics -g -Wall -Werror"

	# Main loop. This will invoke jig-dg-test on each test-*.c file.
	dg-runtest $tests "" $DEFAULT_CFLAGS

	# All done.
	dg-finish