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 "jit-reader.h"
  24 #include "block.h"
  25 #include "breakpoint.h"
  26 #include "command.h"
  27 #include "dictionary.h"
  28 #include "frame-unwind.h"
  29 #include "gdbcmd.h"
  30 #include "gdbcore.h"
  31 #include "inferior.h"
  32 #include "observer.h"
  33 #include "objfiles.h"
  34 #include "symfile.h"
  35 #include "symtab.h"
  36 #include "target.h"
  37 #include "gdb-dlfcn.h"
  38 #include "gdb_stat.h"
  39 #include "exceptions.h"
  40
  41 static const char *jit_reader_dir = NULL;
  42
  43 static const struct objfile_data *jit_objfile_data;
  44
  45 static const char *const jit_break_name = "__jit_debug_register_code";
  46
  47 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
  48
  49 static const struct inferior_data *jit_inferior_data = NULL;
  50
  51 static void jit_inferior_init (struct gdbarch *gdbarch);
  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 struct target_buffer
  65 {
  66   CORE_ADDR base;
  67   ULONGEST size;
  68 };
  69
  70 /* Openning the file is a no-op.  */
  71
  72 static void *
  73 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
  74 {
  75   return open_closure;
  76 }
  77
  78 /* Closing the file is just freeing the base/size pair on our side.  */
  79
  80 static int
  81 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
  82 {
  83   xfree (stream);
  84   return 1;
  85 }
  86
  87 /* For reading the file, we just need to pass through to target_read_memory and
  88    fix up the arguments and return values.  */
  89
  90 static file_ptr
  91 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
  92                      file_ptr nbytes, file_ptr offset)
  93 {
  94   int err;
  95   struct target_buffer *buffer = (struct target_buffer *) stream;
  96
  97   /* If this read will read all of the file, limit it to just the rest.  */
  98   if (offset + nbytes > buffer->size)
  99     nbytes = buffer->size - offset;
 100
 101   /* If there are no more bytes left, we've reached EOF.  */
 102   if (nbytes == 0)
 103     return 0;
 104
 105   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
 106   if (err)
 107     return -1;
 108
 109   return nbytes;
 110 }
 111
 112 /* For statting the file, we only support the st_size attribute.  */
 113
 114 static int
 115 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 116 {
 117   struct target_buffer *buffer = (struct target_buffer*) stream;
 118
 119   sb->st_size = buffer->size;
 120   return 0;
 121 }
 122
 123 /* One reader that has been loaded successfully, and can potentially be used to
 124    parse debug info.  */
 125
 126 static struct jit_reader
 127 {
 128   struct gdb_reader_funcs *functions;
 129   void *handle;
 130 } *loaded_jit_reader = NULL;
 131
 132 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
 133 static const char *reader_init_fn_sym = "gdb_init_reader";
 134
 135 /* Try to load FILE_NAME as a JIT debug info reader.  */
 136
 137 static struct jit_reader *
 138 jit_reader_load (const char *file_name)
 139 {
 140   void *so;
 141   reader_init_fn_type *init_fn;
 142   struct jit_reader *new_reader = NULL;
 143   struct gdb_reader_funcs *funcs = NULL;
 144   struct cleanup *old_cleanups;
 145
 146   if (jit_debug)
 147     fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
 148                         file_name);
 149   so = gdb_dlopen (file_name);
 150   old_cleanups = make_cleanup_dlclose (so);
 151
 152   init_fn = gdb_dlsym (so, reader_init_fn_sym);
 153   if (!init_fn)
 154     error (_("Could not locate initialization function: %s."),
 155           reader_init_fn_sym);
 156
 157   if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
 158     error (_("Reader not GPL compatible."));
 159
 160   funcs = init_fn ();
 161   if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
 162     error (_("Reader version does not match GDB version."));
 163
 164   new_reader = XZALLOC (struct jit_reader);
 165   new_reader->functions = funcs;
 166   new_reader->handle = so;
 167
 168   discard_cleanups (old_cleanups);
 169   return new_reader;
 170 }
 171
 172 /* Provides the jit-reader-load command.  */
 173
 174 static void
 175 jit_reader_load_command (char *args, int from_tty)
 176 {
 177   char *so_name;
 178   int len;
 179   struct cleanup *prev_cleanup;
 180
 181   if (args == NULL)
 182     error (_("No reader name provided."));
 183
 184   if (loaded_jit_reader != NULL)
 185     error (_("JIT reader already loaded.  Run jit-reader-unload first."));
 186
 187   so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
 188   prev_cleanup = make_cleanup (xfree, so_name);
 189
 190   loaded_jit_reader = jit_reader_load (so_name);
 191   do_cleanups (prev_cleanup);
 192 }
 193
 194 /* Provides the jit-reader-unload command.  */
 195
 196 static void
 197 jit_reader_unload_command (char *args, int from_tty)
 198 {
 199   if (!loaded_jit_reader)
 200     error (_("No JIT reader loaded."));
 201
 202   loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
 203
 204   gdb_dlclose (loaded_jit_reader->handle);
 205   xfree (loaded_jit_reader);
 206   loaded_jit_reader = NULL;
 207 }
 208
 209 /* Open a BFD from the target's memory.  */
 210
 211 static struct bfd *
 212 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
 213 {
 214   const char *filename = xstrdup ("<in-memory>");
 215   struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
 216
 217   buffer->base = addr;
 218   buffer->size = size;
 219   return bfd_openr_iovec (filename, target,
 220                           mem_bfd_iovec_open,
 221                           buffer,
 222                           mem_bfd_iovec_pread,
 223                           mem_bfd_iovec_close,
 224                           mem_bfd_iovec_stat);
 225 }
 226
 227 /* Per-inferior structure recording the addresses in the inferior.  */
 228
 229 struct jit_inferior_data
 230 {
 231   CORE_ADDR breakpoint_addr;  /* &__jit_debug_register_code()  */
 232   CORE_ADDR descriptor_addr;  /* &__jit_debug_descriptor  */
 233 };
 234
 235 /* Remember a mapping from entry_addr to objfile.  */
 236
 237 static void
 238 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
 239 {
 240   CORE_ADDR *entry_addr_ptr;
 241
 242   entry_addr_ptr = xmalloc (sizeof (CORE_ADDR));
 243   *entry_addr_ptr = entry;
 244   set_objfile_data (objfile, jit_objfile_data, entry_addr_ptr);
 245 }
 246
 247 /* Return jit_inferior_data for current inferior.  Allocate if not already
 248    present.  */
 249
 250 static struct jit_inferior_data *
 251 get_jit_inferior_data (void)
 252 {
 253   struct inferior *inf;
 254   struct jit_inferior_data *inf_data;
 255
 256   inf = current_inferior ();
 257   inf_data = inferior_data (inf, jit_inferior_data);
 258   if (inf_data == NULL)
 259     {
 260       inf_data = XZALLOC (struct jit_inferior_data);
 261       set_inferior_data (inf, jit_inferior_data, inf_data);
 262     }
 263
 264   return inf_data;
 265 }
 266
 267 static void
 268 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
 269 {
 270   xfree (arg);
 271 }
 272
 273 /* Helper function for reading the global JIT descriptor from remote
 274    memory.  */
 275
 276 static void
 277 jit_read_descriptor (struct gdbarch *gdbarch,
 278                      struct jit_descriptor *descriptor,
 279                      CORE_ADDR descriptor_addr)
 280 {
 281   int err;
 282   struct type *ptr_type;
 283   int ptr_size;
 284   int desc_size;
 285   gdb_byte *desc_buf;
 286   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 287
 288   /* Figure out how big the descriptor is on the remote and how to read it.  */
 289   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 290   ptr_size = TYPE_LENGTH (ptr_type);
 291   desc_size = 8 + 2 * ptr_size;  /* Two 32-bit ints and two pointers.  */
 292   desc_buf = alloca (desc_size);
 293
 294   /* Read the descriptor.  */
 295   err = target_read_memory (descriptor_addr, desc_buf, desc_size);
 296   if (err)
 297     error (_("Unable to read JIT descriptor from remote memory!"));
 298
 299   /* Fix the endianness to match the host.  */
 300   descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
 301   descriptor->action_flag =
 302       extract_unsigned_integer (&desc_buf[4], 4, byte_order);
 303   descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
 304   descriptor->first_entry =
 305       extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
 306 }
 307
 308 /* Helper function for reading a JITed code entry from remote memory.  */
 309
 310 static void
 311 jit_read_code_entry (struct gdbarch *gdbarch,
 312                      CORE_ADDR code_addr, struct jit_code_entry *code_entry)
 313 {
 314   int err, off;
 315   struct type *ptr_type;
 316   int ptr_size;
 317   int entry_size;
 318   int align_bytes;
 319   gdb_byte *entry_buf;
 320   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 321
 322   /* Figure out how big the entry is on the remote and how to read it.  */
 323   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 324   ptr_size = TYPE_LENGTH (ptr_type);
 325   entry_size = 3 * ptr_size + 8;  /* Three pointers and one 64-bit int.  */
 326   entry_buf = alloca (entry_size);
 327
 328   /* Read the entry.  */
 329   err = target_read_memory (code_addr, entry_buf, entry_size);
 330   if (err)
 331     error (_("Unable to read JIT code entry from remote memory!"));
 332
 333   /* Fix the endianness to match the host.  */
 334   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 335   code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
 336   code_entry->prev_entry =
 337       extract_typed_address (&entry_buf[ptr_size], ptr_type);
 338   code_entry->symfile_addr =
 339       extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
 340
 341   align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
 342   off = 3 * ptr_size;
 343   off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
 344
 345   code_entry->symfile_size =
 346       extract_unsigned_integer (&entry_buf[off], 8, byte_order);
 347 }
 348
 349 /* Proxy object for building a block.  */
 350
 351 struct gdb_block
 352 {
 353   /* gdb_blocks are linked into a tree structure.  Next points to the
 354      next node at the same depth as this block and parent to the
 355      parent gdb_block.  */
 356   struct gdb_block *next, *parent;
 357
 358   /* Points to the "real" block that is being built out of this
 359      instance.  This block will be added to a blockvector, which will
 360      then be added to a symtab.  */
 361   struct block *real_block;
 362
 363   /* The first and last code address corresponding to this block.  */
 364   CORE_ADDR begin, end;
 365
 366   /* The name of this block (if any).  If this is non-NULL, the
 367      FUNCTION symbol symbol is set to this value.  */
 368   const char *name;
 369 };
 370
 371 /* Proxy object for building a symtab.  */
 372
 373 struct gdb_symtab
 374 {
 375   /* The list of blocks in this symtab.  These will eventually be
 376      converted to real blocks.  */
 377   struct gdb_block *blocks;
 378
 379   /* The number of blocks inserted.  */
 380   int nblocks;
 381
 382   /* A mapping between line numbers to PC.  */
 383   struct linetable *linetable;
 384
 385   /* The source file for this symtab.  */
 386   const char *file_name;
 387   struct gdb_symtab *next;
 388 };
 389
 390 /* Proxy object for building an object.  */
 391
 392 struct gdb_object
 393 {
 394   struct gdb_symtab *symtabs;
 395 };
 396
 397 /* The type of the `private' data passed around by the callback
 398    functions.  */
 399
 400 typedef CORE_ADDR jit_dbg_reader_data;
 401
 402 /* The reader calls into this function to read data off the targets
 403    address space.  */
 404
 405 static enum gdb_status
 406 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
 407 {
 408   int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
 409   if (result == 0)
 410     return GDB_SUCCESS;
 411   else
 412     return GDB_FAIL;
 413 }
 414
 415 /* The reader calls into this function to create a new gdb_object
 416    which it can then pass around to the other callbacks.  Right now,
 417    all that is required is allocating the memory.  */
 418
 419 static struct gdb_object *
 420 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
 421 {
 422   /* CB is not required right now, but sometime in the future we might
 423      need a handle to it, and we'd like to do that without breaking
 424      the ABI.  */
 425   return XZALLOC (struct gdb_object);
 426 }
 427
 428 /* Readers call into this function to open a new gdb_symtab, which,
 429    again, is passed around to other callbacks.  */
 430
 431 static struct gdb_symtab *
 432 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
 433                       struct gdb_object *object,
 434                       const char *file_name)
 435 {
 436   struct gdb_symtab *ret;
 437
 438   /* CB stays unused.  See comment in jit_object_open_impl.  */
 439
 440   ret = XZALLOC (struct gdb_symtab);
 441   ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
 442   ret->next = object->symtabs;
 443   object->symtabs = ret;
 444   return ret;
 445 }
 446
 447 /* Returns true if the block corresponding to old should be placed
 448    before the block corresponding to new in the final blockvector.  */
 449
 450 static int
 451 compare_block (const struct gdb_block *const old,
 452                const struct gdb_block *const new)
 453 {
 454   if (old == NULL)
 455     return 1;
 456   if (old->begin < new->begin)
 457     return 1;
 458   else if (old->begin == new->begin)
 459     {
 460       if (old->end > new->end)
 461         return 1;
 462       else
 463         return 0;
 464     }
 465   else
 466     return 0;
 467 }
 468
 469 /* Called by readers to open a new gdb_block.  This function also
 470    inserts the new gdb_block in the correct place in the corresponding
 471    gdb_symtab.  */
 472
 473 static struct gdb_block *
 474 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
 475                      struct gdb_symtab *symtab, struct gdb_block *parent,
 476                      GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
 477 {
 478   struct gdb_block *block = XZALLOC (struct gdb_block);
 479
 480   block->next = symtab->blocks;
 481   block->begin = (CORE_ADDR) begin;
 482   block->end = (CORE_ADDR) end;
 483   block->name = name ? xstrdup (name) : NULL;
 484   block->parent = parent;
 485
 486   /* Ensure that the blocks are inserted in the correct (reverse of
 487      the order expected by blockvector).  */
 488   if (compare_block (symtab->blocks, block))
 489     {
 490       symtab->blocks = block;
 491     }
 492   else
 493     {
 494       struct gdb_block *i = symtab->blocks;
 495
 496       for (;; i = i->next)
 497         {
 498           /* Guaranteed to terminate, since compare_block (NULL, _)
 499              returns 1.  */
 500           if (compare_block (i->next, block))
 501             {
 502               block->next = i->next;
 503               i->next = block;
 504               break;
 505             }
 506         }
 507     }
 508   symtab->nblocks++;
 509
 510   return block;
 511 }
 512
 513 /* Readers call this to add a line mapping (from PC to line number) to
 514    a gdb_symtab.  */
 515
 516 static void
 517 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
 518                                   struct gdb_symtab *stab, int nlines,
 519                                   struct gdb_line_mapping *map)
 520 {
 521   int i;
 522
 523   if (nlines < 1)
 524     return;
 525
 526   stab->linetable = xmalloc (sizeof (struct linetable)
 527                              + (nlines - 1) * sizeof (struct linetable_entry));
 528   stab->linetable->nitems = nlines;
 529   for (i = 0; i < nlines; i++)
 530     {
 531       stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
 532       stab->linetable->item[i].line = map[i].line;
 533     }
 534 }
 535
 536 /* Called by readers to close a gdb_symtab.  Does not need to do
 537    anything as of now.  */
 538
 539 static void
 540 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
 541                        struct gdb_symtab *stab)
 542 {
 543   /* Right now nothing needs to be done here.  We may need to do some
 544      cleanup here in the future (again, without breaking the plugin
 545      ABI).  */
 546 }
 547
 548 /* Transform STAB to a proper symtab, and add it it OBJFILE.  */
 549
 550 static void
 551 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
 552 {
 553   struct symtab *symtab;
 554   struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
 555   struct block *block_iter;
 556   int actual_nblocks, i, blockvector_size;
 557   CORE_ADDR begin, end;
 558
 559   actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
 560
 561   symtab = allocate_symtab (stab->file_name, objfile);
 562   /* JIT compilers compile in memory.  */
 563   symtab->dirname = NULL;
 564
 565   /* Copy over the linetable entry if one was provided.  */
 566   if (stab->linetable)
 567     {
 568       int size = ((stab->linetable->nitems - 1)
 569                   * sizeof (struct linetable_entry)
 570                   + sizeof (struct linetable));
 571       LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
 572       memcpy (LINETABLE (symtab), stab->linetable, size);
 573     }
 574   else
 575     {
 576       LINETABLE (symtab) = NULL;
 577     }
 578
 579   blockvector_size = (sizeof (struct blockvector)
 580                       + (actual_nblocks - 1) * sizeof (struct block *));
 581   symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
 582                                        blockvector_size);
 583
 584   /* (begin, end) will contain the PC range this entire blockvector
 585      spans.  */
 586   symtab->primary = 1;
 587   BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
 588   begin = stab->blocks->begin;
 589   end = stab->blocks->end;
 590   BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
 591
 592   /* First run over all the gdb_block objects, creating a real block
 593      object for each.  Simultaneously, keep setting the real_block
 594      fields.  */
 595   for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
 596        i >= FIRST_LOCAL_BLOCK;
 597        i--, gdb_block_iter = gdb_block_iter->next)
 598     {
 599       struct block *new_block = allocate_block (&objfile->objfile_obstack);
 600       struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
 601                                                  sizeof (struct symbol));
 602
 603       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
 604                                                    NULL);
 605       /* The address range.  */
 606       BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
 607       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
 608
 609       /* The name.  */
 610       memset (block_name, 0, sizeof (struct symbol));
 611       SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
 612       SYMBOL_CLASS (block_name) = LOC_BLOCK;
 613       SYMBOL_SYMTAB (block_name) = symtab;
 614       SYMBOL_BLOCK_VALUE (block_name) = new_block;
 615
 616       block_name->ginfo.name = obsavestring (gdb_block_iter->name,
 617                                              strlen (gdb_block_iter->name),
 618                                              &objfile->objfile_obstack);
 619
 620       BLOCK_FUNCTION (new_block) = block_name;
 621
 622       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
 623       if (begin > BLOCK_START (new_block))
 624         begin = BLOCK_START (new_block);
 625       if (end < BLOCK_END (new_block))
 626         end = BLOCK_END (new_block);
 627
 628       gdb_block_iter->real_block = new_block;
 629     }
 630
 631   /* Now add the special blocks.  */
 632   block_iter = NULL;
 633   for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
 634     {
 635       struct block *new_block = allocate_block (&objfile->objfile_obstack);
 636       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
 637                                                    NULL);
 638       BLOCK_SUPERBLOCK (new_block) = block_iter;
 639       block_iter = new_block;
 640
 641       BLOCK_START (new_block) = (CORE_ADDR) begin;
 642       BLOCK_END (new_block) = (CORE_ADDR) end;
 643
 644       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
 645     }
 646
 647   /* Fill up the superblock fields for the real blocks, using the
 648      real_block fields populated earlier.  */
 649   for (gdb_block_iter = stab->blocks;
 650        gdb_block_iter;
 651        gdb_block_iter = gdb_block_iter->next)
 652     {
 653       if (gdb_block_iter->parent != NULL)
 654         BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
 655           gdb_block_iter->parent->real_block;
 656     }
 657
 658   /* Free memory.  */
 659   gdb_block_iter = stab->blocks;
 660
 661   for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
 662        gdb_block_iter;
 663        gdb_block_iter = gdb_block_iter_tmp)
 664     {
 665       xfree ((void *) gdb_block_iter->name);
 666       xfree (gdb_block_iter);
 667     }
 668   xfree (stab->linetable);
 669   xfree ((char *) stab->file_name);
 670   xfree (stab);
 671 }
 672
 673 /* Called when closing a gdb_objfile.  Converts OBJ to a proper
 674    objfile.  */
 675
 676 static void
 677 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
 678                        struct gdb_object *obj)
 679 {
 680   struct gdb_symtab *i, *j;
 681   struct objfile *objfile;
 682   jit_dbg_reader_data *priv_data;
 683
 684   priv_data = cb->priv_data;
 685
 686   objfile = allocate_objfile (NULL, 0);
 687   objfile->gdbarch = target_gdbarch;
 688
 689   objfile->msymbols = obstack_alloc (&objfile->objfile_obstack,
 690                                      sizeof (struct minimal_symbol));
 691   memset (objfile->msymbols, 0, sizeof (struct minimal_symbol));
 692
 693   xfree (objfile->name);
 694   objfile->name = xstrdup ("<< JIT compiled code >>");
 695
 696   j = NULL;
 697   for (i = obj->symtabs; i; i = j)
 698     {
 699       j = i->next;
 700       finalize_symtab (i, objfile);
 701     }
 702   add_objfile_entry (objfile, *priv_data);
 703   xfree (obj);
 704 }
 705
 706 /* Try to read CODE_ENTRY using the loaded jit reader (if any).  */
 707
 708 static int
 709 jit_reader_try_read_symtab (struct jit_code_entry *code_entry)
 710 {
 711   void *gdb_mem;
 712   int status;
 713   struct jit_dbg_reader *i;
 714   jit_dbg_reader_data priv_data;
 715   struct gdb_reader_funcs *funcs;
 716   volatile struct gdb_exception e;
 717   struct gdb_symbol_callbacks callbacks =
 718     {
 719       jit_object_open_impl,
 720       jit_symtab_open_impl,
 721       jit_block_open_impl,
 722       jit_symtab_close_impl,
 723       jit_object_close_impl,
 724
 725       jit_symtab_line_mapping_add_impl,
 726       jit_target_read_impl,
 727
 728       &priv_data
 729     };
 730
 731   priv_data = code_entry->symfile_addr;
 732
 733   if (!loaded_jit_reader)
 734     return 0;
 735
 736   gdb_mem = xmalloc (code_entry->symfile_size);
 737
 738   status = 1;
 739   TRY_CATCH (e, RETURN_MASK_ALL)
 740     if (target_read_memory (code_entry->symfile_addr, gdb_mem,
 741                             code_entry->symfile_size))
 742       status = 0;
 743   if (e.reason < 0)
 744     status = 0;
 745
 746   if (status)
 747     {
 748       funcs = loaded_jit_reader->functions;
 749       if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
 750           != GDB_SUCCESS)
 751         status = 0;
 752     }
 753
 754   xfree (gdb_mem);
 755   if (jit_debug && status == 0)
 756     fprintf_unfiltered (gdb_stdlog,
 757                         "Could not read symtab using the loaded JIT reader.\n");
 758   return status;
 759 }
 760
 761 /* Try to read CODE_ENTRY using BFD.  */
 762
 763 static void
 764 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
 765                          struct gdbarch *gdbarch)
 766 {
 767   bfd *nbfd;
 768   struct section_addr_info *sai;
 769   struct bfd_section *sec;
 770   struct objfile *objfile;
 771   struct cleanup *old_cleanups;
 772   int i;
 773   const struct bfd_arch_info *b;
 774
 775   if (jit_debug)
 776     fprintf_unfiltered (gdb_stdlog,
 777                         "jit_register_code, symfile_addr = %s, "
 778                         "symfile_size = %s\n",
 779                         paddress (gdbarch, code_entry->symfile_addr),
 780                         pulongest (code_entry->symfile_size));
 781
 782   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
 783                                       code_entry->symfile_size, gnutarget);
 784   if (nbfd == NULL)
 785     {
 786       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
 787       return;
 788     }
 789
 790   /* Check the format.  NOTE: This initializes important data that GDB uses!
 791      We would segfault later without this line.  */
 792   if (!bfd_check_format (nbfd, bfd_object))
 793     {
 794       printf_unfiltered (_("\
 795 JITed symbol file is not an object file, ignoring it.\n"));
 796       bfd_close (nbfd);
 797       return;
 798     }
 799
 800   /* Check bfd arch.  */
 801   b = gdbarch_bfd_arch_info (gdbarch);
 802   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
 803     warning (_("JITed object file architecture %s is not compatible "
 804                "with target architecture %s."), bfd_get_arch_info
 805              (nbfd)->printable_name, b->printable_name);
 806
 807   /* Read the section address information out of the symbol file.  Since the
 808      file is generated by the JIT at runtime, it should all of the absolute
 809      addresses that we care about.  */
 810   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
 811   old_cleanups = make_cleanup_free_section_addr_info (sai);
 812   i = 0;
 813   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 814     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 815       {
 816         /* We assume that these virtual addresses are absolute, and do not
 817            treat them as offsets.  */
 818         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
 819         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
 820         sai->other[i].sectindex = sec->index;
 821         ++i;
 822       }
 823
 824   /* This call takes ownership of NBFD.  It does not take ownership of SAI.  */
 825   objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
 826
 827   do_cleanups (old_cleanups);
 828   add_objfile_entry (objfile, code_entry->symfile_addr);
 829 }
 830
 831 /* This function registers code associated with a JIT code entry.  It uses the
 832    pointer and size pair in the entry to read the symbol file from the remote
 833    and then calls symbol_file_add_from_local_memory to add it as though it were
 834    a symbol file added by the user.  */
 835
 836 static void
 837 jit_register_code (struct gdbarch *gdbarch,
 838                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
 839 {
 840   int i, success;
 841   const struct bfd_arch_info *b;
 842   struct jit_inferior_data *inf_data = get_jit_inferior_data ();
 843
 844   if (jit_debug)
 845     fprintf_unfiltered (gdb_stdlog,
 846                         "jit_register_code, symfile_addr = %s, "
 847                         "symfile_size = %s\n",
 848                         paddress (gdbarch, code_entry->symfile_addr),
 849                         pulongest (code_entry->symfile_size));
 850
 851   success = jit_reader_try_read_symtab (code_entry);
 852
 853   if (!success)
 854     jit_bfd_try_read_symtab (code_entry, gdbarch);
 855 }
 856
 857 /* This function unregisters JITed code and frees the corresponding
 858    objfile.  */
 859
 860 static void
 861 jit_unregister_code (struct objfile *objfile)
 862 {
 863   free_objfile (objfile);
 864 }
 865
 866 /* Look up the objfile with this code entry address.  */
 867
 868 static struct objfile *
 869 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 870 {
 871   struct objfile *objf;
 872   CORE_ADDR *objf_entry_addr;
 873
 874   ALL_OBJFILES (objf)
 875     {
 876       objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
 877       if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
 878         return objf;
 879     }
 880   return NULL;
 881 }
 882
 883 /* (Re-)Initialize the jit breakpoint if necessary.
 884    Return 0 on success.  */
 885
 886 static int
 887 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 888                                 struct jit_inferior_data *inf_data)
 889 {
 890   if (inf_data->breakpoint_addr == 0)
 891     {
 892       struct minimal_symbol *reg_symbol;
 893
 894       /* Lookup the registration symbol.  If it is missing, then we assume
 895          we are not attached to a JIT.  */
 896       reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL);
 897       if (reg_symbol == NULL)
 898         return 1;
 899       inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
 900       if (inf_data->breakpoint_addr == 0)
 901         return 2;
 902
 903       /* If we have not read the jit descriptor yet (e.g. because the JITer
 904          itself is in a shared library which just got loaded), do so now.  */
 905       if (inf_data->descriptor_addr == 0)
 906         jit_inferior_init (gdbarch);
 907     }
 908   else
 909     return 0;
 910
 911   if (jit_debug)
 912     fprintf_unfiltered (gdb_stdlog,
 913                         "jit_breakpoint_re_set_internal, "
 914                         "breakpoint_addr = %s\n",
 915                         paddress (gdbarch, inf_data->breakpoint_addr));
 916
 917   /* Put a breakpoint in the registration symbol.  */
 918   create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr);
 919
 920   return 0;
 921 }
 922
 923 /* Register any already created translations.  */
 924
 925 static void
 926 jit_inferior_init (struct gdbarch *gdbarch)
 927 {
 928   struct jit_descriptor descriptor;
 929   struct jit_code_entry cur_entry;
 930   struct jit_inferior_data *inf_data;
 931   CORE_ADDR cur_entry_addr;
 932
 933   if (jit_debug)
 934     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
 935
 936   inf_data = get_jit_inferior_data ();
 937   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
 938     return;
 939
 940   if (inf_data->descriptor_addr == 0)
 941     {
 942       struct minimal_symbol *desc_symbol;
 943
 944       /* Lookup the descriptor symbol and cache the addr.  If it is
 945          missing, we assume we are not attached to a JIT and return early.  */
 946       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL);
 947       if (desc_symbol == NULL)
 948         return;
 949
 950       inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
 951       if (inf_data->descriptor_addr == 0)
 952         return;
 953     }
 954
 955   if (jit_debug)
 956     fprintf_unfiltered (gdb_stdlog,
 957                         "jit_inferior_init, descriptor_addr = %s\n",
 958                         paddress (gdbarch, inf_data->descriptor_addr));
 959
 960   /* Read the descriptor so we can check the version number and load
 961      any already JITed functions.  */
 962   jit_read_descriptor (gdbarch, &descriptor, inf_data->descriptor_addr);
 963
 964   /* Check that the version number agrees with that we support.  */
 965   if (descriptor.version != 1)
 966     error (_("Unsupported JIT protocol version in descriptor!"));
 967
 968   /* If we've attached to a running program, we need to check the descriptor
 969      to register any functions that were already generated.  */
 970   for (cur_entry_addr = descriptor.first_entry;
 971        cur_entry_addr != 0;
 972        cur_entry_addr = cur_entry.next_entry)
 973     {
 974       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
 975
 976       /* This hook may be called many times during setup, so make sure we don't
 977          add the same symbol file twice.  */
 978       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
 979         continue;
 980
 981       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
 982     }
 983 }
 984
 985 /* Exported routine to call when an inferior has been created.  */
 986
 987 void
 988 jit_inferior_created_hook (void)
 989 {
 990   jit_inferior_init (target_gdbarch);
 991 }
 992
 993 /* Exported routine to call to re-set the jit breakpoints,
 994    e.g. when a program is rerun.  */
 995
 996 void
 997 jit_breakpoint_re_set (void)
 998 {
 999   jit_breakpoint_re_set_internal (target_gdbarch,
1000                                   get_jit_inferior_data ());
1001 }
1002
1003 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
1004    will be reset.  */
1005
1006 static void
1007 jit_reset_inferior_data_and_breakpoints (void)
1008 {
1009   struct jit_inferior_data *inf_data;
1010
1011   /* Force jit_inferior_init to re-lookup of jit symbol addresses.  */
1012   inf_data = get_jit_inferior_data ();
1013   inf_data->breakpoint_addr = 0;
1014   inf_data->descriptor_addr = 0;
1015
1016   /* Remove any existing JIT breakpoint(s).  */
1017   remove_jit_event_breakpoints ();
1018
1019   jit_inferior_init (target_gdbarch);
1020 }
1021
1022 /* Wrapper to match the observer function pointer prototype.  */
1023
1024 static void
1025 jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
1026 {
1027   jit_reset_inferior_data_and_breakpoints ();
1028 }
1029
1030 /* This function cleans up any code entries left over when the
1031    inferior exits.  We get left over code when the inferior exits
1032    without unregistering its code, for example when it crashes.  */
1033
1034 static void
1035 jit_inferior_exit_hook (struct inferior *inf)
1036 {
1037   struct objfile *objf;
1038   struct objfile *temp;
1039
1040   ALL_OBJFILES_SAFE (objf, temp)
1041     if (objfile_data (objf, jit_objfile_data) != NULL)
1042       jit_unregister_code (objf);
1043 }
1044
1045 static void
1046 jit_executable_changed_observer (void)
1047 {
1048   jit_reset_inferior_data_and_breakpoints ();
1049 }
1050
1051 void
1052 jit_event_handler (struct gdbarch *gdbarch)
1053 {
1054   struct jit_descriptor descriptor;
1055   struct jit_code_entry code_entry;
1056   CORE_ADDR entry_addr;
1057   struct objfile *objf;
1058
1059   /* Read the descriptor from remote memory.  */
1060   jit_read_descriptor (gdbarch, &descriptor,
1061                        get_jit_inferior_data ()->descriptor_addr);
1062   entry_addr = descriptor.relevant_entry;
1063
1064   /* Do the corresponding action.  */
1065   switch (descriptor.action_flag)
1066     {
1067     case JIT_NOACTION:
1068       break;
1069     case JIT_REGISTER:
1070       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1071       jit_register_code (gdbarch, entry_addr, &code_entry);
1072       break;
1073     case JIT_UNREGISTER:
1074       objf = jit_find_objf_with_entry_addr (entry_addr);
1075       if (objf == NULL)
1076         printf_unfiltered (_("Unable to find JITed code "
1077                              "entry at address: %s\n"),
1078                            paddress (gdbarch, entry_addr));
1079       else
1080         jit_unregister_code (objf);
1081
1082       break;
1083     default:
1084       error (_("Unknown action_flag value in JIT descriptor!"));
1085       break;
1086     }
1087 }
1088
1089 /* Called to free the data allocated to the jit_inferior_data slot.  */
1090
1091 static void
1092 free_objfile_data (struct objfile *objfile, void *data)
1093 {
1094   xfree (data);
1095 }
1096
1097 /* Provide a prototype to silence -Wmissing-prototypes.  */
1098
1099 extern void _initialize_jit (void);
1100
1101 void
1102 _initialize_jit (void)
1103 {
1104   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1105                                            JIT_READER_DIR_RELOCATABLE);
1106   add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1107                             _("Set JIT debugging."),
1108                             _("Show JIT debugging."),
1109                             _("When non-zero, JIT debugging is enabled."),
1110                             NULL,
1111                             show_jit_debug,
1112                             &setdebuglist, &showdebuglist);
1113
1114   observer_attach_inferior_created (jit_inferior_created_observer);
1115   observer_attach_inferior_exit (jit_inferior_exit_hook);
1116   observer_attach_executable_changed (jit_executable_changed_observer);
1117   jit_objfile_data =
1118     register_objfile_data_with_cleanup (NULL, free_objfile_data);
1119   jit_inferior_data =
1120     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1121   if (is_dl_available ())
1122     {
1123       add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1124 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1125 Usage: jit-reader-load FILE\n\
1126 Try to load file FILE as a debug info reader (and unwinder) for\n\
1127 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
1128 relocated relative to the GDB executable if required."));
1129       add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1130 Unload the currently loaded JIT debug info reader.\n\
1131 Usage: jit-reader-unload FILE\n\n\
1132 Do \"help jit-reader-load\" for info on loading debug info readers."));
1133     }
1134 }