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 "jit-reader.h"
24 #include "breakpoint.h"
36 static const struct objfile_data
*jit_objfile_data
;
38 static const char *const jit_break_name
= "__jit_debug_register_code";
40 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
42 static const struct inferior_data
*jit_inferior_data
= NULL
;
44 static void jit_inferior_init (struct gdbarch
*gdbarch
);
46 /* Non-zero if we want to see trace of jit level stuff. */
48 static int jit_debug
= 0;
51 show_jit_debug (struct ui_file
*file
, int from_tty
,
52 struct cmd_list_element
*c
, const char *value
)
54 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
63 /* Openning the file is a no-op. */
66 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
71 /* Closing the file is just freeing the base/size pair on our side. */
74 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
80 /* For reading the file, we just need to pass through to target_read_memory and
81 fix up the arguments and return values. */
84 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
85 file_ptr nbytes
, file_ptr offset
)
88 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
90 /* If this read will read all of the file, limit it to just the rest. */
91 if (offset
+ nbytes
> buffer
->size
)
92 nbytes
= buffer
->size
- offset
;
94 /* If there are no more bytes left, we've reached EOF. */
98 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
105 /* For statting the file, we only support the st_size attribute. */
108 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
110 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
112 sb
->st_size
= buffer
->size
;
116 /* Open a BFD from the target's memory. */
119 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
121 const char *filename
= xstrdup ("<in-memory>");
122 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
126 return bfd_openr_iovec (filename
, target
,
134 /* Per-inferior structure recording the addresses in the inferior. */
136 struct jit_inferior_data
138 CORE_ADDR breakpoint_addr
; /* &__jit_debug_register_code() */
139 CORE_ADDR descriptor_addr
; /* &__jit_debug_descriptor */
142 /* Return jit_inferior_data for current inferior. Allocate if not already
145 static struct jit_inferior_data
*
146 get_jit_inferior_data (void)
148 struct inferior
*inf
;
149 struct jit_inferior_data
*inf_data
;
151 inf
= current_inferior ();
152 inf_data
= inferior_data (inf
, jit_inferior_data
);
153 if (inf_data
== NULL
)
155 inf_data
= XZALLOC (struct jit_inferior_data
);
156 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
163 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
168 /* Helper function for reading the global JIT descriptor from remote
172 jit_read_descriptor (struct gdbarch
*gdbarch
,
173 struct jit_descriptor
*descriptor
,
174 CORE_ADDR descriptor_addr
)
177 struct type
*ptr_type
;
181 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
183 /* Figure out how big the descriptor is on the remote and how to read it. */
184 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
185 ptr_size
= TYPE_LENGTH (ptr_type
);
186 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
187 desc_buf
= alloca (desc_size
);
189 /* Read the descriptor. */
190 err
= target_read_memory (descriptor_addr
, desc_buf
, desc_size
);
192 error (_("Unable to read JIT descriptor from remote memory!"));
194 /* Fix the endianness to match the host. */
195 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
196 descriptor
->action_flag
=
197 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
198 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
199 descriptor
->first_entry
=
200 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
203 /* Helper function for reading a JITed code entry from remote memory. */
206 jit_read_code_entry (struct gdbarch
*gdbarch
,
207 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
210 struct type
*ptr_type
;
215 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
217 /* Figure out how big the entry is on the remote and how to read it. */
218 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
219 ptr_size
= TYPE_LENGTH (ptr_type
);
220 entry_size
= 3 * ptr_size
+ 8; /* Three pointers and one 64-bit int. */
221 entry_buf
= alloca (entry_size
);
223 /* Read the entry. */
224 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
226 error (_("Unable to read JIT code entry from remote memory!"));
228 /* Fix the endianness to match the host. */
229 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
230 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
231 code_entry
->prev_entry
=
232 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
233 code_entry
->symfile_addr
=
234 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
236 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
238 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
240 code_entry
->symfile_size
=
241 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
244 /* This function registers code associated with a JIT code entry. It uses the
245 pointer and size pair in the entry to read the symbol file from the remote
246 and then calls symbol_file_add_from_local_memory to add it as though it were
247 a symbol file added by the user. */
250 jit_register_code (struct gdbarch
*gdbarch
,
251 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
254 struct section_addr_info
*sai
;
255 struct bfd_section
*sec
;
256 struct objfile
*objfile
;
257 struct cleanup
*old_cleanups
;
259 const struct bfd_arch_info
*b
;
260 CORE_ADDR
*entry_addr_ptr
;
263 fprintf_unfiltered (gdb_stdlog
,
264 "jit_register_code, symfile_addr = %s, "
265 "symfile_size = %s\n",
266 paddress (gdbarch
, code_entry
->symfile_addr
),
267 pulongest (code_entry
->symfile_size
));
269 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
270 code_entry
->symfile_size
, gnutarget
);
273 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
277 /* Check the format. NOTE: This initializes important data that GDB uses!
278 We would segfault later without this line. */
279 if (!bfd_check_format (nbfd
, bfd_object
))
281 printf_unfiltered (_("\
282 JITed symbol file is not an object file, ignoring it.\n"));
287 /* Check bfd arch. */
288 b
= gdbarch_bfd_arch_info (gdbarch
);
289 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
290 warning (_("JITed object file architecture %s is not compatible "
291 "with target architecture %s."), bfd_get_arch_info
292 (nbfd
)->printable_name
, b
->printable_name
);
294 /* Read the section address information out of the symbol file. Since the
295 file is generated by the JIT at runtime, it should all of the absolute
296 addresses that we care about. */
297 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
298 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
300 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
301 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
303 /* We assume that these virtual addresses are absolute, and do not
304 treat them as offsets. */
305 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
306 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
307 sai
->other
[i
].sectindex
= sec
->index
;
311 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
312 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
314 /* Remember a mapping from entry_addr to objfile. */
315 entry_addr_ptr
= xmalloc (sizeof (CORE_ADDR
));
316 *entry_addr_ptr
= entry_addr
;
317 set_objfile_data (objfile
, jit_objfile_data
, entry_addr_ptr
);
319 do_cleanups (old_cleanups
);
322 /* This function unregisters JITed code and frees the corresponding
326 jit_unregister_code (struct objfile
*objfile
)
328 free_objfile (objfile
);
331 /* Look up the objfile with this code entry address. */
333 static struct objfile
*
334 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
336 struct objfile
*objf
;
337 CORE_ADDR
*objf_entry_addr
;
341 objf_entry_addr
= (CORE_ADDR
*) objfile_data (objf
, jit_objfile_data
);
342 if (objf_entry_addr
!= NULL
&& *objf_entry_addr
== entry_addr
)
348 /* (Re-)Initialize the jit breakpoint if necessary.
349 Return 0 on success. */
352 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
353 struct jit_inferior_data
*inf_data
)
355 if (inf_data
->breakpoint_addr
== 0)
357 struct minimal_symbol
*reg_symbol
;
359 /* Lookup the registration symbol. If it is missing, then we assume
360 we are not attached to a JIT. */
361 reg_symbol
= lookup_minimal_symbol (jit_break_name
, NULL
, NULL
);
362 if (reg_symbol
== NULL
)
364 inf_data
->breakpoint_addr
= SYMBOL_VALUE_ADDRESS (reg_symbol
);
365 if (inf_data
->breakpoint_addr
== 0)
368 /* If we have not read the jit descriptor yet (e.g. because the JITer
369 itself is in a shared library which just got loaded), do so now. */
370 if (inf_data
->descriptor_addr
== 0)
371 jit_inferior_init (gdbarch
);
377 fprintf_unfiltered (gdb_stdlog
,
378 "jit_breakpoint_re_set_internal, "
379 "breakpoint_addr = %s\n",
380 paddress (gdbarch
, inf_data
->breakpoint_addr
));
382 /* Put a breakpoint in the registration symbol. */
383 create_jit_event_breakpoint (gdbarch
, inf_data
->breakpoint_addr
);
388 /* Register any already created translations. */
391 jit_inferior_init (struct gdbarch
*gdbarch
)
393 struct jit_descriptor descriptor
;
394 struct jit_code_entry cur_entry
;
395 struct jit_inferior_data
*inf_data
;
396 CORE_ADDR cur_entry_addr
;
399 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
401 inf_data
= get_jit_inferior_data ();
402 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
405 if (inf_data
->descriptor_addr
== 0)
407 struct minimal_symbol
*desc_symbol
;
409 /* Lookup the descriptor symbol and cache the addr. If it is
410 missing, we assume we are not attached to a JIT and return early. */
411 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, NULL
);
412 if (desc_symbol
== NULL
)
415 inf_data
->descriptor_addr
= SYMBOL_VALUE_ADDRESS (desc_symbol
);
416 if (inf_data
->descriptor_addr
== 0)
421 fprintf_unfiltered (gdb_stdlog
,
422 "jit_inferior_init, descriptor_addr = %s\n",
423 paddress (gdbarch
, inf_data
->descriptor_addr
));
425 /* Read the descriptor so we can check the version number and load
426 any already JITed functions. */
427 jit_read_descriptor (gdbarch
, &descriptor
, inf_data
->descriptor_addr
);
429 /* Check that the version number agrees with that we support. */
430 if (descriptor
.version
!= 1)
431 error (_("Unsupported JIT protocol version in descriptor!"));
433 /* If we've attached to a running program, we need to check the descriptor
434 to register any functions that were already generated. */
435 for (cur_entry_addr
= descriptor
.first_entry
;
437 cur_entry_addr
= cur_entry
.next_entry
)
439 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
441 /* This hook may be called many times during setup, so make sure we don't
442 add the same symbol file twice. */
443 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
446 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
450 /* Exported routine to call when an inferior has been created. */
453 jit_inferior_created_hook (void)
455 jit_inferior_init (target_gdbarch
);
458 /* Exported routine to call to re-set the jit breakpoints,
459 e.g. when a program is rerun. */
462 jit_breakpoint_re_set (void)
464 jit_breakpoint_re_set_internal (target_gdbarch
,
465 get_jit_inferior_data ());
468 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
472 jit_reset_inferior_data_and_breakpoints (void)
474 struct jit_inferior_data
*inf_data
;
476 /* Force jit_inferior_init to re-lookup of jit symbol addresses. */
477 inf_data
= get_jit_inferior_data ();
478 inf_data
->breakpoint_addr
= 0;
479 inf_data
->descriptor_addr
= 0;
481 /* Remove any existing JIT breakpoint(s). */
482 remove_jit_event_breakpoints ();
484 jit_inferior_init (target_gdbarch
);
487 /* Wrapper to match the observer function pointer prototype. */
490 jit_inferior_created_observer (struct target_ops
*objfile
, int from_tty
)
492 jit_reset_inferior_data_and_breakpoints ();
495 /* This function cleans up any code entries left over when the
496 inferior exits. We get left over code when the inferior exits
497 without unregistering its code, for example when it crashes. */
500 jit_inferior_exit_hook (struct inferior
*inf
)
502 struct objfile
*objf
;
503 struct objfile
*temp
;
505 ALL_OBJFILES_SAFE (objf
, temp
)
506 if (objfile_data (objf
, jit_objfile_data
) != NULL
)
507 jit_unregister_code (objf
);
511 jit_executable_changed_observer (void)
513 jit_reset_inferior_data_and_breakpoints ();
517 jit_event_handler (struct gdbarch
*gdbarch
)
519 struct jit_descriptor descriptor
;
520 struct jit_code_entry code_entry
;
521 CORE_ADDR entry_addr
;
522 struct objfile
*objf
;
524 /* Read the descriptor from remote memory. */
525 jit_read_descriptor (gdbarch
, &descriptor
,
526 get_jit_inferior_data ()->descriptor_addr
);
527 entry_addr
= descriptor
.relevant_entry
;
529 /* Do the corresponding action. */
530 switch (descriptor
.action_flag
)
535 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
536 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
539 objf
= jit_find_objf_with_entry_addr (entry_addr
);
541 printf_unfiltered (_("Unable to find JITed code "
542 "entry at address: %s\n"),
543 paddress (gdbarch
, entry_addr
));
545 jit_unregister_code (objf
);
549 error (_("Unknown action_flag value in JIT descriptor!"));
554 /* Provide a prototype to silence -Wmissing-prototypes. */
556 extern void _initialize_jit (void);
559 _initialize_jit (void)
561 add_setshow_zinteger_cmd ("jit", class_maintenance
, &jit_debug
,
562 _("Set JIT debugging."),
563 _("Show JIT debugging."),
564 _("When non-zero, JIT debugging is enabled."),
567 &setdebuglist
, &showdebuglist
);
569 observer_attach_inferior_created (jit_inferior_created_observer
);
570 observer_attach_inferior_exit (jit_inferior_exit_hook
);
571 observer_attach_executable_changed (jit_executable_changed_observer
);
572 jit_objfile_data
= register_objfile_data ();
574 register_inferior_data_with_cleanup (jit_inferior_data_cleanup
);