X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdisasm.c;h=897f2f1412f366f9cd28bd35ae4d96b6f3ad196e;hb=d8b49cf0c891d09dd58de05ad5cfe396b612cf3b;hp=168d7ee04a150f1209e8e670fedb4c9544b10243;hpb=7f5c84d395320e610b6cf45e1adfe97ba3122131;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/disasm.c b/gdb/disasm.c
index 168d7ee04a..897f2f1412 100644
--- a/gdb/disasm.c
+++ b/gdb/disasm.c
@@ -1,13 +1,12 @@
 /* Disassemble support for GDB.
 
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    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 2 of the License, or
+   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,
@@ -16,160 +15,355 @@
    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, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "target.h"
 #include "value.h"
 #include "ui-out.h"
-#include "gdb_string.h"
 #include "disasm.h"
 #include "gdbcore.h"
 #include "dis-asm.h"
+#include "source.h"
+#include <algorithm>
 
 /* 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. */
+   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;
 };
 
-/* Like target_read_memory, but slightly different parameters.  */
+/* 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 = (const struct dis_line_entry *) item;
+
+  return htab_hash_pointer (dle->symtab) + dle->line;
+}
+
+/* Equal function for dis_line_entry.  */
+
 static int
-dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
-		     struct disassemble_info *info)
+eq_dis_line_entry (const void *item_lhs, const void *item_rhs)
 {
-  return target_read_memory (memaddr, myaddr, len);
+  const struct dis_line_entry *lhs = (const struct dis_line_entry *) item_lhs;
+  const struct dis_line_entry *rhs = (const struct dis_line_entry *) item_rhs;
+
+  return (lhs->symtab == rhs->symtab
+	  && lhs->line == rhs->line);
 }
 
-/* Like memory_error with slightly different parameters.  */
-static void
-dis_asm_memory_error (int status, bfd_vma memaddr,
-		      struct disassemble_info *info)
+/* Create the table to manage lines for mixed source/disassembly.  */
+
+static htab_t
+allocate_dis_line_table (void)
 {
-  memory_error (status, memaddr);
+  return htab_create_alloc (41,
+			    hash_dis_line_entry, eq_dis_line_entry,
+			    xfree, xcalloc, xfree);
 }
 
-/* Like print_address with slightly different parameters.  */
+/* Add a new dis_line_entry containing SYMTAB and LINE to TABLE.  */
+
 static void
-dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
+add_dis_line_entry (htab_t table, struct symtab *symtab, int line)
 {
-  print_address (addr, info->stream);
+  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
-compare_lines (const void *mle1p, const void *mle2p)
+line_has_code_p (htab_t table, struct symtab *symtab, int line)
 {
-  struct dis_line_entry *mle1, *mle2;
-  int val;
+  struct dis_line_entry dle;
 
-  mle1 = (struct dis_line_entry *) mle1p;
-  mle2 = (struct dis_line_entry *) mle2p;
+  dle.symtab = symtab;
+  dle.line = line;
+  return htab_find (table, &dle) != NULL;
+}
 
-  val = mle1->line - mle2->line;
+/* Wrapper of target_read_code.  */
 
-  if (val != 0)
-    return val;
+int
+gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr,
+				       unsigned int len,
+				       struct disassemble_info *info)
+{
+  return target_read_code (memaddr, myaddr, len);
+}
+
+/* Wrapper of memory_error.  */
+
+void
+gdb_disassembler::dis_asm_memory_error (int err, bfd_vma memaddr,
+					struct disassemble_info *info)
+{
+  gdb_disassembler *self
+    = static_cast<gdb_disassembler *>(info->application_data);
 
-  return mle1->start_pc - mle2->start_pc;
+  self->m_err_memaddr = memaddr;
+}
+
+/* Wrapper of print_address.  */
+
+void
+gdb_disassembler::dis_asm_print_address (bfd_vma addr,
+					 struct disassemble_info *info)
+{
+  gdb_disassembler *self
+    = static_cast<gdb_disassembler *>(info->application_data);
+
+  print_address (self->arch (), addr, self->stream ());
 }
 
 static int
-dump_insns (struct ui_out *uiout, struct disassemble_info * di,
-	    CORE_ADDR low, CORE_ADDR high,
-	    int how_many, struct ui_stream *stb)
+compare_lines (const void *mle1p, const void *mle2p)
 {
-  int num_displayed = 0;
-  CORE_ADDR pc;
+  struct deprecated_dis_line_entry *mle1, *mle2;
+  int val;
+
+  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.  */
+  if (mle1->line == 0 || mle2->line == 0)
+    {
+      val = mle1->start_pc - mle2->start_pc;
+      if (val == 0)
+        val = mle1->line - mle2->line;
+    }
+  else
+    {
+      val = mle1->line - mle2->line;
+      if (val == 0)
+        val = mle1->start_pc - mle2->start_pc;
+    }
+  return val;
+}
 
+/* See disasm.h.  */
+
+int
+gdb_disassembler::pretty_print_insn (struct ui_out *uiout,
+				     const struct disasm_insn *insn,
+				     int flags)
+{
   /* parts of the symbolic representation of the address */
   int unmapped;
   int offset;
   int line;
+  int size;
   struct cleanup *ui_out_chain;
+  char *filename = NULL;
+  char *name = NULL;
+  CORE_ADDR pc;
+  struct ui_file *stb = stream ();
+  struct gdbarch *gdbarch = arch ();
+
+  ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+  pc = insn->addr;
 
-  for (pc = low; pc < high;)
+  if (insn->number != 0)
     {
-      char *filename = NULL;
-      char *name = NULL;
+      uiout->field_fmt ("insn-number", "%u", insn->number);
+      uiout->text ("\t");
+    }
 
-      QUIT;
-      if (how_many >= 0)
+  if ((flags & DISASSEMBLY_SPECULATIVE) != 0)
+    {
+      if (insn->is_speculative)
 	{
-	  if (num_displayed >= how_many)
-	    break;
+	  uiout->field_string ("is-speculative", "?");
+
+	  /* The speculative execution indication overwrites the first
+	     character of the PC prefix.
+	     We assume a PC prefix length of 3 characters.  */
+	  if ((flags & DISASSEMBLY_OMIT_PC) == 0)
+	    uiout->text (pc_prefix (pc) + 1);
 	  else
-	    num_displayed++;
+	    uiout->text ("  ");
 	}
-      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-      ui_out_field_core_addr (uiout, "address", pc);
+      else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
+	uiout->text (pc_prefix (pc));
+      else
+	uiout->text ("   ");
+    }
+  else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
+    uiout->text (pc_prefix (pc));
+  uiout->field_core_addr ("address", gdbarch, pc);
 
-      if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
-				   &line, &unmapped))
+  if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
+			       &line, &unmapped))
+    {
+      /* We don't care now about line, filename and unmapped.  But we might in
+	 the future.  */
+      uiout->text (" <");
+      if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
+	uiout->field_string ("func-name", name);
+      uiout->text ("+");
+      uiout->field_int ("offset", offset);
+      uiout->text (">:\t");
+    }
+  else
+    uiout->text (":\t");
+
+  if (filename != NULL)
+    xfree (filename);
+  if (name != NULL)
+    xfree (name);
+
+  ui_file_rewind (stb);
+  if (flags & DISASSEMBLY_RAW_INSN)
+    {
+      CORE_ADDR end_pc;
+      bfd_byte data;
+      int err;
+      const char *spacer = "";
+
+      /* Build the opcodes using a temporary stream so we can
+	 write them out in a single go for the MI.  */
+      struct ui_file *opcode_stream = mem_fileopen ();
+      struct cleanup *cleanups =
+	make_cleanup_ui_file_delete (opcode_stream);
+
+      size = print_insn (pc);
+      end_pc = pc + size;
+
+      for (;pc < end_pc; ++pc)
 	{
-	  /* We don't care now about line, filename and
-	     unmapped. But we might in the future. */
-	  ui_out_text (uiout, " <");
-	  ui_out_field_string (uiout, "func-name", name);
-	  ui_out_text (uiout, "+");
-	  ui_out_field_int (uiout, "offset", offset);
-	  ui_out_text (uiout, ">:\t");
+	  err = m_di.read_memory_func (pc, &data, 1, &m_di);
+	  if (err != 0)
+	    m_di.memory_error_func (err, pc, &m_di);
+	  fprintf_filtered (opcode_stream, "%s%02x",
+			    spacer, (unsigned) data);
+	  spacer = " ";
 	}
-      else
-	ui_out_text (uiout, ":\t");
-
-      if (filename != NULL)
-	xfree (filename);
-      if (name != NULL)
-	xfree (name);
-
-      ui_file_rewind (stb->stream);
-      pc += gdbarch_print_insn (current_gdbarch, pc, di);
-      ui_out_field_stream (uiout, "inst", stb);
-      ui_file_rewind (stb->stream);
-      do_cleanups (ui_out_chain);
-      ui_out_text (uiout, "\n");
+
+      uiout->field_stream ("opcodes", opcode_stream);
+      uiout->text ("\t");
+
+      do_cleanups (cleanups);
     }
+  else
+    size = print_insn (pc);
+
+  uiout->field_stream ("inst", stb);
+  ui_file_rewind (stb);
+  do_cleanups (ui_out_chain);
+  uiout->text ("\n");
+
+  return size;
+}
+
+static int
+dump_insns (struct ui_out *uiout, gdb_disassembler *di,
+	    CORE_ADDR low, CORE_ADDR high,
+	    int how_many, int flags,
+	    CORE_ADDR *end_pc)
+{
+  struct disasm_insn insn;
+  int num_displayed = 0;
+
+  memset (&insn, 0, sizeof (insn));
+  insn.addr = low;
+
+  while (insn.addr < high && (how_many < 0 || num_displayed < how_many))
+    {
+      int size;
+
+      size = di->pretty_print_insn (uiout, &insn, flags);
+      if (size <= 0)
+	break;
+
+      ++num_displayed;
+      insn.addr += size;
+
+      /* Allow user to bail out with ^C.  */
+      QUIT;
+    }
+
+  if (end_pc != NULL)
+    *end_pc = insn.addr;
+
   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 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, struct ui_stream *stb)
+do_mixed_source_and_assembly_deprecated
+  (struct ui_out *uiout,
+   gdb_disassembler *di, struct symtab *symtab,
+   CORE_ADDR low, CORE_ADDR high,
+   int how_many, int flags)
 {
   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;
   int next_line = 0;
-  CORE_ADDR pc;
   int num_displayed = 0;
+  print_source_lines_flags psl_flags = 0;
   struct cleanup *ui_out_chain;
   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
   struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
 
-  mle = (struct dis_line_entry *) alloca (nlines
-					  * sizeof (struct dis_line_entry));
+  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 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
@@ -184,7 +378,7 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
   for (; i < nlines - 1 && le[i].pc < high; i++)
     {
       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
-	continue;		/* Ignore duplicates */
+	continue;		/* Ignore duplicates.  */
 
       /* Skip any end-of-function markers.  */
       if (le[i].line == 0)
@@ -210,11 +404,11 @@ do_mixed_source_and_assembly (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
@@ -229,17 +423,17 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 	{
 	  if (next_line != 0)
 	    {
-	      /* Just one line to print. */
+	      /* Just one line to print.  */
 	      if (next_line == mle[i].line)
 		{
 		  ui_out_tuple_chain
 		    = make_cleanup_ui_out_tuple_begin_end (uiout,
 							   "src_and_asm_line");
-		  print_source_lines (symtab, next_line, mle[i].line + 1, 0);
+		  print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
 		}
 	      else
 		{
-		  /* Several source lines w/o asm instructions associated. */
+		  /* Several source lines w/o asm instructions associated.  */
 		  for (; next_line < mle[i].line; next_line++)
 		    {
 		      struct cleanup *ui_out_list_chain_line;
@@ -249,7 +443,7 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 			= make_cleanup_ui_out_tuple_begin_end (uiout,
 							       "src_and_asm_line");
 		      print_source_lines (symtab, next_line, next_line + 1,
-					  0);
+					  psl_flags);
 		      ui_out_list_chain_line
 			= make_cleanup_ui_out_list_begin_end (uiout,
 							      "line_asm_insn");
@@ -257,18 +451,19 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 		      do_cleanups (ui_out_tuple_chain_line);
 		    }
 		  /* Print the last line and leave list open for
-		     asm instructions to be added. */
+		     asm instructions to be added.  */
 		  ui_out_tuple_chain
 		    = make_cleanup_ui_out_tuple_begin_end (uiout,
 							   "src_and_asm_line");
-		  print_source_lines (symtab, next_line, mle[i].line + 1, 0);
+		  print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
 		}
 	    }
 	  else
 	    {
 	      ui_out_tuple_chain
-		= make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
-	      print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
+		= make_cleanup_ui_out_tuple_begin_end (uiout,
+						       "src_and_asm_line");
+	      print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
 	    }
 
 	  next_line = mle[i].line + 1;
@@ -276,8 +471,9 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 	    = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
 	}
 
-      num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
-				   how_many, stb);
+      num_displayed += dump_insns (uiout, di,
+				   mle[i].start_pc, mle[i].end_pc,
+				   how_many, flags, 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.  */
@@ -287,7 +483,7 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 	  do_cleanups (ui_out_tuple_chain);
 	  ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 	  ui_out_list_chain = make_cleanup (null_cleanup, 0);
-	  ui_out_text (uiout, "\n");
+	  uiout->text ("\n");
 	}
       if (how_many >= 0 && num_displayed >= how_many)
 	break;
@@ -295,18 +491,261 @@ do_mixed_source_and_assembly (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_assembly_only (struct ui_out *uiout, struct disassemble_info * di,
-		  CORE_ADDR low, CORE_ADDR high,
-		  int how_many, struct ui_stream *stb)
+do_mixed_source_and_assembly (struct gdbarch *gdbarch,
+			      struct ui_out *uiout,
+			      gdb_disassembler *di,
+			      struct symtab *main_symtab,
+			      CORE_ADDR low, CORE_ADDR high,
+			      int how_many, int flags)
 {
+  const struct linetable_entry *le, *first_le;
+  int i, nlines;
   int num_displayed = 0;
+  print_source_lines_flags psl_flags = 0;
+  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;
+
+  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.  */
+
+  htab_up dis_line_table (allocate_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)
+	add_dis_line_entry (dis_line_table.get (), 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:
+     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 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.get (),
+					   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)
+	    uiout->text ("\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)
+		{
+		  uiout->text (symtab_to_filename_for_display (sal.symtab));
+		}
+	      else
+		uiout->text ("unknown");
+	      uiout->text (":\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
+	    uiout->text (_("--- 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 = std::min (sal.end, high);
+      else
+	end_pc = pc + 1;
+      num_displayed += dump_insns (uiout, di, pc, end_pc,
+				   how_many, flags, &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);
+}
+
+static void
+do_assembly_only (struct ui_out *uiout,
+		  gdb_disassembler *di,
+		  CORE_ADDR low, CORE_ADDR high,
+		  int how_many, int flags)
+{
   struct cleanup *ui_out_chain;
 
   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 
-  num_displayed = dump_insns (uiout, di, low, high, how_many, stb);
+  dump_insns (uiout, di, low, high, how_many, flags, NULL);
 
   do_cleanups (ui_out_chain);
 }
@@ -314,25 +753,28 @@ do_assembly_only (struct ui_out *uiout, struct disassemble_info * di,
 /* Initialize the disassemble info struct ready for the specified
    stream.  */
 
-static int ATTR_FORMAT (printf, 2, 3)
+static int ATTRIBUTE_PRINTF (2, 3)
 fprintf_disasm (void *stream, const char *format, ...)
 {
   va_list args;
+
   va_start (args, format);
-  vfprintf_filtered (stream, format, args);
+  vfprintf_filtered ((struct ui_file *) stream, format, args);
   va_end (args);
   /* Something non -ve.  */
   return 0;
 }
 
-static struct disassemble_info
-gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
+gdb_disassembler::gdb_disassembler (struct gdbarch *gdbarch,
+				    struct ui_file *file,
+				    di_read_memory_ftype read_memory_func)
+  : m_gdbarch (gdbarch),
+    m_err_memaddr (0)
 {
-  struct disassemble_info di;
-  init_disassemble_info (&di, file, fprintf_disasm);
-  di.flavour = bfd_target_unknown_flavour;
-  di.memory_error_func = dis_asm_memory_error;
-  di.print_address_func = dis_asm_print_address;
+  init_disassemble_info (&m_di, file, fprintf_disasm);
+  m_di.flavour = bfd_target_unknown_flavour;
+  m_di.memory_error_func = dis_asm_memory_error;
+  m_di.print_address_func = dis_asm_print_address;
   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
      disassembler had a local optomization here.  By default it would
      access the executable file, instead of the target memory (there
@@ -341,57 +783,137 @@ gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
      didn't work as they relied on the access going to the target.
      Further, it has been supperseeded by trust-read-only-sections
      (although that should be superseeded by target_trust..._p()).  */
-  di.read_memory_func = dis_asm_read_memory;
-  di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
-  di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
-  di.endian = gdbarch_byte_order (gdbarch);
-  disassemble_init_for_target (&di);
-  return di;
+  m_di.read_memory_func = read_memory_func;
+  m_di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
+  m_di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
+  m_di.endian = gdbarch_byte_order (gdbarch);
+  m_di.endian_code = gdbarch_byte_order_for_code (gdbarch);
+  m_di.application_data = this;
+  disassemble_init_for_target (&m_di);
 }
 
-void
-gdb_disassembly (struct ui_out *uiout,
-		char *file_string,
-		int line_num,
-		int mixed_source_and_assembly,
-		int how_many, CORE_ADDR low, CORE_ADDR high)
+int
+gdb_disassembler::print_insn (CORE_ADDR memaddr,
+			      int *branch_delay_insns)
 {
-  struct ui_stream *stb = ui_out_stream_new (uiout);
-  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
-  struct disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
-  /* To collect the instruction outputted from opcodes. */
-  struct symtab *symtab = NULL;
-  struct linetable_entry *le = NULL;
-  int nlines = -1;
+  m_err_memaddr = 0;
 
-  /* Assume symtab is valid for whole PC range */
-  symtab = find_pc_symtab (low);
+  int length = gdbarch_print_insn (arch (), memaddr, &m_di);
 
-  if (symtab != NULL && symtab->linetable != NULL)
+  if (length < 0)
+    memory_error (TARGET_XFER_E_IO, m_err_memaddr);
+
+  if (branch_delay_insns != NULL)
     {
-      /* Convert the linetable to a bunch of my_line_entry's.  */
-      le = symtab->linetable->item;
-      nlines = symtab->linetable->nitems;
+      if (m_di.insn_info_valid)
+	*branch_delay_insns = m_di.branch_delay_insns;
+      else
+	*branch_delay_insns = 0;
     }
+  return length;
+}
+
+void
+gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
+		 char *file_string, int flags, int how_many,
+		 CORE_ADDR low, CORE_ADDR high)
+{
+  struct ui_file *stb = mem_fileopen ();
+  struct cleanup *cleanups = make_cleanup_ui_file_delete (stb);
+  gdb_disassembler di (gdbarch, stb);
+  struct symtab *symtab;
+  int nlines = -1;
+
+  /* Assume symtab is valid for whole PC range.  */
+  symtab = find_pc_line_symtab (low);
+
+  if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
+    nlines = SYMTAB_LINETABLE (symtab)->nitems;
 
-  if (!mixed_source_and_assembly || nlines <= 0
-      || symtab == NULL || symtab->linetable == NULL)
-    do_assembly_only (uiout, &di, low, high, how_many, stb);
+  if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
+      || nlines <= 0)
+    do_assembly_only (uiout, &di, low, high, how_many, flags);
 
-  else if (mixed_source_and_assembly)
-    do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
-				  high, symtab, how_many, stb);
+  else if (flags & DISASSEMBLY_SOURCE)
+    do_mixed_source_and_assembly (gdbarch, uiout, &di, symtab, low, high,
+				  how_many, flags);
+
+  else if (flags & DISASSEMBLY_SOURCE_DEPRECATED)
+    do_mixed_source_and_assembly_deprecated (uiout, &di, symtab,
+					     low, high, how_many, flags);
 
   do_cleanups (cleanups);
   gdb_flush (gdb_stdout);
 }
 
 /* Print the instruction at address MEMADDR in debugged memory,
-   on STREAM.  Returns length of the instruction, in bytes.  */
+   on STREAM.  Returns the length of the instruction, in bytes,
+   and, if requested, the number of branch delay slot instructions.  */
+
+int
+gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
+		struct ui_file *stream, int *branch_delay_insns)
+{
+
+  gdb_disassembler di (gdbarch, stream);
+
+  return di.print_insn (memaddr, branch_delay_insns);
+}
+
+/* Return the length in bytes of the instruction at address MEMADDR in
+   debugged memory.  */
 
 int
-gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream)
+gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
-  struct disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
-  return gdbarch_print_insn (current_gdbarch, memaddr, &di);
+  return gdb_print_insn (gdbarch, addr, null_stream (), NULL);
+}
+
+/* fprintf-function for gdb_buffered_insn_length.  This function is a
+   nop, we don't want to print anything, we just want to compute the
+   length of the insn.  */
+
+static int ATTRIBUTE_PRINTF (2, 3)
+gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
+{
+  return 0;
+}
+
+/* Initialize a struct disassemble_info for gdb_buffered_insn_length.  */
+
+static void
+gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
+				   struct disassemble_info *di,
+				   const gdb_byte *insn, int max_len,
+				   CORE_ADDR addr)
+{
+  init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
+
+  /* init_disassemble_info installs buffer_read_memory, etc.
+     so we don't need to do that here.
+     The cast is necessary until disassemble_info is const-ified.  */
+  di->buffer = (gdb_byte *) insn;
+  di->buffer_length = max_len;
+  di->buffer_vma = addr;
+
+  di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
+  di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
+  di->endian = gdbarch_byte_order (gdbarch);
+  di->endian_code = gdbarch_byte_order_for_code (gdbarch);
+
+  disassemble_init_for_target (di);
+}
+
+/* Return the length in bytes of INSN.  MAX_LEN is the size of the
+   buffer containing INSN.  */
+
+int
+gdb_buffered_insn_length (struct gdbarch *gdbarch,
+			  const gdb_byte *insn, int max_len, CORE_ADDR addr)
+{
+  struct disassemble_info di;
+
+  gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
+
+  return gdbarch_print_insn (gdbarch, addr, &di);
 }