PR gdb/13860: make -interpreter-exec console "list" behave more like "list".

I noticed that "list" behaves differently in CLI vs MI.  Particularly:

  $ ./gdb -nx -q ./testsuite/gdb.mi/mi-cli
  Reading symbols from /home/pedro/gdb/mygit/build/gdb/testsuite/gdb.mi/mi-cli...done.
  (gdb) start
  Temporary breakpoint 1 at 0x40054d: file ../../../src/gdb/testsuite/gdb.mi/basics.c, line 62.
  Starting program: /home/pedro/gdb/mygit/build/gdb/testsuite/gdb.mi/mi-cli

  Temporary breakpoint 1, main () at ../../../src/gdb/testsuite/gdb.mi/basics.c:62
  62        callee1 (2, "A string argument.", 3.5);
  (gdb) list
  57      {
  58      }
  59
  60      main ()
  61      {
  62        callee1 (2, "A string argument.", 3.5);
  63        callee1 (2, "A string argument.", 3.5);
  64
  65        do_nothing (); /* Hello, World! */
  66
  (gdb)

Note the list started at line 57.  IOW, the program stopped at line
62, and GDB centered the list on that.

compare with:

  $ ./gdb -nx -q ./testsuite/gdb.mi/mi-cli -i=mi
  =thread-group-added,id="i1"
  ~"Reading symbols from /home/pedro/gdb/mygit/build/gdb/testsuite/gdb.mi/mi-cli..."
  ~"done.\n"
  (gdb)
  start
  &"start\n"
...
 ~"\nTemporary breakpoint "
  ~"1, main () at ../../../src/gdb/testsuite/gdb.mi/basics.c:62\n"
  ~"62\t  callee1 (2, \"A string argument.\", 3.5);\n"
  *stopped,reason="breakpoint-hit",disp="del",bkptno="1",frame={addr="0x000000000040054d",func="main",args=[],file="../../../src/gdb/testsuite/gdb.mi/basics.c",fullname="/home/pedro/gdb/mygit/src/gdb/testsuite/gdb.mi/basics.c",line="62"},thread-id="1",stopped-threads="all",core="0"
  =breakpoint-deleted,id="1"
  (gdb)
  -interpreter-exec console list
  ~"62\t  callee1 (2, \"A string argument.\", 3.5);\n"
  ~"63\t  callee1 (2, \"A string argument.\", 3.5);\n"
  ~"64\t\n"
  ~"65\t  do_nothing (); /* Hello, World! */\n"
  ~"66\t\n"
  ~"67\t  callme (1);\n"
  ~"68\t  callme (2);\n"
  ~"69\t\n"
  ~"70\t  return 0;\n"
  ~"71\t}\n"
  ^done
  (gdb)

Here the list starts at line 62, where the program was stopped.

This happens because print_stack_frame, called from both normal_stop
and mi_on_normal_stop, is the function responsible for setting the
current sal from the selected frame, overrides the PRINT_WHAT
argument, and only after that does it decide whether to center the
current sal line or not, based on the overridden value, and it will
always decide false.

(The print_stack_frame call in mi_on_normal_stop is a little different
from the call in normal_stop, in that it is an unconditional
SRC_AND_LOC call.  A future patch will make those uniform.)

A previous version of this patch made MI uniform with CLI here, by
making print_stack_frame also center when MI is active.  That changed
the output of a "list" command in mi-cli.exp, to expect line 57
instead of 62, as per the example above.

However, looking deeper, that list in question is the first "list"
after the program stops, and right after the stop, before the "list",
the test did "set listsize 1".  Let's try the same thing with the CLI:

 (gdb) start
 62        callee1 (2, "A string argument.", 3.5);
 (gdb) set listsize 1
 (gdb) list
 57      {

Huh, that's unexpected.  Why the 57?  It's because print_stack_frame,
called in reaction to the breakpoint stop, expecting the next "list"
to show 10 lines (the listsize at the time) around line 62, sets the
lines listed range to 57-67 (62 +/- 5).  If the user changes the
listsize before "list", why would we still show that range?  Looks
bogus to me.

So the fix for this whole issue should be delay trying to center the
listing to until actually listing, so that the correct listsize can be
taken into account.  This makes MI and CLI uniform too, as it deletes
the center code from print_stack_frame.

A series of tests are added to list.exp to cover this.  mi-cli.exp was
after all correct all along, but it now gains an additional test that
lists lines with listsize 10, to ensure the centering is consistent
with CLI's.

One related Python test changed related output -- it's a test that
prints the line number after stopping for a breakpoint, similar to the
new list.exp tests.  Previously we'd print the stop line minus 5 (due
to the premature centering), now we print the stop line.  I think
that's a good change.

Tested on x86_64 Fedora 20.

gdb/
2014-05-21  Pedro Alves  <palves@redhat.com>

	* cli/cli-cmds.c (list_command): Handle the first "list" after the
	current source line having changed.
	* frame.h (set_current_sal_from_frame): Remove 'center' parameter.
	* infrun.c (normal_stop): Adjust call to
	set_current_sal_from_frame.
	* source.c (clear_lines_listed_range): New function.
	(set_current_source_symtab_and_line, identify_source_line): Clear
	the lines listed range.
	(line_info): Handle the first "info line" after the current source
	line having changed.
	* stack.c (print_stack_frame): Remove center handling.
	(set_current_sal_from_frame): Remove 'center' parameter.  Don't
	center sal.line.

gdb/testsuite/
2014-05-21  Pedro Alves  <palves@redhat.com>

	* gdb.base/list.exp (build_pattern, test_list): New procedures.
	Use them to test variations of "list" after reaching a breakpoint.
	* gdb.mi/mi-cli.exp (line_main_callme_2): New global.
	Test "list" with listsize 10 after reaching a breakpoint.
	* gdb.python/python.exp (decode_line current location line
	number): Adjust expected line number.

1 files changed, 95 insertions, 0 deletions

diff --git a/gdb/testsuite/gdb.base/list.exp b/gdb/testsuite/gdb.base/list.exp
index 12b2c94..2d45111 100644
--- a/gdb/testsuite/gdb.base/list.exp
+++ b/gdb/testsuite/gdb.base/list.exp
@@ -529,4 +529,99 @@ if [ set_listsize 10 ] then {
     test_only_end
 }
 
+# Follows tests that require execution.
+
+# Build source listing pattern based on a line range spec string.  The
+# range can be specificed as "START-END" indicating all lines in range
+# (inclusive); or just "LINE", indicating just that line.
+
+proc build_pattern { range_spec } {
+    global line_re
+
+    set range_list [split $range_spec -]
+    set range_list_len [llength $range_list]
+
+    set range_start [lindex $range_list 0]
+    if { $range_list_len > 2 || $range_list_len < 1} {
+	error "invalid range spec string: $range_spec"
+    } elseif { $range_list_len == 2 } {
+	set range_end [lindex $range_list 1]
+    } else {
+	set range_end $range_start
+    }
+
+    for {set i $range_start} {$i <= $range_end} {incr i} {
+	append pattern "\r\n$i\[ \t\]\[^\r\n\]*"
+    }
+
+    verbose -log "pattern $pattern"
+    return $pattern
+}
+
+# Test "list" command invocations right after stopping for an event.
+# COMMAND is the actual list command, including arguments.  LISTSIZE1
+# and LISTSIZE2 are the listsizes set just before and after running
+# the program to the stop point.  COMMAND is issued twice.  The first
+# time, the lines specificed by LINERANGE1 are expected; the second
+# time, the lines specified by LINERANGE2 are expected.
+
+proc test_list {command listsize1 listsize2 linerange1 linerange2} {
+    with_test_prefix "$command after stop: $listsize1, $listsize2" {
+	global binfile
+
+	clean_restart $binfile
+	if ![runto_main] then {
+	    fail "Can't run to main"
+	    return
+	}
+
+	# Test changing the listsize both before nexting, and after
+	# stopping, but before listing.  Only the second listsize
+	# change should affect which lines are listed.
+	gdb_test_no_output "set listsize $listsize1"
+	gdb_test "next" "foo \\(.*"
+	gdb_test_no_output "set listsize $listsize2"
+
+	set pattern1 [build_pattern $linerange1]
+	set pattern2 [build_pattern $linerange2]
+	gdb_test "$command" "${pattern1}" "$command #1"
+	gdb_test "$command" "${pattern2}" "$command #2"
+    }
+}
+
+
+# The first "list" should center the listing around line 8, the stop
+# line.
+test_list "list" 1 10 "3-12" "13-22"
+
+# Likewise.
+test_list "list" 10 10 "3-12" "13-22"
+
+# Likewise, but show only one line.  IOW, the first list should show
+# line 8.  Note how the listsize is 10 at the time of the stop, but
+# before any listing had been requested.  That should not affect the
+# line range that is first listed.
+test_list "list" 10 1 "8" "9"
+
+# Likewise, but show two lines.
+test_list "list" 10 2 "7-8" "9-10"
+
+# Three lines.
+test_list "list" 10 3 "7-9" "10-12"
+
+# Now test backwards.  Just like "list", the first "list -" should
+# center the listing around the stop line.
+test_list "list -" 10 10 "3-12" "2"
+
+# Likewise, but test showing 3 lines at a time.
+test_list "list -" 10 3 "7-9" "4-6"
+
+# 2 lines at a time.
+test_list "list -" 10 2 "7-8" "5-6"
+
+# Test listing one line only.  This case is a little special and
+# starts showing the previous line immediately instead of repeating
+# the current line.
+test_list "list -" 10 1 "7" "6"
+
 remote_exec build "rm -f list0.h"