New /s modifier for the disassemble command.

The "source centric" /m option to the disassemble command is often
unhelpful, e.g., in the presence of optimized code.
This patch adds a /s modifier that is better.
For one, /m only prints instructions from the originating source file,
leaving out instructions from e.g., inlined functions from other files.

gdb/ChangeLog:

	PR gdb/11833
	* NEWS: Document new /s modifier for the disassemble command.
	* cli/cli-cmds.c (disassemble_command): Add support for /s.
	(_initialize_cli_cmds): Update online docs of disassemble command.
	* disasm.c: #include "source.h".
	(struct deprecated_dis_line_entry): Renamed from dis_line_entry.
	All uses updated.
	(dis_line_entry): New struct.
	(hash_dis_line_entry, eq_dis_line_entry): New functions.
	(allocate_dis_line_table): New functions.
	(maybe_add_dis_line_entry, line_has_code_p): New functions.
	(dump_insns): New arg end_pc.  All callers updated.
	(do_mixed_source_and_assembly_deprecated): Renamed from
	do_mixed_source_and_assembly.  All callers updated.
	(do_mixed_source_and_assembly): New function.
	(gdb_disassembly): Handle /s (DISASSEMBLY_SOURCE).
	* disasm.h (DISASSEMBLY_SOURCE_DEPRECATED): Renamed from
	DISASSEMBLY_SOURCE.  All uses updated.
	(DISASSEMBLY_SOURCE): New macro.
	* mi/mi-cmd-disas.c (mi_cmd_disassemble): New modes 4,5.

gdb/doc/ChangeLog:

	* gdb.texinfo (Machine Code): Update docs for mixed source/assembly
	disassembly.
	(GDB/MI Data Manipulation): Update docs for new disassembly modes.

gdb/testsuite/ChangeLog:

	* gdb.mi/mi-disassemble.exp: Update.
	* gdb.base/disasm-optim.S: New file.
	* gdb.base/disasm-optim.c: New file.
	* gdb.base/disasm-optim.h: New file.
	* gdb.base/disasm-optim.exp: New file.

1 files changed, 374 insertions, 30 deletions

diff --git a/gdb/disasm.c b/gdb/disasm.c
index 483df01..2b65c6a 100644
--- a/gdb/disasm.c
+++ b/gdb/disasm.c
@@ -24,23 +24,101 @@
 #include "disasm.h"
 #include "gdbcore.h"
 #include "dis-asm.h"
+#include "source.h"
 
 /* Disassemble functions.
    FIXME: We should get rid of all the duplicate code in gdb that does
    the same thing: disassemble_command() and the gdbtk variation.  */
 
-/* This Structure is used to store line number information.
+/* This structure is used to store line number information for the
+   deprecated /m option.
    We need a different sort of line table from the normal one cuz we can't
    depend upon implicit line-end pc's for lines to do the
    reordering in this function.  */
 
-struct dis_line_entry
+struct deprecated_dis_line_entry
 {
   int line;
   CORE_ADDR start_pc;
   CORE_ADDR end_pc;
 };
 
+/* This Structure is used to store line number information.
+   We need a different sort of line table from the normal one cuz we can't
+   depend upon implicit line-end pc's for lines to do the
+   reordering in this function.  */
+
+struct dis_line_entry
+{
+  struct symtab *symtab;
+  int line;
+};
+
+/* Hash function for dis_line_entry.  */
+
+static hashval_t
+hash_dis_line_entry (const void *item)
+{
+  const struct dis_line_entry *dle = item;
+
+  return htab_hash_pointer (dle->symtab) + dle->line;
+}
+
+/* Equal function for dis_line_entry.  */
+
+static int
+eq_dis_line_entry (const void *item_lhs, const void *item_rhs)
+{
+  const struct dis_line_entry *lhs = item_lhs;
+  const struct dis_line_entry *rhs = item_rhs;
+
+  return (lhs->symtab == rhs->symtab
+	  && lhs->line == rhs->line);
+}
+
+/* Create the table to manage lines for mixed source/disassembly.  */
+
+static htab_t
+allocate_dis_line_table (void)
+{
+  return htab_create_alloc (41,
+			    hash_dis_line_entry, eq_dis_line_entry,
+			    xfree, xcalloc, xfree);
+}
+
+/* Add DLE to TABLE.
+   Returns 1 if added, 0 if already present.  */
+
+static void
+maybe_add_dis_line_entry (htab_t table, struct symtab *symtab, int line)
+{
+  void **slot;
+  struct dis_line_entry dle, *dlep;
+
+  dle.symtab = symtab;
+  dle.line = line;
+  slot = htab_find_slot (table, &dle, INSERT);
+  if (*slot == NULL)
+    {
+      dlep = XNEW (struct dis_line_entry);
+      dlep->symtab = symtab;
+      dlep->line = line;
+      *slot = dlep;
+    }
+}
+
+/* Return non-zero if SYMTAB, LINE are in TABLE.  */
+
+static int
+line_has_code_p (htab_t table, struct symtab *symtab, int line)
+{
+  struct dis_line_entry dle;
+
+  dle.symtab = symtab;
+  dle.line = line;
+  return htab_find (table, &dle) != NULL;
+}
+
 /* Like target_read_memory, but slightly different parameters.  */
 static int
 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
@@ -69,11 +147,11 @@ dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 static int
 compare_lines (const void *mle1p, const void *mle2p)
 {
-  struct dis_line_entry *mle1, *mle2;
+  struct deprecated_dis_line_entry *mle1, *mle2;
   int val;
 
-  mle1 = (struct dis_line_entry *) mle1p;
-  mle2 = (struct dis_line_entry *) mle2p;
+  mle1 = (struct deprecated_dis_line_entry *) mle1p;
+  mle2 = (struct deprecated_dis_line_entry *) mle2p;
 
   /* End of sequence markers have a line number of 0 but don't want to
      be sorted to the head of the list, instead sort by PC.  */
@@ -96,7 +174,8 @@ static int
 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
 	    struct disassemble_info * di,
 	    CORE_ADDR low, CORE_ADDR high,
-	    int how_many, int flags, struct ui_file *stb)
+	    int how_many, int flags, struct ui_file *stb,
+	    CORE_ADDR *end_pc)
 {
   int num_displayed = 0;
   CORE_ADDR pc;
@@ -182,24 +261,30 @@ dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
       do_cleanups (ui_out_chain);
       ui_out_text (uiout, "\n");
     }
+
+  if (end_pc != NULL)
+    *end_pc = pc;
   return num_displayed;
 }
 
 /* The idea here is to present a source-O-centric view of a
    function to the user.  This means that things are presented
    in source order, with (possibly) out of order assembly
-   immediately following.  */
+   immediately following.
+
+   N.B. This view is deprecated.  */
 
 static void
-do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
-			      struct disassemble_info *di, int nlines,
-			      struct linetable_entry *le,
-			      CORE_ADDR low, CORE_ADDR high,
-			      struct symtab *symtab,
-			      int how_many, int flags, struct ui_file *stb)
+do_mixed_source_and_assembly_deprecated
+  (struct gdbarch *gdbarch, struct ui_out *uiout,
+   struct disassemble_info *di, struct symtab *symtab,
+   CORE_ADDR low, CORE_ADDR high,
+   int how_many, int flags, struct ui_file *stb)
 {
   int newlines = 0;
-  struct dis_line_entry *mle;
+  int nlines;
+  struct linetable_entry *le;
+  struct deprecated_dis_line_entry *mle;
   struct symtab_and_line sal;
   int i;
   int out_of_order = 0;
@@ -210,11 +295,16 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
   struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
 
+  gdb_assert (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL);
+
+  nlines = SYMTAB_LINETABLE (symtab)->nitems;
+  le = SYMTAB_LINETABLE (symtab)->item;
+
   if (flags & DISASSEMBLY_FILENAME)
     psl_flags |= PRINT_SOURCE_LINES_FILENAME;
 
-  mle = (struct dis_line_entry *) alloca (nlines
-					  * sizeof (struct dis_line_entry));
+  mle = (struct deprecated_dis_line_entry *)
+    alloca (nlines * sizeof (struct deprecated_dis_line_entry));
 
   /* Copy linetable entries for this function into our data
      structure, creating end_pc's and setting out_of_order as
@@ -255,11 +345,11 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
       newlines++;
     }
 
-  /* Now, sort mle by line #s (and, then by addresses within
-     lines).  */
+  /* Now, sort mle by line #s (and, then by addresses within lines).  */
 
   if (out_of_order)
-    qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
+    qsort (mle, newlines, sizeof (struct deprecated_dis_line_entry),
+	   compare_lines);
 
   /* Now, for each line entry, emit the specified lines (unless
      they have been emitted before), followed by the assembly code
@@ -324,7 +414,7 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 
       num_displayed += dump_insns (gdbarch, uiout, di,
 				   mle[i].start_pc, mle[i].end_pc,
-				   how_many, flags, stb);
+				   how_many, flags, stb, NULL);
 
       /* When we've reached the end of the mle array, or we've seen the last
          assembly range for this source line, close out the list/tuple.  */
@@ -342,6 +432,260 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
   do_cleanups (ui_out_chain);
 }
 
+/* The idea here is to present a source-O-centric view of a
+   function to the user.  This means that things are presented
+   in source order, with (possibly) out of order assembly
+   immediately following.  */
+
+static void
+do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
+			      struct disassemble_info *di,
+			      struct symtab *main_symtab,
+			      CORE_ADDR low, CORE_ADDR high,
+			      int how_many, int flags, struct ui_file *stb)
+{
+  int newlines = 0;
+  const struct linetable_entry *le, *first_le;
+  struct symtab_and_line sal;
+  int i, nlines;
+  int out_of_order = 0;
+  int next_line = 0;
+  int num_displayed = 0;
+  enum print_source_lines_flags psl_flags = 0;
+  struct cleanup *cleanups;
+  struct cleanup *ui_out_chain;
+  struct cleanup *ui_out_tuple_chain;
+  struct cleanup *ui_out_list_chain;
+  CORE_ADDR pc;
+  struct symtab *last_symtab;
+  int last_line;
+  htab_t dis_line_table;
+
+  gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL);
+
+  /* First pass: collect the list of all source files and lines.
+     We do this so that we can only print lines containing code once.
+     We try to print the source text leading up to the next instruction,
+     but if that text is for code that will be disassembled later, then
+     we'll want to defer printing it until later with its associated code.  */
+
+  dis_line_table = allocate_dis_line_table ();
+  cleanups = make_cleanup_htab_delete (dis_line_table);
+
+  pc = low;
+
+  /* The prologue may be empty, but there may still be a line number entry
+     for the opening brace which is distinct from the first line of code.
+     If the prologue has been eliminated find_pc_line may return the source
+     line after the opening brace.  We still want to print this opening brace.
+     first_le is used to implement this.  */
+
+  nlines = SYMTAB_LINETABLE (main_symtab)->nitems;
+  le = SYMTAB_LINETABLE (main_symtab)->item;
+  first_le = NULL;
+
+  /* Skip all the preceding functions.  */
+  for (i = 0; i < nlines && le[i].pc < low; i++)
+    continue;
+
+  if (i < nlines && le[i].pc < high)
+    first_le = &le[i];
+
+  /* Add lines for every pc value.  */
+  while (pc < high)
+    {
+      struct symtab_and_line sal;
+      int length;
+
+      sal = find_pc_line (pc, 0);
+      length = gdb_insn_length (gdbarch, pc);
+      pc += length;
+
+      if (sal.symtab != NULL)
+	maybe_add_dis_line_entry (dis_line_table, sal.symtab, sal.line);
+    }
+
+  /* Second pass: print the disassembly.
+
+     Output format, from an MI perspective:
+       The result is a ui_out list, field name "asm_insns", where elements have
+       name "src_and_asm_line".
+       Each element is a tuple of source line specs (field names line, file,
+       fullname), and field "line_asm_insn" which contains the disassembly.
+       Field "line_asm_insn" is a list of tuples: address, func-name, offset,
+       opcodes, inst.
+
+     CLI output works on top of this because MI ignores ui_out_text output,
+     which is where we put file name and source line contents output.
+
+     Cleanup usage:
+     cleanups:
+       For things created at the beginning of this function and need to be
+       kept until the end of this function.
+     ui_out_chain
+       Handles the outer "asm_insns" list.
+     ui_out_tuple_chain
+       The tuples for each group of consecutive disassemblies.
+     ui_out_list_chain
+       List of consecutive source lines or disassembled insns.  */
+
+  if (flags & DISASSEMBLY_FILENAME)
+    psl_flags |= PRINT_SOURCE_LINES_FILENAME;
+
+  ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
+
+  ui_out_tuple_chain = NULL;
+  ui_out_list_chain = NULL;
+
+  last_symtab = NULL;
+  last_line = 0;
+  pc = low;
+
+  while (pc < high)
+    {
+      struct linetable_entry *le = NULL;
+      struct symtab_and_line sal;
+      CORE_ADDR end_pc;
+      int start_preceding_line_to_display = 0;
+      int end_preceding_line_to_display = 0;
+      int new_source_line = 0;
+
+      sal = find_pc_line (pc, 0);
+
+      if (sal.symtab != last_symtab)
+	{
+	  /* New source file.  */
+	  new_source_line = 1;
+
+	  /* If this is the first line of output, check for any preceding
+	     lines.  */
+	  if (last_line == 0
+	      && first_le != NULL
+	      && first_le->line < sal.line)
+	    {
+	      start_preceding_line_to_display = first_le->line;
+	      end_preceding_line_to_display = sal.line;
+	    }
+	}
+      else
+	{
+	  /* Same source file as last time.  */
+	  if (sal.symtab != NULL)
+	    {
+	      if (sal.line > last_line + 1 && last_line != 0)
+		{
+		  int l;
+
+		  /* Several preceding source lines.  Print the trailing ones
+		     not associated with code that we'll print later.  */
+		  for (l = sal.line - 1; l > last_line; --l)
+		    {
+		      if (line_has_code_p (dis_line_table, sal.symtab, l))
+			break;
+		    }
+		  if (l < sal.line - 1)
+		    {
+		      start_preceding_line_to_display = l + 1;
+		      end_preceding_line_to_display = sal.line;
+		    }
+		}
+	      if (sal.line != last_line)
+		new_source_line = 1;
+	      else
+		{
+		  /* Same source line as last time.  This can happen, depending
+		     on the debug info.  */
+		}
+	    }
+	}
+
+      if (new_source_line)
+	{
+	  /* Skip the newline if this is the first instruction.  */
+	  if (pc > low)
+	    ui_out_text (uiout, "\n");
+	  if (ui_out_tuple_chain != NULL)
+	    {
+	      gdb_assert (ui_out_list_chain != NULL);
+	      do_cleanups (ui_out_list_chain);
+	      do_cleanups (ui_out_tuple_chain);
+	    }
+	  if (sal.symtab != last_symtab
+	      && !(flags & DISASSEMBLY_FILENAME))
+	    {
+	      /* Remember MI ignores ui_out_text.
+		 We don't have to do anything here for MI because MI
+		 output includes the source specs for each line.  */
+	      if (sal.symtab != NULL)
+		{
+		  ui_out_text (uiout,
+			       symtab_to_filename_for_display (sal.symtab));
+		}
+	      else
+		ui_out_text (uiout, "unknown");
+	      ui_out_text (uiout, ":\n");
+	    }
+	  if (start_preceding_line_to_display > 0)
+	    {
+	      /* Several source lines w/o asm instructions associated.
+		 We need to preserve the structure of the output, so output
+		 a bunch of line tuples with no asm entries.  */
+	      int l;
+	      struct cleanup *ui_out_list_chain_line;
+	      struct cleanup *ui_out_tuple_chain_line;
+
+	      gdb_assert (sal.symtab != NULL);
+	      for (l = start_preceding_line_to_display;
+		   l < end_preceding_line_to_display;
+		   ++l)
+		{
+		  ui_out_tuple_chain_line
+		    = make_cleanup_ui_out_tuple_begin_end (uiout,
+							   "src_and_asm_line");
+		  print_source_lines (sal.symtab, l, l + 1, psl_flags);
+		  ui_out_list_chain_line
+		    = make_cleanup_ui_out_list_begin_end (uiout,
+							  "line_asm_insn");
+		  do_cleanups (ui_out_list_chain_line);
+		  do_cleanups (ui_out_tuple_chain_line);
+		}
+	    }
+	  ui_out_tuple_chain
+	    = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
+	  if (sal.symtab != NULL)
+	    print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags);
+	  else
+	    ui_out_text (uiout, _("--- no source info for this pc ---\n"));
+	  ui_out_list_chain
+	    = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
+	}
+      else
+	{
+	  /* Here we're appending instructions to an existing line.
+	     By construction the very first insn will have a symtab
+	     and follow the new_source_line path above.  */
+	  gdb_assert (ui_out_tuple_chain != NULL);
+	  gdb_assert (ui_out_list_chain != NULL);
+	}
+
+      if (sal.end != 0)
+	end_pc = min (sal.end, high);
+      else
+	end_pc = pc + 1;
+      num_displayed += dump_insns (gdbarch, uiout, di, pc, end_pc,
+				   how_many, flags, stb, &end_pc);
+      pc = end_pc;
+
+      if (how_many >= 0 && num_displayed >= how_many)
+	break;
+
+      last_symtab = sal.symtab;
+      last_line = sal.line;
+    }
+
+  do_cleanups (ui_out_chain);
+  do_cleanups (cleanups);
+}
 
 static void
 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
@@ -355,7 +699,7 @@ do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 
   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
-                              flags, stb);
+                              flags, stb, NULL);
 
   do_cleanups (ui_out_chain);
 }
@@ -418,19 +762,19 @@ gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
   symtab = find_pc_line_symtab (low);
 
   if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
-    {
-      /* Convert the linetable to a bunch of my_line_entry's.  */
-      le = SYMTAB_LINETABLE (symtab)->item;
-      nlines = SYMTAB_LINETABLE (symtab)->nitems;
-    }
+    nlines = SYMTAB_LINETABLE (symtab)->nitems;
 
-  if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
-      || symtab == NULL || SYMTAB_LINETABLE (symtab) == NULL)
+  if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
+      || nlines <= 0)
     do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
 
   else if (flags & DISASSEMBLY_SOURCE)
-    do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
-				  high, symtab, how_many, flags, stb);
+    do_mixed_source_and_assembly (gdbarch, uiout, &di, symtab, low, high,
+				  how_many, flags, stb);
+
+  else if (flags & DISASSEMBLY_SOURCE_DEPRECATED)
+    do_mixed_source_and_assembly_deprecated (gdbarch, uiout, &di, symtab,
+					     low, high, how_many, flags, stb);
 
   do_cleanups (cleanups);
   gdb_flush (gdb_stdout);