gdb/jit.c

   1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2012 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 "regcache.h"
  35 #include "symfile.h"
  36 #include "symtab.h"
  37 #include "target.h"
  38 #include "gdb-dlfcn.h"
  39 #include "gdb_stat.h"
  40 #include "exceptions.h"
  41
  42 static const char *jit_reader_dir = NULL;
  43
  44 static const struct objfile_data *jit_objfile_data;
  45
  46 static const char *const jit_break_name = "__jit_debug_register_code";
  47
  48 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
  49
  50 static const struct inferior_data *jit_inferior_data = NULL;
  51
  52 static void jit_inferior_init (struct gdbarch *gdbarch);
  53
  54 /* An unwinder is registered for every gdbarch.  This key is used to
  55    remember if the unwinder has been registered for a particular
  56    gdbarch.  */
  57
  58 static struct gdbarch_data *jit_gdbarch_data;
  59
  60 /* Non-zero if we want to see trace of jit level stuff.  */
  61
  62 static int jit_debug = 0;
  63
  64 static void
  65 show_jit_debug (struct ui_file *file, int from_tty,
  66                 struct cmd_list_element *c, const char *value)
  67 {
  68   fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
  69 }
  70
  71 struct target_buffer
  72 {
  73   CORE_ADDR base;
  74   ULONGEST size;
  75 };
  76
  77 /* Openning the file is a no-op.  */
  78
  79 static void *
  80 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
  81 {
  82   return open_closure;
  83 }
  84
  85 /* Closing the file is just freeing the base/size pair on our side.  */
  86
  87 static int
  88 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
  89 {
  90   xfree (stream);
  91   return 1;
  92 }
  93
  94 /* For reading the file, we just need to pass through to target_read_memory and
  95    fix up the arguments and return values.  */
  96
  97 static file_ptr
  98 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
  99                      file_ptr nbytes, file_ptr offset)
 100 {
 101   int err;
 102   struct target_buffer *buffer = (struct target_buffer *) stream;
 103
 104   /* If this read will read all of the file, limit it to just the rest.  */
 105   if (offset + nbytes > buffer->size)
 106     nbytes = buffer->size - offset;
 107
 108   /* If there are no more bytes left, we've reached EOF.  */
 109   if (nbytes == 0)
 110     return 0;
 111
 112   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
 113   if (err)
 114     return -1;
 115
 116   return nbytes;
 117 }
 118
 119 /* For statting the file, we only support the st_size attribute.  */
 120
 121 static int
 122 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 123 {
 124   struct target_buffer *buffer = (struct target_buffer*) stream;
 125
 126   sb->st_size = buffer->size;
 127   return 0;
 128 }
 129
 130 /* Open a BFD from the target's memory.  */
 131
 132 static struct bfd *
 133 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
 134 {
 135   const char *filename = xstrdup ("<in-memory>");
 136   struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
 137
 138   buffer->base = addr;
 139   buffer->size = size;
 140   return bfd_openr_iovec (filename, target,
 141                           mem_bfd_iovec_open,
 142                           buffer,
 143                           mem_bfd_iovec_pread,
 144                           mem_bfd_iovec_close,
 145                           mem_bfd_iovec_stat);
 146 }
 147
 148 /* One reader that has been loaded successfully, and can potentially be used to
 149    parse debug info.  */
 150
 151 static struct jit_reader
 152 {
 153   struct gdb_reader_funcs *functions;
 154   void *handle;
 155 } *loaded_jit_reader = NULL;
 156
 157 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
 158 static const char *reader_init_fn_sym = "gdb_init_reader";
 159
 160 /* Try to load FILE_NAME as a JIT debug info reader.  */
 161
 162 static struct jit_reader *
 163 jit_reader_load (const char *file_name)
 164 {
 165   void *so;
 166   reader_init_fn_type *init_fn;
 167   struct jit_reader *new_reader = NULL;
 168   struct gdb_reader_funcs *funcs = NULL;
 169   struct cleanup *old_cleanups;
 170
 171   if (jit_debug)
 172     fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
 173                         file_name);
 174   so = gdb_dlopen (file_name);
 175   old_cleanups = make_cleanup_dlclose (so);
 176
 177   init_fn = gdb_dlsym (so, reader_init_fn_sym);
 178   if (!init_fn)
 179     error (_("Could not locate initialization function: %s."),
 180           reader_init_fn_sym);
 181
 182   if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
 183     error (_("Reader not GPL compatible."));
 184
 185   funcs = init_fn ();
 186   if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
 187     error (_("Reader version does not match GDB version."));
 188
 189   new_reader = XZALLOC (struct jit_reader);
 190   new_reader->functions = funcs;
 191   new_reader->handle = so;
 192
 193   discard_cleanups (old_cleanups);
 194   return new_reader;
 195 }
 196
 197 /* Provides the jit-reader-load command.  */
 198
 199 static void
 200 jit_reader_load_command (char *args, int from_tty)
 201 {
 202   char *so_name;
 203   int len;
 204   struct cleanup *prev_cleanup;
 205
 206   if (args == NULL)
 207     error (_("No reader name provided."));
 208
 209   if (loaded_jit_reader != NULL)
 210     error (_("JIT reader already loaded.  Run jit-reader-unload first."));
 211
 212   so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
 213   prev_cleanup = make_cleanup (xfree, so_name);
 214
 215   loaded_jit_reader = jit_reader_load (so_name);
 216   do_cleanups (prev_cleanup);
 217 }
 218
 219 /* Provides the jit-reader-unload command.  */
 220
 221 static void
 222 jit_reader_unload_command (char *args, int from_tty)
 223 {
 224   if (!loaded_jit_reader)
 225     error (_("No JIT reader loaded."));
 226
 227   loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
 228
 229   gdb_dlclose (loaded_jit_reader->handle);
 230   xfree (loaded_jit_reader);
 231   loaded_jit_reader = NULL;
 232 }
 233
 234 /* Per-inferior structure recording which objfile has the JIT
 235    symbols.  */
 236
 237 struct jit_inferior_data
 238 {
 239   /* The objfile.  This is NULL if no objfile holds the JIT
 240      symbols.  */
 241
 242   struct objfile *objfile;
 243 };
 244
 245 /* Per-objfile structure recording the addresses in the inferior.  */
 246
 247 struct jit_objfile_data
 248 {
 249   /* Symbol for __jit_debug_register_code.  */
 250   struct minimal_symbol *register_code;
 251
 252   /* Symbol for __jit_debug_descriptor.  */
 253   struct minimal_symbol *descriptor;
 254
 255   /* Address of struct jit_code_entry in this objfile.  */
 256   CORE_ADDR addr;
 257 };
 258
 259 /* Fetch the jit_objfile_data associated with OBJF.  If no data exists
 260    yet, make a new structure and attach it.  */
 261
 262 static struct jit_objfile_data *
 263 get_jit_objfile_data (struct objfile *objf)
 264 {
 265   struct jit_objfile_data *objf_data;
 266
 267   objf_data = objfile_data (objf, jit_objfile_data);
 268   if (objf_data == NULL)
 269     {
 270       objf_data = XZALLOC (struct jit_objfile_data);
 271       set_objfile_data (objf, jit_objfile_data, objf_data);
 272     }
 273
 274   return objf_data;
 275 }
 276
 277 /* Remember OBJFILE has been created for struct jit_code_entry located
 278    at inferior address ENTRY.  */
 279
 280 static void
 281 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
 282 {
 283   CORE_ADDR *entry_addr_ptr;
 284   struct jit_objfile_data *objf_data;
 285
 286   objf_data = get_jit_objfile_data (objfile);
 287   objf_data->addr = entry;
 288 }
 289
 290 /* Return jit_inferior_data for current inferior.  Allocate if not already
 291    present.  */
 292
 293 static struct jit_inferior_data *
 294 get_jit_inferior_data (void)
 295 {
 296   struct inferior *inf;
 297   struct jit_inferior_data *inf_data;
 298
 299   inf = current_inferior ();
 300   inf_data = inferior_data (inf, jit_inferior_data);
 301   if (inf_data == NULL)
 302     {
 303       inf_data = XZALLOC (struct jit_inferior_data);
 304       set_inferior_data (inf, jit_inferior_data, inf_data);
 305     }
 306
 307   return inf_data;
 308 }
 309
 310 static void
 311 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
 312 {
 313   xfree (arg);
 314 }
 315
 316 /* Helper function for reading the global JIT descriptor from remote
 317    memory.  Returns 1 if all went well, 0 otherwise.  */
 318
 319 static int
 320 jit_read_descriptor (struct gdbarch *gdbarch,
 321                      struct jit_descriptor *descriptor,
 322                      struct jit_inferior_data *inf_data)
 323 {
 324   int err;
 325   struct type *ptr_type;
 326   int ptr_size;
 327   int desc_size;
 328   gdb_byte *desc_buf;
 329   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 330   struct jit_objfile_data *objf_data;
 331
 332   if (inf_data->objfile == NULL)
 333     return 0;
 334   objf_data = get_jit_objfile_data (inf_data->objfile);
 335   if (objf_data->descriptor == NULL)
 336     return 0;
 337
 338   if (jit_debug)
 339     fprintf_unfiltered (gdb_stdlog,
 340                         "jit_read_descriptor, descriptor_addr = %s\n",
 341                         paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
 342
 343   /* Figure out how big the descriptor is on the remote and how to read it.  */
 344   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 345   ptr_size = TYPE_LENGTH (ptr_type);
 346   desc_size = 8 + 2 * ptr_size;  /* Two 32-bit ints and two pointers.  */
 347   desc_buf = alloca (desc_size);
 348
 349   /* Read the descriptor.  */
 350   err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
 351                             desc_buf, desc_size);
 352   if (err)
 353     {
 354       printf_unfiltered (_("Unable to read JIT descriptor from "
 355                            "remote memory\n"));
 356       return 0;
 357     }
 358
 359   /* Fix the endianness to match the host.  */
 360   descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
 361   descriptor->action_flag =
 362       extract_unsigned_integer (&desc_buf[4], 4, byte_order);
 363   descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
 364   descriptor->first_entry =
 365       extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
 366
 367   return 1;
 368 }
 369
 370 /* Helper function for reading a JITed code entry from remote memory.  */
 371
 372 static void
 373 jit_read_code_entry (struct gdbarch *gdbarch,
 374                      CORE_ADDR code_addr, struct jit_code_entry *code_entry)
 375 {
 376   int err, off;
 377   struct type *ptr_type;
 378   int ptr_size;
 379   int entry_size;
 380   int align_bytes;
 381   gdb_byte *entry_buf;
 382   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 383
 384   /* Figure out how big the entry is on the remote and how to read it.  */
 385   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 386   ptr_size = TYPE_LENGTH (ptr_type);
 387
 388   /* Figure out where the longlong value will be.  */
 389   align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
 390   off = 3 * ptr_size;
 391   off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
 392
 393   entry_size = off + 8;  /* Three pointers and one 64-bit int.  */
 394   entry_buf = alloca (entry_size);
 395
 396   /* Read the entry.  */
 397   err = target_read_memory (code_addr, entry_buf, entry_size);
 398   if (err)
 399     error (_("Unable to read JIT code entry from remote memory!"));
 400
 401   /* Fix the endianness to match the host.  */
 402   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 403   code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
 404   code_entry->prev_entry =
 405       extract_typed_address (&entry_buf[ptr_size], ptr_type);
 406   code_entry->symfile_addr =
 407       extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
 408   code_entry->symfile_size =
 409       extract_unsigned_integer (&entry_buf[off], 8, byte_order);
 410 }
 411
 412 /* Proxy object for building a block.  */
 413
 414 struct gdb_block
 415 {
 416   /* gdb_blocks are linked into a tree structure.  Next points to the
 417      next node at the same depth as this block and parent to the
 418      parent gdb_block.  */
 419   struct gdb_block *next, *parent;
 420
 421   /* Points to the "real" block that is being built out of this
 422      instance.  This block will be added to a blockvector, which will
 423      then be added to a symtab.  */
 424   struct block *real_block;
 425
 426   /* The first and last code address corresponding to this block.  */
 427   CORE_ADDR begin, end;
 428
 429   /* The name of this block (if any).  If this is non-NULL, the
 430      FUNCTION symbol symbol is set to this value.  */
 431   const char *name;
 432 };
 433
 434 /* Proxy object for building a symtab.  */
 435
 436 struct gdb_symtab
 437 {
 438   /* The list of blocks in this symtab.  These will eventually be
 439      converted to real blocks.  */
 440   struct gdb_block *blocks;
 441
 442   /* The number of blocks inserted.  */
 443   int nblocks;
 444
 445   /* A mapping between line numbers to PC.  */
 446   struct linetable *linetable;
 447
 448   /* The source file for this symtab.  */
 449   const char *file_name;
 450   struct gdb_symtab *next;
 451 };
 452
 453 /* Proxy object for building an object.  */
 454
 455 struct gdb_object
 456 {
 457   struct gdb_symtab *symtabs;
 458 };
 459
 460 /* The type of the `private' data passed around by the callback
 461    functions.  */
 462
 463 typedef CORE_ADDR jit_dbg_reader_data;
 464
 465 /* The reader calls into this function to read data off the targets
 466    address space.  */
 467
 468 static enum gdb_status
 469 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
 470 {
 471   int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
 472   if (result == 0)
 473     return GDB_SUCCESS;
 474   else
 475     return GDB_FAIL;
 476 }
 477
 478 /* The reader calls into this function to create a new gdb_object
 479    which it can then pass around to the other callbacks.  Right now,
 480    all that is required is allocating the memory.  */
 481
 482 static struct gdb_object *
 483 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
 484 {
 485   /* CB is not required right now, but sometime in the future we might
 486      need a handle to it, and we'd like to do that without breaking
 487      the ABI.  */
 488   return XZALLOC (struct gdb_object);
 489 }
 490
 491 /* Readers call into this function to open a new gdb_symtab, which,
 492    again, is passed around to other callbacks.  */
 493
 494 static struct gdb_symtab *
 495 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
 496                       struct gdb_object *object,
 497                       const char *file_name)
 498 {
 499   struct gdb_symtab *ret;
 500
 501   /* CB stays unused.  See comment in jit_object_open_impl.  */
 502
 503   ret = XZALLOC (struct gdb_symtab);
 504   ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
 505   ret->next = object->symtabs;
 506   object->symtabs = ret;
 507   return ret;
 508 }
 509
 510 /* Returns true if the block corresponding to old should be placed
 511    before the block corresponding to new in the final blockvector.  */
 512
 513 static int
 514 compare_block (const struct gdb_block *const old,
 515                const struct gdb_block *const new)
 516 {
 517   if (old == NULL)
 518     return 1;
 519   if (old->begin < new->begin)
 520     return 1;
 521   else if (old->begin == new->begin)
 522     {
 523       if (old->end > new->end)
 524         return 1;
 525       else
 526         return 0;
 527     }
 528   else
 529     return 0;
 530 }
 531
 532 /* Called by readers to open a new gdb_block.  This function also
 533    inserts the new gdb_block in the correct place in the corresponding
 534    gdb_symtab.  */
 535
 536 static struct gdb_block *
 537 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
 538                      struct gdb_symtab *symtab, struct gdb_block *parent,
 539                      GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
 540 {
 541   struct gdb_block *block = XZALLOC (struct gdb_block);
 542
 543   block->next = symtab->blocks;
 544   block->begin = (CORE_ADDR) begin;
 545   block->end = (CORE_ADDR) end;
 546   block->name = name ? xstrdup (name) : NULL;
 547   block->parent = parent;
 548
 549   /* Ensure that the blocks are inserted in the correct (reverse of
 550      the order expected by blockvector).  */
 551   if (compare_block (symtab->blocks, block))
 552     {
 553       symtab->blocks = block;
 554     }
 555   else
 556     {
 557       struct gdb_block *i = symtab->blocks;
 558
 559       for (;; i = i->next)
 560         {
 561           /* Guaranteed to terminate, since compare_block (NULL, _)
 562              returns 1.  */
 563           if (compare_block (i->next, block))
 564             {
 565               block->next = i->next;
 566               i->next = block;
 567               break;
 568             }
 569         }
 570     }
 571   symtab->nblocks++;
 572
 573   return block;
 574 }
 575
 576 /* Readers call this to add a line mapping (from PC to line number) to
 577    a gdb_symtab.  */
 578
 579 static void
 580 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
 581                                   struct gdb_symtab *stab, int nlines,
 582                                   struct gdb_line_mapping *map)
 583 {
 584   int i;
 585
 586   if (nlines < 1)
 587     return;
 588
 589   stab->linetable = xmalloc (sizeof (struct linetable)
 590                              + (nlines - 1) * sizeof (struct linetable_entry));
 591   stab->linetable->nitems = nlines;
 592   for (i = 0; i < nlines; i++)
 593     {
 594       stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
 595       stab->linetable->item[i].line = map[i].line;
 596     }
 597 }
 598
 599 /* Called by readers to close a gdb_symtab.  Does not need to do
 600    anything as of now.  */
 601
 602 static void
 603 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
 604                        struct gdb_symtab *stab)
 605 {
 606   /* Right now nothing needs to be done here.  We may need to do some
 607      cleanup here in the future (again, without breaking the plugin
 608      ABI).  */
 609 }
 610
 611 /* Transform STAB to a proper symtab, and add it it OBJFILE.  */
 612
 613 static void
 614 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
 615 {
 616   struct symtab *symtab;
 617   struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
 618   struct block *block_iter;
 619   int actual_nblocks, i, blockvector_size;
 620   CORE_ADDR begin, end;
 621
 622   actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
 623
 624   symtab = allocate_symtab (stab->file_name, objfile);
 625   /* JIT compilers compile in memory.  */
 626   symtab->dirname = NULL;
 627
 628   /* Copy over the linetable entry if one was provided.  */
 629   if (stab->linetable)
 630     {
 631       int size = ((stab->linetable->nitems - 1)
 632                   * sizeof (struct linetable_entry)
 633                   + sizeof (struct linetable));
 634       LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
 635       memcpy (LINETABLE (symtab), stab->linetable, size);
 636     }
 637   else
 638     {
 639       LINETABLE (symtab) = NULL;
 640     }
 641
 642   blockvector_size = (sizeof (struct blockvector)
 643                       + (actual_nblocks - 1) * sizeof (struct block *));
 644   symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
 645                                        blockvector_size);
 646
 647   /* (begin, end) will contain the PC range this entire blockvector
 648      spans.  */
 649   symtab->primary = 1;
 650   BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
 651   begin = stab->blocks->begin;
 652   end = stab->blocks->end;
 653   BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
 654
 655   /* First run over all the gdb_block objects, creating a real block
 656      object for each.  Simultaneously, keep setting the real_block
 657      fields.  */
 658   for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
 659        i >= FIRST_LOCAL_BLOCK;
 660        i--, gdb_block_iter = gdb_block_iter->next)
 661     {
 662       struct block *new_block = allocate_block (&objfile->objfile_obstack);
 663       struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
 664                                                  sizeof (struct symbol));
 665
 666       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
 667                                                    NULL);
 668       /* The address range.  */
 669       BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
 670       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
 671
 672       /* The name.  */
 673       memset (block_name, 0, sizeof (struct symbol));
 674       SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
 675       SYMBOL_CLASS (block_name) = LOC_BLOCK;
 676       SYMBOL_SYMTAB (block_name) = symtab;
 677       SYMBOL_BLOCK_VALUE (block_name) = new_block;
 678
 679       block_name->ginfo.name = obsavestring (gdb_block_iter->name,
 680                                              strlen (gdb_block_iter->name),
 681                                              &objfile->objfile_obstack);
 682
 683       BLOCK_FUNCTION (new_block) = block_name;
 684
 685       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
 686       if (begin > BLOCK_START (new_block))
 687         begin = BLOCK_START (new_block);
 688       if (end < BLOCK_END (new_block))
 689         end = BLOCK_END (new_block);
 690
 691       gdb_block_iter->real_block = new_block;
 692     }
 693
 694   /* Now add the special blocks.  */
 695   block_iter = NULL;
 696   for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
 697     {
 698       struct block *new_block = allocate_block (&objfile->objfile_obstack);
 699       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
 700                                                    NULL);
 701       BLOCK_SUPERBLOCK (new_block) = block_iter;
 702       block_iter = new_block;
 703
 704       BLOCK_START (new_block) = (CORE_ADDR) begin;
 705       BLOCK_END (new_block) = (CORE_ADDR) end;
 706
 707       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
 708     }
 709
 710   /* Fill up the superblock fields for the real blocks, using the
 711      real_block fields populated earlier.  */
 712   for (gdb_block_iter = stab->blocks;
 713        gdb_block_iter;
 714        gdb_block_iter = gdb_block_iter->next)
 715     {
 716       if (gdb_block_iter->parent != NULL)
 717         BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
 718           gdb_block_iter->parent->real_block;
 719     }
 720
 721   /* Free memory.  */
 722   gdb_block_iter = stab->blocks;
 723
 724   for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
 725        gdb_block_iter;
 726        gdb_block_iter = gdb_block_iter_tmp)
 727     {
 728       xfree ((void *) gdb_block_iter->name);
 729       xfree (gdb_block_iter);
 730     }
 731   xfree (stab->linetable);
 732   xfree ((char *) stab->file_name);
 733   xfree (stab);
 734 }
 735
 736 /* Called when closing a gdb_objfile.  Converts OBJ to a proper
 737    objfile.  */
 738
 739 static void
 740 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
 741                        struct gdb_object *obj)
 742 {
 743   struct gdb_symtab *i, *j;
 744   struct objfile *objfile;
 745   jit_dbg_reader_data *priv_data;
 746
 747   priv_data = cb->priv_data;
 748
 749   objfile = allocate_objfile (NULL, 0);
 750   objfile->gdbarch = target_gdbarch;
 751
 752   terminate_minimal_symbol_table (objfile);
 753
 754   xfree (objfile->name);
 755   objfile->name = xstrdup ("<< JIT compiled code >>");
 756
 757   j = NULL;
 758   for (i = obj->symtabs; i; i = j)
 759     {
 760       j = i->next;
 761       finalize_symtab (i, objfile);
 762     }
 763   add_objfile_entry (objfile, *priv_data);
 764   xfree (obj);
 765 }
 766
 767 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
 768    ENTRY_ADDR is the address of the struct jit_code_entry in the
 769    inferior address space.  */
 770
 771 static int
 772 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
 773                             CORE_ADDR entry_addr)
 774 {
 775   void *gdb_mem;
 776   int status;
 777   struct jit_dbg_reader *i;
 778   jit_dbg_reader_data priv_data;
 779   struct gdb_reader_funcs *funcs;
 780   volatile struct gdb_exception e;
 781   struct gdb_symbol_callbacks callbacks =
 782     {
 783       jit_object_open_impl,
 784       jit_symtab_open_impl,
 785       jit_block_open_impl,
 786       jit_symtab_close_impl,
 787       jit_object_close_impl,
 788
 789       jit_symtab_line_mapping_add_impl,
 790       jit_target_read_impl,
 791
 792       &priv_data
 793     };
 794
 795   priv_data = entry_addr;
 796
 797   if (!loaded_jit_reader)
 798     return 0;
 799
 800   gdb_mem = xmalloc (code_entry->symfile_size);
 801
 802   status = 1;
 803   TRY_CATCH (e, RETURN_MASK_ALL)
 804     if (target_read_memory (code_entry->symfile_addr, gdb_mem,
 805                             code_entry->symfile_size))
 806       status = 0;
 807   if (e.reason < 0)
 808     status = 0;
 809
 810   if (status)
 811     {
 812       funcs = loaded_jit_reader->functions;
 813       if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
 814           != GDB_SUCCESS)
 815         status = 0;
 816     }
 817
 818   xfree (gdb_mem);
 819   if (jit_debug && status == 0)
 820     fprintf_unfiltered (gdb_stdlog,
 821                         "Could not read symtab using the loaded JIT reader.\n");
 822   return status;
 823 }
 824
 825 /* Try to read CODE_ENTRY using BFD.  ENTRY_ADDR is the address of the
 826    struct jit_code_entry in the inferior address space.  */
 827
 828 static void
 829 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
 830                          CORE_ADDR entry_addr,
 831                          struct gdbarch *gdbarch)
 832 {
 833   bfd *nbfd;
 834   struct section_addr_info *sai;
 835   struct bfd_section *sec;
 836   struct objfile *objfile;
 837   struct cleanup *old_cleanups;
 838   int i;
 839   const struct bfd_arch_info *b;
 840
 841   if (jit_debug)
 842     fprintf_unfiltered (gdb_stdlog,
 843                         "jit_register_code, symfile_addr = %s, "
 844                         "symfile_size = %s\n",
 845                         paddress (gdbarch, code_entry->symfile_addr),
 846                         pulongest (code_entry->symfile_size));
 847
 848   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
 849                                       code_entry->symfile_size, gnutarget);
 850   if (nbfd == NULL)
 851     {
 852       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
 853       return;
 854     }
 855
 856   /* Check the format.  NOTE: This initializes important data that GDB uses!
 857      We would segfault later without this line.  */
 858   if (!bfd_check_format (nbfd, bfd_object))
 859     {
 860       printf_unfiltered (_("\
 861 JITed symbol file is not an object file, ignoring it.\n"));
 862       bfd_close (nbfd);
 863       return;
 864     }
 865
 866   /* Check bfd arch.  */
 867   b = gdbarch_bfd_arch_info (gdbarch);
 868   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
 869     warning (_("JITed object file architecture %s is not compatible "
 870                "with target architecture %s."), bfd_get_arch_info
 871              (nbfd)->printable_name, b->printable_name);
 872
 873   /* Read the section address information out of the symbol file.  Since the
 874      file is generated by the JIT at runtime, it should all of the absolute
 875      addresses that we care about.  */
 876   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
 877   old_cleanups = make_cleanup_free_section_addr_info (sai);
 878   i = 0;
 879   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 880     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 881       {
 882         /* We assume that these virtual addresses are absolute, and do not
 883            treat them as offsets.  */
 884         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
 885         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
 886         sai->other[i].sectindex = sec->index;
 887         ++i;
 888       }
 889
 890   /* This call takes ownership of NBFD.  It does not take ownership of SAI.  */
 891   objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
 892
 893   do_cleanups (old_cleanups);
 894   add_objfile_entry (objfile, entry_addr);
 895 }
 896
 897 /* This function registers code associated with a JIT code entry.  It uses the
 898    pointer and size pair in the entry to read the symbol file from the remote
 899    and then calls symbol_file_add_from_local_memory to add it as though it were
 900    a symbol file added by the user.  */
 901
 902 static void
 903 jit_register_code (struct gdbarch *gdbarch,
 904                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
 905 {
 906   int i, success;
 907   const struct bfd_arch_info *b;
 908   struct jit_inferior_data *inf_data = get_jit_inferior_data ();
 909
 910   if (jit_debug)
 911     fprintf_unfiltered (gdb_stdlog,
 912                         "jit_register_code, symfile_addr = %s, "
 913                         "symfile_size = %s\n",
 914                         paddress (gdbarch, code_entry->symfile_addr),
 915                         pulongest (code_entry->symfile_size));
 916
 917   success = jit_reader_try_read_symtab (code_entry, entry_addr);
 918
 919   if (!success)
 920     jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
 921 }
 922
 923 /* This function unregisters JITed code and frees the corresponding
 924    objfile.  */
 925
 926 static void
 927 jit_unregister_code (struct objfile *objfile)
 928 {
 929   free_objfile (objfile);
 930 }
 931
 932 /* Look up the objfile with this code entry address.  */
 933
 934 static struct objfile *
 935 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 936 {
 937   struct objfile *objf;
 938   CORE_ADDR *objf_entry_addr;
 939
 940   ALL_OBJFILES (objf)
 941     {
 942       struct jit_objfile_data *objf_data;
 943
 944       objf_data = objfile_data (objf, jit_objfile_data);
 945       if (objf_data != NULL && objf_data->addr == entry_addr)
 946         return objf;
 947     }
 948   return NULL;
 949 }
 950
 951 /* (Re-)Initialize the jit breakpoint if necessary.
 952    Return 0 on success.  */
 953
 954 static int
 955 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 956                                 struct jit_inferior_data *inf_data)
 957 {
 958   struct minimal_symbol *reg_symbol, *desc_symbol;
 959   struct objfile *objf;
 960   struct jit_objfile_data *objf_data;
 961
 962   if (inf_data->objfile != NULL)
 963     return 0;
 964
 965   /* Lookup the registration symbol.  If it is missing, then we assume
 966      we are not attached to a JIT.  */
 967   reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
 968   if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
 969     return 1;
 970
 971   desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
 972   if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
 973     return 1;
 974
 975   objf_data = get_jit_objfile_data (objf);
 976   objf_data->register_code = reg_symbol;
 977   objf_data->descriptor = desc_symbol;
 978
 979   inf_data->objfile = objf;
 980
 981   jit_inferior_init (gdbarch);
 982
 983   if (jit_debug)
 984     fprintf_unfiltered (gdb_stdlog,
 985                         "jit_breakpoint_re_set_internal, "
 986                         "breakpoint_addr = %s\n",
 987                         paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
 988
 989   /* Put a breakpoint in the registration symbol.  */
 990   create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
 991
 992   return 0;
 993 }
 994
 995 /* The private data passed around in the frame unwind callback
 996    functions.  */
 997
 998 struct jit_unwind_private
 999 {
1000   /* Cached register values.  See jit_frame_sniffer to see how this
1001      works.  */
1002   struct gdb_reg_value **registers;
1003
1004   /* The frame being unwound.  */
1005   struct frame_info *this_frame;
1006 };
1007
1008 /* Sets the value of a particular register in this frame.  */
1009
1010 static void
1011 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1012                          struct gdb_reg_value *value)
1013 {
1014   struct jit_unwind_private *priv;
1015   int gdb_reg;
1016
1017   priv = cb->priv_data;
1018
1019   gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1020                                           dwarf_regnum);
1021   if (gdb_reg == -1)
1022     {
1023       if (jit_debug)
1024         fprintf_unfiltered (gdb_stdlog,
1025                             _("Could not recognize DWARF regnum %d"),
1026                             dwarf_regnum);
1027       return;
1028     }
1029
1030   gdb_assert (priv->registers);
1031   priv->registers[gdb_reg] = value;
1032 }
1033
1034 static void
1035 reg_value_free_impl (struct gdb_reg_value *value)
1036 {
1037   xfree (value);
1038 }
1039
1040 /* Get the value of register REGNUM in the previous frame.  */
1041
1042 static struct gdb_reg_value *
1043 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1044 {
1045   struct jit_unwind_private *priv;
1046   struct gdb_reg_value *value;
1047   int gdb_reg, size;
1048   struct gdbarch *frame_arch;
1049
1050   priv = cb->priv_data;
1051   frame_arch = get_frame_arch (priv->this_frame);
1052
1053   gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1054   size = register_size (frame_arch, gdb_reg);
1055   value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1056   value->defined = frame_register_read (priv->this_frame, gdb_reg,
1057                                         value->value);
1058   value->size = size;
1059   value->free = reg_value_free_impl;
1060   return value;
1061 }
1062
1063 /* gdb_reg_value has a free function, which must be called on each
1064    saved register value.  */
1065
1066 static void
1067 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1068 {
1069   struct jit_unwind_private *priv_data = cache;
1070   struct gdbarch *frame_arch;
1071   int i;
1072
1073   gdb_assert (priv_data->registers);
1074   frame_arch = get_frame_arch (priv_data->this_frame);
1075
1076   for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1077     if (priv_data->registers[i] && priv_data->registers[i]->free)
1078       priv_data->registers[i]->free (priv_data->registers[i]);
1079
1080   xfree (priv_data->registers);
1081   xfree (priv_data);
1082 }
1083
1084 /* The frame sniffer for the pseudo unwinder.
1085
1086    While this is nominally a frame sniffer, in the case where the JIT
1087    reader actually recognizes the frame, it does a lot more work -- it
1088    unwinds the frame and saves the corresponding register values in
1089    the cache.  jit_frame_prev_register simply returns the saved
1090    register values.  */
1091
1092 static int
1093 jit_frame_sniffer (const struct frame_unwind *self,
1094                    struct frame_info *this_frame, void **cache)
1095 {
1096   struct jit_inferior_data *inf_data;
1097   struct jit_unwind_private *priv_data;
1098   struct jit_dbg_reader *iter;
1099   struct gdb_unwind_callbacks callbacks;
1100   struct gdb_reader_funcs *funcs;
1101
1102   inf_data = get_jit_inferior_data ();
1103
1104   callbacks.reg_get = jit_unwind_reg_get_impl;
1105   callbacks.reg_set = jit_unwind_reg_set_impl;
1106   callbacks.target_read = jit_target_read_impl;
1107
1108   if (loaded_jit_reader == NULL)
1109     return 0;
1110
1111   funcs = loaded_jit_reader->functions;
1112
1113   gdb_assert (!*cache);
1114
1115   *cache = XZALLOC (struct jit_unwind_private);
1116   priv_data = *cache;
1117   priv_data->registers =
1118     XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1119              struct gdb_reg_value *);
1120   priv_data->this_frame = this_frame;
1121
1122   callbacks.priv_data = priv_data;
1123
1124   /* Try to coax the provided unwinder to unwind the stack */
1125   if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1126     {
1127       if (jit_debug)
1128         fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1129                                           "JIT reader.\n"));
1130       return 1;
1131     }
1132   if (jit_debug)
1133     fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1134                                       "JIT reader.\n"));
1135
1136   jit_dealloc_cache (this_frame, *cache);
1137   *cache = NULL;
1138
1139   return 0;
1140 }
1141
1142
1143 /* The frame_id function for the pseudo unwinder.  Relays the call to
1144    the loaded plugin.  */
1145
1146 static void
1147 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1148                    struct frame_id *this_id)
1149 {
1150   struct jit_unwind_private private;
1151   struct gdb_frame_id frame_id;
1152   struct gdb_reader_funcs *funcs;
1153   struct gdb_unwind_callbacks callbacks;
1154
1155   private.registers = NULL;
1156   private.this_frame = this_frame;
1157
1158   /* We don't expect the frame_id function to set any registers, so we
1159      set reg_set to NULL.  */
1160   callbacks.reg_get = jit_unwind_reg_get_impl;
1161   callbacks.reg_set = NULL;
1162   callbacks.target_read = jit_target_read_impl;
1163   callbacks.priv_data = &private;
1164
1165   gdb_assert (loaded_jit_reader);
1166   funcs = loaded_jit_reader->functions;
1167
1168   frame_id = funcs->get_frame_id (funcs, &callbacks);
1169   *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1170 }
1171
1172 /* Pseudo unwinder function.  Reads the previously fetched value for
1173    the register from the cache.  */
1174
1175 static struct value *
1176 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1177 {
1178   struct jit_unwind_private *priv = *cache;
1179   struct gdb_reg_value *value;
1180
1181   if (priv == NULL)
1182     return frame_unwind_got_optimized (this_frame, reg);
1183
1184   gdb_assert (priv->registers);
1185   value = priv->registers[reg];
1186   if (value && value->defined)
1187     return frame_unwind_got_bytes (this_frame, reg, value->value);
1188   else
1189     return frame_unwind_got_optimized (this_frame, reg);
1190 }
1191
1192 /* Relay everything back to the unwinder registered by the JIT debug
1193    info reader.*/
1194
1195 static const struct frame_unwind jit_frame_unwind =
1196 {
1197   NORMAL_FRAME,
1198   default_frame_unwind_stop_reason,
1199   jit_frame_this_id,
1200   jit_frame_prev_register,
1201   NULL,
1202   jit_frame_sniffer,
1203   jit_dealloc_cache
1204 };
1205
1206
1207 /* This is the information that is stored at jit_gdbarch_data for each
1208    architecture.  */
1209
1210 struct jit_gdbarch_data_type
1211 {
1212   /* Has the (pseudo) unwinder been prepended? */
1213   int unwinder_registered;
1214 };
1215
1216 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed.  */
1217
1218 static void
1219 jit_prepend_unwinder (struct gdbarch *gdbarch)
1220 {
1221   struct jit_gdbarch_data_type *data;
1222
1223   data = gdbarch_data (gdbarch, jit_gdbarch_data);
1224   if (!data->unwinder_registered)
1225     {
1226       frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1227       data->unwinder_registered = 1;
1228     }
1229 }
1230
1231 /* Register any already created translations.  */
1232
1233 static void
1234 jit_inferior_init (struct gdbarch *gdbarch)
1235 {
1236   struct jit_descriptor descriptor;
1237   struct jit_code_entry cur_entry;
1238   struct jit_inferior_data *inf_data;
1239   CORE_ADDR cur_entry_addr;
1240   struct jit_objfile_data *objf_data;
1241
1242   if (jit_debug)
1243     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1244
1245   jit_prepend_unwinder (gdbarch);
1246
1247   inf_data = get_jit_inferior_data ();
1248   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1249     return;
1250
1251   /* Read the descriptor so we can check the version number and load
1252      any already JITed functions.  */
1253   if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
1254     return;
1255
1256   /* Check that the version number agrees with that we support.  */
1257   if (descriptor.version != 1)
1258     {
1259       printf_unfiltered (_("Unsupported JIT protocol version %ld "
1260                            "in descriptor (expected 1)\n"),
1261                          (long) descriptor.version);
1262       return;
1263     }
1264
1265   /* If we've attached to a running program, we need to check the descriptor
1266      to register any functions that were already generated.  */
1267   for (cur_entry_addr = descriptor.first_entry;
1268        cur_entry_addr != 0;
1269        cur_entry_addr = cur_entry.next_entry)
1270     {
1271       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1272
1273       /* This hook may be called many times during setup, so make sure we don't
1274          add the same symbol file twice.  */
1275       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1276         continue;
1277
1278       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1279     }
1280 }
1281
1282 /* Exported routine to call when an inferior has been created.  */
1283
1284 void
1285 jit_inferior_created_hook (void)
1286 {
1287   jit_inferior_init (target_gdbarch);
1288 }
1289
1290 /* Exported routine to call to re-set the jit breakpoints,
1291    e.g. when a program is rerun.  */
1292
1293 void
1294 jit_breakpoint_re_set (void)
1295 {
1296   jit_breakpoint_re_set_internal (target_gdbarch,
1297                                   get_jit_inferior_data ());
1298 }
1299
1300 /* This function cleans up any code entries left over when the
1301    inferior exits.  We get left over code when the inferior exits
1302    without unregistering its code, for example when it crashes.  */
1303
1304 static void
1305 jit_inferior_exit_hook (struct inferior *inf)
1306 {
1307   struct objfile *objf;
1308   struct objfile *temp;
1309
1310   ALL_OBJFILES_SAFE (objf, temp)
1311     {
1312       struct jit_objfile_data *objf_data = objfile_data (objf,
1313                                                          jit_objfile_data);
1314
1315       if (objf_data != NULL && objf_data->addr != 0)
1316         jit_unregister_code (objf);
1317     }
1318 }
1319
1320 void
1321 jit_event_handler (struct gdbarch *gdbarch)
1322 {
1323   struct jit_descriptor descriptor;
1324   struct jit_code_entry code_entry;
1325   CORE_ADDR entry_addr;
1326   struct objfile *objf;
1327
1328   /* Read the descriptor from remote memory.  */
1329   if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
1330     return;
1331   entry_addr = descriptor.relevant_entry;
1332
1333   /* Do the corresponding action.  */
1334   switch (descriptor.action_flag)
1335     {
1336     case JIT_NOACTION:
1337       break;
1338     case JIT_REGISTER:
1339       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1340       jit_register_code (gdbarch, entry_addr, &code_entry);
1341       break;
1342     case JIT_UNREGISTER:
1343       objf = jit_find_objf_with_entry_addr (entry_addr);
1344       if (objf == NULL)
1345         printf_unfiltered (_("Unable to find JITed code "
1346                              "entry at address: %s\n"),
1347                            paddress (gdbarch, entry_addr));
1348       else
1349         jit_unregister_code (objf);
1350
1351       break;
1352     default:
1353       error (_("Unknown action_flag value in JIT descriptor!"));
1354       break;
1355     }
1356 }
1357
1358 /* Called to free the data allocated to the jit_inferior_data slot.  */
1359
1360 static void
1361 free_objfile_data (struct objfile *objfile, void *data)
1362 {
1363   struct jit_objfile_data *objf_data = data;
1364
1365   if (objf_data->register_code != NULL)
1366     {
1367       struct jit_inferior_data *inf_data = get_jit_inferior_data ();
1368
1369       if (inf_data->objfile == objfile)
1370         inf_data->objfile = NULL;
1371     }
1372
1373   xfree (data);
1374 }
1375
1376 /* Initialize the jit_gdbarch_data slot with an instance of struct
1377    jit_gdbarch_data_type */
1378
1379 static void *
1380 jit_gdbarch_data_init (struct obstack *obstack)
1381 {
1382   struct jit_gdbarch_data_type *data;
1383
1384   data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1385   data->unwinder_registered = 0;
1386   return data;
1387 }
1388
1389 /* Provide a prototype to silence -Wmissing-prototypes.  */
1390
1391 extern void _initialize_jit (void);
1392
1393 void
1394 _initialize_jit (void)
1395 {
1396   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1397                                            JIT_READER_DIR_RELOCATABLE);
1398   add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1399                             _("Set JIT debugging."),
1400                             _("Show JIT debugging."),
1401                             _("When non-zero, JIT debugging is enabled."),
1402                             NULL,
1403                             show_jit_debug,
1404                             &setdebuglist, &showdebuglist);
1405
1406   observer_attach_inferior_exit (jit_inferior_exit_hook);
1407   jit_objfile_data =
1408     register_objfile_data_with_cleanup (NULL, free_objfile_data);
1409   jit_inferior_data =
1410     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1411   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1412   if (is_dl_available ())
1413     {
1414       add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1415 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1416 Usage: jit-reader-load FILE\n\
1417 Try to load file FILE as a debug info reader (and unwinder) for\n\
1418 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
1419 relocated relative to the GDB executable if required."));
1420       add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1421 Unload the currently loaded JIT debug info reader.\n\
1422 Usage: jit-reader-unload FILE\n\n\
1423 Do \"help jit-reader-load\" for info on loading debug info readers."));
1424     }
1425 }