gdb/disasm.c - gdb

Data types defined

Functions defined

Source code

  1. /* Disassemble support for GDB.

  3.    Copyright (C) 2000-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "defs.h"
  21. #include "target.h"
  22. #include "value.h"
  23. #include "ui-out.h"
  24. #include "disasm.h"
  25. #include "gdbcore.h"
  26. #include "dis-asm.h"

  28. /* Disassemble functions.
  29.    FIXME: We should get rid of all the duplicate code in gdb that does
  30.    the same thing: disassemble_command() and the gdbtk variation.  */

  32. /* This Structure is used to store line number information.
  33.    We need a different sort of line table from the normal one cuz we can't
  34.    depend upon implicit line-end pc's for lines to do the
  35.    reordering in this function.  */

  37. ‌struct dis_line_entry
  38. {
  39.   int line;
  40.   CORE_ADDR start_pc;
  41.   CORE_ADDR end_pc;
  42. };

  44. /* Like target_read_memory, but slightly different parameters.  */
  45. static int
  46. ‌dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
  47.                      struct disassemble_info *info)
  48. {
  49.   return target_read_code (memaddr, myaddr, len);
  50. }

  52. /* Like memory_error with slightly different parameters.  */
  53. static void
  54. ‌dis_asm_memory_error (int status, bfd_vma memaddr,
  55.                       struct disassemble_info *info)
  56. {
  57.   memory_error (status, memaddr);
  58. }

  60. /* Like print_address with slightly different parameters.  */
  61. static void
  62. ‌dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
  63. {
  64.   struct gdbarch *gdbarch = info->application_data;

  66.   print_address (gdbarch, addr, info->stream);
  67. }

  69. static int
  70. ‌compare_lines (const void *mle1p, const void *mle2p)
  71. {
  72.   struct dis_line_entry *mle1, *mle2;
  73.   int val;

  75.   mle1 = (struct dis_line_entry *) mle1p;
  76.   mle2 = (struct dis_line_entry *) mle2p;

  78.   /* End of sequence markers have a line number of 0 but don't want to
  79.      be sorted to the head of the list, instead sort by PC.  */
  80.   if (mle1->line == 0 || mle2->line == 0)
  81.     {
  82.       val = mle1->start_pc - mle2->start_pc;
  83.       if (val == 0)
  84.         val = mle1->line - mle2->line;
  85.     }
  86.   else
  87.     {
  88.       val = mle1->line - mle2->line;
  89.       if (val == 0)
  90.         val = mle1->start_pc - mle2->start_pc;
  91.     }
  92.   return val;
  93. }

  95. static int
  96. ‌dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
  97.             struct disassemble_info * di,
  98.             CORE_ADDR low, CORE_ADDR high,
  99.             int how_many, int flags, struct ui_file *stb)
  100. {
  101.   int num_displayed = 0;
  102.   CORE_ADDR pc;

  104.   /* parts of the symbolic representation of the address */
  105.   int unmapped;
  106.   int offset;
  107.   int line;
  108.   struct cleanup *ui_out_chain;

  110.   for (pc = low; pc < high;)
  111.     {
  112.       char *filename = NULL;
  113.       char *name = NULL;

  115.       QUIT;
  116.       if (how_many >= 0)
  117.         {
  118.           if (num_displayed >= how_many)
  119.             break;
  120.           else
  121.             num_displayed++;
  122.         }
  123.       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

  125.       if ((flags & DISASSEMBLY_OMIT_PC) == 0)
  126.         ui_out_text (uiout, pc_prefix (pc));
  127.       ui_out_field_core_addr (uiout, "address", gdbarch, pc);

  129.       if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
  130.                                    &line, &unmapped))
  131.         {
  132.           /* We don't care now about line, filename and
  133.              unmapped. But we might in the future.  */
  134.           ui_out_text (uiout, " <");
  135.           if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
  136.             ui_out_field_string (uiout, "func-name", name);
  137.           ui_out_text (uiout, "+");
  138.           ui_out_field_int (uiout, "offset", offset);
  139.           ui_out_text (uiout, ">:\t");
  140.         }
  141.       else
  142.         ui_out_text (uiout, ":\t");

  144.       if (filename != NULL)
  145.         xfree (filename);
  146.       if (name != NULL)
  147.         xfree (name);

  149.       ui_file_rewind (stb);
  150.       if (flags & DISASSEMBLY_RAW_INSN)
  151.         {
  152.           CORE_ADDR old_pc = pc;
  153.           bfd_byte data;
  154.           int status;
  155.           const char *spacer = "";

  157.           /* Build the opcodes using a temporary stream so we can
  158.              write them out in a single go for the MI.  */
  159.           struct ui_file *opcode_stream = mem_fileopen ();
  160.           struct cleanup *cleanups =
  161.             make_cleanup_ui_file_delete (opcode_stream);

  163.           pc += gdbarch_print_insn (gdbarch, pc, di);
  164.           for (;old_pc < pc; old_pc++)
  165.             {
  166.               status = (*di->read_memory_func) (old_pc, &data, 1, di);
  167.               if (status != 0)
  168.                 (*di->memory_error_func) (status, old_pc, di);
  169.               fprintf_filtered (opcode_stream, "%s%02x",
  170.                                 spacer, (unsigned) data);
  171.               spacer = " ";
  172.             }
  173.           ui_out_field_stream (uiout, "opcodes", opcode_stream);
  174.           ui_out_text (uiout, "\t");

  176.           do_cleanups (cleanups);
  177.         }
  178.       else
  179.         pc += gdbarch_print_insn (gdbarch, pc, di);
  180.       ui_out_field_stream (uiout, "inst", stb);
  181.       ui_file_rewind (stb);
  182.       do_cleanups (ui_out_chain);
  183.       ui_out_text (uiout, "\n");
  184.     }
  185.   return num_displayed;
  186. }

  188. /* The idea here is to present a source-O-centric view of a
  189.    function to the user.  This means that things are presented
  190.    in source order, with (possibly) out of order assembly
  191.    immediately following.  */

  193. static void
  194. ‌do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
  195.                               struct disassemble_info *di, int nlines,
  196.                               struct linetable_entry *le,
  197.                               CORE_ADDR low, CORE_ADDR high,
  198.                               struct symtab *symtab,
  199.                               int how_many, int flags, struct ui_file *stb)
  200. {
  201.   int newlines = 0;
  202.   struct dis_line_entry *mle;
  203.   struct symtab_and_line sal;
  204.   int i;
  205.   int out_of_order = 0;
  206.   int next_line = 0;
  207.   int num_displayed = 0;
  208.   enum print_source_lines_flags psl_flags = 0;
  209.   struct cleanup *ui_out_chain;
  210.   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
  211.   struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);

  213.   if (flags & DISASSEMBLY_FILENAME)
  214.     psl_flags |= PRINT_SOURCE_LINES_FILENAME;

  216.   mle = (struct dis_line_entry *) alloca (nlines
  217.                                           * sizeof (struct dis_line_entry));

  219.   /* Copy linetable entries for this function into our data
  220.      structure, creating end_pc's and setting out_of_order as
  221.      appropriate.  */

  223.   /* First, skip all the preceding functions.  */

  225.   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);

  227.   /* Now, copy all entries before the end of this function.  */

  229.   for (; i < nlines - 1 && le[i].pc < high; i++)
  230.     {
  231.       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
  232.         continue;                /* Ignore duplicates.  */

  234.       /* Skip any end-of-function markers.  */
  235.       if (le[i].line == 0)
  236.         continue;

  238.       mle[newlines].line = le[i].line;
  239.       if (le[i].line > le[i + 1].line)
  240.         out_of_order = 1;
  241.       mle[newlines].start_pc = le[i].pc;
  242.       mle[newlines].end_pc = le[i + 1].pc;
  243.       newlines++;
  244.     }

  246.   /* If we're on the last line, and it's part of the function,
  247.      then we need to get the end pc in a special way.  */

  249.   if (i == nlines - 1 && le[i].pc < high)
  250.     {
  251.       mle[newlines].line = le[i].line;
  252.       mle[newlines].start_pc = le[i].pc;
  253.       sal = find_pc_line (le[i].pc, 0);
  254.       mle[newlines].end_pc = sal.end;
  255.       newlines++;
  256.     }

  258.   /* Now, sort mle by line #s (and, then by addresses within
  259.      lines).  */

  261.   if (out_of_order)
  262.     qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);

  264.   /* Now, for each line entry, emit the specified lines (unless
  265.      they have been emitted before), followed by the assembly code
  266.      for that line.  */

  268.   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");

  270.   for (i = 0; i < newlines; i++)
  271.     {
  272.       /* Print out everything from next_line to the current line.  */
  273.       if (mle[i].line >= next_line)
  274.         {
  275.           if (next_line != 0)
  276.             {
  277.               /* Just one line to print.  */
  278.               if (next_line == mle[i].line)
  279.                 {
  280.                   ui_out_tuple_chain
  281.                     = make_cleanup_ui_out_tuple_begin_end (uiout,
  282.                                                            "src_and_asm_line");
  283.                   print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
  284.                 }
  285.               else
  286.                 {
  287.                   /* Several source lines w/o asm instructions associated.  */
  288.                   for (; next_line < mle[i].line; next_line++)
  289.                     {
  290.                       struct cleanup *ui_out_list_chain_line;
  291.                       struct cleanup *ui_out_tuple_chain_line;

  293.                       ui_out_tuple_chain_line
  294.                         = make_cleanup_ui_out_tuple_begin_end (uiout,
  295.                                                                "src_and_asm_line");
  296.                       print_source_lines (symtab, next_line, next_line + 1,
  297.                                           psl_flags);
  298.                       ui_out_list_chain_line
  299.                         = make_cleanup_ui_out_list_begin_end (uiout,
  300.                                                               "line_asm_insn");
  301.                       do_cleanups (ui_out_list_chain_line);
  302.                       do_cleanups (ui_out_tuple_chain_line);
  303.                     }
  304.                   /* Print the last line and leave list open for
  305.                      asm instructions to be added.  */
  306.                   ui_out_tuple_chain
  307.                     = make_cleanup_ui_out_tuple_begin_end (uiout,
  308.                                                            "src_and_asm_line");
  309.                   print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
  310.                 }
  311.             }
  312.           else
  313.             {
  314.               ui_out_tuple_chain
  315.                 = make_cleanup_ui_out_tuple_begin_end (uiout,
  316.                                                        "src_and_asm_line");
  317.               print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
  318.             }

  320.           next_line = mle[i].line + 1;
  321.           ui_out_list_chain
  322.             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
  323.         }

  325.       num_displayed += dump_insns (gdbarch, uiout, di,
  326.                                    mle[i].start_pc, mle[i].end_pc,
  327.                                    how_many, flags, stb);

  329.       /* When we've reached the end of the mle array, or we've seen the last
  330.          assembly range for this source line, close out the list/tuple.  */
  331.       if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
  332.         {
  333.           do_cleanups (ui_out_list_chain);
  334.           do_cleanups (ui_out_tuple_chain);
  335.           ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
  336.           ui_out_list_chain = make_cleanup (null_cleanup, 0);
  337.           ui_out_text (uiout, "\n");
  338.         }
  339.       if (how_many >= 0 && num_displayed >= how_many)
  340.         break;
  341.     }
  342.   do_cleanups (ui_out_chain);
  343. }


  346. static void
  347. ‌do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
  348.                   struct disassemble_info * di,
  349.                   CORE_ADDR low, CORE_ADDR high,
  350.                   int how_many, int flags, struct ui_file *stb)
  351. {
  352.   int num_displayed = 0;
  353.   struct cleanup *ui_out_chain;

  355.   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");

  357.   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
  358.                               flags, stb);

  360.   do_cleanups (ui_out_chain);
  361. }

  363. /* Initialize the disassemble info struct ready for the specified
  364.    stream.  */

  366. static int ATTRIBUTE_PRINTF (2, 3)
  367. ‌fprintf_disasm (void *stream, const char *format, ...)
  368. {
  369.   va_list args;

  371.   va_start (args, format);
  372.   vfprintf_filtered (stream, format, args);
  373.   va_end (args);
  374.   /* Something non -ve.  */
  375.   return 0;
  376. }

  378. struct disassemble_info
  379. ‌gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
  380. {
  381.   struct disassemble_info di;

  383.   init_disassemble_info (&di, file, fprintf_disasm);
  384.   di.flavour = bfd_target_unknown_flavour;
  385.   di.memory_error_func = dis_asm_memory_error;
  386.   di.print_address_func = dis_asm_print_address;
  387.   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
  388.      disassembler had a local optomization here.  By default it would
  389.      access the executable file, instead of the target memory (there
  390.      was a growing list of exceptions though).  Unfortunately, the
  391.      heuristic was flawed.  Commands like "disassemble &variable"
  392.      didn't work as they relied on the access going to the target.
  393.      Further, it has been supperseeded by trust-read-only-sections
  394.      (although that should be superseeded by target_trust..._p()).  */
  395.   di.read_memory_func = dis_asm_read_memory;
  396.   di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
  397.   di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
  398.   di.endian = gdbarch_byte_order (gdbarch);
  399.   di.endian_code = gdbarch_byte_order_for_code (gdbarch);
  400.   di.application_data = gdbarch;
  401.   disassemble_init_for_target (&di);
  402.   return di;
  403. }

  405. void
  406. ‌gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
  407.                  char *file_string, int flags, int how_many,
  408.                  CORE_ADDR low, CORE_ADDR high)
  409. {
  410.   struct ui_file *stb = mem_fileopen ();
  411.   struct cleanup *cleanups = make_cleanup_ui_file_delete (stb);
  412.   struct disassemble_info di = gdb_disassemble_info (gdbarch, stb);
  413.   struct symtab *symtab;
  414.   struct linetable_entry *le = NULL;
  415.   int nlines = -1;

  417.   /* Assume symtab is valid for whole PC range.  */
  418.   symtab = find_pc_line_symtab (low);

  420.   if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
  421.     {
  422.       /* Convert the linetable to a bunch of my_line_entry's.  */
  423.       le = SYMTAB_LINETABLE (symtab)->item;
  424.       nlines = SYMTAB_LINETABLE (symtab)->nitems;
  425.     }

  427.   if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
  428.       || symtab == NULL || SYMTAB_LINETABLE (symtab) == NULL)
  429.     do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);

  431.   else if (flags & DISASSEMBLY_SOURCE)
  432.     do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
  433.                                   high, symtab, how_many, flags, stb);

  435.   do_cleanups (cleanups);
  436.   gdb_flush (gdb_stdout);
  437. }

  439. /* Print the instruction at address MEMADDR in debugged memory,
  440.    on STREAM.  Returns the length of the instruction, in bytes,
  441.    and, if requested, the number of branch delay slot instructions.  */

  443. int
  444. ‌gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
  445.                 struct ui_file *stream, int *branch_delay_insns)
  446. {
  447.   struct disassemble_info di;
  448.   int length;

  450.   di = gdb_disassemble_info (gdbarch, stream);
  451.   length = gdbarch_print_insn (gdbarch, memaddr, &di);
  452.   if (branch_delay_insns)
  453.     {
  454.       if (di.insn_info_valid)
  455.         *branch_delay_insns = di.branch_delay_insns;
  456.       else
  457.         *branch_delay_insns = 0;
  458.     }
  459.   return length;
  460. }

  462. static void
  463. ‌do_ui_file_delete (void *arg)
  464. {
  465.   ui_file_delete (arg);
  466. }

  468. /* Return the length in bytes of the instruction at address MEMADDR in
  469.    debugged memory.  */

  471. int
  472. ‌gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
  473. {
  474.   static struct ui_file *null_stream = NULL;

  476.   /* Dummy file descriptor for the disassembler.  */
  477.   if (!null_stream)
  478.     {
  479.       null_stream = ui_file_new ();
  480.       make_final_cleanup (do_ui_file_delete, null_stream);
  481.     }

  483.   return gdb_print_insn (gdbarch, addr, null_stream, NULL);
  484. }

  486. /* fprintf-function for gdb_buffered_insn_length.  This function is a
  487.    nop, we don't want to print anything, we just want to compute the
  488.    length of the insn.  */

  490. static int ATTRIBUTE_PRINTF (2, 3)
  491. ‌gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
  492. {
  493.   return 0;
  494. }

  496. /* Initialize a struct disassemble_info for gdb_buffered_insn_length.  */

  498. static void
  499. ‌gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
  500.                                    struct disassemble_info *di,
  501.                                    const gdb_byte *insn, int max_len,
  502.                                    CORE_ADDR addr)
  503. {
  504.   init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);

  506.   /* init_disassemble_info installs buffer_read_memory, etc.
  507.      so we don't need to do that here.
  508.      The cast is necessary until disassemble_info is const-ified.  */
  509.   di->buffer = (gdb_byte *) insn;
  510.   di->buffer_length = max_len;
  511.   di->buffer_vma = addr;

  513.   di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
  514.   di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
  515.   di->endian = gdbarch_byte_order (gdbarch);
  516.   di->endian_code = gdbarch_byte_order_for_code (gdbarch);

  518.   disassemble_init_for_target (di);
  519. }

  521. /* Return the length in bytes of INSN.  MAX_LEN is the size of the
  522.    buffer containing INSN.  */

  524. int
  525. ‌gdb_buffered_insn_length (struct gdbarch *gdbarch,
  526.                           const gdb_byte *insn, int max_len, CORE_ADDR addr)
  527. {
  528.   struct disassemble_info di;

  530.   gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);

  532.   return gdbarch_print_insn (gdbarch, addr, &di);
  533. }