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 "inferior.h"
  28 #include "observer.h"
  29 #include "objfiles.h"
  30 #include "symfile.h"
  31 #include "symtab.h"
  32 #include "target.h"
  33 #include "gdb_stat.h"
  34
  35 static const struct objfile_data *jit_objfile_data;
  36
  37 static const char *const jit_break_name = "__jit_debug_register_code";
  38
  39 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
  40
  41 static const struct inferior_data *jit_inferior_data = NULL;
  42
  43 static void jit_inferior_init (struct gdbarch *gdbarch);
  44
  45 /* Non-zero if we want to see trace of jit level stuff.  */
  46
  47 static int jit_debug = 0;
  48
  49 static void
  50 show_jit_debug (struct ui_file *file, int from_tty,
  51                 struct cmd_list_element *c, const char *value)
  52 {
  53   fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
  54 }
  55
  56 struct target_buffer
  57 {
  58   CORE_ADDR base;
  59   ULONGEST size;
  60 };
  61
  62 /* Openning the file is a no-op.  */
  63
  64 static void *
  65 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
  66 {
  67   return open_closure;
  68 }
  69
  70 /* Closing the file is just freeing the base/size pair on our side.  */
  71
  72 static int
  73 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
  74 {
  75   xfree (stream);
  76   return 1;
  77 }
  78
  79 /* For reading the file, we just need to pass through to target_read_memory and
  80    fix up the arguments and return values.  */
  81
  82 static file_ptr
  83 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
  84                      file_ptr nbytes, file_ptr offset)
  85 {
  86   int err;
  87   struct target_buffer *buffer = (struct target_buffer *) stream;
  88
  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;
  92
  93   /* If there are no more bytes left, we've reached EOF.  */
  94   if (nbytes == 0)
  95     return 0;
  96
  97   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
  98   if (err)
  99     return -1;
 100
 101   return nbytes;
 102 }
 103
 104 /* For statting the file, we only support the st_size attribute.  */
 105
 106 static int
 107 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 108 {
 109   struct target_buffer *buffer = (struct target_buffer*) stream;
 110
 111   sb->st_size = buffer->size;
 112   return 0;
 113 }
 114
 115 /* Open a BFD from the target's memory.  */
 116
 117 static struct bfd *
 118 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
 119 {
 120   const char *filename = xstrdup ("<in-memory>");
 121   struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
 122
 123   buffer->base = addr;
 124   buffer->size = size;
 125   return bfd_openr_iovec (filename, target,
 126                           mem_bfd_iovec_open,
 127                           buffer,
 128                           mem_bfd_iovec_pread,
 129                           mem_bfd_iovec_close,
 130                           mem_bfd_iovec_stat);
 131 }
 132
 133 /* Per-inferior structure recording the addresses in the inferior.  */
 134
 135 struct jit_inferior_data
 136 {
 137   CORE_ADDR breakpoint_addr;  /* &__jit_debug_register_code()  */
 138   CORE_ADDR descriptor_addr;  /* &__jit_debug_descriptor  */
 139 };
 140
 141 /* Return jit_inferior_data for current inferior.  Allocate if not already
 142    present.  */
 143
 144 static struct jit_inferior_data *
 145 get_jit_inferior_data (void)
 146 {
 147   struct inferior *inf;
 148   struct jit_inferior_data *inf_data;
 149
 150   inf = current_inferior ();
 151   inf_data = inferior_data (inf, jit_inferior_data);
 152   if (inf_data == NULL)
 153     {
 154       inf_data = XZALLOC (struct jit_inferior_data);
 155       set_inferior_data (inf, jit_inferior_data, inf_data);
 156     }
 157
 158   return inf_data;
 159 }
 160
 161 static void
 162 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
 163 {
 164   xfree (arg);
 165 }
 166
 167 /* Helper function for reading the global JIT descriptor from remote
 168    memory.  */
 169
 170 static void
 171 jit_read_descriptor (struct gdbarch *gdbarch,
 172                      struct jit_descriptor *descriptor,
 173                      CORE_ADDR descriptor_addr)
 174 {
 175   int err;
 176   struct type *ptr_type;
 177   int ptr_size;
 178   int desc_size;
 179   gdb_byte *desc_buf;
 180   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 181
 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);
 187
 188   /* Read the descriptor.  */
 189   err = target_read_memory (descriptor_addr, desc_buf, desc_size);
 190   if (err)
 191     error (_("Unable to read JIT descriptor from remote memory!"));
 192
 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);
 200 }
 201
 202 /* Helper function for reading a JITed code entry from remote memory.  */
 203
 204 static void
 205 jit_read_code_entry (struct gdbarch *gdbarch,
 206                      CORE_ADDR code_addr, struct jit_code_entry *code_entry)
 207 {
 208   int err, off;
 209   struct type *ptr_type;
 210   int ptr_size;
 211   int entry_size;
 212   int align_bytes;
 213   gdb_byte *entry_buf;
 214   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 215
 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);
 221
 222   /* Read the entry.  */
 223   err = target_read_memory (code_addr, entry_buf, entry_size);
 224   if (err)
 225     error (_("Unable to read JIT code entry from remote memory!"));
 226
 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);
 234
 235   align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
 236   off = 3 * ptr_size;
 237   off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
 238
 239   code_entry->symfile_size =
 240       extract_unsigned_integer (&entry_buf[off], 8, byte_order);
 241 }
 242
 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.  */
 247
 248 static void
 249 jit_register_code (struct gdbarch *gdbarch,
 250                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
 251 {
 252   bfd *nbfd;
 253   struct section_addr_info *sai;
 254   struct bfd_section *sec;
 255   struct objfile *objfile;
 256   struct cleanup *old_cleanups;
 257   int i;
 258   const struct bfd_arch_info *b;
 259   CORE_ADDR *entry_addr_ptr;
 260
 261   if (jit_debug)
 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));
 267
 268   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
 269                                       code_entry->symfile_size, gnutarget);
 270   if (nbfd == NULL)
 271     {
 272       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
 273       return;
 274     }
 275
 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))
 279     {
 280       printf_unfiltered (_("\
 281 JITed symbol file is not an object file, ignoring it.\n"));
 282       bfd_close (nbfd);
 283       return;
 284     }
 285
 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);
 292
 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);
 298   i = 0;
 299   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 300     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 301       {
 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;
 307         ++i;
 308       }
 309
 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);
 312
 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);
 317
 318   do_cleanups (old_cleanups);
 319 }
 320
 321 /* This function unregisters JITed code and frees the corresponding
 322    objfile.  */
 323
 324 static void
 325 jit_unregister_code (struct objfile *objfile)
 326 {
 327   free_objfile (objfile);
 328 }
 329
 330 /* Look up the objfile with this code entry address.  */
 331
 332 static struct objfile *
 333 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 334 {
 335   struct objfile *objf;
 336   CORE_ADDR *objf_entry_addr;
 337
 338   ALL_OBJFILES (objf)
 339     {
 340       objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
 341       if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
 342         return objf;
 343     }
 344   return NULL;
 345 }
 346
 347 /* (Re-)Initialize the jit breakpoint if necessary.
 348    Return 0 on success.  */
 349
 350 static int
 351 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 352                                 struct jit_inferior_data *inf_data)
 353 {
 354   if (inf_data->breakpoint_addr == 0)
 355     {
 356       struct minimal_symbol *reg_symbol;
 357
 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)
 362         return 1;
 363       inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
 364       if (inf_data->breakpoint_addr == 0)
 365         return 2;
 366
 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);
 371     }
 372   else
 373     return 0;
 374
 375   if (jit_debug)
 376     fprintf_unfiltered (gdb_stdlog,
 377                         "jit_breakpoint_re_set_internal, "
 378                         "breakpoint_addr = %s\n",
 379                         paddress (gdbarch, inf_data->breakpoint_addr));
 380
 381   /* Put a breakpoint in the registration symbol.  */
 382   create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr);
 383
 384   return 0;
 385 }
 386
 387 /* Register any already created translations.  */
 388
 389 static void
 390 jit_inferior_init (struct gdbarch *gdbarch)
 391 {
 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;
 396
 397   if (jit_debug)
 398     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
 399
 400   inf_data = get_jit_inferior_data ();
 401   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
 402     return;
 403
 404   if (inf_data->descriptor_addr == 0)
 405     {
 406       struct minimal_symbol *desc_symbol;
 407
 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)
 412         return;
 413
 414       inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
 415       if (inf_data->descriptor_addr == 0)
 416         return;
 417     }
 418
 419   if (jit_debug)
 420     fprintf_unfiltered (gdb_stdlog,
 421                         "jit_inferior_init, descriptor_addr = %s\n",
 422                         paddress (gdbarch, inf_data->descriptor_addr));
 423
 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);
 427
 428   /* Check that the version number agrees with that we support.  */
 429   if (descriptor.version != 1)
 430     error (_("Unsupported JIT protocol version in descriptor!"));
 431
 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;
 435        cur_entry_addr != 0;
 436        cur_entry_addr = cur_entry.next_entry)
 437     {
 438       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
 439
 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)
 443         continue;
 444
 445       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
 446     }
 447 }
 448
 449 /* Exported routine to call when an inferior has been created.  */
 450
 451 void
 452 jit_inferior_created_hook (void)
 453 {
 454   jit_inferior_init (target_gdbarch);
 455 }
 456
 457 /* Exported routine to call to re-set the jit breakpoints,
 458    e.g. when a program is rerun.  */
 459
 460 void
 461 jit_breakpoint_re_set (void)
 462 {
 463   jit_breakpoint_re_set_internal (target_gdbarch,
 464                                   get_jit_inferior_data ());
 465 }
 466
 467 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
 468    will be reset.  */
 469
 470 static void
 471 jit_reset_inferior_data_and_breakpoints (void)
 472 {
 473   struct jit_inferior_data *inf_data;
 474
 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;
 479
 480   /* Remove any existing JIT breakpoint(s).  */
 481   remove_jit_event_breakpoints ();
 482
 483   jit_inferior_init (target_gdbarch);
 484 }
 485
 486 /* Wrapper to match the observer function pointer prototype.  */
 487
 488 static void
 489 jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
 490 {
 491   jit_reset_inferior_data_and_breakpoints ();
 492 }
 493
 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.  */
 497
 498 static void
 499 jit_inferior_exit_hook (struct inferior *inf)
 500 {
 501   struct objfile *objf;
 502   struct objfile *temp;
 503
 504   ALL_OBJFILES_SAFE (objf, temp)
 505     if (objfile_data (objf, jit_objfile_data) != NULL)
 506       jit_unregister_code (objf);
 507 }
 508
 509 static void
 510 jit_executable_changed_observer (void)
 511 {
 512   jit_reset_inferior_data_and_breakpoints ();
 513 }
 514
 515 void
 516 jit_event_handler (struct gdbarch *gdbarch)
 517 {
 518   struct jit_descriptor descriptor;
 519   struct jit_code_entry code_entry;
 520   CORE_ADDR entry_addr;
 521   struct objfile *objf;
 522
 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;
 527
 528   /* Do the corresponding action.  */
 529   switch (descriptor.action_flag)
 530     {
 531     case JIT_NOACTION:
 532       break;
 533     case JIT_REGISTER:
 534       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
 535       jit_register_code (gdbarch, entry_addr, &code_entry);
 536       break;
 537     case JIT_UNREGISTER:
 538       objf = jit_find_objf_with_entry_addr (entry_addr);
 539       if (objf == NULL)
 540         printf_unfiltered (_("Unable to find JITed code "
 541                              "entry at address: %s\n"),
 542                            paddress (gdbarch, entry_addr));
 543       else
 544         jit_unregister_code (objf);
 545
 546       break;
 547     default:
 548       error (_("Unknown action_flag value in JIT descriptor!"));
 549       break;
 550     }
 551 }
 552
 553 /* Provide a prototype to silence -Wmissing-prototypes.  */
 554
 555 extern void _initialize_jit (void);
 556
 557 void
 558 _initialize_jit (void)
 559 {
 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."),
 564                             NULL,
 565                             show_jit_debug,
 566                             &setdebuglist, &showdebuglist);
 567
 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 ();
 572   jit_inferior_data =
 573     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
 574 }