gdb/disasm.h

   1 /* Disassemble support for GDB.
   2    Copyright (C) 2002-2021 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifndef DISASM_H
  20 #define DISASM_H
  21
  22 #include "dis-asm.h"
  23 #include "gdbsupport/enum-flags.h"
  24
  25 enum gdb_disassembly_flag
  26   {
  27     DISASSEMBLY_SOURCE_DEPRECATED = (0x1 << 0),
  28     DISASSEMBLY_RAW_INSN = (0x1 << 1),
  29     DISASSEMBLY_OMIT_FNAME = (0x1 << 2),
  30     DISASSEMBLY_FILENAME = (0x1 << 3),
  31     DISASSEMBLY_OMIT_PC = (0x1 << 4),
  32     DISASSEMBLY_SOURCE = (0x1 << 5),
  33     DISASSEMBLY_SPECULATIVE = (0x1 << 6),
  34   };
  35 DEF_ENUM_FLAGS_TYPE (enum gdb_disassembly_flag, gdb_disassembly_flags);
  36
  37 struct gdbarch;
  38 struct ui_out;
  39 struct ui_file;
  40
  41 class gdb_disassembler
  42 {
  43   using di_read_memory_ftype = decltype (disassemble_info::read_memory_func);
  44
  45 public:
  46   gdb_disassembler (struct gdbarch *gdbarch, struct ui_file *file)
  47     : gdb_disassembler (gdbarch, file, dis_asm_read_memory)
  48   {}
  49
  50   ~gdb_disassembler ();
  51
  52   DISABLE_COPY_AND_ASSIGN (gdb_disassembler);
  53
  54   int print_insn (CORE_ADDR memaddr, int *branch_delay_insns = NULL);
  55
  56   /* Return the gdbarch of gdb_disassembler.  */
  57   struct gdbarch *arch ()
  58   { return m_gdbarch; }
  59
  60 protected:
  61   gdb_disassembler (struct gdbarch *gdbarch, struct ui_file *file,
  62                     di_read_memory_ftype func);
  63
  64   struct ui_file *stream ()
  65   { return (struct ui_file *) m_di.stream; }
  66
  67 private:
  68   struct gdbarch *m_gdbarch;
  69
  70   /* Stores data required for disassembling instructions in
  71      opcodes.  */
  72   struct disassemble_info m_di;
  73
  74   /* If we own the string in `m_di.disassembler_options', we do so
  75      using this field.  */
  76   std::string m_disassembler_options_holder;
  77
  78   /* This member variable is given a value by calling dis_asm_memory_error.
  79      If after calling into the libopcodes disassembler we get back a
  80      negative value (which indicates an error), then, if this variable has
  81      a value, we report a memory error to the user, otherwise, we report a
  82      non-memory error.  */
  83   gdb::optional<CORE_ADDR> m_err_memaddr;
  84
  85   static int dis_asm_fprintf (void *stream, const char *format, ...)
  86     ATTRIBUTE_PRINTF(2,3);
  87
  88   static int dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr,
  89                                   unsigned int len,
  90                                   struct disassemble_info *info);
  91   static void dis_asm_memory_error (int err, bfd_vma memaddr,
  92                                     struct disassemble_info *info);
  93   static void dis_asm_print_address (bfd_vma addr,
  94                                      struct disassemble_info *info);
  95 };
  96
  97 /* An instruction to be disassembled.  */
  98
  99 struct disasm_insn
 100 {
 101   /* The address of the memory containing the instruction.  */
 102   CORE_ADDR addr;
 103
 104   /* An optional instruction number.  If non-zero, it is printed first.  */
 105   unsigned int number;
 106
 107   /* True if the instruction was executed speculatively.  */
 108   unsigned int is_speculative:1;
 109 };
 110
 111 extern void gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 112                              gdb_disassembly_flags flags, int how_many,
 113                              CORE_ADDR low, CORE_ADDR high);
 114
 115 /* Print the instruction at address MEMADDR in debugged memory,
 116    on STREAM.  Returns the length of the instruction, in bytes,
 117    and, if requested, the number of branch delay slot instructions.  */
 118
 119 extern int gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 120                            struct ui_file *stream, int *branch_delay_insns);
 121
 122 /* Class used to pretty-print instructions.  */
 123
 124 class gdb_pretty_print_disassembler
 125 {
 126 public:
 127   explicit gdb_pretty_print_disassembler (struct gdbarch *gdbarch,
 128                                           struct ui_out *uiout)
 129     : m_uiout (uiout),
 130       m_insn_stb (uiout->can_emit_style_escape ()),
 131       m_di (gdbarch, &m_insn_stb)
 132   {}
 133
 134   /* Prints the instruction INSN into the saved ui_out and returns the
 135      length of the printed instruction in bytes.  */
 136   int pretty_print_insn (const struct disasm_insn *insn,
 137                          gdb_disassembly_flags flags);
 138
 139 private:
 140   /* Returns the architecture used for disassembling.  */
 141   struct gdbarch *arch () { return m_di.arch (); }
 142
 143   /* The ui_out that is used by pretty_print_insn.  */
 144   struct ui_out *m_uiout;
 145
 146   /* The buffer used to build the instruction string.  The
 147      disassembler is initialized with this stream.  */
 148   string_file m_insn_stb;
 149
 150   /* The disassembler used for instruction printing.  */
 151   gdb_disassembler m_di;
 152
 153   /* The buffer used to build the raw opcodes string.  */
 154   string_file m_opcode_stb;
 155 };
 156
 157 /* Return the length in bytes of the instruction at address MEMADDR in
 158    debugged memory.  */
 159
 160 extern int gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR memaddr);
 161
 162 /* Return the length in bytes of INSN, originally at MEMADDR.  MAX_LEN
 163    is the size of the buffer containing INSN.  */
 164
 165 extern int gdb_buffered_insn_length (struct gdbarch *gdbarch,
 166                                      const gdb_byte *insn, int max_len,
 167                                      CORE_ADDR memaddr);
 168
 169 /* Returns GDBARCH's disassembler options.  */
 170
 171 extern char *get_disassembler_options (struct gdbarch *gdbarch);
 172
 173 /* Sets the active gdbarch's disassembler options to OPTIONS.  */
 174
 175 extern void set_disassembler_options (const char *options);
 176
 177 #endif