1 /* Scheme interface to architecture.
3 Copyright (C) 2014-2019 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 /* See README file in this directory for implementation notes, coding
21 conventions, et.al. */
24 #include "arch-utils.h"
28 #include "gdbcore.h" /* Why is memory_error here? */
29 #include "guile-internal.h"
31 static SCM port_keyword;
32 static SCM offset_keyword;
33 static SCM size_keyword;
34 static SCM count_keyword;
36 static SCM address_symbol;
37 static SCM asm_symbol;
38 static SCM length_symbol;
40 class gdbscm_disassembler : public gdb_disassembler
43 gdbscm_disassembler (struct gdbarch *gdbarch,
44 struct ui_file *stream,
45 SCM port, ULONGEST offset);
48 /* The offset of the address of the first instruction in PORT. */
52 /* Struct used to pass data from gdbscm_disasm_read_memory to
53 gdbscm_disasm_read_memory_worker. */
55 struct gdbscm_disasm_read_data
60 gdbscm_disassembler *dinfo;
63 /* Subroutine of gdbscm_arch_disassemble to simplify it.
64 Return the result for one instruction. */
67 dascm_make_insn (CORE_ADDR pc, const char *assembly, int insn_len)
69 return scm_list_3 (scm_cons (address_symbol,
70 gdbscm_scm_from_ulongest (pc)),
72 gdbscm_scm_from_c_string (assembly)),
73 scm_cons (length_symbol,
74 scm_from_int (insn_len)));
77 /* Helper function for gdbscm_disasm_read_memory to safely read from a
78 Scheme port. Called via gdbscm_call_guile.
79 The result is a statically allocated error message or NULL if success. */
82 gdbscm_disasm_read_memory_worker (void *datap)
84 struct gdbscm_disasm_read_data *data
85 = (struct gdbscm_disasm_read_data *) datap;
86 gdbscm_disassembler *dinfo = data->dinfo;
87 SCM seekto, newpos, port = dinfo->port;
90 seekto = gdbscm_scm_from_ulongest (data->memaddr - dinfo->offset);
91 newpos = scm_seek (port, seekto, scm_from_int (SEEK_SET));
92 if (!scm_is_eq (seekto, newpos))
95 bytes_read = scm_c_read (port, data->myaddr, data->length);
97 if (bytes_read != data->length)
100 /* If we get here the read succeeded. */
104 /* disassemble_info.read_memory_func for gdbscm_print_insn_from_port. */
107 gdbscm_disasm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
109 struct disassemble_info *dinfo)
111 gdbscm_disassembler *self
112 = static_cast<gdbscm_disassembler *> (dinfo->application_data);
113 struct gdbscm_disasm_read_data data;
116 data.memaddr = memaddr;
117 data.myaddr = myaddr;
118 data.length = length;
121 status = gdbscm_with_guile (gdbscm_disasm_read_memory_worker, &data);
123 /* TODO: IWBN to distinguish problems reading target memory versus problems
124 with the port (e.g., EOF). */
125 return status != NULL ? -1 : 0;
128 gdbscm_disassembler::gdbscm_disassembler (struct gdbarch *gdbarch,
129 struct ui_file *stream,
130 SCM port_, ULONGEST offset_)
131 : gdb_disassembler (gdbarch, stream, gdbscm_disasm_read_memory),
132 port (port_), offset (offset_)
136 /* Subroutine of gdbscm_arch_disassemble to simplify it.
137 Call gdbarch_print_insn using a port for input.
138 PORT must be seekable.
139 OFFSET is the offset in PORT from which addresses begin.
140 For example, when printing from a bytevector, addresses passed to the
141 bv seek routines must be in the range [0,size). However, the bytevector
142 may represent an instruction at address 0x1234. To handle this case pass
144 This is based on gdb_print_insn, see it for details. */
147 gdbscm_print_insn_from_port (struct gdbarch *gdbarch,
148 SCM port, ULONGEST offset, CORE_ADDR memaddr,
149 string_file *stream, int *branch_delay_insns)
151 gdbscm_disassembler di (gdbarch, stream, port, offset);
153 return di.print_insn (memaddr, branch_delay_insns);
156 /* (arch-disassemble <gdb:arch> address
157 [#:port port] [#:offset address] [#:size integer] [#:count integer])
160 Returns a list of disassembled instructions.
161 If PORT is provided, read bytes from it. Otherwise read target memory.
162 If PORT is #f, read target memory.
163 PORT must be seekable. IWBN to remove this restriction, and a future
164 release may. For now the restriction is in place because it's not clear
165 all disassemblers are strictly sequential.
166 If SIZE is provided, limit the number of bytes read to this amount.
167 If COUNT is provided, limit the number of instructions to this amount.
169 Each instruction in the result is an alist:
170 (('address . address) ('asm . disassembly) ('length . length)).
171 We could use a hash table (dictionary) but there aren't that many fields. */
174 gdbscm_arch_disassemble (SCM self, SCM start_scm, SCM rest)
177 = arscm_get_arch_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
178 struct gdbarch *gdbarch = arscm_get_gdbarch (a_smob);
179 const SCM keywords[] = {
180 port_keyword, offset_keyword, size_keyword, count_keyword, SCM_BOOL_F
182 int port_arg_pos = -1, offset_arg_pos = -1;
183 int size_arg_pos = -1, count_arg_pos = -1;
184 SCM port = SCM_BOOL_F;
186 unsigned int count = 1;
189 CORE_ADDR start, end;
195 gdbscm_parse_function_args (FUNC_NAME, SCM_ARG2, keywords, "U#OUuu",
196 start_scm, &start_arg, rest,
197 &port_arg_pos, &port,
198 &offset_arg_pos, &offset,
199 &size_arg_pos, &size,
200 &count_arg_pos, &count);
201 /* START is first stored in a ULONGEST because we don't have a format char
202 for CORE_ADDR, and it's not really worth it to have one yet. */
205 if (port_arg_pos > 0)
207 SCM_ASSERT_TYPE (gdbscm_is_false (port)
208 || gdbscm_is_true (scm_input_port_p (port)),
209 port, port_arg_pos, FUNC_NAME, _("input port"));
211 using_port = gdbscm_is_true (port);
213 if (offset_arg_pos > 0
215 || gdbscm_is_false (port)))
217 gdbscm_out_of_range_error (FUNC_NAME, offset_arg_pos,
218 gdbscm_scm_from_ulongest (offset),
219 _("offset provided but port is missing"));
222 if (size_arg_pos > 0)
226 /* For now be strict about start+size overflowing. If it becomes
227 a nuisance we can relax things later. */
228 if (start + size < start)
230 gdbscm_out_of_range_error (FUNC_NAME, 0,
231 scm_list_2 (gdbscm_scm_from_ulongest (start),
232 gdbscm_scm_from_ulongest (size)),
233 _("start+size overflows"));
235 end = start + size - 1;
238 end = ~(CORE_ADDR) 0;
245 for (pc = start, i = 0; pc <= end && i < count; )
254 insn_len = gdbscm_print_insn_from_port (gdbarch, port, offset,
258 insn_len = gdb_print_insn (gdbarch, pc, &buf, NULL);
260 CATCH (except, RETURN_MASK_ALL)
262 GDBSCM_HANDLE_GDB_EXCEPTION (except);
266 result = scm_cons (dascm_make_insn (pc, buf.c_str (), insn_len),
273 return scm_reverse_x (result, SCM_EOL);
276 /* Initialize the Scheme architecture support. */
278 static const scheme_function disasm_functions[] =
280 { "arch-disassemble", 2, 0, 1, as_a_scm_t_subr (gdbscm_arch_disassemble),
282 Return list of disassembled instructions in memory.\n\
284 Arguments: <gdb:arch> start-address\n\
285 [#:port port] [#:offset address]\n\
286 [#:size <integer>] [#:count <integer>]\n\
287 port: If non-#f, it is an input port to read bytes from.\n\
288 offset: Specifies the address offset of the first byte in the port.\n\
289 This is useful if the input is from something other than memory\n\
290 (e.g., a bytevector) and you want the result to be as if the bytes\n\
291 came from that address. The value to pass for start-address is\n\
292 then also the desired disassembly address, not the offset in, e.g.,\n\
294 size: Limit the number of bytes read to this amount.\n\
295 count: Limit the number of instructions to this amount.\n\
298 Each instruction in the result is an alist:\n\
299 (('address . address) ('asm . disassembly) ('length . length))." },
305 gdbscm_initialize_disasm (void)
307 gdbscm_define_functions (disasm_functions, 1);
309 port_keyword = scm_from_latin1_keyword ("port");
310 offset_keyword = scm_from_latin1_keyword ("offset");
311 size_keyword = scm_from_latin1_keyword ("size");
312 count_keyword = scm_from_latin1_keyword ("count");
314 address_symbol = scm_from_latin1_symbol ("address");
315 asm_symbol = scm_from_latin1_symbol ("asm");
316 length_symbol = scm_from_latin1_symbol ("length");