Re: RFC: fix PR 13987

[Tom Tromey <tromey at redhat dot com>]

Tom> Maybe I see -- the objfile is attached to a progspace, not an inferior.
Tom> So we have to look for inferiors using this progspace instead of
Tom> assuming the current inferior.

Tom> Is that what you mean?  Or if not, can you walk me through it some more?

Pedro> I meant, that even if it was attached to an inferior, there is no
Pedro> hard guarantee that the current inferior would be the one
Pedro> the breakpoint is attached to.  But yes, that too.

Here's a follow-up patch that reworks jit.c to attach its data to the
program space, not the inferior.  This cleans up a couple of messy bits:
jit_breakpoint_deleted is now much more direct, and free_objfile_data
doesn't rely on the current inferior or program space at all, as it can
now examine the objfile directly.

Built and regtested on x86-64 Fedora 16.

What do you think?
I'm going to hold the earlier patch pending this one, since I think the
two together make the most sense.

Tom

2013-01-24  Tom Tromey  <tromey@redhat.com>

	* jit.c (jit_program_space_data): Rename from jit_inferior_data;
	change type.
	(struct jit_program_space_data): Rename from jit_inferior_data.
	Update comments.
	(get_jit_program_space_data): Rename from get_jit_inferior_data.
	Change return type.  Attach data to program space.
	(jit_program_space_data_cleanup): Rename from
	jit_inferior_data_cleanup; change argument type.
	(jit_read_descriptor): Change 'inf_data' argument to 'ps_data',
	change type.
	(jit_register_code): Update.
	(jit_update_inferior_cache): Remove.
	(jit_breakpoint_deleted): Get jit data from the location's program
	space.
	(jit_breakpoint_re_set_internal): Rename 'inf_data' argument to
	'ps_data', change type.
	(jit_frame_sniffer, jit_inferior_init)
	(jit_breakpoint_re_set_internal, jit_event_handler): Update.
	(free_objfile_data): Get data from objfile's program space.
	(_initialize_jit): Update.

commit 0aa80c607b3a3d6cd07e5b84fa7f60502b89f2f4
Author: Tom Tromey <tromey@redhat.com>
Date:   Thu Jan 24 08:17:38 2013 -0700

    make JIT use program spaces

diff --git a/gdb/jit.c b/gdb/jit.c
index a735cde..94993c4 100644
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -49,7 +49,7 @@ static const char *const jit_break_name = "__jit_debug_register_code";
 
 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
 
-static const struct inferior_data *jit_inferior_data = NULL;
+static const struct program_space_data *jit_program_space_data = NULL;
 
 static void jit_inferior_init (struct gdbarch *gdbarch);
 
@@ -234,17 +234,17 @@ jit_reader_unload_command (char *args, int from_tty)
   loaded_jit_reader = NULL;
 }
 
-/* Per-inferior structure recording which objfile has the JIT
+/* Per-program space structure recording which objfile has the JIT
    symbols.  */
 
-struct jit_inferior_data
+struct jit_program_space_data
 {
   /* The objfile.  This is NULL if no objfile holds the JIT
      symbols.  */
 
   struct objfile *objfile;
 
-  /* If this inferior has __jit_debug_register_code, this is the
+  /* If this program space has __jit_debug_register_code, this is the
      cached address from the minimal symbol.  This is used to detect
      relocations requiring the breakpoint to be re-created.  */
 
@@ -256,7 +256,7 @@ struct jit_inferior_data
   struct breakpoint *jit_breakpoint;
 };
 
-/* Per-objfile structure recording the addresses in the inferior.
+/* Per-objfile structure recording the addresses in the program space.
    This object serves two purposes: for ordinary objfiles, it may
    cache some symbols related to the JIT interface; and for
    JIT-created objfiles, it holds some information about the
@@ -305,28 +305,27 @@ add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
   objf_data->addr = entry;
 }
 
-/* Return jit_inferior_data for current inferior.  Allocate if not already
-   present.  */
+/* Return jit_program_space_data for current program space.  Allocate
+   if not already present.  */
 
-static struct jit_inferior_data *
-get_jit_inferior_data (void)
+static struct jit_program_space_data *
+get_jit_program_space_data (void)
 {
-  struct inferior *inf;
-  struct jit_inferior_data *inf_data;
+  struct jit_program_space_data *ps_data;
 
-  inf = current_inferior ();
-  inf_data = inferior_data (inf, jit_inferior_data);
-  if (inf_data == NULL)
+  ps_data = program_space_data (current_program_space, jit_program_space_data);
+  if (ps_data == NULL)
     {
-      inf_data = XZALLOC (struct jit_inferior_data);
-      set_inferior_data (inf, jit_inferior_data, inf_data);
+      ps_data = XZALLOC (struct jit_program_space_data);
+      set_program_space_data (current_program_space, jit_program_space_data,
+			      ps_data);
     }
 
-  return inf_data;
+  return ps_data;
 }
 
 static void
-jit_inferior_data_cleanup (struct inferior *inf, void *arg)
+jit_program_space_data_cleanup (struct program_space *ps, void *arg)
 {
   xfree (arg);
 }
@@ -337,7 +336,7 @@ jit_inferior_data_cleanup (struct inferior *inf, void *arg)
 static int
 jit_read_descriptor (struct gdbarch *gdbarch,
 		     struct jit_descriptor *descriptor,
-		     struct jit_inferior_data *inf_data)
+		     struct jit_program_space_data *ps_data)
 {
   int err;
   struct type *ptr_type;
@@ -347,9 +346,9 @@ jit_read_descriptor (struct gdbarch *gdbarch,
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct jit_objfile_data *objf_data;
 
-  if (inf_data->objfile == NULL)
+  if (ps_data->objfile == NULL)
     return 0;
-  objf_data = get_jit_objfile_data (inf_data->objfile);
+  objf_data = get_jit_objfile_data (ps_data->objfile);
   if (objf_data->descriptor == NULL)
     return 0;
 
@@ -944,7 +943,7 @@ jit_register_code (struct gdbarch *gdbarch,
 {
   int i, success;
   const struct bfd_arch_info *b;
-  struct jit_inferior_data *inf_data = get_jit_inferior_data ();
+  struct jit_program_space_data *ps_data = get_jit_program_space_data ();
 
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
@@ -986,29 +985,6 @@ jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
   return NULL;
 }
 
-/* A callback for iterate_over_inferiors that updates the inferior's
-   JIT breakpoint information, if necessary.  */
-
-static int
-jit_update_inferior_cache (struct inferior *inf, void *data)
-{
-  struct bp_location *loc = data;
-
-  if (inf->pspace == loc->pspace)
-    {
-      struct jit_inferior_data *inf_data;
-
-      inf_data = inferior_data (inf, jit_inferior_data);
-      if (inf_data != NULL && inf_data->jit_breakpoint == loc->owner)
-	{
-	  inf_data->cached_code_address = 0;
-	  inf_data->jit_breakpoint = NULL;
-	}
-    }
-
-  return 0;
-}
-
 /* This is called when a breakpoint is deleted.  It updates the
    inferior's cache, if needed.  */
 
@@ -1021,7 +997,16 @@ jit_breakpoint_deleted (struct breakpoint *b)
     return;
 
   for (iter = b->loc; iter != NULL; iter = iter->next)
-    iterate_over_inferiors (jit_update_inferior_cache, iter);
+    {
+      struct jit_program_space_data *ps_data;
+
+      ps_data = program_space_data (iter->pspace, jit_program_space_data);
+      if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
+	{
+	  ps_data->cached_code_address = 0;
+	  ps_data->jit_breakpoint = NULL;
+	}
+    }
 }
 
 /* (Re-)Initialize the jit breakpoint if necessary.
@@ -1029,14 +1014,14 @@ jit_breakpoint_deleted (struct breakpoint *b)
 
 static int
 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
-				struct jit_inferior_data *inf_data)
+				struct jit_program_space_data *ps_data)
 {
   struct minimal_symbol *reg_symbol, *desc_symbol;
   struct objfile *objf;
   struct jit_objfile_data *objf_data;
   CORE_ADDR addr;
 
-  if (inf_data->objfile == NULL)
+  if (ps_data->objfile == NULL)
     {
       /* Lookup the registration symbol.  If it is missing, then we
 	 assume we are not attached to a JIT.  */
@@ -1052,10 +1037,10 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
       objf_data->register_code = reg_symbol;
       objf_data->descriptor = desc_symbol;
 
-      inf_data->objfile = objf;
+      ps_data->objfile = objf;
     }
   else
-    objf_data = get_jit_objfile_data (inf_data->objfile);
+    objf_data = get_jit_objfile_data (ps_data->objfile);
 
   addr = SYMBOL_VALUE_ADDRESS (objf_data->register_code);
 
@@ -1065,16 +1050,16 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 			"breakpoint_addr = %s\n",
 			paddress (gdbarch, addr));
 
-  if (inf_data->cached_code_address == addr)
+  if (ps_data->cached_code_address == addr)
     return 1;
 
   /* Delete the old breakpoint.  */
-  if (inf_data->jit_breakpoint != NULL)
-    delete_breakpoint (inf_data->jit_breakpoint);
+  if (ps_data->jit_breakpoint != NULL)
+    delete_breakpoint (ps_data->jit_breakpoint);
 
   /* Put a breakpoint in the registration symbol.  */
-  inf_data->cached_code_address = addr;
-  inf_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
+  ps_data->cached_code_address = addr;
+  ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
 
   return 0;
 }
@@ -1180,12 +1165,12 @@ 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_program_space_data *ps_data;
   struct jit_unwind_private *priv_data;
   struct gdb_unwind_callbacks callbacks;
   struct gdb_reader_funcs *funcs;
 
-  inf_data = get_jit_inferior_data ();
+  ps_data = get_jit_program_space_data ();
 
   callbacks.reg_get = jit_unwind_reg_get_impl;
   callbacks.reg_set = jit_unwind_reg_set_impl;
@@ -1321,7 +1306,7 @@ jit_inferior_init (struct gdbarch *gdbarch)
 {
   struct jit_descriptor descriptor;
   struct jit_code_entry cur_entry;
-  struct jit_inferior_data *inf_data;
+  struct jit_program_space_data *ps_data;
   CORE_ADDR cur_entry_addr;
 
   if (jit_debug)
@@ -1329,13 +1314,13 @@ jit_inferior_init (struct gdbarch *gdbarch)
 
   jit_prepend_unwinder (gdbarch);
 
-  inf_data = get_jit_inferior_data ();
-  if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
+  ps_data = get_jit_program_space_data ();
+  if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
     return;
 
   /* Read the descriptor so we can check the version number and load
      any already JITed functions.  */
-  if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
+  if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
     return;
 
   /* Check that the version number agrees with that we support.  */
@@ -1379,7 +1364,7 @@ void
 jit_breakpoint_re_set (void)
 {
   jit_breakpoint_re_set_internal (target_gdbarch (),
-				  get_jit_inferior_data ());
+				  get_jit_program_space_data ());
 }
 
 /* This function cleans up any code entries left over when the
@@ -1411,7 +1396,8 @@ jit_event_handler (struct gdbarch *gdbarch)
   struct objfile *objf;
 
   /* Read the descriptor from remote memory.  */
-  if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
+  if (!jit_read_descriptor (gdbarch, &descriptor,
+			    get_jit_program_space_data ()))
     return;
   entry_addr = descriptor.relevant_entry;
 
@@ -1440,7 +1426,7 @@ jit_event_handler (struct gdbarch *gdbarch)
     }
 }
 
-/* Called to free the data allocated to the jit_inferior_data slot.  */
+/* Called to free the data allocated to the jit_program_space_data slot.  */
 
 static void
 free_objfile_data (struct objfile *objfile, void *data)
@@ -1449,10 +1435,11 @@ free_objfile_data (struct objfile *objfile, void *data)
 
   if (objf_data->register_code != NULL)
     {
-      struct jit_inferior_data *inf_data = get_jit_inferior_data ();
+      struct jit_program_space_data *ps_data;
 
-      if (inf_data->objfile == objfile)
-	inf_data->objfile = NULL;
+      ps_data = program_space_data (objfile->pspace, jit_program_space_data);
+      if (ps_data != NULL && ps_data->objfile == objfile)
+	ps_data->objfile = NULL;
     }
 
   xfree (data);
@@ -1493,8 +1480,9 @@ _initialize_jit (void)
 
   jit_objfile_data =
     register_objfile_data_with_cleanup (NULL, free_objfile_data);
-  jit_inferior_data =
-    register_inferior_data_with_cleanup (NULL, jit_inferior_data_cleanup);
+  jit_program_space_data =
+    register_program_space_data_with_cleanup (NULL,
+					      jit_program_space_data_cleanup);
   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
   if (is_dl_available ())
     {