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 static void jit_inferior_init (struct gdbarch
*gdbarch
);
45 /* Non-zero if we want to see trace of jit level stuff. */
47 static int jit_debug
= 0;
50 show_jit_debug (struct ui_file
*file
, int from_tty
,
51 struct cmd_list_element
*c
, const char *value
)
53 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
62 /* Openning the file is a no-op. */
65 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
70 /* Closing the file is just freeing the base/size pair on our side. */
73 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
79 /* For reading the file, we just need to pass through to target_read_memory and
80 fix up the arguments and return values. */
83 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
84 file_ptr nbytes
, file_ptr offset
)
87 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
89 /* If this read will read all of the file, limit it to just the rest. */
90 if (offset
+ nbytes
> buffer
->size
)
91 nbytes
= buffer
->size
- offset
;
93 /* If there are no more bytes left, we've reached EOF. */
97 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
104 /* For statting the file, we only support the st_size attribute. */
107 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
109 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
111 sb
->st_size
= buffer
->size
;
115 /* Open a BFD from the target's memory. */
118 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
120 const char *filename
= xstrdup ("<in-memory>");
121 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
125 return bfd_openr_iovec (filename
, target
,
133 /* Per-inferior structure recording the addresses in the inferior. */
135 struct jit_inferior_data
137 CORE_ADDR breakpoint_addr
; /* &__jit_debug_register_code() */
138 CORE_ADDR descriptor_addr
; /* &__jit_debug_descriptor */
141 /* Return jit_inferior_data for current inferior. Allocate if not already
144 static struct jit_inferior_data
*
145 get_jit_inferior_data (void)
147 struct inferior
*inf
;
148 struct jit_inferior_data
*inf_data
;
150 inf
= current_inferior ();
151 inf_data
= inferior_data (inf
, jit_inferior_data
);
152 if (inf_data
== NULL
)
154 inf_data
= XZALLOC (struct jit_inferior_data
);
155 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
162 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
167 /* Helper function for reading the global JIT descriptor from remote
171 jit_read_descriptor (struct gdbarch
*gdbarch
,
172 struct jit_descriptor
*descriptor
,
173 CORE_ADDR descriptor_addr
)
176 struct type
*ptr_type
;
180 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
182 /* Figure out how big the descriptor is on the remote and how to read it. */
183 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
184 ptr_size
= TYPE_LENGTH (ptr_type
);
185 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
186 desc_buf
= alloca (desc_size
);
188 /* Read the descriptor. */
189 err
= target_read_memory (descriptor_addr
, desc_buf
, desc_size
);
191 error (_("Unable to read JIT descriptor from remote memory!"));
193 /* Fix the endianness to match the host. */
194 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
195 descriptor
->action_flag
=
196 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
197 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
198 descriptor
->first_entry
=
199 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
202 /* Helper function for reading a JITed code entry from remote memory. */
205 jit_read_code_entry (struct gdbarch
*gdbarch
,
206 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
209 struct type
*ptr_type
;
214 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
216 /* Figure out how big the entry is on the remote and how to read it. */
217 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
218 ptr_size
= TYPE_LENGTH (ptr_type
);
219 entry_size
= 3 * ptr_size
+ 8; /* Three pointers and one 64-bit int. */
220 entry_buf
= alloca (entry_size
);
222 /* Read the entry. */
223 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
225 error (_("Unable to read JIT code entry from remote memory!"));
227 /* Fix the endianness to match the host. */
228 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
229 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
230 code_entry
->prev_entry
=
231 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
232 code_entry
->symfile_addr
=
233 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
235 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
237 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
239 code_entry
->symfile_size
=
240 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
243 /* This function registers code associated with a JIT code entry. It uses the
244 pointer and size pair in the entry to read the symbol file from the remote
245 and then calls symbol_file_add_from_local_memory to add it as though it were
246 a symbol file added by the user. */
249 jit_register_code (struct gdbarch
*gdbarch
,
250 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
253 struct section_addr_info
*sai
;
254 struct bfd_section
*sec
;
255 struct objfile
*objfile
;
256 struct cleanup
*old_cleanups
;
258 const struct bfd_arch_info
*b
;
259 CORE_ADDR
*entry_addr_ptr
;
262 fprintf_unfiltered (gdb_stdlog
,
263 "jit_register_code, symfile_addr = %s, "
264 "symfile_size = %s\n",
265 paddress (gdbarch
, code_entry
->symfile_addr
),
266 pulongest (code_entry
->symfile_size
));
268 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
269 code_entry
->symfile_size
, gnutarget
);
272 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
276 /* Check the format. NOTE: This initializes important data that GDB uses!
277 We would segfault later without this line. */
278 if (!bfd_check_format (nbfd
, bfd_object
))
280 printf_unfiltered (_("\
281 JITed symbol file is not an object file, ignoring it.\n"));
286 /* Check bfd arch. */
287 b
= gdbarch_bfd_arch_info (gdbarch
);
288 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
289 warning (_("JITed object file architecture %s is not compatible "
290 "with target architecture %s."), bfd_get_arch_info
291 (nbfd
)->printable_name
, b
->printable_name
);
293 /* Read the section address information out of the symbol file. Since the
294 file is generated by the JIT at runtime, it should all of the absolute
295 addresses that we care about. */
296 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
297 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
299 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
300 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
302 /* We assume that these virtual addresses are absolute, and do not
303 treat them as offsets. */
304 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
305 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
306 sai
->other
[i
].sectindex
= sec
->index
;
310 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
311 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
313 /* Remember a mapping from entry_addr to objfile. */
314 entry_addr_ptr
= xmalloc (sizeof (CORE_ADDR
));
315 *entry_addr_ptr
= entry_addr
;
316 set_objfile_data (objfile
, jit_objfile_data
, entry_addr_ptr
);
318 do_cleanups (old_cleanups
);
321 /* This function unregisters JITed code and frees the corresponding
325 jit_unregister_code (struct objfile
*objfile
)
327 free_objfile (objfile
);
330 /* Look up the objfile with this code entry address. */
332 static struct objfile
*
333 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
335 struct objfile
*objf
;
336 CORE_ADDR
*objf_entry_addr
;
340 objf_entry_addr
= (CORE_ADDR
*) objfile_data (objf
, jit_objfile_data
);
341 if (objf_entry_addr
!= NULL
&& *objf_entry_addr
== entry_addr
)
347 /* (Re-)Initialize the jit breakpoint if necessary.
348 Return 0 on success. */
351 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
352 struct jit_inferior_data
*inf_data
)
354 if (inf_data
->breakpoint_addr
== 0)
356 struct minimal_symbol
*reg_symbol
;
358 /* Lookup the registration symbol. If it is missing, then we assume
359 we are not attached to a JIT. */
360 reg_symbol
= lookup_minimal_symbol (jit_break_name
, NULL
, NULL
);
361 if (reg_symbol
== NULL
)
363 inf_data
->breakpoint_addr
= SYMBOL_VALUE_ADDRESS (reg_symbol
);
364 if (inf_data
->breakpoint_addr
== 0)
367 /* If we have not read the jit descriptor yet (e.g. because the JITer
368 itself is in a shared library which just got loaded), do so now. */
369 if (inf_data
->descriptor_addr
== 0)
370 jit_inferior_init (gdbarch
);
376 fprintf_unfiltered (gdb_stdlog
,
377 "jit_breakpoint_re_set_internal, "
378 "breakpoint_addr = %s\n",
379 paddress (gdbarch
, inf_data
->breakpoint_addr
));
381 /* Put a breakpoint in the registration symbol. */
382 create_jit_event_breakpoint (gdbarch
, inf_data
->breakpoint_addr
);
387 /* Register any already created translations. */
390 jit_inferior_init (struct gdbarch
*gdbarch
)
392 struct jit_descriptor descriptor
;
393 struct jit_code_entry cur_entry
;
394 struct jit_inferior_data
*inf_data
;
395 CORE_ADDR cur_entry_addr
;
398 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
400 inf_data
= get_jit_inferior_data ();
401 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
404 if (inf_data
->descriptor_addr
== 0)
406 struct minimal_symbol
*desc_symbol
;
408 /* Lookup the descriptor symbol and cache the addr. If it is
409 missing, we assume we are not attached to a JIT and return early. */
410 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, NULL
);
411 if (desc_symbol
== NULL
)
414 inf_data
->descriptor_addr
= SYMBOL_VALUE_ADDRESS (desc_symbol
);
415 if (inf_data
->descriptor_addr
== 0)
420 fprintf_unfiltered (gdb_stdlog
,
421 "jit_inferior_init, descriptor_addr = %s\n",
422 paddress (gdbarch
, inf_data
->descriptor_addr
));
424 /* Read the descriptor so we can check the version number and load
425 any already JITed functions. */
426 jit_read_descriptor (gdbarch
, &descriptor
, inf_data
->descriptor_addr
);
428 /* Check that the version number agrees with that we support. */
429 if (descriptor
.version
!= 1)
430 error (_("Unsupported JIT protocol version in descriptor!"));
432 /* If we've attached to a running program, we need to check the descriptor
433 to register any functions that were already generated. */
434 for (cur_entry_addr
= descriptor
.first_entry
;
436 cur_entry_addr
= cur_entry
.next_entry
)
438 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
440 /* This hook may be called many times during setup, so make sure we don't
441 add the same symbol file twice. */
442 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
445 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
449 /* Exported routine to call when an inferior has been created. */
452 jit_inferior_created_hook (void)
454 jit_inferior_init (target_gdbarch
);
457 /* Exported routine to call to re-set the jit breakpoints,
458 e.g. when a program is rerun. */
461 jit_breakpoint_re_set (void)
463 jit_breakpoint_re_set_internal (target_gdbarch
,
464 get_jit_inferior_data ());
467 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
471 jit_reset_inferior_data_and_breakpoints (void)
473 struct jit_inferior_data
*inf_data
;
475 /* Force jit_inferior_init to re-lookup of jit symbol addresses. */
476 inf_data
= get_jit_inferior_data ();
477 inf_data
->breakpoint_addr
= 0;
478 inf_data
->descriptor_addr
= 0;
480 /* Remove any existing JIT breakpoint(s). */
481 remove_jit_event_breakpoints ();
483 jit_inferior_init (target_gdbarch
);
486 /* Wrapper to match the observer function pointer prototype. */
489 jit_inferior_created_observer (struct target_ops
*objfile
, int from_tty
)
491 jit_reset_inferior_data_and_breakpoints ();
494 /* This function cleans up any code entries left over when the
495 inferior exits. We get left over code when the inferior exits
496 without unregistering its code, for example when it crashes. */
499 jit_inferior_exit_hook (struct inferior
*inf
)
501 struct objfile
*objf
;
502 struct objfile
*temp
;
504 ALL_OBJFILES_SAFE (objf
, temp
)
505 if (objfile_data (objf
, jit_objfile_data
) != NULL
)
506 jit_unregister_code (objf
);
510 jit_executable_changed_observer (void)
512 jit_reset_inferior_data_and_breakpoints ();
516 jit_event_handler (struct gdbarch
*gdbarch
)
518 struct jit_descriptor descriptor
;
519 struct jit_code_entry code_entry
;
520 CORE_ADDR entry_addr
;
521 struct objfile
*objf
;
523 /* Read the descriptor from remote memory. */
524 jit_read_descriptor (gdbarch
, &descriptor
,
525 get_jit_inferior_data ()->descriptor_addr
);
526 entry_addr
= descriptor
.relevant_entry
;
528 /* Do the corresponding action. */
529 switch (descriptor
.action_flag
)
534 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
535 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
538 objf
= jit_find_objf_with_entry_addr (entry_addr
);
540 printf_unfiltered (_("Unable to find JITed code "
541 "entry at address: %s\n"),
542 paddress (gdbarch
, entry_addr
));
544 jit_unregister_code (objf
);
548 error (_("Unknown action_flag value in JIT descriptor!"));
553 /* Provide a prototype to silence -Wmissing-prototypes. */
555 extern void _initialize_jit (void);
558 _initialize_jit (void)
560 add_setshow_zinteger_cmd ("jit", class_maintenance
, &jit_debug
,
561 _("Set JIT debugging."),
562 _("Show JIT debugging."),
563 _("When non-zero, JIT debugging is enabled."),
566 &setdebuglist
, &showdebuglist
);
568 observer_attach_inferior_created (jit_inferior_created_observer
);
569 observer_attach_inferior_exit (jit_inferior_exit_hook
);
570 observer_attach_executable_changed (jit_executable_changed_observer
);
571 jit_objfile_data
= register_objfile_data ();
573 register_inferior_data_with_cleanup (jit_inferior_data_cleanup
);