contrib/gdb-7/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 /* One reader that has been loaded successfully, and can potentially be used to
 131    parse debug info.  */
 132
 133 static struct jit_reader
 134 {
 135   struct gdb_reader_funcs *functions;
 136   void *handle;
 137 } *loaded_jit_reader = NULL;
 138
 139 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
 140 static const char *reader_init_fn_sym = "gdb_init_reader";
 141
 142 /* Try to load FILE_NAME as a JIT debug info reader.  */
 143
 144 static struct jit_reader *
 145 jit_reader_load (const char *file_name)
 146 {
 147   void *so;
 148   reader_init_fn_type *init_fn;
 149   struct jit_reader *new_reader = NULL;
 150   struct gdb_reader_funcs *funcs = NULL;
 151   struct cleanup *old_cleanups;
 152
 153   if (jit_debug)
 154     fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
 155                         file_name);
 156   so = gdb_dlopen (file_name);
 157   old_cleanups = make_cleanup_dlclose (so);
 158
 159   init_fn = gdb_dlsym (so, reader_init_fn_sym);
 160   if (!init_fn)
 161     error (_("Could not locate initialization function: %s."),
 162           reader_init_fn_sym);
 163
 164   if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
 165     error (_("Reader not GPL compatible."));
 166
 167   funcs = init_fn ();
 168   if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
 169     error (_("Reader version does not match GDB version."));
 170
 171   new_reader = XZALLOC (struct jit_reader);
 172   new_reader->functions = funcs;
 173   new_reader->handle = so;
 174
 175   discard_cleanups (old_cleanups);
 176   return new_reader;
 177 }
 178
 179 /* Provides the jit-reader-load command.  */
 180
 181 static void
 182 jit_reader_load_command (char *args, int from_tty)
 183 {
 184   char *so_name;
 185   int len;
 186   struct cleanup *prev_cleanup;
 187
 188   if (args == NULL)
 189     error (_("No reader name provided."));
 190
 191   if (loaded_jit_reader != NULL)
 192     error (_("JIT reader already loaded.  Run jit-reader-unload first."));
 193
 194   so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
 195   prev_cleanup = make_cleanup (xfree, so_name);
 196
 197   loaded_jit_reader = jit_reader_load (so_name);
 198   do_cleanups (prev_cleanup);
 199 }
 200
 201 /* Provides the jit-reader-unload command.  */
 202
 203 static void
 204 jit_reader_unload_command (char *args, int from_tty)
 205 {
 206   if (!loaded_jit_reader)
 207     error (_("No JIT reader loaded."));
 208
 209   loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
 210
 211   gdb_dlclose (loaded_jit_reader->handle);
 212   xfree (loaded_jit_reader);
 213   loaded_jit_reader = NULL;
 214 }
 215
 216 /* Open a BFD from the target's memory.  */
 217
 218 static struct bfd *
 219 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
 220 {
 221   const char *filename = xstrdup ("<in-memory>");
 222   struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
 223
 224   buffer->base = addr;
 225   buffer->size = size;
 226   return bfd_openr_iovec (filename, target,
 227                           mem_bfd_iovec_open,
 228                           buffer,
 229                           mem_bfd_iovec_pread,
 230                           mem_bfd_iovec_close,
 231                           mem_bfd_iovec_stat);
 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   objfile->msymbols = obstack_alloc (&objfile->objfile_obstack,
 698                                      sizeof (struct minimal_symbol));
 699   memset (objfile->msymbols, 0, sizeof (struct minimal_symbol));
 700
 701   xfree (objfile->name);
 702   objfile->name = xstrdup ("<< JIT compiled code >>");
 703
 704   j = NULL;
 705   for (i = obj->symtabs; i; i = j)
 706     {
 707       j = i->next;
 708       finalize_symtab (i, objfile);
 709     }
 710   add_objfile_entry (objfile, *priv_data);
 711   xfree (obj);
 712 }
 713
 714 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
 715    ENTRY_ADDR is the address of the struct jit_code_entry in the
 716    inferior address space.  */
 717
 718 static int
 719 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
 720                             CORE_ADDR entry_addr)
 721 {
 722   void *gdb_mem;
 723   int status;
 724   struct jit_dbg_reader *i;
 725   jit_dbg_reader_data priv_data;
 726   struct gdb_reader_funcs *funcs;
 727   volatile struct gdb_exception e;
 728   struct gdb_symbol_callbacks callbacks =
 729     {
 730       jit_object_open_impl,
 731       jit_symtab_open_impl,
 732       jit_block_open_impl,
 733       jit_symtab_close_impl,
 734       jit_object_close_impl,
 735
 736       jit_symtab_line_mapping_add_impl,
 737       jit_target_read_impl,
 738
 739       &priv_data
 740     };
 741
 742   priv_data = entry_addr;
 743
 744   if (!loaded_jit_reader)
 745     return 0;
 746
 747   gdb_mem = xmalloc (code_entry->symfile_size);
 748
 749   status = 1;
 750   TRY_CATCH (e, RETURN_MASK_ALL)
 751     if (target_read_memory (code_entry->symfile_addr, gdb_mem,
 752                             code_entry->symfile_size))
 753       status = 0;
 754   if (e.reason < 0)
 755     status = 0;
 756
 757   if (status)
 758     {
 759       funcs = loaded_jit_reader->functions;
 760       if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
 761           != GDB_SUCCESS)
 762         status = 0;
 763     }
 764
 765   xfree (gdb_mem);
 766   if (jit_debug && status == 0)
 767     fprintf_unfiltered (gdb_stdlog,
 768                         "Could not read symtab using the loaded JIT reader.\n");
 769   return status;
 770 }
 771
 772 /* Try to read CODE_ENTRY using BFD.  ENTRY_ADDR is the address of the
 773    struct jit_code_entry in the inferior address space.  */
 774
 775 static void
 776 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
 777                          CORE_ADDR entry_addr,
 778                          struct gdbarch *gdbarch)
 779 {
 780   bfd *nbfd;
 781   struct section_addr_info *sai;
 782   struct bfd_section *sec;
 783   struct objfile *objfile;
 784   struct cleanup *old_cleanups;
 785   int i;
 786   const struct bfd_arch_info *b;
 787
 788   if (jit_debug)
 789     fprintf_unfiltered (gdb_stdlog,
 790                         "jit_register_code, symfile_addr = %s, "
 791                         "symfile_size = %s\n",
 792                         paddress (gdbarch, code_entry->symfile_addr),
 793                         pulongest (code_entry->symfile_size));
 794
 795   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
 796                                       code_entry->symfile_size, gnutarget);
 797   if (nbfd == NULL)
 798     {
 799       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
 800       return;
 801     }
 802
 803   /* Check the format.  NOTE: This initializes important data that GDB uses!
 804      We would segfault later without this line.  */
 805   if (!bfd_check_format (nbfd, bfd_object))
 806     {
 807       printf_unfiltered (_("\
 808 JITed symbol file is not an object file, ignoring it.\n"));
 809       bfd_close (nbfd);
 810       return;
 811     }
 812
 813   /* Check bfd arch.  */
 814   b = gdbarch_bfd_arch_info (gdbarch);
 815   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
 816     warning (_("JITed object file architecture %s is not compatible "
 817                "with target architecture %s."), bfd_get_arch_info
 818              (nbfd)->printable_name, b->printable_name);
 819
 820   /* Read the section address information out of the symbol file.  Since the
 821      file is generated by the JIT at runtime, it should all of the absolute
 822      addresses that we care about.  */
 823   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
 824   old_cleanups = make_cleanup_free_section_addr_info (sai);
 825   i = 0;
 826   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
 827     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
 828       {
 829         /* We assume that these virtual addresses are absolute, and do not
 830            treat them as offsets.  */
 831         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
 832         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
 833         sai->other[i].sectindex = sec->index;
 834         ++i;
 835       }
 836
 837   /* This call takes ownership of NBFD.  It does not take ownership of SAI.  */
 838   objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
 839
 840   do_cleanups (old_cleanups);
 841   add_objfile_entry (objfile, entry_addr);
 842 }
 843
 844 /* This function registers code associated with a JIT code entry.  It uses the
 845    pointer and size pair in the entry to read the symbol file from the remote
 846    and then calls symbol_file_add_from_local_memory to add it as though it were
 847    a symbol file added by the user.  */
 848
 849 static void
 850 jit_register_code (struct gdbarch *gdbarch,
 851                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
 852 {
 853   int i, success;
 854   const struct bfd_arch_info *b;
 855   struct jit_inferior_data *inf_data = get_jit_inferior_data ();
 856
 857   if (jit_debug)
 858     fprintf_unfiltered (gdb_stdlog,
 859                         "jit_register_code, symfile_addr = %s, "
 860                         "symfile_size = %s\n",
 861                         paddress (gdbarch, code_entry->symfile_addr),
 862                         pulongest (code_entry->symfile_size));
 863
 864   success = jit_reader_try_read_symtab (code_entry, entry_addr);
 865
 866   if (!success)
 867     jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
 868 }
 869
 870 /* This function unregisters JITed code and frees the corresponding
 871    objfile.  */
 872
 873 static void
 874 jit_unregister_code (struct objfile *objfile)
 875 {
 876   free_objfile (objfile);
 877 }
 878
 879 /* Look up the objfile with this code entry address.  */
 880
 881 static struct objfile *
 882 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 883 {
 884   struct objfile *objf;
 885   CORE_ADDR *objf_entry_addr;
 886
 887   ALL_OBJFILES (objf)
 888     {
 889       objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
 890       if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
 891         return objf;
 892     }
 893   return NULL;
 894 }
 895
 896 /* (Re-)Initialize the jit breakpoint if necessary.
 897    Return 0 on success.  */
 898
 899 static int
 900 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 901                                 struct jit_inferior_data *inf_data)
 902 {
 903   if (inf_data->breakpoint_addr == 0)
 904     {
 905       struct minimal_symbol *reg_symbol;
 906
 907       /* Lookup the registration symbol.  If it is missing, then we assume
 908          we are not attached to a JIT.  */
 909       reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL);
 910       if (reg_symbol == NULL)
 911         return 1;
 912       inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
 913       if (inf_data->breakpoint_addr == 0)
 914         return 2;
 915
 916       /* If we have not read the jit descriptor yet (e.g. because the JITer
 917          itself is in a shared library which just got loaded), do so now.  */
 918       if (inf_data->descriptor_addr == 0)
 919         jit_inferior_init (gdbarch);
 920     }
 921   else
 922     return 0;
 923
 924   if (jit_debug)
 925     fprintf_unfiltered (gdb_stdlog,
 926                         "jit_breakpoint_re_set_internal, "
 927                         "breakpoint_addr = %s\n",
 928                         paddress (gdbarch, inf_data->breakpoint_addr));
 929
 930   /* Put a breakpoint in the registration symbol.  */
 931   create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr);
 932
 933   return 0;
 934 }
 935
 936 /* The private data passed around in the frame unwind callback
 937    functions.  */
 938
 939 struct jit_unwind_private
 940 {
 941   /* Cached register values.  See jit_frame_sniffer to see how this
 942      works.  */
 943   struct gdb_reg_value **registers;
 944
 945   /* The frame being unwound.  */
 946   struct frame_info *this_frame;
 947 };
 948
 949 /* Sets the value of a particular register in this frame.  */
 950
 951 static void
 952 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
 953                          struct gdb_reg_value *value)
 954 {
 955   struct jit_unwind_private *priv;
 956   int gdb_reg;
 957
 958   priv = cb->priv_data;
 959
 960   gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
 961                                           dwarf_regnum);
 962   if (gdb_reg == -1)
 963     {
 964       if (jit_debug)
 965         fprintf_unfiltered (gdb_stdlog,
 966                             _("Could not recognize DWARF regnum %d"),
 967                             dwarf_regnum);
 968       return;
 969     }
 970
 971   gdb_assert (priv->registers);
 972   priv->registers[gdb_reg] = value;
 973 }
 974
 975 static void
 976 reg_value_free_impl (struct gdb_reg_value *value)
 977 {
 978   xfree (value);
 979 }
 980
 981 /* Get the value of register REGNUM in the previous frame.  */
 982
 983 static struct gdb_reg_value *
 984 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
 985 {
 986   struct jit_unwind_private *priv;
 987   struct gdb_reg_value *value;
 988   int gdb_reg, size;
 989   struct gdbarch *frame_arch;
 990
 991   priv = cb->priv_data;
 992   frame_arch = get_frame_arch (priv->this_frame);
 993
 994   gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
 995   size = register_size (frame_arch, gdb_reg);
 996   value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
 997   value->defined = frame_register_read (priv->this_frame, gdb_reg,
 998                                         value->value);
 999   value->size = size;
1000   value->free = reg_value_free_impl;
1001   return value;
1002 }
1003
1004 /* gdb_reg_value has a free function, which must be called on each
1005    saved register value.  */
1006
1007 static void
1008 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1009 {
1010   struct jit_unwind_private *priv_data = cache;
1011   struct gdbarch *frame_arch;
1012   int i;
1013
1014   gdb_assert (priv_data->registers);
1015   frame_arch = get_frame_arch (priv_data->this_frame);
1016
1017   for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1018     if (priv_data->registers[i] && priv_data->registers[i]->free)
1019       priv_data->registers[i]->free (priv_data->registers[i]);
1020
1021   xfree (priv_data->registers);
1022   xfree (priv_data);
1023 }
1024
1025 /* The frame sniffer for the pseudo unwinder.
1026
1027    While this is nominally a frame sniffer, in the case where the JIT
1028    reader actually recognizes the frame, it does a lot more work -- it
1029    unwinds the frame and saves the corresponding register values in
1030    the cache.  jit_frame_prev_register simply returns the saved
1031    register values.  */
1032
1033 static int
1034 jit_frame_sniffer (const struct frame_unwind *self,
1035                    struct frame_info *this_frame, void **cache)
1036 {
1037   struct jit_inferior_data *inf_data;
1038   struct jit_unwind_private *priv_data;
1039   struct jit_dbg_reader *iter;
1040   struct gdb_unwind_callbacks callbacks;
1041   struct gdb_reader_funcs *funcs;
1042
1043   inf_data = get_jit_inferior_data ();
1044
1045   callbacks.reg_get = jit_unwind_reg_get_impl;
1046   callbacks.reg_set = jit_unwind_reg_set_impl;
1047   callbacks.target_read = jit_target_read_impl;
1048
1049   if (loaded_jit_reader == NULL)
1050     return 0;
1051
1052   funcs = loaded_jit_reader->functions;
1053
1054   gdb_assert (!*cache);
1055
1056   *cache = XZALLOC (struct jit_unwind_private);
1057   priv_data = *cache;
1058   priv_data->registers =
1059     XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1060              struct gdb_reg_value *);
1061   priv_data->this_frame = this_frame;
1062
1063   callbacks.priv_data = priv_data;
1064
1065   /* Try to coax the provided unwinder to unwind the stack */
1066   if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1067     {
1068       if (jit_debug)
1069         fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1070                                           "JIT reader.\n"));
1071       return 1;
1072     }
1073   if (jit_debug)
1074     fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1075                                       "JIT reader.\n"));
1076
1077   jit_dealloc_cache (this_frame, *cache);
1078   *cache = NULL;
1079
1080   return 0;
1081 }
1082
1083
1084 /* The frame_id function for the pseudo unwinder.  Relays the call to
1085    the loaded plugin.  */
1086
1087 static void
1088 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1089                    struct frame_id *this_id)
1090 {
1091   struct jit_unwind_private private;
1092   struct gdb_frame_id frame_id;
1093   struct gdb_reader_funcs *funcs;
1094   struct gdb_unwind_callbacks callbacks;
1095
1096   private.registers = NULL;
1097   private.this_frame = this_frame;
1098
1099   /* We don't expect the frame_id function to set any registers, so we
1100      set reg_set to NULL.  */
1101   callbacks.reg_get = jit_unwind_reg_get_impl;
1102   callbacks.reg_set = NULL;
1103   callbacks.target_read = jit_target_read_impl;
1104   callbacks.priv_data = &private;
1105
1106   gdb_assert (loaded_jit_reader);
1107   funcs = loaded_jit_reader->functions;
1108
1109   frame_id = funcs->get_frame_id (funcs, &callbacks);
1110   *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1111 }
1112
1113 /* Pseudo unwinder function.  Reads the previously fetched value for
1114    the register from the cache.  */
1115
1116 static struct value *
1117 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1118 {
1119   struct jit_unwind_private *priv = *cache;
1120   struct gdb_reg_value *value;
1121
1122   if (priv == NULL)
1123     return frame_unwind_got_optimized (this_frame, reg);
1124
1125   gdb_assert (priv->registers);
1126   value = priv->registers[reg];
1127   if (value && value->defined)
1128     return frame_unwind_got_bytes (this_frame, reg, value->value);
1129   else
1130     return frame_unwind_got_optimized (this_frame, reg);
1131 }
1132
1133 /* Relay everything back to the unwinder registered by the JIT debug
1134    info reader.*/
1135
1136 static const struct frame_unwind jit_frame_unwind =
1137 {
1138   NORMAL_FRAME,
1139   default_frame_unwind_stop_reason,
1140   jit_frame_this_id,
1141   jit_frame_prev_register,
1142   NULL,
1143   jit_frame_sniffer,
1144   jit_dealloc_cache
1145 };
1146
1147
1148 /* This is the information that is stored at jit_gdbarch_data for each
1149    architecture.  */
1150
1151 struct jit_gdbarch_data_type
1152 {
1153   /* Has the (pseudo) unwinder been prepended? */
1154   int unwinder_registered;
1155 };
1156
1157 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed.  */
1158
1159 static void
1160 jit_prepend_unwinder (struct gdbarch *gdbarch)
1161 {
1162   struct jit_gdbarch_data_type *data;
1163
1164   data = gdbarch_data (gdbarch, jit_gdbarch_data);
1165   if (!data->unwinder_registered)
1166     {
1167       frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1168       data->unwinder_registered = 1;
1169     }
1170 }
1171
1172 /* Register any already created translations.  */
1173
1174 static void
1175 jit_inferior_init (struct gdbarch *gdbarch)
1176 {
1177   struct jit_descriptor descriptor;
1178   struct jit_code_entry cur_entry;
1179   struct jit_inferior_data *inf_data;
1180   CORE_ADDR cur_entry_addr;
1181
1182   if (jit_debug)
1183     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1184
1185   jit_prepend_unwinder (gdbarch);
1186
1187   inf_data = get_jit_inferior_data ();
1188   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1189     return;
1190
1191   if (inf_data->descriptor_addr == 0)
1192     {
1193       struct minimal_symbol *desc_symbol;
1194
1195       /* Lookup the descriptor symbol and cache the addr.  If it is
1196          missing, we assume we are not attached to a JIT and return early.  */
1197       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL);
1198       if (desc_symbol == NULL)
1199         return;
1200
1201       inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
1202       if (inf_data->descriptor_addr == 0)
1203         return;
1204     }
1205
1206   if (jit_debug)
1207     fprintf_unfiltered (gdb_stdlog,
1208                         "jit_inferior_init, descriptor_addr = %s\n",
1209                         paddress (gdbarch, inf_data->descriptor_addr));
1210
1211   /* Read the descriptor so we can check the version number and load
1212      any already JITed functions.  */
1213   jit_read_descriptor (gdbarch, &descriptor, inf_data->descriptor_addr);
1214
1215   /* Check that the version number agrees with that we support.  */
1216   if (descriptor.version != 1)
1217     error (_("Unsupported JIT protocol version in descriptor!"));
1218
1219   /* If we've attached to a running program, we need to check the descriptor
1220      to register any functions that were already generated.  */
1221   for (cur_entry_addr = descriptor.first_entry;
1222        cur_entry_addr != 0;
1223        cur_entry_addr = cur_entry.next_entry)
1224     {
1225       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1226
1227       /* This hook may be called many times during setup, so make sure we don't
1228          add the same symbol file twice.  */
1229       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1230         continue;
1231
1232       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1233     }
1234 }
1235
1236 /* Exported routine to call when an inferior has been created.  */
1237
1238 void
1239 jit_inferior_created_hook (void)
1240 {
1241   jit_inferior_init (target_gdbarch);
1242 }
1243
1244 /* Exported routine to call to re-set the jit breakpoints,
1245    e.g. when a program is rerun.  */
1246
1247 void
1248 jit_breakpoint_re_set (void)
1249 {
1250   jit_breakpoint_re_set_internal (target_gdbarch,
1251                                   get_jit_inferior_data ());
1252 }
1253
1254 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
1255    will be reset.  */
1256
1257 static void
1258 jit_reset_inferior_data_and_breakpoints (void)
1259 {
1260   struct jit_inferior_data *inf_data;
1261
1262   /* Force jit_inferior_init to re-lookup of jit symbol addresses.  */
1263   inf_data = get_jit_inferior_data ();
1264   inf_data->breakpoint_addr = 0;
1265   inf_data->descriptor_addr = 0;
1266
1267   /* Remove any existing JIT breakpoint(s).  */
1268   remove_jit_event_breakpoints ();
1269
1270   jit_inferior_init (target_gdbarch);
1271 }
1272
1273 /* Wrapper to match the observer function pointer prototype.  */
1274
1275 static void
1276 jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
1277 {
1278   jit_reset_inferior_data_and_breakpoints ();
1279 }
1280
1281 /* This function cleans up any code entries left over when the
1282    inferior exits.  We get left over code when the inferior exits
1283    without unregistering its code, for example when it crashes.  */
1284
1285 static void
1286 jit_inferior_exit_hook (struct inferior *inf)
1287 {
1288   struct objfile *objf;
1289   struct objfile *temp;
1290
1291   ALL_OBJFILES_SAFE (objf, temp)
1292     if (objfile_data (objf, jit_objfile_data) != NULL)
1293       jit_unregister_code (objf);
1294 }
1295
1296 static void
1297 jit_executable_changed_observer (void)
1298 {
1299   jit_reset_inferior_data_and_breakpoints ();
1300 }
1301
1302 void
1303 jit_event_handler (struct gdbarch *gdbarch)
1304 {
1305   struct jit_descriptor descriptor;
1306   struct jit_code_entry code_entry;
1307   CORE_ADDR entry_addr;
1308   struct objfile *objf;
1309
1310   /* Read the descriptor from remote memory.  */
1311   jit_read_descriptor (gdbarch, &descriptor,
1312                        get_jit_inferior_data ()->descriptor_addr);
1313   entry_addr = descriptor.relevant_entry;
1314
1315   /* Do the corresponding action.  */
1316   switch (descriptor.action_flag)
1317     {
1318     case JIT_NOACTION:
1319       break;
1320     case JIT_REGISTER:
1321       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1322       jit_register_code (gdbarch, entry_addr, &code_entry);
1323       break;
1324     case JIT_UNREGISTER:
1325       objf = jit_find_objf_with_entry_addr (entry_addr);
1326       if (objf == NULL)
1327         printf_unfiltered (_("Unable to find JITed code "
1328                              "entry at address: %s\n"),
1329                            paddress (gdbarch, entry_addr));
1330       else
1331         jit_unregister_code (objf);
1332
1333       break;
1334     default:
1335       error (_("Unknown action_flag value in JIT descriptor!"));
1336       break;
1337     }
1338 }
1339
1340 /* Called to free the data allocated to the jit_inferior_data slot.  */
1341
1342 static void
1343 free_objfile_data (struct objfile *objfile, void *data)
1344 {
1345   xfree (data);
1346 }
1347
1348 /* Initialize the jit_gdbarch_data slot with an instance of struct
1349    jit_gdbarch_data_type */
1350
1351 static void *
1352 jit_gdbarch_data_init (struct obstack *obstack)
1353 {
1354   struct jit_gdbarch_data_type *data;
1355
1356   data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1357   data->unwinder_registered = 0;
1358   return data;
1359 }
1360
1361 /* Provide a prototype to silence -Wmissing-prototypes.  */
1362
1363 extern void _initialize_jit (void);
1364
1365 void
1366 _initialize_jit (void)
1367 {
1368   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1369                                            JIT_READER_DIR_RELOCATABLE);
1370   add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1371                             _("Set JIT debugging."),
1372                             _("Show JIT debugging."),
1373                             _("When non-zero, JIT debugging is enabled."),
1374                             NULL,
1375                             show_jit_debug,
1376                             &setdebuglist, &showdebuglist);
1377
1378   observer_attach_inferior_created (jit_inferior_created_observer);
1379   observer_attach_inferior_exit (jit_inferior_exit_hook);
1380   observer_attach_executable_changed (jit_executable_changed_observer);
1381   jit_objfile_data =
1382     register_objfile_data_with_cleanup (NULL, free_objfile_data);
1383   jit_inferior_data =
1384     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1385   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1386   if (is_dl_available ())
1387     {
1388       add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1389 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1390 Usage: jit-reader-load FILE\n\
1391 Try to load file FILE as a debug info reader (and unwinder) for\n\
1392 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
1393 relocated relative to the GDB executable if required."));
1394       add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1395 Unload the currently loaded JIT debug info reader.\n\
1396 Usage: jit-reader-unload FILE\n\n\
1397 Do \"help jit-reader-load\" for info on loading debug info readers."));
1398     }
1399 }