1 files changed, 92 insertions, 116 deletions

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index ff4f388..71fd352 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -32,7 +32,7 @@
 #include "dwarf2/aranges.h"
 #include "dwarf2/attribute.h"
 #include "dwarf2/comp-unit-head.h"
-#include "dwarf2/cooked-index-storage.h"
+#include "dwarf2/cooked-index-worker.h"
 #include "dwarf2/cooked-indexer.h"
 #include "dwarf2/cu.h"
 #include "dwarf2/index-cache.h"
@@ -728,7 +728,7 @@ show_dwarf_synchronous (struct ui_file *file, int from_tty,
 /* local function prototypes */
 
 static void build_type_psymtabs_reader (cutu_reader *reader,
-					cooked_index_storage *storage);
+					cooked_index_worker_result *storage);
 
 static void var_decode_location (struct attribute *attr,
 				 struct symbol *sym,
@@ -1791,7 +1791,7 @@ dw2_get_file_names (dwarf2_per_cu *this_cu, dwarf2_per_objfile *per_objfile)
   if (this_cu->files_read)
     return this_cu->file_names;
 
-  cutu_reader reader (this_cu, per_objfile, nullptr,
+  cutu_reader reader (*this_cu, *per_objfile, nullptr,
 		      per_objfile->get_cu (this_cu), true, language_minimal,
 		      nullptr);
   if (!reader.is_dummy ())
@@ -2866,8 +2866,12 @@ lookup_dwo_id (struct dwarf2_cu *cu, struct die_info* comp_unit_die)
 }
 
 /* Subroutine of cutu_reader to simplify it.
-   Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
-   Returns NULL if the specified DWO unit cannot be found.  */
+   Look up the DWO unit specified by COMP_UNIT_DIE of CU.
+
+   DWO_NAME is the name (DW_AT_dwo_name) of the DWO unit already read from
+   COMP_UNIT_DIE.
+
+   Returns nullptr if the specified DWO unit cannot be found.  */
 
 static struct dwo_unit *
 lookup_dwo_unit (dwarf2_cu *cu, die_info *comp_unit_die, const char *dwo_name)
@@ -2885,8 +2889,6 @@ lookup_dwo_unit (dwarf2_cu *cu, die_info *comp_unit_die, const char *dwo_name)
 
   gdb_assert (cu != NULL);
 
-  /* Yeah, we look dwo_name up again, but it simplifies the code.  */
-  dwo_name = dwarf2_dwo_name (comp_unit_die, cu);
   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
 
   if (per_cu->is_debug_types)
@@ -2962,16 +2964,16 @@ cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu *this_cu,
    If EXISTING_CU is non-NULL, then use it.  Otherwise, a new CU is
    allocated.  */
 
-cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
-			  dwarf2_per_objfile *per_objfile,
+cutu_reader::cutu_reader (dwarf2_per_cu &this_cu,
+			  dwarf2_per_objfile &per_objfile,
 			  const struct abbrev_table *abbrev_table,
 			  dwarf2_cu *existing_cu,
 			  bool skip_partial,
 			  enum language pretend_language,
-			  const abbrev_table_cache *cache)
+			  const abbrev_table_cache *abbrev_cache)
 {
-  struct objfile *objfile = per_objfile->objfile;
-  struct dwarf2_section_info *section = this_cu->section;
+  struct objfile *objfile = per_objfile.objfile;
+  struct dwarf2_section_info *section = this_cu.section;
   bfd *abfd = section->get_bfd_owner ();
   const gdb_byte *begin_info_ptr;
   struct signatured_type *sig_type = NULL;
@@ -2983,17 +2985,17 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
 
   if (dwarf_die_debug)
     gdb_printf (gdb_stdlog, "Reading %s unit at offset %s\n",
-		this_cu->is_debug_types ? "type" : "comp",
-		sect_offset_str (this_cu->sect_off));
+		this_cu.is_debug_types ? "type" : "comp",
+		sect_offset_str (this_cu.sect_off));
 
   /* If we're reading a TU directly from a DWO file, including a virtual DWO
      file (instead of going through the stub), short-circuit all of this.  */
-  if (this_cu->reading_dwo_directly)
+  if (this_cu.reading_dwo_directly)
     {
       /* Narrow down the scope of possibilities to have to understand.  */
-      gdb_assert (this_cu->is_debug_types);
+      gdb_assert (this_cu.is_debug_types);
       gdb_assert (abbrev_table == NULL);
-      init_tu_and_read_dwo_dies (this_cu, per_objfile, existing_cu,
+      init_tu_and_read_dwo_dies (&this_cu, &per_objfile, existing_cu,
 				 pretend_language);
       return;
     }
@@ -3002,9 +3004,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
   section->read (objfile);
 
   begin_info_ptr = m_info_ptr
-    = section->buffer + to_underlying (this_cu->sect_off);
+    = section->buffer + to_underlying (this_cu.sect_off);
 
-  abbrev_section = get_abbrev_section_for_cu (this_cu);
+  abbrev_section = get_abbrev_section_for_cu (&this_cu);
 
   dwarf2_cu *cu;
 
@@ -3028,9 +3030,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
 	 indexer.  This assert is avoided in this case because (1) it
 	 is irrelevant, and (2) the get_cu method is not
 	 thread-safe.  */
-      gdb_assert (cache != nullptr
-		  || per_objfile->get_cu (this_cu) == nullptr);
-      m_new_cu = std::make_unique<dwarf2_cu> (this_cu, per_objfile);
+      gdb_assert (abbrev_cache != nullptr
+		  || per_objfile.get_cu (&this_cu) == nullptr);
+      m_new_cu = std::make_unique<dwarf2_cu> (&this_cu, &per_objfile);
       cu = m_new_cu.get ();
     }
 
@@ -3042,43 +3044,43 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
     }
   else
     {
-      if (this_cu->is_debug_types)
+      if (this_cu.is_debug_types)
 	{
 	  m_info_ptr
-	    = read_and_check_comp_unit_head (per_objfile, &cu->header, section,
+	    = read_and_check_comp_unit_head (&per_objfile, &cu->header, section,
 					     abbrev_section, m_info_ptr,
 					     rcuh_kind::TYPE);
 
 	  /* Since per_cu is the first member of struct signatured_type,
 	     we can go from a pointer to one to a pointer to the other.  */
-	  sig_type = (struct signatured_type *) this_cu;
+	  sig_type = (struct signatured_type *) &this_cu;
 	  gdb_assert (sig_type->signature == cu->header.signature);
 	  gdb_assert (sig_type->type_offset_in_tu
 		      == cu->header.type_cu_offset_in_tu);
-	  gdb_assert (this_cu->sect_off == cu->header.sect_off);
+	  gdb_assert (this_cu.sect_off == cu->header.sect_off);
 
 	  /* LENGTH has not been set yet for type units if we're
 	     using .gdb_index.  */
-	  this_cu->set_length (cu->header.get_length_with_initial ());
+	  this_cu.set_length (cu->header.get_length_with_initial ());
 
 	  /* Establish the type offset that can be used to lookup the type.  */
 	  sig_type->type_offset_in_section =
-	    this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
+	    this_cu.sect_off + to_underlying (sig_type->type_offset_in_tu);
 	}
       else
 	{
 	  m_info_ptr
-	    = read_and_check_comp_unit_head (per_objfile, &cu->header, section,
+	    = read_and_check_comp_unit_head (&per_objfile, &cu->header, section,
 					     abbrev_section, m_info_ptr,
 					     rcuh_kind::COMPILE);
 
-	  gdb_assert (this_cu->sect_off == cu->header.sect_off);
-	  this_cu->set_length (cu->header.get_length_with_initial ());
+	  gdb_assert (this_cu.sect_off == cu->header.sect_off);
+	  this_cu.set_length (cu->header.get_length_with_initial ());
 	}
     }
 
   /* Skip dummy compilation units.  */
-  if (m_info_ptr >= begin_info_ptr + this_cu->length ()
+  if (m_info_ptr >= begin_info_ptr + this_cu.length ()
       || peek_abbrev_code (abfd, m_info_ptr) == 0)
     m_dummy_p = true;
   else
@@ -3090,9 +3092,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
 	gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
       else
 	{
-	  if (cache != nullptr)
-	    abbrev_table = cache->find (abbrev_section,
-					cu->header.abbrev_sect_off);
+	  if (abbrev_cache != nullptr)
+	    abbrev_table = abbrev_cache->find (abbrev_section,
+					       cu->header.abbrev_sect_off);
 	  if (abbrev_table == nullptr)
 	    {
 	      abbrev_section->read (objfile);
@@ -3130,7 +3132,7 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
 		{
 		  complaint (_("compilation unit with DW_AT_GNU_dwo_name"
 			       " has children (offset %s) [in module %s]"),
-			     sect_offset_str (this_cu->sect_off),
+			     sect_offset_str (this_cu.sect_off),
 			     bfd_get_filename (abfd));
 		}
 
@@ -3165,65 +3167,57 @@ cutu_reader::release_cu ()
   return std::move (m_new_cu);
 }
 
-/* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
-   if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
-   assumed to have already done the lookup to find the DWO file).
+/* This constructor exists for the special case of reading many units in a row
+   from a given known DWO file.
 
-   The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
-   THIS_CU->is_debug_types, but nothing else.
+   THIS_CU is a special dwarf2_per_cu to represent where to read the unit from,
+   in the DWO file.  The caller is required to fill THIS_CU::SECTION,
+   THIS_CU::SECT_OFF, and THIS_CU::IS_DEBUG_TYPES.  This constructor will fill
+   in the length.  THIS_CU::SECTION must point to a section from the DWO file,
+   which is normally not the case for regular dwarf2_per_cu uses.
 
-   We fill in THIS_CU->length.
+   PARENT_CU is the CU created when reading the skeleton unit, and is used to
+   provide a default value for str_offsets_base and addr_base.  */
 
-   THIS_CU->cu is always freed when done.
-   This is done in order to not leave THIS_CU->cu in a state where we have
-   to care whether it refers to the "main" CU or the DWO CU.
-
-   When parent_cu is passed, it is used to provide a default value for
-   str_offsets_base and addr_base from the parent.  */
-
-cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
-			  dwarf2_per_objfile *per_objfile,
-			  enum language pretend_language,
-			  struct dwarf2_cu *parent_cu,
-			  struct dwo_file *dwo_file)
+cutu_reader::cutu_reader (dwarf2_per_cu &this_cu,
+			  dwarf2_per_objfile &per_objfile,
+			  language pretend_language, dwarf2_cu &parent_cu,
+			  dwo_file &dwo_file)
 {
-  struct objfile *objfile = per_objfile->objfile;
-  struct dwarf2_section_info *section = this_cu->section;
+  struct objfile *objfile = per_objfile.objfile;
+  struct dwarf2_section_info *section = this_cu.section;
   bfd *abfd = section->get_bfd_owner ();
 
-  gdb_assert (parent_cu != nullptr);
-  gdb_assert (dwo_file != nullptr);
-
   if (dwarf_die_debug)
     gdb_printf (gdb_stdlog, "Reading %s unit at offset %s\n",
-		this_cu->is_debug_types ? "type" : "comp",
-		sect_offset_str (this_cu->sect_off));
+		this_cu.is_debug_types ? "type" : "comp",
+		sect_offset_str (this_cu.sect_off));
 
-  gdb_assert (per_objfile->get_cu (this_cu) == nullptr);
+  gdb_assert (per_objfile.get_cu (&this_cu) == nullptr);
 
-  dwarf2_section_info *abbrev_section = &dwo_file->sections.abbrev;
+  dwarf2_section_info *abbrev_section = &dwo_file.sections.abbrev;
 
   /* This is cheap if the section is already read in.  */
   section->read (objfile);
 
-  m_new_cu = std::make_unique<dwarf2_cu> (this_cu, per_objfile);
+  m_new_cu = std::make_unique<dwarf2_cu> (&this_cu, &per_objfile);
 
-  m_info_ptr = section->buffer + to_underlying (this_cu->sect_off);
+  m_info_ptr = section->buffer + to_underlying (this_cu.sect_off);
   const gdb_byte *begin_info_ptr = m_info_ptr;
   m_info_ptr
-    = read_and_check_comp_unit_head (per_objfile, &m_new_cu->header, section,
+    = read_and_check_comp_unit_head (&per_objfile, &m_new_cu->header, section,
 				     abbrev_section, m_info_ptr,
-				     (this_cu->is_debug_types
+				     (this_cu.is_debug_types
 				      ? rcuh_kind::TYPE
 				      : rcuh_kind::COMPILE));
 
-  m_new_cu->str_offsets_base = parent_cu->str_offsets_base;
-  m_new_cu->addr_base = parent_cu->addr_base;
+  m_new_cu->str_offsets_base = parent_cu.str_offsets_base;
+  m_new_cu->addr_base = parent_cu.addr_base;
 
-  this_cu->set_length (m_new_cu->header.get_length_with_initial ());
+  this_cu.set_length (m_new_cu->header.get_length_with_initial ());
 
   /* Skip dummy compilation units.  */
-  if (m_info_ptr >= begin_info_ptr + this_cu->length ()
+  if (m_info_ptr >= begin_info_ptr + this_cu.length ()
       || peek_abbrev_code (abfd, m_info_ptr) == 0)
     m_dummy_p = true;
   else
@@ -3233,7 +3227,7 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu,
 	= abbrev_table::read (abbrev_section,
 			      m_new_cu->header.abbrev_sect_off);
 
-      this->init_cu_die_reader (m_new_cu.get (), section, dwo_file,
+      this->init_cu_die_reader (m_new_cu.get (), section, &dwo_file,
 				m_abbrev_table_holder.get ());
       m_top_level_die = this->read_toplevel_die ();
     }
@@ -3295,12 +3289,12 @@ get_type_unit_group_key (struct dwarf2_cu *cu, const struct attribute *stmt_list
 static void
 process_psymtab_comp_unit (dwarf2_per_cu *this_cu,
 			   dwarf2_per_objfile *per_objfile,
-			   cooked_index_storage *storage)
+			   cooked_index_worker_result *storage)
 {
   cutu_reader *reader = storage->get_reader (this_cu);
   if (reader == nullptr)
     {
-      cutu_reader new_reader (this_cu, per_objfile, nullptr, nullptr, false,
+      cutu_reader new_reader (*this_cu, *per_objfile, nullptr, nullptr, false,
 			      language_minimal,
 			      &storage->get_abbrev_table_cache ());
 
@@ -3332,7 +3326,7 @@ process_psymtab_comp_unit (dwarf2_per_cu *this_cu,
 
 static void
 build_type_psymtabs_reader (cutu_reader *reader,
-			    cooked_index_storage *storage)
+			    cooked_index_worker_result *storage)
 {
   struct dwarf2_cu *cu = reader->cu ();
   dwarf2_per_cu *per_cu = cu->per_cu;
@@ -3385,7 +3379,7 @@ struct tu_abbrev_offset
 
 static void
 build_type_psymtabs (dwarf2_per_objfile *per_objfile,
-		     cooked_index_storage *storage)
+		     cooked_index_worker_result *storage)
 {
   struct tu_stats *tu_stats = &per_objfile->per_bfd->tu_stats;
   abbrev_table_up abbrev_table;
@@ -3447,7 +3441,7 @@ build_type_psymtabs (dwarf2_per_objfile *per_objfile,
 	  ++tu_stats->nr_uniq_abbrev_tables;
 	}
 
-      cutu_reader reader (tu.sig_type, per_objfile,
+      cutu_reader reader (*tu.sig_type, *per_objfile,
 			  abbrev_table.get (), nullptr, false,
 			  language_minimal);
       if (!reader.is_dummy ())
@@ -3482,7 +3476,7 @@ print_tu_stats (dwarf2_per_objfile *per_objfile)
 static void
 process_skeletonless_type_unit (dwo_unit *dwo_unit,
 				dwarf2_per_objfile *per_objfile,
-				cooked_index_storage *storage)
+				cooked_index_worker_result *storage)
 {
   dwarf2_per_bfd *per_bfd = per_objfile->per_bfd;
 
@@ -3501,7 +3495,7 @@ process_skeletonless_type_unit (dwo_unit *dwo_unit,
   fill_in_sig_entry_from_dwo_entry (per_objfile, *sig_type_it, dwo_unit);
 
   /* This does the job that build_type_psymtabs would have done.  */
-  cutu_reader reader (*sig_type_it, per_objfile, nullptr, nullptr, false,
+  cutu_reader reader (**sig_type_it, *per_objfile, nullptr, nullptr, false,
 		      language_minimal);
   if (!reader.is_dummy ())
     build_type_psymtabs_reader (&reader, storage);
@@ -3513,7 +3507,7 @@ process_skeletonless_type_unit (dwo_unit *dwo_unit,
 
 static void
 process_skeletonless_type_units (dwarf2_per_objfile *per_objfile,
-				 cooked_index_storage *storage)
+				 cooked_index_worker_result *storage)
 {
   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
   if (get_dwp_file (per_objfile) == nullptr)
@@ -3559,7 +3553,7 @@ private:
 
   /* After the last DWARF-reading task has finished, this function
      does the remaining work to finish the scan.  */
-  void done_reading ();
+  void done_reading () override;
 
   /* An iterator for the comp units.  */
   using unit_iterator = std::vector<dwarf2_per_cu_up>::iterator;
@@ -3573,12 +3567,13 @@ private:
   /* A storage object for "leftovers" -- see the 'start' method, but
      essentially things not parsed during the normal CU parsing
      passes.  */
-  cooked_index_storage m_index_storage;
+  cooked_index_worker_result m_index_storage;
 };
 
 void
-cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator first,
-				      unit_iterator end)
+cooked_index_worker_debug_info::process_cus (size_t task_number,
+					     unit_iterator first,
+					     unit_iterator end)
 {
   SCOPE_EXIT { bfd_thread_cleanup (); };
 
@@ -3586,7 +3581,7 @@ cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator f
   complaint_interceptor complaint_handler;
 
   std::vector<gdb_exception> errors;
-  cooked_index_storage thread_storage;
+  cooked_index_worker_result thread_storage;
   for (auto inner = first; inner != end; ++inner)
     {
       dwarf2_per_cu *per_cu = inner->get ();
@@ -3597,43 +3592,24 @@ cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator f
 	}
       catch (gdb_exception &except)
 	{
-	  errors.push_back (std::move (except));
+	  thread_storage.note_error (std::move (except));
 	}
     }
 
-  m_results[task_number] = result_type (thread_storage.release (),
-					complaint_handler.release (),
-					std::move (errors),
-					thread_storage.release_parent_map ());
+  thread_storage.done_reading (complaint_handler.release ());
+  m_results[task_number] = std::move (thread_storage);
 }
 
 void
 cooked_index_worker_debug_info::done_reading ()
 {
-  /* Only handle the scanning results here.  Complaints and exceptions
-     can only be dealt with on the main thread.  */
-  std::vector<cooked_index_shard_up> shards;
-
-  for (auto &one_result : m_results)
-    {
-      shards.push_back (std::move (std::get<0> (one_result)));
-      m_all_parents_map.add_map (std::get<3> (one_result));
-    }
-
   /* This has to wait until we read the CUs, we need the list of DWOs.  */
   process_skeletonless_type_units (m_per_objfile, &m_index_storage);
 
-  shards.push_back (m_index_storage.release ());
-  shards.shrink_to_fit ();
+  m_results.push_back (std::move (m_index_storage));
 
-  m_all_parents_map.add_map (m_index_storage.release_parent_map ());
-
-  dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd;
-  cooked_index *table
-    = (gdb::checked_static_cast<cooked_index *>
-       (per_bfd->index_table.get ()));
-  table->set_contents (std::move (shards), &m_warnings,
-		       &m_all_parents_map);
+  /* Call into the base class.  */
+  cooked_index_worker::done_reading ();
 }
 
 void
@@ -4223,7 +4199,7 @@ load_full_comp_unit (dwarf2_per_cu *this_cu, dwarf2_per_objfile *per_objfile,
   gdb_assert (! this_cu->is_debug_types);
   gdb_assert (per_objfile->get_cu (this_cu) == nullptr);
 
-  cutu_reader reader (this_cu, per_objfile, nullptr, nullptr, skip_partial,
+  cutu_reader reader (*this_cu, *per_objfile, nullptr, nullptr, skip_partial,
 		      pretend_language);
   if (reader.is_dummy ())
     return;
@@ -6358,8 +6334,8 @@ create_cus_hash_table (dwarf2_cu *cu, dwo_file &dwo_file)
       /* The length of the CU gets set by the cutu_reader just below.  */
       dwarf2_per_cu per_cu (per_bfd, &section, sect_off, 0 /* length */,
 			    false /* is_dwz */);
-      cutu_reader reader (&per_cu, per_objfile, language_minimal,
-			  cu, &dwo_file);
+      cutu_reader reader (per_cu, *per_objfile, language_minimal,
+			  *cu, dwo_file);
 
       info_ptr += per_cu.length ();
 
@@ -15323,7 +15299,7 @@ dwarf2_read_addr_index (dwarf2_per_cu *per_cu, dwarf2_per_objfile *per_objfile,
     }
   else
     {
-      cutu_reader reader (per_cu, per_objfile, nullptr, nullptr, false,
+      cutu_reader reader (*per_cu, *per_objfile, nullptr, nullptr, false,
 			  language_minimal);
       addr_base = reader.cu ()->addr_base;
       addr_size = reader.cu ()->header.addr_size;
@@ -18823,7 +18799,7 @@ read_signatured_type (signatured_type *sig_type,
   gdb_assert (sig_type->is_debug_types);
   gdb_assert (per_objfile->get_cu (sig_type) == nullptr);
 
-  cutu_reader reader (sig_type, per_objfile, nullptr, nullptr, false,
+  cutu_reader reader (*sig_type, *per_objfile, nullptr, nullptr, false,
 		      language_minimal);
 
   if (!reader.is_dummy ())
@@ -19336,7 +19312,7 @@ dwarf2_per_cu::ensure_lang (dwarf2_per_objfile *per_objfile)
 
   /* Constructing this object will set the language as a side
      effect.  */
-  cutu_reader reader (this, per_objfile, nullptr, per_objfile->get_cu (this),
+  cutu_reader reader (*this, *per_objfile, nullptr, per_objfile->get_cu (this),
 		      true, language_minimal, nullptr);
 }