summaryrefslogtreecommitdiff
path: root/gdb/testsuite/gdb.mi/mi-nonstop.exp
blob: e576006eda7386315057293f8db1b4e5fddc9391 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
# Copyright 2002-2013 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


if { ![support_displaced_stepping] } { 
    unsupported "displaced stepping"
    return -1
}

load_lib mi-support.exp
set MIFLAGS "-i=mi"

gdb_exit
if {[mi_gdb_start]} {
    continue
}

proc mi_nonstop_resume { command test } {
    if { [mi_send_resuming_command $command $test] != 0 } {
	# If a resume fails, assume non-stop is broken or unsupported
	# for this target.  We have logged a FAIL or UNSUPPORTED; skip
	# the remaining tests to limit timeouts.
	return -code continue
    }
}

#
# Start here
#
standard_testfile non-stop.c

set options [list debug]
if {[gdb_compile_pthreads "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } {
    return -1
}

mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load $binfile

mi_gdb_test "-gdb-set non-stop 1" ".*"
mi_gdb_test "-gdb-set target-async 1" ".*"
mi_detect_async

if { [mi_run_to_main] < 0 } {
    continue
}

mi_create_breakpoint break_at_me 2 keep break_at_me .* .* .* "breakpoint at marker"

mi_nonstop_resume "exec-continue" "resume 1"
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i0 stop"
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w1,i0 stop"

mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 1"

mi_gdb_test "-thread-select 2" "\\^done.*" "select thread 2"
mi_create_varobj I_W0 "i" "create varobj in first thread"
mi_gdb_test "-thread-select 3" "\\^done.*" "select thread 3"
mi_create_varobj I_W1 "i" "create varobj in second thread" 

mi_nonstop_resume "exec-continue --thread 2" "resume 1"
mi_check_thread_states {"running" "running" "stopped"} "thread state, resume 1"
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i1 stop"
mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 2"

mi_nonstop_resume "exec-continue --thread 3" "resume 2"
mi_check_thread_states {"running" "stopped" "running"} "thread state, resume 2"
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w1,i1 stop"
mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 3"

mi_varobj_update * {I_W1 I_W0} "update varobj, 1"
mi_check_varobj_value I_W0 1 "check varobj, w0, 1"
mi_check_varobj_value I_W1 1 "check varobj, w1, 1"

mi_gdb_test "-exec-interrupt --thread 1" "\\^done" "interrupted"
mi_expect_interrupt "got interrupt"

# The interrupt command sends SIGINT to the target, and therefore the
# thread might not be stopped immediately when we return from the target.
# So, wait a bit
sleep 1
mi_check_thread_states {"stopped" "stopped" "stopped"} "thread state, stop 4"

mi_gdb_test "-exec-continue --all" ".*\\*running,thread-id=\"3\"\r\n\\*running,thread-id=\"2\"\r\n\\*running,thread-id=\"1\"" \
    "resume all"

mi_expect_stop "breakpoint-hit" "break_at_me" "\[^\n\]*" "non-stop.c" "\[0-9\]*" {"" "disp=\"keep\""} "w0,i2 stop"
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w1,i2 stop"

# At this point, thread 1 (main) is running, and worker threads are stopped.
# Check that we can modify breakpoint condition, even when operating on a 
# running thread.
mi_gdb_test "-break-condition --thread 1 2 id==1" "\\^done" "set condition, 1"

mi_nonstop_resume "exec-continue --thread 2" "resume 2"
mi_nonstop_resume "exec-continue --thread 3" "resume 3"

sleep 2
mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i3 stop"
mi_check_thread_states {"running" "running" "stopped"} "thread state, stop on cond breakpoint"

# Check that when we update all varobj, we don't get no error about varobj
# bound to running thread.
mi_varobj_update * {I_W1} "update varobj, 2"
mi_check_varobj_value I_W1 3 "check varobj, w1, 1"


# Check that stack commands are allowed on a stopped thread, even if some other threads
# are running, and produce something sane.  Also check we check error on running thread.
mi_gdb_test "-stack-list-frames --thread 2" "\\^error,msg=\".*\"" "stacktrace of running thread"
mi_gdb_test "-stack-list-frames --thread 3" \
    "\\^done,stack=\\\[frame={level=\"0\",addr=\".*\",func=\"break_at_me\".*" \
    "stacktrace of stopped thread"

# verify that after thread exit, the thread is reported as exited in -thread-info, and
# we can still interact with other threads.
mi_gdb_test "-thread-select 2" "\\^done.*" "select first worker thread"
# Since thread 2 is running, we need to set variable via another thread.
mi_gdb_test "-gdb-set --thread 3 variable exit_first_thread=1" ".*\\^done" "ask the second thread to exit"

set test "wait for thread exit"
if { [is_remote target] } {
    # The remote protocol doesn't have support for thread exit
    # notifications.
    unsupported $test
} else {
    gdb_expect {
	-re ".*=thread-exited,id=\"2\",group-id=\"i\[0-9\]+\"\r\n$" {
	    pass $test
	}
	timeout {
	    fail "$test (timeout)"
	}
    }
}

# See that we can still poke other threads.
mi_gdb_test "-stack-list-frames --thread 3" \
    "\\^done,stack=\\\[frame={level=\"0\",addr=\".*\",func=\"break_at_me\".*" \
    "stacktrace of stopped thread"

mi_gdb_exit