[LynxOS] Remove handling of PTRACE_* values removed in Lynx5.

[binutils.git] / gdb / disasm.c

diff --git a/gdb/disasm.c b/gdb/disasm.c
index 44ad5459925cd0fb3a086153f1a2b159a248c98d..c51f0bf5ccf1cf220d8b1d3c525bcb5239e096b2 100644 (file)
--- a/gdb/disasm.c
+++ b/gdb/disasm.c
@@ -1,12 +1,13 @@
 /* Disassemble support for GDB.
 
 /* Disassemble support for GDB.
 

-   Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
+   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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -15,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "target.h"
 
 #include "defs.h"
 #include "target.h"


@@ -26,6 +25,7 @@
 #include "gdb_string.h"
 #include "disasm.h"
 #include "gdbcore.h"
 #include "gdb_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
 
 /* Disassemble functions.
    FIXME: We should get rid of all the duplicate code in gdb that does


@@ -45,15 +45,16 @@ struct dis_line_entry
 
 /* Like target_read_memory, but slightly different parameters.  */
 static int
 
 /* Like target_read_memory, but slightly different parameters.  */
 static int

-dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
-                    disassemble_info *info)
+dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
+                    struct disassemble_info *info)

 {
 {

-  return target_read_memory (memaddr, (char *) myaddr, len);
+  return target_read_memory (memaddr, myaddr, len);

 }
 
 /* Like memory_error with slightly different parameters.  */
 static void
 }
 
 /* Like memory_error with slightly different parameters.  */
 static void

-dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
+dis_asm_memory_error (int status, bfd_vma memaddr,
+                     struct disassemble_info *info)

 {
   memory_error (status, memaddr);
 }
 {
   memory_error (status, memaddr);
 }


@@ -62,7 +63,9 @@ dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
 static void
 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 {
 static void
 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 {

-  print_address (addr, info->stream);
+  struct gdbarch *gdbarch = info->application_data;
+
+  print_address (gdbarch, addr, info->stream);

 }
 
 static int
 }
 
 static int


@@ -83,9 +86,10 @@ compare_lines (const void *mle1p, const void *mle2p)
 }
 
 static int
 }
 
 static int

-dump_insns (struct ui_out *uiout, disassemble_info * di,
+dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
+           struct disassemble_info * di,

            CORE_ADDR low, CORE_ADDR high,
            CORE_ADDR low, CORE_ADDR high,

-           int how_many, struct ui_stream *stb)
+           int how_many, int flags, struct ui_stream *stb)

 {
   int num_displayed = 0;
   CORE_ADDR pc;
 {
   int num_displayed = 0;
   CORE_ADDR pc;


@@ -110,26 +114,48 @@ dump_insns (struct ui_out *uiout, disassemble_info * di,
            num_displayed++;
        }
       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
            num_displayed++;
        }
       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

-      ui_out_field_core_addr (uiout, "address", pc);
+      ui_out_text (uiout, pc_prefix (pc));
+      ui_out_field_core_addr (uiout, "address", gdbarch, pc);

 
 

-      if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
+      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, " <");
                                   &line, &unmapped))
        {
          /* 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);
+         if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
+           ui_out_field_string (uiout, "func-name", name);

          ui_out_text (uiout, "+");
          ui_out_field_int (uiout, "offset", offset);
          ui_out_text (uiout, ">:\t");
        }
          ui_out_text (uiout, "+");
          ui_out_field_int (uiout, "offset", offset);
          ui_out_text (uiout, ">:\t");
        }

+      else
+       ui_out_text (uiout, ":\t");
+

       if (filename != NULL)
        xfree (filename);
       if (name != NULL)
        xfree (name);
 
       ui_file_rewind (stb->stream);
       if (filename != NULL)
        xfree (filename);
       if (name != NULL)
        xfree (name);
 
       ui_file_rewind (stb->stream);

-      pc += TARGET_PRINT_INSN (pc, di);
+      if (flags & DISASSEMBLY_RAW_INSN)
+        {
+          CORE_ADDR old_pc = pc;
+          bfd_byte data;
+          int status;
+
+          pc += gdbarch_print_insn (gdbarch, pc, di);
+          for (;old_pc < pc; old_pc++)
+            {
+              status = (*di->read_memory_func) (old_pc, &data, 1, di);
+              if (status != 0)
+                (*di->memory_error_func) (status, old_pc, di);
+              ui_out_message (uiout, 0, " %02x", (unsigned)data);
+            }
+          ui_out_text (uiout, "\t");
+        }
+      else
+        pc += gdbarch_print_insn (gdbarch, pc, di);

       ui_out_field_stream (uiout, "inst", stb);
       ui_file_rewind (stb->stream);
       do_cleanups (ui_out_chain);
       ui_out_field_stream (uiout, "inst", stb);
       ui_file_rewind (stb->stream);
       do_cleanups (ui_out_chain);


@@ -143,12 +169,12 @@ dump_insns (struct ui_out *uiout, disassemble_info * di,
    in source order, with (possibly) out of order assembly
    immediately following.  */
 static void
    in source order, with (possibly) out of order assembly
    immediately following.  */
 static void

-do_mixed_source_and_assembly (struct ui_out *uiout,
+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,
                              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)
+                             int how_many, int flags, struct ui_stream *stb)

 {
   int newlines = 0;
   struct dis_line_entry *mle;
 {
   int newlines = 0;
   struct dis_line_entry *mle;


@@ -156,9 +182,10 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
   int i;
   int out_of_order = 0;
   int next_line = 0;
   int i;
   int out_of_order = 0;
   int next_line = 0;

-  CORE_ADDR pc;

   int num_displayed = 0;
   struct cleanup *ui_out_chain;
   int num_displayed = 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));
 
   mle = (struct dis_line_entry *) alloca (nlines
                                          * sizeof (struct dis_line_entry));


@@ -216,10 +243,6 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
 
   for (i = 0; i < newlines; i++)
     {
 
   for (i = 0; i < newlines; i++)
     {

-      struct cleanup *ui_out_tuple_chain = NULL;
-      struct cleanup *ui_out_list_chain = NULL;
-      int close_list = 1;
-      

       /* Print out everything from next_line to the current line.  */
       if (mle[i].line >= next_line)
        {
       /* Print out everything from next_line to the current line.  */
       if (mle[i].line >= next_line)
        {


@@ -270,74 +293,100 @@ do_mixed_source_and_assembly (struct ui_out *uiout,
          next_line = mle[i].line + 1;
          ui_out_list_chain
            = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
          next_line = mle[i].line + 1;
          ui_out_list_chain
            = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");

-         /* Don't close the list if the lines are not in order. */
-         if (i < (newlines - 1) && mle[i + 1].line <= mle[i].line)
-           close_list = 0;

        }
 
        }
 

-      num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
-                                  how_many, stb);
-      if (close_list)
+      num_displayed += dump_insns (gdbarch, uiout, di,
+                                  mle[i].start_pc, mle[i].end_pc,
+                                  how_many, flags, stb);
+
+      /* 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.  */
+      if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)

        {
          do_cleanups (ui_out_list_chain);
          do_cleanups (ui_out_tuple_chain);
        {
          do_cleanups (ui_out_list_chain);
          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");
          ui_out_text (uiout, "\n");

-         close_list = 0;

        }
        }

-      if (how_many >= 0)
-       if (num_displayed >= how_many)
-         break;
+      if (how_many >= 0 && num_displayed >= how_many)
+       break;

     }
   do_cleanups (ui_out_chain);
 }
 
 
 static void
     }
   do_cleanups (ui_out_chain);
 }
 
 
 static void

-do_assembly_only (struct ui_out *uiout, disassemble_info * di,
+do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
+                 struct disassemble_info * di,

                  CORE_ADDR low, CORE_ADDR high,
                  CORE_ADDR low, CORE_ADDR high,

-                 int how_many, struct ui_stream *stb)
+                 int how_many, int flags, struct ui_stream *stb)

 {
   int num_displayed = 0;
   struct cleanup *ui_out_chain;
 
   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 
 {
   int num_displayed = 0;
   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);
+  num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
+                              flags, stb);

 
   do_cleanups (ui_out_chain);
 }
 
 
   do_cleanups (ui_out_chain);
 }
 

-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)
+/* Initialize the disassemble info struct ready for the specified
+   stream.  */
+
+static int ATTRIBUTE_PRINTF (2, 3)
+fprintf_disasm (void *stream, const char *format, ...)

 {
 {

-  struct ui_stream *stb = ui_out_stream_new (uiout);
-  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
-  disassemble_info di;
-  /* To collect the instruction outputted from opcodes. */
-  struct symtab *symtab = NULL;
-  struct linetable_entry *le = NULL;
-  int nlines = -1;
+  va_list args;
+
+  va_start (args, format);
+  vfprintf_filtered (stream, format, args);
+  va_end (args);
+  /* Something non -ve.  */
+  return 0;
+}

 
 

-  INIT_DISASSEMBLE_INFO_NO_ARCH (di, stb->stream,
-                                (fprintf_ftype) fprintf_unfiltered);
+static struct disassemble_info
+gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
+{
+  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;
   /* 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
   di.flavour = bfd_target_unknown_flavour;
   di.memory_error_func = dis_asm_memory_error;
   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

-     was a growing list of exceptions though).  Unfortunatly, the
+     was a growing list of exceptions though).  Unfortunately, the

      heuristic was flawed.  Commands like "disassemble &variable"
      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;
      heuristic was flawed.  Commands like "disassemble &variable"
      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.mach = gdbarch_bfd_arch_info (current_gdbarch)->mach;
-  di.endian = gdbarch_byte_order (current_gdbarch);
+  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);
+  di.application_data = gdbarch;
+  disassemble_init_for_target (&di);
+  return di;
+}
+
+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_stream *stb = ui_out_stream_new (uiout);
+  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
+  struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
+  /* To collect the instruction outputted from opcodes. */
+  struct symtab *symtab = NULL;
+  struct linetable_entry *le = NULL;
+  int nlines = -1;

 
   /* Assume symtab is valid for whole PC range */
   symtab = find_pc_symtab (low);
 
   /* Assume symtab is valid for whole PC range */
   symtab = find_pc_symtab (low);


@@ -349,32 +398,110 @@ gdb_disassembly (struct ui_out *uiout,
       nlines = symtab->linetable->nitems;
     }
 
       nlines = symtab->linetable->nitems;
     }
 

-  if (!mixed_source_and_assembly || nlines <= 0
+  if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0

       || symtab == NULL || symtab->linetable == NULL)
       || symtab == NULL || symtab->linetable == NULL)

-    do_assembly_only (uiout, &di, low, high, how_many, stb);
+    do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);

 
 

-  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, nlines, le, low,
+                                 high, symtab, how_many, flags, stb);

 
   do_cleanups (cleanups);
   gdb_flush (gdb_stdout);
 }
 
 
   do_cleanups (cleanups);
   gdb_flush (gdb_stdout);
 }
 

-\f
-/* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
-   is going away.  */
-disassemble_info deprecated_tm_print_insn_info;
+/* Print the instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns the length of the instruction, in bytes,
+   and, if requested, the number of branch delay slot instructions.  */

 
 

-extern void _initialize_disasm (void);
+int
+gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
+               struct ui_file *stream, int *branch_delay_insns)
+{
+  struct disassemble_info di;
+  int length;

 
 

-void
-_initialize_disasm (void)
+  di = gdb_disassemble_info (gdbarch, stream);
+  length = gdbarch_print_insn (gdbarch, memaddr, &di);
+  if (branch_delay_insns)
+    {
+      if (di.insn_info_valid)
+       *branch_delay_insns = di.branch_delay_insns;
+      else
+       *branch_delay_insns = 0;
+    }
+  return length;
+}
+
+static void
+do_ui_file_delete (void *arg)
+{
+  ui_file_delete (arg);
+}
+
+/* Return the length in bytes of the instruction at address MEMADDR in
+   debugged memory.  */
+
+int
+gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+  static struct ui_file *null_stream = NULL;
+
+  /* Dummy file descriptor for the disassembler.  */
+  if (!null_stream)
+    {
+      null_stream = ui_file_new ();
+      make_final_cleanup (do_ui_file_delete, null_stream);
+    }
+
+  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_NO_ARCH (deprecated_tm_print_insn_info, gdb_stdout,
-                                (fprintf_ftype)fprintf_filtered);
-  deprecated_tm_print_insn_info.flavour = bfd_target_unknown_flavour;
-  deprecated_tm_print_insn_info.read_memory_func = dis_asm_read_memory;
-  deprecated_tm_print_insn_info.memory_error_func = dis_asm_memory_error;
-  deprecated_tm_print_insn_info.print_address_func = dis_asm_print_address;
+  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);

 }
 }