]> Git Repo - binutils.git/blob - gdb/disasm.h
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / disasm.h
1 /* Disassemble support for GDB.
2    Copyright (C) 2002-2022 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
This page took 0.032513 seconds and 4 git commands to generate.