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