gdb/jit.c

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