gdb/jit.c

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