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 char *jit_reader_dir
= NULL
;
38 static const struct objfile_data
*jit_objfile_data
;
40 static const char *const jit_break_name
= "__jit_debug_register_code";
42 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
44 static const struct inferior_data
*jit_inferior_data
= NULL
;
46 static void jit_inferior_init (struct gdbarch
*gdbarch
);
48 /* Non-zero if we want to see trace of jit level stuff. */
50 static int jit_debug
= 0;
53 show_jit_debug (struct ui_file
*file
, int from_tty
,
54 struct cmd_list_element
*c
, const char *value
)
56 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
65 /* Openning the file is a no-op. */
68 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
73 /* Closing the file is just freeing the base/size pair on our side. */
76 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
82 /* For reading the file, we just need to pass through to target_read_memory and
83 fix up the arguments and return values. */
86 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
87 file_ptr nbytes
, file_ptr offset
)
90 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
92 /* If this read will read all of the file, limit it to just the rest. */
93 if (offset
+ nbytes
> buffer
->size
)
94 nbytes
= buffer
->size
- offset
;
96 /* If there are no more bytes left, we've reached EOF. */
100 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
107 /* For statting the file, we only support the st_size attribute. */
110 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
112 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
114 sb
->st_size
= buffer
->size
;
118 /* Open a BFD from the target's memory. */
121 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
123 const char *filename
= xstrdup ("<in-memory>");
124 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
128 return bfd_openr_iovec (filename
, target
,
136 /* Per-inferior structure recording the addresses in the inferior. */
138 struct jit_inferior_data
140 CORE_ADDR breakpoint_addr
; /* &__jit_debug_register_code() */
141 CORE_ADDR descriptor_addr
; /* &__jit_debug_descriptor */
144 /* Return jit_inferior_data for current inferior. Allocate if not already
147 static struct jit_inferior_data
*
148 get_jit_inferior_data (void)
150 struct inferior
*inf
;
151 struct jit_inferior_data
*inf_data
;
153 inf
= current_inferior ();
154 inf_data
= inferior_data (inf
, jit_inferior_data
);
155 if (inf_data
== NULL
)
157 inf_data
= XZALLOC (struct jit_inferior_data
);
158 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
165 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
170 /* Helper function for reading the global JIT descriptor from remote
174 jit_read_descriptor (struct gdbarch
*gdbarch
,
175 struct jit_descriptor
*descriptor
,
176 CORE_ADDR descriptor_addr
)
179 struct type
*ptr_type
;
183 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
185 /* Figure out how big the descriptor is on the remote and how to read it. */
186 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
187 ptr_size
= TYPE_LENGTH (ptr_type
);
188 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
189 desc_buf
= alloca (desc_size
);
191 /* Read the descriptor. */
192 err
= target_read_memory (descriptor_addr
, desc_buf
, desc_size
);
194 error (_("Unable to read JIT descriptor from remote memory!"));
196 /* Fix the endianness to match the host. */
197 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
198 descriptor
->action_flag
=
199 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
200 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
201 descriptor
->first_entry
=
202 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
205 /* Helper function for reading a JITed code entry from remote memory. */
208 jit_read_code_entry (struct gdbarch
*gdbarch
,
209 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
212 struct type
*ptr_type
;
217 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
219 /* Figure out how big the entry is on the remote and how to read it. */
220 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
221 ptr_size
= TYPE_LENGTH (ptr_type
);
222 entry_size
= 3 * ptr_size
+ 8; /* Three pointers and one 64-bit int. */
223 entry_buf
= alloca (entry_size
);
225 /* Read the entry. */
226 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
228 error (_("Unable to read JIT code entry from remote memory!"));
230 /* Fix the endianness to match the host. */
231 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
232 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
233 code_entry
->prev_entry
=
234 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
235 code_entry
->symfile_addr
=
236 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
238 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
240 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
242 code_entry
->symfile_size
=
243 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
246 /* This function registers code associated with a JIT code entry. It uses the
247 pointer and size pair in the entry to read the symbol file from the remote
248 and then calls symbol_file_add_from_local_memory to add it as though it were
249 a symbol file added by the user. */
252 jit_register_code (struct gdbarch
*gdbarch
,
253 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
256 struct section_addr_info
*sai
;
257 struct bfd_section
*sec
;
258 struct objfile
*objfile
;
259 struct cleanup
*old_cleanups
;
261 const struct bfd_arch_info
*b
;
262 CORE_ADDR
*entry_addr_ptr
;
265 fprintf_unfiltered (gdb_stdlog
,
266 "jit_register_code, symfile_addr = %s, "
267 "symfile_size = %s\n",
268 paddress (gdbarch
, code_entry
->symfile_addr
),
269 pulongest (code_entry
->symfile_size
));
271 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
272 code_entry
->symfile_size
, gnutarget
);
275 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
279 /* Check the format. NOTE: This initializes important data that GDB uses!
280 We would segfault later without this line. */
281 if (!bfd_check_format (nbfd
, bfd_object
))
283 printf_unfiltered (_("\
284 JITed symbol file is not an object file, ignoring it.\n"));
289 /* Check bfd arch. */
290 b
= gdbarch_bfd_arch_info (gdbarch
);
291 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
292 warning (_("JITed object file architecture %s is not compatible "
293 "with target architecture %s."), bfd_get_arch_info
294 (nbfd
)->printable_name
, b
->printable_name
);
296 /* Read the section address information out of the symbol file. Since the
297 file is generated by the JIT at runtime, it should all of the absolute
298 addresses that we care about. */
299 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
300 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
302 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
303 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
305 /* We assume that these virtual addresses are absolute, and do not
306 treat them as offsets. */
307 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
308 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
309 sai
->other
[i
].sectindex
= sec
->index
;
313 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
314 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
316 /* Remember a mapping from entry_addr to objfile. */
317 entry_addr_ptr
= xmalloc (sizeof (CORE_ADDR
));
318 *entry_addr_ptr
= entry_addr
;
319 set_objfile_data (objfile
, jit_objfile_data
, entry_addr_ptr
);
321 do_cleanups (old_cleanups
);
324 /* This function unregisters JITed code and frees the corresponding
328 jit_unregister_code (struct objfile
*objfile
)
330 free_objfile (objfile
);
333 /* Look up the objfile with this code entry address. */
335 static struct objfile
*
336 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
338 struct objfile
*objf
;
339 CORE_ADDR
*objf_entry_addr
;
343 objf_entry_addr
= (CORE_ADDR
*) objfile_data (objf
, jit_objfile_data
);
344 if (objf_entry_addr
!= NULL
&& *objf_entry_addr
== entry_addr
)
350 /* (Re-)Initialize the jit breakpoint if necessary.
351 Return 0 on success. */
354 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
355 struct jit_inferior_data
*inf_data
)
357 if (inf_data
->breakpoint_addr
== 0)
359 struct minimal_symbol
*reg_symbol
;
361 /* Lookup the registration symbol. If it is missing, then we assume
362 we are not attached to a JIT. */
363 reg_symbol
= lookup_minimal_symbol (jit_break_name
, NULL
, NULL
);
364 if (reg_symbol
== NULL
)
366 inf_data
->breakpoint_addr
= SYMBOL_VALUE_ADDRESS (reg_symbol
);
367 if (inf_data
->breakpoint_addr
== 0)
370 /* If we have not read the jit descriptor yet (e.g. because the JITer
371 itself is in a shared library which just got loaded), do so now. */
372 if (inf_data
->descriptor_addr
== 0)
373 jit_inferior_init (gdbarch
);
379 fprintf_unfiltered (gdb_stdlog
,
380 "jit_breakpoint_re_set_internal, "
381 "breakpoint_addr = %s\n",
382 paddress (gdbarch
, inf_data
->breakpoint_addr
));
384 /* Put a breakpoint in the registration symbol. */
385 create_jit_event_breakpoint (gdbarch
, inf_data
->breakpoint_addr
);
390 /* Register any already created translations. */
393 jit_inferior_init (struct gdbarch
*gdbarch
)
395 struct jit_descriptor descriptor
;
396 struct jit_code_entry cur_entry
;
397 struct jit_inferior_data
*inf_data
;
398 CORE_ADDR cur_entry_addr
;
401 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
403 inf_data
= get_jit_inferior_data ();
404 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
407 if (inf_data
->descriptor_addr
== 0)
409 struct minimal_symbol
*desc_symbol
;
411 /* Lookup the descriptor symbol and cache the addr. If it is
412 missing, we assume we are not attached to a JIT and return early. */
413 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, NULL
);
414 if (desc_symbol
== NULL
)
417 inf_data
->descriptor_addr
= SYMBOL_VALUE_ADDRESS (desc_symbol
);
418 if (inf_data
->descriptor_addr
== 0)
423 fprintf_unfiltered (gdb_stdlog
,
424 "jit_inferior_init, descriptor_addr = %s\n",
425 paddress (gdbarch
, inf_data
->descriptor_addr
));
427 /* Read the descriptor so we can check the version number and load
428 any already JITed functions. */
429 jit_read_descriptor (gdbarch
, &descriptor
, inf_data
->descriptor_addr
);
431 /* Check that the version number agrees with that we support. */
432 if (descriptor
.version
!= 1)
433 error (_("Unsupported JIT protocol version in descriptor!"));
435 /* If we've attached to a running program, we need to check the descriptor
436 to register any functions that were already generated. */
437 for (cur_entry_addr
= descriptor
.first_entry
;
439 cur_entry_addr
= cur_entry
.next_entry
)
441 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
443 /* This hook may be called many times during setup, so make sure we don't
444 add the same symbol file twice. */
445 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
448 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
452 /* Exported routine to call when an inferior has been created. */
455 jit_inferior_created_hook (void)
457 jit_inferior_init (target_gdbarch
);
460 /* Exported routine to call to re-set the jit breakpoints,
461 e.g. when a program is rerun. */
464 jit_breakpoint_re_set (void)
466 jit_breakpoint_re_set_internal (target_gdbarch
,
467 get_jit_inferior_data ());
470 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
474 jit_reset_inferior_data_and_breakpoints (void)
476 struct jit_inferior_data
*inf_data
;
478 /* Force jit_inferior_init to re-lookup of jit symbol addresses. */
479 inf_data
= get_jit_inferior_data ();
480 inf_data
->breakpoint_addr
= 0;
481 inf_data
->descriptor_addr
= 0;
483 /* Remove any existing JIT breakpoint(s). */
484 remove_jit_event_breakpoints ();
486 jit_inferior_init (target_gdbarch
);
489 /* Wrapper to match the observer function pointer prototype. */
492 jit_inferior_created_observer (struct target_ops
*objfile
, int from_tty
)
494 jit_reset_inferior_data_and_breakpoints ();
497 /* This function cleans up any code entries left over when the
498 inferior exits. We get left over code when the inferior exits
499 without unregistering its code, for example when it crashes. */
502 jit_inferior_exit_hook (struct inferior
*inf
)
504 struct objfile
*objf
;
505 struct objfile
*temp
;
507 ALL_OBJFILES_SAFE (objf
, temp
)
508 if (objfile_data (objf
, jit_objfile_data
) != NULL
)
509 jit_unregister_code (objf
);
513 jit_executable_changed_observer (void)
515 jit_reset_inferior_data_and_breakpoints ();
519 jit_event_handler (struct gdbarch
*gdbarch
)
521 struct jit_descriptor descriptor
;
522 struct jit_code_entry code_entry
;
523 CORE_ADDR entry_addr
;
524 struct objfile
*objf
;
526 /* Read the descriptor from remote memory. */
527 jit_read_descriptor (gdbarch
, &descriptor
,
528 get_jit_inferior_data ()->descriptor_addr
);
529 entry_addr
= descriptor
.relevant_entry
;
531 /* Do the corresponding action. */
532 switch (descriptor
.action_flag
)
537 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
538 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
541 objf
= jit_find_objf_with_entry_addr (entry_addr
);
543 printf_unfiltered (_("Unable to find JITed code "
544 "entry at address: %s\n"),
545 paddress (gdbarch
, entry_addr
));
547 jit_unregister_code (objf
);
551 error (_("Unknown action_flag value in JIT descriptor!"));
556 /* Provide a prototype to silence -Wmissing-prototypes. */
558 extern void _initialize_jit (void);
561 _initialize_jit (void)
563 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
564 JIT_READER_DIR_RELOCATABLE
);
565 add_setshow_zinteger_cmd ("jit", class_maintenance
, &jit_debug
,
566 _("Set JIT debugging."),
567 _("Show JIT debugging."),
568 _("When non-zero, JIT debugging is enabled."),
571 &setdebuglist
, &showdebuglist
);
573 observer_attach_inferior_created (jit_inferior_created_observer
);
574 observer_attach_inferior_exit (jit_inferior_exit_hook
);
575 observer_attach_executable_changed (jit_executable_changed_observer
);
576 jit_objfile_data
= register_objfile_data ();
578 register_inferior_data_with_cleanup (jit_inferior_data_cleanup
);