1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009, 2010, 2011 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/>. */
23 #include "breakpoint.h"
35 static const struct objfile_data
*jit_objfile_data
;
37 static const char *const jit_break_name
= "__jit_debug_register_code";
39 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
41 static const struct inferior_data
*jit_inferior_data
= NULL
;
43 /* Non-zero if we want to see trace of jit level stuff. */
45 static int jit_debug
= 0;
48 show_jit_debug (struct ui_file
*file
, int from_tty
,
49 struct cmd_list_element
*c
, const char *value
)
51 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
60 /* Openning the file is a no-op. */
63 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
68 /* Closing the file is just freeing the base/size pair on our side. */
71 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
77 /* For reading the file, we just need to pass through to target_read_memory and
78 fix up the arguments and return values. */
81 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
82 file_ptr nbytes
, file_ptr offset
)
85 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
87 /* If this read will read all of the file, limit it to just the rest. */
88 if (offset
+ nbytes
> buffer
->size
)
89 nbytes
= buffer
->size
- offset
;
91 /* If there are no more bytes left, we've reached EOF. */
95 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
102 /* For statting the file, we only support the st_size attribute. */
105 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
107 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
109 sb
->st_size
= buffer
->size
;
113 /* Open a BFD from the target's memory. */
116 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
118 const char *filename
= xstrdup ("<in-memory>");
119 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
123 return bfd_openr_iovec (filename
, target
,
131 /* Per-inferior structure recording the addresses in the inferior. */
133 struct jit_inferior_data
135 CORE_ADDR breakpoint_addr
; /* &__jit_debug_register_code() */
136 CORE_ADDR descriptor_addr
; /* &__jit_debug_descriptor */
139 /* Return jit_inferior_data for current inferior. Allocate if not already
142 static struct jit_inferior_data
*
143 get_jit_inferior_data (void)
145 struct inferior
*inf
;
146 struct jit_inferior_data
*inf_data
;
148 inf
= current_inferior ();
149 inf_data
= inferior_data (inf
, jit_inferior_data
);
150 if (inf_data
== NULL
)
152 inf_data
= XZALLOC (struct jit_inferior_data
);
153 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
160 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
165 /* Helper function for reading the global JIT descriptor from remote
169 jit_read_descriptor (struct gdbarch
*gdbarch
,
170 struct jit_descriptor
*descriptor
,
171 CORE_ADDR descriptor_addr
)
174 struct type
*ptr_type
;
178 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
180 /* Figure out how big the descriptor is on the remote and how to read it. */
181 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
182 ptr_size
= TYPE_LENGTH (ptr_type
);
183 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
184 desc_buf
= alloca (desc_size
);
186 /* Read the descriptor. */
187 err
= target_read_memory (descriptor_addr
, desc_buf
, desc_size
);
189 error (_("Unable to read JIT descriptor from remote memory!"));
191 /* Fix the endianness to match the host. */
192 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
193 descriptor
->action_flag
=
194 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
195 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
196 descriptor
->first_entry
=
197 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
200 /* Helper function for reading a JITed code entry from remote memory. */
203 jit_read_code_entry (struct gdbarch
*gdbarch
,
204 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
207 struct type
*ptr_type
;
211 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
213 /* Figure out how big the entry is on the remote and how to read it. */
214 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
215 ptr_size
= TYPE_LENGTH (ptr_type
);
216 entry_size
= 3 * ptr_size
+ 8; /* Three pointers and one 64-bit int. */
217 entry_buf
= alloca (entry_size
);
219 /* Read the entry. */
220 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
222 error (_("Unable to read JIT code entry from remote memory!"));
224 /* Fix the endianness to match the host. */
225 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
226 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
227 code_entry
->prev_entry
=
228 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
229 code_entry
->symfile_addr
=
230 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
231 code_entry
->symfile_size
=
232 extract_unsigned_integer (&entry_buf
[3 * ptr_size
], 8, byte_order
);
235 /* This function registers code associated with a JIT code entry. It uses the
236 pointer and size pair in the entry to read the symbol file from the remote
237 and then calls symbol_file_add_from_local_memory to add it as though it were
238 a symbol file added by the user. */
241 jit_register_code (struct gdbarch
*gdbarch
,
242 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
245 struct section_addr_info
*sai
;
246 struct bfd_section
*sec
;
247 struct objfile
*objfile
;
248 struct cleanup
*old_cleanups
, *my_cleanups
;
250 const struct bfd_arch_info
*b
;
251 CORE_ADDR
*entry_addr_ptr
;
254 fprintf_unfiltered (gdb_stdlog
,
255 "jit_register_code, symfile_addr = %s, "
256 "symfile_size = %s\n",
257 paddress (gdbarch
, code_entry
->symfile_addr
),
258 pulongest (code_entry
->symfile_size
));
260 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
261 code_entry
->symfile_size
, gnutarget
);
262 old_cleanups
= make_cleanup_bfd_close (nbfd
);
264 /* Check the format. NOTE: This initializes important data that GDB uses!
265 We would segfault later without this line. */
266 if (!bfd_check_format (nbfd
, bfd_object
))
268 printf_unfiltered (_("\
269 JITed symbol file is not an object file, ignoring it.\n"));
270 do_cleanups (old_cleanups
);
274 /* Check bfd arch. */
275 b
= gdbarch_bfd_arch_info (gdbarch
);
276 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
277 warning (_("JITed object file architecture %s is not compatible "
278 "with target architecture %s."), bfd_get_arch_info
279 (nbfd
)->printable_name
, b
->printable_name
);
281 /* Read the section address information out of the symbol file. Since the
282 file is generated by the JIT at runtime, it should all of the absolute
283 addresses that we care about. */
284 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
285 make_cleanup_free_section_addr_info (sai
);
287 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
288 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
290 /* We assume that these virtual addresses are absolute, and do not
291 treat them as offsets. */
292 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
293 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
294 sai
->other
[i
].sectindex
= sec
->index
;
298 /* This call takes ownership of sai. */
299 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
);
301 /* Remember a mapping from entry_addr to objfile. */
302 entry_addr_ptr
= xmalloc (sizeof (CORE_ADDR
));
303 *entry_addr_ptr
= entry_addr
;
304 set_objfile_data (objfile
, jit_objfile_data
, entry_addr_ptr
);
306 discard_cleanups (old_cleanups
);
309 /* This function unregisters JITed code and frees the corresponding
313 jit_unregister_code (struct objfile
*objfile
)
315 free_objfile (objfile
);
318 /* Look up the objfile with this code entry address. */
320 static struct objfile
*
321 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
323 struct objfile
*objf
;
324 CORE_ADDR
*objf_entry_addr
;
328 objf_entry_addr
= (CORE_ADDR
*) objfile_data (objf
, jit_objfile_data
);
329 if (objf_entry_addr
!= NULL
&& *objf_entry_addr
== entry_addr
)
335 /* (Re-)Initialize the jit breakpoint if necessary.
336 Return 0 on success. */
339 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
340 struct jit_inferior_data
*inf_data
)
342 if (inf_data
->breakpoint_addr
== 0)
344 struct minimal_symbol
*reg_symbol
;
346 /* Lookup the registration symbol. If it is missing, then we assume
347 we are not attached to a JIT. */
348 reg_symbol
= lookup_minimal_symbol (jit_break_name
, NULL
, NULL
);
349 if (reg_symbol
== NULL
)
351 inf_data
->breakpoint_addr
= SYMBOL_VALUE_ADDRESS (reg_symbol
);
352 if (inf_data
->breakpoint_addr
== 0)
359 fprintf_unfiltered (gdb_stdlog
,
360 "jit_breakpoint_re_set_internal, "
361 "breakpoint_addr = %s\n",
362 paddress (gdbarch
, inf_data
->breakpoint_addr
));
364 /* Put a breakpoint in the registration symbol. */
365 create_jit_event_breakpoint (gdbarch
, inf_data
->breakpoint_addr
);
370 /* Register any already created translations. */
373 jit_inferior_init (struct gdbarch
*gdbarch
)
375 struct jit_descriptor descriptor
;
376 struct jit_code_entry cur_entry
;
377 struct jit_inferior_data
*inf_data
;
378 CORE_ADDR cur_entry_addr
;
381 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
383 inf_data
= get_jit_inferior_data ();
384 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
387 if (inf_data
->descriptor_addr
== 0)
389 struct minimal_symbol
*desc_symbol
;
391 /* Lookup the descriptor symbol and cache the addr. If it is
392 missing, we assume we are not attached to a JIT and return early. */
393 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, NULL
);
394 if (desc_symbol
== NULL
)
397 inf_data
->descriptor_addr
= SYMBOL_VALUE_ADDRESS (desc_symbol
);
398 if (inf_data
->descriptor_addr
== 0)
403 fprintf_unfiltered (gdb_stdlog
,
404 "jit_inferior_init, descriptor_addr = %s\n",
405 paddress (gdbarch
, inf_data
->descriptor_addr
));
407 /* Read the descriptor so we can check the version number and load
408 any already JITed functions. */
409 jit_read_descriptor (gdbarch
, &descriptor
, inf_data
->descriptor_addr
);
411 /* Check that the version number agrees with that we support. */
412 if (descriptor
.version
!= 1)
413 error (_("Unsupported JIT protocol version in descriptor!"));
415 /* If we've attached to a running program, we need to check the descriptor
416 to register any functions that were already generated. */
417 for (cur_entry_addr
= descriptor
.first_entry
;
419 cur_entry_addr
= cur_entry
.next_entry
)
421 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
423 /* This hook may be called many times during setup, so make sure we don't
424 add the same symbol file twice. */
425 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
428 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
432 /* Exported routine to call when an inferior has been created. */
435 jit_inferior_created_hook (void)
437 jit_inferior_init (target_gdbarch
);
440 /* Exported routine to call to re-set the jit breakpoints,
441 e.g. when a program is rerun. */
444 jit_breakpoint_re_set (void)
446 jit_breakpoint_re_set_internal (target_gdbarch
,
447 get_jit_inferior_data ());
450 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
454 jit_reset_inferior_data_and_breakpoints (void)
456 struct jit_inferior_data
*inf_data
;
458 /* Force jit_inferior_init to re-lookup of jit symbol addresses. */
459 inf_data
= get_jit_inferior_data ();
460 inf_data
->breakpoint_addr
= 0;
461 inf_data
->descriptor_addr
= 0;
463 /* Remove any existing JIT breakpoint(s). */
464 remove_jit_event_breakpoints ();
466 jit_inferior_init (target_gdbarch
);
469 /* Wrapper to match the observer function pointer prototype. */
472 jit_inferior_created_observer (struct target_ops
*objfile
, int from_tty
)
474 jit_reset_inferior_data_and_breakpoints ();
477 /* This function cleans up any code entries left over when the
478 inferior exits. We get left over code when the inferior exits
479 without unregistering its code, for example when it crashes. */
482 jit_inferior_exit_hook (struct inferior
*inf
)
484 struct objfile
*objf
;
485 struct objfile
*temp
;
487 ALL_OBJFILES_SAFE (objf
, temp
)
488 if (objfile_data (objf
, jit_objfile_data
) != NULL
)
489 jit_unregister_code (objf
);
493 jit_executable_changed_observer (void)
495 jit_reset_inferior_data_and_breakpoints ();
499 jit_event_handler (struct gdbarch
*gdbarch
)
501 struct jit_descriptor descriptor
;
502 struct jit_code_entry code_entry
;
503 CORE_ADDR entry_addr
;
504 struct objfile
*objf
;
506 /* Read the descriptor from remote memory. */
507 jit_read_descriptor (gdbarch
, &descriptor
,
508 get_jit_inferior_data ()->descriptor_addr
);
509 entry_addr
= descriptor
.relevant_entry
;
511 /* Do the corresponding action. */
512 switch (descriptor
.action_flag
)
517 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
518 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
521 objf
= jit_find_objf_with_entry_addr (entry_addr
);
523 printf_unfiltered (_("Unable to find JITed code "
524 "entry at address: %s\n"),
525 paddress (gdbarch
, entry_addr
));
527 jit_unregister_code (objf
);
531 error (_("Unknown action_flag value in JIT descriptor!"));
536 /* Provide a prototype to silence -Wmissing-prototypes. */
538 extern void _initialize_jit (void);
541 _initialize_jit (void)
543 add_setshow_zinteger_cmd ("jit", class_maintenance
, &jit_debug
,
544 _("Set JIT debugging."),
545 _("Show JIT debugging."),
546 _("When non-zero, JIT debugging is enabled."),
549 &setdebuglist
, &showdebuglist
);
551 observer_attach_inferior_created (jit_inferior_created_observer
);
552 observer_attach_inferior_exit (jit_inferior_exit_hook
);
553 observer_attach_executable_changed (jit_executable_changed_observer
);
554 jit_objfile_data
= register_objfile_data ();
556 register_inferior_data_with_cleanup (jit_inferior_data_cleanup
);