GDB 7.6.50

gdb/disasm.c

 /* Disassemble support for GDB.
 
-   Copyright (C) 2000-2005, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2000-2013 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 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    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, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "target.h"
 #include "value.h"
 #include "ui-out.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "disasm.h"
 #include "gdbcore.h"
 #include "dis-asm.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.
    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
 {
   int line;
   CORE_ADDR start_pc;
   CORE_ADDR end_pc;
 };
 
 /* Like target_read_memory, but slightly different parameters.  */
 static int
 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
                      struct disassemble_info *info)
 {
-  return target_read_memory (memaddr, myaddr, len);
+  return target_read_code (memaddr, myaddr, len);
 }
 
 /* Like memory_error with slightly different parameters.  */
 static void
 dis_asm_memory_error (int status, bfd_vma memaddr,
                       struct disassemble_info *info)
 {
   memory_error (status, memaddr);
 }
 
@@ skipping 54 matching lines @@
 
       QUIT;
       if (how_many >= 0)
         {
           if (num_displayed >= how_many)
             break;
           else
             num_displayed++;
         }
       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-      ui_out_text (uiout, pc_prefix (pc));
+
+      if ((flags & DISASSEMBLY_OMIT_PC) == 0)
+        ui_out_text (uiout, pc_prefix (pc));
       ui_out_field_core_addr (uiout, "address", gdbarch, pc);
 
       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.  */
           ui_out_text (uiout, " <");
           if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
             ui_out_field_string (uiout, "func-name", name);
@@ skipping 61 matching lines @@
                               struct symtab *symtab,
                               int how_many, int flags, struct ui_file *stb)
 {
   int newlines = 0;
   struct dis_line_entry *mle;
   struct symtab_and_line sal;
   int i;
   int out_of_order = 0;
   int next_line = 0;
   int num_displayed = 0;
+  enum 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);
 
+  if (flags & DISASSEMBLY_FILENAME)
+    psl_flags |= PRINT_SOURCE_LINES_FILENAME;
+
   mle = (struct dis_line_entry *) alloca (nlines
                                           * sizeof (struct dis_line_entry));
 
   /* Copy linetable entries for this function into our data
      structure, creating end_pc's and setting out_of_order as
      appropriate.  */
 
   /* First, skip all the preceding functions.  */
 
   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
@@ skipping 47 matching lines @@
       if (mle[i].line >= next_line)
         {
           if (next_line != 0)
             {
               /* 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.  */
                   for (; next_line < mle[i].line; next_line++)
                     {
                       struct cleanup *ui_out_list_chain_line;
                       struct cleanup *ui_out_tuple_chain_line;
                       
                       ui_out_tuple_chain_line
                         = 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");
                       do_cleanups (ui_out_list_chain_line);
                       do_cleanups (ui_out_tuple_chain_line);
                     }
                   /* Print the last line and leave list open for
                      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);
+              print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
             }
 
           next_line = mle[i].line + 1;
           ui_out_list_chain
             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
         }
 
       num_displayed += dump_insns (gdbarch, uiout, di,
                                    mle[i].start_pc, mle[i].end_pc,
                                    how_many, flags, stb);
@@ skipping 197 matching lines @@
 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);
 }