2013-11-04 Tom Tromey <tromey@redhat.com>
+ * gdb.base/advance.exp: Use standard_testfile and
+ prepare_for_testing.
+ * gdb.base/bigcore.exp: Use standard_output_file. "cd" to
+ appropriate directory when local.
+ * gdb.base/dump.exp: Use standard_output_file. Update all
+ "dump" and "restore" filenames.
+ * gdb.base/interact.exp: Use standard_output_file.
+ * gdb.base/jit-so.exp: Don't download file when local.
+ * gdb.base/jit.exp (compile_jit_test): Don't download file
+ when local.
+ * gdb.base/list.exp: Use gdb_remote_download.
+ * gdb.base/maint.exp: Use standard_output_file.
+ * gdb.base/prelink.exp: Use standard_output_file.
+ * gdb.base/save-bp.exp: Use standard_output_file.
+ * gdb.base/sepdebug.exp: Use standard_testfile,
+ standard_output_file.
+ (test_different_dir): Don't declare objdir.
+ * gdb.base/solib-search.exp: Use standard_output_file.
+ * gdb.base/step-line.exp: Use gdb_remote_download.
+ * gdb.base/trace-commands.exp: Use standard_output_file.
+
+2013-11-04 Tom Tromey <tromey@redhat.com>
+
* gdb.trace/mi-traceframe-changed.exp: Pass -DTFILE_DIR
to compilation. Use standard_output_file.
(test_tfind_tfile): Update.
# advance.exp -- Expect script to test 'advance' in gdb
-set testfile advance
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
+standard_testfile
-remote_exec build "rm -f ${binfile}"
-if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested advance.exp
+if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+ untested $testfile.exp
return -1
}
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-
if ![runto_main] then {
fail "Can't run to main"
return 0
}
standard_testfile .c
-set corefile ${binfile}.corefile
+set corefile [standard_output_file ${binfile}.corefile]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
untested bigcore.exp
gdb_test_no_output "set print sevenbit-strings"
gdb_test_no_output "set width 0"
+# Get the core into the output directory.
+if {![is_remote host]} {
+ gdb_test "cd [file dirname $corefile]" "Working directory .*" \
+ "cd to test directory"
+}
+
if { ![runto_main] } then {
gdb_suppress_tests
}
# Find the corefile
set file ""
foreach pat [list core.${inferior_pid} ${testfile}.core core] {
- set names [glob -nocomplain $pat]
+ set names [glob -nocomplain [standard_output_file $pat]]
if {[llength $names] == 1} {
set file [lindex $names 0]
remote_exec build "mv $file $corefile"
# Now load up that core file
set test "load corefile"
-gdb_test_multiple "core $corefile" "$test" {
+# We use [file tail] because gdb is still "cd"d to the
+# output directory.
+gdb_test_multiple "core [file tail $corefile]" "$test" {
-re "A program is being debugged already. Kill it. .y or n. " {
send_gdb "y\n"
exp_continue
# Clean up any stale output files from previous test runs
-remote_exec build "rm -f intarr1.bin intarr1b.bin intarr1.ihex intarr1.srec intarr1.tekhex intarr2.bin intarr2b.bin intarr2.ihex intarr2.srec intarr2.tekhex intstr1.bin intstr1b.bin intstr1.ihex intstr1.srec intstr1.tekhex intstr2.bin intstr2b.bin intstr2.ihex intstr2.srec intstr2.tekhex intarr3.srec"
+set filenames {}
+set all_files {
+ intarr1.bin intarr1b.bin intarr1.ihex
+ intarr1.srec intarr1.tekhex intarr2.bin intarr2b.bin intarr2.ihex
+ intarr2.srec intarr2.tekhex intstr1.bin intstr1b.bin intstr1.ihex
+ intstr1.srec intstr1.tekhex intstr2.bin intstr2b.bin intstr2.ihex
+ intstr2.srec intstr2.tekhex intarr3.srec
+}
+
+# This loop sets variables dynamically -- each name listed in
+# $ALL_FILES is both a file name and a variable name.
+foreach file $all_files {
+ if {[is_remote host]} {
+ set this_name $file
+ } else {
+ set this_name [standard_output_file $file]
+ }
+
+ lappend filenames [set ${file} $this_name]
+}
+
+remote_exec host "rm -f $filenames"
# Test help (FIXME:)
}
}
-make_dump_file "dump val intarr1.bin intarray" \
+make_dump_file "dump val [set intarr1.bin] intarray" \
"dump array as value, default"
-make_dump_file "dump val intstr1.bin intstruct" \
+make_dump_file "dump val [set intstr1.bin] intstruct" \
"dump struct as value, default"
-make_dump_file "dump bin val intarr1b.bin intarray" \
+make_dump_file "dump bin val [set intarr1b.bin] intarray" \
"dump array as value, binary"
-make_dump_file "dump bin val intstr1b.bin intstruct" \
+make_dump_file "dump bin val [set intstr1b.bin] intstruct" \
"dump struct as value, binary"
-make_dump_file "dump srec val intarr1.srec intarray" \
+make_dump_file "dump srec val [set intarr1.srec] intarray" \
"dump array as value, srec"
-make_dump_file "dump srec val intstr1.srec intstruct" \
+make_dump_file "dump srec val [set intstr1.srec] intstruct" \
"dump struct as value, srec"
-make_dump_file "dump ihex val intarr1.ihex intarray" \
+make_dump_file "dump ihex val [set intarr1.ihex] intarray" \
"dump array as value, intel hex"
-make_dump_file "dump ihex val intstr1.ihex intstruct" \
+make_dump_file "dump ihex val [set intstr1.ihex] intstruct" \
"dump struct as value, intel hex"
-make_dump_file "dump tekhex val intarr1.tekhex intarray" \
+make_dump_file "dump tekhex val [set intarr1.tekhex] intarray" \
"dump array as value, tekhex"
-make_dump_file "dump tekhex val intstr1.tekhex intstruct" \
+make_dump_file "dump tekhex val [set intstr1.tekhex] intstruct" \
"dump struct as value, tekhex"
proc capture_value { expression args } {
set array_ptr_type [capture_pointer_with_type "&intarray"]
set struct_ptr_type [capture_pointer_with_type "&intstruct"]
-make_dump_file "dump mem intarr2.bin $array_start $array_end" \
+make_dump_file "dump mem [set intarr2.bin] $array_start $array_end" \
"dump array as memory, default"
-make_dump_file "dump mem intstr2.bin $struct_start $struct_end" \
+make_dump_file "dump mem [set intstr2.bin] $struct_start $struct_end" \
"dump struct as memory, default"
-make_dump_file "dump bin mem intarr2b.bin $array_start $array_end" \
+make_dump_file "dump bin mem [set intarr2b.bin] $array_start $array_end" \
"dump array as memory, binary"
-make_dump_file "dump bin mem intstr2b.bin $struct_start $struct_end" \
+make_dump_file "dump bin mem [set intstr2b.bin] $struct_start $struct_end" \
"dump struct as memory, binary"
-make_dump_file "dump srec mem intarr2.srec $array_start $array_end" \
+make_dump_file "dump srec mem [set intarr2.srec] $array_start $array_end" \
"dump array as memory, srec"
-make_dump_file "dump srec mem intstr2.srec $struct_start $struct_end" \
+make_dump_file "dump srec mem [set intstr2.srec] $struct_start $struct_end" \
"dump struct as memory, srec"
-make_dump_file "dump ihex mem intarr2.ihex $array_start $array_end" \
+make_dump_file "dump ihex mem [set intarr2.ihex] $array_start $array_end" \
"dump array as memory, ihex"
-make_dump_file "dump ihex mem intstr2.ihex $struct_start $struct_end" \
+make_dump_file "dump ihex mem [set intstr2.ihex] $struct_start $struct_end" \
"dump struct as memory, ihex"
-make_dump_file "dump tekhex mem intarr2.tekhex $array_start $array_end" \
+make_dump_file "dump tekhex mem [set intarr2.tekhex] $array_start $array_end" \
"dump array as memory, tekhex"
-make_dump_file "dump tekhex mem intstr2.tekhex $struct_start $struct_end" \
+make_dump_file "dump tekhex mem [set intstr2.tekhex] $struct_start $struct_end" \
"dump struct as memory, tekhex"
# test complex expressions
make_dump_file \
- "dump srec mem intarr3.srec &intarray \(char *\) &intarray + sizeof intarray" \
+ "dump srec mem [set intarr3.srec] &intarray \(char *\) &intarray + sizeof intarray" \
"dump array as mem, srec, expressions"
proc test_restore_saved_value { restore_args msg oldval newval } {
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.srec" "array as value, srec" \
+ test_restore_saved_value "[set intarr1.srec]" "array as value, srec" \
$array_val "intarray"
- test_restore_saved_value "intstr1.srec" "struct as value, srec" \
+ test_restore_saved_value "[set intstr1.srec]" "struct as value, srec" \
$struct_val "intstruct"
gdb_test "print zero_all ()" "void" "zero all"
- test_restore_saved_value "intarr2.srec" "array as memory, srec" \
+ test_restore_saved_value "[set intarr2.srec]" "array as memory, srec" \
$array_val "intarray"
- test_restore_saved_value "intstr2.srec" "struct as memory, srec" \
+ test_restore_saved_value "[set intstr2.srec]" "struct as memory, srec" \
$struct_val "intstruct"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.ihex" "array as value, ihex" \
+ test_restore_saved_value "[set intarr1.ihex]" "array as value, ihex" \
$array_val "intarray"
- test_restore_saved_value "intstr1.ihex" "struct as value, ihex" \
+ test_restore_saved_value "[set intstr1.ihex]" "struct as value, ihex" \
$struct_val "intstruct"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr2.ihex" "array as memory, ihex" \
+ test_restore_saved_value "[set intarr2.ihex]" "array as memory, ihex" \
$array_val "intarray"
- test_restore_saved_value "intstr2.ihex" "struct as memory, ihex" \
+ test_restore_saved_value "[set intstr2.ihex]" "struct as memory, ihex" \
$struct_val "intstruct"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.tekhex" "array as value, tekhex" \
+ test_restore_saved_value "[set intarr1.tekhex]" "array as value, tekhex" \
$array_val "intarray"
- test_restore_saved_value "intstr1.tekhex" "struct as value, tekhex" \
+ test_restore_saved_value "[set intstr1.tekhex]" "struct as value, tekhex" \
$struct_val "intstruct"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr2.tekhex" "array as memory, tekhex" \
+ test_restore_saved_value "[set intarr2.tekhex]" "array as memory, tekhex" \
$array_val "intarray"
- test_restore_saved_value "intstr2.tekhex" "struct as memory, tekhex" \
+ test_restore_saved_value "[set intstr2.tekhex]" "struct as memory, tekhex" \
$struct_val "intstruct"
}
gdb_test "print zero_all ()" ".*"
-test_restore_saved_value "intarr1.bin binary $array_start" \
+test_restore_saved_value "[set intarr1.bin] binary $array_start" \
"array as value, binary" \
$array_val "intarray"
-test_restore_saved_value "intstr1.bin binary $struct_start" \
+test_restore_saved_value "[set intstr1.bin] binary $struct_start" \
"struct as value, binary" \
$struct_val "intstruct"
gdb_test "print zero_all ()" ".*"
-test_restore_saved_value "intarr2.bin binary $array_start" \
+test_restore_saved_value "[set intarr2.bin] binary $array_start" \
"array as memory, binary" \
$array_val "intarray"
-test_restore_saved_value "intstr2.bin binary $struct_start" \
+test_restore_saved_value "[set intstr2.bin] binary $struct_start" \
"struct as memory, binary" \
$struct_val "intstruct"
if ![string compare $is64bitonly "no"] then {
- test_restore_saved_value "intarr1.srec $array2_offset" \
+ test_restore_saved_value "[set intarr1.srec] $array2_offset" \
"array copy, srec" \
$array_val "intarray2"
- test_restore_saved_value "intstr1.srec $struct2_offset" \
+ test_restore_saved_value "[set intstr1.srec] $struct2_offset" \
"struct copy, srec" \
$struct_val "intstruct2"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.ihex $array2_offset" \
+ test_restore_saved_value "[set intarr1.ihex] $array2_offset" \
"array copy, ihex" \
$array_val "intarray2"
- test_restore_saved_value "intstr1.ihex $struct2_offset" \
+ test_restore_saved_value "[set intstr1.ihex] $struct2_offset" \
"struct copy, ihex" \
$struct_val "intstruct2"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.tekhex $array2_offset" \
+ test_restore_saved_value "[set intarr1.tekhex] $array2_offset" \
"array copy, tekhex" \
$array_val "intarray2"
- test_restore_saved_value "intstr1.tekhex $struct2_offset" \
+ test_restore_saved_value "[set intstr1.tekhex] $struct2_offset" \
"struct copy, tekhex" \
$struct_val "intstruct2"
}
gdb_test "print zero_all ()" ".*"
-test_restore_saved_value "intarr1.bin binary $array2_start" \
+test_restore_saved_value "[set intarr1.bin] binary $array2_start" \
"array copy, binary" \
$array_val "intarray2"
-test_restore_saved_value "intstr1.bin binary $struct2_start" \
+test_restore_saved_value "[set intstr1.bin] binary $struct2_start" \
"struct copy, binary" \
$struct_val "intstruct2"
if ![string compare $is64bitonly "no"] then {
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.srec 0 $element3_start $element4_start" \
+ test_restore_saved_value "[set intarr1.srec] 0 $element3_start $element4_start" \
"array partial, srec" 4 "intarray\[3\]"
gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 1"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.ihex 0 $element3_start $element4_start" \
+ test_restore_saved_value "[set intarr1.ihex] 0 $element3_start $element4_start" \
"array partial, ihex" 4 "intarray\[3\]"
gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 2"
gdb_test "print zero_all ()" ".*"
- test_restore_saved_value "intarr1.tekhex 0 $element3_start $element4_start" \
+ test_restore_saved_value "[set intarr1.tekhex] 0 $element3_start $element4_start" \
"array partial, tekhex" 4 "intarray\[3\]"
gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 3"
gdb_test "print zero_all ()" ".*"
test_restore_saved_value \
- "intarr1.bin binary $array_start $element3_offset $element4_offset" \
+ "[set intarr1.bin] binary $array_start $element3_offset $element4_offset" \
"array partial, binary" 4 "intarray\[3\]"
gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 4"
# restore with expressions
test_restore_saved_value \
- "intarr3.srec (char*)${array2_start}-(char*)${array_start} &intarray\[3\] &intarray\[4\]" \
+ "[set intarr3.srec] (char*)${array2_start}-(char*)${array_start} &intarray\[3\] &intarray\[4\]" \
"array partial with expressions" 4 "intarray2\[3\]"
gdb_test "print intarray2\[2\] == 0" " = 1" "element 2 not changed, == 4"
# srec format can not be loaded for 64-bit-only platforms
if ![string compare $is64bitonly "no"] then {
- test_reload_saved_value "intarr1.srec" "reload array as value, srec" \
+ test_reload_saved_value "[set intarr1.srec]" "reload array as value, srec" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr1.srec" "reload struct as value, srec" \
+ test_reload_saved_value "[set intstr1.srec]" "reload struct as value, srec" \
$struct_val "\*$struct_ptr_type"
- test_reload_saved_value "intarr2.srec" "reload array as memory, srec" \
+ test_reload_saved_value "[set intarr2.srec]" "reload array as memory, srec" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr2.srec" "reload struct as memory, srec" \
+ test_reload_saved_value "[set intstr2.srec]" "reload struct as memory, srec" \
$struct_val "\*$struct_ptr_type"
}
# ihex format can not be loaded for 64-bit-only platforms
if ![string compare $is64bitonly "no"] then {
- test_reload_saved_value "intarr1.ihex" "reload array as value, intel hex" \
+ test_reload_saved_value "[set intarr1.ihex]" \
+ "reload array as value, intel hex" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr1.ihex" "reload struct as value, intel hex" \
+ test_reload_saved_value "[set intstr1.ihex]" \
+ "reload struct as value, intel hex" \
$struct_val "\*$struct_ptr_type"
- test_reload_saved_value "intarr2.ihex" "reload array as memory, intel hex" \
+ test_reload_saved_value "[set intarr2.ihex]" \
+ "reload array as memory, intel hex" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr2.ihex" "reload struct as memory, intel hex" \
+ test_reload_saved_value "[set intstr2.ihex]" \
+ "reload struct as memory, intel hex" \
$struct_val "\*$struct_ptr_type"
}
# tekhex format can not be loaded for 64-bit-only platforms
if ![string compare $is64bitonly "no"] then {
- test_reload_saved_value "intarr1.tekhex" "reload array as value, tekhex" \
+ test_reload_saved_value "[set intarr1.tekhex]" \
+ "reload array as value, tekhex" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr1.tekhex" "reload struct as value, tekhex" \
+ test_reload_saved_value "[set intstr1.tekhex]" \
+ "reload struct as value, tekhex" \
$struct_val "\*$struct_ptr_type"
- test_reload_saved_value "intarr2.tekhex" "reload array as memory, tekhex" \
+ test_reload_saved_value "[set intarr2.tekhex]" \
+ "reload array as memory, tekhex" \
$array_val "\*$array_ptr_type"
- test_reload_saved_value "intstr2.tekhex" "reload struct as memory, tekhex" \
+ test_reload_saved_value "[set intstr2.tekhex]" \
+ "reload struct as memory, tekhex" \
$struct_val "\*$struct_ptr_type"
}
# clean up files
-remote_exec build "rm -f intarr1.bin intarr1b.bin intarr1.ihex intarr1.srec intarr1.tekhex intarr2.bin intarr2b.bin intarr2.ihex intarr2.srec intarr2.tekhex intstr1.bin intstr1b.bin intstr1.ihex intstr1.srec intstr1.tekhex intstr2.bin intstr2b.bin intstr2.ihex intstr2.srec intstr2.tekhex intarr3.srec"
+remote_exec host "rm -f $filenames"
# Create a GDB script that we can source. The script needs to generate
# some output, to allow us to verify that it is executed properly.
-set fd [open "zzz-gdbscript" "w"]
+set script [standard_output_file zzz-gdbscript]
+set fd [open $script "w"]
puts $fd "print 1"
puts $fd "print 2"
close $fd
# Verify that evaluating the script does not cause an unexpected
# change of the interactive-mode setting.
gdb_test_no_output "set interactive-mode auto"
-gdb_test "source zzz-gdbscript" "$script_output" \
+gdb_test "source $script" "$script_output" \
"source script with interactive-mode auto"
gdb_test "print 3" "= 3" "sanity check with interactive-mode auto"
gdb_test "show interactive-mode" \
# Verify that evaluating the script does not cause an unexpected
# change of the interactive-mode setting.
gdb_test_no_output "set interactive-mode on"
-gdb_test "source zzz-gdbscript" "$script_output" \
+gdb_test "source $script" "$script_output" \
"source script with interactive-mode on"
gdb_test "print 4" "= 4" "sanity check with interactive-mode on"
gdb_test "show interactive-mode" \
# Verify that evaluating the script does not cause an unexpected
# change of the interactive-mode setting.
gdb_test_no_output "set interactive-mode off"
-gdb_test "source zzz-gdbscript" "$script_output" \
+gdb_test "source $script" "$script_output" \
"source script with interactive-mode off"
gdb_test "print 5" "= 5" "sanity check with interactive-mode off"
gdb_test "show interactive-mode" \
return -1
}
-set solib_binfile_target [gdb_download ${solib_binfile}]
+if {[is_remote target]} {
+ set solib_binfile_target [gdb_download ${solib_binfile}]
+} else {
+ set solib_binfile_target $solib_binfile
+}
proc one_jit_test {count match_str} {
with_test_prefix "one_jit_test-$count" {
return -1
}
- set solib_binfile_target [gdb_download ${solib_binfile}]
+ if {[is_remote target]} {
+ set solib_binfile_target [gdb_download ${solib_binfile}]
+ } else {
+ set solib_binfile_target $solib_binfile
+ }
return 0
}
standard_testfile list0.c list1.c
# Need to download the header to the host.
-remote_download host ${srcdir}/${subdir}/list0.h list0.h
+gdb_remote_download host ${srcdir}/${subdir}/list0.h
if {[prepare_for_testing $testfile.exp $testfile [list $srcfile $srcfile2] \
{debug}]} {
# Check that maint print msymbols allows relative pathnames
set mydir [pwd]
-gdb_test "cd ${objdir}" \
- "Working directory [string_to_regexp ${objdir}]\..*" \
+gdb_test "cd [standard_output_file {}]" \
+ "Working directory .*\..*" \
"cd to objdir"
-gdb_test_multiple "maint print msymbols msymbols_output2 ${subdir}/${testfile}" "maint print msymbols" {
+gdb_test_multiple "maint print msymbols msymbols_output2 ${testfile}" "maint print msymbols" {
-re "^maint print msymbols msymbols_output2 \[^\n\]*\r\n$gdb_prompt $" {
gdb_test_multiple "shell ls msymbols_output2" "maint print msymbols" {
-re "msymbols_output2\r\n$gdb_prompt $" {
set testfile "prelink"
set libsrcfile ${testfile}-lib.c
-set libfile ${objdir}/${subdir}/${testfile}.so
+set libfile [standard_output_file ${testfile}.so]
# Use -soname so that the new library gets copied by build_executable_own_libs.
set srcfile ${testfile}.c
set executable ${testfile}t
-set binfile ${objdir}/${subdir}/${executable}
+set binfile [standard_output_file ${executable}]
set prelink_args [build_executable_own_libs ${testfile}.exp $executable $srcfile [list debug "ldflags=-Wl,${libfile},-rpath,[file dirname ${libfile}]"]]
if {$prelink_args == ""} {
return -1
}
set found 0
-set coredir "${objdir}/${subdir}/coredir.[getpid]"
+set coredir "[standard_output_file coredir.[getpid]]"
file mkdir $coredir
catch "system \"(cd ${coredir}; ulimit -c unlimited; ${binfile}; true) >/dev/null 2>&1\""
foreach i "${coredir}/core ${coredir}/core.coremaker.c ${binfile}.core" {
if [remote_file build exists $i] {
- remote_exec build "mv $i ${objdir}/${subdir}/prelink.core"
+ remote_exec build "mv $i [standard_output_file prelink.core]"
set found 1
}
}
set names [glob -nocomplain -directory $coredir core.*]
if {[llength $names] == 1} {
set corefile [file join $coredir [lindex $names 0]]
- remote_exec build "mv $corefile ${objdir}/${subdir}/prelink.core"
+ remote_exec build "mv $corefile [standard_output_file prelink.core]"
set found 1
}
}
# Print the "adjusting expectations" message.
gdb_test_no_output "set verbose on"
-gdb_test "core-file $objdir/$subdir/prelink.core" "Using PIC \\(Position Independent Code\\) prelink displacement 0x\[^0\]\[0-9a-f\]* for \[^\r\n\]*[file tail ${libfile}].*" "seen displacement message"
+gdb_test "core-file [standard_output_file prelink.core]" "Using PIC \\(Position Independent Code\\) prelink displacement 0x\[^0\]\[0-9a-f\]* for \[^\r\n\]*[file tail ${libfile}].*" "seen displacement message"
gdb_test "p &bssvar == bssvarp" " = 1" ".dynbss vs. .bss address shift"
gdb_test "dprintf ${srcfile}:${loc_bp5},\"At foo entry\\n\"" "Dprintf .*"
# Now, save the breakpoints into a file...
-remote_file host delete "bps"
-gdb_test "save breakpoint bps"
+if {[is_remote host]} {
+ set bps bps
+} else {
+ set bps [standard_output_file bps]
+}
+remote_file host delete "$bps"
+gdb_test "save breakpoint $bps" "" "save breakpoint bps"
# Now start a new debugger session...
clean_restart $testfile
delete_breakpoints
# ... and restore the breakpoints.
-gdb_test "source bps"
+gdb_test "source $bps" "" "source bps"
# Now, verify that all breakpoints have been created correctly...
set bp_row_start "\[0-9\]+ +breakpoint +keep +y +0x\[0-9a-f\]+ +in"
# test running programs
#
-set testfile "sepdebug"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}${EXEEXT}
+standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
untested sepdebug.exp
# PR gdb/9538. Verify that symlinked executable still finds the separate
# debuginfo.
#
-set old_subdir ${subdir}
-set subdir ${subdir}/pr9538
+set old_subdir $subdir
+set subdir [file join ${old_subdir} pr9538]
# Cleanup any stale state.
-remote_exec build "rm -rf ${subdir}"
+set new_name [standard_output_file ${testfile}${EXEEXT}]
+remote_exec build "rm -rf [file dirname $new_name]"
-remote_exec build "mkdir ${subdir}"
-remote_exec build "ln -s ${binfile} ${subdir}"
+remote_exec build "mkdir [file dirname $new_name]"
+remote_exec build "ln -s ${binfile} $new_name"
clean_restart ${testfile}${EXEEXT}
if { $gdb_file_cmd_debug_info != "debug" } then {
fail "No debug information found."
proc test_different_dir {type test_different_dir xfail} {
with_test_prefix "$type" {
- global srcdir subdir objdir binfile srcfile timeout gdb_prompt
+ global srcdir subdir binfile srcfile timeout gdb_prompt
global bp_location6 decimal hex
gdb_exit
# now move the .debug file to a different location so that we can test
# the "set debug-file-directory" command.
-set different_dir "${objdir}/${subdir}/${testfile}.dir"
-set debugfile "${different_dir}/${objdir}/${subdir}/${testfile}.debug"
+set different_dir [standard_output_file ${testfile}.dir]
+set debugfile "${different_dir}/[standard_output_file ${testfile}.debug]"
remote_exec build "rm -rf $different_dir"
remote_exec build "mkdir -p [file dirname $debugfile]"
-remote_exec build "mv -f ${objdir}/${subdir}/${testfile}.debug $debugfile"
+remote_exec build "mv -f [standard_output_file ${testfile}.debug] $debugfile"
test_different_dir debuglink $different_dir 0
# Test CRC mismatch is reported.
if {[build_executable sepdebug.exp sepdebug2 sepdebug2.c debug] != -1
- && ![gdb_gnu_strip_debug ${objdir}/${subdir}/sepdebug2]} {
+ && ![gdb_gnu_strip_debug [standard_output_file sepdebug2]]} {
- remote_exec build "cp ${debugfile} ${objdir}/${subdir}/sepdebug2.debug"
+ remote_exec build "cp ${debugfile} [standard_output_file sepdebug2.debug]"
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
- set escapedobjdirsubdir [string_to_regexp ${objdir}/${subdir}]
+ set escapedobjdirsubdir [string_to_regexp [standard_output_file {}]]
- gdb_test "file ${objdir}/${subdir}/sepdebug2" "warning: the debug information found in \"${escapedobjdirsubdir}/sepdebug2\\.debug\" does not match \"${escapedobjdirsubdir}/sepdebug2\" \\(CRC mismatch\\)\\..*\\(no debugging symbols found\\).*" "CRC mismatch is reported"
+ gdb_test "file [standard_output_file sepdebug2]" "warning: the debug information found in \"${escapedobjdirsubdir}/sepdebug2\\.debug\" does not match \"${escapedobjdirsubdir}/sepdebug2\" \\(CRC mismatch\\)\\..*\\(no debugging symbols found\\).*" "CRC mismatch is reported"
}
pass $test
}
- file mkdir [file dirname ${objdir}/${subdir}/${build_id_debug_filename}]
- remote_exec build "mv $debugfile ${objdir}/${subdir}/${build_id_debug_filename}"
+ file mkdir [file dirname [standard_output_file ${build_id_debug_filename}]]
+ remote_exec build "mv $debugfile [standard_output_file ${build_id_debug_filename}]"
- test_different_dir build-id "${objdir}/${subdir}" $xfail
+ test_different_dir build-id [standard_output_file {}] $xfail
# Test also multiple directories can be specified. Without the build-id
# reference GDB would find the separate debug info just at the same
# location as the executable file.
- test_different_dir multiple-dirs "/doesnotexist:${objdir}/${subdir}" $xfail
+ test_different_dir multiple-dirs "/doesnotexist:[standard_output_file {}]" $xfail
# Spare debug files may confuse testsuite runs in the future.
- remote_exec build "rm -f ${objdir}/${subdir}/${build_id_debug_filename}"
+ remote_exec build "rm -f [standard_output_file ${build_id_debug_filename}]"
}
# First library file.
set libname1 "solib-search-lib1"
set srcfile1_lib ${srcdir}/${subdir}/${libname1}.c
-set wrong_binfile1_lib ${objdir}/${subdir}/${wrong_lib_subdir}/${libname1}.so
-set right_binfile1_lib ${objdir}/${subdir}/${right_lib_subdir}/${libname1}.so
+set wrong_binfile1_lib \
+ [standard_output_file ${wrong_lib_subdir}/${libname1}.so]
+set right_binfile1_lib \
+ [standard_output_file ${right_lib_subdir}/${libname1}.so]
# Second library file.
set libname2 "solib-search-lib2"
set srcfile2_lib ${srcdir}/${subdir}/${libname2}.c
-set wrong_binfile2_lib ${objdir}/${subdir}/${wrong_lib_subdir}/${libname2}.so
-set right_binfile2_lib ${objdir}/${subdir}/${right_lib_subdir}/${libname2}.so
+set wrong_binfile2_lib \
+ [standard_output_file ${wrong_lib_subdir}/${libname2}.so]
+set right_binfile2_lib \
+ [standard_output_file ${right_lib_subdir}/${libname2}.so]
# Link with the library that lives here.
# This is so that we can replace what gdb sees with the wrong copy,
# and then tell gdb to use the right copy that lives someplace else.
-set binfile1_lib ${objdir}/${subdir}/${libname1}.so
-set binfile2_lib ${objdir}/${subdir}/${libname2}.so
+set binfile1_lib [standard_output_file ${libname1}.so]
+set binfile2_lib [standard_output_file ${libname2}.so]
set lib_flags [list debug ldflags=-Wl,-Bsymbolic]
set wrong_lib_flags "$lib_flags additional_flags=-DARRAY_SIZE=1"
set right_lib_flags "$lib_flags additional_flags=-DARRAY_SIZE=8192 -DRIGHT"
# Binary file.
-set testfile "solib-search"
-set srcfile ${srcdir}/${subdir}/${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
+standard_testfile .c
set bin_flags [list debug shlib=${binfile1_lib} shlib=${binfile2_lib}]
-remote_exec build "rm -rf ${subdir}/${wrong_lib_subdir}"
-remote_exec build "rm -rf ${subdir}/${right_lib_subdir}"
-remote_exec build "mkdir ${subdir}/${wrong_lib_subdir}"
-remote_exec build "mkdir ${subdir}/${right_lib_subdir}"
+remote_exec build "rm -rf [standard_output_file ${wrong_lib_subdir}]"
+remote_exec build "rm -rf [standard_output_file ${right_lib_subdir}]"
+remote_exec build "mkdir [standard_output_file ${wrong_lib_subdir}]"
+remote_exec build "mkdir [standard_output_file ${right_lib_subdir}]"
if { [gdb_compile_shlib ${srcfile1_lib} ${wrong_binfile1_lib} $wrong_lib_flags] != ""
|| [gdb_compile_shlib ${srcfile2_lib} ${wrong_binfile2_lib} $wrong_lib_flags] != ""
# Build the test binary using the right copies of the libraries.
remote_exec build "ln -sf ${right_lib_subdir}/${libname1}.so ${binfile1_lib}"
remote_exec build "ln -sf ${right_lib_subdir}/${libname2}.so ${binfile2_lib}"
-if { [gdb_compile ${srcfile} ${binfile} executable $bin_flags] != "" } {
+if { [gdb_compile $srcdir/$subdir/${srcfile} ${binfile} \
+ executable $bin_flags] != "" } {
untested "Could not compile $binfile."
return -1
}
gdb_breakpoint "break_here"
gdb_continue "break_here"
-set corefile "${objdir}/${subdir}/solib-search.core"
+set corefile [standard_output_file solib-search.core]
set core_supported [gdb_gcore_cmd "$corefile" "save a corefile"]
if {!$core_supported} {
remote_exec build "rm -f ${binfile1_lib}"
remote_exec build "rm -f ${binfile2_lib}"
# Set solib-search-path to use the correct copies of libraries.
-gdb_test "set solib-search-path ${objdir}/${subdir}/${right_lib_subdir}" \
+gdb_test "set solib-search-path [standard_output_file ${right_lib_subdir}]" \
"" \
"set solib-search-path"
return 0
}
-set remote_linefile [remote_download host ${srcdir}/${subdir}/${linefile}]
+set remote_linefile [gdb_remote_download host ${srcdir}/${subdir}/${linefile}]
gdb_test "break f1" ".*Breakpoint 2 at .* file .*step-line.c.*" "break f1"
gdb_test "continue" \
gdb_start
# Create a file to source
-set fd [open "tracecommandsscript" w]
+set tracecommandsscript [standard_output_file tracecommandsscript]
+set fd [open "$tracecommandsscript" w]
puts $fd "\
echo in tracecommandsscript\\n
define func
"show trace-commands says off"
# Source the script with verbose mode.
-gdb_test_sequence "source -v tracecommandsscript" "source -v" {
+gdb_test_sequence "source -v $tracecommandsscript" "source -v" {
{[\r\n]\+echo in tracecommandsscript\\n}
{[\r\n]\+define func}
{[\r\n]\+if 1}
}
# Function with source works
-gdb_test_sequence "define topfunc\nsource tracecommandsscript\nend" \
+gdb_test_sequence "define topfunc\nsource $tracecommandsscript\nend" \
"define user command" {
{[\r\n]\+define topfunc}
}
gdb_test_sequence "topfunc" "nested trace-commands test with source" {
{[\r\n]\+topfunc}
- {[\r\n]\+\+source tracecommandsscript}
+ {[\r\n]\+\+source .*/tracecommandsscript}
{[\r\n]\+\+echo in tracecommandsscript\\n}
{[\r\n]\+\+define func}
{[\r\n]\+\+if 1}
projects / external / binutils.git / commitdiff