gdb/jit.c

   1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22
  23 #include "jit.h"
  24 #include "breakpoint.h"
  25 #include "gdbcore.h"
  26 #include "observer.h"
  27 #include "objfiles.h"
  28 #include "symfile.h"
  29 #include "symtab.h"
  30 #include "target.h"
  31 #include "gdb_stat.h"
  32
  33 static const struct objfile_data *jit_objfile_data;
  34
  35 static const char *const jit_break_name = "__jit_debug_register_code";
  36
  37 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
  38
  39 /* This is the address of the JIT descriptor in the inferior.  */
  40
  41 static CORE_ADDR jit_descriptor_addr = 0;
  42
  43 /* This is a boolean indicating whether we're currently registering code.  This
  44    is used to avoid re-entering the registration code.  We want to check for
  45    new JITed every time a new object file is loaded, but we want to avoid
  46    checking for new code while we're registering object files for JITed code.
  47    Therefore, we flip this variable to 1 before registering new object files,
  48    and set it to 0 before returning.  */
  49
  50 static int registering_code = 0;
  51
  52 /* Helper cleanup function to clear an integer flag like the one above.  */
  53
  54 static void
  55 clear_int (void *int_addr)
  56 {
  57   *((int *) int_addr) = 0;
  58 }
  59
  60 struct target_buffer
  61 {
  62   CORE_ADDR base;
  63   size_t size;
  64 };
  65
  66 /* Openning the file is a no-op.  */
  67
  68 static void *
  69 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
  70 {
  71   return open_closure;
  72 }
  73
  74 /* Closing the file is just freeing the base/size pair on our side.  */
  75
  76 static int
  77 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
  78 {
  79   xfree (stream);
  80   return 1;
  81 }
  82
  83 /* For reading the file, we just need to pass through to target_read_memory and
  84    fix up the arguments and return values.  */
  85
  86 static file_ptr
  87 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
  88                      file_ptr nbytes, file_ptr offset)
  89 {
  90   int err;
  91   struct target_buffer *buffer = (struct target_buffer *) stream;
  92
  93   /* If this read will read all of the file, limit it to just the rest.  */
  94   if (offset + nbytes > buffer->size)
  95     nbytes = buffer->size - offset;
  96
  97   /* If there are no more bytes left, we've reached EOF.  */
  98   if (nbytes == 0)
  99     return 0;
 100
 101   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
 102   if (err)
 103     return -1;
 104
 105   return nbytes;
 106 }
 107
 108 /* For statting the file, we only support the st_size attribute.  */
 109
 110 static int
 111 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 112 {
 113   struct target_buffer *buffer = (struct target_buffer*) stream;
 114
 115   sb->st_size = buffer->size;
 116   return 0;
 117 }
 118
 119 /* Open a BFD from the target's memory.  */
 120
 121 static struct bfd *
 122 bfd_open_from_target_memory (CORE_ADDR addr, size_t size, char *target)
 123 {
 124   const char *filename = xstrdup ("<in-memory>");
 125   struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
 126
 127   buffer->base = addr;
 128   buffer->size = size;
 129   return bfd_openr_iovec (filename, target,
 130                           mem_bfd_iovec_open,
 131                           buffer,
 132                           mem_bfd_iovec_pread,
 133                           mem_bfd_iovec_close,
 134                           mem_bfd_iovec_stat);
 135 }
 136
 137 /* Helper function for reading the global JIT descriptor from remote memory.  */
 138
 139 static void
 140 jit_read_descriptor (struct gdbarch *gdbarch,
 141                      struct jit_descriptor *descriptor)
 142 {
 143   int err;
 144   struct type *ptr_type;
 145   int ptr_size;
 146   int desc_size;
 147   gdb_byte *desc_buf;
 148   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 149
 150   /* Figure out how big the descriptor is on the remote and how to read it.  */
 151   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 152   ptr_size = TYPE_LENGTH (ptr_type);
 153   desc_size = 8 + 2 * ptr_size;  /* Two 32-bit ints and two pointers.  */
 154   desc_buf = alloca (desc_size);
 155
 156   /* Read the descriptor.  */
 157   err = target_read_memory (jit_descriptor_addr, desc_buf, desc_size);
 158   if (err)
 159     error (_("Unable to read JIT descriptor from remote memory!"));
 160
 161   /* Fix the endianness to match the host.  */
 162   descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
 163   descriptor->action_flag =
 164       extract_unsigned_integer (&desc_buf[4], 4, byte_order);
 165   descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
 166   descriptor->first_entry =
 167       extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
 168 }
 169
 170 /* Helper function for reading a JITed code entry from remote memory.  */
 171
 172 static void
 173 jit_read_code_entry (struct gdbarch *gdbarch,
 174                      CORE_ADDR code_addr, struct jit_code_entry *code_entry)
 175 {
 176   int err;
 177   struct type *ptr_type;
 178   int ptr_size;
 179   int entry_size;
 180   gdb_byte *entry_buf;
 181   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 182
 183   /* Figure out how big the entry 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   entry_size = 3 * ptr_size + 8;  /* Three pointers and one 64-bit int.  */
 187   entry_buf = alloca (entry_size);
 188
 189   /* Read the entry.  */
 190   err = target_read_memory (code_addr, entry_buf, entry_size);
 191   if (err)
 192     error (_("Unable to read JIT code entry from remote memory!"));
 193
 194   /* Fix the endianness to match the host.  */
 195   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 196   code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
 197   code_entry->prev_entry =
 198       extract_typed_address (&entry_buf[ptr_size], ptr_type);
 199   code_entry->symfile_addr =
 200       extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
 201   code_entry->symfile_size =
 202       extract_unsigned_integer (&entry_buf[3 * ptr_size], 8, byte_order);
 203 }
 204
 205 /* This function registers code associated with a JIT code entry.  It uses the
 206    pointer and size pair in the entry to read the symbol file from the remote
 207    and then calls symbol_file_add_from_local_memory to add it as though it were
 208    a symbol file added by the user.  */
 209
 210 static void
 211 jit_register_code (struct gdbarch *gdbarch,
 212                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
 213 {
 214   bfd *nbfd;
 215   struct section_addr_info *sai;
 216   struct bfd_section *sec;
 217   struct objfile *objfile;
 218   struct cleanup *old_cleanups, *my_cleanups;
 219   int i;
 220   const struct bfd_arch_info *b;
 221   CORE_ADDR *entry_addr_ptr;
 222
 223   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
 224                                       code_entry->symfile_size, gnutarget);
 225   old_cleanups = make_cleanup_bfd_close (nbfd);
 226
 227   /* Check the format.  NOTE: This initializes important data that GDB uses!
 228      We would segfault later without this line.  */
 229   if (!bfd_check_format (nbfd, bfd_object))
 230     {
 231       printf_unfiltered (_("\
 232 JITed symbol file is not an object file, ignoring it.\n"));
 233       do_cleanups (old_cleanups);
 234       return;
 235     }
 236
 237   /* Check bfd arch.  */
 238   b = gdbarch_bfd_arch_info (gdbarch);
 239   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
 240     warning (_("JITed object file architecture %s is not compatible "
 241                "with target architecture %s."), bfd_get_arch_info
 242              (nbfd)->printable_name, b->printable_name);
 243
 244   /* Read the section address information out of the symbol file.  Since the
 245      file is generated by the JIT at runtime, it should all of the absolute
 246      addresses that we care about.  */
 247   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
 248   make_cleanup_free_section_addr_info (sai);
 249   i = 0;
 250   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 251     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 252       {
 253         /* We assume that these virtual addresses are absolute, and do not
 254            treat them as offsets.  */
 255         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
 256         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
 257         sai->other[i].sectindex = sec->index;
 258         ++i;
 259       }
 260
 261   /* Raise this flag while we register code so we won't trigger any
 262      re-registration.  */
 263   registering_code = 1;
 264   my_cleanups = make_cleanup (clear_int, &registering_code);
 265
 266   /* This call takes ownership of sai.  */
 267   objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED);
 268
 269   /* Clear the registering_code flag.  */
 270   do_cleanups (my_cleanups);
 271
 272   /* Remember a mapping from entry_addr to objfile.  */
 273   entry_addr_ptr = xmalloc (sizeof (CORE_ADDR));
 274   *entry_addr_ptr = entry_addr;
 275   set_objfile_data (objfile, jit_objfile_data, entry_addr_ptr);
 276
 277   discard_cleanups (old_cleanups);
 278 }
 279
 280 /* This function unregisters JITed code and frees the corresponding objfile.  */
 281
 282 static void
 283 jit_unregister_code (struct objfile *objfile)
 284 {
 285   free_objfile (objfile);
 286 }
 287
 288 /* Look up the objfile with this code entry address.  */
 289
 290 static struct objfile *
 291 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 292 {
 293   struct objfile *objf;
 294   CORE_ADDR *objf_entry_addr;
 295
 296   ALL_OBJFILES (objf)
 297     {
 298       objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
 299       if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
 300         return objf;
 301     }
 302   return NULL;
 303 }
 304
 305 /* (Re-)Initialize the jit breakpoint handler, and register any already
 306    created translations.  */
 307
 308 static void
 309 jit_inferior_init (struct gdbarch *gdbarch)
 310 {
 311   struct minimal_symbol *reg_symbol;
 312   struct minimal_symbol *desc_symbol;
 313   CORE_ADDR reg_addr;
 314   struct jit_descriptor descriptor;
 315   struct jit_code_entry cur_entry;
 316   CORE_ADDR cur_entry_addr;
 317   struct cleanup *old_cleanups;
 318
 319   /* When we register code, GDB resets its breakpoints in case symbols have
 320      changed.  That in turn calls this handler, which makes us look for new
 321      code again.  To avoid being re-entered, we check this flag.  */
 322   if (registering_code)
 323     return;
 324
 325   /* Lookup the registration symbol.  If it is missing, then we assume we are
 326      not attached to a JIT.  */
 327   reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL);
 328   if (reg_symbol == NULL)
 329     return;
 330   reg_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
 331   if (reg_addr == 0)
 332     return;
 333
 334   /* Lookup the descriptor symbol and cache the addr.  If it is missing, we
 335      assume we are not attached to a JIT and return early.  */
 336   desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL);
 337   if (desc_symbol == NULL)
 338     return;
 339   jit_descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
 340   if (jit_descriptor_addr == 0)
 341     return;
 342
 343   /* Read the descriptor so we can check the version number and load any already
 344      JITed functions.  */
 345   jit_read_descriptor (gdbarch, &descriptor);
 346
 347   /* Check that the version number agrees with that we support.  */
 348   if (descriptor.version != 1)
 349     error (_("Unsupported JIT protocol version in descriptor!"));
 350
 351   /* Put a breakpoint in the registration symbol.  */
 352   create_jit_event_breakpoint (gdbarch, reg_addr);
 353
 354   /* If we've attached to a running program, we need to check the descriptor to
 355      register any functions that were already generated.  */
 356   for (cur_entry_addr = descriptor.first_entry;
 357        cur_entry_addr != 0;
 358        cur_entry_addr = cur_entry.next_entry)
 359     {
 360       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
 361
 362       /* This hook may be called many times during setup, so make sure we don't
 363          add the same symbol file twice.  */
 364       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
 365         continue;
 366
 367       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
 368     }
 369 }
 370
 371 /* Exported routine to call when an inferior has been created.  */
 372
 373 void
 374 jit_inferior_created_hook (void)
 375 {
 376   jit_inferior_init (target_gdbarch);
 377 }
 378
 379 /* Exported routine to call to re-set the jit breakpoints,
 380    e.g. when a program is rerun.  */
 381
 382 void
 383 jit_breakpoint_re_set (void)
 384 {
 385   jit_inferior_init (target_gdbarch);
 386 }
 387
 388 /* Wrapper to match the observer function pointer prototype.  */
 389
 390 static void
 391 jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
 392 {
 393   jit_inferior_init (target_gdbarch);
 394 }
 395
 396 /* This function cleans up any code entries left over when the inferior exits.
 397    We get left over code when the inferior exits without unregistering its code,
 398    for example when it crashes.  */
 399
 400 static void
 401 jit_inferior_exit_hook (int pid)
 402 {
 403   struct objfile *objf;
 404   struct objfile *temp;
 405
 406   /* We need to reset the descriptor addr so that next time we load up the
 407      inferior we look for it again.  */
 408   jit_descriptor_addr = 0;
 409
 410   ALL_OBJFILES_SAFE (objf, temp)
 411     if (objfile_data (objf, jit_objfile_data) != NULL)
 412       jit_unregister_code (objf);
 413 }
 414
 415 void
 416 jit_event_handler (struct gdbarch *gdbarch)
 417 {
 418   struct jit_descriptor descriptor;
 419   struct jit_code_entry code_entry;
 420   CORE_ADDR entry_addr;
 421   struct objfile *objf;
 422
 423   /* Read the descriptor from remote memory.  */
 424   jit_read_descriptor (gdbarch, &descriptor);
 425   entry_addr = descriptor.relevant_entry;
 426
 427   /* Do the corresponding action. */
 428   switch (descriptor.action_flag)
 429     {
 430     case JIT_NOACTION:
 431       break;
 432     case JIT_REGISTER:
 433       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
 434       jit_register_code (gdbarch, entry_addr, &code_entry);
 435       break;
 436     case JIT_UNREGISTER:
 437       objf = jit_find_objf_with_entry_addr (entry_addr);
 438       if (objf == NULL)
 439         printf_unfiltered (_("Unable to find JITed code entry at address: %s\n"),
 440                            paddress (gdbarch, entry_addr));
 441       else
 442         jit_unregister_code (objf);
 443
 444       break;
 445     default:
 446       error (_("Unknown action_flag value in JIT descriptor!"));
 447       break;
 448     }
 449 }
 450
 451 /* Provide a prototype to silence -Wmissing-prototypes.  */
 452
 453 extern void _initialize_jit (void);
 454
 455 void
 456 _initialize_jit (void)
 457 {
 458   observer_attach_inferior_created (jit_inferior_created_observer);
 459   observer_attach_inferior_exit (jit_inferior_exit_hook);
 460   jit_objfile_data = register_objfile_data ();
 461 }