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