[PATCH v2 2/3] Add type signature fallback and JIT objfile restriction.

[dominikmascherbauer <dominik.mascherbauer@gmail.com>]

To support type signature fallback, the lookup_signatured_type method is extended.
If no type signature was found in the current objfile or in a dwo file, the dwraf-type-signature-fallback option is checked:
'off': return nullptr
'main': only check the current main objfile for the type signature.
This reduces the additional load for a fallback as only one additional objfile is checked.
The main objfile often contains major parts of the debug info, thus it is also likely that the requested type signature is found there.
If the main objfile is linked to dwo/dwp files, those are also checked for the type signature.
This should be the same behavior as if the type signature is lookup up without fallback.
'full': check all objfiles in the current prospace.
Requires potentially more time than just checking the main objfile, but it will also find a type signature in a loaded shared library.

If a type signature was found in a fallback objfile, the per_objfile after lookup_signatured_type is the fallback per_objfile.
This ensures that if the type unit still needs to be read, it is read from the correct objfile.

Additionally, a flag is added to objfiles that marks an objfile as a JIT objfile.
With this information the type signature fallback can be restricted to only work for JIT objfiles.
This is a separate option because JIT objfile are self-contained but usually share debug info (especially type information) with some other already loaded objfile.
So this leaves loading other objfiles as is to avoid unexpected behavior if needed.
---
 gdb/dwarf2/read.c   | 184 +++++++++++++++++++++++++++++++++++++-------
 gdb/jit.c           |   6 +-
 gdb/objfile-flags.h |   3 +
 3 files changed, 162 insertions(+), 31 deletions(-)

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 3fdaf003fb7..4b86acec772 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -2669,12 +2669,12 @@ fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile *per_objfile,
    to read all the DWOs to build the type unit groups.  */
 
 static struct signatured_type *
-lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
+lookup_dwo_signatured_type (struct dwo_unit *dwo_unit, ULONGEST sig,
+			    struct dwarf2_per_objfile *per_objfile)
 {
-  dwarf2_per_objfile *per_objfile = cu->per_objfile;
   dwarf2_per_bfd *per_bfd = per_objfile->per_bfd;
 
-  gdb_assert (cu->dwo_unit);
+  gdb_assert (dwo_unit);
 
   /* We only ever need to read in one copy of a signatured type.
      Use the global signatured_types array to do our own comdat-folding
@@ -2697,14 +2697,14 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
       && (*sig_type_it)->tu_read)
     return *sig_type_it;
 
-  /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
+  /* Note: dwo_unit is the dwo_unit that references this TU, not the
      dwo_unit of the TU itself.  */
-  dwo_file *dwo_file = cu->dwo_unit->dwo_file;
+  dwo_file *dwo_file = dwo_unit->dwo_file;
   auto it = dwo_file->tus.find (sig);
   if (it == dwo_file->tus.end ())
     return nullptr;
 
-  dwo_unit *dwo_entry = *it;
+  struct dwo_unit *dwo_entry = *it;
 
   /* If the global table doesn't have an entry for this TU, add one.  */
   if (sig_type_it == per_bfd->signatured_types.end ())
@@ -2724,13 +2724,12 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
    it won't be in .gdb_index.  */
 
 static struct signatured_type *
-lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
+lookup_dwp_signatured_type (ULONGEST sig,
+			    struct dwarf2_per_objfile *per_objfile)
 {
-  dwarf2_per_objfile *per_objfile = cu->per_objfile;
   dwarf2_per_bfd *per_bfd = per_objfile->per_bfd;
   struct dwp_file *dwp_file = get_dwp_file (per_objfile);
 
-  gdb_assert (cu->dwo_unit);
   gdb_assert (dwp_file != NULL);
 
   auto sig_type_it = per_bfd->signatured_types.find (sig);
@@ -2756,34 +2755,133 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
   return *sig_type_it;
 }
 
+/* Subroutine of lookup_signatured_type.
+   Look up the type for signature SIG, from a fallback objfile.
+   If we don't have a DWO/DWP file or can't find the signature there, check the
+   fallback object file.
+   If a signatured type was found, PER_OBJFILE will contain its per_objfile.  */
+
+static struct signatured_type *
+lookup_fallback_signatured_type (struct objfile *fallback_objfile, ULONGEST sig,
+				 struct dwarf2_per_objfile **per_objfile)
+{
+  struct signatured_type *sig_type = nullptr;
+
+  /* If we have a separate debug objfile, use it for the fallback.  */
+  if (fallback_objfile->separate_debug_objfile != nullptr)
+    fallback_objfile = fallback_objfile->separate_debug_objfile;
+
+  struct dwarf2_per_objfile *fallback_per_objfile = get_dwarf2_per_objfile
+	  (fallback_objfile);
+
+  /* The fallback objfile must be different to the current objfile.  Otherwise,
+     this is no fallback so all necessary checks were already performed in
+     lookup_signatured_type.  */
+  if (fallback_per_objfile == *per_objfile)
+    return nullptr;
+
+  /* Do we have a dwp file?  */
+  if (get_dwp_file (fallback_per_objfile) != nullptr)
+    {
+      sig_type = lookup_dwp_signatured_type (sig, fallback_per_objfile);
+    }
+    /* Do we have dwo files?  */
+  else
+    {
+      /* Look for dwo_entry that contains the signatured type.  */
+      for (const dwo_file_up &file : fallback_per_objfile->per_bfd->dwo_files)
+        {
+	  auto it = file->tus.find (sig);
+	  if (it != file->tus.end ())
+	    {
+	      /* We found the dwo entry.  Check for the signatured type.  */
+	      sig_type = lookup_dwo_signatured_type (*it, sig,
+						   fallback_per_objfile);
+	      break;
+	    }
+        }
+    }
+
+  /* Do we still need to check the fallback per_objfile or was the signatured
+     type found in a DWO/DWP file?  */
+  if (sig_type == nullptr)
+    {
+      auto sig_type_it
+        = fallback_per_objfile->per_bfd->signatured_types.find (sig);
+
+      if (sig_type_it != fallback_per_objfile->per_bfd->signatured_types.end ())
+	sig_type = *sig_type_it;
+    }
+
+  if (sig_type != nullptr)
+    /* Ensure we will know where the signature type came from.  */
+    *per_objfile = fallback_per_objfile;
+  return sig_type;
+}
+
 /* Lookup a signature based type for DW_FORM_ref_sig8.
    Returns NULL if signature SIG is not present in the table.
-   It is up to the caller to complain about this.  */
+   It is up to the caller to complain about this.
+   If type_signature_fallback is enabled and the signatured type is found,
+   per_objfile is the objfile where the signatured type was found in.  */
 
 static struct signatured_type *
-lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
+lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig,
+			struct dwarf2_per_objfile **per_objfile)
 {
-  dwarf2_per_objfile *per_objfile = cu->per_objfile;
-  dwarf2_per_bfd *per_bfd = per_objfile->per_bfd;
+  struct signatured_type *sig_type = nullptr;
+  dwarf2_per_bfd *per_bfd = (*per_objfile)->per_bfd;
 
   if (cu->dwo_unit)
     {
       /* We're in a DWO/DWP file, and we're using .gdb_index.
-	 These cases require special processing.  */
-      if (get_dwp_file (per_objfile) == NULL)
-	return lookup_dwo_signatured_type (cu, sig);
+     These cases require special processing.  */
+      if (get_dwp_file (*per_objfile) == nullptr)
+	sig_type = lookup_dwo_signatured_type (cu->dwo_unit, sig, *per_objfile);
       else
-	return lookup_dwp_signatured_type (cu, sig);
+	sig_type = lookup_dwp_signatured_type (sig, *per_objfile);
+
+      /* If we already found the signatured type, return it.  */
+      if (sig_type != nullptr)
+	return sig_type;
     }
   else
     {
+      /* Lookup type signature in the current objfile.  */
       auto sig_type_it = per_bfd->signatured_types.find (sig);
 
+      /* If we already found the signatured type, return it.  */
       if (sig_type_it != per_bfd->signatured_types.end ())
 	return *sig_type_it;
+    }
 
-      return nullptr;
+  /* Handle fallback if type signature lookup fallback is enabled for this
+     objfile.  */
+  if (use_type_signature_fallback ((*per_objfile)->objfile))
+    {
+      /* Do a full fallback through all objfiles in the progspace.  */
+      if (type_signature_fallback == type_signature_fallback_full)
+	{
+	  for (objfile *objfile: (*per_objfile)->objfile->pspace ()->objfiles ())
+	    {
+	      sig_type = lookup_fallback_signatured_type (objfile, sig,
+							  per_objfile);
+	      /* If we already found the signatured type, return it.  */
+	      if (sig_type != nullptr)
+		return sig_type;
+	    }
+	}
+      else
+	{
+	  /* fallback to main symfile objfile.  */
+	  struct objfile *objfile
+	    = (*per_objfile)->objfile->pspace ()->symfile_object_file;
+	  return lookup_fallback_signatured_type (objfile, sig, per_objfile);
+	}
     }
+
+  /* We could not find the signatured type.  */
+  return nullptr;
 }
 
 /* Low level DIE reading support.  */
@@ -4333,8 +4431,19 @@ maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu, dwarf2_per_cu *per_cu,
   bool queued = false;
   if (!per_objfile->symtab_set_p (per_cu))
     {
-      /* Add it to the queue.  */
-      queue_comp_unit (per_cu, per_objfile, pretend_language);
+      if (dependent_cu != nullptr && !per_objfile->queue.has_value () &&
+	  type_signature_fallback != type_signature_fallback_off)
+	{
+	  /* If the signatured type in the fallback objfile references another
+	     signatured type we might end up here with no queue in the fallback
+	     objfile.  */
+	  dw2_instantiate_symtab (per_cu, per_objfile, false);
+	}
+      else
+	{
+	  /* Add it to the queue.  */
+	  queue_comp_unit (per_cu, per_objfile, pretend_language);
+	}
       queued = true;
 
       dwarf_read_debug_printf ("Queuing CU for expansion: "
@@ -8383,7 +8492,7 @@ static int
 queue_and_load_dwo_tu (dwo_unit *dwo_unit, dwarf2_cu *cu)
 {
   ULONGEST signature = dwo_unit->signature;
-  signatured_type *sig_type = lookup_dwo_signatured_type (cu, signature);
+  signatured_type *sig_type = lookup_dwo_signatured_type (cu->dwo_unit, signature, cu->per_objfile);
 
   if (sig_type != NULL)
     {
@@ -18985,6 +19094,7 @@ dwarf2_get_die_type (cu_offset die_offset, dwarf2_per_cu *per_cu,
 
 static struct die_info *
 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
+		  struct dwarf2_per_objfile *sig_type_per_objfile,
 		  struct dwarf2_cu **ref_cu)
 {
   struct dwarf2_cu *sig_cu;
@@ -19000,12 +19110,14 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
      Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
      it doesn't mean they are currently loaded.  Since we require them
      to be loaded, we must check for ourselves.  */
-  if (maybe_queue_comp_unit (*ref_cu, sig_type, per_objfile,
+  if (maybe_queue_comp_unit (*ref_cu, sig_type, sig_type_per_objfile,
 			     language_minimal)
-      || per_objfile->get_cu (sig_type) == nullptr)
-    read_signatured_type (sig_type, per_objfile);
+      || sig_type_per_objfile->get_cu (sig_type) == nullptr)
+    {
+      read_signatured_type (sig_type, sig_type_per_objfile);
+    }
 
-  sig_cu = per_objfile->get_cu (sig_type);
+  sig_cu = sig_type_per_objfile->get_cu (sig_type);
   gdb_assert (sig_cu != NULL);
   gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
 
@@ -19041,7 +19153,8 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr,
 
   gdb_assert (attr->form == DW_FORM_ref_sig8);
 
-  sig_type = lookup_signatured_type (*ref_cu, signature);
+  dwarf2_per_objfile *sig_type_per_objfile = (*ref_cu)->per_objfile;
+  sig_type = lookup_signatured_type (*ref_cu, signature, &sig_type_per_objfile);
   /* sig_type will be NULL if the signatured type is missing from
      the debug info.  */
   if (sig_type == NULL)
@@ -19053,7 +19166,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr,
 	     objfile_name ((*ref_cu)->per_objfile->objfile));
     }
 
-  die = follow_die_sig_1 (src_die, sig_type, ref_cu);
+  die = follow_die_sig_1 (src_die, sig_type, sig_type_per_objfile, ref_cu);
   if (die == NULL)
     {
       src_die->error_dump ();
@@ -19080,7 +19193,8 @@ get_signatured_type (struct die_info *die, ULONGEST signature,
   struct die_info *type_die;
   struct type *type;
 
-  sig_type = lookup_signatured_type (cu, signature);
+  dwarf2_per_objfile *sig_type_per_objfile = per_objfile;
+  sig_type = lookup_signatured_type (cu, signature, &sig_type_per_objfile);
   /* sig_type will be NULL if the signatured type is missing from
      the debug info.  */
   if (sig_type == NULL)
@@ -19099,7 +19213,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature,
     return type;
 
   type_cu = cu;
-  type_die = follow_die_sig_1 (die, sig_type, &type_cu);
+  type_die = follow_die_sig_1 (die, sig_type, sig_type_per_objfile, &type_cu);
   if (type_die != NULL)
     {
       /* N.B. We need to call get_die_type to ensure only one type for this DIE
@@ -19126,6 +19240,18 @@ get_signatured_type (struct die_info *die, ULONGEST signature,
       type = build_error_marker_type (cu, die);
     }
 
+  if (type_signature_fallback != type_signature_fallback_off)
+    {
+      /* We might already have read the required signatured type
+         after looking for it in a fallback objfile  */
+      struct type *existing_type = per_objfile->get_type_for_signatured_type
+	      (sig_type);
+      if (existing_type != nullptr)
+	{
+	  gdb_assert (type == existing_type);
+	  return type;
+	}
+    }
   per_objfile->set_type_for_signatured_type (sig_type, type);
 
   return type;
diff --git a/gdb/jit.c b/gdb/jit.c
index d55e371b02a..ce19591c378 100644
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -664,7 +664,8 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb,
 			       priv_data->entry.symfile_addr));
 
   objfile *objfile = objfile::make (nullptr, current_program_space,
-				    objfile_name.c_str (), OBJF_NOT_FILENAME);
+				    objfile_name.c_str (),
+				    OBJF_NOT_FILENAME | OBJF_JIT);
   objfile->section_offsets.push_back (0);
   objfile->sect_index_text = 0;
   objfile->per_bfd->gdbarch = priv_data->gdbarch;
@@ -801,7 +802,8 @@ JITed symbol file is not an object file, ignoring it.\n"));
   objfile = symbol_file_add_from_bfd (nbfd,
 				      bfd_get_filename (nbfd.get ()), 0,
 				      &sai,
-				      OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
+				      OBJF_SHARED | OBJF_NOT_FILENAME |
+				      OBJF_JIT, NULL);
 
   add_objfile_entry (objfile, entry_addr, code_entry->symfile_addr,
 		     code_entry->symfile_size);
diff --git a/gdb/objfile-flags.h b/gdb/objfile-flags.h
index e0a84bcdc2e..0ad6e4037dd 100644
--- a/gdb/objfile-flags.h
+++ b/gdb/objfile-flags.h
@@ -56,6 +56,9 @@ enum objfile_flag : unsigned
     /* User requested that we do not read this objfile's symbolic
        information.  */
     OBJF_READNEVER = 1 << 6,
+
+    /* Set if this objfile originates from a JIT compilation  */
+    OBJF_JIT = 1 << 7,
   };
 
 DEF_ENUM_FLAGS_TYPE (enum objfile_flag, objfile_flags);
-- 
2.34.1