Added
Link Here
|
1 |
# Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, |
2 |
# 2000, 2002, 2003, 2004 |
3 |
# Free Software Foundation, Inc. |
4 |
|
5 |
# This program is free software; you can redistribute it and/or modify |
6 |
# it under the terms of the GNU General Public License as published by |
7 |
# the Free Software Foundation; either version 2 of the License, or |
8 |
# (at your option) any later version. |
9 |
# |
10 |
# This program is distributed in the hope that it will be useful, |
11 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
13 |
# GNU General Public License for more details. |
14 |
# |
15 |
# You should have received a copy of the GNU General Public License |
16 |
# along with this program; if not, write to the Free Software |
17 |
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
18 |
|
19 |
# Please email any bugs, comments, and/or additions to this file to: |
20 |
# bug-gdb@prep.ai.mit.edu |
21 |
|
22 |
# This file was written by Rob Savoye. (rob@cygnus.com) |
23 |
|
24 |
# Test the same stuff but with PIE executables |
25 |
|
26 |
if $tracelevel then { |
27 |
strace $tracelevel |
28 |
} |
29 |
|
30 |
|
31 |
# |
32 |
# test running programs |
33 |
# |
34 |
set prms_id 0 |
35 |
set bug_id 0 |
36 |
|
37 |
set testfile "break" |
38 |
set srcfile ${testfile}.c |
39 |
set srcfile1 ${testfile}1.c |
40 |
set binfile ${objdir}/${subdir}/${testfile} |
41 |
|
42 |
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}0.o" object {debug "additional_flags=-w -fpie -pie"}] != "" } { |
43 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
44 |
} |
45 |
|
46 |
if { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}1.o" object {debug "additional_flags=-w -fpie -pie"}] != "" } { |
47 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
48 |
} |
49 |
|
50 |
if { [gdb_compile "${binfile}0.o ${binfile}1.o" "${binfile}" executable {debug "additional_flags=-w -fpie -pie"}] != "" } { |
51 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
52 |
} |
53 |
|
54 |
if [get_compiler_info ${binfile}] { |
55 |
return -1 |
56 |
} |
57 |
|
58 |
gdb_exit |
59 |
gdb_start |
60 |
gdb_reinitialize_dir $srcdir/$subdir |
61 |
gdb_load ${binfile} |
62 |
|
63 |
if [target_info exists gdb_stub] { |
64 |
gdb_step_for_stub; |
65 |
} |
66 |
# |
67 |
# test simple breakpoint setting commands |
68 |
# |
69 |
|
70 |
# Test deleting all breakpoints when there are none installed, |
71 |
# GDB should not prompt for confirmation. |
72 |
# Note that gdb-init.exp provides a "delete_breakpoints" proc |
73 |
# for general use elsewhere. |
74 |
|
75 |
send_gdb "delete breakpoints\n" |
76 |
gdb_expect { |
77 |
-re "Delete all breakpoints.*$" { |
78 |
send_gdb "y\n" |
79 |
gdb_expect { |
80 |
-re "$gdb_prompt $" { |
81 |
fail "Delete all breakpoints when none (unexpected prompt)" |
82 |
} |
83 |
timeout { fail "Delete all breakpoints when none (timeout after unexpected prompt)" } |
84 |
} |
85 |
} |
86 |
-re ".*$gdb_prompt $" { pass "Delete all breakpoints when none" } |
87 |
timeout { fail "Delete all breakpoints when none (timeout)" } |
88 |
} |
89 |
|
90 |
# |
91 |
# test break at function |
92 |
# |
93 |
gdb_test "break main" \ |
94 |
"Breakpoint.*at.* file .*$srcfile, line.*" \ |
95 |
"breakpoint function" |
96 |
|
97 |
# |
98 |
# test break at quoted function |
99 |
# |
100 |
gdb_test "break \"marker2\"" \ |
101 |
"Breakpoint.*at.* file .*$srcfile1, line.*" \ |
102 |
"breakpoint quoted function" |
103 |
|
104 |
# |
105 |
# test break at function in file |
106 |
# |
107 |
gdb_test "break $srcfile:factorial" \ |
108 |
"Breakpoint.*at.* file .*$srcfile, line.*" \ |
109 |
"breakpoint function in file" |
110 |
|
111 |
set bp_location1 [gdb_get_line_number "set breakpoint 1 here"] |
112 |
|
113 |
# |
114 |
# test break at line number |
115 |
# |
116 |
# Note that the default source file is the last one whose source text |
117 |
# was printed. For native debugging, before we've executed the |
118 |
# program, this is the file containing main, but for remote debugging, |
119 |
# it's wherever the processor was stopped when we connected to the |
120 |
# board. So, to be sure, we do a list command. |
121 |
# |
122 |
gdb_test "list main" \ |
123 |
".*main \\(argc, argv, envp\\).*" \ |
124 |
"use `list' to establish default source file" |
125 |
gdb_test "break $bp_location1" \ |
126 |
"Breakpoint.*at.* file .*$srcfile, line $bp_location1\\." \ |
127 |
"breakpoint line number" |
128 |
|
129 |
# |
130 |
# test duplicate breakpoint |
131 |
# |
132 |
gdb_test "break $bp_location1" \ |
133 |
"Note: breakpoint \[0-9\]+ also set at pc.*Breakpoint \[0-9\]+ at.* file .*$srcfile, line $bp_location1\\." \ |
134 |
"breakpoint duplicate" |
135 |
|
136 |
set bp_location2 [gdb_get_line_number "set breakpoint 2 here"] |
137 |
|
138 |
# |
139 |
# test break at line number in file |
140 |
# |
141 |
gdb_test "break $srcfile:$bp_location2" \ |
142 |
"Breakpoint.*at.* file .*$srcfile, line $bp_location2\\." \ |
143 |
"breakpoint line number in file" |
144 |
|
145 |
set bp_location3 [gdb_get_line_number "set breakpoint 3 here"] |
146 |
set bp_location4 [gdb_get_line_number "set breakpoint 4 here"] |
147 |
|
148 |
# |
149 |
# Test putting a break at the start of a multi-line if conditional. |
150 |
# Verify the breakpoint was put at the start of the conditional. |
151 |
# |
152 |
gdb_test "break multi_line_if_conditional" \ |
153 |
"Breakpoint.*at.* file .*$srcfile, line $bp_location3\\." \ |
154 |
"breakpoint at start of multi line if conditional" |
155 |
|
156 |
gdb_test "break multi_line_while_conditional" \ |
157 |
"Breakpoint.*at.* file .*$srcfile, line $bp_location4\\." \ |
158 |
"breakpoint at start of multi line while conditional" |
159 |
|
160 |
set bp_location5 [gdb_get_line_number "set breakpoint 5 here"] |
161 |
set bp_location6 [gdb_get_line_number "set breakpoint 6 here"] |
162 |
|
163 |
# |
164 |
# check to see what breakpoints are set |
165 |
# |
166 |
if [target_info exists gdb_stub] { |
167 |
set main_line $bp_location5 |
168 |
} else { |
169 |
set main_line $bp_location6 |
170 |
} |
171 |
|
172 |
if {$hp_aCC_compiler} { |
173 |
set proto "\\(int\\)" |
174 |
} else { |
175 |
set proto "" |
176 |
} |
177 |
|
178 |
set bp_location7 [gdb_get_line_number "set breakpoint 7 here"] |
179 |
set bp_location8 [gdb_get_line_number "set breakpoint 8 here" $srcfile1] |
180 |
set bp_location9 [gdb_get_line_number "set breakpoint 9 here" $srcfile1] |
181 |
|
182 |
gdb_test "info break" \ |
183 |
"Num Type\[ \]+Disp Enb Address\[ \]+What.* |
184 |
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$main_line.* |
185 |
\[0-9\]+\[\t \]+breakpoint keep y.* in marker2 at .*$srcfile1:($bp_location8|$bp_location9).* |
186 |
\[0-9\]+\[\t \]+breakpoint keep y.* in factorial$proto at .*$srcfile:$bp_location7.* |
187 |
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$bp_location1.* |
188 |
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$bp_location1.* |
189 |
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$bp_location2.* |
190 |
\[0-9\]+\[\t \]+breakpoint keep y.* in multi_line_if_conditional at .*$srcfile:$bp_location3.* |
191 |
\[0-9\]+\[\t \]+breakpoint keep y.* in multi_line_while_conditional at .*$srcfile:$bp_location4" \ |
192 |
"breakpoint info" |
193 |
|
194 |
# FIXME: The rest of this test doesn't work with anything that can't |
195 |
# handle arguments. |
196 |
# Huh? There doesn't *appear* to be anything that passes arguments |
197 |
# below. |
198 |
if [istarget "mips-idt-*"] then { |
199 |
return |
200 |
} |
201 |
|
202 |
# |
203 |
# run until the breakpoint at main is hit. For non-stubs-using targets. |
204 |
# |
205 |
if ![target_info exists use_gdb_stub] { |
206 |
if [istarget "*-*-vxworks*"] then { |
207 |
send_gdb "run vxmain \"2\"\n" |
208 |
set timeout 120 |
209 |
verbose "Timeout is now $timeout seconds" 2 |
210 |
} else { |
211 |
send_gdb "run\n" |
212 |
} |
213 |
gdb_expect { |
214 |
-re "The program .* has been started already.*y or n. $" { |
215 |
send_gdb "y\n" |
216 |
exp_continue |
217 |
} |
218 |
-re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\ |
219 |
{ pass "run until function breakpoint" } |
220 |
-re ".*$gdb_prompt $" { fail "run until function breakpoint" } |
221 |
timeout { fail "run until function breakpoint (timeout)" } |
222 |
} |
223 |
} else { |
224 |
if ![target_info exists gdb_stub] { |
225 |
gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue" |
226 |
} |
227 |
} |
228 |
|
229 |
# |
230 |
# run until the breakpoint at a line number |
231 |
# |
232 |
gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location1.*$bp_location1\[\t \]+printf.*factorial.*" \ |
233 |
"run until breakpoint set at a line number" |
234 |
|
235 |
# |
236 |
# Run until the breakpoint set in a function in a file |
237 |
# |
238 |
for {set i 6} {$i >= 1} {incr i -1} { |
239 |
gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, factorial \\(value=$i\\) at .*$srcfile:$bp_location7.*$bp_location7\[\t \]+.*if .value > 1. \{.*" \ |
240 |
"run until file:function($i) breakpoint" |
241 |
} |
242 |
|
243 |
# |
244 |
# Run until the breakpoint set at a quoted function |
245 |
# |
246 |
gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, (0x\[0-9a-f\]+ in )?marker2 \\(a=43\\) at .*$srcfile1:($bp_location8|$bp_location9).*" \ |
247 |
"run until quoted breakpoint" |
248 |
# |
249 |
# run until the file:function breakpoint at a line number in a file |
250 |
# |
251 |
gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location2.*$bp_location2\[\t \]+argc = \\(argc == 12345\\);.*" \ |
252 |
"run until file:linenum breakpoint" |
253 |
|
254 |
# Test break at offset +1 |
255 |
set bp_location10 [gdb_get_line_number "set breakpoint 10 here"] |
256 |
|
257 |
gdb_test "break +1" \ |
258 |
"Breakpoint.*at.* file .*$srcfile, line $bp_location10\\." \ |
259 |
"breakpoint offset +1" |
260 |
|
261 |
# Check to see if breakpoint is hit when stepped onto |
262 |
|
263 |
gdb_test "step" \ |
264 |
".*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location10.*$bp_location10\[\t \]+return argc;.*breakpoint 10 here.*" \ |
265 |
"step onto breakpoint" |
266 |
|
267 |
# |
268 |
# delete all breakpoints so we can start over, course this can be a test too |
269 |
# |
270 |
delete_breakpoints |
271 |
|
272 |
# |
273 |
# test temporary breakpoint at function |
274 |
# |
275 |
|
276 |
gdb_test "tbreak main" "Breakpoint.*at.* file .*$srcfile, line.*" "Temporary breakpoint function" |
277 |
|
278 |
# |
279 |
# test break at function in file |
280 |
# |
281 |
|
282 |
gdb_test "tbreak $srcfile:factorial" "Breakpoint.*at.* file .*$srcfile, line.*" \ |
283 |
"Temporary breakpoint function in file" |
284 |
|
285 |
# |
286 |
# test break at line number |
287 |
# |
288 |
send_gdb "tbreak $bp_location1\n" |
289 |
gdb_expect { |
290 |
-re "Breakpoint.*at.* file .*$srcfile, line $bp_location1.*$gdb_prompt $" { pass "Temporary breakpoint line number #1" } |
291 |
-re ".*$gdb_prompt $" { pass "Temporary breakpoint line number #1" } |
292 |
timeout { fail "breakpoint line number #1 (timeout)" } |
293 |
} |
294 |
|
295 |
gdb_test "tbreak $bp_location6" "Breakpoint.*at.* file .*$srcfile, line $bp_location6.*" "Temporary breakpoint line number #2" |
296 |
|
297 |
# |
298 |
# test break at line number in file |
299 |
# |
300 |
send_gdb "tbreak $srcfile:$bp_location2\n" |
301 |
gdb_expect { |
302 |
-re "Breakpoint.*at.* file .*$srcfile, line $bp_location2.*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" } |
303 |
-re ".*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" } |
304 |
timeout { fail "Temporary breakpoint line number in file #1 (timeout)" } |
305 |
} |
306 |
|
307 |
set bp_location11 [gdb_get_line_number "set breakpoint 11 here"] |
308 |
gdb_test "tbreak $srcfile:$bp_location11" "Breakpoint.*at.* file .*$srcfile, line $bp_location11.*" "Temporary breakpoint line number in file #2" |
309 |
|
310 |
# |
311 |
# check to see what breakpoints are set (temporary this time) |
312 |
# |
313 |
gdb_test "info break" "Num Type.*Disp Enb Address.*What.*\[\r\n\] |
314 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$main_line.*\[\r\n\] |
315 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in factorial$proto at .*$srcfile:$bp_location7.*\[\r\n\] |
316 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$bp_location1.*\[\r\n\] |
317 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$bp_location6.*\[\r\n\] |
318 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$bp_location2.*\[\r\n\] |
319 |
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$bp_location11.*" \ |
320 |
"Temporary breakpoint info" |
321 |
|
322 |
|
323 |
#*********** |
324 |
|
325 |
# Verify that catchpoints for fork, vfork and exec don't trigger |
326 |
# inappropriately. (There are no calls to those system functions |
327 |
# in this test program.) |
328 |
# |
329 |
if ![runto_main] then { fail "break tests suppressed" } |
330 |
|
331 |
send_gdb "catch\n" |
332 |
gdb_expect { |
333 |
-re "Catch requires an event name.*$gdb_prompt $"\ |
334 |
{pass "catch requires an event name"} |
335 |
-re "$gdb_prompt $"\ |
336 |
{fail "catch requires an event name"} |
337 |
timeout {fail "(timeout) catch requires an event name"} |
338 |
} |
339 |
|
340 |
|
341 |
set name "set catch fork, never expected to trigger" |
342 |
send_gdb "catch fork\n" |
343 |
gdb_expect { |
344 |
-re "Catchpoint \[0-9\]* .fork..*$gdb_prompt $" |
345 |
{pass $name} |
346 |
-re "Catch of fork not yet implemented.*$gdb_prompt $" |
347 |
{pass $name} |
348 |
-re "$gdb_prompt $" |
349 |
{fail $name} |
350 |
timeout {fail "(timeout) $name"} |
351 |
} |
352 |
|
353 |
|
354 |
set name "set catch vfork, never expected to trigger" |
355 |
send_gdb "catch vfork\n" |
356 |
|
357 |
# If we are on HP-UX 10.20, we expect an error message to be |
358 |
# printed if we type "catch vfork" at the gdb gdb_prompt. This is |
359 |
# because on HP-UX 10.20, we cannot catch vfork events. |
360 |
|
361 |
if [istarget "hppa*-hp-hpux10.20"] then { |
362 |
gdb_expect { |
363 |
-re "Catch of vfork events not supported on HP-UX 10.20..*$gdb_prompt $" |
364 |
{pass $name} |
365 |
-re "$gdb_prompt $" |
366 |
{fail $name} |
367 |
timeout {fail "(timeout) $name"} |
368 |
} |
369 |
} else { |
370 |
gdb_expect { |
371 |
-re "Catchpoint \[0-9\]* .vfork..*$gdb_prompt $" |
372 |
{pass $name} |
373 |
-re "Catch of vfork not yet implemented.*$gdb_prompt $" |
374 |
{pass $name} |
375 |
-re "$gdb_prompt $" |
376 |
{fail $name} |
377 |
timeout {fail "(timeout) $name"} |
378 |
} |
379 |
} |
380 |
|
381 |
set name "set catch exec, never expected to trigger" |
382 |
send_gdb "catch exec\n" |
383 |
gdb_expect { |
384 |
-re "Catchpoint \[0-9\]* .exec..*$gdb_prompt $" |
385 |
{pass $name} |
386 |
-re "Catch of exec not yet implemented.*$gdb_prompt $" |
387 |
{pass $name} |
388 |
-re "$gdb_prompt $" {fail $name} |
389 |
timeout {fail "(timeout) $name"} |
390 |
} |
391 |
|
392 |
# Verify that GDB responds gracefully when asked to set a breakpoint |
393 |
# on a nonexistent source line. |
394 |
# |
395 |
send_gdb "break 999\n" |
396 |
gdb_expect { |
397 |
-re "No line 999 in file .*$gdb_prompt $"\ |
398 |
{pass "break on non-existent source line"} |
399 |
-re "$gdb_prompt $"\ |
400 |
{fail "break on non-existent source line"} |
401 |
timeout {fail "(timeout) break on non-existent source line"} |
402 |
} |
403 |
|
404 |
# Run to the desired default location. If not positioned here, the |
405 |
# tests below don't work. |
406 |
# |
407 |
gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" "until bp_location1" |
408 |
|
409 |
|
410 |
# Verify that GDB allows one to just say "break", which is treated |
411 |
# as the "default" breakpoint. Note that GDB gets cute when printing |
412 |
# the informational message about other breakpoints at the same |
413 |
# location. We'll hit that bird with this stone too. |
414 |
# |
415 |
send_gdb "break\n" |
416 |
gdb_expect { |
417 |
-re "Breakpoint \[0-9\]*.*$gdb_prompt $"\ |
418 |
{pass "break on default location, 1st time"} |
419 |
-re "$gdb_prompt $"\ |
420 |
{fail "break on default location, 1st time"} |
421 |
timeout {fail "(timeout) break on default location, 1st time"} |
422 |
} |
423 |
|
424 |
send_gdb "break\n" |
425 |
gdb_expect { |
426 |
-re "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\ |
427 |
{pass "break on default location, 2nd time"} |
428 |
-re "$gdb_prompt $"\ |
429 |
{fail "break on default location, 2nd time"} |
430 |
timeout {fail "(timeout) break on default location, 2nd time"} |
431 |
} |
432 |
|
433 |
send_gdb "break\n" |
434 |
gdb_expect { |
435 |
-re "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\ |
436 |
{pass "break on default location, 3rd time"} |
437 |
-re "$gdb_prompt $"\ |
438 |
{fail "break on default location, 3rd time"} |
439 |
timeout {fail "(timeout) break on default location, 3rd time"} |
440 |
} |
441 |
|
442 |
send_gdb "break\n" |
443 |
gdb_expect { |
444 |
-re "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\ |
445 |
{pass "break on default location, 4th time"} |
446 |
-re "$gdb_prompt $"\ |
447 |
{fail "break on default location, 4th time"} |
448 |
timeout {fail "(timeout) break on default location, 4th time"} |
449 |
} |
450 |
|
451 |
# Verify that a "silent" breakpoint can be set, and that GDB is indeed |
452 |
# "silent" about its triggering. |
453 |
# |
454 |
if ![runto_main] then { fail "break tests suppressed" } |
455 |
|
456 |
send_gdb "break $bp_location1\n" |
457 |
gdb_expect { |
458 |
-re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $"\ |
459 |
{pass "set to-be-silent break bp_location1"} |
460 |
-re "$gdb_prompt $"\ |
461 |
{fail "set to-be-silent break bp_location1"} |
462 |
timeout {fail "(timeout) set to-be-silent break bp_location1"} |
463 |
} |
464 |
|
465 |
send_gdb "commands $expect_out(1,string)\n" |
466 |
send_gdb "silent\n" |
467 |
send_gdb "end\n" |
468 |
gdb_expect { |
469 |
-re ".*$gdb_prompt $"\ |
470 |
{pass "set silent break bp_location1"} |
471 |
timeout {fail "(timeout) set silent break bp_location1"} |
472 |
} |
473 |
|
474 |
send_gdb "info break $expect_out(1,string)\n" |
475 |
gdb_expect { |
476 |
-re "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*$gdb_prompt $"\ |
477 |
{pass "info silent break bp_location1"} |
478 |
-re "$gdb_prompt $"\ |
479 |
{fail "info silent break bp_location1"} |
480 |
timeout {fail "(timeout) info silent break bp_location1"} |
481 |
} |
482 |
send_gdb "continue\n" |
483 |
gdb_expect { |
484 |
-re "Continuing.\r\n$gdb_prompt $"\ |
485 |
{pass "hit silent break bp_location1"} |
486 |
-re "$gdb_prompt $"\ |
487 |
{fail "hit silent break bp_location1"} |
488 |
timeout {fail "(timeout) hit silent break bp_location1"} |
489 |
} |
490 |
send_gdb "bt\n" |
491 |
gdb_expect { |
492 |
-re "#0 main .* at .*:$bp_location1.*$gdb_prompt $"\ |
493 |
{pass "stopped for silent break bp_location1"} |
494 |
-re "$gdb_prompt $"\ |
495 |
{fail "stopped for silent break bp_location1"} |
496 |
timeout {fail "(timeout) stopped for silent break bp_location1"} |
497 |
} |
498 |
|
499 |
# Verify that GDB can at least parse a breakpoint with the |
500 |
# "thread" keyword. (We won't attempt to test here that a |
501 |
# thread-specific breakpoint really triggers appropriately. |
502 |
# The gdb.threads subdirectory contains tests for that.) |
503 |
# |
504 |
set bp_location12 [gdb_get_line_number "set breakpoint 12 here"] |
505 |
send_gdb "break $bp_location12 thread 999\n" |
506 |
gdb_expect { |
507 |
-re "Unknown thread 999.*$gdb_prompt $"\ |
508 |
{pass "thread-specific breakpoint on non-existent thread disallowed"} |
509 |
-re "$gdb_prompt $"\ |
510 |
{fail "thread-specific breakpoint on non-existent thread disallowed"} |
511 |
timeout {fail "(timeout) thread-specific breakpoint on non-existent thread disallowed"} |
512 |
} |
513 |
send_gdb "break $bp_location12 thread foo\n" |
514 |
gdb_expect { |
515 |
-re "Junk after thread keyword..*$gdb_prompt $"\ |
516 |
{pass "thread-specific breakpoint on bogus thread ID disallowed"} |
517 |
-re "$gdb_prompt $"\ |
518 |
{fail "thread-specific breakpoint on bogus thread ID disallowed"} |
519 |
timeout {fail "(timeout) thread-specific breakpoint on bogus thread ID disallowed"} |
520 |
} |
521 |
|
522 |
# Verify that GDB responds gracefully to a breakpoint command with |
523 |
# trailing garbage. |
524 |
# |
525 |
send_gdb "break $bp_location12 foo\n" |
526 |
gdb_expect { |
527 |
-re "Junk at end of arguments..*$gdb_prompt $"\ |
528 |
{pass "breakpoint with trailing garbage disallowed"} |
529 |
-re "$gdb_prompt $"\ |
530 |
{fail "breakpoint with trailing garbage disallowed"} |
531 |
timeout {fail "(timeout) breakpoint with trailing garbage disallowed"} |
532 |
} |
533 |
|
534 |
# Verify that GDB responds gracefully to a "clear" command that has |
535 |
# no matching breakpoint. (First, get us off the current source line, |
536 |
# which we know has a breakpoint.) |
537 |
# |
538 |
send_gdb "next\n" |
539 |
gdb_expect { |
540 |
-re ".*$gdb_prompt $"\ |
541 |
{pass "step over breakpoint"} |
542 |
timeout {fail "(timeout) step over breakpoint"} |
543 |
} |
544 |
send_gdb "clear 81\n" |
545 |
gdb_expect { |
546 |
-re "No breakpoint at 81..*$gdb_prompt $"\ |
547 |
{pass "clear line has no breakpoint disallowed"} |
548 |
-re "$gdb_prompt $"\ |
549 |
{fail "clear line has no breakpoint disallowed"} |
550 |
timeout {fail "(timeout) clear line has no breakpoint disallowed"} |
551 |
} |
552 |
send_gdb "clear\n" |
553 |
gdb_expect { |
554 |
-re "No breakpoint at this line..*$gdb_prompt $"\ |
555 |
{pass "clear current line has no breakpoint disallowed"} |
556 |
-re "$gdb_prompt $"\ |
557 |
{fail "clear current line has no breakpoint disallowed"} |
558 |
timeout {fail "(timeout) clear current line has no breakpoint disallowed"} |
559 |
} |
560 |
|
561 |
# Verify that we can set and clear multiple breakpoints. |
562 |
# |
563 |
# We don't test that it deletes the correct breakpoints. We do at |
564 |
# least test that it deletes more than one breakpoint. |
565 |
# |
566 |
gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #1" |
567 |
gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #2" |
568 |
gdb_test "clear marker3" {Deleted breakpoints [0-9]+ [0-9]+.*} |
569 |
|
570 |
# Verify that a breakpoint can be set via a convenience variable. |
571 |
# |
572 |
send_gdb "set \$foo=$bp_location11\n" |
573 |
gdb_expect { |
574 |
-re "$gdb_prompt $"\ |
575 |
{pass "set convenience variable \$foo to bp_location11"} |
576 |
timeout {fail "(timeout) set convenience variable \$foo to bp_location11"} |
577 |
} |
578 |
send_gdb "break \$foo\n" |
579 |
gdb_expect { |
580 |
-re "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*$gdb_prompt $"\ |
581 |
{pass "set breakpoint via convenience variable"} |
582 |
-re "$gdb_prompt $"\ |
583 |
{fail "set breakpoint via convenience variable"} |
584 |
timeout {fail "(timeout) set breakpoint via convenience variable"} |
585 |
} |
586 |
|
587 |
# Verify that GDB responds gracefully to an attempt to set a |
588 |
# breakpoint via a convenience variable whose type is not integer. |
589 |
# |
590 |
send_gdb "set \$foo=81.5\n" |
591 |
gdb_expect { |
592 |
-re "$gdb_prompt $"\ |
593 |
{pass "set convenience variable \$foo to 81.5"} |
594 |
timeout {fail "(timeout) set convenience variable \$foo to 81.5"} |
595 |
} |
596 |
send_gdb "break \$foo\n" |
597 |
gdb_expect { |
598 |
-re "Convenience variables used in line specs must have integer values..*$gdb_prompt $"\ |
599 |
{pass "set breakpoint via non-integer convenience variable disallowed"} |
600 |
-re "$gdb_prompt $"\ |
601 |
{fail "set breakpoint via non-integer convenience variable disallowed"} |
602 |
timeout {fail "(timeout) set breakpoint via non-integer convenience variable disallowed"} |
603 |
} |
604 |
|
605 |
# Verify that we can set and trigger a breakpoint in a user-called function. |
606 |
# |
607 |
send_gdb "break marker2\n" |
608 |
gdb_expect { |
609 |
-re "Breakpoint (\[0-9\]*) at .*, line ($bp_location8|$bp_location9).*$gdb_prompt $"\ |
610 |
{pass "set breakpoint on to-be-called function"} |
611 |
-re "$gdb_prompt $"\ |
612 |
{fail "set breakpoint on to-be-called function"} |
613 |
timeout {fail "(timeout) set breakpoint on to-be-called function"} |
614 |
} |
615 |
send_gdb "print marker2(99)\n" |
616 |
gdb_expect { |
617 |
-re "The program being debugged stopped while in a function called from GDB.\r\nWhen the function .marker2$proto. is done executing, GDB will silently\r\nstop .instead of continuing to evaluate the expression containing\r\nthe function call...*$gdb_prompt $"\ |
618 |
{pass "hit breakpoint on called function"} |
619 |
-re "$gdb_prompt $"\ |
620 |
{fail "hit breakpoint on called function"} |
621 |
timeout {fail "(timeout) hit breakpoint on called function"} |
622 |
} |
623 |
|
624 |
# As long as we're stopped (breakpointed) in a called function, |
625 |
# verify that we can successfully backtrace & such from here. |
626 |
# |
627 |
# In this and the following test, the _sr4export check apparently is needed |
628 |
# for hppa*-*-hpux. |
629 |
# |
630 |
send_gdb "bt\n" |
631 |
gdb_expect { |
632 |
-re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*_sr4export.*$gdb_prompt $"\ |
633 |
{pass "backtrace while in called function"} |
634 |
-re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*function called from gdb.*$gdb_prompt $"\ |
635 |
{pass "backtrace while in called function"} |
636 |
-re "$gdb_prompt $"\ |
637 |
{fail "backtrace while in called function"} |
638 |
timeout {fail "(timeout) backtrace while in called function"} |
639 |
} |
640 |
|
641 |
# Return from the called function. For remote targets, it's important to do |
642 |
# this before runto_main, which otherwise may silently stop on the dummy |
643 |
# breakpoint inserted by GDB at the program's entry point. |
644 |
# |
645 |
send_gdb "finish\n" |
646 |
gdb_expect { |
647 |
-re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.* in _sr4export.*$gdb_prompt $"\ |
648 |
{pass "finish from called function"} |
649 |
-re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*function called from gdb.*$gdb_prompt $"\ |
650 |
{pass "finish from called function"} |
651 |
-re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*Value returned.*$gdb_prompt $"\ |
652 |
{pass "finish from called function"} |
653 |
-re "$gdb_prompt $"\ |
654 |
{fail "finish from called function"} |
655 |
timeout {fail "(timeout) finish from called function"} |
656 |
} |
657 |
|
658 |
# Verify that GDB responds gracefully to a "finish" command with |
659 |
# arguments. |
660 |
# |
661 |
if ![runto_main] then { fail "break tests suppressed" } |
662 |
|
663 |
send_gdb "finish 123\n" |
664 |
gdb_expect { |
665 |
-re "The \"finish\" command does not take any arguments.\r\n$gdb_prompt $"\ |
666 |
{pass "finish with arguments disallowed"} |
667 |
-re "$gdb_prompt $"\ |
668 |
{fail "finish with arguments disallowed"} |
669 |
timeout {fail "(timeout) finish with arguments disallowed"} |
670 |
} |
671 |
|
672 |
# Verify that GDB responds gracefully to a request to "finish" from |
673 |
# the outermost frame. On a stub that never exits, this will just |
674 |
# run to the stubs routine, so we don't get this error... Thus the |
675 |
# second condition. |
676 |
# |
677 |
|
678 |
send_gdb "finish\n" |
679 |
gdb_expect { |
680 |
-re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $"\ |
681 |
{pass "finish from outermost frame disallowed"} |
682 |
-re "Run till exit from.*\r\n$gdb_prompt $" { |
683 |
pass "finish from outermost frame disallowed" |
684 |
} |
685 |
-re "$gdb_prompt $"\ |
686 |
{fail "finish from outermost frame disallowed"} |
687 |
timeout {fail "(timeout) finish from outermost frame disallowed"} |
688 |
} |
689 |
|
690 |
# Verify that we can explicitly ask GDB to stop on all shared library |
691 |
# events, and that it does so. |
692 |
# |
693 |
if [istarget "hppa*-*-hpux*"] then { |
694 |
if ![runto_main] then { fail "break tests suppressed" } |
695 |
|
696 |
send_gdb "set stop-on-solib-events 1\n" |
697 |
gdb_expect { |
698 |
-re "$gdb_prompt $"\ |
699 |
{pass "set stop-on-solib-events"} |
700 |
timeout {fail "(timeout) set stop-on-solib-events"} |
701 |
} |
702 |
|
703 |
send_gdb "run\n" |
704 |
gdb_expect { |
705 |
-re ".*Start it from the beginning.*y or n. $"\ |
706 |
{send_gdb "y\n" |
707 |
gdb_expect { |
708 |
-re ".*Stopped due to shared library event.*$gdb_prompt $"\ |
709 |
{pass "triggered stop-on-solib-events"} |
710 |
-re "$gdb_prompt $"\ |
711 |
{fail "triggered stop-on-solib-events"} |
712 |
timeout {fail "(timeout) triggered stop-on-solib-events"} |
713 |
} |
714 |
} |
715 |
-re "$gdb_prompt $"\ |
716 |
{fail "rerun for stop-on-solib-events"} |
717 |
timeout {fail "(timeout) rerun for stop-on-solib-events"} |
718 |
} |
719 |
|
720 |
send_gdb "set stop-on-solib-events 0\n" |
721 |
gdb_expect { |
722 |
-re "$gdb_prompt $"\ |
723 |
{pass "reset stop-on-solib-events"} |
724 |
timeout {fail "(timeout) reset stop-on-solib-events"} |
725 |
} |
726 |
} |
727 |
|
728 |
# Hardware breakpoints are unsupported on HP-UX. Verify that GDB |
729 |
# gracefully responds to requests to create them. |
730 |
# |
731 |
if [istarget "hppa*-*-hpux*"] then { |
732 |
if ![runto_main] then { fail "break tests suppressed" } |
733 |
|
734 |
send_gdb "hbreak\n" |
735 |
gdb_expect { |
736 |
-re "No hardware breakpoint support in the target.*$gdb_prompt $"\ |
737 |
{pass "hw breaks disallowed"} |
738 |
-re "$gdb_prompt $"\ |
739 |
{fail "hw breaks disallowed"} |
740 |
timeout {fail "(timeout) hw breaks disallowed"} |
741 |
} |
742 |
|
743 |
send_gdb "thbreak\n" |
744 |
gdb_expect { |
745 |
-re "No hardware breakpoint support in the target.*$gdb_prompt $"\ |
746 |
{pass "temporary hw breaks disallowed"} |
747 |
-re "$gdb_prompt $"\ |
748 |
{fail "temporary hw breaks disallowed"} |
749 |
timeout {fail "(timeout) temporary hw breaks disallowed"} |
750 |
} |
751 |
} |
752 |
|
753 |
#******** |
754 |
|
755 |
|
756 |
# |
757 |
# Test "next" over recursive function call. |
758 |
# |
759 |
|
760 |
proc test_next_with_recursion {} { |
761 |
global gdb_prompt |
762 |
global decimal |
763 |
global binfile |
764 |
|
765 |
if [target_info exists use_gdb_stub] { |
766 |
# Reload the program. |
767 |
delete_breakpoints |
768 |
gdb_load ${binfile}; |
769 |
} else { |
770 |
# FIXME: should be using runto |
771 |
gdb_test "kill" "" "kill program" "Kill the program being debugged.*y or n. $" "y" |
772 |
|
773 |
delete_breakpoints |
774 |
} |
775 |
|
776 |
gdb_test "break factorial" "Breakpoint $decimal at .*" "break at factorial" |
777 |
|
778 |
# Run until we call factorial with 6 |
779 |
|
780 |
if [istarget "*-*-vxworks*"] then { |
781 |
send_gdb "run vxmain \"6\"\n" |
782 |
} else { |
783 |
gdb_run_cmd |
784 |
} |
785 |
gdb_expect { |
786 |
-re "Break.* factorial .value=6. .*$gdb_prompt $" {} |
787 |
-re ".*$gdb_prompt $" { |
788 |
fail "run to factorial(6)"; |
789 |
gdb_suppress_tests; |
790 |
} |
791 |
timeout { fail "run to factorial(6) (timeout)" ; gdb_suppress_tests } |
792 |
} |
793 |
|
794 |
# Continue until we call factorial recursively with 5. |
795 |
|
796 |
if [gdb_test "continue" \ |
797 |
"Continuing.*Break.* factorial .value=5. .*" \ |
798 |
"continue to factorial(5)"] then { gdb_suppress_tests } |
799 |
|
800 |
# Do a backtrace just to confirm how many levels deep we are. |
801 |
|
802 |
if [gdb_test "backtrace" \ |
803 |
"#0\[ \t\]+ factorial .value=5..*" \ |
804 |
"backtrace from factorial(5)"] then { gdb_suppress_tests } |
805 |
|
806 |
# Now a "next" should position us at the recursive call, which |
807 |
# we will be performing with 4. |
808 |
|
809 |
if [gdb_test "next" \ |
810 |
".* factorial .value - 1.;.*" \ |
811 |
"next to recursive call"] then { gdb_suppress_tests } |
812 |
|
813 |
# Disable the breakpoint at the entry to factorial by deleting them all. |
814 |
# The "next" should run until we return to the next line from this |
815 |
# recursive call to factorial with 4. |
816 |
# Buggy versions of gdb will stop instead at the innermost frame on |
817 |
# the line where we are trying to "next" to. |
818 |
|
819 |
delete_breakpoints |
820 |
|
821 |
if [istarget "mips*tx39-*"] { |
822 |
set timeout 60 |
823 |
} |
824 |
# We used to set timeout here for all other targets as well. This |
825 |
# is almost certainly wrong. The proper timeout depends on the |
826 |
# target system in use, and how we communicate with it, so there |
827 |
# is no single value appropriate for all targets. The timeout |
828 |
# should be established by the Dejagnu config file(s) for the |
829 |
# board, and respected by the test suite. |
830 |
# |
831 |
# For example, if I'm running GDB over an SSH tunnel talking to a |
832 |
# portmaster in California talking to an ancient 68k board running |
833 |
# a crummy ROM monitor (a situation I can only wish were |
834 |
# hypothetical), then I need a large timeout. But that's not the |
835 |
# kind of knowledge that belongs in this file. |
836 |
|
837 |
gdb_test next "\[0-9\]*\[\t \]+return \\(value\\);.*" \ |
838 |
"next over recursive call" |
839 |
|
840 |
# OK, we should be back in the same stack frame we started from. |
841 |
# Do a backtrace just to confirm. |
842 |
|
843 |
set result [gdb_test "backtrace" \ |
844 |
"#0\[ \t\]+ factorial .value=120.*\r\n#1\[ \t\]+ \[0-9a-fx\]+ in factorial .value=6..*" \ |
845 |
"backtrace from factorial(5.1)"] |
846 |
if { $result != 0 } { gdb_suppress_tests } |
847 |
|
848 |
if [target_info exists gdb,noresults] { gdb_suppress_tests } |
849 |
gdb_continue_to_end "recursive next test" |
850 |
gdb_stop_suppressing_tests; |
851 |
} |
852 |
|
853 |
test_next_with_recursion |
854 |
|
855 |
|
856 |
#******** |
857 |
|
858 |
# build a new file with optimization enabled so that we can try breakpoints |
859 |
# on targets with optimized prologues |
860 |
|
861 |
set binfileo2 ${objdir}/${subdir}/${testfile}o2 |
862 |
|
863 |
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}O0.o" object {debug "additional_flags=-w -O2 -fpie -pie"}] != "" } { |
864 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
865 |
} |
866 |
|
867 |
if { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}O1.o" object {debug "additional_flags=-w -O2 -fpie -pie"}] != "" } { |
868 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
869 |
} |
870 |
|
871 |
if { [gdb_compile "${binfile}O0.o ${binfile}O1.o" "${binfileo2}" executable {debug "additional_flags=-w -fpie -pie"}] != "" } { |
872 |
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." |
873 |
} |
874 |
|
875 |
if [get_compiler_info ${binfileo2}] { |
876 |
return -1 |
877 |
} |
878 |
|
879 |
gdb_exit |
880 |
gdb_start |
881 |
gdb_reinitialize_dir $srcdir/$subdir |
882 |
gdb_load ${binfileo2} |
883 |
|
884 |
if [target_info exists gdb_stub] { |
885 |
gdb_step_for_stub; |
886 |
} |
887 |
|
888 |
# |
889 |
# test break at function |
890 |
# |
891 |
gdb_test "break main" \ |
892 |
"Breakpoint.*at.* file .*$srcfile, line.*" \ |
893 |
"breakpoint function, optimized file" |
894 |
|
895 |
# |
896 |
# test break at function |
897 |
# |
898 |
gdb_test "break marker4" \ |
899 |
"Breakpoint.*at.* file .*$srcfile1, line.*" \ |
900 |
"breakpoint small function, optimized file" |
901 |
|
902 |
# |
903 |
# run until the breakpoint at main is hit. For non-stubs-using targets. |
904 |
# |
905 |
if ![target_info exists use_gdb_stub] { |
906 |
if [istarget "*-*-vxworks*"] then { |
907 |
send_gdb "run vxmain \"2\"\n" |
908 |
set timeout 120 |
909 |
verbose "Timeout is now $timeout seconds" 2 |
910 |
} else { |
911 |
send_gdb "run\n" |
912 |
} |
913 |
gdb_expect { |
914 |
-re "The program .* has been started already.*y or n. $" { |
915 |
send_gdb "y\n" |
916 |
exp_continue |
917 |
} |
918 |
-re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\ |
919 |
{ pass "run until function breakpoint, optimized file" } |
920 |
-re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $"\ |
921 |
{ pass "run until function breakpoint, optimized file (code motion)" } |
922 |
-re ".*$gdb_prompt $" { fail "run until function breakpoint, optimized file" } |
923 |
timeout { fail "run until function breakpoint, optimized file (timeout)" } |
924 |
} |
925 |
} else { |
926 |
if ![target_info exists gdb_stub] { |
927 |
gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue, optimized file" |
928 |
} |
929 |
} |
930 |
|
931 |
# |
932 |
# run until the breakpoint at a small function |
933 |
# |
934 |
|
935 |
# |
936 |
# Add a second pass pattern. The behavior differs here between stabs |
937 |
# and dwarf for one-line functions. Stabs preserves two line symbols |
938 |
# (one before the prologue and one after) with the same line number, |
939 |
# but dwarf regards these as duplicates and discards one of them. |
940 |
# Therefore the address after the prologue (where the breakpoint is) |
941 |
# has no exactly matching line symbol, and GDB reports the breakpoint |
942 |
# as if it were in the middle of a line rather than at the beginning. |
943 |
|
944 |
set bp_location13 [gdb_get_line_number "set breakpoint 13 here" $srcfile1] |
945 |
set bp_location14 [gdb_get_line_number "set breakpoint 14 here" $srcfile1] |
946 |
send_gdb "continue\n" |
947 |
gdb_expect { |
948 |
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" { |
949 |
pass "run until breakpoint set at small function, optimized file" |
950 |
} |
951 |
-re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" { |
952 |
pass "run until breakpoint set at small function, optimized file" |
953 |
} |
954 |
-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*" { |
955 |
# marker4() is defined at line 46 when compiled with -DPROTOTYPES |
956 |
pass "run until breakpoint set at small function, optimized file (line bp_location14)" |
957 |
} |
958 |
-re ".*$gdb_prompt " { |
959 |
fail "run until breakpoint set at small function, optimized file" |
960 |
} |
961 |
timeout { |
962 |
fail "run until breakpoint set at small function, optimized file (timeout)" |
963 |
} |
964 |
} |
965 |
|
966 |
|
967 |
# Reset the default arguments for VxWorks |
968 |
if [istarget "*-*-vxworks*"] { |
969 |
set timeout 10 |
970 |
verbose "Timeout is now $timeout seconds" 2 |
971 |
send_gdb "set args main\n" |
972 |
gdb_expect -re ".*$gdb_prompt $" {} |
973 |
} |