]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/testsuite/gdb.linespec/explicit.exp
e9ccbbb74030017bd87558ace83db74130ec232e
[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.linespec / explicit.exp
1 # Copyright 2012-2020 Free Software Foundation, Inc.
2
3 # This program is free software; you can redistribute it and/or modify
4 # it under the terms of the GNU General Public License as published by
5 # the Free Software Foundation; either version 3 of the License, or
6 # (at your option) any later version.
7 #
8 # This program is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # GNU General Public License for more details.
12 #
13 # You should have received a copy of the GNU General Public License
14 # along with this program. If not, see <http://www.gnu.org/licenses/>.
15
16 # Tests for explicit locations
17
18 load_lib completion-support.exp
19
20 standard_testfile explicit.c explicit2.c 3explicit.c
21 set exefile $testfile
22
23 if {[prepare_for_testing "failed to prepare" $exefile \
24 [list $srcfile $srcfile2 $srcfile3] {debug nowarnings}]} {
25 return -1
26 }
27
28 # Wrap the entire test in a namespace to avoid contaminating other tests.
29 namespace eval $testfile {
30
31 # Test the given (explicit) LINESPEC which should cause gdb to break
32 # at LOCATION.
33 proc test_breakpoint {linespec location} {
34
35 set testname "set breakpoint at \"$linespec\""
36 # Delete all breakpoints, set a new breakpoint at LINESPEC,
37 # and attempt to run to it.
38 delete_breakpoints
39 if {[gdb_breakpoint $linespec]} {
40 pass $testname
41 send_log "\nexpecting locpattern \"$location\"\n"
42 gdb_continue_to_breakpoint $linespec $location
43 } else {
44 fail $testname
45 }
46 }
47
48 # Add the given LINESPEC to the array named in THEARRAY. GDB is expected
49 # to stop at LOCATION.
50 proc add {thearray linespec location} {
51 upvar $thearray ar
52
53 lappend ar(linespecs) $linespec
54 lappend ar(locations) $location
55 }
56
57 # A list of all explicit linespec arguments.
58 variable all_arguments
59 set all_arguments {"source" "function" "label" "line"}
60
61 # Some locations used in this test
62 variable lineno
63 variable location
64 set lineno(normal) [gdb_get_line_number "myfunction location" $srcfile]
65 set lineno(top) [gdb_get_line_number "top location" $srcfile]
66 foreach v [array names lineno] {
67 set location($v) ".*[string_to_regexp "$srcfile:$lineno($v)"].*"
68 }
69
70 # A list of explicit locations and the corresponding location.
71 variable linespecs
72 set linespecs(linespecs) {}
73 set linespecs(location) {}
74
75 add linespecs "-source $srcfile -function myfunction" $location(normal)
76 add linespecs "-source $srcfile -function myfunction -label top" \
77 $location(top)
78
79 # This isn't implemented yet; -line is silently ignored.
80 add linespecs "-source $srcfile -function myfunction -label top -line 3" \
81 $location(top)
82 add linespecs "-source $srcfile -line $lineno(top)" $location(top)
83 add linespecs "-function myfunction" $location(normal)
84 add linespecs "-function myfunction -label top" $location(top)
85
86 # These are also not yet supported; -line is silently ignored.
87 add linespecs "-function myfunction -line 3" $location(normal)
88 add linespecs "-function myfunction -label top -line 3" $location(top)
89 add linespecs "-line 3" $location(normal)
90
91 # Fire up gdb.
92 if {![runto_main]} {
93 return -1
94 }
95
96 # Turn off queries
97 gdb_test_no_output "set confirm off"
98
99 # Simple error tests (many more are tested in ls-err.exp)
100 foreach arg $all_arguments {
101 # Test missing argument
102 gdb_test "break -$arg" \
103 [string_to_regexp "missing argument for \"-$arg\""]
104
105 # Test abbreviations
106 set short [string range $arg 0 3]
107 if { $arg != $short } {
108 gdb_test "break -$short" \
109 [string_to_regexp "missing argument for \"-$short\""]
110 }
111 }
112
113 # Test invalid arguments
114 foreach arg {"-foo" "-foo bar" "-function myfunction -foo" \
115 "-function -myfunction -foo bar"} {
116 gdb_test "break $arg" \
117 [string_to_regexp "invalid explicit location argument, \"-foo\""]
118 }
119
120 # Test explicit locations, with and without conditions.
121 # For these tests, it is easiest to turn of pending breakpoint.
122 gdb_test_no_output "set breakpoint pending off" \
123 "turn off pending breakpoints"
124
125 foreach linespec $linespecs(linespecs) loc_pattern $linespecs(locations) {
126
127 # Test the linespec
128 test_breakpoint $linespec $loc_pattern
129
130 # Test with a valid condition
131 delete_breakpoints
132 set tst "set breakpoint at \"$linespec\" with valid condition"
133 if {[gdb_breakpoint "$linespec if arg == 0"]} {
134 pass $tst
135
136 gdb_test "info break" ".*stop only if arg == 0.*" \
137 "info break of conditional breakpoint at \"$linespec\""
138 } else {
139 fail $tst
140 }
141
142 # Test with invalid condition
143 gdb_test "break $linespec if foofoofoo == 1" \
144 ".*No symbol \"foofoofoo\" in current context.*" \
145 "set breakpoint at \"$linespec\" with invalid condition"
146
147 # Test with thread
148 delete_breakpoints
149 gdb_test "break $linespec thread 123" "Unknown thread 123."
150 }
151
152 # Tests below are about tab-completion, which doesn't work if readline
153 # library isn't used. Check it first.
154 if { [readline_is_used] } {
155
156 # Test the explicit location completer
157 foreach abbrev {"fun" "so" "lab" "li"} full {"function" "source" "label" "line"} {
158 set tst "complete 'break -$abbrev'"
159 send_gdb "break -${abbrev}\t"
160 gdb_test_multiple "" $tst {
161 -re "break -$full " {
162 send_gdb "\n"
163 gdb_test_multiple "" $tst {
164 -re "missing argument for \"-$full\".*$gdb_prompt " {
165 pass $tst
166 }
167 }
168 }
169 }
170 set tst "complete -$full with no value"
171 send_gdb "break -$full \t"
172 gdb_test_multiple "" $tst {
173 -re ".*break -$full " {
174 send_gdb "\n"
175 gdb_test_multiple "" $tst {
176 -re ".*Source filename requires function, label, or line offset\..*$gdb_prompt " {
177 if {[string equal $full "source"]} {
178 pass $tst
179 } else {
180 fail $tst
181 }
182 }
183 -re "missing argument for \"-$full\".*$gdb_prompt " {
184 pass $tst
185 }
186 }
187 }
188 }
189 }
190
191 set tst "complete unique function name"
192 send_gdb "break -function my_unique_func\t"
193 gdb_test_multiple "" $tst {
194 -re "break -function my_unique_function_name" {
195 send_gdb "\n"
196 gdb_test "" ".*Breakpoint \[0-9\]+.*" $tst
197 gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
198 }
199 }
200
201 set tst "complete non-unique function name"
202 send_gdb "break -function myfunc\t"
203 gdb_test_multiple "" $tst {
204 -re "break -function myfunc\\\x07tion" {
205 send_gdb "\t\t"
206 gdb_test_multiple "" $tst {
207 -re "\\\x07\r\nmyfunction\[ \t\]+myfunction2\[ \t\]+myfunction3\[ \t\]+myfunction4\[ \t\]+\r\n$gdb_prompt " {
208 gdb_test "2" ".*Breakpoint \[0-9\]+.*" $tst
209 gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
210 }
211 }
212 }
213 }
214
215 set tst "complete non-existant function name"
216 send_gdb "break -function foo\t"
217 gdb_test_multiple "" $tst {
218 -re "break -function foo\\\x07" {
219 send_gdb "\t\t"
220 gdb_test_multiple "" $tst {
221 -re "\\\x07\\\x07" {
222 send_gdb "\n"
223 gdb_test "" {Function "foo" not defined.} $tst
224 }
225 }
226 }
227 }
228
229 with_test_prefix "complete unique file name" {
230 foreach qc $completion::maybe_quoted_list {
231 set cmd "break -source ${qc}3explicit.c${qc}"
232 test_gdb_complete_unique \
233 "break -source ${qc}3ex" \
234 $cmd
235 gdb_test $cmd \
236 {Source filename requires function, label, or line offset.}
237 }
238 }
239
240 set tst "complete non-unique file name"
241 send_gdb "break -source exp\t"
242 # We're matching two cases here:
243 # - without GLIBC debuginfo
244 # (gdb) break -source exp^Glicit^G^M
245 # explicit.c explicit2.c ^M
246 # (gdb) break -source explicit^M
247 # Source filename requires function, label, or line offset.^M
248 # (gdb) PASS: gdb.linespec/explicit.exp: complete non-unique file name
249 # - with GLIBC debuginfo:
250 # (gdb) break -source exp^Gl^G^M
251 # explicit.c explicit2.c explicit_bzero.c explicit_bzero_chk.c \
252 # explodename.c ^M
253 # (gdb) break -source expl^M
254 # Source filename requires function, label, or line offset.^M
255 # (gdb) PASS: gdb.linespec/explicit.exp: complete non-unique file name
256 gdb_test_multiple "" $tst {
257 -re "break -source exp\\\x07l" {
258 # At this point, either output is done (first case), or a
259 # further "icit" is emitted (second case). We have no reliable
260 # way to decide one way or another, so just send the tabs, even
261 # though that may be a little early in the second case.
262 send_gdb "\t\t"
263 gdb_test_multiple "" $tst {
264 -re "\\\x07\r\nexplicit.c\[ \t\]+explicit2.c\[ \t\]+\(expl.*\)?\r\n$gdb_prompt" {
265 send_gdb "\n"
266 gdb_test "" \
267 {Source filename requires function, label, or line offset.} \
268 $tst
269 }
270 }
271 }
272 }
273
274 set tst "complete non-existant file name"
275 send_gdb "break -source foo\t"
276 gdb_test_multiple "" $tst {
277 -re "break -source foo" {
278 send_gdb "\t\t"
279 gdb_test_multiple "" $tst {
280 -re "\\\x07\\\x07" {
281 send_gdb "\n"
282 gdb_test "" \
283 {Source filename requires function, label, or line offset.} \
284 $tst
285 }
286 }
287 }
288 }
289
290 set tst "complete filename and unique function name"
291 send_gdb "break -source explicit.c -function ma\t"
292 gdb_test_multiple "" $tst {
293 -re "break -source explicit.c -function main " {
294 send_gdb "\n"
295 gdb_test "" ".*Breakpoint .*" $tst
296 gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
297 }
298 }
299
300 set tst "complete filename and non-unique function name"
301 send_gdb "break -so 3explicit.c -func myfunc\t"
302 gdb_test_multiple "" $tst {
303 -re "break -so 3explicit.c -func myfunc\\\x07tion" {
304 send_gdb "\t\t"
305 gdb_test_multiple "" $tst {
306 -re "\\\x07\r\nmyfunction3\[ \t\]+myfunction4\[ \t\]+\r\n$gdb_prompt " {
307 gdb_test "3" ".*Breakpoint \[0-9\]+.*" $tst
308 gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
309 }
310 }
311 }
312 }
313
314 set tst "complete filename and non-existant function name"
315 send_gdb "break -sou 3explicit.c -fun foo\t"
316 gdb_test_multiple "" $tst {
317 -re "break -sou 3explicit.c -fun foo\\\x07" {
318 send_gdb "\t\t"
319 gdb_test_multiple "" $tst {
320 -re "\\\x07\\\x07" {
321 send_gdb "\n"
322 gdb_test "" \
323 {Function "foo" not defined in "3explicit.c".} $tst
324 }
325 }
326 }
327 }
328
329 set tst "complete filename and function reversed"
330 send_gdb "break -func myfunction4 -source 3ex\t"
331 gdb_test_multiple "" $tst {
332 -re "break -func myfunction4 -source 3explicit.c " {
333 send_gdb "\n"
334 gdb_test "" "Breakpoint \[0-9\]+.*" $tst
335 gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
336 }
337 }
338
339 with_test_prefix "complete unique label name" {
340 foreach qc $completion::maybe_quoted_list {
341 test_gdb_complete_unique \
342 "break -function myfunction -label ${qc}to" \
343 "break -function myfunction -label ${qc}top${qc}"
344 }
345 }
346
347 with_test_prefix "complete unique label name with source file" {
348 test_gdb_complete_unique \
349 "break -source explicit.c -function myfunction -label to" \
350 "break -source explicit.c -function myfunction -label top"
351 }
352
353 with_test_prefix "complete unique label name reversed" {
354 test_gdb_complete_multiple "b -label top -function " "myfunction" "" {
355 "myfunction"
356 "myfunction2"
357 "myfunction3"
358 "myfunction4"
359 }
360 }
361
362 with_test_prefix "complete non-unique label name" {
363 test_gdb_complete_multiple "b -function myfunction -label " "" "" {
364 "done"
365 "top"
366 }
367 }
368
369 # The program is stopped at myfunction, so gdb is able to
370 # infer the label's function.
371 with_test_prefix "complete label name with no function" {
372 test_gdb_complete_unique \
373 "break -label to" \
374 "break -label top"
375 check_bp_locations_match_list \
376 "break -label top" {
377 "-function myfunction -label top"
378 }
379 }
380
381 # See above.
382 with_test_prefix "complete label name with source file but no function" {
383 test_gdb_complete_unique \
384 "break -source explicit.c -label to" \
385 "break -source explicit.c -label top"
386 check_bp_locations_match_list \
387 "break -source explicit.c -label top" {
388 "-source explicit.c -function myfunction -label top"
389 }
390 }
391
392 with_test_prefix "complete label name with wrong source file" {
393 test_gdb_complete_none \
394 "break -source explicit2.c -function myfunction -label to"
395 check_setting_bp_fails \
396 "break -source explicit2.c -function myfunction -label top"
397 }
398
399 # Get rid of symbols from shared libraries, otherwise
400 # "b -source thr<tab>" could find some system library's
401 # source.
402 gdb_test_no_output "nosharedlibrary"
403
404 # Test that after a seemingly finished option argument,
405 # completion matches both the explicit location options and
406 # the linespec keywords.
407 set completions_list {
408 "-function"
409 "-label"
410 "-line"
411 "-qualified"
412 "-source"
413 "if"
414 "task"
415 "thread"
416 }
417 foreach what { "-function" "-label" "-line" "-source" } {
418 # Also test with "-qualified" appearing before the
419 # explicit location.
420 foreach prefix {"" "-qualified "} {
421
422 # ... and with "-qualified" appearing after the
423 # explicit location.
424 foreach suffix {"" " -qualified"} {
425 with_test_prefix "complete after $prefix$what$suffix" {
426 if {$what != "-line"} {
427 set w "$prefix$what argument$suffix "
428 test_gdb_complete_multiple \
429 "b $w" "" "" $completions_list
430 test_gdb_complete_unique \
431 "b $w thr" \
432 "b $w thread"
433 test_gdb_complete_unique \
434 "b $w -fun" \
435 "b $w -function"
436 } else {
437 # After -line, we expect a number / offset.
438 foreach line {"10" "+10" "-10"} {
439 set w "$prefix-line $line$suffix"
440 test_gdb_complete_multiple \
441 "b $w " "" "" $completions_list
442 test_gdb_complete_unique \
443 "b $w thr" \
444 "b $w thread"
445 test_gdb_complete_unique \
446 "b $w -fun" \
447 "b $w -function"
448 }
449
450 # With an invalid -line argument, we don't get any
451 # completions.
452 test_gdb_complete_none "b $prefix-line argument$suffix "
453 }
454
455 }
456
457 }
458
459 # These tests don't make sense with "-qualified" after
460 # the location.
461 with_test_prefix "complete after $prefix$what" {
462 # Don't complete a linespec keyword ("thread") or
463 # another option name when expecting an option
464 # argument.
465 test_gdb_complete_none "b $prefix$what thr"
466 test_gdb_complete_none "b $prefix$what -fun"
467 }
468 }
469 }
470
471 # Tests that ensure that after "if" we complete on expressions
472 # are in cpcompletion.exp.
473
474 # Disable the completion limit for the rest of the testcase.
475 gdb_test_no_output "set max-completions unlimited"
476
477 # Get rid of symbols from shared libraries, otherwise the
478 # completions match list for "break <tab>" is huge and makes
479 # the test below quite long while the gdb_test_multiple loop
480 # below consumes the matches. Not doing this added ~20
481 # seconds at the time of writing. (Actually, already done above.)
482 # gdb_test_no_output "nosharedlibrary"
483
484 # Test completion with no input argument. We should see all
485 # the options, plus all the functions. To keep it simple, as
486 # proxy, we check for presence of one explicit location
487 # option, one probe location, and one function.
488 set saw_opt_function 0
489 set saw_opt_probe_stap 0
490 set saw_function 0
491
492 set tst "complete with no arguments"
493 send_gdb "break \t"
494 gdb_test_multiple "" $tst {
495 "break \\\x07" {
496 send_gdb "\t"
497 gdb_test_multiple "" $tst {
498 "Display all" {
499 send_gdb "y"
500 exp_continue
501 }
502 -re "-function" {
503 set saw_opt_function 1
504 exp_continue
505 }
506 -re "-probe-stap" {
507 set saw_opt_probe_stap 1
508 exp_continue
509 }
510 -re "myfunction4" {
511 set saw_function 1
512 exp_continue
513 }
514 -re "\r\n$gdb_prompt " {
515 gdb_assert {$saw_opt_function && $saw_opt_probe_stap && $saw_function} $tst
516 }
517 -re " " {
518 exp_continue
519 }
520 }
521 }
522 }
523 clear_input_line $tst
524
525 # NOTE: We don't bother testing more elaborate combinations of options,
526 # such as "-func main -sour 3ex\t" (main is defined in explicit.c).
527 # The completer cannot handle these yet.
528
529 # The following completion tests require having no symbols
530 # loaded.
531 gdb_exit
532 gdb_start
533
534 # The match list you get when you complete with no options
535 # specified at all.
536 set completion_list {
537 "-function"
538 "-label"
539 "-line"
540 "-probe"
541 "-probe-dtrace"
542 "-probe-stap"
543 "-qualified"
544 "-source"
545 }
546 with_test_prefix "complete with no arguments and no symbols" {
547 test_gdb_complete_multiple "b " "" "-" $completion_list
548 test_gdb_complete_multiple "b " "-" "" $completion_list
549 }
550 }
551 # End of completion tests.
552
553 # Test pending explicit breakpoints
554 gdb_exit
555 gdb_start
556
557 set tst "pending invalid conditional explicit breakpoint"
558 if {![gdb_breakpoint "-func myfunction if foofoofoo == 1" \
559 allow-pending]} {
560 fail "set $tst"
561 } else {
562 gdb_test "info break" ".*PENDING.*myfunction if foofoofoo == 1.*" $tst
563 }
564
565 gdb_exit
566 gdb_start
567
568 set tst "pending valid conditional explicit breakpoint"
569 if {![gdb_breakpoint "-func myfunction if arg == 0" \
570 allow-pending]} {
571 fail "set $tst"
572 } else {
573 gdb_test "info break" ".*PENDING.*myfunction if arg == 0" $tst
574
575 gdb_load [standard_output_file $exefile]
576 gdb_test "info break" \
577 ".*in myfunction at .*$srcfile:.*stop only if arg == 0.*" \
578 "$tst resolved"
579 }
580
581 # Test interaction of condition command and explicit linespec conditons.
582 gdb_exit
583 gdb_start
584 gdb_load [standard_output_file $exefile]
585
586 set tst "condition_command overrides explicit linespec condition"
587 if {![runto_main]} {
588 fail $tst
589 } else {
590 if {![gdb_breakpoint "-func myfunction if arg == 1"]} {
591 fail "set breakpoint with condition 'arg == 1'"
592 } else {
593 gdb_test_no_output "cond 2 arg == 0" \
594 "set new breakpoint condition for explicit linespec"
595
596 gdb_continue_to_breakpoint $tst $location(normal)
597 }
598 }
599
600 gdb_test "cond 2" [string_to_regexp "Breakpoint 2 now unconditional."] \
601 "clear condition for explicit breakpoint"
602 set tst "info break of cleared condition of explicit breakpoint"
603 gdb_test_multiple "info break" $tst {
604 -re ".*in myfunction at .*$srcfile:.*stop only if arg == 0.*" {
605 fail $tst
606 }
607 -re ".*in myfunction at .*$srcfile:.*$gdb_prompt $" {
608 pass $tst
609 }
610 }
611
612 # Test explicit "ranges." Make sure that using explicit
613 # locations doesn't alter the expected outcome.
614 gdb_test "list -q main" ".*" "list main 1"
615 set list_result [capture_command_output "list -,+" ""]
616 gdb_test "list -q main" ".*" "list main 2"
617 gdb_test "list -line -,-line +" [string_to_regexp $list_result]
618
619 # Ditto for the reverse (except that no output is expected).
620 gdb_test "list -q myfunction" ".*" "list myfunction 1"
621 gdb_test_no_output "list +,-"
622 gdb_test "list -q myfunction" ".*" "list myfunction 2"
623 gdb_test_no_output "list -line +, -line -"
624 }
625
626 namespace delete $testfile