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, *my_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   old_cleanups = make_cleanup_bfd_close (nbfd);
 271
 272   /* Check the format.  NOTE: This initializes important data that GDB uses!
 273      We would segfault later without this line.  */
 274   if (!bfd_check_format (nbfd, bfd_object))
 275     {
 276       printf_unfiltered (_("\
 277 JITed symbol file is not an object file, ignoring it.\n"));
 278       do_cleanups (old_cleanups);
 279       return;
 280     }
 281
 282   /* Check bfd arch.  */
 283   b = gdbarch_bfd_arch_info (gdbarch);
 284   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
 285     warning (_("JITed object file architecture %s is not compatible "
 286                "with target architecture %s."), bfd_get_arch_info
 287              (nbfd)->printable_name, b->printable_name);
 288
 289   /* Read the section address information out of the symbol file.  Since the
 290      file is generated by the JIT at runtime, it should all of the absolute
 291      addresses that we care about.  */
 292   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
 293   make_cleanup_free_section_addr_info (sai);
 294   i = 0;
 295   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 296     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 297       {
 298         /* We assume that these virtual addresses are absolute, and do not
 299            treat them as offsets.  */
 300         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
 301         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
 302         sai->other[i].sectindex = sec->index;
 303         ++i;
 304       }
 305
 306   /* This call takes ownership of sai.  */
 307   objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
 308
 309   /* Remember a mapping from entry_addr to objfile.  */
 310   entry_addr_ptr = xmalloc (sizeof (CORE_ADDR));
 311   *entry_addr_ptr = entry_addr;
 312   set_objfile_data (objfile, jit_objfile_data, entry_addr_ptr);
 313
 314   discard_cleanups (old_cleanups);
 315 }
 316
 317 /* This function unregisters JITed code and frees the corresponding
 318    objfile.  */
 319
 320 static void
 321 jit_unregister_code (struct objfile *objfile)
 322 {
 323   free_objfile (objfile);
 324 }
 325
 326 /* Look up the objfile with this code entry address.  */
 327
 328 static struct objfile *
 329 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 330 {
 331   struct objfile *objf;
 332   CORE_ADDR *objf_entry_addr;
 333
 334   ALL_OBJFILES (objf)
 335     {
 336       objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
 337       if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
 338         return objf;
 339     }
 340   return NULL;
 341 }
 342
 343 /* (Re-)Initialize the jit breakpoint if necessary.
 344    Return 0 on success.  */
 345
 346 static int
 347 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 348                                 struct jit_inferior_data *inf_data)
 349 {
 350   if (inf_data->breakpoint_addr == 0)
 351     {
 352       struct minimal_symbol *reg_symbol;
 353
 354       /* Lookup the registration symbol.  If it is missing, then we assume
 355          we are not attached to a JIT.  */
 356       reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL);
 357       if (reg_symbol == NULL)
 358         return 1;
 359       inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
 360       if (inf_data->breakpoint_addr == 0)
 361         return 2;
 362
 363       /* If we have not read the jit descriptor yet (e.g. because the JITer
 364          itself is in a shared library which just got loaded), do so now.  */
 365       if (inf_data->descriptor_addr == 0)
 366         jit_inferior_init (gdbarch);
 367     }
 368   else
 369     return 0;
 370
 371   if (jit_debug)
 372     fprintf_unfiltered (gdb_stdlog,
 373                         "jit_breakpoint_re_set_internal, "
 374                         "breakpoint_addr = %s\n",
 375                         paddress (gdbarch, inf_data->breakpoint_addr));
 376
 377   /* Put a breakpoint in the registration symbol.  */
 378   create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr);
 379
 380   return 0;
 381 }
 382
 383 /* Register any already created translations.  */
 384
 385 static void
 386 jit_inferior_init (struct gdbarch *gdbarch)
 387 {
 388   struct jit_descriptor descriptor;
 389   struct jit_code_entry cur_entry;
 390   struct jit_inferior_data *inf_data;
 391   CORE_ADDR cur_entry_addr;
 392
 393   if (jit_debug)
 394     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
 395
 396   inf_data = get_jit_inferior_data ();
 397   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
 398     return;
 399
 400   if (inf_data->descriptor_addr == 0)
 401     {
 402       struct minimal_symbol *desc_symbol;
 403
 404       /* Lookup the descriptor symbol and cache the addr.  If it is
 405          missing, we assume we are not attached to a JIT and return early.  */
 406       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL);
 407       if (desc_symbol == NULL)
 408         return;
 409
 410       inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
 411       if (inf_data->descriptor_addr == 0)
 412         return;
 413     }
 414
 415   if (jit_debug)
 416     fprintf_unfiltered (gdb_stdlog,
 417                         "jit_inferior_init, descriptor_addr = %s\n",
 418                         paddress (gdbarch, inf_data->descriptor_addr));
 419
 420   /* Read the descriptor so we can check the version number and load
 421      any already JITed functions.  */
 422   jit_read_descriptor (gdbarch, &descriptor, inf_data->descriptor_addr);
 423
 424   /* Check that the version number agrees with that we support.  */
 425   if (descriptor.version != 1)
 426     error (_("Unsupported JIT protocol version in descriptor!"));
 427
 428   /* If we've attached to a running program, we need to check the descriptor
 429      to register any functions that were already generated.  */
 430   for (cur_entry_addr = descriptor.first_entry;
 431        cur_entry_addr != 0;
 432        cur_entry_addr = cur_entry.next_entry)
 433     {
 434       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
 435
 436       /* This hook may be called many times during setup, so make sure we don't
 437          add the same symbol file twice.  */
 438       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
 439         continue;
 440
 441       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
 442     }
 443 }
 444
 445 /* Exported routine to call when an inferior has been created.  */
 446
 447 void
 448 jit_inferior_created_hook (void)
 449 {
 450   jit_inferior_init (target_gdbarch);
 451 }
 452
 453 /* Exported routine to call to re-set the jit breakpoints,
 454    e.g. when a program is rerun.  */
 455
 456 void
 457 jit_breakpoint_re_set (void)
 458 {
 459   jit_breakpoint_re_set_internal (target_gdbarch,
 460                                   get_jit_inferior_data ());
 461 }
 462
 463 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
 464    will be reset.  */
 465
 466 static void
 467 jit_reset_inferior_data_and_breakpoints (void)
 468 {
 469   struct jit_inferior_data *inf_data;
 470
 471   /* Force jit_inferior_init to re-lookup of jit symbol addresses.  */
 472   inf_data = get_jit_inferior_data ();
 473   inf_data->breakpoint_addr = 0;
 474   inf_data->descriptor_addr = 0;
 475
 476   /* Remove any existing JIT breakpoint(s).  */
 477   remove_jit_event_breakpoints ();
 478
 479   jit_inferior_init (target_gdbarch);
 480 }
 481
 482 /* Wrapper to match the observer function pointer prototype.  */
 483
 484 static void
 485 jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
 486 {
 487   jit_reset_inferior_data_and_breakpoints ();
 488 }
 489
 490 /* This function cleans up any code entries left over when the
 491    inferior exits.  We get left over code when the inferior exits
 492    without unregistering its code, for example when it crashes.  */
 493
 494 static void
 495 jit_inferior_exit_hook (struct inferior *inf)
 496 {
 497   struct objfile *objf;
 498   struct objfile *temp;
 499
 500   ALL_OBJFILES_SAFE (objf, temp)
 501     if (objfile_data (objf, jit_objfile_data) != NULL)
 502       jit_unregister_code (objf);
 503 }
 504
 505 static void
 506 jit_executable_changed_observer (void)
 507 {
 508   jit_reset_inferior_data_and_breakpoints ();
 509 }
 510
 511 void
 512 jit_event_handler (struct gdbarch *gdbarch)
 513 {
 514   struct jit_descriptor descriptor;
 515   struct jit_code_entry code_entry;
 516   CORE_ADDR entry_addr;
 517   struct objfile *objf;
 518
 519   /* Read the descriptor from remote memory.  */
 520   jit_read_descriptor (gdbarch, &descriptor,
 521                        get_jit_inferior_data ()->descriptor_addr);
 522   entry_addr = descriptor.relevant_entry;
 523
 524   /* Do the corresponding action.  */
 525   switch (descriptor.action_flag)
 526     {
 527     case JIT_NOACTION:
 528       break;
 529     case JIT_REGISTER:
 530       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
 531       jit_register_code (gdbarch, entry_addr, &code_entry);
 532       break;
 533     case JIT_UNREGISTER:
 534       objf = jit_find_objf_with_entry_addr (entry_addr);
 535       if (objf == NULL)
 536         printf_unfiltered (_("Unable to find JITed code "
 537                              "entry at address: %s\n"),
 538                            paddress (gdbarch, entry_addr));
 539       else
 540         jit_unregister_code (objf);
 541
 542       break;
 543     default:
 544       error (_("Unknown action_flag value in JIT descriptor!"));
 545       break;
 546     }
 547 }
 548
 549 /* Provide a prototype to silence -Wmissing-prototypes.  */
 550
 551 extern void _initialize_jit (void);
 552
 553 void
 554 _initialize_jit (void)
 555 {
 556   add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
 557                             _("Set JIT debugging."),
 558                             _("Show JIT debugging."),
 559                             _("When non-zero, JIT debugging is enabled."),
 560                             NULL,
 561                             show_jit_debug,
 562                             &setdebuglist, &showdebuglist);
 563
 564   observer_attach_inferior_created (jit_inferior_created_observer);
 565   observer_attach_inferior_exit (jit_inferior_exit_hook);
 566   observer_attach_executable_changed (jit_executable_changed_observer);
 567   jit_objfile_data = register_objfile_data ();
 568   jit_inferior_data =
 569     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
 570 }