Merge GDB 7.5.1

gdb/jit.c

 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
 
    Copyright (C) 2009-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 109 matching lines @@
 
 static int
 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 {
   struct target_buffer *buffer = (struct target_buffer*) stream;
 
   sb->st_size = buffer->size;
   return 0;
 }
 
+/* Open a BFD from the target's memory.  */
+
+static struct bfd *
+bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
+{
+  const char *filename = xstrdup ("<in-memory>");
+  struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
+
+  buffer->base = addr;
+  buffer->size = size;
+  return bfd_openr_iovec (filename, target,
+                          mem_bfd_iovec_open,
+                          buffer,
+                          mem_bfd_iovec_pread,
+                          mem_bfd_iovec_close,
+                          mem_bfd_iovec_stat);
+}
+
 /* One reader that has been loaded successfully, and can potentially be used to
    parse debug info.  */
 
 static struct jit_reader
 {
   struct gdb_reader_funcs *functions;
   void *handle;
 } *loaded_jit_reader = NULL;
 
 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
@@ skipping 35 matching lines @@
   discard_cleanups (old_cleanups);
   return new_reader;
 }
 
 /* Provides the jit-reader-load command.  */
 
 static void
 jit_reader_load_command (char *args, int from_tty)
 {
   char *so_name;
-  int len;
   struct cleanup *prev_cleanup;
 
   if (args == NULL)
     error (_("No reader name provided."));
 
   if (loaded_jit_reader != NULL)
     error (_("JIT reader already loaded.  Run jit-reader-unload first."));
 
   so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
   prev_cleanup = make_cleanup (xfree, so_name);
@@ skipping 10 matching lines @@
   if (!loaded_jit_reader)
     error (_("No JIT reader loaded."));
 
   loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
 
   gdb_dlclose (loaded_jit_reader->handle);
   xfree (loaded_jit_reader);
   loaded_jit_reader = NULL;
 }
 
-/* Open a BFD from the target's memory.  */
-
-static struct bfd *
-bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
-{
-  const char *filename = xstrdup ("<in-memory>");
-  struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
-
-  buffer->base = addr;
-  buffer->size = size;
-  return bfd_openr_iovec (filename, target,
-                          mem_bfd_iovec_open,
-                          buffer,
-                          mem_bfd_iovec_pread,
-                          mem_bfd_iovec_close,
-                          mem_bfd_iovec_stat);
-}
-
-/* Per-inferior structure recording the addresses in the inferior.  */
+/* Per-inferior structure recording which objfile has the JIT
+   symbols.  */
 
 struct jit_inferior_data
 {
-  CORE_ADDR breakpoint_addr;  /* &__jit_debug_register_code()  */
-  CORE_ADDR descriptor_addr;  /* &__jit_debug_descriptor  */
+  /* The objfile.  This is NULL if no objfile holds the JIT
+     symbols.  */
+
+  struct objfile *objfile;
 };
 
+/* Per-objfile structure recording the addresses in the inferior.  */
+
+struct jit_objfile_data
+{
+  /* Symbol for __jit_debug_register_code.  */
+  struct minimal_symbol *register_code;
+
+  /* Symbol for __jit_debug_descriptor.  */
+  struct minimal_symbol *descriptor;
+
+  /* Address of struct jit_code_entry in this objfile.  */
+  CORE_ADDR addr;
+};
+
+/* Fetch the jit_objfile_data associated with OBJF.  If no data exists
+   yet, make a new structure and attach it.  */
+
+static struct jit_objfile_data *
+get_jit_objfile_data (struct objfile *objf)
+{
+  struct jit_objfile_data *objf_data;
+
+  objf_data = objfile_data (objf, jit_objfile_data);
+  if (objf_data == NULL)
+    {
+      objf_data = XZALLOC (struct jit_objfile_data);
+      set_objfile_data (objf, jit_objfile_data, objf_data);
+    }
+
+  return objf_data;
+}
+
 /* Remember OBJFILE has been created for struct jit_code_entry located
    at inferior address ENTRY.  */
 
 static void
 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
 {
-  CORE_ADDR *entry_addr_ptr;
+  struct jit_objfile_data *objf_data;
 
-  entry_addr_ptr = xmalloc (sizeof (CORE_ADDR));
-  *entry_addr_ptr = entry;
-  set_objfile_data (objfile, jit_objfile_data, entry_addr_ptr);
+  objf_data = get_jit_objfile_data (objfile);
+  objf_data->addr = entry;
 }
 
 /* Return jit_inferior_data for current inferior.  Allocate if not already
    present.  */
 
 static struct jit_inferior_data *
 get_jit_inferior_data (void)
 {
   struct inferior *inf;
   struct jit_inferior_data *inf_data;
 
   inf = current_inferior ();
   inf_data = inferior_data (inf, jit_inferior_data);
   if (inf_data == NULL)
     {
       inf_data = XZALLOC (struct jit_inferior_data);
       set_inferior_data (inf, jit_inferior_data, inf_data);
     }
 
   return inf_data;
 }
 
 static void
 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
 {
   xfree (arg);
 }
 
 /* Helper function for reading the global JIT descriptor from remote
-   memory.  */
+   memory.  Returns 1 if all went well, 0 otherwise.  */
 
-static void
+static int
 jit_read_descriptor (struct gdbarch *gdbarch,
                      struct jit_descriptor *descriptor,
-                     CORE_ADDR descriptor_addr)
+                     struct jit_inferior_data *inf_data)
 {
   int err;
   struct type *ptr_type;
   int ptr_size;
   int desc_size;
   gdb_byte *desc_buf;
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  struct jit_objfile_data *objf_data;
+
+  if (inf_data->objfile == NULL)
+    return 0;
+  objf_data = get_jit_objfile_data (inf_data->objfile);
+  if (objf_data->descriptor == NULL)
+    return 0;
+
+  if (jit_debug)
+    fprintf_unfiltered (gdb_stdlog,
+                        "jit_read_descriptor, descriptor_addr = %s\n",
+                        paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
 
   /* Figure out how big the descriptor is on the remote and how to read it.  */
   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
   ptr_size = TYPE_LENGTH (ptr_type);
   desc_size = 8 + 2 * ptr_size;  /* Two 32-bit ints and two pointers.  */
   desc_buf = alloca (desc_size);
 
   /* Read the descriptor.  */
-  err = target_read_memory (descriptor_addr, desc_buf, desc_size);
+  err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
+                            desc_buf, desc_size);
   if (err)
-    error (_("Unable to read JIT descriptor from remote memory!"));
+    {
+      printf_unfiltered (_("Unable to read JIT descriptor from "
+                           "remote memory\n"));
+      return 0;
+    }
 
   /* Fix the endianness to match the host.  */
   descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
   descriptor->action_flag =
       extract_unsigned_integer (&desc_buf[4], 4, byte_order);
   descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
   descriptor->first_entry =
       extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
+
+  return 1;
 }
 
 /* Helper function for reading a JITed code entry from remote memory.  */
 
 static void
 jit_read_code_entry (struct gdbarch *gdbarch,
                      CORE_ADDR code_addr, struct jit_code_entry *code_entry)
 {
   int err, off;
   struct type *ptr_type;
   int ptr_size;
   int entry_size;
   int align_bytes;
   gdb_byte *entry_buf;
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
   /* Figure out how big the entry is on the remote and how to read it.  */
   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
   ptr_size = TYPE_LENGTH (ptr_type);
-  entry_size = 3 * ptr_size + 8;  /* Three pointers and one 64-bit int.  */
+
+  /* Figure out where the longlong value will be.  */
+  align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
+  off = 3 * ptr_size;
+  off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
+
+  entry_size = off + 8;  /* Three pointers and one 64-bit int.  */
   entry_buf = alloca (entry_size);
 
   /* Read the entry.  */
   err = target_read_memory (code_addr, entry_buf, entry_size);
   if (err)
     error (_("Unable to read JIT code entry from remote memory!"));
 
   /* Fix the endianness to match the host.  */
   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
   code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
   code_entry->prev_entry =
       extract_typed_address (&entry_buf[ptr_size], ptr_type);
   code_entry->symfile_addr =
       extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
-
-  align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
-  off = 3 * ptr_size;
-  off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
-
   code_entry->symfile_size =
       extract_unsigned_integer (&entry_buf[off], 8, byte_order);
 }
 
 /* Proxy object for building a block.  */
 
 struct gdb_block
 {
   /* gdb_blocks are linked into a tree structure.  Next points to the
      next node at the same depth as this block and parent to the
@@ skipping 237 matching lines @@
   /* First run over all the gdb_block objects, creating a real block
      object for each.  Simultaneously, keep setting the real_block
      fields.  */
   for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
        i >= FIRST_LOCAL_BLOCK;
        i--, gdb_block_iter = gdb_block_iter->next)
     {
       struct block *new_block = allocate_block (&objfile->objfile_obstack);
       struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
                                                  sizeof (struct symbol));
+      struct type *block_type = arch_type (get_objfile_arch (objfile),
+                                           TYPE_CODE_VOID,
+                                           1,
+                                           "void");
 
       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
                                                    NULL);
       /* The address range.  */
       BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
 
       /* The name.  */
       memset (block_name, 0, sizeof (struct symbol));
       SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
       SYMBOL_CLASS (block_name) = LOC_BLOCK;
       SYMBOL_SYMTAB (block_name) = symtab;
+      SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
       SYMBOL_BLOCK_VALUE (block_name) = new_block;
 
       block_name->ginfo.name = obsavestring (gdb_block_iter->name,
                                              strlen (gdb_block_iter->name),
                                              &objfile->objfile_obstack);
 
       BLOCK_FUNCTION (new_block) = block_name;
 
       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
       if (begin > BLOCK_START (new_block))
         begin = BLOCK_START (new_block);
       if (end < BLOCK_END (new_block))
         end = BLOCK_END (new_block);
 
       gdb_block_iter->real_block = new_block;
     }
 
   /* Now add the special blocks.  */
   block_iter = NULL;
   for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
     {
-      struct block *new_block = allocate_block (&objfile->objfile_obstack);
+      struct block *new_block;
+
+      new_block = (i == GLOBAL_BLOCK
+                   ? allocate_global_block (&objfile->objfile_obstack)
+                   : allocate_block (&objfile->objfile_obstack));
       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
                                                    NULL);
       BLOCK_SUPERBLOCK (new_block) = block_iter;
       block_iter = new_block;
 
       BLOCK_START (new_block) = (CORE_ADDR) begin;
       BLOCK_END (new_block) = (CORE_ADDR) end;
 
       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
+
+      if (i == GLOBAL_BLOCK)
+        set_block_symtab (new_block, symtab);
     }
 
   /* Fill up the superblock fields for the real blocks, using the
      real_block fields populated earlier.  */
   for (gdb_block_iter = stab->blocks;
        gdb_block_iter;
        gdb_block_iter = gdb_block_iter->next)
     {
       if (gdb_block_iter->parent != NULL)
         BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
@@ skipping 24 matching lines @@
 {
   struct gdb_symtab *i, *j;
   struct objfile *objfile;
   jit_dbg_reader_data *priv_data;
 
   priv_data = cb->priv_data;
 
   objfile = allocate_objfile (NULL, 0);
   objfile->gdbarch = target_gdbarch;
 
-  objfile->msymbols = obstack_alloc (&objfile->objfile_obstack,
-                                     sizeof (struct minimal_symbol));
-  memset (objfile->msymbols, 0, sizeof (struct minimal_symbol));
+  terminate_minimal_symbol_table (objfile);
 
   xfree (objfile->name);
   objfile->name = xstrdup ("<< JIT compiled code >>");
 
   j = NULL;
   for (i = obj->symtabs; i; i = j)
     {
       j = i->next;
       finalize_symtab (i, objfile);
     }
   add_objfile_entry (objfile, *priv_data);
   xfree (obj);
 }
 
 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
    ENTRY_ADDR is the address of the struct jit_code_entry in the
    inferior address space.  */
 
 static int
 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
                             CORE_ADDR entry_addr)
 {
   void *gdb_mem;
   int status;
-  struct jit_dbg_reader *i;
   jit_dbg_reader_data priv_data;
   struct gdb_reader_funcs *funcs;
   volatile struct gdb_exception e;
   struct gdb_symbol_callbacks callbacks =
     {
       jit_object_open_impl,
       jit_symtab_open_impl,
       jit_block_open_impl,
       jit_symtab_close_impl,
       jit_object_close_impl,
@@ skipping 140 matching lines @@
 {
   free_objfile (objfile);
 }
 
 /* Look up the objfile with this code entry address.  */
 
 static struct objfile *
 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
 {
   struct objfile *objf;
-  CORE_ADDR *objf_entry_addr;
 
   ALL_OBJFILES (objf)
     {
-      objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data);
-      if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr)
+      struct jit_objfile_data *objf_data;
+
+      objf_data = objfile_data (objf, jit_objfile_data);
+      if (objf_data != NULL && objf_data->addr == entry_addr)
         return objf;
     }
   return NULL;
 }
 
 /* (Re-)Initialize the jit breakpoint if necessary.
    Return 0 on success.  */
 
 static int
 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
                                 struct jit_inferior_data *inf_data)
 {
-  if (inf_data->breakpoint_addr == 0)
-    {
-      struct minimal_symbol *reg_symbol;
+  struct minimal_symbol *reg_symbol, *desc_symbol;
+  struct objfile *objf;
+  struct jit_objfile_data *objf_data;
 
-      /* Lookup the registration symbol.  If it is missing, then we assume
-         we are not attached to a JIT.  */
-      reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL);
-      if (reg_symbol == NULL)
-        return 1;
-      inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol);
-      if (inf_data->breakpoint_addr == 0)
-        return 2;
+  if (inf_data->objfile != NULL)
+    return 0;
 
-      /* If we have not read the jit descriptor yet (e.g. because the JITer
-         itself is in a shared library which just got loaded), do so now.  */
-      if (inf_data->descriptor_addr == 0)
-        jit_inferior_init (gdbarch);
-    }
-  else
-    return 0;
+  /* Lookup the registration symbol.  If it is missing, then we assume
+     we are not attached to a JIT.  */
+  reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
+  if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
+    return 1;
+
+  desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
+  if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
+    return 1;
+
+  objf_data = get_jit_objfile_data (objf);
+  objf_data->register_code = reg_symbol;
+  objf_data->descriptor = desc_symbol;
+
+  inf_data->objfile = objf;
+
+  jit_inferior_init (gdbarch);
 
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
                         "jit_breakpoint_re_set_internal, "
                         "breakpoint_addr = %s\n",
-                        paddress (gdbarch, inf_data->breakpoint_addr));
+                        paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
 
   /* Put a breakpoint in the registration symbol.  */
-  create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr);
+  create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
 
   return 0;
 }
 
 /* The private data passed around in the frame unwind callback
    functions.  */
 
 struct jit_unwind_private
 {
   /* Cached register values.  See jit_frame_sniffer to see how this
@@ skipping 87 matching lines @@
    unwinds the frame and saves the corresponding register values in
    the cache.  jit_frame_prev_register simply returns the saved
    register values.  */
 
 static int
 jit_frame_sniffer (const struct frame_unwind *self,
                    struct frame_info *this_frame, void **cache)
 {
   struct jit_inferior_data *inf_data;
   struct jit_unwind_private *priv_data;
-  struct jit_dbg_reader *iter;
   struct gdb_unwind_callbacks callbacks;
   struct gdb_reader_funcs *funcs;
 
   inf_data = get_jit_inferior_data ();
 
   callbacks.reg_get = jit_unwind_reg_get_impl;
   callbacks.reg_set = jit_unwind_reg_set_impl;
   callbacks.target_read = jit_target_read_impl;
 
   if (loaded_jit_reader == NULL)
@@ skipping 131 matching lines @@
 
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
 
   jit_prepend_unwinder (gdbarch);
 
   inf_data = get_jit_inferior_data ();
   if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
     return;
 
-  if (inf_data->descriptor_addr == 0)
-    {
-      struct minimal_symbol *desc_symbol;
-
-      /* Lookup the descriptor symbol and cache the addr.  If it is
-         missing, we assume we are not attached to a JIT and return early.  */
-      desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL);
-      if (desc_symbol == NULL)
-        return;
-
-      inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol);
-      if (inf_data->descriptor_addr == 0)
-        return;
-    }
-
-  if (jit_debug)
-    fprintf_unfiltered (gdb_stdlog,
-                        "jit_inferior_init, descriptor_addr = %s\n",
-                        paddress (gdbarch, inf_data->descriptor_addr));
-
   /* Read the descriptor so we can check the version number and load
      any already JITed functions.  */
-  jit_read_descriptor (gdbarch, &descriptor, inf_data->descriptor_addr);
+  if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
+    return;
 
   /* Check that the version number agrees with that we support.  */
   if (descriptor.version != 1)
-    error (_("Unsupported JIT protocol version in descriptor!"));
+    {
+      printf_unfiltered (_("Unsupported JIT protocol version %ld "
+                           "in descriptor (expected 1)\n"),
+                         (long) descriptor.version);
+      return;
+    }
 
   /* If we've attached to a running program, we need to check the descriptor
      to register any functions that were already generated.  */
   for (cur_entry_addr = descriptor.first_entry;
        cur_entry_addr != 0;
        cur_entry_addr = cur_entry.next_entry)
     {
       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
 
       /* This hook may be called many times during setup, so make sure we don't
@@ skipping 16 matching lines @@
 /* Exported routine to call to re-set the jit breakpoints,
    e.g. when a program is rerun.  */
 
 void
 jit_breakpoint_re_set (void)
 {
   jit_breakpoint_re_set_internal (target_gdbarch,
                                   get_jit_inferior_data ());
 }
 
-/* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint
-   will be reset.  */
-
-static void
-jit_reset_inferior_data_and_breakpoints (void)
-{
-  struct jit_inferior_data *inf_data;
-
-  /* Force jit_inferior_init to re-lookup of jit symbol addresses.  */
-  inf_data = get_jit_inferior_data ();
-  inf_data->breakpoint_addr = 0;
-  inf_data->descriptor_addr = 0;
-
-  /* Remove any existing JIT breakpoint(s).  */
-  remove_jit_event_breakpoints ();
-
-  jit_inferior_init (target_gdbarch);
-}
-
-/* Wrapper to match the observer function pointer prototype.  */
-
-static void
-jit_inferior_created_observer (struct target_ops *objfile, int from_tty)
-{
-  jit_reset_inferior_data_and_breakpoints ();
-}
-
 /* This function cleans up any code entries left over when the
    inferior exits.  We get left over code when the inferior exits
    without unregistering its code, for example when it crashes.  */
 
 static void
 jit_inferior_exit_hook (struct inferior *inf)
 {
   struct objfile *objf;
   struct objfile *temp;
 
   ALL_OBJFILES_SAFE (objf, temp)
-    if (objfile_data (objf, jit_objfile_data) != NULL)
-      jit_unregister_code (objf);
-}
+    {
+      struct jit_objfile_data *objf_data = objfile_data (objf,
+                                                         jit_objfile_data);
 
-static void
-jit_executable_changed_observer (void)
-{
-  jit_reset_inferior_data_and_breakpoints ();
+      if (objf_data != NULL && objf_data->addr != 0)
+        jit_unregister_code (objf);
+    }
 }
 
 void
 jit_event_handler (struct gdbarch *gdbarch)
 {
   struct jit_descriptor descriptor;
   struct jit_code_entry code_entry;
   CORE_ADDR entry_addr;
   struct objfile *objf;
 
   /* Read the descriptor from remote memory.  */
-  jit_read_descriptor (gdbarch, &descriptor,
-                       get_jit_inferior_data ()->descriptor_addr);
+  if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
+    return;
   entry_addr = descriptor.relevant_entry;
 
   /* Do the corresponding action.  */
   switch (descriptor.action_flag)
     {
     case JIT_NOACTION:
       break;
     case JIT_REGISTER:
       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
       jit_register_code (gdbarch, entry_addr, &code_entry);
@@ skipping 12 matching lines @@
       error (_("Unknown action_flag value in JIT descriptor!"));
       break;
     }
 }
 
 /* Called to free the data allocated to the jit_inferior_data slot.  */
 
 static void
 free_objfile_data (struct objfile *objfile, void *data)
 {
+  struct jit_objfile_data *objf_data = data;
+
+  if (objf_data->register_code != NULL)
+    {
+      struct jit_inferior_data *inf_data = get_jit_inferior_data ();
+
+      if (inf_data->objfile == objfile)
+        inf_data->objfile = NULL;
+    }
+
   xfree (data);
 }
 
 /* Initialize the jit_gdbarch_data slot with an instance of struct
    jit_gdbarch_data_type */
 
 static void *
 jit_gdbarch_data_init (struct obstack *obstack)
 {
   struct jit_gdbarch_data_type *data;
@@ skipping 13 matching lines @@
   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
                                            JIT_READER_DIR_RELOCATABLE);
   add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
                             _("Set JIT debugging."),
                             _("Show JIT debugging."),
                             _("When non-zero, JIT debugging is enabled."),
                             NULL,
                             show_jit_debug,
                             &setdebuglist, &showdebuglist);
 
-  observer_attach_inferior_created (jit_inferior_created_observer);
   observer_attach_inferior_exit (jit_inferior_exit_hook);
-  observer_attach_executable_changed (jit_executable_changed_observer);
   jit_objfile_data =
     register_objfile_data_with_cleanup (NULL, free_objfile_data);
   jit_inferior_data =
     register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
   if (is_dl_available ())
     {
       add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
 Usage: jit-reader-load FILE\n\
 Try to load file FILE as a debug info reader (and unwinder) for\n\
 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
 relocated relative to the GDB executable if required."));
       add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
 Unload the currently loaded JIT debug info reader.\n\
 Usage: jit-reader-unload FILE\n\n\
 Do \"help jit-reader-load\" for info on loading debug info readers."));
     }
 }