gdb/testsuite/

* gdb.threads/non-ldr-exc-1.exp (do_test): Fix the indent of
	using with_test_prefix.
	* gdb.threads/non-ldr-exc-2.exp (do_test): Likewise.
	* gdb.threads/non-ldr-exc-3.exp (do_test): Likewise.
	* gdb.threads/non-ldr-exc-4.exp (do_test): Likewise.
	* gdb.threads/watchpoint-fork.exp (test): Likewise.
	* gdb.base/break-interp.exp (test_core): Likewise.
	(test_attach_gdb): Likewise.
	* gdb.base/catch-load.exp (one_catch_load_test): Likewise.
	* gdb.base/disp-step-syscall.exp (disp_step_cross_syscall):
	Likewise.
	* gdb.base/jit-so.exp (one_jit_test): Likewise.
	* gdb.base/jit.exp (one_jit_test): Likewise.
	* gdb.base/sepdebug.exp (test_different_dir): Likewise.
	* gdb.dwarf2/dw2-dir-file-name.exp (test): Likewise.
	* gdb.dwarf2/dw2-noloc.exp (file_symbols): Likewise.
	* gdb.mi/mi-breakpoint-changed.exp (test_pending_resolved):
	Likewise.
	* gdb.mi/mi-cmd-param-changed.exp (test_command_param_changed):
	Likewise.
	* gdb.mi/mi-watch.exp test_watchpoint_all): Likewise.
	* gdb.mi/pr11022.exp (test_memory_changed_observer): Likewise.
	* gdb.trace/change-loc.exp (tracepoint_change_loc_1): Likewise.
	(tracepoint_change_loc_2): Likewise.
	* gdb.trace/disconnected-tracing.exp (disconnected_tracing):
	Likewise.
	(disconnected_tfind): Likewise.
	* gdb.trace/mi-traceframe-changed.exp (test_tfind_tfile):
	Likewise.
	(test_tfind_remote): Likewise.
	* gdb.trace/mi-tracepoint-changed.exp (test_reconnect):
	Likewise.
	(test_pending_resolved): Likewise.
	* gdb.trace/mi-tsv-changed.exp (test_create_delete_modify_tsv):
	Likewise.
	(test_upload_tsv): Likewise.
	* gdb.trace/pending.exp (pending_tracepoint_resolved):
	Likewise.
	(pending_tracepoint_works): Likewise.
	* gdb.trace/report.exp (use_collected_data): Likewise.
	* gdb.trace/status-stop.exp (test_tstart_tstop_tstart):
	Likewise.
	(test_tstart_tstart, test_buffer_full_tstart): Likewise.
	* gdb.trace/strace.exp (strace_info_marker): Likewise.
	(strace_trace_on_same_addr): Likewise.
	(strace_trace_on_diff_addr): Likewise.
	* gdb.trace/unavailable.exp (gdb_collect_args_test): Likewise.
	(gdb_collect_locals_test): Likewise.
	(gdb_unavailable_registers_test): Likewise.
	(gdb_collect_globals_test): Likewise.
This commit is contained in:
Yao Qi 2013-03-15 01:41:29 +00:00
parent 2c415c0f38
commit 0a251e08fa
28 changed files with 2464 additions and 2300 deletions

View file

@ -1,3 +1,56 @@
2013-03-15 Yao Qi <yao@codesourcery.com>
* gdb.threads/non-ldr-exc-1.exp (do_test): Fix the indent of
using with_test_prefix.
* gdb.threads/non-ldr-exc-2.exp (do_test): Likewise.
* gdb.threads/non-ldr-exc-3.exp (do_test): Likewise.
* gdb.threads/non-ldr-exc-4.exp (do_test): Likewise.
* gdb.threads/watchpoint-fork.exp (test): Likewise.
* gdb.base/break-interp.exp (test_core): Likewise.
(test_attach_gdb): Likewise.
* gdb.base/catch-load.exp (one_catch_load_test): Likewise.
* gdb.base/disp-step-syscall.exp (disp_step_cross_syscall):
Likewise.
* gdb.base/jit-so.exp (one_jit_test): Likewise.
* gdb.base/jit.exp (one_jit_test): Likewise.
* gdb.base/sepdebug.exp (test_different_dir): Likewise.
* gdb.dwarf2/dw2-dir-file-name.exp (test): Likewise.
* gdb.dwarf2/dw2-noloc.exp (file_symbols): Likewise.
* gdb.mi/mi-breakpoint-changed.exp (test_pending_resolved):
Likewise.
* gdb.mi/mi-cmd-param-changed.exp (test_command_param_changed):
Likewise.
* gdb.mi/mi-watch.exp test_watchpoint_all): Likewise.
* gdb.mi/pr11022.exp (test_memory_changed_observer): Likewise.
* gdb.trace/change-loc.exp (tracepoint_change_loc_1): Likewise.
(tracepoint_change_loc_2): Likewise.
* gdb.trace/disconnected-tracing.exp (disconnected_tracing):
Likewise.
(disconnected_tfind): Likewise.
* gdb.trace/mi-traceframe-changed.exp (test_tfind_tfile):
Likewise.
(test_tfind_remote): Likewise.
* gdb.trace/mi-tracepoint-changed.exp (test_reconnect):
Likewise.
(test_pending_resolved): Likewise.
* gdb.trace/mi-tsv-changed.exp (test_create_delete_modify_tsv):
Likewise.
(test_upload_tsv): Likewise.
* gdb.trace/pending.exp (pending_tracepoint_resolved):
Likewise.
(pending_tracepoint_works): Likewise.
* gdb.trace/report.exp (use_collected_data): Likewise.
* gdb.trace/status-stop.exp (test_tstart_tstop_tstart):
Likewise.
(test_tstart_tstart, test_buffer_full_tstart): Likewise.
* gdb.trace/strace.exp (strace_info_marker): Likewise.
(strace_trace_on_same_addr): Likewise.
(strace_trace_on_diff_addr): Likewise.
* gdb.trace/unavailable.exp (gdb_collect_args_test): Likewise.
(gdb_collect_locals_test): Likewise.
(gdb_unavailable_registers_test): Likewise.
(gdb_collect_globals_test): Likewise.
2013-03-15 Yao Qi <yao@codesourcery.com> 2013-03-15 Yao Qi <yao@codesourcery.com>
* gdb.base/condbreak.exp: Add semicolon back which was removed * gdb.base/condbreak.exp: Add semicolon back which was removed

View file

@ -190,103 +190,107 @@ proc reach {func command displacement} {
} }
} }
proc test_core {file displacement} { with_test_prefix "core" { proc test_core {file displacement} {
global srcdir subdir gdb_prompt expect_out with_test_prefix "core" {
global srcdir subdir gdb_prompt expect_out
set corefile [core_find $file {} "segv"] set corefile [core_find $file {} "segv"]
if {$corefile == ""} { if {$corefile == ""} {
return return
} }
gdb_exit gdb_exit
gdb_start gdb_start
# Clear it to never find any separate debug infos in $debug_root. # Clear it to never find any separate debug infos in $debug_root.
gdb_test_no_output "set debug-file-directory" \ gdb_test_no_output "set debug-file-directory" \
"set debug-file-directory for core" "set debug-file-directory for core"
gdb_reinitialize_dir $srcdir/$subdir gdb_reinitialize_dir $srcdir/$subdir
gdb_load $file gdb_load $file
# Print the "PIE (Position Independent Executable) displacement" message. # Print the "PIE (Position Independent Executable) displacement" message.
gdb_test_no_output "set verbose on" gdb_test_no_output "set verbose on"
set test "core loaded" set test "core loaded"
set test_displacement "seen displacement message as $displacement" set test_displacement "seen displacement message as $displacement"
gdb_test_multiple "core-file $corefile" $test { gdb_test_multiple "core-file $corefile" $test {
-re "Using PIE \\(Position Independent Executable\\) displacement (0x\[0-9a-f\]+) " { -re "Using PIE \\(Position Independent Executable\\) displacement (0x\[0-9a-f\]+) " {
# Missing "$gdb_prompt $" is intentional. # Missing "$gdb_prompt $" is intentional.
if {$expect_out(1,string) == "0x0"} { if {$expect_out(1,string) == "0x0"} {
set case "ZERO" set case "ZERO"
} else { } else {
set case "NONZERO" set case "NONZERO"
}
if {$displacement == $case || $displacement == "PRESENT"} {
pass $test_displacement
set displacement "FOUND-$displacement"
} else {
fail $test_displacement
}
exp_continue
} }
if {$displacement == $case || $displacement == "PRESENT"} { -re "Core was generated by .*\r\n#0 .*$gdb_prompt $" {
pass $test_displacement # Do not check the binary filename as it may be truncated.
set displacement "FOUND-$displacement" pass $test
} else {
fail $test_displacement
} }
exp_continue
} }
-re "Core was generated by .*\r\n#0 .*$gdb_prompt $" { if ![regexp {^(NONE|FOUND-.*)$} $displacement] {
# Do not check the binary filename as it may be truncated. fail $test_displacement
pass $test
} }
gdb_test "bt" "#\[0-9\]+ +\[^\r\n\]*\\mlibfunc\\M\[^\r\n\]*\r\n#\[0-9\]+ +\[^\r\n\]*\\mmain\\M.*" "core main bt"
} }
if ![regexp {^(NONE|FOUND-.*)$} $displacement] { }
fail $test_displacement
}
gdb_test "bt" "#\[0-9\]+ +\[^\r\n\]*\\mlibfunc\\M\[^\r\n\]*\r\n#\[0-9\]+ +\[^\r\n\]*\\mmain\\M.*" "core main bt" proc test_attach_gdb {file pid displacement prefix} {
}} with_test_prefix "$prefix" {
global gdb_prompt expect_out
proc test_attach_gdb {file pid displacement prefix} { with_test_prefix "$prefix" { gdb_exit
global gdb_prompt expect_out gdb_start
gdb_exit # Print the "PIE (Position Independent Executable) displacement" message.
gdb_start gdb_test_no_output "set verbose on"
# Print the "PIE (Position Independent Executable) displacement" message. gdb_test "file $file" "Reading symbols from .*done\\." "file"
gdb_test_no_output "set verbose on"
gdb_test "file $file" "Reading symbols from .*done\\." "file" set test "attach"
gdb_test_multiple "attach $pid" $test {
set test "attach" -re "Attaching to (program: .*, )?process $pid\r\n" {
gdb_test_multiple "attach $pid" $test { # Missing "$gdb_prompt $" is intentional.
-re "Attaching to (program: .*, )?process $pid\r\n" { pass $test
# Missing "$gdb_prompt $" is intentional.
pass $test
}
}
set test "attach final prompt"
set test_displacement "seen displacement message as $displacement"
gdb_test_multiple "" $test {
-re "Using PIE \\(Position Independent Executable\\) displacement (0x\[0-9a-f\]+) " {
# Missing "$gdb_prompt $" is intentional.
if {$expect_out(1,string) == "0x0"} {
set case "ZERO"
} else {
set case "NONZERO"
} }
if {$displacement == $case || $displacement == "PRESENT"} {
pass $test_displacement
set displacement "FOUND-$displacement"
} else {
fail $test_displacement
}
exp_continue
} }
-re "$gdb_prompt $" {
pass $test
}
}
if ![regexp {^(NONE|FOUND-.*)$} $displacement] {
fail $test_displacement
}
gdb_test "bt" "#\[0-9\]+ +\[^\r\n\]*\\mlibfunc\\M\[^\r\n\]*\r\n#\[0-9\]+ +\[^\r\n\]*\\mmain\\M.*" "attach main bt" set test "attach final prompt"
gdb_exit set test_displacement "seen displacement message as $displacement"
}} gdb_test_multiple "" $test {
-re "Using PIE \\(Position Independent Executable\\) displacement (0x\[0-9a-f\]+) " {
# Missing "$gdb_prompt $" is intentional.
if {$expect_out(1,string) == "0x0"} {
set case "ZERO"
} else {
set case "NONZERO"
}
if {$displacement == $case || $displacement == "PRESENT"} {
pass $test_displacement
set displacement "FOUND-$displacement"
} else {
fail $test_displacement
}
exp_continue
}
-re "$gdb_prompt $" {
pass $test
}
}
if ![regexp {^(NONE|FOUND-.*)$} $displacement] {
fail $test_displacement
}
gdb_test "bt" "#\[0-9\]+ +\[^\r\n\]*\\mlibfunc\\M\[^\r\n\]*\r\n#\[0-9\]+ +\[^\r\n\]*\\mmain\\M.*" "attach main bt"
gdb_exit
}
}
proc test_attach {file displacement {relink_args ""}} { proc test_attach {file displacement {relink_args ""}} {
global board_info global board_info

View file

@ -46,54 +46,56 @@ if { [gdb_compile_shlib "${srcdir}/${subdir}/${srcfile2}" ${binfile2} {debug}] !
# names. # names.
# KIND is passed to the "catch" command. # KIND is passed to the "catch" command.
# MATCH is a boolean saying whether we expect the catchpoint to be hit. # MATCH is a boolean saying whether we expect the catchpoint to be hit.
proc one_catch_load_test {scenario kind match sostop} { with_test_prefix "${scenario}" { proc one_catch_load_test {scenario kind match sostop} {
global verbose testfile testfile2 binfile2 binfile2_dlopen with_test_prefix "${scenario}" {
global srcfile global verbose testfile testfile2 binfile2 binfile2_dlopen
global decimal gdb_prompt global srcfile
global decimal gdb_prompt
clean_restart $testfile clean_restart $testfile
gdb_load_shlibs $binfile2 gdb_load_shlibs $binfile2
if {![runto_main]} { if {![runto_main]} {
fail "can't run to main" fail "can't run to main"
return return
}
gdb_breakpoint [gdb_get_line_number "final breakpoint here"]
gdb_test_no_output "set var libname = \"$binfile2_dlopen\""
gdb_test_no_output "set stop-on-solib-events $sostop"
gdb_test "catch $kind" "Catchpoint $decimal \\(.*\\)"
gdb_test_multiple "continue" "continue" {
-re "Catchpoint $decimal\r\n.*loaded .*/$testfile2.*\r\n.*$gdb_prompt $" {
if {$match} {
pass "continue"
} else {
fail "continue"
}
} }
-re "Stopped due to shared library event.*\r\n$gdb_prompt $" { gdb_breakpoint [gdb_get_line_number "final breakpoint here"]
if {$sostop} { gdb_test_no_output "set var libname = \"$binfile2_dlopen\""
pass "continue" gdb_test_no_output "set stop-on-solib-events $sostop"
} else { gdb_test "catch $kind" "Catchpoint $decimal \\(.*\\)"
gdb_test_multiple "continue" "continue" {
-re "Catchpoint $decimal\r\n.*loaded .*/$testfile2.*\r\n.*$gdb_prompt $" {
if {$match} {
pass "continue"
} else {
fail "continue"
}
}
-re "Stopped due to shared library event.*\r\n$gdb_prompt $" {
if {$sostop} {
pass "continue"
} else {
fail "continue"
}
}
-re "Breakpoint $decimal, .*\r\n$gdb_prompt $" {
if {!$match} {
pass "continue"
} else {
fail "continue"
}
}
-re ".*$gdb_prompt $" {
fail "continue" fail "continue"
} }
} }
-re "Breakpoint $decimal, .*\r\n$gdb_prompt $" {
if {!$match} {
pass "continue"
} else {
fail "continue"
}
}
-re ".*$gdb_prompt $" {
fail "continue"
}
} }
}} }
one_catch_load_test "plain load" "load" 1 0 one_catch_load_test "plain load" "load" 1 0
one_catch_load_test "plain load with stop-on-solib-events" "load" 1 1 one_catch_load_test "plain load with stop-on-solib-events" "load" 1 1

View file

@ -30,128 +30,130 @@ if { [istarget "i\[34567\]86-*-linux*"] || [istarget "x86_64-*-linux*"] } {
return -1 return -1
} }
proc disp_step_cross_syscall { syscall } { with_test_prefix "$syscall" { proc disp_step_cross_syscall { syscall } {
global syscall_insn with_test_prefix "$syscall" {
global gdb_prompt global syscall_insn
global gdb_prompt
set testfile "disp-step-$syscall" set testfile "disp-step-$syscall"
if [prepare_for_testing ${testfile}.exp ${testfile} ${testfile}.c {debug}] { if [prepare_for_testing ${testfile}.exp ${testfile} ${testfile}.c {debug}] {
untested ${testfile}.exp untested ${testfile}.exp
return -1 return -1
}
if { ![runto main] } then {
fail "run to main ($syscall)"
return
}
# Delete the breakpoint on main.
gdb_test_no_output "delete break 1"
gdb_test "break marker" "Breakpoint.*at.* file .*${testfile}.c, line.*"
gdb_test_no_output "set displaced-stepping off"
set syscall_bp 0
gdb_test_multiple "break $syscall" "break $syscall" {
-re "Breakpoint (\[0-9\]*) at .*$gdb_prompt $" {
set syscall_bp $expect_out(1,string)
pass "break $syscall"
} }
}
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \ if { ![runto main] } then {
"continue to $syscall (1st time)" fail "run to main ($syscall)"
# Hit the breakpoint on $syscall for the first time. In this time, we will let PLT return
# resolution done, and the number single steps we will do later will be }
# reduced.
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \ # Delete the breakpoint on main.
"continue to $syscall (2nd time)" gdb_test_no_output "delete break 1"
# Hit the breakpoint on $syscall for the second time. In this time, the address
# of syscall insn and next insn of syscall are recorded.
gdb_test "display/i \$pc" ".*" gdb_test "break marker" "Breakpoint.*at.* file .*${testfile}.c, line.*"
gdb_test_no_output "set displaced-stepping off"
set syscall_bp 0
# Single step until we see sysall insn or we reach the upper bound of loop gdb_test_multiple "break $syscall" "break $syscall" {
# iterations. -re "Breakpoint (\[0-9\]*) at .*$gdb_prompt $" {
set see_syscall_insn 0 set syscall_bp $expect_out(1,string)
pass "break $syscall"
for {set i 0} {$i < 1000 && $see_syscall_insn == 0} {incr i} {
send_gdb "stepi\n"
gdb_expect {
-re ".*$syscall_insn.*$gdb_prompt $" {
set see_syscall_insn 1
} }
-re ".*$gdb_prompt $" {}
} }
}
if {$see_syscall_insn == 0} then { gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \
fail "find syscall insn in $syscall" "continue to $syscall (1st time)"
return -1 # Hit the breakpoint on $syscall for the first time. In this time, we will let PLT
} # resolution done, and the number single steps we will do later will be
# reduced.
set syscall_insn_addr [get_hexadecimal_valueof "\$pc" "0"] gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \
gdb_test "stepi" ".*" "stepi $syscall insn" "continue to $syscall (2nd time)"
set syscall_insn_next_addr [get_hexadecimal_valueof "\$pc" "0"] # Hit the breakpoint on $syscall for the second time. In this time, the address
# of syscall insn and next insn of syscall are recorded.
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \ gdb_test "display/i \$pc" ".*"
"continue to $syscall (3rd time)"
# Hit the breakpoint on $syscall for the third time. In this time, we'll set
# breakpoint on the syscall insn we recorded previously, and single step over it.
set syscall_insn_bp 0 # Single step until we see sysall insn or we reach the upper bound of loop
gdb_test_multiple "break \*$syscall_insn_addr" "break on syscall insn" { # iterations.
-re "Breakpoint (\[0-9\]*) at .*$gdb_prompt $" { set see_syscall_insn 0
set syscall_insn_bp $expect_out(1,string)
pass "break on syscall insns" for {set i 0} {$i < 1000 && $see_syscall_insn == 0} {incr i} {
send_gdb "stepi\n"
gdb_expect {
-re ".*$syscall_insn.*$gdb_prompt $" {
set see_syscall_insn 1
}
-re ".*$gdb_prompt $" {}
}
} }
}
gdb_test_no_output "delete $syscall_bp" "delete break $syscall"
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, .*" \ if {$see_syscall_insn == 0} then {
"continue to syscall insn $syscall" fail "find syscall insn in $syscall"
return -1
gdb_test_no_output "set displaced-stepping on"
# Check the address of next instruction of syscall.
if {$syscall == "vfork" && [is_remote target]} {
setup_kfail server/13796 "*-*-*"
}
set test "single step over $syscall"
gdb_test_multiple "stepi" $test {
-re "Program terminated with signal SIGILL,.*\r\n$gdb_prompt $" {
fail $test
return
} }
-re "\\\[Inferior .* exited normally\\\].*\r\n$gdb_prompt $" {
fail $test set syscall_insn_addr [get_hexadecimal_valueof "\$pc" "0"]
return gdb_test "stepi" ".*" "stepi $syscall insn"
set syscall_insn_next_addr [get_hexadecimal_valueof "\$pc" "0"]
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in |__libc_|)$syscall \\(\\).*" \
"continue to $syscall (3rd time)"
# Hit the breakpoint on $syscall for the third time. In this time, we'll set
# breakpoint on the syscall insn we recorded previously, and single step over it.
set syscall_insn_bp 0
gdb_test_multiple "break \*$syscall_insn_addr" "break on syscall insn" {
-re "Breakpoint (\[0-9\]*) at .*$gdb_prompt $" {
set syscall_insn_bp $expect_out(1,string)
pass "break on syscall insns"
}
} }
-re "\r\n$gdb_prompt $" { gdb_test_no_output "delete $syscall_bp" "delete break $syscall"
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, .*" \
"continue to syscall insn $syscall"
gdb_test_no_output "set displaced-stepping on"
# Check the address of next instruction of syscall.
if {$syscall == "vfork" && [is_remote target]} {
setup_kfail server/13796 "*-*-*"
}
set test "single step over $syscall"
gdb_test_multiple "stepi" $test {
-re "Program terminated with signal SIGILL,.*\r\n$gdb_prompt $" {
fail $test
return
}
-re "\\\[Inferior .* exited normally\\\].*\r\n$gdb_prompt $" {
fail $test
return
}
-re "\r\n$gdb_prompt $" {
pass $test
}
}
set syscall_insn_next_addr_found [get_hexadecimal_valueof "\$pc" "0"]
set test "single step over $syscall final pc"
if {$syscall_insn_next_addr != 0
&& $syscall_insn_next_addr == $syscall_insn_next_addr_found} {
pass $test pass $test
} else {
fail $test
} }
# Delete breakpoint syscall insns to avoid interference to other syscalls.
gdb_test_no_output "delete $syscall_insn_bp" "delete break $syscall insn"
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, marker \\(\\) at.*" \
"continue to marker ($syscall)"
} }
}
set syscall_insn_next_addr_found [get_hexadecimal_valueof "\$pc" "0"]
set test "single step over $syscall final pc"
if {$syscall_insn_next_addr != 0
&& $syscall_insn_next_addr == $syscall_insn_next_addr_found} {
pass $test
} else {
fail $test
}
# Delete breakpoint syscall insns to avoid interference to other syscalls.
gdb_test_no_output "delete $syscall_insn_bp" "delete break $syscall insn"
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, marker \\(\\) at.*" \
"continue to marker ($syscall)"
}}
disp_step_cross_syscall "fork" disp_step_cross_syscall "fork"
disp_step_cross_syscall "vfork" disp_step_cross_syscall "vfork"

View file

@ -63,55 +63,57 @@ if { [gdb_compile_shlib ${solib_srcfile} ${solib_binfile} {}] != "" } {
set solib_binfile_target [gdb_download ${solib_binfile}] set solib_binfile_target [gdb_download ${solib_binfile}]
proc one_jit_test {count match_str} { with_test_prefix "one_jit_test-$count" { proc one_jit_test {count match_str} {
global verbose testfile srcfile2 binfile2 binfile2_dlopen solib_binfile_target solib_binfile_test_msg with_test_prefix "one_jit_test-$count" {
global verbose testfile srcfile2 binfile2 binfile2_dlopen solib_binfile_target solib_binfile_test_msg
clean_restart $testfile clean_restart $testfile
gdb_load_shlibs $binfile2 gdb_load_shlibs $binfile2
# This is just to help debugging when things fail # This is just to help debugging when things fail
if {$verbose > 0} { if {$verbose > 0} {
gdb_test "set debug jit 1" gdb_test "set debug jit 1"
}
if { ![runto_main] } {
fail "Can't run to main"
return
}
gdb_breakpoint [gdb_get_line_number "break here before-dlopen" ]
gdb_continue_to_breakpoint "break here before-dlopen"
# Poke desired values directly into inferior instead of using "set args"
# because "set args" does not work under gdbserver.
gdb_test_no_output "set var jit_libname = \"$binfile2_dlopen\""
gdb_breakpoint [gdb_get_line_number "break here after-dlopen" ]
gdb_continue_to_breakpoint "break here after-dlopen"
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 0} $srcfile2]"
gdb_continue_to_breakpoint "break here 0"
gdb_test_no_output "set var argc = 2"
gdb_test_no_output "set var libname = \"$solib_binfile_target\"" "set var libname = \"$solib_binfile_test_msg\""
gdb_test_no_output "set var count = $count"
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 1} $srcfile2]"
gdb_continue_to_breakpoint "break here 1"
gdb_test "info function jit_function" "$match_str"
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "maintenance print objfiles"
gdb_test "maintenance info break"
}
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 2} $srcfile2]"
gdb_continue_to_breakpoint "break here 2"
# All jit librares must have been unregistered
gdb_test "info function jit_function" \
"All functions matching regular expression \"jit_function\":"
} }
}
if { ![runto_main] } {
fail "Can't run to main"
return
}
gdb_breakpoint [gdb_get_line_number "break here before-dlopen" ]
gdb_continue_to_breakpoint "break here before-dlopen"
# Poke desired values directly into inferior instead of using "set args"
# because "set args" does not work under gdbserver.
gdb_test_no_output "set var jit_libname = \"$binfile2_dlopen\""
gdb_breakpoint [gdb_get_line_number "break here after-dlopen" ]
gdb_continue_to_breakpoint "break here after-dlopen"
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 0} $srcfile2]"
gdb_continue_to_breakpoint "break here 0"
gdb_test_no_output "set var argc = 2"
gdb_test_no_output "set var libname = \"$solib_binfile_target\"" "set var libname = \"$solib_binfile_test_msg\""
gdb_test_no_output "set var count = $count"
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 1} $srcfile2]"
gdb_continue_to_breakpoint "break here 1"
gdb_test "info function jit_function" "$match_str"
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "maintenance print objfiles"
gdb_test "maintenance info break"
}
gdb_breakpoint "$srcfile2:[gdb_get_line_number {break here 2} $srcfile2]"
gdb_continue_to_breakpoint "break here 2"
# All jit librares must have been unregistered
gdb_test "info function jit_function" \
"All functions matching regular expression \"jit_function\":"
}}
one_jit_test 1 "${hex} jit_function_0000" one_jit_test 1 "${hex} jit_function_0000"
one_jit_test 2 "${hex} jit_function_0000\[\r\n\]+${hex} jit_function_0001" one_jit_test 2 "${hex} jit_function_0000\[\r\n\]+${hex} jit_function_0001"

View file

@ -61,47 +61,49 @@ proc compile_jit_test {testname options} {
return 0 return 0
} }
proc one_jit_test {count match_str} { with_test_prefix "one_jit_test-$count" { proc one_jit_test {count match_str} {
global verbose testfile solib_binfile_target solib_binfile_test_msg with_test_prefix "one_jit_test-$count" {
global verbose testfile solib_binfile_target solib_binfile_test_msg
clean_restart $testfile clean_restart $testfile
# This is just to help debugging when things fail # This is just to help debugging when things fail
if {$verbose > 0} { if {$verbose > 0} {
gdb_test "set debug jit 1" gdb_test "set debug jit 1"
}
if { ![runto_main] } {
fail "Can't run to main"
return
}
gdb_breakpoint [gdb_get_line_number "break here 0"]
gdb_continue_to_breakpoint "break here 0"
# Poke desired values directly into inferior instead of using "set args"
# because "set args" does not work under gdbserver.
gdb_test_no_output "set var argc = 2"
gdb_test_no_output "set var libname = \"$solib_binfile_target\"" "set var libname = \"$solib_binfile_test_msg\""
gdb_test_no_output "set var count = $count"
gdb_breakpoint [gdb_get_line_number "break here 1"]
gdb_continue_to_breakpoint "break here 1"
gdb_test "info function jit_function" "$match_str"
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "maintenance print objfiles"
gdb_test "maintenance info break"
}
gdb_breakpoint [gdb_get_line_number "break here 2"]
gdb_continue_to_breakpoint "break here 2"
# All jit librares must have been unregistered
gdb_test "info function jit_function" \
"All functions matching regular expression \"jit_function\":"
} }
}
if { ![runto_main] } {
fail "Can't run to main"
return
}
gdb_breakpoint [gdb_get_line_number "break here 0"]
gdb_continue_to_breakpoint "break here 0"
# Poke desired values directly into inferior instead of using "set args"
# because "set args" does not work under gdbserver.
gdb_test_no_output "set var argc = 2"
gdb_test_no_output "set var libname = \"$solib_binfile_target\"" "set var libname = \"$solib_binfile_test_msg\""
gdb_test_no_output "set var count = $count"
gdb_breakpoint [gdb_get_line_number "break here 1"]
gdb_continue_to_breakpoint "break here 1"
gdb_test "info function jit_function" "$match_str"
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "maintenance print objfiles"
gdb_test "maintenance info break"
}
gdb_breakpoint [gdb_get_line_number "break here 2"]
gdb_continue_to_breakpoint "break here 2"
# All jit librares must have been unregistered
gdb_test "info function jit_function" \
"All functions matching regular expression \"jit_function\":"
}}
if {[compile_jit_test jit.exp {}] < 0} { if {[compile_jit_test jit.exp {}] < 0} {
return return

View file

@ -648,101 +648,103 @@ test_next_with_recursion
#******** #********
proc test_different_dir {type test_different_dir xfail} { with_test_prefix "$type" { proc test_different_dir {type test_different_dir xfail} {
global srcdir subdir objdir binfile srcfile timeout gdb_prompt with_test_prefix "$type" {
global bp_location6 decimal hex global srcdir subdir objdir binfile srcfile timeout gdb_prompt
global bp_location6 decimal hex
gdb_exit gdb_exit
gdb_start gdb_start
gdb_reinitialize_dir $srcdir/$subdir gdb_reinitialize_dir $srcdir/$subdir
gdb_test_no_output "set debug-file-directory ${test_different_dir}" \ gdb_test_no_output "set debug-file-directory ${test_different_dir}" \
"set separate debug location" "set separate debug location"
gdb_load ${binfile} gdb_load ${binfile}
# #
# test break at function # test break at function
# #
if {$xfail} { if {$xfail} {
setup_xfail "*-*-*" setup_xfail "*-*-*"
}
gdb_test "break main" \
"Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function, optimized file"
#
# test break at function
#
if {$xfail} {
setup_xfail "*-*-*"
}
gdb_test "break marker4" \
"Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint small function, optimized file"
#
# run until the breakpoint at main is hit. For non-stubs-using targets.
#
gdb_run_cmd
if {$xfail} {
setup_xfail "*-*-*"
}
gdb_expect {
-re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $" {
pass "run until function breakpoint, optimized file"
} }
-re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $" { gdb_test "break main" \
pass "run until function breakpoint, optimized file (code motion)" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function, optimized file"
#
# test break at function
#
if {$xfail} {
setup_xfail "*-*-*"
} }
-re "$gdb_prompt $" { gdb_test "break marker4" \
fail "run until function breakpoint, optimized file" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint small function, optimized file"
#
# run until the breakpoint at main is hit. For non-stubs-using targets.
#
gdb_run_cmd
if {$xfail} {
setup_xfail "*-*-*"
} }
timeout { gdb_expect {
fail "run until function breakpoint, optimized file (timeout)" -re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $" {
pass "run until function breakpoint, optimized file"
}
-re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $" {
pass "run until function breakpoint, optimized file (code motion)"
}
-re "$gdb_prompt $" {
fail "run until function breakpoint, optimized file"
}
timeout {
fail "run until function breakpoint, optimized file (timeout)"
}
} }
#
# run until the breakpoint at a small function
#
#
# Add a second pass pattern. The behavior differs here between stabs
# and dwarf for one-line functions. Stabs preserves two line symbols
# (one before the prologue and one after) with the same line number,
# but dwarf regards these as duplicates and discards one of them.
# Therefore the address after the prologue (where the breakpoint is)
# has no exactly matching line symbol, and GDB reports the breakpoint
# as if it were in the middle of a line rather than at the beginning.
set bp_location13 [gdb_get_line_number "set breakpoint 13 here"]
set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
if {$xfail} {
setup_xfail "*-*-*"
}
gdb_test_multiple "continue" "run until breakpoint set at small function, optimized file" {
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*$gdb_prompt $" {
pass "run until breakpoint set at small function, optimized file"
}
-re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*$gdb_prompt $" {
pass "run until breakpoint set at small function, optimized file"
}
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*$gdb_prompt $" {
# marker4() is defined at line 46 when compiled with -DPROTOTYPES
pass "run until breakpoint set at small function, optimized file (line bp_location14)"
}
}
# Reset the default arguments for VxWorks
if [istarget "*-*-vxworks*"] {
set timeout 10
verbose "Timeout is now $timeout seconds" 2
gdb_test_no_output "set args main"
}
# proc test_different_dir
} }
}
#
# run until the breakpoint at a small function
#
#
# Add a second pass pattern. The behavior differs here between stabs
# and dwarf for one-line functions. Stabs preserves two line symbols
# (one before the prologue and one after) with the same line number,
# but dwarf regards these as duplicates and discards one of them.
# Therefore the address after the prologue (where the breakpoint is)
# has no exactly matching line symbol, and GDB reports the breakpoint
# as if it were in the middle of a line rather than at the beginning.
set bp_location13 [gdb_get_line_number "set breakpoint 13 here"]
set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
if {$xfail} {
setup_xfail "*-*-*"
}
gdb_test_multiple "continue" "run until breakpoint set at small function, optimized file" {
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*$gdb_prompt $" {
pass "run until breakpoint set at small function, optimized file"
}
-re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*$gdb_prompt $" {
pass "run until breakpoint set at small function, optimized file"
}
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*$gdb_prompt $" {
# marker4() is defined at line 46 when compiled with -DPROTOTYPES
pass "run until breakpoint set at small function, optimized file (line bp_location14)"
}
}
# Reset the default arguments for VxWorks
if [istarget "*-*-vxworks*"] {
set timeout 10
verbose "Timeout is now $timeout seconds" 2
gdb_test_no_output "set args main"
}
# proc test_different_dir
}}
# now move the .debug file to a different location so that we can test # now move the .debug file to a different location so that we can test

View file

@ -335,34 +335,36 @@ if ![runto_main] {
gdb_test "cd ${srcabsdir}/rdir" "Working directory [string_to_regexp ${srcabsdir}]/rdir\\." "cd .../rdir" gdb_test "cd ${srcabsdir}/rdir" "Working directory [string_to_regexp ${srcabsdir}]/rdir\\." "cd .../rdir"
proc test { func compdir filename } { with_test_prefix "$func" { proc test { func compdir filename } {
# Clear the GDB cache. with_test_prefix "$func" {
gdb_test_no_output "set directories" "" # Clear the GDB cache.
gdb_test_no_output "set directories" ""
if {$compdir == ""} { if {$compdir == ""} {
set absolute "$filename" set absolute "$filename"
} else { } else {
set absolute "$compdir/$filename" set absolute "$compdir/$filename"
}
if {[string index $absolute 0] != "/"} {
error "not absolute"
}
gdb_breakpoint $func
gdb_continue_to_breakpoint $func "$func \\(\\) at .*"
gdb_test_no_output "set filename-display absolute"
verbose -log "expect: ${absolute}"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp ${absolute}]:999" "absolute"
gdb_test_no_output "set filename-display basename"
verbose -log "expect: [file tail $filename]"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp [file tail $filename]]:999" "basename"
gdb_test_no_output "set filename-display relative"
verbose -log "expect: $filename"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp $filename]:999" "relative"
} }
if {[string index $absolute 0] != "/"} { }
error "not absolute"
}
gdb_breakpoint $func
gdb_continue_to_breakpoint $func "$func \\(\\) at .*"
gdb_test_no_output "set filename-display absolute"
verbose -log "expect: ${absolute}"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp ${absolute}]:999" "absolute"
gdb_test_no_output "set filename-display basename"
verbose -log "expect: [file tail $filename]"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp [file tail $filename]]:999" "basename"
gdb_test_no_output "set filename-display relative"
verbose -log "expect: $filename"
gdb_test "frame" " in $func \\(\\) at [string_to_regexp $filename]:999" "relative"
}}
set bdir "${srcabsdir}" set bdir "${srcabsdir}"
set file "${srctmpfile}" set file "${srctmpfile}"

View file

@ -33,49 +33,51 @@ if { [prepare_for_testing dw2-noloc.exp "dw2-noloc" {dw2-noloc-main.c dw2-noloc.
# unresolvable: .symtab entry does not exist for this symbol name. # unresolvable: .symtab entry does not exist for this symbol name.
# DW_AT_declaration is not present in any of these DIEs. # DW_AT_declaration is not present in any of these DIEs.
proc file_symbols {type} { with_test_prefix "$type" { proc file_symbols {type} {
with_test_prefix "$type" {
global gdb_prompt global gdb_prompt
gdb_test "print file_locaddr_resolvable" "= 1234567890" gdb_test "print file_locaddr_resolvable" "= 1234567890"
gdb_test "ptype file_locaddr_resolvable" "type = int" gdb_test "ptype file_locaddr_resolvable" "type = int"
gdb_test "print file_locaddr_unresolvable" "= 1234567890" gdb_test "print file_locaddr_unresolvable" "= 1234567890"
gdb_test "ptype file_locaddr_unresolvable" "type = int" gdb_test "ptype file_locaddr_unresolvable" "type = int"
gdb_test "print file_locempty_resolvable" "= <optimized out>" gdb_test "print file_locempty_resolvable" "= <optimized out>"
gdb_test "ptype file_locempty_resolvable" "type = int" gdb_test "ptype file_locempty_resolvable" "type = int"
gdb_test "print file_locempty_unresolvable" "= <optimized out>" gdb_test "print file_locempty_unresolvable" "= <optimized out>"
gdb_test "ptype file_locempty_unresolvable" "type = int" gdb_test "ptype file_locempty_unresolvable" "type = int"
gdb_test "print file_locno_resolvable" "= <optimized out>" gdb_test "print file_locno_resolvable" "= <optimized out>"
gdb_test "ptype file_locno_resolvable" "type = int" gdb_test "ptype file_locno_resolvable" "type = int"
gdb_test "print file_locno_unresolvable" "= <optimized out>" gdb_test "print file_locno_unresolvable" "= <optimized out>"
gdb_test "ptype file_locno_unresolvable" "type = int" gdb_test "ptype file_locno_unresolvable" "type = int"
gdb_test "print file_extern_locaddr_resolvable" "= 1234567890" gdb_test "print file_extern_locaddr_resolvable" "= 1234567890"
gdb_test "ptype file_extern_locaddr_resolvable" "type = int" gdb_test "ptype file_extern_locaddr_resolvable" "type = int"
gdb_test "print file_extern_locaddr_unresolvable" "= 1234567890" gdb_test "print file_extern_locaddr_unresolvable" "= 1234567890"
gdb_test "ptype file_extern_locaddr_unresolvable" "type = int" gdb_test "ptype file_extern_locaddr_unresolvable" "type = int"
gdb_test "print file_extern_locempty_resolvable" "= <optimized out>" gdb_test "print file_extern_locempty_resolvable" "= <optimized out>"
gdb_test "ptype file_extern_locempty_resolvable" "type = int" gdb_test "ptype file_extern_locempty_resolvable" "type = int"
gdb_test "print file_extern_locempty_unresolvable" "= <optimized out>" gdb_test "print file_extern_locempty_unresolvable" "= <optimized out>"
gdb_test "ptype file_extern_locempty_unresolvable" "type = int" gdb_test "ptype file_extern_locempty_unresolvable" "type = int"
gdb_test "print file_extern_locno_resolvable" "= 1234567890" gdb_test "print file_extern_locno_resolvable" "= 1234567890"
gdb_test "ptype file_extern_locno_resolvable" "type = int" gdb_test "ptype file_extern_locno_resolvable" "type = int"
# `print file_extern_locno_unresolvable' currently prints # `print file_extern_locno_unresolvable' currently prints
# Address of symbol "file_extern_locno_unresolvable" is unknown. # Address of symbol "file_extern_locno_unresolvable" is unknown.
# As DW_AT_declaration is not present in this DIE # As DW_AT_declaration is not present in this DIE
# it should print <optimized out>. As usefulness of such DIE is not # it should print <optimized out>. As usefulness of such DIE is not
# clear its resolution is not being tested. # clear its resolution is not being tested.
}} }
}
file_symbols no-run file_symbols no-run

View file

@ -138,98 +138,100 @@ test_insert_delete_modify
# Test 'breakpoint-modified' notification is emited when pending breakpoints are # Test 'breakpoint-modified' notification is emited when pending breakpoints are
# resolved. # resolved.
proc test_pending_resolved { } { with_test_prefix "pending resolved" { proc test_pending_resolved { } {
global decimal hex with_test_prefix "pending resolved" {
global srcdir global decimal hex
global subdir global srcdir
global binfile global subdir
global lib_sl1 lib_sl2 global binfile
global mi_gdb_prompt global lib_sl1 lib_sl2
global mi_gdb_prompt
gdb_exit gdb_exit
if [mi_gdb_start] { if [mi_gdb_start] {
continue continue
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
mi_load_shlibs $lib_sl1 $lib_sl2
# Create a pending breakpoint on pendfunc1
mi_gdb_test "-break-insert -f pendfunc1" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc1"
mi_run_cmd
set test "breakpoint on pendfunc1 resolved"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"1\".*addr=\"${hex}\".*,times=\"0\"" {
pass $test
exp_continue
}
-re ".*=breakpoint-modified,bkpt=\{number=\"1\".*addr=\"${hex}\".*,times=\"1\"" {
pass "$test: hit_count is updated"
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "breakpoint-hit" "pendfunc1" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to pendfunc1 breakpoint"
# Delete breakpoint on pendfunc1
mi_gdb_test "-break-delete 1" {\^done} \
"delete breakpoint on pendfunc1"
# Insert breakpoint on marker
mi_gdb_test "-break-insert marker" {.*\^done,bkpt=.*} \
"insert breakpoint on marker"
# Create a pending breakpoint on pendfunc3
mi_gdb_test "-break-insert -f pendfunc3" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc3"
mi_execute_to "exec-continue" "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker 1"
mi_send_resuming_command "exec-continue" "continuing execution to marker"
set test "breakpoint on pendfunc3 resolved"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"2\".*addr=\"${hex}\",.*func=\"marker\",.*times=\"1\"" {
pass "$test: hit_count is updated"
exp_continue
}
-re ".*=breakpoint-modified,bkpt=\{number=\"3\".*addr=\"${hex}\",.*func=\"pendfunc3\",.*times=\"0\"" {
pass $test
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker 2"
mi_send_resuming_command "exec-continue" "continuing to exit"
set test "breakpoint on pendfunc3 pending again"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"3\".*addr=\"<PENDING>\"" {
pass $test
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "exited-normally" "" "" "" "" "" ""
} }
mi_gdb_reinitialize_dir $srcdir/$subdir }
mi_gdb_load ${binfile}
mi_load_shlibs $lib_sl1 $lib_sl2
# Create a pending breakpoint on pendfunc1
mi_gdb_test "-break-insert -f pendfunc1" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc1"
mi_run_cmd
set test "breakpoint on pendfunc1 resolved"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"1\".*addr=\"${hex}\".*,times=\"0\"" {
pass $test
exp_continue
}
-re ".*=breakpoint-modified,bkpt=\{number=\"1\".*addr=\"${hex}\".*,times=\"1\"" {
pass "$test: hit_count is updated"
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "breakpoint-hit" "pendfunc1" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to pendfunc1 breakpoint"
# Delete breakpoint on pendfunc1
mi_gdb_test "-break-delete 1" {\^done} \
"delete breakpoint on pendfunc1"
# Insert breakpoint on marker
mi_gdb_test "-break-insert marker" {.*\^done,bkpt=.*} \
"insert breakpoint on marker"
# Create a pending breakpoint on pendfunc3
mi_gdb_test "-break-insert -f pendfunc3" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc3"
mi_execute_to "exec-continue" "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker 1"
mi_send_resuming_command "exec-continue" "continuing execution to marker"
set test "breakpoint on pendfunc3 resolved"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"2\".*addr=\"${hex}\",.*func=\"marker\",.*times=\"1\"" {
pass "$test: hit_count is updated"
exp_continue
}
-re ".*=breakpoint-modified,bkpt=\{number=\"3\".*addr=\"${hex}\",.*func=\"pendfunc3\",.*times=\"0\"" {
pass $test
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker 2"
mi_send_resuming_command "exec-continue" "continuing to exit"
set test "breakpoint on pendfunc3 pending again"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"3\".*addr=\"<PENDING>\"" {
pass $test
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "exited-normally" "" "" "" "" "" ""
}}
test_pending_resolved test_pending_resolved

View file

@ -23,78 +23,80 @@ if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
return -1 return -1
} }
proc test_command_param_changed { } { with_test_prefix "cmd param" { proc test_command_param_changed { } {
if [mi_gdb_start] { with_test_prefix "cmd param" {
return if [mi_gdb_start] {
} return
mi_run_to_main }
mi_run_to_main
foreach opt { "on" "off" "step" } { foreach opt { "on" "off" "step" } {
mi_gdb_test "set scheduler-locking ${opt}" \ mi_gdb_test "set scheduler-locking ${opt}" \
".*=cmd-param-changed,param=\"scheduler-locking\",value=\"${opt}\".*\\^done" \ ".*=cmd-param-changed,param=\"scheduler-locking\",value=\"${opt}\".*\\^done" \
"\"set scheduler-locking ${opt}\"" "\"set scheduler-locking ${opt}\""
} }
foreach opt { "on" "off" "step" } { foreach opt { "on" "off" "step" } {
mi_gdb_test "interpreter-exec console \"set scheduler-locking ${opt}\"" \ mi_gdb_test "interpreter-exec console \"set scheduler-locking ${opt}\"" \
".*=cmd-param-changed,param=\"scheduler-locking\",value=\"${opt}\".*\\^done" \ ".*=cmd-param-changed,param=\"scheduler-locking\",value=\"${opt}\".*\\^done" \
"interpreter-exec \"set scheduler-locking ${opt}\"" "interpreter-exec \"set scheduler-locking ${opt}\""
} }
# Don't emit MI notification for request from MI. # Don't emit MI notification for request from MI.
mi_gdb_test "-gdb-set scheduler-locking on" \ mi_gdb_test "-gdb-set scheduler-locking on" \
{\^done} \ {\^done} \
"\"set scheduler-locking on\" no event (requested by MI)" "\"set scheduler-locking on\" no event (requested by MI)"
mi_gdb_test "interpreter-exec mi \"-gdb-set scheduler-locking step\"" \ mi_gdb_test "interpreter-exec mi \"-gdb-set scheduler-locking step\"" \
"\\&\"interpreter-exec mi .*\"-gdb-set scheduler-locking step.*\"\\\\n\"\r\n\\^done\r\n\\^done" \ "\\&\"interpreter-exec mi .*\"-gdb-set scheduler-locking step.*\"\\\\n\"\r\n\\^done\r\n\\^done" \
"\"set scheduler-locking step\" no event (requested by MI interp)" "\"set scheduler-locking step\" no event (requested by MI interp)"
mi_gdb_test "set scheduler-locking step" \ mi_gdb_test "set scheduler-locking step" \
"\\&\"set scheduler-locking step\\\\n\"\r\n\\^done" \ "\\&\"set scheduler-locking step\\\\n\"\r\n\\^done" \
"\"set scheduler-locking stepr\" no event" "\"set scheduler-locking stepr\" no event"
foreach command { "remotecache" "check type" } { foreach command { "remotecache" "check type" } {
# The default value of each command option may be different, so we first # The default value of each command option may be different, so we first
# set it to 'off', and this may or may not trigger MI notification. # set it to 'off', and this may or may not trigger MI notification.
mi_gdb_test "set ${command} off" ".*\\^done" "\"set ${command}\" warmup" mi_gdb_test "set ${command} off" ".*\\^done" "\"set ${command}\" warmup"
foreach boolean_opt { "on" "off" } {
mi_gdb_test "set ${command} ${boolean_opt}" \
".*=cmd-param-changed,param=\"${command}\",value=\"${boolean_opt}\".*\\^done" \
"\"set ${command} ${boolean_opt}\""
}
mi_gdb_test "set ${command} off" \
"\\&\"set ${command} off\\\\n\"\r\n\\^done" \
"\"set ${command}\" no event"
}
foreach command { "trace-notes" "remote exec-file" } {
foreach str_opt { "foo" "bar" } {
mi_gdb_test "set ${command} ${str_opt}" \
".*=cmd-param-changed,param=\"${command}\",value=\"${str_opt}\".*\\^done" \
"\"set ${command} ${str_opt}\""
}
mi_gdb_test "set ${command} bar" \
"\\&\"set ${command} bar\\\\n\"\r\n(\\&\"warning.*|)\\^done" \
"\"set ${command} bar\" no event"
}
# No notification is emitted for 'maint set' commands.
foreach boolean_opt { "on" "off" } { foreach boolean_opt { "on" "off" } {
mi_gdb_test "set ${command} ${boolean_opt}" \ mi_gdb_test "maint set profile ${boolean_opt}" \
".*=cmd-param-changed,param=\"${command}\",value=\"${boolean_opt}\".*\\^done" \ "\\&\"maint set profile ${boolean_opt}\\\\n\"\r\n\\^done" \
"\"set ${command} ${boolean_opt}\"" "\"maint set profile ${boolean_opt}\""
} }
mi_gdb_test "set ${command} off" \
"\\&\"set ${command} off\\\\n\"\r\n\\^done" \ # Full command parameters are included in the notification when a
"\"set ${command}\" no event" # abbreviated one is typed.
mi_gdb_test "set ch type on" \
".*=cmd-param-changed,param=\"check type\",value=\"on\".*\\^done" \
"\"set ch type on\""
mi_gdb_exit
} }
}
foreach command { "trace-notes" "remote exec-file" } {
foreach str_opt { "foo" "bar" } {
mi_gdb_test "set ${command} ${str_opt}" \
".*=cmd-param-changed,param=\"${command}\",value=\"${str_opt}\".*\\^done" \
"\"set ${command} ${str_opt}\""
}
mi_gdb_test "set ${command} bar" \
"\\&\"set ${command} bar\\\\n\"\r\n(\\&\"warning.*|)\\^done" \
"\"set ${command} bar\" no event"
}
# No notification is emitted for 'maint set' commands.
foreach boolean_opt { "on" "off" } {
mi_gdb_test "maint set profile ${boolean_opt}" \
"\\&\"maint set profile ${boolean_opt}\\\\n\"\r\n\\^done" \
"\"maint set profile ${boolean_opt}\""
}
# Full command parameters are included in the notification when a
# abbreviated one is typed.
mi_gdb_test "set ch type on" \
".*=cmd-param-changed,param=\"check type\",value=\"on\".*\\^done" \
"\"set ch type on\""
mi_gdb_exit
}}
test_command_param_changed test_command_param_changed

View file

@ -141,21 +141,23 @@ proc test_watchpoint_triggering {type} {
clear_xfail *-*-* clear_xfail *-*-*
} }
proc test_watchpoint_all {type} { with_test_prefix "$type" { proc test_watchpoint_all {type} {
upvar srcdir srcdir with_test_prefix "$type" {
upvar subdir subdir upvar srcdir srcdir
upvar binfile binfile upvar subdir subdir
upvar binfile binfile
mi_delete_breakpoints mi_delete_breakpoints
mi_gdb_reinitialize_dir $srcdir/$subdir mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile} mi_gdb_load ${binfile}
mi_runto callee4 mi_runto callee4
test_watchpoint_creation_and_listing $type test_watchpoint_creation_and_listing $type
#test_rwatch_creation_and_listing $type #test_rwatch_creation_and_listing $type
#test_awatch_creation_and_listing $type #test_awatch_creation_and_listing $type
test_watchpoint_triggering $type test_watchpoint_triggering $type
}} }
}
# Run the tests twice, once using software watchpoints... # Run the tests twice, once using software watchpoints...
mi_gdb_test "567-gdb-set can-use-hw-watchpoints 0" \ mi_gdb_test "567-gdb-set can-use-hw-watchpoints 0" \

View file

@ -27,39 +27,41 @@ if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
return return
} }
proc test_memory_changed_observer { mi_command } { with_test_prefix "${mi_command}" { proc test_memory_changed_observer { mi_command } {
global srcfile with_test_prefix "${mi_command}" {
global srcfile
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
mi_run_to_main
set line_number [gdb_get_line_number "break here"]
mi_gdb_test "-break-insert ${srcfile}:${line_number}" \
{\^done,bkpt=.number="2",type="breakpoint".*\}} \
"set breakpoint"
mi_gdb_test "watch x" ".*" "set watchpoint"
mi_execute_to "exec-continue" "breakpoint-hit" "main" "" ".*" ".*" \
{ "" "disp=\"keep\"" } "breakpoint hit"
mi_execute_to "exec-continue" "watchpoint-trigger" "main" "" ".*" ".*" \
{ "" "wpt=\{number=\"3\",exp=\"x\"\},value=\{old=\"0\",new=\"42\"\}" } \
"watchpoint hit"
mi_execute_to "exec-continue" "breakpoint-hit" "main" "" ".*" ".*" \
{ "" "disp=\"keep\"" } "breakpoint hit 2"
mi_gdb_test "-${mi_command}" {\^done} "set x"
mi_execute_to "exec-continue" "watchpoint-trigger" "main" "" ".*" ".*" \
{ "" "wpt=\{number=\"3\",exp=\"x\"\},value=\{old=\"1\",new=\"42\"\}" } \
"watchpoint hit 2"
mi_gdb_exit
} }
mi_run_to_main }
set line_number [gdb_get_line_number "break here"]
mi_gdb_test "-break-insert ${srcfile}:${line_number}" \
{\^done,bkpt=.number="2",type="breakpoint".*\}} \
"set breakpoint"
mi_gdb_test "watch x" ".*" "set watchpoint"
mi_execute_to "exec-continue" "breakpoint-hit" "main" "" ".*" ".*" \
{ "" "disp=\"keep\"" } "breakpoint hit"
mi_execute_to "exec-continue" "watchpoint-trigger" "main" "" ".*" ".*" \
{ "" "wpt=\{number=\"3\",exp=\"x\"\},value=\{old=\"0\",new=\"42\"\}" } \
"watchpoint hit"
mi_execute_to "exec-continue" "breakpoint-hit" "main" "" ".*" ".*" \
{ "" "disp=\"keep\"" } "breakpoint hit 2"
mi_gdb_test "-${mi_command}" {\^done} "set x"
mi_execute_to "exec-continue" "watchpoint-trigger" "main" "" ".*" ".*" \
{ "" "wpt=\{number=\"3\",exp=\"x\"\},value=\{old=\"1\",new=\"42\"\}" } \
"watchpoint hit 2"
mi_gdb_exit
}}
test_memory_changed_observer "data-write-memory-bytes &x \"01\"" test_memory_changed_observer "data-write-memory-bytes &x \"01\""
# We want to trigger a target memory write here, so the word size (4 or 8) # We want to trigger a target memory write here, so the word size (4 or 8)

View file

@ -28,29 +28,31 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
return -1 return -1
} }
proc do_test { lock_sched } { with_test_prefix "lock-sched$lock_sched" { proc do_test { lock_sched } {
global executable with_test_prefix "lock-sched$lock_sched" {
global executable
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
return -1 return -1
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
} }
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
}}
do_test 0 do_test 0
do_test 1 do_test 1

View file

@ -29,33 +29,35 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
return -1 return -1
} }
proc do_test { lock_sched } { with_test_prefix "lock-sched$lock_sched" { proc do_test { lock_sched } {
global executable with_test_prefix "lock-sched$lock_sched" {
global executable
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
return -1 return -1
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
gdb_test "info threads" \
"\r\n\[ \t\]*Id\[ \t\]+Target\[ \t\]+Id\[ \t\]+Frame\[ \t\]*\r\n\\* 2 *Thread \[^\r\n\]* at \[^\r\n\]*" \
"single thread left"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
} }
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
gdb_test "info threads" \
"\r\n\[ \t\]*Id\[ \t\]+Target\[ \t\]+Id\[ \t\]+Frame\[ \t\]*\r\n\\* 2 *Thread \[^\r\n\]* at \[^\r\n\]*" \
"single thread left"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
}}
do_test 0 do_test 0
do_test 1 do_test 1

View file

@ -31,29 +31,31 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
return -1 return -1
} }
proc do_test { lock_sched } { with_test_prefix "lock-sched$lock_sched" { proc do_test { lock_sched } {
global executable with_test_prefix "lock-sched$lock_sched" {
global executable
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
return -1 return -1
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
} }
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
}}
do_test 0 do_test 0
do_test 1 do_test 1

View file

@ -30,29 +30,31 @@ if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executab
return -1 return -1
} }
proc do_test { lock_sched } { with_test_prefix "lock-sched$lock_sched" { proc do_test { lock_sched } {
global executable with_test_prefix "lock-sched$lock_sched" {
global executable
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
return -1 return -1
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
} }
}
gdb_breakpoint [gdb_get_line_number "break-here"]
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
# Also test with sched-lock to make sure we can follow the
# non-leader thread execing even though the main thread wasn't
# resumed before the exec.
if { $lock_sched } {
gdb_test_no_output "set scheduler-locking on"
}
gdb_test "continue" \
".*is executing new program.*Breakpoint 1, main.* at .*" \
"continue over exec"
}}
do_test 0 do_test 0
do_test 1 do_test 1

View file

@ -22,120 +22,122 @@ if [is_remote target] {
return return
} }
proc test {type symbol} { with_test_prefix "$type" { proc test {type symbol} {
global testfile subdir srcdir gdb_prompt with_test_prefix "$type" {
global testfile subdir srcdir gdb_prompt
set srcfile_type ${srcdir}/${subdir}/${testfile}-${type}.c set srcfile_type ${srcdir}/${subdir}/${testfile}-${type}.c
# no threads # no threads
with_test_prefix "singlethreaded" { with_test_prefix "singlethreaded" {
set executable ${testfile}-${type}-st set executable ${testfile}-${type}-st
set srcfile_main ${testfile}-st.c set srcfile_main ${testfile}-st.c
if {[build_executable $testfile.exp $executable \ if {[build_executable $testfile.exp $executable \
[list $srcfile_main ${testfile}-${type}.c] \ [list $srcfile_main ${testfile}-${type}.c] \
[list debug additional_flags=-D$symbol]] == -1} { [list debug additional_flags=-D$symbol]] == -1} {
return -1 return -1
}
clean_restart $executable
if [target_info exists gdb,no_hardware_watchpoints] {
# The software watchpoint functionality is in GDB an unrelated test.
gdb_test_no_output "set can-use-hw-watchpoints 0"
}
gdb_test "show detach-on-fork" "Whether gdb will detach the child of a fork is on\\."
gdb_test_no_output "set follow-fork-mode $type"
gdb_test "show follow-fork-mode" "Debugger response to a program call of fork or vfork is \"$type\"\\."
# Testcase uses it for the `follow-fork-mode child' type.
gdb_test "handle SIGUSR1 nostop noprint pass" "No\[ \t\]+No\[ \t\]+Yes.*"
if ![runto_main] {
return
}
gdb_test "watch var" "atchpoint \[0-9\]+: var" "Set the watchpoint"
# It is never hit but it should not be left over in the fork()ed-off child.
if [skip_hw_breakpoint_tests] {
set hbreak "break"
} else {
set hbreak "hbreak"
}
gdb_test "$hbreak marker"
gdb_breakpoint "mark_exit"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "hardware breakpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 0.*New value = 1.*forkoff *\\(1\\).*" "watchpoints work"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 1.*New value = 2.*forkoff *\\(2\\).*" "watchpoint after the first fork"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 2.*New value = 3.*mark_exit \\(\\);" "watchpoint after the second fork"
gdb_test "continue" "Continuing\\..*\r\nBreakpoint \[0-9\]+, mark_exit .*" "finish"
} }
clean_restart $executable # threads
if [target_info exists gdb,no_hardware_watchpoints] { if [target_info exists gdb,no_hardware_watchpoints] {
# The software watchpoint functionality is in GDB an unrelated test. # Watchpoint hits would get detected in unexpected threads.
gdb_test_no_output "set can-use-hw-watchpoints 0"
}
gdb_test "show detach-on-fork" "Whether gdb will detach the child of a fork is on\\."
gdb_test_no_output "set follow-fork-mode $type"
gdb_test "show follow-fork-mode" "Debugger response to a program call of fork or vfork is \"$type\"\\."
# Testcase uses it for the `follow-fork-mode child' type.
gdb_test "handle SIGUSR1 nostop noprint pass" "No\[ \t\]+No\[ \t\]+Yes.*"
if ![runto_main] {
return return
} }
gdb_test "watch var" "atchpoint \[0-9\]+: var" "Set the watchpoint" with_test_prefix "multithreaded" {
set executable ${testfile}-${type}-mt
set srcfile_main ${srcdir}/${subdir}/${testfile}-mt.c
if { [gdb_compile_pthreads "${srcfile_main} ${srcfile_type}" [standard_output_file ${executable}] executable [list debug "additional_flags=-D$symbol -DTHREAD"]] != "" } {
untested ${testfile}.exp
return
}
clean_restart $executable
# It is never hit but it should not be left over in the fork()ed-off child. gdb_test_no_output "set follow-fork-mode $type"
if [skip_hw_breakpoint_tests] { # Testcase uses it for the `follow-fork-mode child' type.
set hbreak "break" gdb_test "handle SIGUSR1 nostop noprint pass" "No\[ \t\]+No\[ \t\]+Yes.*"
} else {
set hbreak "hbreak" if ![runto_main] {
return
}
gdb_test "watch var" "atchpoint \[0-9\]+: var" "Set the watchpoint"
# It should not be left over in the fork()ed-off child.
gdb_test "$hbreak marker" {reakpoint [0-9]+.*}
gdb_breakpoint "mark_exit"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "hardware breakpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 0.*New value = 1.*validity-first.*" "singlethread watchpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 1.*New value = 2.*validity-thread-A.*" "multithreaded watchpoints work at A"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 2.*New value = 3.*validity-thread-B.*" "multithreaded watchpoints work at B"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint (A) after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 3.*New value = 4.*after-fork1-A.*" "watchpoint A after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 4.*New value = 5.*after-fork1-B.*" "watchpoint B after the first fork"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint (A) after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 5.*New value = 6.*after-fork2-A.*" "watchpoint A after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 6.*New value = 7.*after-fork2-B.*" "watchpoint B after the second fork"
gdb_test "continue" "Continuing\\..*\r\nBreakpoint \[0-9\]+, mark_exit .*" "finish"
} }
gdb_test "$hbreak marker"
gdb_breakpoint "mark_exit"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "hardware breakpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 0.*New value = 1.*forkoff *\\(1\\).*" "watchpoints work"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 1.*New value = 2.*forkoff *\\(2\\).*" "watchpoint after the first fork"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 2.*New value = 3.*mark_exit \\(\\);" "watchpoint after the second fork"
gdb_test "continue" "Continuing\\..*\r\nBreakpoint \[0-9\]+, mark_exit .*" "finish"
} }
}
# threads
if [target_info exists gdb,no_hardware_watchpoints] {
# Watchpoint hits would get detected in unexpected threads.
return
}
with_test_prefix "multithreaded" {
set executable ${testfile}-${type}-mt
set srcfile_main ${srcdir}/${subdir}/${testfile}-mt.c
if { [gdb_compile_pthreads "${srcfile_main} ${srcfile_type}" [standard_output_file ${executable}] executable [list debug "additional_flags=-D$symbol -DTHREAD"]] != "" } {
untested ${testfile}.exp
return
}
clean_restart $executable
gdb_test_no_output "set follow-fork-mode $type"
# Testcase uses it for the `follow-fork-mode child' type.
gdb_test "handle SIGUSR1 nostop noprint pass" "No\[ \t\]+No\[ \t\]+Yes.*"
if ![runto_main] {
return
}
gdb_test "watch var" "atchpoint \[0-9\]+: var" "Set the watchpoint"
# It should not be left over in the fork()ed-off child.
gdb_test "$hbreak marker" {reakpoint [0-9]+.*}
gdb_breakpoint "mark_exit"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "hardware breakpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 0.*New value = 1.*validity-first.*" "singlethread watchpoints work"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 1.*New value = 2.*validity-thread-A.*" "multithreaded watchpoints work at A"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 2.*New value = 3.*validity-thread-B.*" "multithreaded watchpoints work at B"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint (A) after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 3.*New value = 4.*after-fork1-A.*" "watchpoint A after the first fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 4.*New value = 5.*after-fork1-B.*" "watchpoint B after the first fork"
gdb_test "continue" \
"reakpoint \[0-9\]+, marker.*" "breakpoint (A) after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 5.*New value = 6.*after-fork2-A.*" "watchpoint A after the second fork"
gdb_test "continue" \
"atchpoint \[0-9\]+: var.*Old value = 6.*New value = 7.*after-fork2-B.*" "watchpoint B after the second fork"
gdb_test "continue" "Continuing\\..*\r\nBreakpoint \[0-9\]+, mark_exit .*" "finish"
}
}}
test parent FOLLOW_PARENT test parent FOLLOW_PARENT

View file

@ -69,208 +69,218 @@ if [is_amd64_regs_target] {
# Set tracepoint during tracing experiment. # Set tracepoint during tracing experiment.
proc tracepoint_change_loc_1 { trace_type } { with_test_prefix "1 $trace_type" { proc tracepoint_change_loc_1 { trace_type } {
global testfile with_test_prefix "1 $trace_type" {
global srcfile global testfile
global pcreg global srcfile
global gdb_prompt global pcreg
global gdb_prompt
clean_restart ${testfile} clean_restart ${testfile}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
} }
gdb_test_no_output "delete break 1" gdb_test_no_output "delete break 1"
# Set a tracepoint we'll never meet. Just to avoid the complain after # Set a tracepoint we'll never meet. Just to avoid the
# type `tstart' later. # complain after type `tstart' later.
gdb_test "next" ".*" gdb_test "next" ".*"
gdb_test "trace main" "Tracepoint \[0-9\] at.* file .*$srcfile, line.*" \ gdb_test "trace main" \
"set tracepoint on main" "Tracepoint \[0-9\] at.* file .*$srcfile, line.*" \
"set tracepoint on main"
gdb_test "break marker" "Breakpoint.*at.* file .*$srcfile, line.*" \ gdb_test "break marker" \
"breakpoint on marker" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint on marker"
gdb_test_no_output "tstart" gdb_test_no_output "tstart"
gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \ gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \
"continue to marker 1" "continue to marker 1"
# Set a tracepoint during tracing. # Set a tracepoint during tracing.
set test "set tracepoint on set_tracepoint" set test "set tracepoint on set_tracepoint"
gdb_test_multiple "${trace_type} set_tracepoint" $test { gdb_test_multiple "${trace_type} set_tracepoint" $test {
-re "Target returns error code .* too far .*$gdb_prompt $" { -re "Target returns error code .* too far .*$gdb_prompt $" {
if [string equal $trace_type "ftrace"] { if [string equal $trace_type "ftrace"] {
# The target was unable to install the fast tracepoint # The target was unable to install the fast tracepoint
# (e.g., jump pad too far from tracepoint). # (e.g., jump pad too far from tracepoint).
pass "$test (too far)" pass "$test (too far)"
} else { } else {
fail $test fail $test
}
}
-re "\r\n$gdb_prompt $" {
pass $test
} }
} }
-re "\r\n$gdb_prompt $" {
pass $test
}
}
gdb_trace_setactions "set action for tracepoint" "" \ gdb_trace_setactions "set action for tracepoint" "" \
"collect \$$pcreg" "^$" "collect \$$pcreg" "^$"
# tracepoint has two locations after shlib change-loc-1 is loaded. # tracepoint has two locations after shlib change-loc-1 is loaded.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*4\.1.* in func4.*4\.2.* in func4.*" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*4\.1.* in func4.*4\.2.* in func4.*" \
"tracepoint with two locations" "tracepoint with two locations"
set test "continue to marker 2" set test "continue to marker 2"
gdb_test_multiple "continue" $test { gdb_test_multiple "continue" $test {
-re "Target returns error code .* too far .*$gdb_prompt $" { -re "Target returns error code .* too far .*$gdb_prompt $" {
if [string equal $trace_type "ftrace"] { if [string equal $trace_type "ftrace"] {
# Expected if the target was unable to install the # Expected if the target was unable to install the
# fast tracepoint (e.g., jump pad too far from # fast tracepoint (e.g., jump pad too far from
# tracepoint). # tracepoint).
pass "$test (too far)" pass "$test (too far)"
# Skip the rest of the tests. # Skip the rest of the tests.
return return
} else { } else {
fail "continue to marker 2" fail "continue to marker 2"
fail $test fail $test
} }
} }
-re ".*Breakpoint.*marker.*at.*$srcfile.*$gdb_prompt $" { -re ".*Breakpoint.*marker.*at.*$srcfile.*$gdb_prompt $" {
pass "continue to marker 2" pass "continue to marker 2"
} }
} }
# tracepoint has three locations after shlib change-loc-2 is loaded. # tracepoint has three locations after shlib change-loc-2 is
gdb_test "info trace" \ # loaded.
"Num Type\[ \]+Disp Enb Address\[ \]+What.* gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*4\.1.* in func4.*4\.2.* in func4.*4\.3.* in func4 .*" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*4\.1.* in func4.*4\.2.* in func4.*4\.3.* in func4 .*" \
"tracepoint with three locations" "tracepoint with three locations"
gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \ gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \
"continue to marker 3" "continue to marker 3"
# shlib is unloaded, there are still three locations, but one is pending. # shlib is unloaded, there are still three locations, but one
gdb_test "info trace" \ # is pending.
"Num Type\[ \]+Disp Enb Address\[ \]+What.* gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.* \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*
4\.1.* in func4.*\tinstalled on target\r\n(4\.2.* in func4.*\tinstalled on target\r\n4\.3.* \<PENDING\>\[\t \]+set_tracepoint|4\.2.* \<PENDING\>\[\t \]+set_tracepoint.*4\.3.* in func4.*\tinstalled on target).*" \ 4\.1.* in func4.*\tinstalled on target\r\n(4\.2.* in func4.*\tinstalled on target\r\n4\.3.* \<PENDING\>\[\t \]+set_tracepoint|4\.2.* \<PENDING\>\[\t \]+set_tracepoint.*4\.3.* in func4.*\tinstalled on target).*" \
"tracepoint with two locations (unload)" "tracepoint with two locations (unload)"
gdb_test_no_output "tstop" gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint 4.*" "tfind frame 0" gdb_test "tfind" "Found trace frame 0, tracepoint 4.*" \
gdb_test "tfind" "Target failed to find requested trace frame\\..*" "tfind frame 0"
}} gdb_test "tfind" \
"Target failed to find requested trace frame\\..*"
}
}
# Set pending tracepoint. # Set pending tracepoint.
proc tracepoint_change_loc_2 { trace_type } { with_test_prefix "2 $trace_type" { proc tracepoint_change_loc_2 { trace_type } {
global srcdir with_test_prefix "2 $trace_type" {
global srcfile global srcdir
global subdir global srcfile
global pcreg global subdir
global binfile global pcreg
global gdb_prompt global binfile
global gdb_prompt
gdb_exit gdb_exit
gdb_start gdb_start
gdb_reinitialize_dir $srcdir/$subdir gdb_reinitialize_dir $srcdir/$subdir
gdb_test_multiple "${trace_type} set_tracepoint" "set pending tracepoint" { gdb_test_multiple "${trace_type} set_tracepoint" "set pending tracepoint" {
-re ".*Make \(|fast \)tracepoint pending.*y or \\\[n\\\]. $" { -re ".*Make \(|fast \)tracepoint pending.*y or \\\[n\\\]. $" {
gdb_test "y" "\(Fast t|T\)racepoint.*set_tracepoint.*pending." "set pending tracepoint" gdb_test "y" "\(Fast t|T\)racepoint.*set_tracepoint.*pending." "set pending tracepoint"
}
} }
}
gdb_trace_setactions "set action for tracepoint" "" \ gdb_trace_setactions "set action for tracepoint" "" \
"collect \$$pcreg" "^$" "collect \$$pcreg" "^$"
# tracepoint has no location information now. Make sure nothing # tracepoint has no location information now. Make sure nothing
# else is displayed. # else is displayed.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*PENDING.*set_tracepoint\r\n\[\t \]+collect \\$$pcreg\r" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*PENDING.*set_tracepoint\r\n\[\t \]+collect \\$$pcreg\r" \
"single pending tracepoint info (without symbols)" "single pending tracepoint info (without symbols)"
gdb_load ${binfile} gdb_load ${binfile}
# tracepoint has one location after executable is loaded. # tracepoint has one location after executable is loaded.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*func4.*" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*func4.*" \
"tracepoint with one location" "tracepoint with one location"
set main_bp 0 set main_bp 0
gdb_test_multiple "break main" "set breakpoint on main" { gdb_test_multiple "break main" "set breakpoint on main" {
-re "Breakpoint (\[0-9\]*) at .*, line.*$gdb_prompt $" { -re "Breakpoint (\[0-9\]*) at .*, line.*$gdb_prompt $" {
set main_bp $expect_out(1,string) set main_bp $expect_out(1,string)
}
} }
} gdb_run_cmd
gdb_run_cmd
gdb_test "" \ gdb_test "" \
".*Breakpoint.*main.*at.*$srcfile.*" \ ".*Breakpoint.*main.*at.*$srcfile.*" \
"run to main" "run to main"
gdb_test_no_output "delete break $main_bp" gdb_test_no_output "delete break $main_bp"
# tracepoint has two locations after shlib change-loc-1 is loaded. # tracepoint has two locations after shlib change-loc-1 is loaded.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*1\.1.* in func4.*1\.2.* in func4.*" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*1\.1.* in func4.*1\.2.* in func4.*" \
"tracepoint with two locations" "tracepoint with two locations"
gdb_test "break marker" "Breakpoint.*at.* file .*$srcfile, line.*" \ gdb_test "break marker" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint on marker" "breakpoint on marker"
# tracepoint with two locations will be downloaded and installed. # tracepoint with two locations will be downloaded and installed.
set test "tstart" set test "tstart"
gdb_test_multiple "tstart" $test { gdb_test_multiple "tstart" $test {
-re "^tstart\r\n$gdb_prompt $" { -re "^tstart\r\n$gdb_prompt $" {
pass "tstart" pass "tstart"
} }
-re "Target returns error code .* too far .*$gdb_prompt $" { -re "Target returns error code .* too far .*$gdb_prompt $" {
if [string equal $trace_type "ftrace"] { if [string equal $trace_type "ftrace"] {
# The target was unable to install the fast tracepoint # The target was unable to install the fast tracepoint
# (e.g., jump pad too far from tracepoint). # (e.g., jump pad too far from tracepoint).
pass "$test (too far)" pass "$test (too far)"
# Skip the rest of the tests. # Skip the rest of the tests.
return return
} else { } else {
fail $test fail $test
} }
}
} }
}
gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \ gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \
"continue to marker 1" "continue to marker 1"
gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \ gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \
"continue to marker 2" "continue to marker 2"
# tracepoint has three locations after shlib change-loc-2 is loaded. # tracepoint has three locations after shlib change-loc-2 is loaded.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*1\.1.* in func4.*1\.2.* in func4.*1\.3.* in func4 .*" \ \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*1\.1.* in func4.*1\.2.* in func4.*1\.3.* in func4 .*" \
"tracepoint with three locations" "tracepoint with three locations"
gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \ gdb_test "continue" ".*Breakpoint.*marker.*at.*$srcfile.*" \
"continue to marker 3" "continue to marker 3"
# shlib is unloaded, there are still three locations, but one is pending. # shlib is unloaded, there are still three locations, but one is pending.
gdb_test "info trace" \ gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.* \[0-9\]+\[\t \]+\(|fast \)tracepoint\[ \]+keep y.*\<MULTIPLE\>.*
1\.1.* in func4.*\tinstalled on target\r\n(1\.2.* in func4.*\tinstalled on target\r\n1\.3.* \<PENDING\>\[\t \]+set_tracepoint|1\.2.* \<PENDING\>\[\t \]+set_tracepoint\r\n1\.3.* in func4.*\tinstalled on target).*" \ 1\.1.* in func4.*\tinstalled on target\r\n(1\.2.* in func4.*\tinstalled on target\r\n1\.3.* \<PENDING\>\[\t \]+set_tracepoint|1\.2.* \<PENDING\>\[\t \]+set_tracepoint\r\n1\.3.* in func4.*\tinstalled on target).*" \
"tracepoint with two locations (unload)" "tracepoint with two locations (unload)"
gdb_test_no_output "tstop" gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint 1.*" "tfind frame 0" gdb_test "tfind" "Found trace frame 0, tracepoint 1.*" "tfind frame 0"
gdb_test "tfind" "Found trace frame 1, tracepoint 1.*" "tfind frame 1" gdb_test "tfind" "Found trace frame 1, tracepoint 1.*" "tfind frame 1"
gdb_test "tfind" "Found trace frame 2, tracepoint 1.*" "tfind frame 2" gdb_test "tfind" "Found trace frame 2, tracepoint 1.*" "tfind frame 2"
gdb_test "tfind" "Target failed to find requested trace frame\\..*" gdb_test "tfind" "Target failed to find requested trace frame\\..*"
}} }
}
tracepoint_change_loc_1 "trace" tracepoint_change_loc_1 "trace"
tracepoint_change_loc_2 "trace" tracepoint_change_loc_2 "trace"

View file

@ -45,101 +45,105 @@ if ![gdb_target_supports_trace] {
# Disconnect in tracing. # Disconnect in tracing.
proc disconnected_tracing { } { with_test_prefix "trace" { proc disconnected_tracing { } {
global executable with_test_prefix "trace" {
global decimal global executable
global srcfile global decimal
global srcfile
# Start with a fresh gdb. # Start with a fresh gdb.
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
} }
gdb_test_no_output "set confirm off" gdb_test_no_output "set confirm off"
gdb_test_no_output "set disconnected-tracing on" gdb_test_no_output "set disconnected-tracing on"
gdb_test "trace start" ".*" gdb_test "trace start" ".*"
gdb_trace_setactions "collect on tracepoint 2" "2" \ gdb_trace_setactions "collect on tracepoint 2" "2" \
"collect foo" "^$" "collect foo" "^$"
gdb_test "break end" "Breakpoint ${decimal} at .*" gdb_test "break end" "Breakpoint ${decimal} at .*"
gdb_test_no_output "tstart" gdb_test_no_output "tstart"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*"
gdb_test_no_output "tstop" gdb_test_no_output "tstop"
gdb_test "info tracepoints" ".*in start at.*" \ gdb_test "info tracepoints" ".*in start at.*" \
"first info tracepoints" "first info tracepoints"
gdb_test "disconnect" "Ending remote debugging\\." "first disconnect" gdb_test "disconnect" "Ending remote debugging\\." "first disconnect"
if { [gdb_reconnect] == 0 } { if { [gdb_reconnect] == 0 } {
pass "first reconnect after unload" pass "first reconnect after unload"
} else { } else {
fail "first reconnect after unload" fail "first reconnect after unload"
return 0 return 0
} }
gdb_test "info tracepoints" ".*in start at.*" \ gdb_test "info tracepoints" ".*in start at.*" \
"second info tracepoints" "second info tracepoints"
delete_breakpoints delete_breakpoints
gdb_test "info tracepoints" ".*No tracepoints..*" \ gdb_test "info tracepoints" ".*No tracepoints..*" \
"third info tracepoints" "third info tracepoints"
gdb_test "disconnect" "Ending remote debugging\\." "second disconnect" gdb_test "disconnect" "Ending remote debugging\\." "second disconnect"
if { [gdb_reconnect] == 0 } { if { [gdb_reconnect] == 0 } {
pass "second reconnect after unload" pass "second reconnect after unload"
} else { } else {
fail "second reconnect after unload" fail "second reconnect after unload"
return 0 return 0
} }
gdb_test "tstatus" gdb_test "tstatus"
gdb_test "info tracepoints" \ gdb_test "info tracepoints" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.* "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+tracepoint keep y.* in start at .*$srcfile:\[0-9\]+. \[0-9\]+\[\t \]+tracepoint keep y.* in start at .*$srcfile:\[0-9\]+.
\[\t \]+tracepoint already hit 1 time. \[\t \]+tracepoint already hit 1 time.
\[\t \]+trace buffer usage ${decimal} bytes. \[\t \]+trace buffer usage ${decimal} bytes.
\[\t \]+collect foo.*" \ \[\t \]+collect foo.*" \
"fourth info tracepoints" "fourth info tracepoints"
}} }
}
disconnected_tracing disconnected_tracing
# Disconnected in tfind # Disconnected in tfind
proc disconnected_tfind { } { with_test_prefix "tfind" { proc disconnected_tfind { } {
global executable with_test_prefix "tfind" {
global decimal global executable
global decimal
# Start with a fresh gdb. # Start with a fresh gdb.
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
}
gdb_test_no_output "set confirm off"
gdb_test_no_output "set disconnected-tracing on"
gdb_test "trace start" ".*"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint ${decimal} at .*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*"
gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" "tfind frame 0"
gdb_test "p \$trace_frame" ".*\\\$${decimal} = 0.*" \
"p \$trace_frame before disconnected"
gdb_test "p \$tracepoint" ".*\\\$${decimal} = 2.*" \
"p \$tracepoint before disconnected"
gdb_test "disconnect" "Ending remote debugging\\." "first disconnect"
gdb_test "p \$trace_frame" ".*\\\$${decimal} = -1.*"
gdb_test "p \$tracepoint" ".*\\\$${decimal} = -1.*"
gdb_test "p \$trace_line" ".*\\\$${decimal} = -1.*"
gdb_test "p \$trace_file" ".*\\\$${decimal} = void.*"
gdb_test "p \$trace_func" ".*\\\$${decimal} = void.*"
} }
}
gdb_test_no_output "set confirm off"
gdb_test_no_output "set disconnected-tracing on"
gdb_test "trace start" ".*"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint ${decimal} at .*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*"
gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" "tfind frame 0"
gdb_test "p \$trace_frame" ".*\\\$${decimal} = 0.*" \
"p \$trace_frame before disconnected"
gdb_test "p \$tracepoint" ".*\\\$${decimal} = 2.*" \
"p \$tracepoint before disconnected"
gdb_test "disconnect" "Ending remote debugging\\." "first disconnect"
gdb_test "p \$trace_frame" ".*\\\$${decimal} = -1.*"
gdb_test "p \$tracepoint" ".*\\\$${decimal} = -1.*"
gdb_test "p \$trace_line" ".*\\\$${decimal} = -1.*"
gdb_test "p \$trace_file" ".*\\\$${decimal} = void.*"
gdb_test "p \$trace_func" ".*\\\$${decimal} = void.*"
}}
disconnected_tfind disconnected_tfind

View file

@ -34,39 +34,41 @@ remote_exec target "$binfile"
# Copy tracefile from target to host. # Copy tracefile from target to host.
remote_download host [remote_upload target basic.tf] basic.tf remote_download host [remote_upload target basic.tf] basic.tf
proc test_tfind_tfile { } { with_test_prefix "tfile" { proc test_tfind_tfile { } {
global binfile with_test_prefix "tfile" {
global decimal global binfile
global decimal
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
mi_gdb_load ${binfile}
mi_gdb_test "-target-select tfile basic.tf" \
".*=breakpoint-created,bkpt=\{number=\"${decimal}\",type=\"tracepoint\",disp=\"keep\",enabled=\"y\",.*,func=\"write_basic_trace_file\".*\\^connected" \
"select trace file"
mi_gdb_test "tfind 0" \
".*=traceframe-changed,num=\"0\",tracepoint=\"${decimal}\".*\\^done" \
"tfind 0"
# No MI notification is sent because traceframe is not changed.
mi_gdb_test "tfind 0" \
"\\&\"tfind 0\\\\n\"\r\n\~\"Found.*\\^done" \
"tfind 0 again"
mi_gdb_test "tfind end" \
".*=traceframe-changed,end.*\\^done" \
"tfind end"
# No MI notification is send because request is from MI command.
mi_gdb_test "-trace-find frame-number 0" \
"-trace-find frame-number 0\r\n\\^done,found=\"1\",tracepoint=\"${decimal}\",traceframe=\"0\",frame=\{.*" \
"-trace-find frame-number 0"
mi_gdb_exit
} }
mi_gdb_load ${binfile} }
mi_gdb_test "-target-select tfile basic.tf" \
".*=breakpoint-created,bkpt=\{number=\"${decimal}\",type=\"tracepoint\",disp=\"keep\",enabled=\"y\",.*,func=\"write_basic_trace_file\".*\\^connected" \
"select trace file"
mi_gdb_test "tfind 0" \
".*=traceframe-changed,num=\"0\",tracepoint=\"${decimal}\".*\\^done" \
"tfind 0"
# No MI notification is sent because traceframe is not changed.
mi_gdb_test "tfind 0" \
"\\&\"tfind 0\\\\n\"\r\n\~\"Found.*\\^done" \
"tfind 0 again"
mi_gdb_test "tfind end" \
".*=traceframe-changed,end.*\\^done" \
"tfind end"
# No MI notification is send because request is from MI command.
mi_gdb_test "-trace-find frame-number 0" \
"-trace-find frame-number 0\r\n\\^done,found=\"1\",tracepoint=\"${decimal}\",traceframe=\"0\",frame=\{.*" \
"-trace-find frame-number 0"
mi_gdb_exit
}}
test_tfind_tfile test_tfind_tfile
@ -99,38 +101,40 @@ if ![gdb_target_supports_trace] {
gdb_exit gdb_exit
proc test_tfind_remote { } { with_test_prefix "remote" { proc test_tfind_remote { } {
global decimal with_test_prefix "remote" {
global decimal
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
mi_run_to_main
mi_gdb_test "-break-insert end" "\\^done.*" "break end"
mi_gdb_test "-break-insert -a func2" "\\^done.*" "break func2"
mi_gdb_test "-trace-start" "=breakpoint-modified,bkpt={.*installed=\"y\".*}.*\\^done.*" \
"trace start"
mi_execute_to "exec-continue" "breakpoint-hit" end "" ".*" ".*" \
{ "" "disp=\"keep\"" } \
"continue to end"
mi_gdb_test "-trace-stop" "\\^done.*" "trace stop"
mi_gdb_test "tfind 0" \
".*=traceframe-changed,num=\"0\",tracepoint=\"${decimal}\".*\\^done" \
"tfind 0"
mi_gdb_test "tfind" \
".*=traceframe-changed,num=\"1\",tracepoint=\"${decimal}\".*\\^done" \
"tfind"
mi_gdb_test "tfind end" \
".*=traceframe-changed,end.*\\^done" \
"tfind end"
mi_gdb_exit
} }
mi_run_to_main }
mi_gdb_test "-break-insert end" "\\^done.*" "break end"
mi_gdb_test "-break-insert -a func2" "\\^done.*" "break func2"
mi_gdb_test "-trace-start" "=breakpoint-modified,bkpt={.*installed=\"y\".*}.*\\^done.*" \
"trace start"
mi_execute_to "exec-continue" "breakpoint-hit" end "" ".*" ".*" \
{ "" "disp=\"keep\"" } \
"continue to end"
mi_gdb_test "-trace-stop" "\\^done.*" "trace stop"
mi_gdb_test "tfind 0" \
".*=traceframe-changed,num=\"0\",tracepoint=\"${decimal}\".*\\^done" \
"tfind 0"
mi_gdb_test "tfind" \
".*=traceframe-changed,num=\"1\",tracepoint=\"${decimal}\".*\\^done" \
"tfind"
mi_gdb_test "tfind end" \
".*=traceframe-changed,end.*\\^done" \
"tfind end"
mi_gdb_exit
}}
test_tfind_remote test_tfind_remote

View file

@ -49,192 +49,195 @@ set MIFLAGS "-i=mi"
# remote stub can be uploaded to GDB, and GDB emits MI notification if # remote stub can be uploaded to GDB, and GDB emits MI notification if
# new tracepoints are created. # new tracepoints are created.
proc test_reconnect { } { with_test_prefix "reconnect" { proc test_reconnect { } {
with_test_prefix "reconnect" {
global gdbserver_reconnect_p global gdbserver_reconnect_p
global gdb_prompt global gdb_prompt
global executable global executable
global lib_sl1 lib_sl2 global lib_sl1 lib_sl2
set gdbserver_reconnect_p 1 set gdbserver_reconnect_p 1
if { [info proc gdb_reconnect] == "" } { if { [info proc gdb_reconnect] == "" } {
return 0 return 0
} }
clean_restart $executable clean_restart $executable
gdb_load_shlibs $lib_sl1 gdb_load_shlibs $lib_sl1
gdb_load_shlibs $lib_sl2 gdb_load_shlibs $lib_sl2
if ![runto_main] then { if ![runto_main] then {
fail "Can't run to main" fail "Can't run to main"
return 0 return 0
} }
# Create tracepoints on marker and main, and leave them in the # Create tracepoints on marker and main, and leave them in the
# remote stub. # remote stub.
gdb_test "trace marker" "Tracepoint.*at.* file .*" \ gdb_test "trace marker" "Tracepoint.*at.* file .*" \
"tracepoint on marker" "tracepoint on marker"
gdb_test "trace main" "Tracepoint.*at.* file .*" \ gdb_test "trace main" "Tracepoint.*at.* file .*" \
"tracepoint on main" "tracepoint on main"
gdb_test_no_output "tstart" "start trace experiment" gdb_test_no_output "tstart" "start trace experiment"
set test "disconnect" set test "disconnect"
gdb_test_multiple "disconnect" $test { gdb_test_multiple "disconnect" $test {
-re "Trace is running but will stop on detach; detach anyway\\? \\(y or n\\) $" { -re "Trace is running but will stop on detach; detach anyway\\? \\(y or n\\) $" {
pass $test pass $test
set test "disconnected" set test "disconnected"
gdb_test_multiple "y" $test { gdb_test_multiple "y" $test {
-re "$gdb_prompt $" { -re "$gdb_prompt $" {
pass "$test" pass "$test"
}
} }
} }
} }
}
gdb_exit gdb_exit
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
global srcdir
global subdir
global binfile
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
global gdbserver_protocol
global gdbserver_gdbport
# Create tracepoints on marker and pendfunc2.
mi_gdb_test "-break-insert -a -f pendfunc2" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert tracepoint on pendfunc2"
mi_gdb_test "-break-insert -a marker" {.*\^done,bkpt=.*\".*} \
"insert tracepoint on marker"
# Connect to the remote stub again, and make sure GDB merges the
# tracepoints of both sides correctly.
send_gdb "47-target-select $gdbserver_protocol $gdbserver_gdbport\n"
global mi_gdb_prompt
set test "tracepoint created"
gdb_expect {
-re "=breakpoint-created,bkpt=\{number=\"1\",type=\"tracepoint\"" {
# Tracepoint 1 in GDB, which has already existed before
# connecting, should have been merged with a tracepoint on
# the target, so we shouldn't see a =breakpoint-created
# notification for it.
fail "$test: 1"
exp_continue
} }
-re "=breakpoint-created,bkpt=\{number=\"2\",type=\"tracepoint\"" {
# Similar to above.
fail "$test: 2"
exp_continue
}
-re "=breakpoint-created,bkpt=\{number=\"3\",type=\"tracepoint\",disp=\"keep\",enabled=\"y\",\[^\n\]+,func=\"main\"\[^\n\]+,installed=\"y\"" {
# A tracepoint on main was defined in the stub, not in GDB,
# so we should see a =breakpoint-created notification.
pass $test
}
}
# Tracepoint on marker is defined. After the sync, we know that
# the tracepoint is in remote stub. Mark it 'installed'.
set test "tracepoint on marker is installed"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"2\".*,func=\"marker\".*installed=\"y\".*${mi_gdb_prompt}$" {
pass "$test"
}
}
# Check that tracepoint 1 is still pending.
mi_gdb_test "-break-info 1" \
{.*\^done,BreakpointTable=.*addr=\"<PENDING>\".*} \
"break-info 1"
set gdbserver_reconnect_p 0 global srcdir
}} global subdir
global binfile
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
global gdbserver_protocol
global gdbserver_gdbport
# Create tracepoints on marker and pendfunc2.
mi_gdb_test "-break-insert -a -f pendfunc2" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert tracepoint on pendfunc2"
mi_gdb_test "-break-insert -a marker" {.*\^done,bkpt=.*\".*} \
"insert tracepoint on marker"
# Connect to the remote stub again, and make sure GDB merges the
# tracepoints of both sides correctly.
send_gdb "47-target-select $gdbserver_protocol $gdbserver_gdbport\n"
global mi_gdb_prompt
set test "tracepoint created"
gdb_expect {
-re "=breakpoint-created,bkpt=\{number=\"1\",type=\"tracepoint\"" {
# Tracepoint 1 in GDB, which has already existed before
# connecting, should have been merged with a tracepoint on
# the target, so we shouldn't see a =breakpoint-created
# notification for it.
fail "$test: 1"
exp_continue
}
-re "=breakpoint-created,bkpt=\{number=\"2\",type=\"tracepoint\"" {
# Similar to above.
fail "$test: 2"
exp_continue
}
-re "=breakpoint-created,bkpt=\{number=\"3\",type=\"tracepoint\",disp=\"keep\",enabled=\"y\",\[^\n\]+,func=\"main\"\[^\n\]+,installed=\"y\"" {
# A tracepoint on main was defined in the stub, not in GDB,
# so we should see a =breakpoint-created notification.
pass $test
}
}
# Tracepoint on marker is defined. After the sync, we know that
# the tracepoint is in remote stub. Mark it 'installed'.
set test "tracepoint on marker is installed"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"2\".*,func=\"marker\".*installed=\"y\".*${mi_gdb_prompt}$" {
pass "$test"
}
}
# Check that tracepoint 1 is still pending.
mi_gdb_test "-break-info 1" \
{.*\^done,BreakpointTable=.*addr=\"<PENDING>\".*} \
"break-info 1"
set gdbserver_reconnect_p 0
}
}
# Test 'breakpoint-modified' notification is emited when pending tracepoints are # Test 'breakpoint-modified' notification is emited when pending tracepoints are
# resolved. # resolved.
proc test_pending_resolved { } { with_test_prefix "pending resolved" { proc test_pending_resolved { } {
global decimal hex with_test_prefix "pending resolved" {
global executable global decimal hex
global srcdir global executable
global subdir global srcdir
global binfile global subdir
global lib_sl1 lib_sl2 global binfile
global mi_gdb_prompt global lib_sl1 lib_sl2
global mi_gdb_prompt
gdb_exit gdb_exit
if [mi_gdb_start] { if [mi_gdb_start] {
continue continue
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
mi_load_shlibs $lib_sl1 $lib_sl2
# Create a pending tracepoint on pendfunc2
mi_gdb_test "-break-insert -a -f pendfunc2" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc2"
# Insert breakpoint on marker
mi_gdb_test "-break-insert marker" {.*\^done,bkpt=.*} \
"insert breakpoint on marker"
mi_run_cmd
mi_expect_stop "breakpoint-hit" "marker" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to marker breakpoint"
mi_gdb_test "-trace-start" {\^done} "trace start"
mi_send_resuming_command "exec-continue" "continuing execution to marker 1"
# It is expected to get two "=breakpoint-modified" notifications.
# Pending tracepoint is resolved.
set test "tracepoint on pendfunc2 resolved"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*.*times=\"0\".*installed=\"n\"" {
pass "$test"
}
}
# Resolved tracepoint is installed.
set test "tracepoint on pendfunc2 installed"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*.*times=\"0\".*installed=\"y\"" {
pass "$test"
}
}
mi_expect_stop "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker"
mi_gdb_test "-trace-stop" {\^done,.*} "trace stop"
mi_gdb_test "-trace-find frame-number 0" \
"-trace-find frame-number 0\r\n\\^done,found=\"1\",tracepoint=\"${decimal}\",traceframe=\"0\",frame=\{.*" \
"-trace-find frame-number 0"
mi_gdb_test "-trace-find none" {\^done,found="0"} "back to live inferior"
mi_send_resuming_command "exec-continue" "continuing to exit"
set test "tracepoint on pendfunc2 becomes pending again"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*addr=\"<PENDING>\",.*times=\"0\"" {
pass "$test"
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "exited-normally" "" "" "" "" "" ""
} }
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
mi_load_shlibs $lib_sl1 $lib_sl2
# Create a pending tracepoint on pendfunc2
mi_gdb_test "-break-insert -a -f pendfunc2" \
{.*\^done,bkpt=.*addr=\"<PENDING>\".*} \
"insert breakpoint on pendfunc2"
# Insert breakpoint on marker
mi_gdb_test "-break-insert marker" {.*\^done,bkpt=.*} \
"insert breakpoint on marker"
mi_run_cmd
mi_expect_stop "breakpoint-hit" "marker" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to marker breakpoint"
mi_gdb_test "-trace-start" {\^done} "trace start"
mi_send_resuming_command "exec-continue" "continuing execution to marker 1"
# It is expected to get two "=breakpoint-modified" notifications.
# Pending tracepoint is resolved.
set test "tracepoint on pendfunc2 resolved"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*.*times=\"0\".*installed=\"n\"" {
pass "$test"
}
}
# Resolved tracepoint is installed.
set test "tracepoint on pendfunc2 installed"
gdb_expect {
-re "=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*.*times=\"0\".*installed=\"y\"" {
pass "$test"
}
}
mi_expect_stop "breakpoint-hit" "marker" ".*" ".*" ".*" \
{"" "disp=\"keep\""} "continue to marker"
mi_gdb_test "-trace-stop" {\^done,.*} "trace stop"
mi_gdb_test "-trace-find frame-number 0" \
"-trace-find frame-number 0\r\n\\^done,found=\"1\",tracepoint=\"${decimal}\",traceframe=\"0\",frame=\{.*" \
"-trace-find frame-number 0"
mi_gdb_test "-trace-find none" {\^done,found="0"} "back to live inferior"
mi_send_resuming_command "exec-continue" "continuing to exit"
set test "tracepoint on pendfunc2 becomes pending again"
gdb_expect {
-re ".*=breakpoint-modified,bkpt=\{number=\"1\",type=\"tracepoint\".*addr=\"<PENDING>\",.*times=\"0\"" {
pass "$test"
}
-re ".*${mi_gdb_prompt}$" {
fail $test
}
timeout {
fail "$test (timeout)"
}
}
mi_expect_stop "exited-normally" "" "" "" "" "" ""
}}
# Test target supports tracepoints or not. # Test target supports tracepoints or not.

View file

@ -25,202 +25,206 @@ if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
# Test notifications on creating, deleting and modifying TSV. # Test notifications on creating, deleting and modifying TSV.
proc test_create_delete_modify_tsv { } {with_test_prefix "create delete modify" { proc test_create_delete_modify_tsv { } {
global binfile with_test_prefix "create delete modify" {
global decimal global binfile
global testfile global decimal
global srcdir subdir global testfile
global mi_gdb_prompt global srcdir subdir
global mi_gdb_prompt
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
mi_gdb_load ${binfile}
mi_gdb_test "tvariable \$tvar1" \
".*=tsv-created,name=\"tvar1\",initial=\"0\"\\\\n.*\\^done" \
"tvariable \$tvar1"
mi_gdb_test "tvariable \$tvar1 = 1" \
".*=tsv-modified,name=\"tvar1\",initial=\"1\".*\\^done" \
"tvariable \$tvar1 modified"
# No "=tsv-modified" notification is emitted, because the initial
# value is not changed.
mi_gdb_test "tvariable \$tvar1 = 1" \
".*\\\$tvar1 = 1\\\\n\"\r\n~\"Trace state .*\\\\n.*\\^done" \
"tvariable \$tvar1 modified without notification"
mi_gdb_test "tvariable \$tvar2 = 45" \
".*=tsv-created,name=\"tvar2\",initial=\"45\"\\\\n.*\\^done" \
"tvariable \$tvar2"
mi_gdb_test "delete tvariable \$tvar2" \
".*=tsv-deleted,name=\"tvar2\"\\\\n.*\\^done" \
"delete tvariable \$tvar2"
mi_gdb_test "delete tvariable" \
".*=tsv-deleted\\\\n.*\\^done" \
"delete all tvariables"
# Test target supports tracepoints or not.
clean_restart $testfile
if ![runto_main] {
fail "Can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
unsupported "Current target does not support trace"
return -1
}
gdb_exit
if [mi_gdb_start] {
continue
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
mi_gdb_test "tvariable \$tvar3 = 3" \
".*=tsv-created,name=\"tvar3\",initial=\"3\".*\\^done" \
"tvariable \$tvar3 modified"
mi_gdb_test "-break-insert -a gdb_c_test" \
{.*\^done,bkpt=.*} \
"insert tracepoint on gdb_c_test"
# Define an action that increases $tvar3
send_gdb "actions\n"
gdb_expect {
-re "End with" {
} }
} mi_gdb_load ${binfile}
send_gdb "collect \$tvar3 += 3\nend\n"
set test "define actions" mi_gdb_test "tvariable \$tvar1" \
gdb_expect { ".*=tsv-created,name=\"tvar1\",initial=\"0\"\\\\n.*\\^done" \
-re ".*${mi_gdb_prompt}$" { "tvariable \$tvar1"
pass $test mi_gdb_test "tvariable \$tvar1 = 1" \
".*=tsv-modified,name=\"tvar1\",initial=\"1\".*\\^done" \
"tvariable \$tvar1 modified"
# No "=tsv-modified" notification is emitted, because the initial
# value is not changed.
mi_gdb_test "tvariable \$tvar1 = 1" \
".*\\\$tvar1 = 1\\\\n\"\r\n~\"Trace state .*\\\\n.*\\^done" \
"tvariable \$tvar1 modified without notification"
mi_gdb_test "tvariable \$tvar2 = 45" \
".*=tsv-created,name=\"tvar2\",initial=\"45\"\\\\n.*\\^done" \
"tvariable \$tvar2"
mi_gdb_test "delete tvariable \$tvar2" \
".*=tsv-deleted,name=\"tvar2\"\\\\n.*\\^done" \
"delete tvariable \$tvar2"
mi_gdb_test "delete tvariable" \
".*=tsv-deleted\\\\n.*\\^done" \
"delete all tvariables"
# Test target supports tracepoints or not.
clean_restart $testfile
if ![runto_main] {
fail "Can't run to main to check for trace support"
return -1
} }
timeout {
fail "$test (timeout)" if ![gdb_target_supports_trace] {
unsupported "Current target does not support trace"
return -1
} }
gdb_exit
if [mi_gdb_start] {
continue
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
mi_gdb_test "tvariable \$tvar3 = 3" \
".*=tsv-created,name=\"tvar3\",initial=\"3\".*\\^done" \
"tvariable \$tvar3 modified"
mi_gdb_test "-break-insert -a gdb_c_test" \
{.*\^done,bkpt=.*} \
"insert tracepoint on gdb_c_test"
# Define an action that increases $tvar3
send_gdb "actions\n"
gdb_expect {
-re "End with" {
}
}
send_gdb "collect \$tvar3 += 3\nend\n"
set test "define actions"
gdb_expect {
-re ".*${mi_gdb_prompt}$" {
pass $test
}
timeout {
fail "$test (timeout)"
}
}
mi_gdb_test "-break-insert begin" \
{.*\^done,bkpt=.*} \
"insert tracepoint on begin"
mi_gdb_test "-break-insert end" \
{.*\^done,bkpt=.*} \
"insert tracepoint on end"
mi_run_cmd
mi_expect_stop "breakpoint-hit" "begin" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to begin breakpoint"
mi_gdb_test "-trace-start" {.*\^done} "trace start"
mi_send_resuming_command "exec-continue" "continuing to end"
mi_gdb_test "-trace-stop" {.*} "trace stop"
# Force GDB to get the current value of trace state variable.
mi_gdb_test "-trace-list-variables" ".*" "list trace variables"
mi_gdb_test "tvariable \$tvar3 = 2" \
".*=tsv-modified,name=\"tvar3\",initial=\"2\",current=\"6\".*\\^done" \
"tvariable \$tvar3 modified"
} }
}
mi_gdb_test "-break-insert begin" \
{.*\^done,bkpt=.*} \
"insert tracepoint on begin"
mi_gdb_test "-break-insert end" \
{.*\^done,bkpt=.*} \
"insert tracepoint on end"
mi_run_cmd
mi_expect_stop "breakpoint-hit" "begin" ""\
".*" ".*" {"" "disp=\"keep\""} \
"continue to begin breakpoint"
mi_gdb_test "-trace-start" {.*\^done} "trace start"
mi_send_resuming_command "exec-continue" "continuing to end"
mi_gdb_test "-trace-stop" {.*} "trace stop"
# Force GDB to get the current value of trace state variable.
mi_gdb_test "-trace-list-variables" ".*" "list trace variables"
mi_gdb_test "tvariable \$tvar3 = 2" \
".*=tsv-modified,name=\"tvar3\",initial=\"2\",current=\"6\".*\\^done" \
"tvariable \$tvar3 modified"
}}
# Test when GDB connects to a disconnected stub, existing TSVs in # Test when GDB connects to a disconnected stub, existing TSVs in
# remote stub can be uploaded to GDB, and GDB emits MI notification # remote stub can be uploaded to GDB, and GDB emits MI notification
# for new uploaded TSVs. # for new uploaded TSVs.
proc test_upload_tsv { } { with_test_prefix "upload" { proc test_upload_tsv { } {
with_test_prefix "upload" {
global gdbserver_reconnect_p global gdbserver_reconnect_p
global gdb_prompt global gdb_prompt
global testfile global testfile
global decimal global decimal
set gdbserver_reconnect_p 1 set gdbserver_reconnect_p 1
if { [info proc gdb_reconnect] == "" } { if { [info proc gdb_reconnect] == "" } {
return 0 return 0
} }
clean_restart $testfile clean_restart $testfile
if ![runto_main] then { if ![runto_main] then {
fail "Can't run to main" fail "Can't run to main"
return 0 return 0
} }
gdb_test "tvariable \$tvar1" \ gdb_test "tvariable \$tvar1" \
"Trace state variable \\\$tvar1 created, with initial value 0." \ "Trace state variable \\\$tvar1 created, with initial value 0." \
"Create a trace state variable" "Create a trace state variable"
gdb_test "tvariable \$tvar2 = 45" \ gdb_test "tvariable \$tvar2 = 45" \
"Trace state variable \\\$tvar2 created, with initial value 45." \ "Trace state variable \\\$tvar2 created, with initial value 45." \
"Create a trace state variable with initial value" "Create a trace state variable with initial value"
# Define a tracepoint otherwise tracing cannot be started. # Define a tracepoint otherwise tracing cannot be started.
gdb_test "trace main" "Tracepoint $decimal at .*" gdb_test "trace main" "Tracepoint $decimal at .*"
gdb_test_no_output "tstart" "start trace experiment" gdb_test_no_output "tstart" "start trace experiment"
set test "disconnect" set test "disconnect"
gdb_test_multiple "disconnect" $test { gdb_test_multiple "disconnect" $test {
-re "Trace is running but will stop on detach; detach anyway\\? \\(y or n\\) $" { -re "Trace is running but will stop on detach; detach anyway\\? \\(y or n\\) $" {
pass $test pass $test
set test "disconnected" set test "disconnected"
gdb_test_multiple "y" $test { gdb_test_multiple "y" $test {
-re "$gdb_prompt $" { -re "$gdb_prompt $" {
pass "$test" pass "$test"
}
} }
} }
} }
}
gdb_exit gdb_exit
if [mi_gdb_start] { if [mi_gdb_start] {
return return
}
global srcdir
global subdir
global binfile
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
global gdbserver_protocol
global gdbserver_gdbport
send_gdb "47-target-select $gdbserver_protocol $gdbserver_gdbport\n"
global mi_gdb_prompt
set tsv1_created 0
set tsv2_created 0
gdb_expect {
-re "=tsv-created,name=\"tvar1\",initial=\"0\"" {
set tsv1_created 1
exp_continue
} }
-re "=tsv-created,name=\"tvar2\",initial=\"45\"" {
set tsv2_created 1 global srcdir
exp_continue global subdir
global binfile
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
global gdbserver_protocol
global gdbserver_gdbport
send_gdb "47-target-select $gdbserver_protocol $gdbserver_gdbport\n"
global mi_gdb_prompt
set tsv1_created 0
set tsv2_created 0
gdb_expect {
-re "=tsv-created,name=\"tvar1\",initial=\"0\"" {
set tsv1_created 1
exp_continue
}
-re "=tsv-created,name=\"tvar2\",initial=\"45\"" {
set tsv2_created 1
exp_continue
}
-re ".*${mi_gdb_prompt}" {
}
} }
-re ".*${mi_gdb_prompt}" {
if $tsv1_created {
pass "tsv1 created"
} else {
fail "tsv1 created"
}
if $tsv2_created {
pass "tsv2 created"
} else {
fail "tsv2 created"
} }
}
if $tsv1_created { set gdbserver_reconnect_p 0
pass "tsv1 created"
} else {
fail "tsv1 created"
} }
if $tsv2_created { }
pass "tsv2 created"
} else {
fail "tsv2 created"
}
set gdbserver_reconnect_p 0
}}
test_create_delete_modify_tsv test_create_delete_modify_tsv

View file

@ -58,107 +58,117 @@ if ![gdb_target_supports_trace] {
# Verify pending tracepoint is resolved to running to main. # Verify pending tracepoint is resolved to running to main.
proc pending_tracepoint_resolved { trace_type } { with_test_prefix "$trace_type resolved" { proc pending_tracepoint_resolved { trace_type } {
global srcdir with_test_prefix "$trace_type resolved" {
global subdir global srcdir
global binfile global subdir
global srcfile global binfile
global lib_sl1 global srcfile
global lib_sl1
# Start with a fresh gdb. # Start with a fresh gdb.
gdb_exit gdb_exit
gdb_start gdb_start
gdb_reinitialize_dir $srcdir/$subdir gdb_reinitialize_dir $srcdir/$subdir
gdb_test_multiple "$trace_type set_point1" "set pending tracepoint" { gdb_test_multiple "$trace_type set_point1" "set pending tracepoint" {
-re ".*Make \(fast |\)tracepoint pending.*y or \\\[n\\\]. $" { -re ".*Make \(fast |\)tracepoint pending.*y or \\\[n\\\]. $" {
gdb_test "y" "\(Fast t|T\)racepoint.*set_point1.*pending." \ gdb_test "y" "\(Fast t|T\)racepoint.*set_point1.*pending." \
"set pending tracepoint (without symbols)" "set pending tracepoint (without symbols)"
}
}
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*PENDING.*set_point1.*" \
"single pending tracepoint info (without symbols)"
gdb_load ${binfile}
gdb_test "break main" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function"
gdb_run_cmd
gdb_test "" "Breakpoint 2, main.*"
# Run to main which should resolve a pending tracepoint
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*pendfunc.*" \
"single tracepoint info"
}}
# Verify pending tracepoint is resolved and works as expected.
proc pending_tracepoint_works { trace_type } { with_test_prefix "$trace_type works" {
global executable
global srcfile
global lib_sl1
global gdb_prompt
# Restart with a fresh gdb.
clean_restart $executable
# Test setting and querying pending tracepoints
gdb_test_multiple "$trace_type set_point1" "set pending tracepoint" {
-re ".*Make \(fast |\)tracepoint pending.*y or \\\[n\\\]. $" {
gdb_test "y" "\(Fast t|T\)racepoint.*set_point1.*pending." "set pending tracepoint"
}
}
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*PENDING.*set_point1.*" \
"single pending tracepoint info"
# Run to main which should resolve a pending tracepoint
gdb_test "break main" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function"
gdb_run_cmd
gdb_test "" "Breakpoint 2, main.*"
gdb_test "break marker" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint on marker"
set test "start trace experiment"
gdb_test_multiple "tstart" $test {
-re "^tstart\r\n$gdb_prompt $" {
pass $test
}
-re "Target returns error code .* too far .*$gdb_prompt $" {
if [string equal $trace_type "ftrace"] {
# The target was unable to install the fast tracepoint
# (e.g., jump pad too far from tracepoint).
pass "$test (too far)"
# Skip the rest of the tests.
return
} else {
fail $test
} }
} }
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*PENDING.*set_point1.*" \
"single pending tracepoint info (without symbols)"
gdb_load ${binfile}
gdb_test "break main" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function"
gdb_run_cmd
gdb_test "" "Breakpoint 2, main.*"
# Run to main which should resolve a pending tracepoint
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*pendfunc.*" \
"single tracepoint info"
} }
}
gdb_test "continue" "Continuing.\r\n\r\nBreakpoint.*marker.*at.*$srcfile.*" \ # Verify pending tracepoint is resolved and works as expected.
"continue to marker"
gdb_test "tstop" "\[\r\n\]+" "stop trace experiment" proc pending_tracepoint_works { trace_type } {
with_test_prefix "$trace_type works" {
global executable
global srcfile
global lib_sl1
global gdb_prompt
gdb_test "tfind start" "#0 .*" "tfind test frame 0" # Restart with a fresh gdb.
gdb_test "tfind" "Found trace frame 1, tracepoint 1.*" "tfind test frame 1" clean_restart $executable
gdb_test "tfind" "Found trace frame 2, tracepoint 1.*" "tfind test frame 2"
gdb_test "tfind" "Target failed to find requested trace frame..*" "tfind test frame" # Test setting and querying pending tracepoints
}}
gdb_test_multiple "$trace_type set_point1" "set pending tracepoint" {
-re ".*Make \(fast |\)tracepoint pending.*y or \\\[n\\\]. $" {
gdb_test "y" \
"\(Fast t|T\)racepoint.*set_point1.*pending." \
"set pending tracepoint"
}
}
gdb_test "info trace" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+\(fast |\)tracepoint\[ \]+keep y.*PENDING.*set_point1.*" \
"single pending tracepoint info"
# Run to main which should resolve a pending tracepoint
gdb_test "break main" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function"
gdb_run_cmd
gdb_test "" "Breakpoint 2, main.*"
gdb_test "break marker" "Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint on marker"
set test "start trace experiment"
gdb_test_multiple "tstart" $test {
-re "^tstart\r\n$gdb_prompt $" {
pass $test
}
-re "Target returns error code .* too far .*$gdb_prompt $" {
if [string equal $trace_type "ftrace"] {
# The target was unable to install the fast tracepoint
# (e.g., jump pad too far from tracepoint).
pass "$test (too far)"
# Skip the rest of the tests.
return
} else {
fail $test
}
}
}
gdb_test "continue" "Continuing.\r\n\r\nBreakpoint.*marker.*at.*$srcfile.*" \
"continue to marker"
gdb_test "tstop" "\[\r\n\]+" "stop trace experiment"
gdb_test "tfind start" "#0 .*" "tfind test frame 0"
gdb_test "tfind" "Found trace frame 1, tracepoint 1.*" \
"tfind test frame 1"
gdb_test "tfind" "Found trace frame 2, tracepoint 1.*" \
"tfind test frame 2"
gdb_test "tfind" \
"Target failed to find requested trace frame..*" \
"tfind test frame"
}
}
# Verify pending tracepoint is resolved during trace. # Verify pending tracepoint is resolved during trace.

View file

@ -192,211 +192,212 @@ gdb_test "help tdump" "Print everything collected at the current.*" \
# Check the collected trace data from different sources, such as live # Check the collected trace data from different sources, such as live
# inferior and tfile. # inferior and tfile.
proc use_collected_data { data_source } { with_test_prefix "${data_source}" { proc use_collected_data { data_source } {
global tdp1 tdp2 tdp3 tdp4 tdp5 tdp6 with_test_prefix "${data_source}" {
global testline1 testline2 testline3 testline4 testline5 testline6 global tdp1 tdp2 tdp3 tdp4 tdp5 tdp6
global pcreg fpreg spreg global testline1 testline2 testline3 testline4 testline5 testline6
global srcfile srcdir subdir global pcreg fpreg spreg
global arg1 arg3 global srcfile srcdir subdir
global decimal hex gdb_prompt global arg1 arg3
# global decimal hex gdb_prompt
# 9.1 test the tdump command #
# # 9.1 test the tdump command
#
set timeout 60 set timeout 60
gdb_tfind_test "9.1: find frame for TP $tdp1" "tracepoint $tdp1" \ gdb_tfind_test "9.1: find frame for TP $tdp1" "tracepoint $tdp1" \
"\$tracepoint" "$tdp1" "\$tracepoint" "$tdp1"
# Nothing was collected at tdp1, so this tdump should be empty. # Nothing was collected at tdp1, so this tdump should be empty.
gdb_test "tdump" \ gdb_test "tdump" \
"Data collected at tracepoint $tdp1, trace frame $decimal:" \ "Data collected at tracepoint $tdp1, trace frame $decimal:" \
"9.1: tdump, nothing collected" "9.1: tdump, nothing collected"
gdb_tfind_test "9.1: find frame for TP $tdp2" "tracepoint $tdp2" \ gdb_tfind_test "9.1: find frame for TP $tdp2" "tracepoint $tdp2" \
"\$tracepoint" "$tdp2" "\$tracepoint" "$tdp2"
# regs were collected at tdp2. # regs were collected at tdp2.
# How to match for the output of "info registers" on an unknown architecture? # How to match for the output of "info registers" on an unknown architecture?
# For now, assume that most architectures have a register called "pc". # For now, assume that most architectures have a register called "pc".
gdb_test "tdump" \ gdb_test "tdump" \
"\[\r\n\]$pcreg .*" \ "\[\r\n\]$pcreg .*" \
"9.1: tdump, regs collected" "9.1: tdump, regs collected"
gdb_tfind_test "9.1: find frame for TP $tdp3" "tracepoint $tdp3" \ gdb_tfind_test "9.1: find frame for TP $tdp3" "tracepoint $tdp3" \
"\$tracepoint" "$tdp3" "\$tracepoint" "$tdp3"
# args were collected at tdp3 # args were collected at tdp3
gdb_test "tdump" \ gdb_test "tdump" \
"depth = 3.*q1 = 2.*q2 = 2.*q3 = 3.*q4 = 4.*q5 = 5.*q6 = 6" \ "depth = 3.*q1 = 2.*q2 = 2.*q3 = 3.*q4 = 4.*q5 = 5.*q6 = 6" \
"9.1: tdump, args collected" "9.1: tdump, args collected"
gdb_tfind_test "9.1: find frame for TP $tdp4" "tracepoint $tdp4" \ gdb_tfind_test "9.1: find frame for TP $tdp4" "tracepoint $tdp4" \
"\$tracepoint" "$tdp4" "\$tracepoint" "$tdp4"
# locals were collected at tdp4 # locals were collected at tdp4
gdb_test "tdump" \ gdb_test "tdump" \
"q = 1" \ "q = 1" \
"9.1: tdump, locals collected" "9.1: tdump, locals collected"
gdb_tfind_test "9.1: find frame for TP $tdp5" "tracepoint $tdp5" \ gdb_tfind_test "9.1: find frame for TP $tdp5" "tracepoint $tdp5" \
"\$tracepoint" "$tdp5" "\$tracepoint" "$tdp5"
# stack was collected at tdp5, plus the frame pointer # stack was collected at tdp5, plus the frame pointer
gdb_test "tdump" \ gdb_test "tdump" \
".$fpreg = .*$spreg @ 64 = .*" \ ".$fpreg = .*$spreg @ 64 = .*" \
"9.1: tdump, memrange collected" "9.1: tdump, memrange collected"
gdb_tfind_test "9.1: find frame for TP $tdp6" "tracepoint $tdp6" \ gdb_tfind_test "9.1: find frame for TP $tdp6" "tracepoint $tdp6" \
"\$tracepoint" "$tdp6" "\$tracepoint" "$tdp6"
# globals were collected at tdp6 # globals were collected at tdp6
gdb_test "tdump" \ gdb_test "tdump" \
"gdb_char_test = 1.*gdb_short_test = 2.*gdb_long_test = 3" \ "gdb_char_test = 1.*gdb_short_test = 2.*gdb_long_test = 3" \
"9.1: tdump, global variables collected" "9.1: tdump, global variables collected"
# 9.2 test tdump with arguments # 9.2 test tdump with arguments
# [no go, tdump doesn't have any arguments] # [no go, tdump doesn't have any arguments]
set linecount1 0 set linecount1 0
set linecount2 0 set linecount2 0
set linecount3 0 set linecount3 0
set linecount4 0 set linecount4 0
set linecount5 0 set linecount5 0
set linecount6 0 set linecount6 0
gdb_tfind_test "11.x, 12.1: find start frame" "start" "0" gdb_tfind_test "11.x, 12.1: find start frame" "start" "0"
# #
# 11.x test built-in trace variables $trace_frame, $trace_line etc. # 11.x test built-in trace variables $trace_frame, $trace_line etc.
# #
gdb_test "printf \"x %d x\\n\", \$trace_frame" "x 0 x" \ gdb_test "printf \"x %d x\\n\", \$trace_frame" "x 0 x" \
"11.1: test \$trace_frame" "11.1: test \$trace_frame"
gdb_test "printf \"x %d x\\n\", \$tracepoint" "x $tdp1 x" \ gdb_test "printf \"x %d x\\n\", \$tracepoint" "x $tdp1 x" \
"11.2: test \$tracepoint" "11.2: test \$tracepoint"
gdb_test "printf \"x %d x\\n\", \$trace_line" "x $testline1 x" \ gdb_test "printf \"x %d x\\n\", \$trace_line" "x $testline1 x" \
"11.3: test \$trace_line" "11.3: test \$trace_line"
gdb_test_multiple "print \$trace_file" "11.4: test \$trace_file" { gdb_test_multiple "print \$trace_file" "11.4: test \$trace_file" {
-re "\\$\[0-9\]+ = \"$srcfile\"\[\r\n\]+$gdb_prompt $" { -re "\\$\[0-9\]+ = \"$srcfile\"\[\r\n\]+$gdb_prompt $" {
pass "11.4: test \$trace_file" pass "11.4: test \$trace_file"
}
-re "\\$\[0-9\]+ = \"$srcdir/$subdir/$srcfile\"\[\r\n\]+$gdb_prompt $" {
pass "11.4: test \$trace_file"
}
} }
-re "\\$\[0-9\]+ = \"$srcdir/$subdir/$srcfile\"\[\r\n\]+$gdb_prompt $" {
pass "11.4: test \$trace_file"
}
}
#gdb_test "print \$trace_file" "\"$srcdir/$subdir/$srcfile\"" \ #gdb_test "print \$trace_file" "\"$srcdir/$subdir/$srcfile\"" \
# "11.4: test \$trace_file" # "11.4: test \$trace_file"
# #
# 12.x test report generation using arbitrary GDB commands, loops etc. # 12.x test report generation using arbitrary GDB commands, loops etc.
# #
gdb_test_multiple "while \$trace_frame != -1\n output \$trace_file\n printf \", line \%d \(tracepoint #\%d\)\\n\", \$trace_line, \$tracepoint\n tfind\n end" "12.1: trace report #1" { gdb_test_multiple "while \$trace_frame != -1\n output \$trace_file\n printf \", line \%d \(tracepoint #\%d\)\\n\", \$trace_line, \$tracepoint\n tfind\n end" "12.1: trace report #1" {
-re "> end\r\n" { -re "> end\r\n" {
exp_continue exp_continue
}
-re "^Found trace frame \[0-9\]+, tracepoint \[0-9\]+\r\n" {
exp_continue
}
-re "^\[^\r\n\]* line $testline1 .tracepoint .$tdp1\\)\r\n" {
set linecount1 [expr $linecount1 + 1]
exp_continue
}
-re "^\[^\r\n\]* line $testline2 .tracepoint .$tdp2\\)\r\n" {
set linecount2 [expr $linecount2 + 1]
exp_continue
}
-re "^\[^\r\n\]* line $testline3 .tracepoint .$tdp3\\)\r\n" {
set linecount3 [expr $linecount3 + 1]
exp_continue
}
-re "^\[^\r\n\]* line $testline4 .tracepoint .$tdp4\\)\r\n" {
set linecount4 [expr $linecount4 + 1]
exp_continue
}
-re "^\[^\r\n\]* line $testline5 .tracepoint .$tdp5\\)\r\n" {
set linecount5 [expr $linecount5 + 1]
exp_continue
}
-re "^\[^\r\n\]* line $testline6 .tracepoint .$tdp6\\)\r\n" {
set linecount6 [expr $linecount6 + 1]
exp_continue
}
-re "^No trace frame found\r\n$gdb_prompt $" {
if { ($linecount1 < 4) || ($linecount2 < 4) || ($linecount3 < 4) || ($linecount4 < 4) || ($linecount5 < 4) || ($linecount6 < 4) } {
fail "12.1: trace report #1"
} else {
pass "12.1: trace report #1"
}
}
} }
-re "^Found trace frame \[0-9\]+, tracepoint \[0-9\]+\r\n" {
exp_continue gdb_tfind_test "12.2: tfind end, selects no frame" "end" "-1"
gdb_tfind_test "12.2: find first TDP #2 frame" "tracepoint $tdp2" \
"\$tracepoint" "$tdp2"
set linecount2 0
gdb_test_multiple "while \$trace_frame != -1\n printf \"tracepoint #\%d, FP 0x\%08x, SP 0x\%08x, PC 0x%08x\\n\", \$tracepoint, \$fp, \$sp, \$pc\n tfind tracepoint\n end" "12.2: trace report #2" {
-re "tracepoint #$tdp2, FP $hex, SP $hex, PC $hex" {
set linecount2 [expr $linecount2 + 1]
exp_continue
}
-re ".*$gdb_prompt $" {
if { ($linecount2 < 4) } {
fail "12.2: trace report #2"
} else {
pass "12.2: trace report #2"
}
}
} }
-re "^\[^\r\n\]* line $testline1 .tracepoint .$tdp1\\)\r\n" {
set linecount1 [expr $linecount1 + 1] gdb_tfind_test "12.3: tfind end, selects no frame" "end" "-1"
exp_continue gdb_tfind_test "12.3: find first TDP #3 frame" "tracepoint $tdp3" \
"\$tracepoint" "$tdp3"
set linecount3 0
gdb_test_multiple "while \$trace_frame != -1\n printf \"TDP #\%d, frame \%d: depth = \%d, q1 = \%d\\n\", \$tracepoint, \$trace_frame, depth, q1\n tfind tracepoint\n end" "12.3: trace report #3" {
-re "TDP #$tdp3, frame $decimal: depth = $decimal, q1 = $decimal" {
set linecount3 [expr $linecount3 + 1]
exp_continue
}
-re ".*$gdb_prompt $" {
if { ($linecount3 < 4) } {
fail "12.3: trace report #3"
} else {
pass "12.3: trace report #3"
}
}
} }
-re "^\[^\r\n\]* line $testline2 .tracepoint .$tdp2\\)\r\n" {
set linecount2 [expr $linecount2 + 1] gdb_tfind_test "12.4: tfind end, selects no frame" "end" "-1"
exp_continue gdb_tfind_test "12.4: find first TDP #6 frame" "tracepoint $tdp6" \
} "\$tracepoint" "$tdp6"
-re "^\[^\r\n\]* line $testline3 .tracepoint .$tdp3\\)\r\n" {
set linecount3 [expr $linecount3 + 1] set linecount6 0
exp_continue
} gdb_test_multiple "while \$trace_frame != -1\n printf \"TDP #\%d, frame %d: char_test = \%d, long_test = \%d\\n\", \$tracepoint, \$trace_frame, gdb_char_test, gdb_long_test\n tfind tracepoint\n end" "12.4: trace report #4" {
-re "^\[^\r\n\]* line $testline4 .tracepoint .$tdp4\\)\r\n" { -re "TDP #$tdp6, frame $decimal: char_test = $arg1, long_test = $arg3" {
set linecount4 [expr $linecount4 + 1] set linecount6 [expr $linecount6 + 1]
exp_continue exp_continue
} }
-re "^\[^\r\n\]* line $testline5 .tracepoint .$tdp5\\)\r\n" { -re ".*$gdb_prompt $" {
set linecount5 [expr $linecount5 + 1] if { ($linecount6 < 4) } {
exp_continue fail "12.4: trace report #4"
} } else {
-re "^\[^\r\n\]* line $testline6 .tracepoint .$tdp6\\)\r\n" { pass "12.4: trace report #4"
set linecount6 [expr $linecount6 + 1] }
exp_continue
}
-re "^No trace frame found\r\n$gdb_prompt $" {
if { ($linecount1 < 4) || ($linecount2 < 4) || ($linecount3 < 4) || ($linecount4 < 4) || ($linecount5 < 4) || ($linecount6 < 4) } {
fail "12.1: trace report #1"
} else {
pass "12.1: trace report #1"
} }
} }
} }
gdb_tfind_test "12.2: tfind end, selects no frame" "end" "-1"
gdb_tfind_test "12.2: find first TDP #2 frame" "tracepoint $tdp2" \
"\$tracepoint" "$tdp2"
set linecount2 0
gdb_test_multiple "while \$trace_frame != -1\n printf \"tracepoint #\%d, FP 0x\%08x, SP 0x\%08x, PC 0x%08x\\n\", \$tracepoint, \$fp, \$sp, \$pc\n tfind tracepoint\n end" "12.2: trace report #2" {
-re "tracepoint #$tdp2, FP $hex, SP $hex, PC $hex" {
set linecount2 [expr $linecount2 + 1]
exp_continue
}
-re ".*$gdb_prompt $" {
if { ($linecount2 < 4) } {
fail "12.2: trace report #2"
} else {
pass "12.2: trace report #2"
}
}
}
gdb_tfind_test "12.3: tfind end, selects no frame" "end" "-1"
gdb_tfind_test "12.3: find first TDP #3 frame" "tracepoint $tdp3" \
"\$tracepoint" "$tdp3"
set linecount3 0
gdb_test_multiple "while \$trace_frame != -1\n printf \"TDP #\%d, frame \%d: depth = \%d, q1 = \%d\\n\", \$tracepoint, \$trace_frame, depth, q1\n tfind tracepoint\n end" "12.3: trace report #3" {
-re "TDP #$tdp3, frame $decimal: depth = $decimal, q1 = $decimal" {
set linecount3 [expr $linecount3 + 1]
exp_continue
}
-re ".*$gdb_prompt $" {
if { ($linecount3 < 4) } {
fail "12.3: trace report #3"
} else {
pass "12.3: trace report #3"
}
}
}
gdb_tfind_test "12.4: tfind end, selects no frame" "end" "-1"
gdb_tfind_test "12.4: find first TDP #6 frame" "tracepoint $tdp6" \
"\$tracepoint" "$tdp6"
set linecount6 0
gdb_test_multiple "while \$trace_frame != -1\n printf \"TDP #\%d, frame %d: char_test = \%d, long_test = \%d\\n\", \$tracepoint, \$trace_frame, gdb_char_test, gdb_long_test\n tfind tracepoint\n end" "12.4: trace report #4" {
-re "TDP #$tdp6, frame $decimal: char_test = $arg1, long_test = $arg3" {
set linecount6 [expr $linecount6 + 1]
exp_continue
}
-re ".*$gdb_prompt $" {
if { ($linecount6 < 4) } {
fail "12.4: trace report #4"
} else {
pass "12.4: trace report #4"
}
}
}
}
} }
use_collected_data "live" use_collected_data "live"

View file

@ -37,72 +37,81 @@ if ![gdb_target_supports_trace] {
# Verify that the sequence of commands "tstart tstop tstart" works well. # Verify that the sequence of commands "tstart tstop tstart" works well.
proc test_tstart_tstop_tstart { } { with_test_prefix "tstart_tstop_tstart" { proc test_tstart_tstop_tstart { } {
global executable with_test_prefix "tstart_tstop_tstart" {
global hex global executable
global hex
# Start with a fresh gdb. # Start with a fresh gdb.
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
}
gdb_test "trace func1" "Tracepoint \[0-9\] at $hex: file.*"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint \[0-9\] at $hex: file.*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to end"
gdb_test_no_output "tstop"
gdb_test_no_output "tstart"
} }
}
gdb_test "trace func1" "Tracepoint \[0-9\] at $hex: file.*"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint \[0-9\] at $hex: file.*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" "continue to end"
gdb_test_no_output "tstop"
gdb_test_no_output "tstart"
}}
# Verify the sequence of commands "tstart tstart" works well. # Verify the sequence of commands "tstart tstart" works well.
proc test_tstart_tstart { } { with_test_prefix "tstart_tstart" { proc test_tstart_tstart { } {
global executable with_test_prefix "tstart_tstart" {
global hex global executable
global hex
# Start with a fresh gdb. # Start with a fresh gdb.
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
}
gdb_test "trace func1" "Tracepoint \[0-9\] at $hex: file.*"
gdb_test_no_output "tstart"
gdb_test "tstart" "" "tstart again" \
"A trace is running already. Start a new run\\? \\(y or n\\) " \
"y"
} }
}
gdb_test "trace func1" "Tracepoint \[0-9\] at $hex: file.*"
gdb_test_no_output "tstart"
gdb_test "tstart" "" "tstart again" "A trace is running already. Start a new run\\? \\(y or n\\) " "y"
}}
# Verify that trace stops clearly when trace buffer is full. # Verify that trace stops clearly when trace buffer is full.
proc test_buffer_full_tstart { } { with_test_prefix "buffer_full_tstart" { proc test_buffer_full_tstart { } {
global executable with_test_prefix "buffer_full_tstart" {
global hex global executable
global hex
# Start with a fresh gdb. # Start with a fresh gdb.
clean_restart ${executable} clean_restart ${executable}
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
}
gdb_test "trace func2" "Tracepoint \[0-9\] at $hex: file.*"
gdb_trace_setactions "collect buf: define actions" \
"" \
"collect buf" "^$"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint \[0-9\] at $hex: file.*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" "continue to end"
gdb_test "tstatus" ".*buffer was full.*"
gdb_test_no_output "tstart"
} }
}
gdb_test "trace func2" "Tracepoint \[0-9\] at $hex: file.*"
gdb_trace_setactions "collect buf: define actions" \
"" \
"collect buf" "^$"
gdb_test_no_output "tstart"
gdb_test "break end" "Breakpoint \[0-9\] at $hex: file.*"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" "continue to end"
gdb_test "tstatus" ".*buffer was full.*"
gdb_test_no_output "tstart"
}}
test_tstart_tstop_tstart test_tstart_tstop_tstart

View file

@ -126,223 +126,245 @@ proc strace_remove_socket { action } {
} }
}} }}
proc strace_info_marker { } { with_test_prefix "info_marker" { proc strace_info_marker { } {
global executable with_test_prefix "info_marker" {
global gdb_prompt global executable
global libipa global gdb_prompt
global libipa
# Restart with a fresh gdb. # Restart with a fresh gdb.
clean_restart $executable clean_restart $executable
gdb_load_shlibs $libipa gdb_load_shlibs $libipa
if ![runto_main] { if ![runto_main] {
fail "Can't run to main" fail "Can't run to main"
return -1 return -1
}
# List the markers in program. They should be disabled.
gdb_test "info static-tracepoint-markers" \
".*ust/bar\[\t \]+n\[\t \]+.*ust/bar2\[\t \]+n\[\t \]+.*"
# List all the thread. It is expected to get three threads without
# any errors.
gdb_test_multiple "info threads 3 2 1" "info threads" {
-re "3\[ \t\]+Thread .*2\[ \t\]+Thread .*1\[ \t\]+Thread .*${gdb_prompt} $" {
pass "info threads"
} }
}
# GDB detaches inferior so that the socket file can be removed. # List the markers in program. They should be disabled.
gdb_test_multiple "detach" "detach" { gdb_test "info static-tracepoint-markers" \
-re "Detaching .*, process .*${gdb_prompt} $" { ".*ust/bar\[\t \]+n\[\t \]+.*ust/bar2\[\t \]+n\[\t \]+.*"
pass "detach"
# List all the thread. It is expected to get three threads without
# any errors.
gdb_test_multiple "info threads 3 2 1" "info threads" {
-re "3\[ \t\]+Thread .*2\[ \t\]+Thread .*1\[ \t\]+Thread .*${gdb_prompt} $" {
pass "info threads"
}
} }
}
}}
proc strace_probe_marker { } { with_test_prefix "probe_marker" { # GDB detaches inferior so that the socket file can be removed.
global executable gdb_test_multiple "detach" "detach" {
global expect_out -re "Detaching .*, process .*${gdb_prompt} $" {
global gdb_prompt pass "detach"
global hex
global libipa
# Restart with a fresh gdb.
clean_restart $executable
gdb_load_shlibs $libipa
if ![runto_main] {
fail "Can't run to main"
return -1
}
gdb_test "strace -m ust/bar" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "strace -m ust/bar2" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
# Two trace markers should be enabled.
gdb_test "info static-tracepoint-markers" \
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+y\[\t \]+$hex.*"
gdb_test "break end" "Breakpoint \[0-9\]+ at.*"
gdb_test_no_output "tstart"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" "continue to end"
gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" "tfind frame 0"
gdb_test "tfind" "Found trace frame 1, tracepoint .*" "tfind frame 1"
gdb_test "tfind" "Target failed to find requested trace frame\\..*"
}}
proc strace_trace_on_same_addr { type } {
with_test_prefix "trace_same_addr $type" {
global executable
global expect_out
global gdb_prompt
global hex
global libipa
# Restart with a fresh gdb.
clean_restart $executable
gdb_load_shlibs $libipa
if ![runto_main] {
fail "Can't run to main"
return -1
}
set marker_bar_addr ""
set marker_bar2_addr ""
# List the markers in program. They should be disabled.
gdb_test_multiple "info static-tracepoint-markers" "info static-tracepoint-markers 1" {
-re ".*ust/bar\[\t \]+n.*${gdb_prompt} $" {
set ignore ""
regexp "ust/bar\[\t \]+n\[\t \]+($hex) .*ust/bar2\[\t \]+n\[\t \]+($hex) " \
"$expect_out(0,string)" ignore marker_bar_addr marker_bar2_addr
pass "info static-tracepoint-markers 1"
}
-re ".*${gdb_prompt} $" {
fail "info static-tracepoint-markers 1"
}
}
gdb_test "strace -m ust/bar" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "strace -m ust/bar2" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
# Two trace markers should be enabled.
gdb_test "info static-tracepoint-markers" \
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+y\[\t \]+$hex.*" \
"info static-tracepoint-markers 2"
# Set breapoints or tracepoints.
set test "${type} on marker bar"
gdb_test_multiple "${type} *${marker_bar_addr}" $test {
-re "\(Fast trace|Trace|Break\)point \[0-9\]+ at ${hex}: file.*\r\n$gdb_prompt $" {
pass $test
}
-re ".*\r\n$gdb_prompt $" {
if [string equal $type "ftrace"] {
# The instruction may be not long enough to set a fast
# tracepoint. Skip the rest of this test.
return -1
} else {
fail $test
}
}
}
set test "${type} on marker bar2"
gdb_test_multiple "${type} *${marker_bar2_addr}" $test {
-re "\(Fast trace|Trace|Break\)point \[0-9\]+ at ${hex}: file.*" {
pass $test
}
-re ".*\r\n$gdb_prompt $" {
if [string equal $type "ftrace"] {
# The instruction may be not long enough to set a fast
# tracepoint. Skip the rest of this test.
return -1
} else {
fail $test
} }
} }
} }
}
gdb_test "break end" "Breakpoint \[0-9\]+ at.*" proc strace_probe_marker { } {
with_test_prefix "probe_marker" {
global executable
global expect_out
global gdb_prompt
global hex
global libipa
if [string equal $type "break"] { # Restart with a fresh gdb.
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \ clean_restart $executable
"continue to bar" gdb_load_shlibs $libipa
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \ if ![runto_main] {
"continue to bar2" fail "Can't run to main"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \ return -1
"continue to end" }
} else {
gdb_test "strace -m ust/bar" \
"Static tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "strace -m ust/bar2" \
"Static tracepoint \[0-9\]+ at ${hex}: file.*"
# Two trace markers should be enabled.
gdb_test "info static-tracepoint-markers" \
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+y\[\t \]+$hex.*"
gdb_test "break end" "Breakpoint \[0-9\]+ at.*"
gdb_test_no_output "tstart" gdb_test_no_output "tstart"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \ gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to end" "continue to end"
gdb_test_no_output "tstop" gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" "tfind frame 0" gdb_test "tfind" "Found trace frame 0, tracepoint .*" \
gdb_test "tfind" "Found trace frame 1, tracepoint .*" "tfind frame 1" "tfind frame 0"
gdb_test "tfind" "Found trace frame 2, tracepoint .*" "tfind frame 2" gdb_test "tfind" "Found trace frame 1, tracepoint .*" \
gdb_test "tfind" "Found trace frame 3, tracepoint .*" "tfind frame 3" "tfind frame 1"
gdb_test "tfind" "Target failed to find requested trace frame\\..*" gdb_test "tfind" \
"Target failed to find requested trace frame\\..*"
} }
}} }
proc strace_trace_on_diff_addr { } { with_test_prefix "trace_diff_addr" { proc strace_trace_on_same_addr { type } {
with_test_prefix "trace_same_addr $type" {
global executable
global expect_out
global gdb_prompt
global hex
global libipa
global executable # Restart with a fresh gdb.
global expect_out clean_restart $executable
global gdb_prompt gdb_load_shlibs $libipa
global hex if ![runto_main] {
global libipa fail "Can't run to main"
return -1
# Restart with a fresh gdb.
clean_restart $executable
gdb_load_shlibs $libipa
if ![runto_main] {
fail "Can't run to main"
return -1
}
set marker_bar_addr ""
set marker_bar2_addr ""
# List the markers in program. They should be disabled.
gdb_test_multiple "info static-tracepoint-markers" "info static-tracepoint-markers 1" {
-re ".*ust/bar\[\t \]+n.*${gdb_prompt} $" {
set ignore ""
regexp "ust/bar\[\t \]+n\[\t \]+($hex) .*ust/bar2\[\t \]+n\[\t \]+($hex) " \
"$expect_out(0,string)" ignore marker_bar_addr marker_bar2_addr
pass "info static-tracepoint-markers 1"
} }
-re ".*${gdb_prompt} $" {
fail "info static-tracepoint-markers 1" set marker_bar_addr ""
set marker_bar2_addr ""
# List the markers in program. They should be disabled.
gdb_test_multiple "info static-tracepoint-markers" "info static-tracepoint-markers 1" {
-re ".*ust/bar\[\t \]+n.*${gdb_prompt} $" {
set ignore ""
regexp "ust/bar\[\t \]+n\[\t \]+($hex) .*ust/bar2\[\t \]+n\[\t \]+($hex) " \
"$expect_out(0,string)" ignore marker_bar_addr marker_bar2_addr
pass "info static-tracepoint-markers 1"
}
-re ".*${gdb_prompt} $" {
fail "info static-tracepoint-markers 1"
}
}
gdb_test "strace -m ust/bar" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "strace -m ust/bar2" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
# Two trace markers should be enabled.
gdb_test "info static-tracepoint-markers" \
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+y\[\t \]+$hex.*" \
"info static-tracepoint-markers 2"
# Set breapoints or tracepoints.
set test "${type} on marker bar"
gdb_test_multiple "${type} *${marker_bar_addr}" $test {
-re "\(Fast trace|Trace|Break\)point \[0-9\]+ at ${hex}: file.*\r\n$gdb_prompt $" {
pass $test
}
-re ".*\r\n$gdb_prompt $" {
if [string equal $type "ftrace"] {
# The instruction may be not long enough to set a fast
# tracepoint. Skip the rest of this test.
return -1
} else {
fail $test
}
}
}
set test "${type} on marker bar2"
gdb_test_multiple "${type} *${marker_bar2_addr}" $test {
-re "\(Fast trace|Trace|Break\)point \[0-9\]+ at ${hex}: file.*" {
pass $test
}
-re ".*\r\n$gdb_prompt $" {
if [string equal $type "ftrace"] {
# The instruction may be not long enough to set a fast
# tracepoint. Skip the rest of this test.
return -1
} else {
fail $test
}
}
}
gdb_test "break end" "Breakpoint \[0-9\]+ at.*"
if [string equal $type "break"] {
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to bar"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to bar2"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to end"
} else {
gdb_test_no_output "tstart"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
"continue to end"
gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" \
"tfind frame 0"
gdb_test "tfind" "Found trace frame 1, tracepoint .*" \
"tfind frame 1"
gdb_test "tfind" "Found trace frame 2, tracepoint .*" \
"tfind frame 2"
gdb_test "tfind" "Found trace frame 3, tracepoint .*" \
"tfind frame 3"
gdb_test "tfind" \
"Target failed to find requested trace frame\\..*"
} }
} }
}
gdb_test "strace -m ust/bar" "Static tracepoint \[0-9\]+ at ${hex}: file.*" proc strace_trace_on_diff_addr { } {
with_test_prefix "trace_diff_addr" {
gdb_test "info static-tracepoint-markers" \ global executable
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+n\[\t \]+$hex.*" \ global expect_out
"info static-tracepoint-markers 2" global gdb_prompt
global hex
global libipa
# Restart with a fresh gdb.
clean_restart $executable
gdb_load_shlibs $libipa
if ![runto_main] {
fail "Can't run to main"
return -1
}
set marker_bar_addr ""
set marker_bar2_addr ""
# List the markers in program. They should be disabled.
gdb_test_multiple "info static-tracepoint-markers" "info static-tracepoint-markers 1" {
-re ".*ust/bar\[\t \]+n.*${gdb_prompt} $" {
set ignore ""
regexp "ust/bar\[\t \]+n\[\t \]+($hex) .*ust/bar2\[\t \]+n\[\t \]+($hex) " \
"$expect_out(0,string)" ignore marker_bar_addr marker_bar2_addr
pass "info static-tracepoint-markers 1"
}
-re ".*${gdb_prompt} $" {
fail "info static-tracepoint-markers 1"
}
}
gdb_test "strace -m ust/bar" "Static tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "info static-tracepoint-markers" \
"ust/bar\[\t \]+y\[\t \]+$hex .*ust/bar2\[\t \]+n\[\t \]+$hex.*" \
"info static-tracepoint-markers 2"
# Set common tracepoint. # Set common tracepoint.
gdb_test "trace *${marker_bar2_addr}" \ gdb_test "trace *${marker_bar2_addr}" \
"Tracepoint \[0-9\]+ at ${hex}: file.*" "Tracepoint \[0-9\]+ at ${hex}: file.*"
gdb_test "break end" "Breakpoint \[0-9\]+ at.*" gdb_test "break end" "Breakpoint \[0-9\]+ at.*"
gdb_test_no_output "tstart" gdb_test_no_output "tstart"
gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" "continue to end" gdb_test "continue" "Continuing\\.\[ \r\n\]+Breakpoint.*" \
gdb_test_no_output "tstop" "continue to end"
gdb_test_no_output "tstop"
gdb_test "tfind" "Found trace frame 0, tracepoint .*" "tfind frame 0" gdb_test "tfind" "Found trace frame 0, tracepoint .*" \
gdb_test "tfind" "Found trace frame 1, tracepoint .*" "tfind frame 1" "tfind frame 0"
gdb_test "tfind" "Target failed to find requested trace frame\\..*" gdb_test "tfind" "Found trace frame 1, tracepoint .*" \
}} "tfind frame 1"
gdb_test "tfind" \
"Target failed to find requested trace frame\\..*"
}
}
# Run it on x86/x86_64 linux. # Run it on x86/x86_64 linux.
if { [istarget "x86_64-*-linux*"] || [istarget "i\[34567\]86-*-linux*"] } { if { [istarget "x86_64-*-linux*"] || [istarget "i\[34567\]86-*-linux*"] } {

View file

@ -133,174 +133,180 @@ proc test_maybe_regvar_display { var } {
# Test procs # Test procs
# #
proc gdb_collect_args_test {} { with_test_prefix "unavailable arguments" { proc gdb_collect_args_test {} {
global cr with_test_prefix "unavailable arguments" {
global gdb_prompt global cr
global gdb_prompt
prepare_for_trace_test prepare_for_trace_test
gdb_test "trace args_test_func" \ gdb_test "trace args_test_func" \
"Tracepoint \[0-9\]+ at .*" \
"set tracepoint"
# Begin the test.
run_trace_experiment args_test_func
# Test printing the variables, and also their addresses. We
# haven't collected any stack, so there's no way GDB can figure
# out the latter.
gdb_test "print argc" " = <unavailable>"
gdb_test "print &argc" \
"Can't take address of \"argc\" which isn't an lvalue\."
gdb_test "print argi" " = <unavailable>"
gdb_test "print &argi" \
"Can't take address of \"argi\" which isn't an lvalue\."
gdb_test "print argf" " = <unavailable>"
gdb_test "print &argf" \
"Can't take address of \"argf\" which isn't an lvalue\."
gdb_test "print argd" " = <unavailable>"
gdb_test "print &argd" \
"Can't take address of \"argd\" which isn't an lvalue\."
# struct arg as one of several args (near end of list)
gdb_test "print argstruct" \
" = \{memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>\}"
gdb_test "print argstruct.memberc" " = <unavailable>"
gdb_test "print argstruct.memberi" " = <unavailable>"
gdb_test "print argstruct.memberf" " = <unavailable>"
gdb_test "print argstruct.memberd" " = <unavailable>"
gdb_test "print argarray" " = \\(int \\*\\) <unavailable>"
gdb_test "print &argarray" \
"Can't take address of \"argarray\" which isn't an lvalue\."
gdb_test "print argarray\[0\]" "value is not available"
# Test "info args"
set r ""
set r "${r}argc = <unavailable>${cr}"
set r "${r}argi = <unavailable>${cr}"
set r "${r}argf = <unavailable>${cr}"
set r "${r}argd = <unavailable>${cr}"
set r "${r}argstruct = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}"
set r "${r}argarray = <unavailable>${cr}"
gdb_test "info args" "$r" "info args"
test_maybe_regvar_display "argc"
gdb_test "tfind none" \
"#0 end .*" \
"cease trace debugging"
}}
proc gdb_collect_locals_test { func msg } { with_test_prefix "unavailable locals: $msg" {
global cr
global gdb_prompt
prepare_for_trace_test
set testline [gdb_get_line_number "set $func tracepoint here"]
gdb_test "trace $testline" \
"Tracepoint \[0-9\]+ at .*" \ "Tracepoint \[0-9\]+ at .*" \
"set tracepoint" "set tracepoint"
# Begin the test. # Begin the test.
run_trace_experiment $func run_trace_experiment args_test_func
gdb_test "print locc" " = <unavailable>" # Test printing the variables, and also their addresses. We
gdb_test "print loci" " = <unavailable>" # haven't collected any stack, so there's no way GDB can figure
gdb_test "print locf" " = <unavailable>" # out the latter.
gdb_test "print locd" " = <unavailable>"
gdb_test "print locst.memberc" " = <unavailable>" gdb_test "print argc" " = <unavailable>"
gdb_test "print locst.memberi" " = <unavailable>" gdb_test "print &argc" \
gdb_test "print locst.memberf" " = <unavailable>" "Can't take address of \"argc\" which isn't an lvalue\."
gdb_test "print locst.memberd" " = <unavailable>"
gdb_test "print locar\[0\]" " = <unavailable>" gdb_test "print argi" " = <unavailable>"
gdb_test "print locar\[1\]" " = <unavailable>" gdb_test "print &argi" \
gdb_test "print locar\[2\]" " = <unavailable>" "Can't take address of \"argi\" which isn't an lvalue\."
gdb_test "print locar\[3\]" " = <unavailable>"
# Test "info locals" gdb_test "print argf" " = <unavailable>"
set r "" gdb_test "print &argf" \
set r "${r}locf = <unavailable>${cr}" "Can't take address of \"argf\" which isn't an lvalue\."
set r "${r}locd = <unavailable>${cr}"
set r "${r}locst = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}" gdb_test "print argd" " = <unavailable>"
set r "${r}locar = {<unavailable>, <unavailable>, <unavailable>, <unavailable>}${cr}" gdb_test "print &argd" \
set r "${r}i = <unavailable>${cr}" "Can't take address of \"argd\" which isn't an lvalue\."
if { $func == "local_test_func" } {
set r "${r}locdefst = {<No data fields>}${cr}" # struct arg as one of several args (near end of list)
gdb_test "print argstruct" \
" = \{memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>\}"
gdb_test "print argstruct.memberc" " = <unavailable>"
gdb_test "print argstruct.memberi" " = <unavailable>"
gdb_test "print argstruct.memberf" " = <unavailable>"
gdb_test "print argstruct.memberd" " = <unavailable>"
gdb_test "print argarray" " = \\(int \\*\\) <unavailable>"
gdb_test "print &argarray" \
"Can't take address of \"argarray\" which isn't an lvalue\."
gdb_test "print argarray\[0\]" "value is not available"
# Test "info args"
set r ""
set r "${r}argc = <unavailable>${cr}"
set r "${r}argi = <unavailable>${cr}"
set r "${r}argf = <unavailable>${cr}"
set r "${r}argd = <unavailable>${cr}"
set r "${r}argstruct = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}"
set r "${r}argarray = <unavailable>${cr}"
gdb_test "info args" "$r" "info args"
test_maybe_regvar_display "argc"
gdb_test "tfind none" \
"#0 end .*" \
"cease trace debugging"
} }
set r "${r}locc = <unavailable>${cr}" }
set r "${r}loci = <unavailable>${cr}"
gdb_test "info locals" "$r" "info locals"
test_maybe_regvar_display "loci" proc gdb_collect_locals_test { func msg } {
with_test_prefix "unavailable locals: $msg" {
global cr
global gdb_prompt
gdb_test "tfind none" \ prepare_for_trace_test
"#0 end .*" \
"cease trace debugging"
}}
proc gdb_unavailable_registers_test { } { with_test_prefix "unavailable registers" { set testline [gdb_get_line_number "set $func tracepoint here"]
global gdb_prompt
global spreg
global pcreg
prepare_for_trace_test gdb_test "trace $testline" \
# We'll simply re-use the globals_test_function for this test
gdb_test "trace globals_test_func" \
"Tracepoint \[0-9\]+ at .*" \ "Tracepoint \[0-9\]+ at .*" \
"set tracepoint" "set tracepoint"
# Collect nothing. # Begin the test.
run_trace_experiment $func
# Begin the test. gdb_test "print locc" " = <unavailable>"
run_trace_experiment globals_test_func gdb_test "print loci" " = <unavailable>"
gdb_test "print locf" " = <unavailable>"
gdb_test "print locd" " = <unavailable>"
# On some archs, the $sp/$pc are a real raw registers. On others, gdb_test "print locst.memberc" " = <unavailable>"
# like x86, they're user registers. Test both variants. gdb_test "print locst.memberi" " = <unavailable>"
test_register_unavailable "\$$spreg" gdb_test "print locst.memberf" " = <unavailable>"
test_register_unavailable "\$sp" gdb_test "print locst.memberd" " = <unavailable>"
# Test reading uncollected pseudo-registers. The set of which gdb_test "print locar\[0\]" " = <unavailable>"
# depends on target. gdb_test "print locar\[1\]" " = <unavailable>"
if [is_amd64_regs_target] { gdb_test "print locar\[2\]" " = <unavailable>"
# Check the raw register first. gdb_test "print locar\[3\]" " = <unavailable>"
test_register_unavailable "\$rax"
test_register_unavailable "\$eax" # Test "info locals"
test_register_unavailable "\$ax" set r ""
} elseif [is_x86_like_target] { set r "${r}locf = <unavailable>${cr}"
# Check the raw register first. set r "${r}locd = <unavailable>${cr}"
test_register_unavailable "\$eax" set r "${r}locst = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}"
test_register_unavailable "\$ax" set r "${r}locar = {<unavailable>, <unavailable>, <unavailable>, <unavailable>}${cr}"
set r "${r}i = <unavailable>${cr}"
if { $func == "local_test_func" } {
set r "${r}locdefst = {<No data fields>}${cr}"
}
set r "${r}locc = <unavailable>${cr}"
set r "${r}loci = <unavailable>${cr}"
gdb_test "info locals" "$r" "info locals"
test_maybe_regvar_display "loci"
gdb_test "tfind none" \
"#0 end .*" \
"cease trace debugging"
} }
}
# GDBserver always provides the PC value of regular tracepoint proc gdb_unavailable_registers_test { } {
# hits, since it's the same as the tracepoint's address. with_test_prefix "unavailable registers" {
test_register "\$$pcreg" global gdb_prompt
test_register "\$pc" global spreg
global pcreg
gdb_test "info registers" \ prepare_for_trace_test
"\\*value not available\\*.*\\*value not available\\*" \
"info registers, multiple registers not available"
gdb_test "info registers \$$spreg" \ # We'll simply re-use the globals_test_function for this test
"\\*value not available\\*" \ gdb_test "trace globals_test_func" \
"info registers \$$spreg reports not available" "Tracepoint \[0-9\]+ at .*" \
"set tracepoint"
gdb_test "tfind none" "#0 end .*" "cease trace debugging" # Collect nothing.
}}
# Begin the test.
run_trace_experiment globals_test_func
# On some archs, the $sp/$pc are a real raw registers. On others,
# like x86, they're user registers. Test both variants.
test_register_unavailable "\$$spreg"
test_register_unavailable "\$sp"
# Test reading uncollected pseudo-registers. The set of which
# depends on target.
if [is_amd64_regs_target] {
# Check the raw register first.
test_register_unavailable "\$rax"
test_register_unavailable "\$eax"
test_register_unavailable "\$ax"
} elseif [is_x86_like_target] {
# Check the raw register first.
test_register_unavailable "\$eax"
test_register_unavailable "\$ax"
}
# GDBserver always provides the PC value of regular tracepoint
# hits, since it's the same as the tracepoint's address.
test_register "\$$pcreg"
test_register "\$pc"
gdb_test "info registers" \
"\\*value not available\\*.*\\*value not available\\*" \
"info registers, multiple registers not available"
gdb_test "info registers \$$spreg" \
"\\*value not available\\*" \
"info registers \$$spreg reports not available"
gdb_test "tfind none" "#0 end .*" "cease trace debugging"
}
}
proc gdb_unavailable_floats { } { proc gdb_unavailable_floats { } {
global gdb_prompt global gdb_prompt
@ -335,244 +341,246 @@ proc gdb_unavailable_floats { } {
} }
} }
proc gdb_collect_globals_test { } { with_test_prefix "collect globals" { proc gdb_collect_globals_test { } {
global ws with_test_prefix "collect globals" {
global cr global ws
global gdb_prompt global cr
global hex global gdb_prompt
global hex
prepare_for_trace_test prepare_for_trace_test
set testline [gdb_get_line_number "set globals_test_func tracepoint here"] set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
gdb_test "trace $testline" \ gdb_test "trace $testline" \
"Tracepoint \[0-9\]+ at .*" \ "Tracepoint \[0-9\]+ at .*" \
"set tracepoint" "set tracepoint"
# We collect the initial sizeof(pointer) bytes of derived_partial # We collect the initial sizeof(pointer) bytes of derived_partial
# in an attempt of collecting the vptr. Not portable, but should # in an attempt of collecting the vptr. Not portable, but should
# work everywhere we need to care. # work everywhere we need to care.
gdb_trace_setactions "define actions" \ gdb_trace_setactions "define actions" \
"" \ "" \
"collect struct_b.struct_a.array\[2\]" "^$" \ "collect struct_b.struct_a.array\[2\]" "^$" \
"collect struct_b.struct_a.array\[100\]" "^$" \ "collect struct_b.struct_a.array\[100\]" "^$" \
\ \
"collect a" "^$" \ "collect a" "^$" \
"collect c" "^$" \ "collect c" "^$" \
\ \
"collect tarray\[0\].a" "^$" \ "collect tarray\[0\].a" "^$" \
"collect tarray\[1\].a" "^$" \ "collect tarray\[1\].a" "^$" \
"collect tarray\[3\].a" "^$" \ "collect tarray\[3\].a" "^$" \
"collect tarray\[3\].b" "^$" \ "collect tarray\[3\].b" "^$" \
"collect tarray\[4\].b" "^$" \ "collect tarray\[4\].b" "^$" \
"collect tarray\[5\].b" "^$" \ "collect tarray\[5\].b" "^$" \
\ \
"collect g_string_p" "^$" \ "collect g_string_p" "^$" \
"collect g_string_partial\[1\]" "^$" \ "collect g_string_partial\[1\]" "^$" \
"collect g_string_partial\[2\]" "^$" \ "collect g_string_partial\[2\]" "^$" \
\ \
"collect g_structref_p" "^$" \ "collect g_structref_p" "^$" \
\ \
"collect *((char *)&derived_partial)@sizeof\(void *\)" "^$" \ "collect *((char *)&derived_partial)@sizeof\(void *\)" "^$" \
"collect derived_whole" "^$" \ "collect derived_whole" "^$" \
\ \
"collect virtual_partial.z" "^$" "collect virtual_partial.z" "^$"
# Begin the test. # Begin the test.
run_trace_experiment globals_test_func run_trace_experiment globals_test_func
gdb_test "print globalc" " = <unavailable>" gdb_test "print globalc" " = <unavailable>"
gdb_test "print globali" " = <unavailable>" gdb_test "print globali" " = <unavailable>"
gdb_test "print globalf" " = <unavailable>" gdb_test "print globalf" " = <unavailable>"
gdb_test "print globald" " = <unavailable>" gdb_test "print globald" " = <unavailable>"
gdb_test "print globalstruct.memberc" " = <unavailable>" gdb_test "print globalstruct.memberc" " = <unavailable>"
gdb_test "print globalstruct.memberi" " = <unavailable>" gdb_test "print globalstruct.memberi" " = <unavailable>"
gdb_test "print globalstruct.memberf" " = <unavailable>" gdb_test "print globalstruct.memberf" " = <unavailable>"
gdb_test "print globalstruct.memberd" " = <unavailable>" gdb_test "print globalstruct.memberd" " = <unavailable>"
gdb_test "print globalstruct" \ gdb_test "print globalstruct" \
" = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}" " = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}"
gdb_test "print globalp == &globalstruct" \ gdb_test "print globalp == &globalstruct" \
"value is not available" \ "value is not available" \
"can't compare using non collected global pointer" "can't compare using non collected global pointer"
gdb_test "print globalarr\[1\]" " = <unavailable>" gdb_test "print globalarr\[1\]" " = <unavailable>"
gdb_test "print globalarr\[2\]" " = <unavailable>" gdb_test "print globalarr\[2\]" " = <unavailable>"
gdb_test "print globalarr\[3\]" " = <unavailable>" gdb_test "print globalarr\[3\]" " = <unavailable>"
gdb_test "print struct_b" \ gdb_test "print struct_b" \
" = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, -1431655766, <unavailable> <repeats 97 times>, -1431655766, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}" " = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, -1431655766, <unavailable> <repeats 97 times>, -1431655766, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}"
gdb_test "print /x struct_b" \ gdb_test "print /x struct_b" \
" = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}" " = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}"
gdb_test "print /x struct_b.struct_a" \ gdb_test "print /x struct_b.struct_a" \
" = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}" " = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
gdb_test "print /x struct_b.struct_a.array" \ gdb_test "print /x struct_b.struct_a.array" \
" = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}" " = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>" gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa" gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
# Check the target doesn't overcollect. GDB used to merge memory # Check the target doesn't overcollect. GDB used to merge memory
# ranges to collect if they were close enough (collecting the hole # ranges to collect if they were close enough (collecting the hole
# as well), but does not do that anymore. It's plausible that a # as well), but does not do that anymore. It's plausible that a
# target may do this on its end, but as of this writing, no known # target may do this on its end, but as of this writing, no known
# target does it. # target does it.
gdb_test "print {a, b, c}" \ gdb_test "print {a, b, c}" \
" = \\{1, <unavailable>, 3\\}" \ " = \\{1, <unavailable>, 3\\}" \
"No overcollect of almost but not quite adjacent memory ranges" "No overcollect of almost but not quite adjacent memory ranges"
# Check <unavailable> isn't confused with 0 in array element repetitions # Check <unavailable> isn't confused with 0 in array element repetitions
gdb_test_no_output "set print repeat 1" gdb_test_no_output "set print repeat 1"
gdb_test "print /x tarray" \ gdb_test "print /x tarray" \
" = \{\{a = 0x0, b = <unavailable>\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\}, \{a = 0x0, b = 0x0\}, \{a = <unavailable>, b = 0x0\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\} <repeats 2 times>\}" \ " = \{\{a = 0x0, b = <unavailable>\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\}, \{a = 0x0, b = 0x0\}, \{a = <unavailable>, b = 0x0\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\} <repeats 2 times>\}" \
"<unavailable> is not the same as 0 in array element repetitions" "<unavailable> is not the same as 0 in array element repetitions"
gdb_test_no_output "set print repeat 10" gdb_test_no_output "set print repeat 10"
# Check that value repeat handles unavailable-ness. # Check that value repeat handles unavailable-ness.
gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}" gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}"
# Static fields # Static fields
gdb_test "print struct_b.static_struct_a" \ gdb_test "print struct_b.static_struct_a" \
" = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}" " = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
# Bitfields # Bitfields
gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>" gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
# References # References
gdb_test "print g_int" " = <unavailable>" gdb_test "print g_int" " = <unavailable>"
gdb_test "print g_ref" \ gdb_test "print g_ref" \
"\\(int &\\) @$hex: <unavailable>" \ "\\(int &\\) @$hex: <unavailable>" \
"global reference shows address but not value" "global reference shows address but not value"
gdb_test "print *&g_ref" \ gdb_test "print *&g_ref" \
"\\$\[0-9\]+ = <unavailable>$cr" \ "\\$\[0-9\]+ = <unavailable>$cr" \
"referenced integer was not collected (taking address of reference)" "referenced integer was not collected (taking address of reference)"
gdb_test "print *g_structref_p" \ gdb_test "print *g_structref_p" \
" = {d = <unavailable>, ref = <unavailable>}" " = {d = <unavailable>, ref = <unavailable>}"
# Strings # Strings
# Const string is always available, even when not collected. # Const string is always available, even when not collected.
gdb_test "print g_const_string" \ gdb_test "print g_const_string" \
" = \"hello world\"$cr" \ " = \"hello world\"$cr" \
"non collected const string is still printable" "non collected const string is still printable"
gdb_test "print g_string_p" \ gdb_test "print g_string_p" \
" = $hex <g_const_string> \"hello world\"" \ " = $hex <g_const_string> \"hello world\"" \
"printing constant string through collected pointer" "printing constant string through collected pointer"
gdb_test "print g_string_unavail" \ gdb_test "print g_string_unavail" \
" = \{<unavailable> <repeats 12 times>\}" \ " = \{<unavailable> <repeats 12 times>\}" \
"printing non collected string" "printing non collected string"
# Incomplete strings print as an array. # Incomplete strings print as an array.
gdb_test "print g_string_partial" \ gdb_test "print g_string_partial" \
"\\$\[0-9\]+ = \{<unavailable>, 101 'e', 108 'l', <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>\}" \ "\\$\[0-9\]+ = \{<unavailable>, 101 'e', 108 'l', <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>\}" \
"printing partially collected string" "printing partially collected string"
# It is important for this test that the last examined value is # It is important for this test that the last examined value is
# <unavailable>, to exercise the case of the $__ convenience # <unavailable>, to exercise the case of the $__ convenience
# variable being set to <unavailable> without error. # variable being set to <unavailable> without error.
set msg "examining partially collected object" set msg "examining partially collected object"
gdb_test_multiple "x /10x &struct_b" "$msg" { gdb_test_multiple "x /10x &struct_b" "$msg" {
-re "$hex <struct_b>:${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>$cr$hex <struct_b\\+16>:${ws}<unavailable>${ws}<unavailable>${ws}0xaaaaaaaa${ws}<unavailable>$cr$hex <struct_b\\+32>:${ws}<unavailable>${ws}<unavailable>$cr$gdb_prompt $" { -re "$hex <struct_b>:${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>$cr$hex <struct_b\\+16>:${ws}<unavailable>${ws}<unavailable>${ws}0xaaaaaaaa${ws}<unavailable>$cr$hex <struct_b\\+32>:${ws}<unavailable>${ws}<unavailable>$cr$gdb_prompt $" {
pass "$msg" pass "$msg"
}
-re "value is not available" {
fail "$msg"
}
} }
-re "value is not available" {
fail "$msg" gdb_test "p \$__" " = <unavailable>" "last examined value was <unavailable>"
# This tests that building the array does not require accessing
# g_int's contents.
gdb_test "print { 1, g_int, 3 }" \
" = \\{1, <unavailable>, 3\\}" \
"build array from unavailable value"
# Note, depends on previous test.
gdb_test "print \$\[1\]" \
" = <unavailable>" \
"subscript a non-memory rvalue array, accessing an unvailable element"
# Access a field of a non-lazy value, making sure the
# unavailable-ness is propagated. History values are easy
# non-lazy values, so use those. The first test just sets up for
# the second.
gdb_test "print g_smallstruct" " = \\{member = <unavailable>\\}"
gdb_test "print \$.member" " = <unavailable>"
# Cast to baseclass, checking the unavailable-ness is propagated.
gdb_test "print (small_struct) g_smallstruct_b" " = \\{member = <unavailable>\\}"
# Same cast, but starting from a non-lazy, value.
gdb_test "print g_smallstruct_b" " = \\{<small_struct> = \\{member = <unavailable>\\}, <No data fields>\\}"
gdb_test "print (small_struct) \$" " = \\{member = <unavailable>\\}"
gdb_test_no_output "set print object on"
with_test_prefix "print object on" {
# With print object on, printing a pointer may need to fetch
# the pointed-to object, to check its run-time type. Make
# sure that fails gracefully and transparently when the
# pointer itself is unavailable.
gdb_test "print virtualp" " = \\(Virtual \\*\\) <unavailable>"
# no vtable pointer available
gdb_test "print derived_unavail" \
" = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <unavailable>}"
# vtable pointer available, but nothing else
gdb_test "print derived_partial" \
" = \\(Derived\\) {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
# whole object available
gdb_test "print derived_whole" \
" = \\(Derived\\) {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
} }
gdb_test_no_output "set print object off"
with_test_prefix "print object off" {
gdb_test "print virtualp" " = \\(Virtual \\*\\) <unavailable>"
# no vtable pointer available
gdb_test "print derived_unavail" \
" = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <unavailable>}"
# vtable pointer available, but nothing else
gdb_test "print derived_partial" \
" = {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
# whole object available
gdb_test "print derived_whole" \
" = {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
}
# An instance of a virtual class where we collected everything but
# the vptr.
gdb_test "print virtual_partial" \
" = {_vptr.Virtual = <unavailable>, z = 0}"
gdb_test "tfind none" \
"#0 end .*" \
"cease trace debugging"
} }
}
gdb_test "p \$__" " = <unavailable>" "last examined value was <unavailable>"
# This tests that building the array does not require accessing
# g_int's contents.
gdb_test "print { 1, g_int, 3 }" \
" = \\{1, <unavailable>, 3\\}" \
"build array from unavailable value"
# Note, depends on previous test.
gdb_test "print \$\[1\]" \
" = <unavailable>" \
"subscript a non-memory rvalue array, accessing an unvailable element"
# Access a field of a non-lazy value, making sure the
# unavailable-ness is propagated. History values are easy
# non-lazy values, so use those. The first test just sets up for
# the second.
gdb_test "print g_smallstruct" " = \\{member = <unavailable>\\}"
gdb_test "print \$.member" " = <unavailable>"
# Cast to baseclass, checking the unavailable-ness is propagated.
gdb_test "print (small_struct) g_smallstruct_b" " = \\{member = <unavailable>\\}"
# Same cast, but starting from a non-lazy, value.
gdb_test "print g_smallstruct_b" " = \\{<small_struct> = \\{member = <unavailable>\\}, <No data fields>\\}"
gdb_test "print (small_struct) \$" " = \\{member = <unavailable>\\}"
gdb_test_no_output "set print object on"
with_test_prefix "print object on" {
# With print object on, printing a pointer may need to fetch
# the pointed-to object, to check its run-time type. Make
# sure that fails gracefully and transparently when the
# pointer itself is unavailable.
gdb_test "print virtualp" " = \\(Virtual \\*\\) <unavailable>"
# no vtable pointer available
gdb_test "print derived_unavail" \
" = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <unavailable>}"
# vtable pointer available, but nothing else
gdb_test "print derived_partial" \
" = \\(Derived\\) {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
# whole object available
gdb_test "print derived_whole" \
" = \\(Derived\\) {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
}
gdb_test_no_output "set print object off"
with_test_prefix "print object off" {
gdb_test "print virtualp" " = \\(Virtual \\*\\) <unavailable>"
# no vtable pointer available
gdb_test "print derived_unavail" \
" = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <unavailable>}"
# vtable pointer available, but nothing else
gdb_test "print derived_partial" \
" = {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
# whole object available
gdb_test "print derived_whole" \
" = {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
}
# An instance of a virtual class where we collected everything but
# the vptr.
gdb_test "print virtual_partial" \
" = {_vptr.Virtual = <unavailable>, z = 0}"
gdb_test "tfind none" \
"#0 end .*" \
"cease trace debugging"
}}
proc gdb_trace_collection_test {} { proc gdb_trace_collection_test {} {
gdb_collect_globals_test gdb_collect_globals_test