Make load_cu return the loaded dwarf2_cu

[thirdparty/binutils-gdb.git] / gdb / dwarf2 / read.c

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 0581b8e20855fad7103ddfd0637f085896eca819..a27c351e1cc5eda0ae510c2913fbcf0c21a5b9c3 100644 (file)
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -399,7 +399,8 @@ struct delayed_method_info
 /* Internal state when decoding a particular compilation unit.  */
 struct dwarf2_cu
 {
 /* Internal state when decoding a particular compilation unit.  */
 struct dwarf2_cu
 {

-  explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
+  explicit dwarf2_cu (dwarf2_per_cu_data *per_cu,
+                     dwarf2_per_objfile *per_objfile);

   ~dwarf2_cu ();
 
   DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
   ~dwarf2_cu ();
 
   DISABLE_COPY_AND_ASSIGN (dwarf2_cu);


@@ -420,6 +421,16 @@ struct dwarf2_cu
   /* Reset the builder.  */
   void reset_builder () { m_builder.reset (); }
 
   /* Reset the builder.  */
   void reset_builder () { m_builder.reset (); }
 

+  /* Return a type that is a generic pointer type, the size of which
+     matches the address size given in the compilation unit header for
+     this CU.  */
+  struct type *addr_type () const;
+
+  /* Find an integer type the same size as the address size given in
+     the compilation unit header for this CU.  UNSIGNED_P controls if
+     the integer is unsigned or not.  */
+  struct type *addr_sized_int_type (bool unsigned_p) const;
+

   /* The header of the compilation unit.  */
   struct comp_unit_head header {};
 
   /* The header of the compilation unit.  */
   struct comp_unit_head header {};
 


@@ -466,6 +477,9 @@ public:
   /* Backlink to our per_cu entry.  */
   struct dwarf2_per_cu_data *per_cu;
 
   /* Backlink to our per_cu entry.  */
   struct dwarf2_per_cu_data *per_cu;
 

+  /* The dwarf2_per_objfile that owns this.  */
+  struct dwarf2_per_objfile *per_objfile;
+

   /* How many compilation units ago was this CU last referenced?  */
   int last_used = 0;
 
   /* How many compilation units ago was this CU last referenced?  */
   int last_used = 0;
 


@@ -484,7 +498,7 @@ public:
   /* Header data from the line table, during full symbol processing.  */
   struct line_header *line_header = nullptr;
   /* Non-NULL if LINE_HEADER is owned by this DWARF_CU.  Otherwise,
   /* Header data from the line table, during full symbol processing.  */
   struct line_header *line_header = nullptr;
   /* Non-NULL if LINE_HEADER is owned by this DWARF_CU.  Otherwise,

-     it's owned by dwarf2_per_objfile::line_header_hash.  If non-NULL,
+     it's owned by dwarf2_per_bfd::line_header_hash.  If non-NULL,

      this is the DW_TAG_compile_unit die for this CU.  We'll hold on
      to the line header as long as this DIE is being processed.  See
      process_die_scope.  */
      this is the DW_TAG_compile_unit die for this CU.  We'll hold on
      to the line header as long as this DIE is being processed.  See
      process_die_scope.  */


@@ -599,8 +613,10 @@ struct stmt_list_hash
   sect_offset line_sect_off;
 };
 
   sect_offset line_sect_off;
 };
 

-/* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
-   an object of this type.  */
+/* Each element of dwarf2_per_bfd->type_unit_groups is a pointer to
+   an object of this type.  This contains elements of type unit groups
+   that can be shared across objfiles.  The non-shareable parts are in
+   type_unit_group_unshareable.  */

 
 struct type_unit_group
 {
 
 struct type_unit_group
 {


@@ -615,23 +631,8 @@ struct type_unit_group
      and is deleted afterwards and not used again.  */
   std::vector<signatured_type *> *tus;
 
      and is deleted afterwards and not used again.  */
   std::vector<signatured_type *> *tus;
 

-  /* The compunit symtab.
-     Type units in a group needn't all be defined in the same source file,
-     so we create an essentially anonymous symtab as the compunit symtab.  */
-  struct compunit_symtab *compunit_symtab;
-

   /* The data used to construct the hash key.  */
   struct stmt_list_hash hash;
   /* The data used to construct the hash key.  */
   struct stmt_list_hash hash;

-
-  /* The symbol tables for this TU (obtained from the files listed in
-     DW_AT_stmt_list).
-     WARNING: The order of entries here must match the order of entries
-     in the line header.  After the first TU using this type_unit_group, the
-     line header for the subsequent TUs is recreated from this.  This is done
-     because we need to use the same symtabs for each TU using the same
-     DW_AT_stmt_list value.  Also note that symtabs may be repeated here,
-     there's no guarantee the line header doesn't have duplicate entries.  */
-  struct symtab **symtabs;

 };
 
 /* These sections are what may appear in a (real or virtual) DWO file.  */
 };
 
 /* These sections are what may appear in a (real or virtual) DWO file.  */


@@ -908,12 +909,14 @@ class cutu_reader : public die_reader_specs
 {
 public:
 
 {
 public:
 

-  cutu_reader (struct dwarf2_per_cu_data *this_cu,
+  cutu_reader (dwarf2_per_cu_data *this_cu,
+              dwarf2_per_objfile *per_objfile,

               struct abbrev_table *abbrev_table,
               int use_existing_cu,
               bool skip_partial);
 
   explicit cutu_reader (struct dwarf2_per_cu_data *this_cu,
               struct abbrev_table *abbrev_table,
               int use_existing_cu,
               bool skip_partial);
 
   explicit cutu_reader (struct dwarf2_per_cu_data *this_cu,

+                       dwarf2_per_objfile *per_objfile,

                        struct dwarf2_cu *parent_cu = nullptr,
                        struct dwo_file *dwo_file = nullptr);
 
                        struct dwarf2_cu *parent_cu = nullptr,
                        struct dwo_file *dwo_file = nullptr);
 


@@ -928,7 +931,8 @@ public:
   void keep ();
 
 private:
   void keep ();
 
 private:

-  void init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
+  void init_tu_and_read_dwo_dies (dwarf2_per_cu_data *this_cu,
+                                 dwarf2_per_objfile *per_objfile,

                                  int use_existing_cu);
 
   struct dwarf2_per_cu_data *m_this_cu;
                                  int use_existing_cu);
 
   struct dwarf2_per_cu_data *m_this_cu;


@@ -1197,7 +1201,8 @@ static void dwarf2_find_base_address (struct die_info *die,
                                      struct dwarf2_cu *cu);
 
 static dwarf2_psymtab *create_partial_symtab
                                      struct dwarf2_cu *cu);
 
 static dwarf2_psymtab *create_partial_symtab

-  (struct dwarf2_per_cu_data *per_cu, const char *name);
+  (dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile,
+   const char *name);

 
 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
                                        const gdb_byte *info_ptr,
 
 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
                                        const gdb_byte *info_ptr,


@@ -1505,9 +1510,11 @@ static struct type *get_DW_AT_signature_type (struct die_info *,
                                              const struct attribute *,
                                              struct dwarf2_cu *);
 
                                              const struct attribute *,
                                              struct dwarf2_cu *);
 

-static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
+static void load_full_type_unit (dwarf2_per_cu_data *per_cu,
+                                dwarf2_per_objfile *per_objfile);

 
 

-static void read_signatured_type (struct signatured_type *);
+static void read_signatured_type (signatured_type *sig_type,
+                                 dwarf2_per_objfile *per_objfile);

 
 static int attr_to_dynamic_prop (const struct attribute *attr,
                                 struct die_info *die, struct dwarf2_cu *cu,
 
 static int attr_to_dynamic_prop (const struct attribute *attr,
                                 struct die_info *die, struct dwarf2_cu *cu,


@@ -1548,7 +1555,8 @@ static void prepare_one_comp_unit (struct dwarf2_cu *cu,
 
 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
 
 
 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
 

-static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
+static void free_one_cached_comp_unit (dwarf2_per_cu_data *target_per_cu,
+                                      dwarf2_per_objfile *per_objfile);

 
 static struct type *set_die_type (struct die_info *, struct type *,
                                  struct dwarf2_cu *);
 
 static struct type *set_die_type (struct die_info *, struct type *,
                                  struct dwarf2_cu *);


@@ -1557,14 +1565,16 @@ static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile
 
 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
 
 
 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
 

-static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
-                                enum language);
+static void load_full_comp_unit (dwarf2_per_cu_data *per_cu,
+                                dwarf2_per_objfile *per_objfile,
+                                bool skip_partial,
+                                enum language pretend_language);

 
 

-static void process_full_comp_unit (struct dwarf2_per_cu_data *,
-                                   enum language);
+static void process_full_comp_unit (dwarf2_cu *cu,
+                                   enum language pretend_language);

 
 

-static void process_full_type_unit (struct dwarf2_per_cu_data *,
-                                   enum language);
+static void process_full_type_unit (dwarf2_cu *cu,
+                                   enum language pretend_language);

 
 static void dwarf2_add_dependence (struct dwarf2_cu *,
                                   struct dwarf2_per_cu_data *);
 
 static void dwarf2_add_dependence (struct dwarf2_cu *,
                                   struct dwarf2_per_cu_data *);


@@ -1574,11 +1584,13 @@ static void dwarf2_mark (struct dwarf2_cu *);
 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
 
 static struct type *get_die_type_at_offset (sect_offset,
 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
 
 static struct type *get_die_type_at_offset (sect_offset,

-                                           struct dwarf2_per_cu_data *);
+                                           dwarf2_per_cu_data *per_cu,
+                                           dwarf2_per_objfile *per_objfile);

 
 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
 
 
 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
 

-static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
+static void queue_comp_unit (dwarf2_per_cu_data *per_cu,
+                            dwarf2_per_objfile *per_objfile,

                             enum language pretend_language);
 
 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
                             enum language pretend_language);
 
 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);


@@ -1602,7 +1614,7 @@ public:
   {
     /* Ensure that no memory is allocated by the queue.  */
     std::queue<dwarf2_queue_item> empty;
   {
     /* Ensure that no memory is allocated by the queue.  */
     std::queue<dwarf2_queue_item> empty;

-    std::swap (m_per_objfile->queue, empty);
+    std::swap (m_per_objfile->per_bfd->queue, empty);

   }
 
   DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard);
   }
 
   DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard);


@@ -1618,7 +1630,7 @@ dwarf2_queue_item::~dwarf2_queue_item ()
   if (per_cu->queued)
     {
       if (per_cu->cu != NULL)
   if (per_cu->queued)
     {
       if (per_cu->cu != NULL)

-       free_one_cached_comp_unit (per_cu);
+       free_one_cached_comp_unit (per_cu, per_objfile);

       per_cu->queued = 0;
     }
 }
       per_cu->queued = 0;
     }
 }


@@ -1658,12 +1670,13 @@ static struct dwp_file *get_dwp_file
   (struct dwarf2_per_objfile *dwarf2_per_objfile);
 
 static struct dwo_unit *lookup_dwo_comp_unit
   (struct dwarf2_per_objfile *dwarf2_per_objfile);
 
 static struct dwo_unit *lookup_dwo_comp_unit

-  (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
+  (dwarf2_cu *cu, const char *dwo_name, const char *comp_dir,
+   ULONGEST signature);

 
 static struct dwo_unit *lookup_dwo_type_unit
 
 static struct dwo_unit *lookup_dwo_type_unit

-  (struct signatured_type *, const char *, const char *);
+  (dwarf2_cu *cu, const char *dwo_name, const char *comp_dir);

 
 

-static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
+static void queue_and_load_all_dwo_tus (dwarf2_cu *cu);

 
 /* A unique pointer to a dwo_file.  */
 
 
 /* A unique pointer to a dwo_file.  */
 


@@ -1745,22 +1758,19 @@ line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
 
 /* See declaration.  */
 
 
 /* See declaration.  */
 

-dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
-                                       const dwarf2_debug_sections *names,
-                                       bool can_copy_)
-  : objfile (objfile_),
+dwarf2_per_bfd::dwarf2_per_bfd (bfd *obfd, const dwarf2_debug_sections *names,
+                               bool can_copy_)
+  : obfd (obfd),

     can_copy (can_copy_)
 {
   if (names == NULL)
     names = &dwarf2_elf_names;
 
     can_copy (can_copy_)
 {
   if (names == NULL)
     names = &dwarf2_elf_names;
 

-  bfd *obfd = objfile->obfd;
-

   for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
     locate_sections (obfd, sec, *names);
 }
 
   for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
     locate_sections (obfd, sec, *names);
 }
 

-dwarf2_per_objfile::~dwarf2_per_objfile ()
+dwarf2_per_bfd::~dwarf2_per_bfd ()

 {
   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
   free_cached_comp_units ();
 {
   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
   free_cached_comp_units ();


@@ -1771,13 +1781,13 @@ dwarf2_per_objfile::~dwarf2_per_objfile ()
   for (signatured_type *sig_type : all_type_units)
     sig_type->per_cu.imported_symtabs_free ();
 
   for (signatured_type *sig_type : all_type_units)
     sig_type->per_cu.imported_symtabs_free ();
 

-  /* Everything else should be on the objfile obstack.  */
+  /* Everything else should be on this->obstack.  */

 }
 
 /* See declaration.  */
 
 void
 }
 
 /* See declaration.  */
 
 void

-dwarf2_per_objfile::free_cached_comp_units ()
+dwarf2_per_bfd::free_cached_comp_units ()

 {
   dwarf2_per_cu_data *per_cu = read_in_chain;
   dwarf2_per_cu_data **last_chain = &read_in_chain;
 {
   dwarf2_per_cu_data *per_cu = read_in_chain;
   dwarf2_per_cu_data **last_chain = &read_in_chain;


@@ -1805,7 +1815,7 @@ public:
 
   ~free_cached_comp_units ()
   {
 
   ~free_cached_comp_units ()
   {

-    m_per_objfile->free_cached_comp_units ();
+    m_per_objfile->per_bfd->free_cached_comp_units ();

   }
 
   DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
   }
 
   DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);


@@ -1815,6 +1825,38 @@ private:
   dwarf2_per_objfile *m_per_objfile;
 };
 
   dwarf2_per_objfile *m_per_objfile;
 };
 

+/* See read.h.  */
+
+bool
+dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data *per_cu) const
+{
+  gdb_assert (per_cu->index < this->m_symtabs.size ());
+
+  return this->m_symtabs[per_cu->index] != nullptr;
+}
+
+/* See read.h.  */
+
+compunit_symtab *
+dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data *per_cu) const
+{
+  gdb_assert (per_cu->index < this->m_symtabs.size ());
+
+  return this->m_symtabs[per_cu->index];
+}
+
+/* See read.h.  */
+
+void
+dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data *per_cu,
+                               compunit_symtab *symtab)
+{
+  gdb_assert (per_cu->index < this->m_symtabs.size ());
+  gdb_assert (this->m_symtabs[per_cu->index] == nullptr);
+
+  this->m_symtabs[per_cu->index] = symtab;
+}
+

 /* Try to locate the sections we need for DWARF 2 debugging
    information and return true if we have enough to do something.
    NAMES points to the dwarf2 section names, or is NULL if the standard
 /* Try to locate the sections we need for DWARF 2 debugging
    information and return true if we have enough to do something.
    NAMES points to the dwarf2 section names, or is NULL if the standard


@@ -1834,14 +1876,18 @@ dwarf2_has_info (struct objfile *objfile,
     = get_dwarf2_per_objfile (objfile);
 
   if (dwarf2_per_objfile == NULL)
     = get_dwarf2_per_objfile (objfile);
 
   if (dwarf2_per_objfile == NULL)

-    dwarf2_per_objfile = dwarf2_objfile_data_key.emplace (objfile, objfile,
-                                                         names,
-                                                         can_copy);
+    {
+      /* For now, each dwarf2_per_objfile owns its own dwarf2_per_bfd (no
+         sharing yet).  */
+      dwarf2_per_bfd *per_bfd = new dwarf2_per_bfd (objfile->obfd, names, can_copy);
+
+      dwarf2_per_objfile = dwarf2_objfile_data_key.emplace (objfile, objfile, per_bfd);
+    }

 
 

-  return (!dwarf2_per_objfile->info.is_virtual
-         && dwarf2_per_objfile->info.s.section != NULL
-         && !dwarf2_per_objfile->abbrev.is_virtual
-         && dwarf2_per_objfile->abbrev.s.section != NULL);
+  return (!dwarf2_per_objfile->per_bfd->info.is_virtual
+         && dwarf2_per_objfile->per_bfd->info.s.section != NULL
+         && !dwarf2_per_objfile->per_bfd->abbrev.is_virtual
+         && dwarf2_per_objfile->per_bfd->abbrev.s.section != NULL);

 }
 
 /* When loading sections, we look either for uncompressed section or for
 }
 
 /* When loading sections, we look either for uncompressed section or for


@@ -1863,8 +1909,8 @@ section_is_p (const char *section_name,
 /* See declaration.  */
 
 void
 /* See declaration.  */
 
 void

-dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
-                                    const dwarf2_debug_sections &names)
+dwarf2_per_bfd::locate_sections (bfd *abfd, asection *sectp,
+                                const dwarf2_debug_sections &names)

 {
   flagword aflag = bfd_section_flags (sectp);
 
 {
   flagword aflag = bfd_section_flags (sectp);
 


@@ -2010,10 +2056,10 @@ dwarf2_get_section_info (struct objfile *objfile,
   switch (sect)
     {
     case DWARF2_DEBUG_FRAME:
   switch (sect)
     {
     case DWARF2_DEBUG_FRAME:

-      info = &data->frame;
+      info = &data->per_bfd->frame;

       break;
     case DWARF2_EH_FRAME:
       break;
     case DWARF2_EH_FRAME:

-      info = &data->eh_frame;
+      info = &data->per_bfd->eh_frame;

       break;
     default:
       gdb_assert_not_reached ("unexpected section");
       break;
     default:
       gdb_assert_not_reached ("unexpected section");


@@ -2075,19 +2121,19 @@ locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
 /* See dwarf2read.h.  */
 
 struct dwz_file *
 /* See dwarf2read.h.  */
 
 struct dwz_file *

-dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
+dwarf2_get_dwz_file (dwarf2_per_bfd *per_bfd)

 {
   const char *filename;
   bfd_size_type buildid_len_arg;
   size_t buildid_len;
   bfd_byte *buildid;
 
 {
   const char *filename;
   bfd_size_type buildid_len_arg;
   size_t buildid_len;
   bfd_byte *buildid;
 

-  if (dwarf2_per_objfile->dwz_file != NULL)
-    return dwarf2_per_objfile->dwz_file.get ();
+  if (per_bfd->dwz_file != NULL)
+    return per_bfd->dwz_file.get ();

 
   bfd_set_error (bfd_error_no_error);
   gdb::unique_xmalloc_ptr<char> data
 
   bfd_set_error (bfd_error_no_error);
   gdb::unique_xmalloc_ptr<char> data

-    (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
+    (bfd_get_alt_debug_link_info (per_bfd->obfd,

                                  &buildid_len_arg, &buildid));
   if (data == NULL)
     {
                                  &buildid_len_arg, &buildid));
   if (data == NULL)
     {


@@ -2107,7 +2153,7 @@ dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
   if (!IS_ABSOLUTE_PATH (filename))
     {
       gdb::unique_xmalloc_ptr<char> abs
   if (!IS_ABSOLUTE_PATH (filename))
     {
       gdb::unique_xmalloc_ptr<char> abs

-       = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
+       = gdb_realpath (bfd_get_filename (per_bfd->obfd));

 
       abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
       filename = abs_storage.c_str ();
 
       abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
       filename = abs_storage.c_str ();


@@ -2128,7 +2174,7 @@ dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
   if (dwz_bfd == nullptr)
     {
       gdb::unique_xmalloc_ptr<char> alt_filename;
   if (dwz_bfd == nullptr)
     {
       gdb::unique_xmalloc_ptr<char> alt_filename;

-      const char *origname = dwarf2_per_objfile->objfile->original_name;
+      const char *origname = bfd_get_filename (per_bfd->obfd);

 
       scoped_fd fd (debuginfod_debuginfo_query (buildid,
                                                buildid_len,
 
       scoped_fd fd (debuginfod_debuginfo_query (buildid,
                                                buildid_len,


@@ -2150,7 +2196,7 @@ dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
 
   if (dwz_bfd == NULL)
     error (_("could not find '.gnu_debugaltlink' file for %s"),
 
   if (dwz_bfd == NULL)
     error (_("could not find '.gnu_debugaltlink' file for %s"),

-          objfile_name (dwarf2_per_objfile->objfile));
+          bfd_get_filename (per_bfd->obfd));

 
   std::unique_ptr<struct dwz_file> result
     (new struct dwz_file (std::move (dwz_bfd)));
 
   std::unique_ptr<struct dwz_file> result
     (new struct dwz_file (std::move (dwz_bfd)));


@@ -2158,10 +2204,9 @@ dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
   bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
                         result.get ());
 
   bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
                         result.get ());
 

-  gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
-                           result->dwz_bfd.get ());
-  dwarf2_per_objfile->dwz_file = std::move (result);
-  return dwarf2_per_objfile->dwz_file.get ();
+  gdb_bfd_record_inclusion (per_bfd->obfd, result->dwz_bfd.get ());
+  per_bfd->dwz_file = std::move (result);
+  return per_bfd->dwz_file.get ();

 }
 \f
 /* DWARF quick_symbols_functions support.  */
 }
 \f
 /* DWARF quick_symbols_functions support.  */


@@ -2195,13 +2240,9 @@ struct dwarf2_per_cu_quick_data
 {
   /* The file table.  This can be NULL if there was no file table
      or it's currently not read in.
 {
   /* The file table.  This can be NULL if there was no file table
      or it's currently not read in.

-     NOTE: This points into dwarf2_per_objfile->quick_file_names_table.  */
+     NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table.  */

   struct quick_file_names *file_names;
 
   struct quick_file_names *file_names;
 

-  /* The corresponding symbol table.  This is NULL if symbols for this
-     CU have not yet been read.  */
-  struct compunit_symtab *compunit_symtab;
-

   /* A temporary mark bit used when iterating over all CUs in
      expand_symtabs_matching.  */
   unsigned int mark : 1;
   /* A temporary mark bit used when iterating over all CUs in
      expand_symtabs_matching.  */
   unsigned int mark : 1;


@@ -2276,8 +2317,8 @@ delete_file_name_entry (void *e)
        xfree ((void*) file_data->real_names[i]);
     }
 
        xfree ((void*) file_data->real_names[i]);
     }
 

-  /* The space for the struct itself lives on objfile_obstack,
-     so we don't free it here.  */
+  /* The space for the struct itself lives on the obstack, so we don't
+     free it here.  */

 }
 
 /* Create a quick_file_names hash table.  */
 }
 
 /* Create a quick_file_names hash table.  */


@@ -2290,31 +2331,34 @@ create_quick_file_names_table (unsigned int nr_initial_entries)
                                     delete_file_name_entry, xcalloc, xfree));
 }
 
                                     delete_file_name_entry, xcalloc, xfree));
 }
 

-/* Read in PER_CU->CU.  This function is unrelated to symtabs, symtab would
-   have to be created afterwards.  You should call age_cached_comp_units after
-   processing PER_CU->CU.  dw2_setup must have been already called.  */
+/* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE.  This
+   function is unrelated to symtabs, symtab would have to be created afterwards.
+   You should call age_cached_comp_units after processing the CU.  */

 
 

-static void
-load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
+static dwarf2_cu *
+load_cu (dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile,
+        bool skip_partial)

 {
   if (per_cu->is_debug_types)
 {
   if (per_cu->is_debug_types)

-    load_full_type_unit (per_cu);
+    load_full_type_unit (per_cu, per_objfile);

   else
   else

-    load_full_comp_unit (per_cu, skip_partial, language_minimal);
+    load_full_comp_unit (per_cu, per_objfile, skip_partial, language_minimal);

 
 

-  if (per_cu->cu == NULL)
-    return;  /* Dummy CU.  */
+  if (per_cu->cu == nullptr)
+    return nullptr;  /* Dummy CU.  */

 
   dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
 
   dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);

+
+  return per_cu->cu;

 }
 
 }
 

-/* Read in the symbols for PER_CU.  */
+/* Read in the symbols for PER_CU in the context of DWARF"_PER_OBJFILE.  */

 
 static void
 
 static void

-dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
+dw2_do_instantiate_symtab (dwarf2_per_cu_data *per_cu,
+                          dwarf2_per_objfile *dwarf2_per_objfile,
+                          bool skip_partial)

 {
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
-

   /* Skip type_unit_groups, reading the type units they contain
      is handled elsewhere.  */
   if (per_cu->type_unit_group_p ())
   /* Skip type_unit_groups, reading the type units they contain
      is handled elsewhere.  */
   if (per_cu->type_unit_group_p ())


@@ -2325,24 +2369,22 @@ dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
      with the dwarf queue empty.  */
   dwarf2_queue_guard q_guard (dwarf2_per_objfile);
 
      with the dwarf queue empty.  */
   dwarf2_queue_guard q_guard (dwarf2_per_objfile);
 

-  if (dwarf2_per_objfile->using_index
-      ? per_cu->v.quick->compunit_symtab == NULL
-      : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
+  if (!dwarf2_per_objfile->symtab_set_p (per_cu))

     {
     {

-      queue_comp_unit (per_cu, language_minimal);
-      load_cu (per_cu, skip_partial);
+      queue_comp_unit (per_cu, dwarf2_per_objfile, language_minimal);
+      dwarf2_cu *cu = load_cu (per_cu, dwarf2_per_objfile, skip_partial);

 
       /* If we just loaded a CU from a DWO, and we're working with an index
         that may badly handle TUs, load all the TUs in that DWO as well.
         http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
       if (!per_cu->is_debug_types
 
       /* If we just loaded a CU from a DWO, and we're working with an index
         that may badly handle TUs, load all the TUs in that DWO as well.
         http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
       if (!per_cu->is_debug_types

-         && per_cu->cu != NULL
-         && per_cu->cu->dwo_unit != NULL
-         && dwarf2_per_objfile->index_table != NULL
-         && dwarf2_per_objfile->index_table->version <= 7
+         && cu != NULL
+         && cu->dwo_unit != NULL
+         && dwarf2_per_objfile->per_bfd->index_table != NULL
+         && dwarf2_per_objfile->per_bfd->index_table->version <= 7

          /* DWP files aren't supported yet.  */
          && get_dwp_file (dwarf2_per_objfile) == NULL)
          /* DWP files aren't supported yet.  */
          && get_dwp_file (dwarf2_per_objfile) == NULL)

-       queue_and_load_all_dwo_tus (per_cu);
+       queue_and_load_all_dwo_tus (cu);

     }
 
   process_queue (dwarf2_per_objfile);
     }
 
   process_queue (dwarf2_per_objfile);


@@ -2352,31 +2394,33 @@ dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
   age_cached_comp_units (dwarf2_per_objfile);
 }
 
   age_cached_comp_units (dwarf2_per_objfile);
 }
 

-/* Ensure that the symbols for PER_CU have been read in.  OBJFILE is
-   the objfile from which this CU came.  Returns the resulting symbol
-   table.  */
+/* Ensure that the symbols for PER_CU have been read in.  DWARF2_PER_OBJFILE is
+   the per-objfile for which this symtab is instantiated.
+
+   Returns the resulting symbol table.  */

 
 static struct compunit_symtab *
 
 static struct compunit_symtab *

-dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
+dw2_instantiate_symtab (dwarf2_per_cu_data *per_cu,
+                       dwarf2_per_objfile *dwarf2_per_objfile,
+                       bool skip_partial)

 {
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
+  gdb_assert (dwarf2_per_objfile->per_bfd->using_index);

 
 

-  gdb_assert (dwarf2_per_objfile->using_index);
-  if (!per_cu->v.quick->compunit_symtab)
+  if (!dwarf2_per_objfile->symtab_set_p (per_cu))

     {
       free_cached_comp_units freer (dwarf2_per_objfile);
       scoped_restore decrementer = increment_reading_symtab ();
     {
       free_cached_comp_units freer (dwarf2_per_objfile);
       scoped_restore decrementer = increment_reading_symtab ();

-      dw2_do_instantiate_symtab (per_cu, skip_partial);
+      dw2_do_instantiate_symtab (per_cu, dwarf2_per_objfile, skip_partial);

       process_cu_includes (dwarf2_per_objfile);
     }
 
       process_cu_includes (dwarf2_per_objfile);
     }
 

-  return per_cu->v.quick->compunit_symtab;
+  return dwarf2_per_objfile->get_symtab (per_cu);

 }
 
 /* See declaration.  */
 
 dwarf2_per_cu_data *
 }
 
 /* See declaration.  */
 
 dwarf2_per_cu_data *

-dwarf2_per_objfile::get_cutu (int index)
+dwarf2_per_bfd::get_cutu (int index)

 {
   if (index >= this->all_comp_units.size ())
     {
 {
   if (index >= this->all_comp_units.size ())
     {


@@ -2391,7 +2435,7 @@ dwarf2_per_objfile::get_cutu (int index)
 /* See declaration.  */
 
 dwarf2_per_cu_data *
 /* See declaration.  */
 
 dwarf2_per_cu_data *

-dwarf2_per_objfile::get_cu (int index)
+dwarf2_per_bfd::get_cu (int index)

 {
   gdb_assert (index >= 0 && index < this->all_comp_units.size ());
 
 {
   gdb_assert (index >= 0 && index < this->all_comp_units.size ());
 


@@ -2401,33 +2445,50 @@ dwarf2_per_objfile::get_cu (int index)
 /* See declaration.  */
 
 signatured_type *
 /* See declaration.  */
 
 signatured_type *

-dwarf2_per_objfile::get_tu (int index)
+dwarf2_per_bfd::get_tu (int index)

 {
   gdb_assert (index >= 0 && index < this->all_type_units.size ());
 
   return this->all_type_units[index];
 }
 
 {
   gdb_assert (index >= 0 && index < this->all_type_units.size ());
 
   return this->all_type_units[index];
 }
 

-/* Return a new dwarf2_per_cu_data allocated on OBJFILE's
-   objfile_obstack, and constructed with the specified field
-   values.  */
+/* See read.h.  */
+
+dwarf2_per_cu_data *
+dwarf2_per_bfd::allocate_per_cu ()
+{
+  dwarf2_per_cu_data *result = OBSTACK_ZALLOC (&obstack, dwarf2_per_cu_data);
+  result->per_bfd = this;
+  result->index = m_num_psymtabs++;
+  return result;
+}
+
+/* See read.h.  */
+
+signatured_type *
+dwarf2_per_bfd::allocate_signatured_type ()
+{
+  signatured_type *result = OBSTACK_ZALLOC (&obstack, signatured_type);
+  result->per_cu.per_bfd = this;
+  result->per_cu.index = m_num_psymtabs++;
+  return result;
+}
+
+/* Return a new dwarf2_per_cu_data allocated on the per-bfd
+   obstack, and constructed with the specified field values.  */

 
 static dwarf2_per_cu_data *
 
 static dwarf2_per_cu_data *

-create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
-                          struct dwarf2_section_info *section,
-                          int is_dwz,
-                          sect_offset sect_off, ULONGEST length)
+create_cu_from_index_list (dwarf2_per_bfd *per_bfd,
+                          struct dwarf2_section_info *section,
+                          int is_dwz,
+                          sect_offset sect_off, ULONGEST length)

 {
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;
-  dwarf2_per_cu_data *the_cu
-    = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                     struct dwarf2_per_cu_data);
+  dwarf2_per_cu_data *the_cu = per_bfd->allocate_per_cu ();

   the_cu->sect_off = sect_off;
   the_cu->length = length;
   the_cu->sect_off = sect_off;
   the_cu->length = length;

-  the_cu->dwarf2_per_objfile = dwarf2_per_objfile;

   the_cu->section = section;
   the_cu->section = section;

-  the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                                   struct dwarf2_per_cu_quick_data);
+  the_cu->v.quick = OBSTACK_ZALLOC (&per_bfd->obstack,
+                                   struct dwarf2_per_cu_quick_data);

   the_cu->is_dwz = is_dwz;
   return the_cu;
 }
   the_cu->is_dwz = is_dwz;
   return the_cu;
 }


@@ -2436,7 +2497,7 @@ create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
    CUs.  */
 
 static void
    CUs.  */
 
 static void

-create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
+create_cus_from_index_list (dwarf2_per_bfd *per_bfd,

                            const gdb_byte *cu_list, offset_type n_elements,
                            struct dwarf2_section_info *section,
                            int is_dwz)
                            const gdb_byte *cu_list, offset_type n_elements,
                            struct dwarf2_section_info *section,
                            int is_dwz)


@@ -2451,32 +2512,31 @@ create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
       cu_list += 2 * 8;
 
       dwarf2_per_cu_data *per_cu
       cu_list += 2 * 8;
 
       dwarf2_per_cu_data *per_cu

-       = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
-                                    sect_off, length);
-      dwarf2_per_objfile->all_comp_units.push_back (per_cu);
+       = create_cu_from_index_list (per_bfd, section, is_dwz, sect_off,
+                                    length);
+      per_bfd->all_comp_units.push_back (per_cu);

     }
 }
 
 /* Read the CU list from the mapped index, and use it to create all
     }
 }
 
 /* Read the CU list from the mapped index, and use it to create all

-   the CU objects for this objfile.  */
+   the CU objects for PER_BFD.  */

 
 static void
 
 static void

-create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
+create_cus_from_index (dwarf2_per_bfd *per_bfd,

                       const gdb_byte *cu_list, offset_type cu_list_elements,
                       const gdb_byte *dwz_list, offset_type dwz_elements)
 {
                       const gdb_byte *cu_list, offset_type cu_list_elements,
                       const gdb_byte *dwz_list, offset_type dwz_elements)
 {

-  gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
-  dwarf2_per_objfile->all_comp_units.reserve
-    ((cu_list_elements + dwz_elements) / 2);
+  gdb_assert (per_bfd->all_comp_units.empty ());
+  per_bfd->all_comp_units.reserve ((cu_list_elements + dwz_elements) / 2);

 
 

-  create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
-                             &dwarf2_per_objfile->info, 0);
+  create_cus_from_index_list (per_bfd, cu_list, cu_list_elements,
+                             &per_bfd->info, 0);

 
   if (dwz_elements == 0)
     return;
 
 
   if (dwz_elements == 0)
     return;
 

-  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
-  create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
+  dwz_file *dwz = dwarf2_get_dwz_file (per_bfd);
+  create_cus_from_index_list (per_bfd, dwz_list, dwz_elements,

                              &dwz->info, 1);
 }
 
                              &dwz->info, 1);
 }
 


@@ -2484,15 +2544,11 @@ create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
 
 static void
 create_signatured_type_table_from_index
 
 static void
 create_signatured_type_table_from_index

-  (struct dwarf2_per_objfile *dwarf2_per_objfile,
-   struct dwarf2_section_info *section,
-   const gdb_byte *bytes,
-   offset_type elements)
+  (dwarf2_per_bfd *per_bfd, struct dwarf2_section_info *section,
+   const gdb_byte *bytes, offset_type elements)

 {
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;
-
-  gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
-  dwarf2_per_objfile->all_type_units.reserve (elements / 3);
+  gdb_assert (per_bfd->all_type_units.empty ());
+  per_bfd->all_type_units.reserve (elements / 3);

 
   htab_up sig_types_hash = allocate_signatured_type_table ();
 
 
   htab_up sig_types_hash = allocate_signatured_type_table ();
 


@@ -2512,25 +2568,23 @@ create_signatured_type_table_from_index
       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
       bytes += 3 * 8;
 
       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
       bytes += 3 * 8;
 

-      sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                                struct signatured_type);
+      sig_type = per_bfd->allocate_signatured_type ();

       sig_type->signature = signature;
       sig_type->type_offset_in_tu = type_offset_in_tu;
       sig_type->per_cu.is_debug_types = 1;
       sig_type->per_cu.section = section;
       sig_type->per_cu.sect_off = sect_off;
       sig_type->signature = signature;
       sig_type->type_offset_in_tu = type_offset_in_tu;
       sig_type->per_cu.is_debug_types = 1;
       sig_type->per_cu.section = section;
       sig_type->per_cu.sect_off = sect_off;

-      sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;

       sig_type->per_cu.v.quick
       sig_type->per_cu.v.quick

-       = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+       = OBSTACK_ZALLOC (&per_bfd->obstack,

                          struct dwarf2_per_cu_quick_data);
 
       slot = htab_find_slot (sig_types_hash.get (), sig_type, INSERT);
       *slot = sig_type;
 
                          struct dwarf2_per_cu_quick_data);
 
       slot = htab_find_slot (sig_types_hash.get (), sig_type, INSERT);
       *slot = sig_type;
 

-      dwarf2_per_objfile->all_type_units.push_back (sig_type);
+      per_bfd->all_type_units.push_back (sig_type);

     }
 
     }
 

-  dwarf2_per_objfile->signatured_types = std::move (sig_types_hash);
+  per_bfd->signatured_types = std::move (sig_types_hash);

 }
 
 /* Create the signatured type hash table from .debug_names.  */
 }
 
 /* Create the signatured type hash table from .debug_names.  */


@@ -2547,8 +2601,8 @@ create_signatured_type_table_from_debug_names
   section->read (objfile);
   abbrev_section->read (objfile);
 
   section->read (objfile);
   abbrev_section->read (objfile);
 

-  gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
-  dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
+  gdb_assert (dwarf2_per_objfile->per_bfd->all_type_units.empty ());
+  dwarf2_per_objfile->per_bfd->all_type_units.reserve (map.tu_count);

 
   htab_up sig_types_hash = allocate_signatured_type_table ();
 
 
   htab_up sig_types_hash = allocate_signatured_type_table ();
 


@@ -2569,25 +2623,23 @@ create_signatured_type_table_from_debug_names
                                     section->buffer + to_underlying (sect_off),
                                     rcuh_kind::TYPE);
 
                                     section->buffer + to_underlying (sect_off),
                                     rcuh_kind::TYPE);
 

-      sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                                struct signatured_type);
+      sig_type = dwarf2_per_objfile->per_bfd->allocate_signatured_type ();

       sig_type->signature = cu_header.signature;
       sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
       sig_type->per_cu.is_debug_types = 1;
       sig_type->per_cu.section = section;
       sig_type->per_cu.sect_off = sect_off;
       sig_type->signature = cu_header.signature;
       sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
       sig_type->per_cu.is_debug_types = 1;
       sig_type->per_cu.section = section;
       sig_type->per_cu.sect_off = sect_off;

-      sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;

       sig_type->per_cu.v.quick
       sig_type->per_cu.v.quick

-       = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+       = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                          struct dwarf2_per_cu_quick_data);
 
       slot = htab_find_slot (sig_types_hash.get (), sig_type, INSERT);
       *slot = sig_type;
 
                          struct dwarf2_per_cu_quick_data);
 
       slot = htab_find_slot (sig_types_hash.get (), sig_type, INSERT);
       *slot = sig_type;
 

-      dwarf2_per_objfile->all_type_units.push_back (sig_type);
+      dwarf2_per_objfile->per_bfd->all_type_units.push_back (sig_type);

     }
 
     }
 

-  dwarf2_per_objfile->signatured_types = std::move (sig_types_hash);
+  dwarf2_per_objfile->per_bfd->signatured_types = std::move (sig_types_hash);

 }
 
 /* Read the address map data from the mapped index, and use it to
 }
 
 /* Read the address map data from the mapped index, and use it to


@@ -2629,7 +2681,7 @@ create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
          continue;
        }
 
          continue;
        }
 

-      if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
+      if (cu_index >= dwarf2_per_objfile->per_bfd->all_comp_units.size ())

        {
          complaint (_(".gdb_index address table has invalid CU number %u"),
                     (unsigned) cu_index);
        {
          complaint (_(".gdb_index address table has invalid CU number %u"),
                     (unsigned) cu_index);


@@ -2639,7 +2691,7 @@ create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
       lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
       hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
       addrmap_set_empty (mutable_map, lo, hi - 1,
       lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
       hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
       addrmap_set_empty (mutable_map, lo, hi - 1,

-                        dwarf2_per_objfile->get_cu (cu_index));
+                        dwarf2_per_objfile->per_bfd->get_cu (cu_index));

     }
 
   objfile->partial_symtabs->psymtabs_addrmap
     }
 
   objfile->partial_symtabs->psymtabs_addrmap


@@ -2665,7 +2717,7 @@ create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
                     dwarf2_per_cu_data *,
                     gdb::hash_enum<sect_offset>>
     debug_info_offset_to_per_cu;
                     dwarf2_per_cu_data *,
                     gdb::hash_enum<sect_offset>>
     debug_info_offset_to_per_cu;

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       const auto insertpair
        = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
     {
       const auto insertpair
        = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);


@@ -2793,7 +2845,7 @@ create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
          addr += address_size;
          if (start == 0 && length == 0)
            break;
          addr += address_size;
          if (start == 0 && length == 0)
            break;

-         if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
+         if (start == 0 && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

            {
              /* Symbol was eliminated due to a COMDAT group.  */
              continue;
            {
              /* Symbol was eliminated due to a COMDAT group.  */
              continue;


@@ -2986,7 +3038,7 @@ to use the section anyway."),
 /* Callback types for dwarf2_read_gdb_index.  */
 
 typedef gdb::function_view
 /* Callback types for dwarf2_read_gdb_index.  */
 
 typedef gdb::function_view

-    <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
+    <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_bfd *)>

     get_gdb_index_contents_ftype;
 typedef gdb::function_view
     <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
     get_gdb_index_contents_ftype;
 typedef gdb::function_view
     <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>


@@ -3007,7 +3059,7 @@ dwarf2_read_gdb_index
   struct objfile *objfile = dwarf2_per_objfile->objfile;
 
   gdb::array_view<const gdb_byte> main_index_contents
   struct objfile *objfile = dwarf2_per_objfile->objfile;
 
   gdb::array_view<const gdb_byte> main_index_contents

-    = get_gdb_index_contents (objfile, dwarf2_per_objfile);
+    = get_gdb_index_contents (objfile, dwarf2_per_objfile->per_bfd);

 
   if (main_index_contents.empty ())
     return 0;
 
   if (main_index_contents.empty ())
     return 0;


@@ -3026,7 +3078,7 @@ dwarf2_read_gdb_index
 
   /* If there is a .dwz file, read it so we can get its CU list as
      well.  */
 
   /* If there is a .dwz file, read it so we can get its CU list as
      well.  */

-  dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+  dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);

   if (dwz != NULL)
     {
       struct mapped_index dwz_map;
   if (dwz != NULL)
     {
       struct mapped_index dwz_map;


@@ -3051,28 +3103,29 @@ dwarf2_read_gdb_index
        }
     }
 
        }
     }
 

-  create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
+  create_cus_from_index (dwarf2_per_objfile->per_bfd, cu_list, cu_list_elements,

                         dwz_list, dwz_list_elements);
 
   if (types_list_elements)
     {
       /* We can only handle a single .debug_types when we have an
         index.  */
                         dwz_list, dwz_list_elements);
 
   if (types_list_elements)
     {
       /* We can only handle a single .debug_types when we have an
         index.  */

-      if (dwarf2_per_objfile->types.size () != 1)
+      if (dwarf2_per_objfile->per_bfd->types.size () != 1)

        return 0;
 
        return 0;
 

-      dwarf2_section_info *section = &dwarf2_per_objfile->types[0];
+      dwarf2_section_info *section = &dwarf2_per_objfile->per_bfd->types[0];

 
 

-      create_signatured_type_table_from_index (dwarf2_per_objfile, section,
-                                              types_list, types_list_elements);
+      create_signatured_type_table_from_index (dwarf2_per_objfile->per_bfd,
+                                              section, types_list,
+                                              types_list_elements);

     }
 
   create_addrmap_from_index (dwarf2_per_objfile, map.get ());
 
     }
 
   create_addrmap_from_index (dwarf2_per_objfile, map.get ());
 

-  dwarf2_per_objfile->index_table = std::move (map);
-  dwarf2_per_objfile->using_index = 1;
-  dwarf2_per_objfile->quick_file_names_table =
-    create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
+  dwarf2_per_objfile->per_bfd->index_table = std::move (map);
+  dwarf2_per_objfile->per_bfd->using_index = 1;
+  dwarf2_per_objfile->per_bfd->quick_file_names_table =
+    create_quick_file_names_table (dwarf2_per_objfile->per_bfd->all_comp_units.size ());

 
   return 1;
 }
 
   return 1;
 }


@@ -3086,9 +3139,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
 {
   struct dwarf2_cu *cu = reader->cu;
   struct dwarf2_per_cu_data *this_cu = cu->per_cu;
 {
   struct dwarf2_cu *cu = reader->cu;
   struct dwarf2_per_cu_data *this_cu = cu->per_cu;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct dwarf2_per_cu_data *lh_cu;
   struct attribute *attr;
   void **slot;
   struct dwarf2_per_cu_data *lh_cu;
   struct attribute *attr;
   void **slot;


@@ -3121,7 +3172,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
         If we have we're done.  */
       find_entry.hash.dwo_unit = cu->dwo_unit;
       find_entry.hash.line_sect_off = line_offset;
         If we have we're done.  */
       find_entry.hash.dwo_unit = cu->dwo_unit;
       find_entry.hash.line_sect_off = line_offset;

-      slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table.get (),
+      slot = htab_find_slot (dwarf2_per_objfile->per_bfd->quick_file_names_table.get (),

                             &find_entry, INSERT);
       if (*slot != NULL)
        {
                             &find_entry, INSERT);
       if (*slot != NULL)
        {


@@ -3137,7 +3188,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
       return;
     }
 
       return;
     }
 

-  qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
+  qfn = XOBNEW (&dwarf2_per_objfile->per_bfd->obstack, struct quick_file_names);

   qfn->hash.dwo_unit = cu->dwo_unit;
   qfn->hash.line_sect_off = line_offset;
   gdb_assert (slot != NULL);
   qfn->hash.dwo_unit = cu->dwo_unit;
   qfn->hash.line_sect_off = line_offset;
   gdb_assert (slot != NULL);


@@ -3151,7 +3202,8 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
 
   qfn->num_file_names = offset + lh->file_names_size ();
   qfn->file_names =
 
   qfn->num_file_names = offset + lh->file_names_size ();
   qfn->file_names =

-    XOBNEWVEC (&objfile->objfile_obstack, const char *, qfn->num_file_names);
+    XOBNEWVEC (&dwarf2_per_objfile->per_bfd->obstack, const char *,
+              qfn->num_file_names);

   if (offset != 0)
     qfn->file_names[0] = xstrdup (fnd.name);
   for (int i = 0; i < lh->file_names_size (); ++i)
   if (offset != 0)
     qfn->file_names[0] = xstrdup (fnd.name);
   for (int i = 0; i < lh->file_names_size (); ++i)


@@ -3166,7 +3218,8 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
    table for THIS_CU.  */
 
 static struct quick_file_names *
    table for THIS_CU.  */
 
 static struct quick_file_names *

-dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
+dw2_get_file_names (dwarf2_per_cu_data *this_cu,
+                   dwarf2_per_objfile *per_objfile)

 {
   /* This should never be called for TUs.  */
   gdb_assert (! this_cu->is_debug_types);
 {
   /* This should never be called for TUs.  */
   gdb_assert (! this_cu->is_debug_types);


@@ -3179,7 +3232,7 @@ dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
   if (this_cu->v.quick->no_file_data)
     return NULL;
 
   if (this_cu->v.quick->no_file_data)
     return NULL;
 

-  cutu_reader reader (this_cu);
+  cutu_reader reader (this_cu, per_objfile);

   if (!reader.dummy_p)
     dw2_get_file_names_reader (&reader, reader.info_ptr, reader.comp_unit_die);
 
   if (!reader.dummy_p)
     dw2_get_file_names_reader (&reader, reader.info_ptr, reader.comp_unit_die);
 


@@ -3192,11 +3245,11 @@ dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
    real path for a given file name from the line table.  */
 
 static const char *
    real path for a given file name from the line table.  */
 
 static const char *

-dw2_get_real_path (struct objfile *objfile,
+dw2_get_real_path (struct dwarf2_per_objfile *dwarf2_per_objfile,

                   struct quick_file_names *qfn, int index)
 {
   if (qfn->real_names == NULL)
                   struct quick_file_names *qfn, int index)
 {
   if (qfn->real_names == NULL)

-    qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
+    qfn->real_names = OBSTACK_CALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                                      qfn->num_file_names, const char *);
 
   if (qfn->real_names[index] == NULL)
                                      qfn->num_file_names, const char *);
 
   if (qfn->real_names[index] == NULL)


@@ -3210,8 +3263,9 @@ dw2_find_last_source_symtab (struct objfile *objfile)
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);

-  dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
-  compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
+  dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->per_bfd->all_comp_units.back ();
+  compunit_symtab *cust
+    = dw2_instantiate_symtab (dwarf_cu, dwarf2_per_objfile, false);

 
   if (cust == NULL)
     return NULL;
 
   if (cust == NULL)
     return NULL;


@@ -3246,7 +3300,7 @@ dw2_forget_cached_source_info (struct objfile *objfile)
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table.get (),
+  htab_traverse_noresize (dwarf2_per_objfile->per_bfd->quick_file_names_table.get (),

                          dw2_free_cached_file_names, NULL);
 }
 
                          dw2_free_cached_file_names, NULL);
 }
 


@@ -3262,12 +3316,13 @@ dw2_map_expand_apply (struct objfile *objfile,
   struct compunit_symtab *last_made = objfile->compunit_symtabs;
 
   /* Don't visit already-expanded CUs.  */
   struct compunit_symtab *last_made = objfile->compunit_symtabs;
 
   /* Don't visit already-expanded CUs.  */

-  if (per_cu->v.quick->compunit_symtab)
+  dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
+  if (per_objfile->symtab_set_p (per_cu))

     return 0;
 
   /* This may expand more than one symtab, and we want to iterate over
      all of them.  */
     return 0;
 
   /* This may expand more than one symtab, and we want to iterate over
      all of them.  */

-  dw2_instantiate_symtab (per_cu, false);
+  dw2_instantiate_symtab (per_cu, per_objfile, false);

 
   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
                                    last_made, callback);
 
   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
                                    last_made, callback);


@@ -3287,13 +3342,14 @@ dw2_map_symtabs_matching_filename
   /* The rule is CUs specify all the files, including those used by
      any TU, so there's no need to scan TUs here.  */
 
   /* The rule is CUs specify all the files, including those used by
      any TU, so there's no need to scan TUs here.  */
 

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       /* We only need to look at symtabs not already expanded.  */
     {
       /* We only need to look at symtabs not already expanded.  */

-      if (per_cu->v.quick->compunit_symtab)
+      if (dwarf2_per_objfile->symtab_set_p (per_cu))

        continue;
 
        continue;
 

-      quick_file_names *file_data = dw2_get_file_names (per_cu);
+      quick_file_names *file_data
+       = dw2_get_file_names (per_cu, dwarf2_per_objfile);

       if (file_data == NULL)
        continue;
 
       if (file_data == NULL)
        continue;
 


@@ -3316,7 +3372,8 @@ dw2_map_symtabs_matching_filename
              && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
            continue;
 
              && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
            continue;
 

-         this_real_name = dw2_get_real_path (objfile, file_data, j);
+         this_real_name = dw2_get_real_path (dwarf2_per_objfile,
+                                             file_data, j);

          if (compare_filenames_for_search (this_real_name, name))
            {
              if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
          if (compare_filenames_for_search (this_real_name, name))
            {
              if (dw2_map_expand_apply (objfile, per_cu, name, real_path,


@@ -3384,7 +3441,7 @@ dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
   iter->next = 0;
   iter->global_seen = 0;
 
   iter->next = 0;
   iter->global_seen = 0;
 

-  mapped_index *index = dwarf2_per_objfile->index_table.get ();
+  mapped_index *index = dwarf2_per_objfile->per_bfd->index_table.get ();

 
   /* index is NULL if OBJF_READNOW.  */
   if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
 
   /* index is NULL if OBJF_READNOW.  */
   if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))


@@ -3415,12 +3472,12 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
         and indices >= 7 may elide them for certain symbols
         (gold does this).  */
       int attrs_valid =
         and indices >= 7 may elide them for certain symbols
         (gold does this).  */
       int attrs_valid =

-       (dwarf2_per_objfile->index_table->version >= 7
+       (dwarf2_per_objfile->per_bfd->index_table->version >= 7

         && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
 
       /* Don't crash on bad data.  */
         && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
 
       /* Don't crash on bad data.  */

-      if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
-                      + dwarf2_per_objfile->all_type_units.size ()))
+      if (cu_index >= (dwarf2_per_objfile->per_bfd->all_comp_units.size ()
+                      + dwarf2_per_objfile->per_bfd->all_type_units.size ()))

        {
          complaint (_(".gdb_index entry has bad CU index"
                       " [in module %s]"),
        {
          complaint (_(".gdb_index entry has bad CU index"
                       " [in module %s]"),


@@ -3428,10 +3485,10 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
          continue;
        }
 
          continue;
        }
 

-      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
+      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->per_bfd->get_cutu (cu_index);

 
       /* Skip if already read in.  */
 
       /* Skip if already read in.  */

-      if (per_cu->v.quick->compunit_symtab)
+      if (dwarf2_per_objfile->symtab_set_p (per_cu))

        continue;
 
       /* Check static vs global.  */
        continue;
 
       /* Check static vs global.  */


@@ -3508,7 +3565,8 @@ dw2_lookup_symbol (struct objfile *objfile, block_enum block_index,
   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
     {
       struct symbol *sym, *with_opaque = NULL;
   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
     {
       struct symbol *sym, *with_opaque = NULL;

-      struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
+      struct compunit_symtab *stab
+       = dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, false);

       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 
       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 


@@ -3538,15 +3596,15 @@ dw2_print_stats (struct objfile *objfile)
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);

-  int total = (dwarf2_per_objfile->all_comp_units.size ()
-              + dwarf2_per_objfile->all_type_units.size ());
+  int total = (dwarf2_per_objfile->per_bfd->all_comp_units.size ()
+              + dwarf2_per_objfile->per_bfd->all_type_units.size ());

   int count = 0;
 
   for (int i = 0; i < total; ++i)
     {
   int count = 0;
 
   for (int i = 0; i < total; ++i)
     {

-      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
+      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->per_bfd->get_cutu (i);

 
 

-      if (!per_cu->v.quick->compunit_symtab)
+      if (!dwarf2_per_objfile->symtab_set_p (per_cu))

        ++count;
     }
   printf_filtered (_("  Number of read CUs: %d\n"), total - count);
        ++count;
     }
   printf_filtered (_("  Number of read CUs: %d\n"), total - count);


@@ -3564,12 +3622,12 @@ dw2_dump (struct objfile *objfile)
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  gdb_assert (dwarf2_per_objfile->using_index);
+  gdb_assert (dwarf2_per_objfile->per_bfd->using_index);

   printf_filtered (".gdb_index:");
   printf_filtered (".gdb_index:");

-  if (dwarf2_per_objfile->index_table != NULL)
+  if (dwarf2_per_objfile->per_bfd->index_table != NULL)

     {
       printf_filtered (" version %d\n",
     {
       printf_filtered (" version %d\n",

-                      dwarf2_per_objfile->index_table->version);
+                      dwarf2_per_objfile->per_bfd->index_table->version);

     }
   else
     printf_filtered (" faked for \"readnow\"\n");
     }
   else
     printf_filtered (" faked for \"readnow\"\n");


@@ -3589,7 +3647,7 @@ dw2_expand_symtabs_for_function (struct objfile *objfile,
   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, {}, VAR_DOMAIN, func_name);
 
   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, {}, VAR_DOMAIN, func_name);
 
   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)

-    dw2_instantiate_symtab (per_cu, false);
+    dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, false);

 
 }
 
 
 }
 


@@ -3598,19 +3656,19 @@ dw2_expand_all_symtabs (struct objfile *objfile)
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 {
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);

-  int total_units = (dwarf2_per_objfile->all_comp_units.size ()
-                    + dwarf2_per_objfile->all_type_units.size ());
+  int total_units = (dwarf2_per_objfile->per_bfd->all_comp_units.size ()
+                    + dwarf2_per_objfile->per_bfd->all_type_units.size ());

 
   for (int i = 0; i < total_units; ++i)
     {
 
   for (int i = 0; i < total_units; ++i)
     {

-      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
+      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->per_bfd->get_cutu (i);

 
       /* We don't want to directly expand a partial CU, because if we
         read it with the wrong language, then assertion failures can
         be triggered later on.  See PR symtab/23010.  So, tell
         dw2_instantiate_symtab to skip partial CUs -- any important
         partial CU will be read via DW_TAG_imported_unit anyway.  */
 
       /* We don't want to directly expand a partial CU, because if we
         read it with the wrong language, then assertion failures can
         be triggered later on.  See PR symtab/23010.  So, tell
         dw2_instantiate_symtab to skip partial CUs -- any important
         partial CU will be read via DW_TAG_imported_unit anyway.  */

-      dw2_instantiate_symtab (per_cu, true);
+      dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, true);

     }
 }
 
     }
 }
 


@@ -3626,13 +3684,14 @@ dw2_expand_symtabs_with_fullname (struct objfile *objfile,
      There can be an order of magnitude (or more) more type units
      than comp units, and we avoid them if we can.  */
 
      There can be an order of magnitude (or more) more type units
      than comp units, and we avoid them if we can.  */
 

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       /* We only need to look at symtabs not already expanded.  */
     {
       /* We only need to look at symtabs not already expanded.  */

-      if (per_cu->v.quick->compunit_symtab)
+      if (dwarf2_per_objfile->symtab_set_p (per_cu))

        continue;
 
        continue;
 

-      quick_file_names *file_data = dw2_get_file_names (per_cu);
+      quick_file_names *file_data
+       = dw2_get_file_names (per_cu, dwarf2_per_objfile);

       if (file_data == NULL)
        continue;
 
       if (file_data == NULL)
        continue;
 


@@ -3642,7 +3701,7 @@ dw2_expand_symtabs_with_fullname (struct objfile *objfile,
 
          if (filename_cmp (this_fullname, fullname) == 0)
            {
 
          if (filename_cmp (this_fullname, fullname) == 0)
            {

-             dw2_instantiate_symtab (per_cu, false);
+             dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, false);

              break;
            }
        }
              break;
            }
        }


@@ -3659,7 +3718,8 @@ dw2_expand_symtabs_matching_symbol
 
 static void
 dw2_expand_symtabs_matching_one
 
 static void
 dw2_expand_symtabs_matching_one

-  (struct dwarf2_per_cu_data *per_cu,
+  (dwarf2_per_cu_data *per_cu,
+   dwarf2_per_objfile *per_objfile,

    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify);
 
    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify);
 


@@ -3677,12 +3737,12 @@ dw2_map_matching_symbols
 
   const block_enum block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
 
 
   const block_enum block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
 

-  if (dwarf2_per_objfile->index_table != nullptr)
+  if (dwarf2_per_objfile->per_bfd->index_table != nullptr)

     {
       /* Ada currently doesn't support .gdb_index (see PR24713).  We can get
         here though if the current language is Ada for a non-Ada objfile
         using GNU index.  */
     {
       /* Ada currently doesn't support .gdb_index (see PR24713).  We can get
         here though if the current language is Ada for a non-Ada objfile
         using GNU index.  */

-      mapped_index &index = *dwarf2_per_objfile->index_table;
+      mapped_index &index = *dwarf2_per_objfile->per_bfd->index_table;

 
       const char *match_name = name.ada ().lookup_name ().c_str ();
       auto matcher = [&] (const char *symname)
 
       const char *match_name = name.ada ().lookup_name ().c_str ();
       auto matcher = [&] (const char *symname)


@@ -3701,7 +3761,8 @@ dw2_map_matching_symbols
        dw2_symtab_iter_init (&iter, dwarf2_per_objfile, block_kind, domain,
                              match_name);
        while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
        dw2_symtab_iter_init (&iter, dwarf2_per_objfile, block_kind, domain,
                              match_name);
        while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)

-         dw2_expand_symtabs_matching_one (per_cu, nullptr, nullptr);
+         dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile, nullptr,
+                                          nullptr);

        return true;
       });
     }
        return true;
       });
     }


@@ -4484,21 +4545,21 @@ run_test ()
 
 static void
 dw2_expand_symtabs_matching_one
 
 static void
 dw2_expand_symtabs_matching_one

-  (struct dwarf2_per_cu_data *per_cu,
+  (dwarf2_per_cu_data *per_cu,
+   dwarf2_per_objfile *per_objfile,

    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
 {
   if (file_matcher == NULL || per_cu->v.quick->mark)
     {
    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
 {
   if (file_matcher == NULL || per_cu->v.quick->mark)
     {

-      bool symtab_was_null
-       = (per_cu->v.quick->compunit_symtab == NULL);
+      bool symtab_was_null = !per_objfile->symtab_set_p (per_cu);

 
 

-      dw2_instantiate_symtab (per_cu, false);
+      compunit_symtab *symtab
+       = dw2_instantiate_symtab (per_cu, per_objfile, false);
+      gdb_assert (symtab != nullptr);

 
 

-      if (expansion_notify != NULL
-         && symtab_was_null
-         && per_cu->v.quick->compunit_symtab != NULL)
-       expansion_notify (per_cu->v.quick->compunit_symtab);
+      if (expansion_notify != NULL && symtab_was_null)
+       expansion_notify (symtab);

     }
 }
 
     }
 }
 


@@ -4508,14 +4569,14 @@ dw2_expand_symtabs_matching_one
 
 static void
 dw2_expand_marked_cus
 
 static void
 dw2_expand_marked_cus

-  (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
+  (dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,

    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
    search_domain kind)
 {
   offset_type *vec, vec_len, vec_idx;
   bool global_seen = false;
    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
    search_domain kind)
 {
   offset_type *vec, vec_len, vec_idx;
   bool global_seen = false;

-  mapped_index &index = *dwarf2_per_objfile->index_table;
+  mapped_index &index = *dwarf2_per_objfile->per_bfd->index_table;

 
   vec = (offset_type *) (index.constant_pool
                         + MAYBE_SWAP (index.symbol_table[idx].vec));
 
   vec = (offset_type *) (index.constant_pool
                         + MAYBE_SWAP (index.symbol_table[idx].vec));


@@ -4572,8 +4633,8 @@ dw2_expand_marked_cus
        }
 
       /* Don't crash on bad data.  */
        }
 
       /* Don't crash on bad data.  */

-      if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
-                      + dwarf2_per_objfile->all_type_units.size ()))
+      if (cu_index >= (dwarf2_per_objfile->per_bfd->all_comp_units.size ()
+                      + dwarf2_per_objfile->per_bfd->all_type_units.size ()))

        {
          complaint (_(".gdb_index entry has bad CU index"
                       " [in module %s]"),
        {
          complaint (_(".gdb_index entry has bad CU index"
                       " [in module %s]"),


@@ -4581,8 +4642,8 @@ dw2_expand_marked_cus
          continue;
        }
 
          continue;
        }
 

-      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
-      dw2_expand_symtabs_matching_one (per_cu, file_matcher,
+      dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->per_bfd->get_cutu (cu_index);
+      dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile, file_matcher,

                                       expansion_notify);
     }
 }
                                       expansion_notify);
     }
 }


@@ -4599,8 +4660,6 @@ dw_expand_symtabs_matching_file_matcher
   if (file_matcher == NULL)
     return;
 
   if (file_matcher == NULL)
     return;
 

-  objfile *const objfile = dwarf2_per_objfile->objfile;
-

   htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
                                            htab_eq_pointer,
                                            NULL, xcalloc, xfree));
   htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
                                            htab_eq_pointer,
                                            NULL, xcalloc, xfree));


@@ -4611,17 +4670,18 @@ dw_expand_symtabs_matching_file_matcher
   /* The rule is CUs specify all the files, including those used by
      any TU, so there's no need to scan TUs here.  */
 
   /* The rule is CUs specify all the files, including those used by
      any TU, so there's no need to scan TUs here.  */
 

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       QUIT;
 
       per_cu->v.quick->mark = 0;
 
       /* We only need to look at symtabs not already expanded.  */
     {
       QUIT;
 
       per_cu->v.quick->mark = 0;
 
       /* We only need to look at symtabs not already expanded.  */

-      if (per_cu->v.quick->compunit_symtab)
+      if (dwarf2_per_objfile->symtab_set_p (per_cu))

        continue;
 
        continue;
 

-      quick_file_names *file_data = dw2_get_file_names (per_cu);
+      quick_file_names *file_data
+       = dw2_get_file_names (per_cu, dwarf2_per_objfile);

       if (file_data == NULL)
        continue;
 
       if (file_data == NULL)
        continue;
 


@@ -4650,7 +4710,8 @@ dw_expand_symtabs_matching_file_matcher
                                true))
            continue;
 
                                true))
            continue;
 

-         this_real_name = dw2_get_real_path (objfile, file_data, j);
+         this_real_name = dw2_get_real_path (dwarf2_per_objfile,
+                                             file_data, j);

          if (file_matcher (this_real_name, false))
            {
              per_cu->v.quick->mark = 1;
          if (file_matcher (this_real_name, false))
            {
              per_cu->v.quick->mark = 1;


@@ -4679,24 +4740,24 @@ dw2_expand_symtabs_matching
     = get_dwarf2_per_objfile (objfile);
 
   /* index_table is NULL if OBJF_READNOW.  */
     = get_dwarf2_per_objfile (objfile);
 
   /* index_table is NULL if OBJF_READNOW.  */

-  if (!dwarf2_per_objfile->index_table)
+  if (!dwarf2_per_objfile->per_bfd->index_table)

     return;
 
   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
 
   if (symbol_matcher == NULL && lookup_name == NULL)
     {
     return;
 
   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
 
   if (symbol_matcher == NULL && lookup_name == NULL)
     {

-      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

        {
          QUIT;
 
        {
          QUIT;
 

-         dw2_expand_symtabs_matching_one (per_cu, file_matcher,
-                                          expansion_notify);
+         dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile,
+                                          file_matcher, expansion_notify);

        }
       return;
     }
 
        }
       return;
     }
 

-  mapped_index &index = *dwarf2_per_objfile->index_table;
+  mapped_index &index = *dwarf2_per_objfile->per_bfd->index_table;

 
   dw2_expand_symtabs_matching_symbol (index, *lookup_name,
                                      symbol_matcher,
 
   dw2_expand_symtabs_matching_symbol (index, *lookup_name,
                                      symbol_matcher,


@@ -4755,14 +4816,14 @@ dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
   if (!data)
     return NULL;
 
   if (!data)
     return NULL;
 

-  if (warn_if_readin && data->v.quick->compunit_symtab)
+  dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
+  if (warn_if_readin && per_objfile->symtab_set_p (data))

     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
             paddress (objfile->arch (), pc));
 
     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
             paddress (objfile->arch (), pc));
 

-  result
-    = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
-                                                                       false),
-                                               pc);
+  result = recursively_find_pc_sect_compunit_symtab
+    (dw2_instantiate_symtab (data, per_objfile, false), pc);
+

   gdb_assert (result != NULL);
   return result;
 }
   gdb_assert (result != NULL);
   return result;
 }


@@ -4774,9 +4835,9 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  if (!dwarf2_per_objfile->filenames_cache)
+  if (!dwarf2_per_objfile->per_bfd->filenames_cache)

     {
     {

-      dwarf2_per_objfile->filenames_cache.emplace ();
+      dwarf2_per_objfile->per_bfd->filenames_cache.emplace ();

 
       htab_up visited (htab_create_alloc (10,
                                          htab_hash_pointer, htab_eq_pointer,
 
       htab_up visited (htab_create_alloc (10,
                                          htab_hash_pointer, htab_eq_pointer,


@@ -4786,9 +4847,9 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
         by any TU, so there's no need to scan TUs here.  We can
         ignore file names coming from already-expanded CUs.  */
 
         by any TU, so there's no need to scan TUs here.  We can
         ignore file names coming from already-expanded CUs.  */
 

-      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

        {
        {

-         if (per_cu->v.quick->compunit_symtab)
+         if (dwarf2_per_objfile->symtab_set_p (per_cu))

            {
              void **slot = htab_find_slot (visited.get (),
                                            per_cu->v.quick->file_names,
            {
              void **slot = htab_find_slot (visited.get (),
                                            per_cu->v.quick->file_names,


@@ -4798,13 +4859,14 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
            }
        }
 
            }
        }
 

-      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

        {
          /* We only need to look at symtabs not already expanded.  */
        {
          /* We only need to look at symtabs not already expanded.  */

-         if (per_cu->v.quick->compunit_symtab)
+         if (dwarf2_per_objfile->symtab_set_p (per_cu))

            continue;
 
            continue;
 

-         quick_file_names *file_data = dw2_get_file_names (per_cu);
+         quick_file_names *file_data
+           = dw2_get_file_names (per_cu, dwarf2_per_objfile);

          if (file_data == NULL)
            continue;
 
          if (file_data == NULL)
            continue;
 


@@ -4819,12 +4881,12 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
          for (int j = 0; j < file_data->num_file_names; ++j)
            {
              const char *filename = file_data->file_names[j];
          for (int j = 0; j < file_data->num_file_names; ++j)
            {
              const char *filename = file_data->file_names[j];

-             dwarf2_per_objfile->filenames_cache->seen (filename);
+             dwarf2_per_objfile->per_bfd->filenames_cache->seen (filename);

            }
        }
     }
 
            }
        }
     }
 

-  dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
+  dwarf2_per_objfile->per_bfd->filenames_cache->traverse ([&] (const char *filename)

     {
       gdb::unique_xmalloc_ptr<char> this_real_name;
 
     {
       gdb::unique_xmalloc_ptr<char> this_real_name;
 


@@ -5053,7 +5115,7 @@ read_debug_names_from_section (struct objfile *objfile,
    list.  */
 
 static void
    list.  */
 
 static void

-create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
+create_cus_from_debug_names_list (dwarf2_per_bfd *per_bfd,

                                  const mapped_debug_names &map,
                                  dwarf2_section_info &section,
                                  bool is_dwz)
                                  const mapped_debug_names &map,
                                  dwarf2_section_info &section,
                                  bool is_dwz)


@@ -5072,9 +5134,8 @@ create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
           the next CU as end of this CU.  We create the CUs here with length 0,
           and in cutu_reader::cutu_reader we'll fill in the actual length.  */
        dwarf2_per_cu_data *per_cu
           the next CU as end of this CU.  We create the CUs here with length 0,
           and in cutu_reader::cutu_reader we'll fill in the actual length.  */
        dwarf2_per_cu_data *per_cu

-         = create_cu_from_index_list (dwarf2_per_objfile, &section, is_dwz,
-                                      sect_off, 0);
-       dwarf2_per_objfile->all_comp_units.push_back (per_cu);
+         = create_cu_from_index_list (per_bfd, &section, is_dwz, sect_off, 0);
+       per_bfd->all_comp_units.push_back (per_cu);

       }
     }
 
       }
     }
 


@@ -5096,9 +5157,9 @@ create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
        {
          const ULONGEST length = sect_off_next - sect_off_prev;
          dwarf2_per_cu_data *per_cu
        {
          const ULONGEST length = sect_off_next - sect_off_prev;
          dwarf2_per_cu_data *per_cu

-           = create_cu_from_index_list (dwarf2_per_objfile, &section, is_dwz,
+           = create_cu_from_index_list (per_bfd, &section, is_dwz,

                                         sect_off_prev, length);
                                         sect_off_prev, length);

-         dwarf2_per_objfile->all_comp_units.push_back (per_cu);
+         per_bfd->all_comp_units.push_back (per_cu);

        }
       sect_off_prev = sect_off_next;
     }
        }
       sect_off_prev = sect_off_next;
     }


@@ -5108,22 +5169,21 @@ create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
    the CU objects for this dwarf2_per_objfile.  */
 
 static void
    the CU objects for this dwarf2_per_objfile.  */
 
 static void

-create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
+create_cus_from_debug_names (dwarf2_per_bfd *per_bfd,

                             const mapped_debug_names &map,
                             const mapped_debug_names &dwz_map)
 {
                             const mapped_debug_names &map,
                             const mapped_debug_names &dwz_map)
 {

-  gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
-  dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
+  gdb_assert (per_bfd->all_comp_units.empty ());
+  per_bfd->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);

 
 

-  create_cus_from_debug_names_list (dwarf2_per_objfile, map,
-                                   dwarf2_per_objfile->info,
+  create_cus_from_debug_names_list (per_bfd, map, per_bfd->info,

                                    false /* is_dwz */);
 
   if (dwz_map.cu_count == 0)
     return;
 
                                    false /* is_dwz */);
 
   if (dwz_map.cu_count == 0)
     return;
 

-  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
-  create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
+  dwz_file *dwz = dwarf2_get_dwz_file (per_bfd);
+  create_cus_from_debug_names_list (per_bfd, dwz_map, dwz->info,

                                    true /* is_dwz */);
 }
 
                                    true /* is_dwz */);
 }
 


@@ -5139,7 +5199,7 @@ dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
   struct objfile *objfile = dwarf2_per_objfile->objfile;
 
   if (!read_debug_names_from_section (objfile, objfile_name (objfile),
   struct objfile *objfile = dwarf2_per_objfile->objfile;
 
   if (!read_debug_names_from_section (objfile, objfile_name (objfile),

-                                     &dwarf2_per_objfile->debug_names,
+                                     &dwarf2_per_objfile->per_bfd->debug_names,

                                      *map))
     return false;
 
                                      *map))
     return false;
 


@@ -5149,7 +5209,7 @@ dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
 
   /* If there is a .dwz file, read it so we can get its CU list as
      well.  */
 
   /* If there is a .dwz file, read it so we can get its CU list as
      well.  */

-  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);

   if (dwz != NULL)
     {
       if (!read_debug_names_from_section (objfile,
   if (dwz != NULL)
     {
       if (!read_debug_names_from_section (objfile,


@@ -5162,28 +5222,28 @@ dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
        }
     }
 
        }
     }
 

-  create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
+  create_cus_from_debug_names (dwarf2_per_objfile->per_bfd, *map, dwz_map);

 
   if (map->tu_count != 0)
     {
       /* We can only handle a single .debug_types when we have an
         index.  */
 
   if (map->tu_count != 0)
     {
       /* We can only handle a single .debug_types when we have an
         index.  */

-      if (dwarf2_per_objfile->types.size () != 1)
+      if (dwarf2_per_objfile->per_bfd->types.size () != 1)

        return false;
 
        return false;
 

-      dwarf2_section_info *section = &dwarf2_per_objfile->types[0];
+      dwarf2_section_info *section = &dwarf2_per_objfile->per_bfd->types[0];

 
       create_signatured_type_table_from_debug_names
 
       create_signatured_type_table_from_debug_names

-       (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
+       (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->per_bfd->abbrev);

     }
 
   create_addrmap_from_aranges (dwarf2_per_objfile,
     }
 
   create_addrmap_from_aranges (dwarf2_per_objfile,

-                              &dwarf2_per_objfile->debug_aranges);
+                              &dwarf2_per_objfile->per_bfd->debug_aranges);

 
 

-  dwarf2_per_objfile->debug_names_table = std::move (map);
-  dwarf2_per_objfile->using_index = 1;
-  dwarf2_per_objfile->quick_file_names_table =
-    create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
+  dwarf2_per_objfile->per_bfd->debug_names_table = std::move (map);
+  dwarf2_per_objfile->per_bfd->using_index = 1;
+  dwarf2_per_objfile->per_bfd->quick_file_names_table =
+    create_quick_file_names_table (dwarf2_per_objfile->per_bfd->all_comp_units.size ());

 
   return true;
 }
 
   return true;
 }


@@ -5430,7 +5490,7 @@ dw2_debug_names_iterator::next ()
        {
        case DW_IDX_compile_unit:
          /* Don't crash on bad data.  */
        {
        case DW_IDX_compile_unit:
          /* Don't crash on bad data.  */

-         if (ull >= dwarf2_per_objfile->all_comp_units.size ())
+         if (ull >= dwarf2_per_objfile->per_bfd->all_comp_units.size ())

            {
              complaint (_(".debug_names entry has bad CU index %s"
                           " [in module %s]"),
            {
              complaint (_(".debug_names entry has bad CU index %s"
                           " [in module %s]"),


@@ -5438,11 +5498,11 @@ dw2_debug_names_iterator::next ()
                         objfile_name (dwarf2_per_objfile->objfile));
              continue;
            }
                         objfile_name (dwarf2_per_objfile->objfile));
              continue;
            }

-         per_cu = dwarf2_per_objfile->get_cutu (ull);
+         per_cu = dwarf2_per_objfile->per_bfd->get_cutu (ull);

          break;
        case DW_IDX_type_unit:
          /* Don't crash on bad data.  */
          break;
        case DW_IDX_type_unit:
          /* Don't crash on bad data.  */

-         if (ull >= dwarf2_per_objfile->all_type_units.size ())
+         if (ull >= dwarf2_per_objfile->per_bfd->all_type_units.size ())

            {
              complaint (_(".debug_names entry has bad TU index %s"
                           " [in module %s]"),
            {
              complaint (_(".debug_names entry has bad TU index %s"
                           " [in module %s]"),


@@ -5450,13 +5510,13 @@ dw2_debug_names_iterator::next ()
                         objfile_name (dwarf2_per_objfile->objfile));
              continue;
            }
                         objfile_name (dwarf2_per_objfile->objfile));
              continue;
            }

-         per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
+         per_cu = &dwarf2_per_objfile->per_bfd->get_tu (ull)->per_cu;

          break;
        case DW_IDX_die_offset:
          /* In a per-CU index (as opposed to a per-module index), index
             entries without CU attribute implicitly refer to the single CU.  */
          if (per_cu == NULL)
          break;
        case DW_IDX_die_offset:
          /* In a per-CU index (as opposed to a per-module index), index
             entries without CU attribute implicitly refer to the single CU.  */
          if (per_cu == NULL)

-           per_cu = dwarf2_per_objfile->get_cu (0);
+           per_cu = dwarf2_per_objfile->per_bfd->get_cu (0);

          break;
        case DW_IDX_GNU_internal:
          if (!m_map.augmentation_is_gdb)
          break;
        case DW_IDX_GNU_internal:
          if (!m_map.augmentation_is_gdb)


@@ -5472,7 +5532,7 @@ dw2_debug_names_iterator::next ()
     }
 
   /* Skip if already read in.  */
     }
 
   /* Skip if already read in.  */

-  if (per_cu->v.quick->compunit_symtab)
+  if (dwarf2_per_objfile->symtab_set_p (per_cu))

     goto again;
 
   /* Check static vs global.  */
     goto again;
 
   /* Check static vs global.  */


@@ -5589,7 +5649,7 @@ dw2_debug_names_lookup_symbol (struct objfile *objfile, block_enum block_index,
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  const auto &mapp = dwarf2_per_objfile->debug_names_table;
+  const auto &mapp = dwarf2_per_objfile->per_bfd->debug_names_table;

   if (!mapp)
     {
       /* index is NULL if OBJF_READNOW.  */
   if (!mapp)
     {
       /* index is NULL if OBJF_READNOW.  */


@@ -5604,7 +5664,8 @@ dw2_debug_names_lookup_symbol (struct objfile *objfile, block_enum block_index,
   while ((per_cu = iter.next ()) != NULL)
     {
       struct symbol *sym, *with_opaque = NULL;
   while ((per_cu = iter.next ()) != NULL)
     {
       struct symbol *sym, *with_opaque = NULL;

-      struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
+      compunit_symtab *stab
+       = dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, false);

       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 
       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 


@@ -5639,9 +5700,9 @@ dw2_debug_names_dump (struct objfile *objfile)
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  gdb_assert (dwarf2_per_objfile->using_index);
+  gdb_assert (dwarf2_per_objfile->per_bfd->using_index);

   printf_filtered (".debug_names:");
   printf_filtered (".debug_names:");

-  if (dwarf2_per_objfile->debug_names_table)
+  if (dwarf2_per_objfile->per_bfd->debug_names_table)

     printf_filtered (" exists\n");
   else
     printf_filtered (" faked for \"readnow\"\n");
     printf_filtered (" exists\n");
   else
     printf_filtered (" faked for \"readnow\"\n");


@@ -5655,16 +5716,16 @@ dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW.  */
-  if (dwarf2_per_objfile->debug_names_table)
+  /* dwarf2_per_objfile->per_bfd->debug_names_table is NULL if OBJF_READNOW.  */
+  if (dwarf2_per_objfile->per_bfd->debug_names_table)

     {
     {

-      const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
+      const mapped_debug_names &map = *dwarf2_per_objfile->per_bfd->debug_names_table;

 
       dw2_debug_names_iterator iter (map, {}, VAR_DOMAIN, func_name);
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)
 
       dw2_debug_names_iterator iter (map, {}, VAR_DOMAIN, func_name);
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)

-       dw2_instantiate_symtab (per_cu, false);
+       dw2_instantiate_symtab (per_cu, dwarf2_per_objfile, false);

     }
 }
 
     }
 }
 


@@ -5680,10 +5741,10 @@ dw2_debug_names_map_matching_symbols
     = get_dwarf2_per_objfile (objfile);
 
   /* debug_names_table is NULL if OBJF_READNOW.  */
     = get_dwarf2_per_objfile (objfile);
 
   /* debug_names_table is NULL if OBJF_READNOW.  */

-  if (!dwarf2_per_objfile->debug_names_table)
+  if (!dwarf2_per_objfile->per_bfd->debug_names_table)

     return;
 
     return;
 

-  mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
+  mapped_debug_names &map = *dwarf2_per_objfile->per_bfd->debug_names_table;

   const block_enum block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
 
   const char *match_name = name.ada ().lookup_name ().c_str ();
   const block_enum block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
 
   const char *match_name = name.ada ().lookup_name ().c_str ();


@@ -5703,7 +5764,8 @@ dw2_debug_names_map_matching_symbols
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)

-       dw2_expand_symtabs_matching_one (per_cu, nullptr, nullptr);
+       dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile, nullptr,
+                                        nullptr);

       return true;
     });
 
       return true;
     });
 


@@ -5711,13 +5773,13 @@ dw2_debug_names_map_matching_symbols
      dw2_expand_symtabs_matching_symbol callback, but that skips CUs
      that have already been expanded.  Instead, this loop matches what
      the psymtab code does.  */
      dw2_expand_symtabs_matching_symbol callback, but that skips CUs
      that have already been expanded.  Instead, this loop matches what
      the psymtab code does.  */

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
     {

-      struct compunit_symtab *cust = per_cu->v.quick->compunit_symtab;
-      if (cust != nullptr)
+      compunit_symtab *symtab = dwarf2_per_objfile->get_symtab (per_cu);
+      if (symtab != nullptr)

        {
          const struct block *block
        {
          const struct block *block

-           = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
+           = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab), block_kind);

          if (!iterate_over_symbols_terminated (block, name,
                                                domain, callback))
            break;
          if (!iterate_over_symbols_terminated (block, name,
                                                domain, callback))
            break;


@@ -5738,24 +5800,24 @@ dw2_debug_names_expand_symtabs_matching
     = get_dwarf2_per_objfile (objfile);
 
   /* debug_names_table is NULL if OBJF_READNOW.  */
     = get_dwarf2_per_objfile (objfile);
 
   /* debug_names_table is NULL if OBJF_READNOW.  */

-  if (!dwarf2_per_objfile->debug_names_table)
+  if (!dwarf2_per_objfile->per_bfd->debug_names_table)

     return;
 
   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
 
   if (symbol_matcher == NULL && lookup_name == NULL)
     {
     return;
 
   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
 
   if (symbol_matcher == NULL && lookup_name == NULL)
     {

-      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+      for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

        {
          QUIT;
 
        {
          QUIT;
 

-         dw2_expand_symtabs_matching_one (per_cu, file_matcher,
-                                          expansion_notify);
+         dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile,
+                                          file_matcher, expansion_notify);

        }
       return;
     }
 
        }
       return;
     }
 

-  mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
+  mapped_debug_names &map = *dwarf2_per_objfile->per_bfd->debug_names_table;

 
   dw2_expand_symtabs_matching_symbol (map, *lookup_name,
                                      symbol_matcher,
 
   dw2_expand_symtabs_matching_symbol (map, *lookup_name,
                                      symbol_matcher,


@@ -5767,8 +5829,8 @@ dw2_debug_names_expand_symtabs_matching
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)
 
       struct dwarf2_per_cu_data *per_cu;
       while ((per_cu = iter.next ()) != NULL)

-       dw2_expand_symtabs_matching_one (per_cu, file_matcher,
-                                        expansion_notify);
+       dw2_expand_symtabs_matching_one (per_cu, dwarf2_per_objfile,
+                                        file_matcher, expansion_notify);

       return true;
     });
 }
       return true;
     });
 }


@@ -5794,7 +5856,7 @@ const struct quick_symbol_functions dwarf2_debug_names_functions =
 };
 
 /* Get the content of the .gdb_index section of OBJ.  SECTION_OWNER should point
 };
 
 /* Get the content of the .gdb_index section of OBJ.  SECTION_OWNER should point

-   to either a dwarf2_per_objfile or dwz_file object.  */
+   to either a dwarf2_per_bfd or dwz_file object.  */

 
 template <typename T>
 static gdb::array_view<const gdb_byte>
 
 template <typename T>
 static gdb::array_view<const gdb_byte>


@@ -5825,14 +5887,14 @@ get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
    DWARF2_OBJ.  */
 
 static gdb::array_view<const gdb_byte>
    DWARF2_OBJ.  */
 
 static gdb::array_view<const gdb_byte>

-get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
+get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_bfd *dwarf2_per_bfd)

 {
   const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
   if (build_id == nullptr)
     return {};
 
   return global_index_cache.lookup_gdb_index (build_id,
 {
   const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
   if (build_id == nullptr)
     return {};
 
   return global_index_cache.lookup_gdb_index (build_id,

-                                             &dwarf2_obj->index_cache_res);
+                                             &dwarf2_per_bfd->index_cache_res);

 }
 
 /* Same as the above, but for DWZ.  */
 }
 
 /* Same as the above, but for DWZ.  */


@@ -5861,19 +5923,20 @@ dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
      expanded anyway.  */
   if ((objfile->flags & OBJF_READNOW))
     {
      expanded anyway.  */
   if ((objfile->flags & OBJF_READNOW))
     {

-      dwarf2_per_objfile->using_index = 1;
+      dwarf2_per_objfile->per_bfd->using_index = 1;

       create_all_comp_units (dwarf2_per_objfile);
       create_all_type_units (dwarf2_per_objfile);
       create_all_comp_units (dwarf2_per_objfile);
       create_all_type_units (dwarf2_per_objfile);

-      dwarf2_per_objfile->quick_file_names_table
+      dwarf2_per_objfile->per_bfd->quick_file_names_table

        = create_quick_file_names_table
        = create_quick_file_names_table

-           (dwarf2_per_objfile->all_comp_units.size ());
+           (dwarf2_per_objfile->per_bfd->all_comp_units.size ());
+      dwarf2_per_objfile->resize_symtabs ();

 
 

-      for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
-                          + dwarf2_per_objfile->all_type_units.size ()); ++i)
+      for (int i = 0; i < (dwarf2_per_objfile->per_bfd->all_comp_units.size ()
+                          + dwarf2_per_objfile->per_bfd->all_type_units.size ()); ++i)

        {
        {

-         dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
+         dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->per_bfd->get_cutu (i);

 
 

-         per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+         per_cu->v.quick = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                                            struct dwarf2_per_cu_quick_data);
        }
 
                                            struct dwarf2_per_cu_quick_data);
        }
 


@@ -5887,14 +5950,16 @@ dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
   if (dwarf2_read_debug_names (dwarf2_per_objfile))
     {
       *index_kind = dw_index_kind::DEBUG_NAMES;
   if (dwarf2_read_debug_names (dwarf2_per_objfile))
     {
       *index_kind = dw_index_kind::DEBUG_NAMES;

+      dwarf2_per_objfile->resize_symtabs ();

       return true;
     }
 
   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
       return true;
     }
 
   if (dwarf2_read_gdb_index (dwarf2_per_objfile,

-                            get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
+                            get_gdb_index_contents_from_section<struct dwarf2_per_bfd>,

                             get_gdb_index_contents_from_section<dwz_file>))
     {
       *index_kind = dw_index_kind::GDB_INDEX;
                             get_gdb_index_contents_from_section<dwz_file>))
     {
       *index_kind = dw_index_kind::GDB_INDEX;

+      dwarf2_per_objfile->resize_symtabs ();

       return true;
     }
 
       return true;
     }
 


@@ -5905,6 +5970,7 @@ dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
     {
       global_index_cache.hit ();
       *index_kind = dw_index_kind::GDB_INDEX;
     {
       global_index_cache.hit ();
       *index_kind = dw_index_kind::GDB_INDEX;

+      dwarf2_per_objfile->resize_symtabs ();

       return true;
     }
 
       return true;
     }
 


@@ -5933,6 +5999,8 @@ dwarf2_build_psymtabs (struct objfile *objfile)
       dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
       psymtabs.keep ();
 
       dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
       psymtabs.keep ();
 

+      dwarf2_per_objfile->resize_symtabs ();
+

       /* (maybe) store an index in the cache.  */
       global_index_cache.store (dwarf2_per_objfile);
     }
       /* (maybe) store an index in the cache.  */
       global_index_cache.store (dwarf2_per_objfile);
     }


@@ -5973,12 +6041,12 @@ static struct dwarf2_section_info *
 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
 {
   struct dwarf2_section_info *abbrev;
 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
 {
   struct dwarf2_section_info *abbrev;

-  struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
+  dwarf2_per_bfd *per_bfd = this_cu->per_bfd;

 
   if (this_cu->is_dwz)
 
   if (this_cu->is_dwz)

-    abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
+    abbrev = &dwarf2_get_dwz_file (per_bfd)->abbrev;

   else
   else

-    abbrev = &dwarf2_per_objfile->abbrev;
+    abbrev = &per_bfd->abbrev;

 
   return abbrev;
 }
 
   return abbrev;
 }


@@ -6044,12 +6112,12 @@ struct dwarf2_include_psymtab : public partial_symtab
     gdb_assert (false);
   }
 
     gdb_assert (false);
   }
 

-  bool readin_p () const override
+  bool readin_p (struct objfile *objfile) const override

   {
   {

-    return includer ()->readin_p ();
+    return includer ()->readin_p (objfile);

   }
 
   }
 

-  struct compunit_symtab *get_compunit_symtab () const override
+  compunit_symtab *get_compunit_symtab (struct objfile *objfile) const override

   {
     return nullptr;
   }
   {
     return nullptr;
   }


@@ -6074,10 +6142,7 @@ dwarf2_create_include_psymtab (const char *name, dwarf2_psymtab *pst,
   dwarf2_include_psymtab *subpst = new dwarf2_include_psymtab (name, objfile);
 
   if (!IS_ABSOLUTE_PATH (subpst->filename))
   dwarf2_include_psymtab *subpst = new dwarf2_include_psymtab (name, objfile);
 
   if (!IS_ABSOLUTE_PATH (subpst->filename))

-    {
-      /* It shares objfile->objfile_obstack.  */
-      subpst->dirname = pst->dirname;
-    }
+    subpst->dirname = pst->dirname;

 
   subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
   subpst->dependencies[0] = pst;
 
   subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
   subpst->dependencies[0] = pst;


@@ -6171,7 +6236,7 @@ create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
 
   abbrev_section = (dwo_file != NULL
                    ? &dwo_file->sections.abbrev
 
   abbrev_section = (dwo_file != NULL
                    ? &dwo_file->sections.abbrev

-                   : &dwarf2_per_objfile->abbrev);
+                   : &dwarf2_per_objfile->per_bfd->abbrev);

 
   if (dwarf_read_debug)
     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
 
   if (dwarf_read_debug)
     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",


@@ -6235,7 +6300,7 @@ create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
       if (dwo_file)
        {
          sig_type = NULL;
       if (dwo_file)
        {
          sig_type = NULL;

-         dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+         dwo_tu = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                                   struct dwo_unit);
          dwo_tu->dwo_file = dwo_file;
          dwo_tu->signature = header.signature;
                                   struct dwo_unit);
          dwo_tu->dwo_file = dwo_file;
          dwo_tu->signature = header.signature;


@@ -6249,11 +6314,9 @@ create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
          /* N.B.: type_offset is not usable if this type uses a DWO file.
             The real type_offset is in the DWO file.  */
          dwo_tu = NULL;
          /* N.B.: type_offset is not usable if this type uses a DWO file.
             The real type_offset is in the DWO file.  */
          dwo_tu = NULL;

-         sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                                    struct signatured_type);
+         sig_type = dwarf2_per_objfile->per_bfd->allocate_signatured_type ();

          sig_type->signature = header.signature;
          sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
          sig_type->signature = header.signature;
          sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;

-         sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;

          sig_type->per_cu.is_debug_types = 1;
          sig_type->per_cu.section = section;
          sig_type->per_cu.sect_off = sect_off;
          sig_type->per_cu.is_debug_types = 1;
          sig_type->per_cu.section = section;
          sig_type->per_cu.sect_off = sect_off;


@@ -6330,30 +6393,30 @@ create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
   htab_up types_htab;
 
   create_debug_type_hash_table (dwarf2_per_objfile, NULL,
   htab_up types_htab;
 
   create_debug_type_hash_table (dwarf2_per_objfile, NULL,

-                               &dwarf2_per_objfile->info, types_htab,
+                               &dwarf2_per_objfile->per_bfd->info, types_htab,

                                rcuh_kind::COMPILE);
   create_debug_types_hash_table (dwarf2_per_objfile, NULL,
                                rcuh_kind::COMPILE);
   create_debug_types_hash_table (dwarf2_per_objfile, NULL,

-                                dwarf2_per_objfile->types, types_htab);
+                                dwarf2_per_objfile->per_bfd->types, types_htab);

   if (types_htab == NULL)
     {
   if (types_htab == NULL)
     {

-      dwarf2_per_objfile->signatured_types = NULL;
+      dwarf2_per_objfile->per_bfd->signatured_types = NULL;

       return 0;
     }
 
       return 0;
     }
 

-  dwarf2_per_objfile->signatured_types = std::move (types_htab);
+  dwarf2_per_objfile->per_bfd->signatured_types = std::move (types_htab);

 
 

-  gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
-  dwarf2_per_objfile->all_type_units.reserve
-    (htab_elements (dwarf2_per_objfile->signatured_types.get ()));
+  gdb_assert (dwarf2_per_objfile->per_bfd->all_type_units.empty ());
+  dwarf2_per_objfile->per_bfd->all_type_units.reserve
+    (htab_elements (dwarf2_per_objfile->per_bfd->signatured_types.get ()));

 
 

-  htab_traverse_noresize (dwarf2_per_objfile->signatured_types.get (),
+  htab_traverse_noresize (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                          add_signatured_type_cu_to_table,
                          add_signatured_type_cu_to_table,

-                         &dwarf2_per_objfile->all_type_units);
+                         &dwarf2_per_objfile->per_bfd->all_type_units);

 
   return 1;
 }
 
 
   return 1;
 }
 

-/* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
+/* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.

    If SLOT is non-NULL, it is the entry to use in the hash table.
    Otherwise we find one.  */
 
    If SLOT is non-NULL, it is the entry to use in the hash table.
    Otherwise we find one.  */
 


@@ -6361,28 +6424,27 @@ static struct signatured_type *
 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
               void **slot)
 {
 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
               void **slot)
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  if (dwarf2_per_objfile->per_bfd->all_type_units.size ()
+      == dwarf2_per_objfile->per_bfd->all_type_units.capacity ())
+    ++dwarf2_per_objfile->per_bfd->tu_stats.nr_all_type_units_reallocs;

 
 

-  if (dwarf2_per_objfile->all_type_units.size ()
-      == dwarf2_per_objfile->all_type_units.capacity ())
-    ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
+  signatured_type *sig_type = dwarf2_per_objfile->per_bfd->allocate_signatured_type ();

 
 

-  signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
-                                             struct signatured_type);
+  dwarf2_per_objfile->resize_symtabs ();

 
 

-  dwarf2_per_objfile->all_type_units.push_back (sig_type);
+  dwarf2_per_objfile->per_bfd->all_type_units.push_back (sig_type);

   sig_type->signature = sig;
   sig_type->per_cu.is_debug_types = 1;
   sig_type->signature = sig;
   sig_type->per_cu.is_debug_types = 1;

-  if (dwarf2_per_objfile->using_index)
+  if (dwarf2_per_objfile->per_bfd->using_index)

     {
       sig_type->per_cu.v.quick =
     {
       sig_type->per_cu.v.quick =

-       OBSTACK_ZALLOC (&objfile->objfile_obstack,
+       OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                        struct dwarf2_per_cu_quick_data);
     }
 
   if (slot == NULL)
     {
                        struct dwarf2_per_cu_quick_data);
     }
 
   if (slot == NULL)
     {

-      slot = htab_find_slot (dwarf2_per_objfile->signatured_types.get (),
+      slot = htab_find_slot (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                             sig_type, INSERT);
     }
   gdb_assert (*slot == NULL);
                             sig_type, INSERT);
     }
   gdb_assert (*slot == NULL);


@@ -6399,13 +6461,15 @@ fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
                                  struct signatured_type *sig_entry,
                                  struct dwo_unit *dwo_entry)
 {
                                  struct signatured_type *sig_entry,
                                  struct dwo_unit *dwo_entry)
 {

+  dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;
+

   /* Make sure we're not clobbering something we don't expect to.  */
   gdb_assert (! sig_entry->per_cu.queued);
   gdb_assert (sig_entry->per_cu.cu == NULL);
   /* Make sure we're not clobbering something we don't expect to.  */
   gdb_assert (! sig_entry->per_cu.queued);
   gdb_assert (sig_entry->per_cu.cu == NULL);

-  if (dwarf2_per_objfile->using_index)
+  if (per_bfd->using_index)

     {
       gdb_assert (sig_entry->per_cu.v.quick != NULL);
     {
       gdb_assert (sig_entry->per_cu.v.quick != NULL);

-      gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
+      gdb_assert (!dwarf2_per_objfile->symtab_set_p (&sig_entry->per_cu));

     }
   else
       gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
     }
   else
       gdb_assert (sig_entry->per_cu.v.psymtab == NULL);


@@ -6418,7 +6482,7 @@ fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
   sig_entry->per_cu.sect_off = dwo_entry->sect_off;
   sig_entry->per_cu.length = dwo_entry->length;
   sig_entry->per_cu.reading_dwo_directly = 1;
   sig_entry->per_cu.sect_off = dwo_entry->sect_off;
   sig_entry->per_cu.length = dwo_entry->length;
   sig_entry->per_cu.reading_dwo_directly = 1;

-  sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
+  sig_entry->per_cu.per_bfd = per_bfd;

   sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
   sig_entry->dwo_unit = dwo_entry;
 }
   sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
   sig_entry->dwo_unit = dwo_entry;
 }


@@ -6438,19 +6502,18 @@ fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
 static struct signatured_type *
 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {
 static struct signatured_type *
 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct dwo_file *dwo_file;
   struct dwo_unit find_dwo_entry, *dwo_entry;
   struct signatured_type find_sig_entry, *sig_entry;
   void **slot;
 
   struct dwo_file *dwo_file;
   struct dwo_unit find_dwo_entry, *dwo_entry;
   struct signatured_type find_sig_entry, *sig_entry;
   void **slot;
 

-  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
+  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->per_bfd->using_index);

 
   /* If TU skeletons have been removed then we may not have read in any
      TUs yet.  */
 
   /* If TU skeletons have been removed then we may not have read in any
      TUs yet.  */

-  if (dwarf2_per_objfile->signatured_types == NULL)
-    dwarf2_per_objfile->signatured_types = allocate_signatured_type_table ();
+  if (dwarf2_per_objfile->per_bfd->signatured_types == NULL)
+    dwarf2_per_objfile->per_bfd->signatured_types = allocate_signatured_type_table ();

 
   /* 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
 
   /* 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


@@ -6459,7 +6522,7 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
      .gdb_index with this TU.  */
 
   find_sig_entry.signature = sig;
      .gdb_index with this TU.  */
 
   find_sig_entry.signature = sig;

-  slot = htab_find_slot (dwarf2_per_objfile->signatured_types.get (),
+  slot = htab_find_slot (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                         &find_sig_entry, INSERT);
   sig_entry = (struct signatured_type *) *slot;
 
                         &find_sig_entry, INSERT);
   sig_entry = (struct signatured_type *) *slot;
 


@@ -6505,23 +6568,22 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 static struct signatured_type *
 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {
 static struct signatured_type *
 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
   struct dwo_unit *dwo_entry;
   struct signatured_type find_sig_entry, *sig_entry;
   void **slot;
 
   struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
   struct dwo_unit *dwo_entry;
   struct signatured_type find_sig_entry, *sig_entry;
   void **slot;
 

-  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
+  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->per_bfd->using_index);

   gdb_assert (dwp_file != NULL);
 
   /* If TU skeletons have been removed then we may not have read in any
      TUs yet.  */
   gdb_assert (dwp_file != NULL);
 
   /* If TU skeletons have been removed then we may not have read in any
      TUs yet.  */

-  if (dwarf2_per_objfile->signatured_types == NULL)
-    dwarf2_per_objfile->signatured_types = allocate_signatured_type_table ();
+  if (dwarf2_per_objfile->per_bfd->signatured_types == NULL)
+    dwarf2_per_objfile->per_bfd->signatured_types = allocate_signatured_type_table ();

 
   find_sig_entry.signature = sig;
 
   find_sig_entry.signature = sig;

-  slot = htab_find_slot (dwarf2_per_objfile->signatured_types.get (),
+  slot = htab_find_slot (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                         &find_sig_entry, INSERT);
   sig_entry = (struct signatured_type *) *slot;
 
                         &find_sig_entry, INSERT);
   sig_entry = (struct signatured_type *) *slot;
 


@@ -6551,11 +6613,10 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 static struct signatured_type *
 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {
 static struct signatured_type *
 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   if (cu->dwo_unit
 
   if (cu->dwo_unit

-      && dwarf2_per_objfile->using_index)
+      && dwarf2_per_objfile->per_bfd->using_index)

     {
       /* We're in a DWO/DWP file, and we're using .gdb_index.
         These cases require special processing.  */
     {
       /* We're in a DWO/DWP file, and we're using .gdb_index.
         These cases require special processing.  */


@@ -6568,11 +6629,11 @@ lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
     {
       struct signatured_type find_entry, *entry;
 
     {
       struct signatured_type find_entry, *entry;
 

-      if (dwarf2_per_objfile->signatured_types == NULL)
+      if (dwarf2_per_objfile->per_bfd->signatured_types == NULL)

        return NULL;
       find_entry.signature = sig;
       entry = ((struct signatured_type *)
        return NULL;
       find_entry.signature = sig;
       entry = ((struct signatured_type *)

-              htab_find (dwarf2_per_objfile->signatured_types.get (),
+              htab_find (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                          &find_entry));
       return entry;
     }
                          &find_entry));
       return entry;
     }


@@ -6619,7 +6680,7 @@ init_cu_die_reader (struct die_reader_specs *reader,
    The result is non-zero if a valid (non-dummy) DIE was found.  */
 
 static int
    The result is non-zero if a valid (non-dummy) DIE was found.  */
 
 static int

-read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
+read_cutu_die_from_dwo (dwarf2_cu *cu,

                        struct dwo_unit *dwo_unit,
                        struct die_info *stub_comp_unit_die,
                        const char *stub_comp_dir,
                        struct dwo_unit *dwo_unit,
                        struct die_info *stub_comp_unit_die,
                        const char *stub_comp_dir,


@@ -6628,9 +6689,9 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
                        struct die_info **result_comp_unit_die,
                        abbrev_table_up *result_dwo_abbrev_table)
 {
                        struct die_info **result_comp_unit_die,
                        abbrev_table_up *result_dwo_abbrev_table)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
+  dwarf2_per_cu_data *per_cu = cu->per_cu;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct objfile *objfile = dwarf2_per_objfile->objfile;

-  struct dwarf2_cu *cu = this_cu->cu;

   bfd *abfd;
   const gdb_byte *begin_info_ptr, *info_ptr;
   struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
   bfd *abfd;
   const gdb_byte *begin_info_ptr, *info_ptr;
   struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;


@@ -6659,7 +6720,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
     {
       /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
         DWO file.  */
     {
       /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
         DWO file.  */

-      if (! this_cu->is_debug_types)
+      if (!per_cu->is_debug_types)

        stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
       low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
       high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
        stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
       low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
       high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);


@@ -6692,9 +6753,9 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
                               + to_underlying (dwo_unit->sect_off));
   dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
 
                               + to_underlying (dwo_unit->sect_off));
   dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
 

-  if (this_cu->is_debug_types)
+  if (per_cu->is_debug_types)

     {
     {

-      struct signatured_type *sig_type = (struct signatured_type *) this_cu;
+      signatured_type *sig_type = (struct signatured_type *) per_cu;

 
       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
                                                &cu->header, section,
 
       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
                                                &cu->header, section,


@@ -6805,11 +6866,9 @@ lookup_dwo_id (struct dwarf2_cu *cu, struct die_info* comp_unit_die)
    Returns NULL if the specified DWO unit cannot be found.  */
 
 static struct dwo_unit *
    Returns NULL if the specified DWO unit cannot be found.  */
 
 static struct dwo_unit *

-lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
-                struct die_info *comp_unit_die,
-                const char *dwo_name)
+lookup_dwo_unit (dwarf2_cu *cu, die_info *comp_unit_die, const char *dwo_name)

 {
 {

-  struct dwarf2_cu *cu = this_cu->cu;
+  dwarf2_per_cu_data *per_cu = cu->per_cu;

   struct dwo_unit *dwo_unit;
   const char *comp_dir;
 
   struct dwo_unit *dwo_unit;
   const char *comp_dir;
 


@@ -6819,24 +6878,18 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
   dwo_name = dwarf2_dwo_name (comp_unit_die, cu);
   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
 
   dwo_name = dwarf2_dwo_name (comp_unit_die, cu);
   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
 

-  if (this_cu->is_debug_types)
-    {
-      struct signatured_type *sig_type;
-
-      /* Since this_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;
-      dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
-    }
+  if (per_cu->is_debug_types)
+    dwo_unit = lookup_dwo_type_unit (cu, dwo_name, comp_dir);

   else
     {
       gdb::optional<ULONGEST> signature = lookup_dwo_id (cu, comp_unit_die);
   else
     {
       gdb::optional<ULONGEST> signature = lookup_dwo_id (cu, comp_unit_die);

+

       if (!signature.has_value ())
        error (_("Dwarf Error: missing dwo_id for dwo_name %s"
                 " [in module %s]"),
       if (!signature.has_value ())
        error (_("Dwarf Error: missing dwo_id for dwo_name %s"
                 " [in module %s]"),

-              dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
-      dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
-                                      *signature);
+              dwo_name, bfd_get_filename (per_cu->per_bfd->obfd));
+
+      dwo_unit = lookup_dwo_comp_unit (cu, dwo_name, comp_dir, *signature);

     }
 
   return dwo_unit;
     }
 
   return dwo_unit;


@@ -6847,7 +6900,8 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
    Read a TU directly from a DWO file, bypassing the stub.  */
 
 void
    Read a TU directly from a DWO file, bypassing the stub.  */
 
 void

-cutu_reader::init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
+cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data *this_cu,
+                                       dwarf2_per_objfile *per_objfile,

                                        int use_existing_cu)
 {
   struct signatured_type *sig_type;
                                        int use_existing_cu)
 {
   struct signatured_type *sig_type;


@@ -6868,14 +6922,14 @@ cutu_reader::init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
     {
       /* If !use_existing_cu, this_cu->cu must be NULL.  */
       gdb_assert (this_cu->cu == NULL);
     {
       /* If !use_existing_cu, this_cu->cu must be NULL.  */
       gdb_assert (this_cu->cu == NULL);

-      m_new_cu.reset (new dwarf2_cu (this_cu));
+      m_new_cu.reset (new dwarf2_cu (this_cu, per_objfile));

     }
 
   /* A future optimization, if needed, would be to use an existing
      abbrev table.  When reading DWOs with skeletonless TUs, all the TUs
      could share abbrev tables.  */
 
     }
 
   /* A future optimization, if needed, would be to use an existing
      abbrev table.  When reading DWOs with skeletonless TUs, all the TUs
      could share abbrev tables.  */
 

-  if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
+  if (read_cutu_die_from_dwo (this_cu->cu, sig_type->dwo_unit,

                              NULL /* stub_comp_unit_die */,
                              sig_type->dwo_unit->dwo_file->comp_dir,
                              this, &info_ptr,
                              NULL /* stub_comp_unit_die */,
                              sig_type->dwo_unit->dwo_file->comp_dir,
                              this, &info_ptr,


@@ -6897,14 +6951,14 @@ cutu_reader::init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
    If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
    Otherwise, a new CU is allocated with xmalloc.  */
 
    If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
    Otherwise, a new CU is allocated with xmalloc.  */
 

-cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
+cutu_reader::cutu_reader (dwarf2_per_cu_data *this_cu,
+                         dwarf2_per_objfile *dwarf2_per_objfile,

                          struct abbrev_table *abbrev_table,
                          int use_existing_cu,
                          bool skip_partial)
   : die_reader_specs {},
     m_this_cu (this_cu)
 {
                          struct abbrev_table *abbrev_table,
                          int use_existing_cu,
                          bool skip_partial)
   : die_reader_specs {},
     m_this_cu (this_cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = this_cu->section;
   bfd *abfd = section->get_bfd_owner ();
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = this_cu->section;
   bfd *abfd = section->get_bfd_owner ();


@@ -6929,7 +6983,7 @@ cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
       /* Narrow down the scope of possibilities to have to understand.  */
       gdb_assert (this_cu->is_debug_types);
       gdb_assert (abbrev_table == NULL);
       /* Narrow down the scope of possibilities to have to understand.  */
       gdb_assert (this_cu->is_debug_types);
       gdb_assert (abbrev_table == NULL);

-      init_tu_and_read_dwo_dies (this_cu, use_existing_cu);
+      init_tu_and_read_dwo_dies (this_cu, dwarf2_per_objfile, use_existing_cu);

       return;
     }
 
       return;
     }
 


@@ -6956,7 +7010,7 @@ cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
     {
       /* If !use_existing_cu, this_cu->cu must be NULL.  */
       gdb_assert (this_cu->cu == NULL);
     {
       /* If !use_existing_cu, this_cu->cu must be NULL.  */
       gdb_assert (this_cu->cu == NULL);

-      m_new_cu.reset (new dwarf2_cu (this_cu));
+      m_new_cu.reset (new dwarf2_cu (this_cu, dwarf2_per_objfile));

       cu = m_new_cu.get ();
     }
 
       cu = m_new_cu.get ();
     }
 


@@ -7062,10 +7116,10 @@ cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
                     sect_offset_str (this_cu->sect_off),
                     bfd_get_filename (abfd));
        }
                     sect_offset_str (this_cu->sect_off),
                     bfd_get_filename (abfd));
        }

-      dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die, dwo_name);
+      dwo_unit = lookup_dwo_unit (cu, comp_unit_die, dwo_name);

       if (dwo_unit != NULL)
        {
       if (dwo_unit != NULL)
        {

-         if (read_cutu_die_from_dwo (this_cu, dwo_unit,
+         if (read_cutu_die_from_dwo (cu, dwo_unit,

                                      comp_unit_die, NULL,
                                      this, &info_ptr,
                                      &dwo_comp_unit_die,
                                      comp_unit_die, NULL,
                                      this, &info_ptr,
                                      &dwo_comp_unit_die,


@@ -7095,11 +7149,14 @@ cutu_reader::keep ()
   gdb_assert (!dummy_p);
   if (m_new_cu != NULL)
     {
   gdb_assert (!dummy_p);
   if (m_new_cu != NULL)
     {

-      struct dwarf2_per_objfile *dwarf2_per_objfile
-       = m_this_cu->dwarf2_per_objfile;
+      /* We know that m_this_cu->cu is set, since we are in the process of
+         parsing the CU.  */
+      gdb_assert (m_this_cu->cu != nullptr);
+      dwarf2_per_objfile *dwarf2_per_objfile = m_this_cu->cu->per_objfile;
+

       /* Link this CU into read_in_chain.  */
       /* Link this CU into read_in_chain.  */

-      m_this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
-      dwarf2_per_objfile->read_in_chain = m_this_cu;
+      m_this_cu->cu->read_in_chain = dwarf2_per_objfile->per_bfd->read_in_chain;
+      dwarf2_per_objfile->per_bfd->read_in_chain = m_this_cu;

       /* The chain owns it now.  */
       m_new_cu.release ();
     }
       /* The chain owns it now.  */
       m_new_cu.release ();
     }


@@ -7121,13 +7178,13 @@ cutu_reader::keep ()
    When parent_cu is passed, it is used to provide a default value for
    str_offsets_base and addr_base from the parent.  */
 
    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 (struct dwarf2_per_cu_data *this_cu,
+cutu_reader::cutu_reader (dwarf2_per_cu_data *this_cu,
+                         dwarf2_per_objfile *dwarf2_per_objfile,

                          struct dwarf2_cu *parent_cu,
                          struct dwo_file *dwo_file)
   : die_reader_specs {},
     m_this_cu (this_cu)
 {
                          struct dwarf2_cu *parent_cu,
                          struct dwo_file *dwo_file)
   : die_reader_specs {},
     m_this_cu (this_cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = this_cu->section;
   bfd *abfd = section->get_bfd_owner ();
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = this_cu->section;
   bfd *abfd = section->get_bfd_owner ();


@@ -7148,7 +7205,7 @@ cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
   /* This is cheap if the section is already read in.  */
   section->read (objfile);
 
   /* This is cheap if the section is already read in.  */
   section->read (objfile);
 

-  m_new_cu.reset (new dwarf2_cu (this_cu));
+  m_new_cu.reset (new dwarf2_cu (this_cu, dwarf2_per_objfile));

 
   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
   info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
 
   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
   info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,


@@ -7232,20 +7289,19 @@ allocate_type_unit_groups_table ()
 static struct type_unit_group *
 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
 {
 static struct type_unit_group *
 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
+  dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;

   struct dwarf2_per_cu_data *per_cu;
   struct type_unit_group *tu_group;
 
   struct dwarf2_per_cu_data *per_cu;
   struct type_unit_group *tu_group;
 

-  tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+  tu_group = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                             struct type_unit_group);
   per_cu = &tu_group->per_cu;
                             struct type_unit_group);
   per_cu = &tu_group->per_cu;

-  per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
+  per_cu->per_bfd = per_bfd;

 
 

-  if (dwarf2_per_objfile->using_index)
+  if (per_bfd->using_index)

     {
     {

-      per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+      per_cu->v.quick = OBSTACK_ZALLOC (&per_bfd->obstack,

                                        struct dwarf2_per_cu_quick_data);
     }
   else
                                        struct dwarf2_per_cu_quick_data);
     }
   else


@@ -7261,7 +7317,7 @@ create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
       else
        name = string_printf ("<type_units_at_0x%x>", line_offset);
 
       else
        name = string_printf ("<type_units_at_0x%x>", line_offset);
 

-      pst = create_partial_symtab (per_cu, name.c_str ());
+      pst = create_partial_symtab (per_cu, dwarf2_per_objfile, name.c_str ());

       pst->anonymous = true;
     }
 
       pst->anonymous = true;
     }
 


@@ -7277,16 +7333,15 @@ create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
 static struct type_unit_group *
 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
 {
 static struct type_unit_group *
 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
-  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
+  struct tu_stats *tu_stats = &dwarf2_per_objfile->per_bfd->tu_stats;

   struct type_unit_group *tu_group;
   void **slot;
   unsigned int line_offset;
   struct type_unit_group type_unit_group_for_lookup;
 
   struct type_unit_group *tu_group;
   void **slot;
   unsigned int line_offset;
   struct type_unit_group type_unit_group_for_lookup;
 

-  if (dwarf2_per_objfile->type_unit_groups == NULL)
-    dwarf2_per_objfile->type_unit_groups = allocate_type_unit_groups_table ();
+  if (dwarf2_per_objfile->per_bfd->type_unit_groups == NULL)
+    dwarf2_per_objfile->per_bfd->type_unit_groups = allocate_type_unit_groups_table ();

 
   /* Do we need to create a new group, or can we use an existing one?  */
 
 
   /* Do we need to create a new group, or can we use an existing one?  */
 


@@ -7310,7 +7365,7 @@ get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
 
   type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
   type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
 
   type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
   type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;

-  slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups.get (),
+  slot = htab_find_slot (dwarf2_per_objfile->per_bfd->type_unit_groups.get (),

                         &type_unit_group_for_lookup, INSERT);
   if (*slot != NULL)
     {
                         &type_unit_group_for_lookup, INSERT);
   if (*slot != NULL)
     {


@@ -7336,9 +7391,11 @@ get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
    dirname, textlow, texthigh.  */
 
 static dwarf2_psymtab *
    dirname, textlow, texthigh.  */
 
 static dwarf2_psymtab *

-create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
+create_partial_symtab (dwarf2_per_cu_data *per_cu,
+                      dwarf2_per_objfile *per_objfile,
+                      const char *name)

 {
 {

-  struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = per_objfile->objfile;

   dwarf2_psymtab *pst;
 
   pst = new dwarf2_psymtab (name, objfile, per_cu);
   dwarf2_psymtab *pst;
 
   pst = new dwarf2_psymtab (name, objfile, per_cu);


@@ -7360,7 +7417,8 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
                                  enum language pretend_language)
 {
   struct dwarf2_cu *cu = reader->cu;
                                  enum language pretend_language)
 {
   struct dwarf2_cu *cu = reader->cu;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
   CORE_ADDR baseaddr;
   struct gdbarch *gdbarch = objfile->arch ();
   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
   CORE_ADDR baseaddr;


@@ -7387,7 +7445,7 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
       filename = debug_filename.get ();
     }
 
       filename = debug_filename.get ();
     }
 

-  pst = create_partial_symtab (per_cu, filename);
+  pst = create_partial_symtab (per_cu, per_objfile, filename);

 
   /* This must be done before calling dwarf2_build_include_psymtabs.  */
   pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
 
   /* This must be done before calling dwarf2_build_include_psymtabs.  */
   pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);


@@ -7490,7 +7548,8 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
    Process compilation unit THIS_CU for a psymtab.  */
 
 static void
    Process compilation unit THIS_CU for a psymtab.  */
 
 static void

-process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
+process_psymtab_comp_unit (dwarf2_per_cu_data *this_cu,
+                          dwarf2_per_objfile *per_objfile,

                           bool want_partial_unit,
                           enum language pretend_language)
 {
                           bool want_partial_unit,
                           enum language pretend_language)
 {


@@ -7500,9 +7559,9 @@ process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
      read in the compilation unit (see load_partial_dies).
      This problem could be avoided, but the benefit is unclear.  */
   if (this_cu->cu != NULL)
      read in the compilation unit (see load_partial_dies).
      This problem could be avoided, but the benefit is unclear.  */
   if (this_cu->cu != NULL)

-    free_one_cached_comp_unit (this_cu);
+    free_one_cached_comp_unit (this_cu, per_objfile);

 
 

-  cutu_reader reader (this_cu, NULL, 0, false);
+  cutu_reader reader (this_cu, per_objfile, NULL, 0, false);

 
   switch (reader.comp_unit_die->tag)
     {
 
   switch (reader.comp_unit_die->tag)
     {


@@ -7532,7 +7591,7 @@ process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
   this_cu->lang = this_cu->cu->language;
 
   /* Age out any secondary CUs.  */
   this_cu->lang = this_cu->cu->language;
 
   /* Age out any secondary CUs.  */

-  age_cached_comp_units (this_cu->dwarf2_per_objfile);
+  age_cached_comp_units (per_objfile);

 }
 
 /* Reader function for build_type_psymtabs.  */
 }
 
 /* Reader function for build_type_psymtabs.  */


@@ -7542,8 +7601,7 @@ build_type_psymtabs_reader (const struct die_reader_specs *reader,
                            const gdb_byte *info_ptr,
                            struct die_info *type_unit_die)
 {
                            const gdb_byte *info_ptr,
                            struct die_info *type_unit_die)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = reader->cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = reader->cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_cu *cu = reader->cu;
   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_cu *cu = reader->cu;
   struct dwarf2_per_cu_data *per_cu = cu->per_cu;


@@ -7568,7 +7626,7 @@ build_type_psymtabs_reader (const struct die_reader_specs *reader,
   tu_group->tus->push_back (sig_type);
 
   prepare_one_comp_unit (cu, type_unit_die, language_minimal);
   tu_group->tus->push_back (sig_type);
 
   prepare_one_comp_unit (cu, type_unit_die, language_minimal);

-  pst = create_partial_symtab (per_cu, "");
+  pst = create_partial_symtab (per_cu, dwarf2_per_objfile, "");

   pst->anonymous = true;
 
   first_die = load_partial_dies (reader, info_ptr, 1);
   pst->anonymous = true;
 
   first_die = load_partial_dies (reader, info_ptr, 1);


@@ -7609,7 +7667,7 @@ sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
    sharing 8K abbrev tables.
 
    The main purpose of this function is to support building the
    sharing 8K abbrev tables.
 
    The main purpose of this function is to support building the

-   dwarf2_per_objfile->type_unit_groups table.
+   dwarf2_per_objfile->per_bfd->type_unit_groups table.

    TUs typically share the DW_AT_stmt_list of the CU they came from, so we
    can collapse the search space by grouping them by stmt_list.
    The savings can be significant, in the same program from above the 200K TUs
    TUs typically share the DW_AT_stmt_list of the CU they came from, so we
    can collapse the search space by grouping them by stmt_list.
    The savings can be significant, in the same program from above the 200K TUs


@@ -7617,19 +7675,19 @@ sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
 
    FUNC is expected to call get_type_unit_group, which will create the
    struct type_unit_group if necessary and add it to
 
    FUNC is expected to call get_type_unit_group, which will create the
    struct type_unit_group if necessary and add it to

-   dwarf2_per_objfile->type_unit_groups.  */
+   dwarf2_per_objfile->per_bfd->type_unit_groups.  */

 
 static void
 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 
 static void
 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
+  struct tu_stats *tu_stats = &dwarf2_per_objfile->per_bfd->tu_stats;

   abbrev_table_up abbrev_table;
   sect_offset abbrev_offset;
 
   /* It's up to the caller to not call us multiple times.  */
   abbrev_table_up abbrev_table;
   sect_offset abbrev_offset;
 
   /* It's up to the caller to not call us multiple times.  */

-  gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
+  gdb_assert (dwarf2_per_objfile->per_bfd->type_unit_groups == NULL);

 
 

-  if (dwarf2_per_objfile->all_type_units.empty ())
+  if (dwarf2_per_objfile->per_bfd->all_type_units.empty ())

     return;
 
   /* TUs typically share abbrev tables, and there can be way more TUs than
     return;
 
   /* TUs typically share abbrev tables, and there can be way more TUs than


@@ -7657,9 +7715,9 @@ build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
   /* Sort in a separate table to maintain the order of all_type_units
      for .gdb_index: TU indices directly index all_type_units.  */
   std::vector<tu_abbrev_offset> sorted_by_abbrev;
   /* Sort in a separate table to maintain the order of all_type_units
      for .gdb_index: TU indices directly index all_type_units.  */
   std::vector<tu_abbrev_offset> sorted_by_abbrev;

-  sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
+  sorted_by_abbrev.reserve (dwarf2_per_objfile->per_bfd->all_type_units.size ());

 
 

-  for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
+  for (signatured_type *sig_type : dwarf2_per_objfile->per_bfd->all_type_units)

     sorted_by_abbrev.emplace_back
       (sig_type, read_abbrev_offset (dwarf2_per_objfile,
                                     sig_type->per_cu.section,
     sorted_by_abbrev.emplace_back
       (sig_type, read_abbrev_offset (dwarf2_per_objfile,
                                     sig_type->per_cu.section,


@@ -7679,13 +7737,13 @@ build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
          abbrev_offset = tu.abbrev_offset;
          abbrev_table =
            abbrev_table::read (dwarf2_per_objfile->objfile,
          abbrev_offset = tu.abbrev_offset;
          abbrev_table =
            abbrev_table::read (dwarf2_per_objfile->objfile,

-                               &dwarf2_per_objfile->abbrev,
+                               &dwarf2_per_objfile->per_bfd->abbrev,

                                abbrev_offset);
          ++tu_stats->nr_uniq_abbrev_tables;
        }
 
                                abbrev_offset);
          ++tu_stats->nr_uniq_abbrev_tables;
        }
 

-      cutu_reader reader (&tu.sig_type->per_cu, abbrev_table.get (),
-                         0, false);
+      cutu_reader reader (&tu.sig_type->per_cu, dwarf2_per_objfile,
+                         abbrev_table.get (), 0, false);

       if (!reader.dummy_p)
        build_type_psymtabs_reader (&reader, reader.info_ptr,
                                    reader.comp_unit_die);
       if (!reader.dummy_p)
        build_type_psymtabs_reader (&reader, reader.info_ptr,
                                    reader.comp_unit_die);


@@ -7697,11 +7755,11 @@ build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
 static void
 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 static void
 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
+  struct tu_stats *tu_stats = &dwarf2_per_objfile->per_bfd->tu_stats;

 
   fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
   fprintf_unfiltered (gdb_stdlog, "  %zu TUs\n",
 
   fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
   fprintf_unfiltered (gdb_stdlog, "  %zu TUs\n",

-                     dwarf2_per_objfile->all_type_units.size ());
+                     dwarf2_per_objfile->per_bfd->all_type_units.size ());

   fprintf_unfiltered (gdb_stdlog, "  %d uniq abbrev tables\n",
                      tu_stats->nr_uniq_abbrev_tables);
   fprintf_unfiltered (gdb_stdlog, "  %d symtabs from stmt_list entries\n",
   fprintf_unfiltered (gdb_stdlog, "  %d uniq abbrev tables\n",
                      tu_stats->nr_uniq_abbrev_tables);
   fprintf_unfiltered (gdb_stdlog, "  %d symtabs from stmt_list entries\n",


@@ -7772,11 +7830,11 @@ process_skeletonless_type_unit (void **slot, void *info)
 
   /* If this TU doesn't exist in the global table, add it and read it in.  */
 
 
   /* If this TU doesn't exist in the global table, add it and read it in.  */
 

-  if (dwarf2_per_objfile->signatured_types == NULL)
-    dwarf2_per_objfile->signatured_types = allocate_signatured_type_table ();
+  if (dwarf2_per_objfile->per_bfd->signatured_types == NULL)
+    dwarf2_per_objfile->per_bfd->signatured_types = allocate_signatured_type_table ();

 
   find_entry.signature = dwo_unit->signature;
 
   find_entry.signature = dwo_unit->signature;

-  slot = htab_find_slot (dwarf2_per_objfile->signatured_types.get (),
+  slot = htab_find_slot (dwarf2_per_objfile->per_bfd->signatured_types.get (),

                         &find_entry, INSERT);
   /* If we've already seen this type there's nothing to do.  What's happening
      is we're doing our own version of comdat-folding here.  */
                         &find_entry, INSERT);
   /* If we've already seen this type there's nothing to do.  What's happening
      is we're doing our own version of comdat-folding here.  */


@@ -7790,7 +7848,7 @@ process_skeletonless_type_unit (void **slot, void *info)
   *slot = entry;
 
   /* This does the job that build_type_psymtabs_1 would have done.  */
   *slot = entry;
 
   /* This does the job that build_type_psymtabs_1 would have done.  */

-  cutu_reader reader (&entry->per_cu, NULL, 0, false);
+  cutu_reader reader (&entry->per_cu, dwarf2_per_objfile, NULL, 0, false);

   if (!reader.dummy_p)
     build_type_psymtabs_reader (&reader, reader.info_ptr,
                                reader.comp_unit_die);
   if (!reader.dummy_p)
     build_type_psymtabs_reader (&reader, reader.info_ptr,
                                reader.comp_unit_die);


@@ -7821,9 +7879,9 @@ process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
   if (get_dwp_file (dwarf2_per_objfile) == NULL
 {
   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
   if (get_dwp_file (dwarf2_per_objfile) == NULL

-      && dwarf2_per_objfile->dwo_files != NULL)
+      && dwarf2_per_objfile->per_bfd->dwo_files != NULL)

     {
     {

-      htab_traverse_noresize (dwarf2_per_objfile->dwo_files.get (),
+      htab_traverse_noresize (dwarf2_per_objfile->per_bfd->dwo_files.get (),

                              process_dwo_file_for_skeletonless_type_units,
                              dwarf2_per_objfile);
     }
                              process_dwo_file_for_skeletonless_type_units,
                              dwarf2_per_objfile);
     }


@@ -7834,7 +7892,7 @@ process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 static void
 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 static void
 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       dwarf2_psymtab *pst = per_cu->v.psymtab;
 
     {
       dwarf2_psymtab *pst = per_cu->v.psymtab;
 


@@ -7865,10 +7923,10 @@ dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
     }
 
   scoped_restore restore_reading_psyms
     }
 
   scoped_restore restore_reading_psyms

-    = make_scoped_restore (&dwarf2_per_objfile->reading_partial_symbols,
+    = make_scoped_restore (&dwarf2_per_objfile->per_bfd->reading_partial_symbols,

                           true);
 
                           true);
 

-  dwarf2_per_objfile->info.read (objfile);
+  dwarf2_per_objfile->per_bfd->info.read (objfile);

 
   /* Any cached compilation units will be linked by the per-objfile
      read_in_chain.  Make sure to free them when we're done.  */
 
   /* Any cached compilation units will be linked by the per-objfile
      read_in_chain.  Make sure to free them when we're done.  */


@@ -7886,21 +7944,22 @@ dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
     = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
                           addrmap_create_mutable (&temp_obstack));
 
     = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
                           addrmap_create_mutable (&temp_obstack));
 

-  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+  for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->per_bfd->all_comp_units)

     {
       if (per_cu->v.psymtab != NULL)
        /* In case a forward DW_TAG_imported_unit has read the CU already.  */
        continue;
     {
       if (per_cu->v.psymtab != NULL)
        /* In case a forward DW_TAG_imported_unit has read the CU already.  */
        continue;

-      process_psymtab_comp_unit (per_cu, false, language_minimal);
+      process_psymtab_comp_unit (per_cu, dwarf2_per_objfile, false,
+                                language_minimal);

     }
 
   /* This has to wait until we read the CUs, we need the list of DWOs.  */
   process_skeletonless_type_units (dwarf2_per_objfile);
 
   /* Now that all TUs have been processed we can fill in the dependencies.  */
     }
 
   /* This has to wait until we read the CUs, we need the list of DWOs.  */
   process_skeletonless_type_units (dwarf2_per_objfile);
 
   /* Now that all TUs have been processed we can fill in the dependencies.  */

-  if (dwarf2_per_objfile->type_unit_groups != NULL)
+  if (dwarf2_per_objfile->per_bfd->type_unit_groups != NULL)

     {
     {

-      htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups.get (),
+      htab_traverse_noresize (dwarf2_per_objfile->per_bfd->type_unit_groups.get (),

                              build_type_psymtab_dependencies, dwarf2_per_objfile);
     }
 
                              build_type_psymtab_dependencies, dwarf2_per_objfile);
     }
 


@@ -7924,9 +7983,10 @@ dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
    This is also used when rereading a primary CU with load_all_dies.  */
 
 static void
    This is also used when rereading a primary CU with load_all_dies.  */
 
 static void

-load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
+load_partial_comp_unit (dwarf2_per_cu_data *this_cu,
+                       dwarf2_per_objfile *per_objfile)

 {
 {

-  cutu_reader reader (this_cu, NULL, 1, false);
+  cutu_reader reader (this_cu, per_objfile, NULL, 1, false);

 
   if (!reader.dummy_p)
     {
 
   if (!reader.dummy_p)
     {


@@ -7974,16 +8034,10 @@ read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
 
       /* Save the compilation unit for later lookup.  */
       if (cu_header.unit_type != DW_UT_type)
 
       /* Save the compilation unit for later lookup.  */
       if (cu_header.unit_type != DW_UT_type)

-       {
-         this_cu = XOBNEW (&objfile->objfile_obstack,
-                           struct dwarf2_per_cu_data);
-         memset (this_cu, 0, sizeof (*this_cu));
-       }
+       this_cu = dwarf2_per_objfile->per_bfd->allocate_per_cu ();

       else
        {
       else
        {

-         auto sig_type = XOBNEW (&objfile->objfile_obstack,
-                                 struct signatured_type);
-         memset (sig_type, 0, sizeof (*sig_type));
+         auto sig_type = dwarf2_per_objfile->per_bfd->allocate_signatured_type ();

          sig_type->signature = cu_header.signature;
          sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
          this_cu = &sig_type->per_cu;
          sig_type->signature = cu_header.signature;
          sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
          this_cu = &sig_type->per_cu;


@@ -7992,10 +8046,9 @@ read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
       this_cu->sect_off = sect_off;
       this_cu->length = cu_header.length + cu_header.initial_length_size;
       this_cu->is_dwz = is_dwz;
       this_cu->sect_off = sect_off;
       this_cu->length = cu_header.length + cu_header.initial_length_size;
       this_cu->is_dwz = is_dwz;

-      this_cu->dwarf2_per_objfile = dwarf2_per_objfile;

       this_cu->section = section;
 
       this_cu->section = section;
 

-      dwarf2_per_objfile->all_comp_units.push_back (this_cu);
+      dwarf2_per_objfile->per_bfd->all_comp_units.push_back (this_cu);

 
       info_ptr = info_ptr + this_cu->length;
     }
 
       info_ptr = info_ptr + this_cu->length;
     }


@@ -8007,11 +8060,11 @@ read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
 static void
 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 static void
 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
-  read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
-                               &dwarf2_per_objfile->abbrev, 0);
+  gdb_assert (dwarf2_per_objfile->per_bfd->all_comp_units.empty ());
+  read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->per_bfd->info,
+                               &dwarf2_per_objfile->per_bfd->abbrev, 0);

 
 

-  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+  dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);

   if (dwz != NULL)
     read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
                                  1);
   if (dwz != NULL)
     read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
                                  1);


@@ -8103,16 +8156,16 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
                  {
                    error (_("Dwarf Error: DW_TAG_imported_unit is not"
                             " supported in type units [in module %s]"),
                  {
                    error (_("Dwarf Error: DW_TAG_imported_unit is not"
                             " supported in type units [in module %s]"),

-                          objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                          objfile_name (cu->per_objfile->objfile));

                  }
 
                per_cu = dwarf2_find_containing_comp_unit
                  }
 
                per_cu = dwarf2_find_containing_comp_unit

-                          (pdi->d.sect_off, pdi->is_dwz,
-                           cu->per_cu->dwarf2_per_objfile);
+                          (pdi->d.sect_off, pdi->is_dwz, cu->per_objfile);

 
                /* Go read the partial unit, if needed.  */
                if (per_cu->v.psymtab == NULL)
 
                /* Go read the partial unit, if needed.  */
                if (per_cu->v.psymtab == NULL)

-                 process_psymtab_comp_unit (per_cu, true, cu->language);
+                 process_psymtab_comp_unit (per_cu, cu->per_objfile, true,
+                                            cu->language);

 
                cu->per_cu->imported_symtabs_push (per_cu);
              }
 
                cu->per_cu->imported_symtabs_push (per_cu);
              }


@@ -8278,8 +8331,7 @@ partial_die_full_name (struct partial_die_info *pdi,
 static void
 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
 {
 static void
 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR addr = 0;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR addr = 0;


@@ -8347,7 +8399,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
 
       if (pdi->d.locdesc
          && addr == 0
 
       if (pdi->d.locdesc
          && addr == 0

-         && !dwarf2_per_objfile->has_section_at_zero)
+         && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

        {
          /* A global or static variable may also have been stripped
             out by the linker if unused, in which case its address
        {
          /* A global or static variable may also have been stripped
             out by the linker if unused, in which case its address


@@ -8529,7 +8581,7 @@ add_partial_subprogram (struct partial_die_info *pdi,
             *highpc = pdi->highpc;
          if (set_addrmap)
            {
             *highpc = pdi->highpc;
          if (set_addrmap)
            {

-             struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+             struct objfile *objfile = cu->per_objfile->objfile;

              struct gdbarch *gdbarch = objfile->arch ();
              CORE_ADDR baseaddr;
              CORE_ADDR this_highpc;
              struct gdbarch *gdbarch = objfile->arch ();
              CORE_ADDR baseaddr;
              CORE_ADDR this_highpc;


@@ -8623,7 +8675,7 @@ peek_die_abbrev (const die_reader_specs &reader,
                 const gdb_byte *info_ptr, unsigned int *bytes_read)
 {
   dwarf2_cu *cu = reader.cu;
                 const gdb_byte *info_ptr, unsigned int *bytes_read)
 {
   dwarf2_cu *cu = reader.cu;

-  bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
+  bfd *abfd = cu->per_objfile->objfile->obfd;

   unsigned int abbrev_number
     = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
 
   unsigned int abbrev_number
     = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
 


@@ -8839,7 +8891,8 @@ dwarf2_psymtab::read_symtab (struct objfile *objfile)
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 
   struct dwarf2_per_objfile *dwarf2_per_objfile
     = get_dwarf2_per_objfile (objfile);
 

-  gdb_assert (!readin);
+  gdb_assert (!dwarf2_per_objfile->symtab_set_p (per_cu_data));
+

   /* If this psymtab is constructed from a debug-only objfile, the
      has_section_at_zero flag will not necessarily be correct.  We
      can get the correct value for this flag by looking at the data
   /* If this psymtab is constructed from a debug-only objfile, the
      has_section_at_zero flag will not necessarily be correct.  We
      can get the correct value for this flag by looking at the data


@@ -8849,8 +8902,8 @@ dwarf2_psymtab::read_symtab (struct objfile *objfile)
       struct dwarf2_per_objfile *dpo_backlink
        = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
 
       struct dwarf2_per_objfile *dpo_backlink
        = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
 

-      dwarf2_per_objfile->has_section_at_zero
-       = dpo_backlink->has_section_at_zero;
+      dwarf2_per_objfile->per_bfd->has_section_at_zero
+       = dpo_backlink->per_bfd->has_section_at_zero;

     }
 
   expand_psymtab (objfile);
     }
 
   expand_psymtab (objfile);


@@ -8863,11 +8916,12 @@ dwarf2_psymtab::read_symtab (struct objfile *objfile)
 /* Add PER_CU to the queue.  */
 
 static void
 /* Add PER_CU to the queue.  */
 
 static void

-queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
+queue_comp_unit (dwarf2_per_cu_data *per_cu,
+                dwarf2_per_objfile *per_objfile,

                 enum language pretend_language)
 {
   per_cu->queued = 1;
                 enum language pretend_language)
 {
   per_cu->queued = 1;

-  per_cu->dwarf2_per_objfile->queue.emplace (per_cu, pretend_language);
+  per_cu->per_bfd->queue.emplace (per_cu, per_objfile, pretend_language);

 }
 
 /* If PER_CU is not yet queued, add it to the queue.
 }
 
 /* If PER_CU is not yet queued, add it to the queue.


@@ -8881,13 +8935,14 @@ queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
 
 static int
 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
 
 static int
 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,

-                      struct dwarf2_per_cu_data *per_cu,
+                      dwarf2_per_cu_data *per_cu,
+                      dwarf2_per_objfile *per_objfile,

                       enum language pretend_language)
 {
   /* We may arrive here during partial symbol reading, if we need full
      DIEs to process an unusual case (e.g. template arguments).  Do
      not queue PER_CU, just tell our caller to load its DIEs.  */
                       enum language pretend_language)
 {
   /* We may arrive here during partial symbol reading, if we need full
      DIEs to process an unusual case (e.g. template arguments).  Do
      not queue PER_CU, just tell our caller to load its DIEs.  */

-  if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
+  if (per_cu->per_bfd->reading_partial_symbols)

     {
       if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
        return 1;
     {
       if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
        return 1;


@@ -8912,7 +8967,7 @@ maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
     }
 
   /* Add it to the queue.  */
     }
 
   /* Add it to the queue.  */

-  queue_comp_unit (per_cu, pretend_language);
+  queue_comp_unit (per_cu, per_objfile,  pretend_language);

 
   return 1;
 }
 
   return 1;
 }


@@ -8931,13 +8986,11 @@ process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
 
   /* The queue starts out with one item, but following a DIE reference
      may load a new CU, adding it to the end of the queue.  */
 
   /* The queue starts out with one item, but following a DIE reference
      may load a new CU, adding it to the end of the queue.  */

-  while (!dwarf2_per_objfile->queue.empty ())
+  while (!dwarf2_per_objfile->per_bfd->queue.empty ())

     {
     {

-      dwarf2_queue_item &item = dwarf2_per_objfile->queue.front ();
+      dwarf2_queue_item &item = dwarf2_per_objfile->per_bfd->queue.front ();

 
 

-      if ((dwarf2_per_objfile->using_index
-          ? !item.per_cu->v.quick->compunit_symtab
-          : (item.per_cu->v.psymtab && !item.per_cu->v.psymtab->readin))
+      if (!dwarf2_per_objfile->symtab_set_p (item.per_cu)

          /* Skip dummy CUs.  */
          && item.per_cu->cu != NULL)
        {
          /* Skip dummy CUs.  */
          && item.per_cu->cu != NULL)
        {


@@ -8968,16 +9021,16 @@ process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
            fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
 
          if (per_cu->is_debug_types)
            fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
 
          if (per_cu->is_debug_types)

-           process_full_type_unit (per_cu, item.pretend_language);
+           process_full_type_unit (per_cu->cu, item.pretend_language);

          else
          else

-           process_full_comp_unit (per_cu, item.pretend_language);
+           process_full_comp_unit (per_cu->cu, item.pretend_language);

 
          if (dwarf_read_debug >= debug_print_threshold)
            fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
        }
 
       item.per_cu->queued = 0;
 
          if (dwarf_read_debug >= debug_print_threshold)
            fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
        }
 
       item.per_cu->queued = 0;

-      dwarf2_per_objfile->queue.pop ();
+      dwarf2_per_objfile->per_bfd->queue.pop ();

     }
 
   if (dwarf_read_debug)
     }
 
   if (dwarf_read_debug)


@@ -8992,12 +9045,31 @@ process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
 void
 dwarf2_psymtab::expand_psymtab (struct objfile *objfile)
 {
 void
 dwarf2_psymtab::expand_psymtab (struct objfile *objfile)
 {

-  gdb_assert (!readin);
+  gdb_assert (!readin_p (objfile));

 
   expand_dependencies (objfile);
 
 
   expand_dependencies (objfile);
 

-  dw2_do_instantiate_symtab (per_cu_data, false);
-  gdb_assert (get_compunit_symtab () != nullptr);
+  dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
+  dw2_do_instantiate_symtab (per_cu_data, per_objfile, false);
+  gdb_assert (get_compunit_symtab (objfile) != nullptr);
+}
+
+/* See psympriv.h.  */
+
+bool
+dwarf2_psymtab::readin_p (struct objfile *objfile) const
+{
+  dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
+  return per_objfile->symtab_set_p (per_cu_data);
+}
+
+/* See psympriv.h.  */
+
+compunit_symtab *
+dwarf2_psymtab::get_compunit_symtab (struct objfile *objfile) const
+{
+  dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
+  return per_objfile->get_symtab (per_cu_data);

 }
 
 /* Trivial hash function for die_info: the hash value of a DIE
 }
 
 /* Trivial hash function for die_info: the hash value of a DIE


@@ -9026,13 +9098,14 @@ die_eq (const void *item_lhs, const void *item_rhs)
 /* Load the DIEs associated with PER_CU into memory.  */
 
 static void
 /* Load the DIEs associated with PER_CU into memory.  */
 
 static void

-load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
+load_full_comp_unit (dwarf2_per_cu_data *this_cu,
+                    dwarf2_per_objfile *per_objfile,

                     bool skip_partial,
                     enum language pretend_language)
 {
   gdb_assert (! this_cu->is_debug_types);
 
                     bool skip_partial,
                     enum language pretend_language)
 {
   gdb_assert (! this_cu->is_debug_types);
 

-  cutu_reader reader (this_cu, NULL, 1, skip_partial);
+  cutu_reader reader (this_cu, per_objfile, NULL, 1, skip_partial);

   if (reader.dummy_p)
     return;
 
   if (reader.dummy_p)
     return;
 


@@ -9186,8 +9259,7 @@ fixup_go_packaging (struct dwarf2_cu *cu)
                package_name = std::move (this_package_name);
              else
                {
                package_name = std::move (this_package_name);
              else
                {

-                 struct objfile *objfile
-                   = cu->per_cu->dwarf2_per_objfile->objfile;
+                 struct objfile *objfile = cu->per_objfile->objfile;

                  if (strcmp (package_name.get (), this_package_name.get ()) != 0)
                    complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
                               (symbol_symtab (sym) != NULL
                  if (strcmp (package_name.get (), this_package_name.get ()) != 0)
                    complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
                               (symbol_symtab (sym) != NULL


@@ -9202,7 +9274,7 @@ fixup_go_packaging (struct dwarf2_cu *cu)
 
   if (package_name != NULL)
     {
 
   if (package_name != NULL)
     {

-      struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+      struct objfile *objfile = cu->per_objfile->objfile;

       const char *saved_package_name = objfile->intern (package_name.get ());
       struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
                                     saved_package_name);
       const char *saved_package_name = objfile->intern (package_name.get ());
       struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
                                     saved_package_name);


@@ -9364,19 +9436,19 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
       type->set_code (TYPE_CODE_STRUCT);
       type->set_num_fields (3);
       /* Save the field we care about.  */
       type->set_code (TYPE_CODE_STRUCT);
       type->set_num_fields (3);
       /* Save the field we care about.  */

-      struct field saved_field = TYPE_FIELD (type, 0);
-      TYPE_FIELDS (type)
-       = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
+      struct field saved_field = type->field (0);
+      type->set_fields
+       ((struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field)));

 
       /* Put the discriminant at index 0.  */
       TYPE_FIELD_TYPE (type, 0) = field_type;
       TYPE_FIELD_ARTIFICIAL (type, 0) = 1;
       TYPE_FIELD_NAME (type, 0) = "<<discriminant>>";
 
       /* Put the discriminant at index 0.  */
       TYPE_FIELD_TYPE (type, 0) = field_type;
       TYPE_FIELD_ARTIFICIAL (type, 0) = 1;
       TYPE_FIELD_NAME (type, 0) = "<<discriminant>>";

-      SET_FIELD_BITPOS (TYPE_FIELD (type, 0), bit_offset);
+      SET_FIELD_BITPOS (type->field (0), bit_offset);

 
       /* The order of fields doesn't really matter, so put the real
         field at index 1 and the data-less field at index 2.  */
 
       /* The order of fields doesn't really matter, so put the real
         field at index 1 and the data-less field at index 2.  */

-      TYPE_FIELD (type, 1) = saved_field;
+      type->field (1) = saved_field;

       TYPE_FIELD_NAME (type, 1)
        = rust_last_path_segment (TYPE_FIELD_TYPE (type, 1)->name ());
       TYPE_FIELD_TYPE (type, 1)->set_name
       TYPE_FIELD_NAME (type, 1)
        = rust_last_path_segment (TYPE_FIELD_TYPE (type, 1)->name ());
       TYPE_FIELD_TYPE (type, 1)->set_name


@@ -9392,7 +9464,7 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
       /* NAME points into the original discriminant name, which
         already has the correct lifetime.  */
       TYPE_FIELD_NAME (type, 2) = name;
       /* NAME points into the original discriminant name, which
         already has the correct lifetime.  */
       TYPE_FIELD_NAME (type, 2) = name;

-      SET_FIELD_BITPOS (TYPE_FIELD (type, 2), 0);
+      SET_FIELD_BITPOS (type->field (2), 0);

 
       /* Indicate that this is a variant type.  */
       static discriminant_range ranges[1] = { { 0, 0 } };
 
       /* Indicate that this is a variant type.  */
       static discriminant_range ranges[1] = { { 0, 0 } };


@@ -9454,17 +9526,17 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
       type->set_code (TYPE_CODE_STRUCT);
 
       /* Make space for the discriminant field.  */
       type->set_code (TYPE_CODE_STRUCT);
 
       /* Make space for the discriminant field.  */

-      struct field *disr_field = &TYPE_FIELD (disr_type, 0);
+      struct field *disr_field = &disr_type->field (0);

       field *new_fields
        = (struct field *) TYPE_ZALLOC (type, ((type->num_fields () + 1)
                                               * sizeof (struct field)));
       field *new_fields
        = (struct field *) TYPE_ZALLOC (type, ((type->num_fields () + 1)
                                               * sizeof (struct field)));

-      memcpy (new_fields + 1, TYPE_FIELDS (type),
+      memcpy (new_fields + 1, type->fields (),

              type->num_fields () * sizeof (struct field));
              type->num_fields () * sizeof (struct field));

-      TYPE_FIELDS (type) = new_fields;
+      type->set_fields (new_fields);

       type->set_num_fields (type->num_fields () + 1);
 
       /* Install the discriminant at index 0 in the union.  */
       type->set_num_fields (type->num_fields () + 1);
 
       /* Install the discriminant at index 0 in the union.  */

-      TYPE_FIELD (type, 0) = *disr_field;
+      type->field (0) = *disr_field;

       TYPE_FIELD_ARTIFICIAL (type, 0) = 1;
       TYPE_FIELD_NAME (type, 0) = "<<discriminant>>";
 
       TYPE_FIELD_ARTIFICIAL (type, 0) = 1;
       TYPE_FIELD_NAME (type, 0) = "<<discriminant>>";
 


@@ -9510,7 +9582,7 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
          if (sub_type->num_fields () > 0)
            {
              sub_type->set_num_fields (sub_type->num_fields () - 1);
          if (sub_type->num_fields () > 0)
            {
              sub_type->set_num_fields (sub_type->num_fields () - 1);

-             ++TYPE_FIELDS (sub_type);
+             sub_type->set_fields (sub_type->fields () + 1);

            }
          TYPE_FIELD_NAME (type, i) = variant_name;
          sub_type->set_name
            }
          TYPE_FIELD_NAME (type, i) = variant_name;
          sub_type->set_name


@@ -9532,20 +9604,43 @@ rust_union_quirks (struct dwarf2_cu *cu)
 {
   gdb_assert (cu->language == language_rust);
   for (type *type_ : cu->rust_unions)
 {
   gdb_assert (cu->language == language_rust);
   for (type *type_ : cu->rust_unions)

-    quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
+    quirk_rust_enum (type_, cu->per_objfile->objfile);

   /* We don't need this any more.  */
   cu->rust_unions.clear ();
 }
 
   /* We don't need this any more.  */
   cu->rust_unions.clear ();
 }
 

-/* Return the symtab for PER_CU.  This works properly regardless of
-   whether we're using the index or psymtabs.  */
+/* See read.h.  */

 
 

-static struct compunit_symtab *
-get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
+type_unit_group_unshareable *
+dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group *tu_group)

 {
 {

-  return (per_cu->dwarf2_per_objfile->using_index
-         ? per_cu->v.quick->compunit_symtab
-         : per_cu->v.psymtab->compunit_symtab);
+  auto iter = this->m_type_units.find (tu_group);
+  if (iter != this->m_type_units.end ())
+    return iter->second.get ();
+
+  type_unit_group_unshareable_up uniq (new type_unit_group_unshareable);
+  type_unit_group_unshareable *result = uniq.get ();
+  this->m_type_units[tu_group] = std::move (uniq);
+  return result;
+}
+
+struct type *
+dwarf2_per_objfile::get_type_for_signatured_type
+  (signatured_type *sig_type) const
+{
+  auto iter = this->m_type_map.find (sig_type);
+  if (iter == this->m_type_map.end ())
+    return nullptr;
+
+  return iter->second;
+}
+
+void dwarf2_per_objfile::set_type_for_signatured_type
+  (signatured_type *sig_type, struct type *type)
+{
+  gdb_assert (this->m_type_map.find (sig_type) == this->m_type_map.end ());
+
+  this->m_type_map[sig_type] = type;

 }
 
 /* A helper function for computing the list of all symbol tables
 }
 
 /* A helper function for computing the list of all symbol tables


@@ -9554,13 +9649,11 @@ get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
 static void
 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
                                htab_t all_children, htab_t all_type_symtabs,
 static void
 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
                                htab_t all_children, htab_t all_type_symtabs,

-                               struct dwarf2_per_cu_data *per_cu,
+                               dwarf2_per_cu_data *per_cu,
+                               dwarf2_per_objfile *per_objfile,

                                struct compunit_symtab *immediate_parent)
 {
                                struct compunit_symtab *immediate_parent)
 {

-  void **slot;
-  struct compunit_symtab *cust;
-
-  slot = htab_find_slot (all_children, per_cu, INSERT);
+  void **slot = htab_find_slot (all_children, per_cu, INSERT);

   if (*slot != NULL)
     {
       /* This inclusion and its children have been processed.  */
   if (*slot != NULL)
     {
       /* This inclusion and its children have been processed.  */


@@ -9568,8 +9661,9 @@ recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
     }
 
   *slot = per_cu;
     }
 
   *slot = per_cu;

+

   /* Only add a CU if it has a symbol table.  */
   /* Only add a CU if it has a symbol table.  */

-  cust = get_compunit_symtab (per_cu);
+  compunit_symtab *cust = per_objfile->get_symtab (per_cu);

   if (cust != NULL)
     {
       /* If this is a type unit only add its symbol table if we haven't
   if (cust != NULL)
     {
       /* If this is a type unit only add its symbol table if we haven't


@@ -9597,7 +9691,8 @@ recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
     for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs)
       {
        recursively_compute_inclusions (result, all_children,
     for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs)
       {
        recursively_compute_inclusions (result, all_children,

-                                       all_type_symtabs, ptr, cust);
+                                       all_type_symtabs, ptr, per_objfile,
+                                       cust);

       }
 }
 
       }
 }
 


@@ -9605,7 +9700,8 @@ recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
    PER_CU.  */
 
 static void
    PER_CU.  */
 
 static void

-compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
+compute_compunit_symtab_includes (dwarf2_per_cu_data *per_cu,
+                                 dwarf2_per_objfile *per_objfile)

 {
   gdb_assert (! per_cu->is_debug_types);
 
 {
   gdb_assert (! per_cu->is_debug_types);
 


@@ -9614,7 +9710,7 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
       int len;
       std::vector<compunit_symtab *> result_symtabs;
       htab_t all_children, all_type_symtabs;
       int len;
       std::vector<compunit_symtab *> result_symtabs;
       htab_t all_children, all_type_symtabs;

-      struct compunit_symtab *cust = get_compunit_symtab (per_cu);
+      compunit_symtab *cust = per_objfile->get_symtab (per_cu);

 
       /* If we don't have a symtab, we can just skip this case.  */
       if (cust == NULL)
 
       /* If we don't have a symtab, we can just skip this case.  */
       if (cust == NULL)


@@ -9628,13 +9724,14 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
       for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs)
        {
          recursively_compute_inclusions (&result_symtabs, all_children,
       for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs)
        {
          recursively_compute_inclusions (&result_symtabs, all_children,

-                                         all_type_symtabs, ptr, cust);
+                                         all_type_symtabs, ptr, per_objfile,
+                                         cust);

        }
 
       /* Now we have a transitive closure of all the included symtabs.  */
       len = result_symtabs.size ();
       cust->includes
        }
 
       /* Now we have a transitive closure of all the included symtabs.  */
       len = result_symtabs.size ();
       cust->includes

-       = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
+       = XOBNEWVEC (&per_objfile->objfile->objfile_obstack,

                     struct compunit_symtab *, len + 1);
       memcpy (cust->includes, result_symtabs.data (),
              len * sizeof (compunit_symtab *));
                     struct compunit_symtab *, len + 1);
       memcpy (cust->includes, result_symtabs.data (),
              len * sizeof (compunit_symtab *));


@@ -9651,24 +9748,22 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
 static void
 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 static void
 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
+  for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->per_bfd->just_read_cus)

     {
       if (! iter->is_debug_types)
     {
       if (! iter->is_debug_types)

-       compute_compunit_symtab_includes (iter);
+       compute_compunit_symtab_includes (iter, dwarf2_per_objfile);

     }
 
     }
 

-  dwarf2_per_objfile->just_read_cus.clear ();
+  dwarf2_per_objfile->per_bfd->just_read_cus.clear ();

 }
 
 }
 

-/* Generate full symbol information for PER_CU, whose DIEs have
+/* Generate full symbol information for CU, whose DIEs have

    already been loaded into memory.  */
 
 static void
    already been loaded into memory.  */
 
 static void

-process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
-                       enum language pretend_language)
+process_full_comp_unit (dwarf2_cu *cu, enum language pretend_language)

 {
 {

-  struct dwarf2_cu *cu = per_cu->cu;
-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
+  dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc, highpc;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc, highpc;


@@ -9751,37 +9846,29 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
       cust->call_site_htab = cu->call_site_htab;
     }
 
       cust->call_site_htab = cu->call_site_htab;
     }
 

-  if (dwarf2_per_objfile->using_index)
-    per_cu->v.quick->compunit_symtab = cust;
-  else
-    {
-      dwarf2_psymtab *pst = per_cu->v.psymtab;
-      pst->compunit_symtab = cust;
-      pst->readin = true;
-    }
+  dwarf2_per_objfile->set_symtab (cu->per_cu, cust);

 
   /* Push it for inclusion processing later.  */
 
   /* Push it for inclusion processing later.  */

-  dwarf2_per_objfile->just_read_cus.push_back (per_cu);
+  dwarf2_per_objfile->per_bfd->just_read_cus.push_back (cu->per_cu);

 
   /* Not needed any more.  */
   cu->reset_builder ();
 }
 
 
   /* Not needed any more.  */
   cu->reset_builder ();
 }
 

-/* Generate full symbol information for type unit PER_CU, whose DIEs have
+/* Generate full symbol information for type unit CU, whose DIEs have

    already been loaded into memory.  */
 
 static void
    already been loaded into memory.  */
 
 static void

-process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
+process_full_type_unit (dwarf2_cu *cu,

                        enum language pretend_language)
 {
                        enum language pretend_language)
 {

-  struct dwarf2_cu *cu = per_cu->cu;
-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
+  dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct compunit_symtab *cust;
   struct signatured_type *sig_type;
 
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct compunit_symtab *cust;
   struct signatured_type *sig_type;
 

-  gdb_assert (per_cu->is_debug_types);
-  sig_type = (struct signatured_type *) per_cu;
+  gdb_assert (cu->per_cu->is_debug_types);
+  sig_type = (struct signatured_type *) cu->per_cu;

 
   /* Clear the list here in case something was left over.  */
   cu->method_list.clear ();
 
   /* Clear the list here in case something was left over.  */
   cu->method_list.clear ();


@@ -9808,11 +9895,13 @@ process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
      If this is the first TU to use this symtab, complete the construction
      of it with end_expandable_symtab.  Otherwise, complete the addition of
      this TU's symbols to the existing symtab.  */
      If this is the first TU to use this symtab, complete the construction
      of it with end_expandable_symtab.  Otherwise, complete the addition of
      this TU's symbols to the existing symtab.  */

-  if (sig_type->type_unit_group->compunit_symtab == NULL)
+  type_unit_group_unshareable *tug_unshare =
+    dwarf2_per_objfile->get_type_unit_group_unshareable (sig_type->type_unit_group);
+  if (tug_unshare->compunit_symtab == NULL)

     {
       buildsym_compunit *builder = cu->get_builder ();
       cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
     {
       buildsym_compunit *builder = cu->get_builder ();
       cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));

-      sig_type->type_unit_group->compunit_symtab = cust;
+      tug_unshare->compunit_symtab = cust;

 
       if (cust != NULL)
        {
 
       if (cust != NULL)
        {


@@ -9828,17 +9917,10 @@ process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
   else
     {
       cu->get_builder ()->augment_type_symtab ();
   else
     {
       cu->get_builder ()->augment_type_symtab ();

-      cust = sig_type->type_unit_group->compunit_symtab;
+      cust = tug_unshare->compunit_symtab;

     }
 
     }
 

-  if (dwarf2_per_objfile->using_index)
-    per_cu->v.quick->compunit_symtab = cust;
-  else
-    {
-      dwarf2_psymtab *pst = per_cu->v.psymtab;
-      pst->compunit_symtab = cust;
-      pst->readin = true;
-    }
+  dwarf2_per_objfile->set_symtab (cu->per_cu, cust);

 
   /* Not needed any more.  */
   cu->reset_builder ();
 
   /* Not needed any more.  */
   cu->reset_builder ();


@@ -9856,7 +9938,7 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
     {
       error (_("Dwarf Error: DW_TAG_imported_unit is not"
               " supported in type units [in module %s]"),
     {
       error (_("Dwarf Error: DW_TAG_imported_unit is not"
               " supported in type units [in module %s]"),

-            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+            objfile_name (cu->per_objfile->objfile));

     }
 
   attr = dwarf2_attr (die, DW_AT_import, cu);
     }
 
   attr = dwarf2_attr (die, DW_AT_import, cu);


@@ -9864,9 +9946,9 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
     {
       sect_offset sect_off = attr->get_ref_die_offset ();
       bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
     {
       sect_offset sect_off = attr->get_ref_die_offset ();
       bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);

+      dwarf2_per_objfile *per_objfile = cu->per_objfile;

       dwarf2_per_cu_data *per_cu
       dwarf2_per_cu_data *per_cu

-       = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
-                                           cu->per_cu->dwarf2_per_objfile);
+       = dwarf2_find_containing_comp_unit (sect_off, is_dwz, per_objfile);

 
       /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
         into another compilation unit, at root level.  Regard this as a hint,
 
       /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
         into another compilation unit, at root level.  Regard this as a hint,


@@ -9877,8 +9959,8 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
        return;
 
       /* If necessary, add it to the queue and load its DIEs.  */
        return;
 
       /* If necessary, add it to the queue and load its DIEs.  */

-      if (maybe_queue_comp_unit (cu, per_cu, cu->language))
-       load_full_comp_unit (per_cu, false, cu->language);
+      if (maybe_queue_comp_unit (cu, per_cu, per_objfile, cu->language))
+       load_full_comp_unit (per_cu, per_objfile, false, cu->language);

 
       cu->per_cu->imported_symtabs_push (per_cu);
     }
 
       cu->per_cu->imported_symtabs_push (per_cu);
     }


@@ -10136,14 +10218,15 @@ dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
    For Ada, return the DIE's linkage name rather than the fully qualified
    name.  PHYSNAME is ignored..
 
    For Ada, return the DIE's linkage name rather than the fully qualified
    name.  PHYSNAME is ignored..
 

-   The result is allocated on the objfile_obstack and canonicalized.  */
+   The result is allocated on the objfile->per_bfd's obstack and
+   canonicalized.  */

 
 static const char *
 dwarf2_compute_name (const char *name,
                     struct die_info *die, struct dwarf2_cu *cu,
                     int physname)
 {
 
 static const char *
 dwarf2_compute_name (const char *name,
                     struct die_info *die, struct dwarf2_cu *cu,
                     int physname)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

 
   if (name == NULL)
     name = dwarf2_name (die, cu);
 
   if (name == NULL)
     name = dwarf2_name (die, cu);


@@ -10283,7 +10366,8 @@ dwarf2_compute_name (const char *name,
                        v = dwarf2_evaluate_loc_desc (type, NULL,
                                                      baton->data,
                                                      baton->size,
                        v = dwarf2_evaluate_loc_desc (type, NULL,
                                                      baton->data,
                                                      baton->size,

-                                                     baton->per_cu);
+                                                     baton->per_cu,
+                                                     baton->per_objfile);

                      else if (bytes != NULL)
                        {
                          v = allocate_value (type);
                      else if (bytes != NULL)
                        {
                          v = allocate_value (type);


@@ -10386,7 +10470,7 @@ dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
 static const char *
 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
 {
 static const char *
 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const char *retval, *mangled = NULL, *canon = NULL;
   int need_copy = 1;
 
   const char *retval, *mangled = NULL, *canon = NULL;
   int need_copy = 1;
 


@@ -10518,7 +10602,7 @@ read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
          struct type *type;
          sect_offset sect_off = attr->get_ref_die_offset ();
 
          struct type *type;
          sect_offset sect_off = attr->get_ref_die_offset ();
 

-         type = get_die_type_at_offset (sect_off, cu->per_cu);
+         type = get_die_type_at_offset (sect_off, cu->per_cu, cu->per_objfile);

          if (type != NULL && type->code () == TYPE_CODE_NAMESPACE)
            {
              /* This declaration is a global namespace alias.  Add
          if (type != NULL && type->code () == TYPE_CODE_NAMESPACE)
            {
              /* This declaration is a global namespace alias.  Add


@@ -10556,7 +10640,7 @@ using_directives (struct dwarf2_cu *cu)
 static void
 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct attribute *import_attr;
   struct die_info *imported_die, *child_die;
   struct dwarf2_cu *imported_cu;
   struct attribute *import_attr;
   struct die_info *imported_die, *child_die;
   struct dwarf2_cu *imported_cu;


@@ -10776,8 +10860,7 @@ static void
 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
                        const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
 {
 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
                        const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct attribute *attr;
   struct line_header line_header_local;
   hashval_t line_header_local_hash;
   struct attribute *attr;
   struct line_header line_header_local;
   hashval_t line_header_local_hash;


@@ -10798,10 +10881,10 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
      compile_unit, then use the line header hash table if it's already
      created, but don't create one just yet.  */
 
      compile_unit, then use the line header hash table if it's already
      created, but don't create one just yet.  */
 

-  if (dwarf2_per_objfile->line_header_hash == NULL
+  if (dwarf2_per_objfile->per_bfd->line_header_hash == NULL

       && die->tag == DW_TAG_partial_unit)
     {
       && die->tag == DW_TAG_partial_unit)
     {

-      dwarf2_per_objfile->line_header_hash
+      dwarf2_per_objfile->per_bfd->line_header_hash

        .reset (htab_create_alloc (127, line_header_hash_voidp,
                                   line_header_eq_voidp,
                                   free_line_header_voidp,
        .reset (htab_create_alloc (127, line_header_hash_voidp,
                                   line_header_eq_voidp,
                                   free_line_header_voidp,


@@ -10811,9 +10894,9 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
   line_header_local.sect_off = line_offset;
   line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
   line_header_local_hash = line_header_hash (&line_header_local);
   line_header_local.sect_off = line_offset;
   line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
   line_header_local_hash = line_header_hash (&line_header_local);

-  if (dwarf2_per_objfile->line_header_hash != NULL)
+  if (dwarf2_per_objfile->per_bfd->line_header_hash != NULL)

     {
     {

-      slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash.get (),
+      slot = htab_find_slot_with_hash (dwarf2_per_objfile->per_bfd->line_header_hash.get (),

                                       &line_header_local,
                                       line_header_local_hash, NO_INSERT);
 
                                       &line_header_local,
                                       line_header_local_hash, NO_INSERT);
 


@@ -10837,11 +10920,11 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
   cu->line_header = lh.release ();
   cu->line_header_die_owner = die;
 
   cu->line_header = lh.release ();
   cu->line_header_die_owner = die;
 

-  if (dwarf2_per_objfile->line_header_hash == NULL)
+  if (dwarf2_per_objfile->per_bfd->line_header_hash == NULL)

     slot = NULL;
   else
     {
     slot = NULL;
   else
     {

-      slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash.get (),
+      slot = htab_find_slot_with_hash (dwarf2_per_objfile->per_bfd->line_header_hash.get (),

                                       &line_header_local,
                                       line_header_local_hash, INSERT);
       gdb_assert (slot != NULL);
                                       &line_header_local,
                                       line_header_local_hash, INSERT);
       gdb_assert (slot != NULL);


@@ -10873,8 +10956,7 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
 static void
 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc = ((CORE_ADDR) -1);
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc = ((CORE_ADDR) -1);


@@ -10974,7 +11056,9 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die)
      do it again, we could fake it and just recreate the part we need
      (file name,index -> symtab mapping).  If data shows this optimization
      is useful we can do it then.  */
      do it again, we could fake it and just recreate the part we need
      (file name,index -> symtab mapping).  If data shows this optimization
      is useful we can do it then.  */

-  first_time = tu_group->compunit_symtab == NULL;
+  type_unit_group_unshareable *tug_unshare
+    = per_objfile->get_type_unit_group_unshareable (tu_group);
+  first_time = tug_unshare->compunit_symtab == NULL;

 
   /* We have to handle the case of both a missing DW_AT_stmt_list or bad
      debug info.  */
 
   /* We have to handle the case of both a missing DW_AT_stmt_list or bad
      debug info.  */


@@ -10990,9 +11074,9 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die)
        start_symtab ("", NULL, 0);
       else
        {
        start_symtab ("", NULL, 0);
       else
        {

-         gdb_assert (tu_group->symtabs == NULL);
+         gdb_assert (tug_unshare->symtabs == NULL);

          gdb_assert (m_builder == nullptr);
          gdb_assert (m_builder == nullptr);

-         struct compunit_symtab *cust = tu_group->compunit_symtab;
+         struct compunit_symtab *cust = tug_unshare->compunit_symtab;

          m_builder.reset (new struct buildsym_compunit
                           (COMPUNIT_OBJFILE (cust), "",
                            COMPUNIT_DIRNAME (cust),
          m_builder.reset (new struct buildsym_compunit
                           (COMPUNIT_OBJFILE (cust), "",
                            COMPUNIT_DIRNAME (cust),


@@ -11015,7 +11099,7 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die)
         process_full_type_unit still needs to know if this is the first
         time.  */
 
         process_full_type_unit still needs to know if this is the first
         time.  */
 

-      tu_group->symtabs
+      tug_unshare->symtabs

        = XOBNEWVEC (&COMPUNIT_OBJFILE (cust)->objfile_obstack,
                     struct symtab *, line_header->file_names_size ());
 
        = XOBNEWVEC (&COMPUNIT_OBJFILE (cust)->objfile_obstack,
                     struct symtab *, line_header->file_names_size ());
 


@@ -11038,13 +11122,13 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die)
            }
 
          fe.symtab = b->get_current_subfile ()->symtab;
            }
 
          fe.symtab = b->get_current_subfile ()->symtab;

-         tu_group->symtabs[i] = fe.symtab;
+         tug_unshare->symtabs[i] = fe.symtab;

        }
     }
   else
     {
       gdb_assert (m_builder == nullptr);
        }
     }
   else
     {
       gdb_assert (m_builder == nullptr);

-      struct compunit_symtab *cust = tu_group->compunit_symtab;
+      struct compunit_symtab *cust = tug_unshare->compunit_symtab;

       m_builder.reset (new struct buildsym_compunit
                       (COMPUNIT_OBJFILE (cust), "",
                        COMPUNIT_DIRNAME (cust),
       m_builder.reset (new struct buildsym_compunit
                       (COMPUNIT_OBJFILE (cust), "",
                        COMPUNIT_DIRNAME (cust),


@@ -11056,7 +11140,7 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die)
       for (i = 0; i < file_names.size (); ++i)
        {
          file_entry &fe = file_names[i];
       for (i = 0; i < file_names.size (); ++i)
        {
          file_entry &fe = file_names[i];

-         fe.symtab = tu_group->symtabs[i];
+         fe.symtab = tug_unshare->symtabs[i];

        }
     }
 
        }
     }
 


@@ -11158,12 +11242,12 @@ lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
   struct dwo_file find_entry;
   void **slot;
 
   struct dwo_file find_entry;
   void **slot;
 

-  if (dwarf2_per_objfile->dwo_files == NULL)
-    dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
+  if (dwarf2_per_objfile->per_bfd->dwo_files == NULL)
+    dwarf2_per_objfile->per_bfd->dwo_files = allocate_dwo_file_hash_table ();

 
   find_entry.dwo_name = dwo_name;
   find_entry.comp_dir = comp_dir;
 
   find_entry.dwo_name = dwo_name;
   find_entry.comp_dir = comp_dir;

-  slot = htab_find_slot (dwarf2_per_objfile->dwo_files.get (), &find_entry,
+  slot = htab_find_slot (dwarf2_per_objfile->per_bfd->dwo_files.get (), &find_entry,

                         INSERT);
 
   return slot;
                         INSERT);
 
   return slot;


@@ -11248,6 +11332,7 @@ create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
                       dwarf2_section_info &section, htab_up &cus_htab)
 {
   struct objfile *objfile = dwarf2_per_objfile->objfile;
                       dwarf2_section_info &section, htab_up &cus_htab)
 {
   struct objfile *objfile = dwarf2_per_objfile->objfile;

+  dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;

   const gdb_byte *info_ptr, *end_ptr;
 
   section.read (objfile);
   const gdb_byte *info_ptr, *end_ptr;
 
   section.read (objfile);


@@ -11273,12 +11358,12 @@ create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
       sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
 
       memset (&per_cu, 0, sizeof (per_cu));
       sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
 
       memset (&per_cu, 0, sizeof (per_cu));

-      per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
+      per_cu.per_bfd = per_bfd;

       per_cu.is_debug_types = 0;
       per_cu.sect_off = sect_offset (info_ptr - section.buffer);
       per_cu.section = &section;
 
       per_cu.is_debug_types = 0;
       per_cu.sect_off = sect_offset (info_ptr - section.buffer);
       per_cu.section = &section;
 

-      cutu_reader reader (&per_cu, cu, &dwo_file);
+      cutu_reader reader (&per_cu, dwarf2_per_objfile, cu, &dwo_file);

       if (!reader.dummy_p)
        create_dwo_cu_reader (&reader, reader.info_ptr, reader.comp_unit_die,
                              &dwo_file, &read_unit);
       if (!reader.dummy_p)
        create_dwo_cu_reader (&reader, reader.info_ptr, reader.comp_unit_die,
                              &dwo_file, &read_unit);


@@ -11291,7 +11376,8 @@ create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
       if (cus_htab == NULL)
        cus_htab = allocate_dwo_unit_table ();
 
       if (cus_htab == NULL)
        cus_htab = allocate_dwo_unit_table ();
 

-      dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
+      dwo_unit = OBSTACK_ZALLOC (&per_bfd->obstack,
+                                struct dwo_unit);

       *dwo_unit = read_unit;
       slot = htab_find_slot (cus_htab.get (), dwo_unit, INSERT);
       gdb_assert (slot != NULL);
       *dwo_unit = read_unit;
       slot = htab_find_slot (cus_htab.get (), dwo_unit, INSERT);
       gdb_assert (slot != NULL);


@@ -11494,7 +11580,7 @@ create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
             pulongest (nr_slots), dwp_file->name);
     }
 
             pulongest (nr_slots), dwp_file->name);
     }
 

-  htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
+  htab = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack, struct dwp_hash_table);

   htab->version = version;
   htab->nr_columns = nr_columns;
   htab->nr_units = nr_units;
   htab->version = version;
   htab->nr_columns = nr_columns;
   htab->nr_units = nr_units;


@@ -11691,7 +11777,6 @@ create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
                           const char *comp_dir,
                           ULONGEST signature, int is_debug_types)
 {
                           const char *comp_dir,
                           ULONGEST signature, int is_debug_types)
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;

   const struct dwp_hash_table *dwp_htab =
     is_debug_types ? dwp_file->tus : dwp_file->cus;
   bfd *dbfd = dwp_file->dbfd.get ();
   const struct dwp_hash_table *dwp_htab =
     is_debug_types ? dwp_file->tus : dwp_file->cus;
   bfd *dbfd = dwp_file->dbfd.get ();


@@ -11796,7 +11881,7 @@ create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
                              virtual_dwo_name.c_str ());
        }
       dwo_file = new struct dwo_file;
                              virtual_dwo_name.c_str ());
        }
       dwo_file = new struct dwo_file;

-      dwo_file->dwo_name = objfile->intern (virtual_dwo_name);
+      dwo_file->dwo_name = dwarf2_per_objfile->objfile->intern (virtual_dwo_name);

       dwo_file->comp_dir = comp_dir;
       dwo_file->sections.abbrev = sections.abbrev;
       dwo_file->sections.line = sections.line;
       dwo_file->comp_dir = comp_dir;
       dwo_file->sections.abbrev = sections.abbrev;
       dwo_file->sections.line = sections.line;


@@ -11825,11 +11910,11 @@ create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
       dwo_file = (struct dwo_file *) *dwo_file_slot;
     }
 
       dwo_file = (struct dwo_file *) *dwo_file_slot;
     }
 

-  dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
+  dwo_unit = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack, struct dwo_unit);

   dwo_unit->dwo_file = dwo_file;
   dwo_unit->signature = signature;
   dwo_unit->section =
   dwo_unit->dwo_file = dwo_file;
   dwo_unit->signature = signature;
   dwo_unit->section =

-    XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
+    XOBNEW (&dwarf2_per_objfile->per_bfd->obstack, struct dwarf2_section_info);

   *dwo_unit->section = sections.info_or_types;
   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
 
   *dwo_unit->section = sections.info_or_types;
   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
 


@@ -11890,7 +11975,6 @@ create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
                           const char *comp_dir,
                           ULONGEST signature, int is_debug_types)
 {
                           const char *comp_dir,
                           ULONGEST signature, int is_debug_types)
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;

   const struct dwp_hash_table *dwp_htab =
     is_debug_types ? dwp_file->tus : dwp_file->cus;
   bfd *dbfd = dwp_file->dbfd.get ();
   const struct dwp_hash_table *dwp_htab =
     is_debug_types ? dwp_file->tus : dwp_file->cus;
   bfd *dbfd = dwp_file->dbfd.get ();


@@ -11991,7 +12075,7 @@ create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
                              virtual_dwo_name.c_str ());
        }
       dwo_file = new struct dwo_file;
                              virtual_dwo_name.c_str ());
        }
       dwo_file = new struct dwo_file;

-      dwo_file->dwo_name = objfile->intern (virtual_dwo_name);
+      dwo_file->dwo_name = dwarf2_per_objfile->objfile->intern (virtual_dwo_name);

       dwo_file->comp_dir = comp_dir;
       dwo_file->sections.abbrev =
        create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
       dwo_file->comp_dir = comp_dir;
       dwo_file->sections.abbrev =
        create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,


@@ -12034,11 +12118,11 @@ create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
       dwo_file = (struct dwo_file *) *dwo_file_slot;
     }
 
       dwo_file = (struct dwo_file *) *dwo_file_slot;
     }
 

-  dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
+  dwo_unit = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack, struct dwo_unit);

   dwo_unit->dwo_file = dwo_file;
   dwo_unit->signature = signature;
   dwo_unit->section =
   dwo_unit->dwo_file = dwo_file;
   dwo_unit->signature = signature;
   dwo_unit->section =

-    XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
+    XOBNEW (&dwarf2_per_objfile->per_bfd->obstack, struct dwarf2_section_info);

   *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
                                              is_debug_types
                                              ? &dwp_file->sections.types
   *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
                                              is_debug_types
                                              ? &dwp_file->sections.types


@@ -12296,10 +12380,10 @@ dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
    The result is NULL if DWO_NAME can't be found.  */
 
 static struct dwo_file *
    The result is NULL if DWO_NAME can't be found.  */
 
 static struct dwo_file *

-open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
-                       const char *dwo_name, const char *comp_dir)
+open_and_init_dwo_file (dwarf2_cu *cu, const char *dwo_name,
+                       const char *comp_dir)

 {
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   gdb_bfd_ref_ptr dbfd = open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir);
   if (dbfd == NULL)
 
   gdb_bfd_ref_ptr dbfd = open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir);
   if (dbfd == NULL)


@@ -12317,7 +12401,7 @@ open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
   bfd_map_over_sections (dwo_file->dbfd.get (), dwarf2_locate_dwo_sections,
                         &dwo_file->sections);
 
   bfd_map_over_sections (dwo_file->dbfd.get (), dwarf2_locate_dwo_sections,
                         &dwo_file->sections);
 

-  create_cus_hash_table (dwarf2_per_objfile, per_cu->cu, *dwo_file,
+  create_cus_hash_table (dwarf2_per_objfile, cu, *dwo_file,

                         dwo_file->sections.info, dwo_file->cus);
 
   create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
                         dwo_file->sections.info, dwo_file->cus);
 
   create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),


@@ -12544,7 +12628,7 @@ open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
 
   dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
   dwp_file->elf_sections =
 
   dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
   dwp_file->elf_sections =

-    OBSTACK_CALLOC (&objfile->objfile_obstack,
+    OBSTACK_CALLOC (&dwarf2_per_objfile->per_bfd->obstack,

                    dwp_file->num_sections, asection *);
 
   bfd_map_over_sections (dwp_file->dbfd.get (),
                    dwp_file->num_sections, asection *);
 
   bfd_map_over_sections (dwp_file->dbfd.get (),


@@ -12602,13 +12686,13 @@ open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
 static struct dwp_file *
 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
 static struct dwp_file *
 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {

-  if (! dwarf2_per_objfile->dwp_checked)
+  if (! dwarf2_per_objfile->per_bfd->dwp_checked)

     {
     {

-      dwarf2_per_objfile->dwp_file
+      dwarf2_per_objfile->per_bfd->dwp_file

        = open_and_init_dwp_file (dwarf2_per_objfile);
        = open_and_init_dwp_file (dwarf2_per_objfile);

-      dwarf2_per_objfile->dwp_checked = 1;
+      dwarf2_per_objfile->per_bfd->dwp_checked = 1;

     }
     }

-  return dwarf2_per_objfile->dwp_file.get ();
+  return dwarf2_per_objfile->per_bfd->dwp_file.get ();

 }
 
 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
 }
 
 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.


@@ -12628,11 +12712,10 @@ get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
    (dwo_id mismatch or couldn't find the DWO/DWP file).  */
 
 static struct dwo_unit *
    (dwo_id mismatch or couldn't find the DWO/DWP file).  */
 
 static struct dwo_unit *

-lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
-                const char *dwo_name, const char *comp_dir,
+lookup_dwo_cutu (dwarf2_cu *cu, const char *dwo_name, const char *comp_dir,

                 ULONGEST signature, int is_debug_types)
 {
                 ULONGEST signature, int is_debug_types)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const char *kind = is_debug_types ? "TU" : "CU";
   void **dwo_file_slot;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const char *kind = is_debug_types ? "TU" : "CU";
   void **dwo_file_slot;


@@ -12678,7 +12761,7 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
       if (*dwo_file_slot == NULL)
        {
          /* Read in the file and build a table of the CUs/TUs it contains.  */
       if (*dwo_file_slot == NULL)
        {
          /* Read in the file and build a table of the CUs/TUs it contains.  */

-         *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
+         *dwo_file_slot = open_and_init_dwo_file (cu, dwo_name, comp_dir);

        }
       /* NOTE: This will be NULL if unable to open the file.  */
       dwo_file = (struct dwo_file *) *dwo_file_slot;
        }
       /* NOTE: This will be NULL if unable to open the file.  */
       dwo_file = (struct dwo_file *) *dwo_file_slot;


@@ -12743,10 +12826,8 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
 
     warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
               " [in module %s]"),
 
     warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
               " [in module %s]"),

-            kind, dwo_name, hex_string (signature),
-            dwp_text.c_str (),
-            this_unit->is_debug_types ? "TU" : "CU",
-            sect_offset_str (this_unit->sect_off), objfile_name (objfile));
+            kind, dwo_name, hex_string (signature), dwp_text.c_str (), kind,
+            sect_offset_str (cu->per_cu->sect_off), objfile_name (objfile));

   }
   return NULL;
 }
   }
   return NULL;
 }


@@ -12755,21 +12836,25 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
    See lookup_dwo_cutu_unit for details.  */
 
 static struct dwo_unit *
    See lookup_dwo_cutu_unit for details.  */
 
 static struct dwo_unit *

-lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
-                     const char *dwo_name, const char *comp_dir,
+lookup_dwo_comp_unit (dwarf2_cu *cu, const char *dwo_name, const char *comp_dir,

                      ULONGEST signature)
 {
                      ULONGEST signature)
 {

-  return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
+  gdb_assert (!cu->per_cu->is_debug_types);
+
+  return lookup_dwo_cutu (cu, dwo_name, comp_dir, signature, 0);

 }
 
 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
    See lookup_dwo_cutu_unit for details.  */
 
 static struct dwo_unit *
 }
 
 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
    See lookup_dwo_cutu_unit for details.  */
 
 static struct dwo_unit *

-lookup_dwo_type_unit (struct signatured_type *this_tu,
-                     const char *dwo_name, const char *comp_dir)
+lookup_dwo_type_unit (dwarf2_cu *cu, const char *dwo_name, const char *comp_dir)

 {
 {

-  return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
+  gdb_assert (cu->per_cu->is_debug_types);
+
+  signatured_type *sig_type = (signatured_type *) cu->per_cu;
+
+  return lookup_dwo_cutu (cu, dwo_name, comp_dir, sig_type->signature, 1);

 }
 
 /* Traversal function for queue_and_load_all_dwo_tus.  */
 }
 
 /* Traversal function for queue_and_load_all_dwo_tus.  */


@@ -12778,10 +12863,9 @@ static int
 queue_and_load_dwo_tu (void **slot, void *info)
 {
   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
 queue_and_load_dwo_tu (void **slot, void *info)
 {
   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;

-  struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
+  dwarf2_cu *cu = (dwarf2_cu *) info;

   ULONGEST signature = dwo_unit->signature;
   ULONGEST signature = dwo_unit->signature;

-  struct signatured_type *sig_type =
-    lookup_dwo_signatured_type (per_cu->cu, signature);
+  signatured_type *sig_type = lookup_dwo_signatured_type (cu, signature);

 
   if (sig_type != NULL)
     {
 
   if (sig_type != NULL)
     {


@@ -12790,36 +12874,35 @@ queue_and_load_dwo_tu (void **slot, void *info)
       /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
         a real dependency of PER_CU on SIG_TYPE.  That is detected later
         while processing PER_CU.  */
       /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
         a real dependency of PER_CU on SIG_TYPE.  That is detected later
         while processing PER_CU.  */

-      if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
-       load_full_type_unit (sig_cu);
-      per_cu->imported_symtabs_push (sig_cu);
+      if (maybe_queue_comp_unit (NULL, sig_cu, cu->per_objfile, cu->language))
+       load_full_type_unit (sig_cu, cu->per_objfile);
+      cu->per_cu->imported_symtabs_push (sig_cu);

     }
 
   return 1;
 }
 
     }
 
   return 1;
 }
 

-/* Queue all TUs contained in the DWO of PER_CU to be read in.
+/* Queue all TUs contained in the DWO of CU to be read in.

    The DWO may have the only definition of the type, though it may not be
    referenced anywhere in PER_CU.  Thus we have to load *all* its TUs.
    http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
 
 static void
    The DWO may have the only definition of the type, though it may not be
    referenced anywhere in PER_CU.  Thus we have to load *all* its TUs.
    http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
 
 static void

-queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
+queue_and_load_all_dwo_tus (dwarf2_cu *cu)

 {
   struct dwo_unit *dwo_unit;
   struct dwo_file *dwo_file;
 
 {
   struct dwo_unit *dwo_unit;
   struct dwo_file *dwo_file;
 

-  gdb_assert (!per_cu->is_debug_types);
-  gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
-  gdb_assert (per_cu->cu != NULL);
+  gdb_assert (cu != nullptr);
+  gdb_assert (!cu->per_cu->is_debug_types);
+  gdb_assert (get_dwp_file (cu->per_objfile) == nullptr);

 
 

-  dwo_unit = per_cu->cu->dwo_unit;
+  dwo_unit = cu->dwo_unit;

   gdb_assert (dwo_unit != NULL);
 
   dwo_file = dwo_unit->dwo_file;
   if (dwo_file->tus != NULL)
   gdb_assert (dwo_unit != NULL);
 
   dwo_file = dwo_unit->dwo_file;
   if (dwo_file->tus != NULL)

-    htab_traverse_noresize (dwo_file->tus.get (), queue_and_load_dwo_tu,
-                           per_cu);
+    htab_traverse_noresize (dwo_file->tus.get (), queue_and_load_dwo_tu, cu);

 }
 
 /* Read in various DIEs.  */
 }
 
 /* Read in various DIEs.  */


@@ -12956,7 +13039,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
 static void
 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   struct context_stack *newobj;
   CORE_ADDR lowpc;
   struct gdbarch *gdbarch = objfile->arch ();
   struct context_stack *newobj;
   CORE_ADDR lowpc;


@@ -13047,7 +13130,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
       newobj->static_link
        = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
       attr_to_dynamic_prop (attr, die, cu, newobj->static_link,
       newobj->static_link
        = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
       attr_to_dynamic_prop (attr, die, cu, newobj->static_link,

-                           cu->per_cu->addr_type ());
+                           cu->addr_type ());

     }
 
   cu->list_in_scope = cu->get_builder ()->get_local_symbols ();
     }
 
   cu->list_in_scope = cu->get_builder ()->get_local_symbols ();


@@ -13157,7 +13240,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
 static void
 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc, highpc;
   struct die_info *child_die;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR lowpc, highpc;
   struct die_info *child_die;


@@ -13237,7 +13320,8 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
 static void
 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR pc, baseaddr;
   struct attribute *attr;
   struct gdbarch *gdbarch = objfile->arch ();
   CORE_ADDR pc, baseaddr;
   struct attribute *attr;


@@ -13377,6 +13461,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
       dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
       dlbaton->data = DW_BLOCK (attr)->data;
       dlbaton->size = DW_BLOCK (attr)->size;
       dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
       dlbaton->data = DW_BLOCK (attr)->data;
       dlbaton->size = DW_BLOCK (attr)->size;

+      dlbaton->per_objfile = per_objfile;

       dlbaton->per_cu = cu->per_cu;
 
       SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
       dlbaton->per_cu = cu->per_cu;
 
       SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);


@@ -13387,7 +13472,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
       struct die_info *target_die;
 
       target_die = follow_die_ref (die, attr, &target_cu);
       struct die_info *target_die;
 
       target_die = follow_die_ref (die, attr, &target_cu);

-      gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
+      gdb_assert (target_cu->per_objfile->objfile == objfile);

       if (die_is_declaration (target_die, target_cu))
        {
          const char *target_physname;
       if (die_is_declaration (target_die, target_cu))
        {
          const char *target_physname;


@@ -13426,6 +13511,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
               sect_offset_str (die->sect_off), objfile_name (objfile));
 
   call_site->per_cu = cu->per_cu;
               sect_offset_str (die->sect_off), objfile_name (objfile));
 
   call_site->per_cu = cu->per_cu;

+  call_site->per_objfile = per_objfile;

 
   for (child_die = die->child;
        child_die && child_die->tag;
 
   for (child_die = die->child;
        child_die && child_die->tag;


@@ -13580,7 +13666,7 @@ read_variable (struct die_info *die, struct dwarf2_cu *cu)
 
       if (containing_type != NULL)
        {
 
       if (containing_type != NULL)
        {

-         struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+         struct objfile *objfile = cu->per_objfile->objfile;

 
          storage = new (&objfile->objfile_obstack) rust_vtable_symbol;
          storage->concrete_type = containing_type;
 
          storage = new (&objfile->objfile_obstack) rust_vtable_symbol;
          storage->concrete_type = containing_type;


@@ -13601,8 +13687,9 @@ read_variable (struct die_info *die, struct dwarf2_cu *cu)
       struct dwarf2_cu *origin_cu = cu;
       struct die_info *origin_die
        = follow_die_ref (die, abstract_origin, &origin_cu);
       struct dwarf2_cu *origin_cu = cu;
       struct die_info *origin_die
        = follow_die_ref (die, abstract_origin, &origin_cu);

-      dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
-      dpo->abstract_to_concrete[origin_die->sect_off].push_back (die->sect_off);
+      dwarf2_per_objfile *per_objfile = cu->per_objfile;
+      per_objfile->per_bfd->abstract_to_concrete
+       [origin_die->sect_off].push_back (die->sect_off);

     }
 }
 
     }
 }
 


@@ -13618,8 +13705,7 @@ static bool
 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
                         Callback &&callback)
 {
 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
                         Callback &&callback)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *obfd = objfile->obfd;
   /* Base address selection entry.  */
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *obfd = objfile->obfd;
   /* Base address selection entry.  */


@@ -13630,14 +13716,14 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
 
   base = cu->base_address;
 
 
   base = cu->base_address;
 

-  dwarf2_per_objfile->rnglists.read (objfile);
-  if (offset >= dwarf2_per_objfile->rnglists.size)
+  dwarf2_per_objfile->per_bfd->rnglists.read (objfile);
+  if (offset >= dwarf2_per_objfile->per_bfd->rnglists.size)

     {
       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
                 offset);
       return false;
     }
     {
       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
                 offset);
       return false;
     }

-  buffer = dwarf2_per_objfile->rnglists.buffer + offset;
+  buffer = dwarf2_per_objfile->per_bfd->rnglists.buffer + offset;

 
   baseaddr = objfile->text_section_offset ();
 
 
   baseaddr = objfile->text_section_offset ();
 


@@ -13645,8 +13731,8 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
     {
       /* Initialize it due to a false compiler warning.  */
       CORE_ADDR range_beginning = 0, range_end = 0;
     {
       /* Initialize it due to a false compiler warning.  */
       CORE_ADDR range_beginning = 0, range_end = 0;

-      const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
-                                + dwarf2_per_objfile->rnglists.size);
+      const gdb_byte *buf_end = (dwarf2_per_objfile->per_bfd->rnglists.buffer
+                                + dwarf2_per_objfile->per_bfd->rnglists.size);

       unsigned int bytes_read;
 
       if (buffer == buf_end)
       unsigned int bytes_read;
 
       if (buffer == buf_end)


@@ -13748,7 +13834,7 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
       /* A not-uncommon case of bad debug info.
         Don't pollute the addrmap with bad data.  */
       if (range_beginning + baseaddr == 0
       /* A not-uncommon case of bad debug info.
         Don't pollute the addrmap with bad data.  */
       if (range_beginning + baseaddr == 0

-         && !dwarf2_per_objfile->has_section_at_zero)
+         && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

        {
          complaint (_(".debug_rnglists entry has start address of zero"
                       " [in module %s]"), objfile_name (objfile));
        {
          complaint (_(".debug_rnglists entry has start address of zero"
                       " [in module %s]"), objfile_name (objfile));


@@ -13779,9 +13865,8 @@ static int
 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
                       Callback &&callback)
 {
 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
                       Callback &&callback)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-      = cu->per_cu->dwarf2_per_objfile;
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;

   struct comp_unit_head *cu_header = &cu->header;
   bfd *obfd = objfile->obfd;
   unsigned int addr_size = cu_header->addr_size;
   struct comp_unit_head *cu_header = &cu->header;
   bfd *obfd = objfile->obfd;
   unsigned int addr_size = cu_header->addr_size;


@@ -13797,14 +13882,14 @@ dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
 
   base = cu->base_address;
 
 
   base = cu->base_address;
 

-  dwarf2_per_objfile->ranges.read (objfile);
-  if (offset >= dwarf2_per_objfile->ranges.size)
+  per_objfile->per_bfd->ranges.read (objfile);
+  if (offset >= per_objfile->per_bfd->ranges.size)

     {
       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
                 offset);
       return 0;
     }
     {
       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
                 offset);
       return 0;
     }

-  buffer = dwarf2_per_objfile->ranges.buffer + offset;
+  buffer = per_objfile->per_bfd->ranges.buffer + offset;

 
   baseaddr = objfile->text_section_offset ();
 
 
   baseaddr = objfile->text_section_offset ();
 


@@ -13859,7 +13944,7 @@ dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
       /* A not-uncommon case of bad debug info.
         Don't pollute the addrmap with bad data.  */
       if (range_beginning + baseaddr == 0
       /* A not-uncommon case of bad debug info.
         Don't pollute the addrmap with bad data.  */
       if (range_beginning + baseaddr == 0

-         && !dwarf2_per_objfile->has_section_at_zero)
+         && !per_objfile->per_bfd->has_section_at_zero)

        {
          complaint (_(".debug_ranges entry has start address of zero"
                       " [in module %s]"), objfile_name (objfile));
        {
          complaint (_(".debug_ranges entry has start address of zero"
                       " [in module %s]"), objfile_name (objfile));


@@ -13881,7 +13966,7 @@ dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
                    CORE_ADDR *high_return, struct dwarf2_cu *cu,
                    dwarf2_psymtab *ranges_pst)
 {
                    CORE_ADDR *high_return, struct dwarf2_cu *cu,
                    dwarf2_psymtab *ranges_pst)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   const CORE_ADDR baseaddr = objfile->text_section_offset ();
   int low_set = 0;
   struct gdbarch *gdbarch = objfile->arch ();
   const CORE_ADDR baseaddr = objfile->text_section_offset ();
   int low_set = 0;


@@ -13949,8 +14034,7 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
                      CORE_ADDR *highpc, struct dwarf2_cu *cu,
                      dwarf2_psymtab *pst)
 {
                      CORE_ADDR *highpc, struct dwarf2_cu *cu,
                      dwarf2_psymtab *pst)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct attribute *attr;
   struct attribute *attr_high;
   CORE_ADDR low = 0;
   struct attribute *attr;
   struct attribute *attr_high;
   CORE_ADDR low = 0;


@@ -14012,7 +14096,7 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
      labels are not in the output, so the relocs get a value of 0.
      If this is a discarded function, mark the pc bounds as invalid,
      so that GDB will ignore it.  */
      labels are not in the output, so the relocs get a value of 0.
      If this is a discarded function, mark the pc bounds as invalid,
      so that GDB will ignore it.  */

-  if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
+  if (low == 0 && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

     return PC_BOUNDS_INVALID;
 
   *lowpc = low;
     return PC_BOUNDS_INVALID;
 
   *lowpc = low;


@@ -14125,7 +14209,7 @@ static void
 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
                             CORE_ADDR baseaddr, struct dwarf2_cu *cu)
 {
 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
                             CORE_ADDR baseaddr, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   struct attribute *attr;
   struct attribute *attr_high;
   struct gdbarch *gdbarch = objfile->arch ();
   struct attribute *attr;
   struct attribute *attr_high;


@@ -14333,8 +14417,8 @@ handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
            SET_FIELD_BITPOS (*field, offset * bits_per_byte);
          else
            {
            SET_FIELD_BITPOS (*field, offset * bits_per_byte);
          else
            {

-             struct objfile *objfile
-               = cu->per_cu->dwarf2_per_objfile->objfile;
+             dwarf2_per_objfile *per_objfile = cu->per_objfile;
+             struct objfile *objfile = per_objfile->objfile;

              struct dwarf2_locexpr_baton *dlbaton
                = XOBNEW (&objfile->objfile_obstack,
                          struct dwarf2_locexpr_baton);
              struct dwarf2_locexpr_baton *dlbaton
                = XOBNEW (&objfile->objfile_obstack,
                          struct dwarf2_locexpr_baton);


@@ -14344,6 +14428,7 @@ handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
                 of the field, not the value.  This is why
                 is_reference is set to false here.  */
              dlbaton->is_reference = false;
                 of the field, not the value.  This is why
                 is_reference is set to false here.  */
              dlbaton->is_reference = false;

+             dlbaton->per_objfile = per_objfile;

              dlbaton->per_cu = cu->per_cu;
 
              SET_FIELD_DWARF_BLOCK (*field, dlbaton);
              dlbaton->per_cu = cu->per_cu;
 
              SET_FIELD_DWARF_BLOCK (*field, dlbaton);


@@ -14360,7 +14445,7 @@ static void
 dwarf2_add_field (struct field_info *fip, struct die_info *die,
                  struct dwarf2_cu *cu)
 {
 dwarf2_add_field (struct field_info *fip, struct die_info *die,
                  struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   struct nextfield *new_field;
   struct attribute *attr;
   struct gdbarch *gdbarch = objfile->arch ();
   struct nextfield *new_field;
   struct attribute *attr;


@@ -14780,7 +14865,7 @@ add_variant_property (struct field_info *fip, struct type *type,
   for (int i = 0; i < fip->fields.size (); ++i)
     offset_map[fip->fields[i].offset] = i;
 
   for (int i = 0; i < fip->fields.size (); ++i)
     offset_map[fip->fields[i].offset] = i;
 

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   gdb::array_view<variant_part> parts
     = create_variant_parts (&objfile->objfile_obstack, offset_map, fip,
                            fip->variant_parts);
   gdb::array_view<variant_part> parts
     = create_variant_parts (&objfile->objfile_obstack, offset_map, fip,
                            fip->variant_parts);


@@ -14805,8 +14890,8 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
   /* Record the field count, allocate space for the array of fields,
      and create blank accessibility bitfields if necessary.  */
   type->set_num_fields (nfields);
   /* Record the field count, allocate space for the array of fields,
      and create blank accessibility bitfields if necessary.  */
   type->set_num_fields (nfields);

-  TYPE_FIELDS (type) = (struct field *)
-    TYPE_ZALLOC (type, sizeof (struct field) * nfields);
+  type->set_fields
+    ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));

 
   if (fip->non_public_fields && cu->language != language_ada)
     {
 
   if (fip->non_public_fields && cu->language != language_ada)
     {


@@ -14849,7 +14934,7 @@ dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
        = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
           : fip->fields[i - fip->baseclasses.size ()]);
 
        = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
           : fip->fields[i - fip->baseclasses.size ()]);
 

-      TYPE_FIELD (type, i) = field.field;
+      type->field (i) = field.field;

       switch (field.accessibility)
        {
        case DW_ACCESS_private:
       switch (field.accessibility)
        {
        case DW_ACCESS_private:


@@ -14941,7 +15026,7 @@ static void
 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
                      struct type *type, struct dwarf2_cu *cu)
 {
 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
                      struct type *type, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct attribute *attr;
   int i;
   struct fnfieldlist *flp = nullptr;
   struct attribute *attr;
   int i;
   struct fnfieldlist *flp = nullptr;


@@ -15002,7 +15087,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
           of the method itself (TYPE_CODE_METHOD).  */
       smash_to_method_type (fnp->type, type,
                            TYPE_TARGET_TYPE (this_type),
           of the method itself (TYPE_CODE_METHOD).  */
       smash_to_method_type (fnp->type, type,
                            TYPE_TARGET_TYPE (this_type),

-                           TYPE_FIELDS (this_type),
+                           this_type->fields (),

                            this_type->num_fields (),
                            TYPE_VARARGS (this_type));
 
                            this_type->num_fields (),
                            TYPE_VARARGS (this_type));
 


@@ -15219,7 +15304,7 @@ quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
   self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
   new_type = alloc_type (objfile);
   smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
   self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
   new_type = alloc_type (objfile);
   smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),

-                       TYPE_FIELDS (pfn_type), pfn_type->num_fields (),
+                       pfn_type->fields (), pfn_type->num_fields (),

                        TYPE_VARARGS (pfn_type));
   smash_to_methodptr_type (type, new_type);
 }
                        TYPE_VARARGS (pfn_type));
   smash_to_methodptr_type (type, new_type);
 }


@@ -15241,7 +15326,7 @@ get_alignment (struct dwarf2_cu *cu, struct die_info *die)
       complaint (_("DW_AT_alignment must have constant form"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("DW_AT_alignment must have constant form"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return 0;
     }
 
       return 0;
     }
 


@@ -15254,7 +15339,7 @@ get_alignment (struct dwarf2_cu *cu, struct die_info *die)
          complaint (_("DW_AT_alignment value must not be negative"
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),
          complaint (_("DW_AT_alignment value must not be negative"
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),

-                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                    objfile_name (cu->per_objfile->objfile));

          return 0;
        }
       align = val;
          return 0;
        }
       align = val;


@@ -15267,7 +15352,7 @@ get_alignment (struct dwarf2_cu *cu, struct die_info *die)
       complaint (_("DW_AT_alignment value must not be zero"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("DW_AT_alignment value must not be zero"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return 0;
     }
   if ((align & (align - 1)) != 0)
       return 0;
     }
   if ((align & (align - 1)) != 0)


@@ -15275,7 +15360,7 @@ get_alignment (struct dwarf2_cu *cu, struct die_info *die)
       complaint (_("DW_AT_alignment value must be a power of 2"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("DW_AT_alignment value must be a power of 2"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return 0;
     }
 
       return 0;
     }
 


@@ -15293,7 +15378,7 @@ maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
     complaint (_("DW_AT_alignment value too large"
                 " - DIE at %s [in module %s]"),
               sect_offset_str (die->sect_off),
     complaint (_("DW_AT_alignment value too large"
                 " - DIE at %s [in module %s]"),
               sect_offset_str (die->sect_off),

-              objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+              objfile_name (cu->per_objfile->objfile));

 }
 
 /* Check if the given VALUE is a valid enum dwarf_calling_convention
 }
 
 /* Check if the given VALUE is a valid enum dwarf_calling_convention


@@ -15357,7 +15442,7 @@ is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value)
 static struct type *
 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct type *type;
   struct attribute *attr;
   const char *name;
   struct type *type;
   struct attribute *attr;
   const char *name;


@@ -15438,8 +15523,7 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
       else
        {
          struct dynamic_prop prop;
       else
        {
          struct dynamic_prop prop;

-         if (attr_to_dynamic_prop (attr, die, cu, &prop,
-                                   cu->per_cu->addr_type ()))
+         if (attr_to_dynamic_prop (attr, die, cu, &prop, cu->addr_type ()))

            type->add_dyn_prop (DYN_PROP_BYTE_SIZE, prop);
           TYPE_LENGTH (type) = 0;
        }
            type->add_dyn_prop (DYN_PROP_BYTE_SIZE, prop);
           TYPE_LENGTH (type) = 0;
        }


@@ -15506,7 +15590,7 @@ handle_variant_part (struct die_info *die, struct type *type,
       complaint (_("nested DW_TAG_variant_part seen "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("nested DW_TAG_variant_part seen "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return;
     }
   else
       return;
     }
   else


@@ -15538,7 +15622,7 @@ handle_variant_part (struct die_info *die, struct type *type,
       complaint (_("DW_AT_discr does not have DIE reference form"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("DW_AT_discr does not have DIE reference form"
                   " - DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

     }
 
   for (die_info *child_die = die->child;
     }
 
   for (die_info *child_die = die->child;


@@ -15561,7 +15645,7 @@ handle_variant (struct die_info *die, struct type *type,
       complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return;
     }
   if (fi->current_variant_part->processing_variant)
       return;
     }
   if (fi->current_variant_part->processing_variant)


@@ -15569,7 +15653,7 @@ handle_variant (struct die_info *die, struct type *type,
       complaint (_("nested DW_TAG_variant seen "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),
       complaint (_("nested DW_TAG_variant seen "
                   "- DIE at %s [in module %s]"),
                 sect_offset_str (die->sect_off),

-                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                objfile_name (cu->per_objfile->objfile));

       return;
     }
 
       return;
     }
 


@@ -15662,7 +15746,7 @@ handle_struct_member_die (struct die_info *child_die, struct type *type,
 static void
 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct die_info *child_die;
   struct type *type;
 
   struct die_info *child_die;
   struct type *type;
 


@@ -15934,9 +16018,10 @@ update_enumeration_type_from_children (struct die_info *die,
   if (!fields.empty ())
     {
       type->set_num_fields (fields.size ());
   if (!fields.empty ())
     {
       type->set_num_fields (fields.size ());

-      TYPE_FIELDS (type) = (struct field *)
-       TYPE_ALLOC (type, sizeof (struct field) * fields.size ());
-      memcpy (TYPE_FIELDS (type), fields.data (),
+      type->set_fields
+       ((struct field *)
+        TYPE_ALLOC (type, sizeof (struct field) * fields.size ()));
+      memcpy (type->fields (), fields.data (),

              sizeof (struct field) * fields.size ());
     }
 
              sizeof (struct field) * fields.size ());
     }
 


@@ -15952,7 +16037,7 @@ update_enumeration_type_from_children (struct die_info *die,
 static struct type *
 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct type *type;
   struct attribute *attr;
   const char *name;
   struct type *type;
   struct attribute *attr;
   const char *name;


@@ -16104,7 +16189,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct die_info *child_die;
   struct type *type;
   struct type *element_type, *range_type, *index_type;
   struct die_info *child_die;
   struct type *type;
   struct type *element_type, *range_type, *index_type;


@@ -16124,7 +16209,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
   if (attr != NULL)
     {
       int stride_ok;
   if (attr != NULL)
     {
       int stride_ok;

-      struct type *prop_type = cu->per_cu->addr_sized_int_type (false);
+      struct type *prop_type = cu->addr_sized_int_type (false);

 
       byte_stride_prop
        = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
 
       byte_stride_prop
        = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));


@@ -16135,7 +16220,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
          complaint (_("unable to read array DW_AT_byte_stride "
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),
          complaint (_("unable to read array DW_AT_byte_stride "
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),

-                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                    objfile_name (cu->per_objfile->objfile));

          /* Ignore this attribute.  We will likely not be able to print
             arrays of this type correctly, but there is little we can do
             to help if we cannot read the attribute's value.  */
          /* Ignore this attribute.  We will likely not be able to print
             arrays of this type correctly, but there is little we can do
             to help if we cannot read the attribute's value.  */


@@ -16311,9 +16396,8 @@ mark_common_block_symbol_computed (struct symbol *sym,
                                   struct attribute *member_loc,
                                   struct dwarf2_cu *cu)
 {
                                   struct attribute *member_loc,
                                   struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;

   struct dwarf2_locexpr_baton *baton;
   gdb_byte *ptr;
   unsigned int cu_off;
   struct dwarf2_locexpr_baton *baton;
   gdb_byte *ptr;
   unsigned int cu_off;


@@ -16326,6 +16410,7 @@ mark_common_block_symbol_computed (struct symbol *sym,
              || member_loc->form_is_constant ());
 
   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
              || member_loc->form_is_constant ());
 
   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);

+  baton->per_objfile = per_objfile;

   baton->per_cu = cu->per_cu;
   gdb_assert (baton->per_cu);
 
   baton->per_cu = cu->per_cu;
   gdb_assert (baton->per_cu);
 


@@ -16402,7 +16487,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu)
 
   if (die->child != NULL)
     {
 
   if (die->child != NULL)
     {

-      struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+      struct objfile *objfile = cu->per_objfile->objfile;

       struct die_info *child_die;
       size_t n_entries = 0, size;
       struct common_block *common_block;
       struct die_info *child_die;
       size_t n_entries = 0, size;
       struct common_block *common_block;


@@ -16473,7 +16558,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const char *previous_prefix, *name;
   int is_anonymous;
   struct type *type;
   const char *previous_prefix, *name;
   int is_anonymous;
   struct type *type;


@@ -16512,7 +16597,7 @@ read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
 static void
 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
 {
 static void
 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   int is_anonymous;
 
   /* Add a symbol associated to this if we haven't seen the namespace
   int is_anonymous;
 
   /* Add a symbol associated to this if we haven't seen the namespace


@@ -16557,7 +16642,7 @@ read_namespace (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const char *module_name;
   struct type *type;
 
   const char *module_name;
   struct type *type;
 


@@ -16624,8 +16709,7 @@ namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
 static struct type *
 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct gdbarch *gdbarch
-    = cu->per_cu->dwarf2_per_objfile->objfile->arch ();
+  struct gdbarch *gdbarch = cu->per_objfile->objfile->arch ();

   struct comp_unit_head *cu_header = &cu->header;
   struct type *type;
   struct attribute *attr_byte_size;
   struct comp_unit_head *cu_header = &cu->header;
   struct type *type;
   struct attribute *attr_byte_size;


@@ -16683,7 +16767,7 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
          complaint (_("Invalid DW_AT_alignment"
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),
          complaint (_("Invalid DW_AT_alignment"
                       " - DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),

-                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                    objfile_name (cu->per_objfile->objfile));

        }
       else
        {
        }
       else
        {


@@ -16718,11 +16802,10 @@ read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
     type = lookup_methodptr_type (to_type);
   else if (check_typedef (to_type)->code () == TYPE_CODE_FUNC)
     {
     type = lookup_methodptr_type (to_type);
   else if (check_typedef (to_type)->code () == TYPE_CODE_FUNC)
     {

-      struct type *new_type
-       = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
+      struct type *new_type = alloc_type (cu->per_objfile->objfile);

 
       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
 
       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),

-                           TYPE_FIELDS (to_type), to_type->num_fields (),
+                           to_type->fields (), to_type->num_fields (),

                            TYPE_VARARGS (to_type));
       type = lookup_methodptr_type (new_type);
     }
                            TYPE_VARARGS (to_type));
       type = lookup_methodptr_type (new_type);
     }


@@ -16883,7 +16966,7 @@ read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct gdbarch *gdbarch = objfile->arch ();
   struct type *type, *range_type, *index_type, *char_type;
   struct attribute *attr;
   struct gdbarch *gdbarch = objfile->arch ();
   struct type *type, *range_type, *index_type, *char_type;
   struct attribute *attr;


@@ -16926,13 +17009,13 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
          /* Pass 0 as the default as we know this attribute is constant
             and the default value will not be returned.  */
          LONGEST sz = len->constant_value (0);
          /* Pass 0 as the default as we know this attribute is constant
             and the default value will not be returned.  */
          LONGEST sz = len->constant_value (0);

-         prop_type = cu->per_cu->int_type (sz, true);
+         prop_type = cu->per_objfile->int_type (sz, true);

        }
       else
        {
          /* If the size is not specified then we assume it is the size of
             an address on this target.  */
        }
       else
        {
          /* If the size is not specified then we assume it is the size of
             an address on this target.  */

-         prop_type = cu->per_cu->addr_sized_int_type (true);
+         prop_type = cu->addr_sized_int_type (true);

        }
 
       /* Convert the attribute into a dynamic property.  */
        }
 
       /* Convert the attribute into a dynamic property.  */


@@ -17022,7 +17105,7 @@ prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct type *type;           /* Type that this function returns.  */
   struct type *ftype;          /* Function that returns above type.  */
   struct attribute *attr;
   struct type *type;           /* Type that this function returns.  */
   struct type *ftype;          /* Function that returns above type.  */
   struct attribute *attr;


@@ -17085,8 +17168,8 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
 
       /* Allocate storage for parameters and fill them in.  */
       ftype->set_num_fields (nparams);
 
       /* Allocate storage for parameters and fill them in.  */
       ftype->set_num_fields (nparams);

-      TYPE_FIELDS (ftype) = (struct field *)
-       TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
+      ftype->set_fields
+       ((struct field *) TYPE_ZALLOC (ftype, nparams * sizeof (struct field)));

 
       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
         even if we error out during the parameters reading below.  */
 
       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
         even if we error out during the parameters reading below.  */


@@ -17161,7 +17244,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const char *name = NULL;
   struct type *this_type, *target_type;
 
   const char *name = NULL;
   struct type *this_type, *target_type;
 


@@ -17306,7 +17389,7 @@ dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
 static struct type *
 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct type *type;
   struct attribute *attr;
   int encoding = 0, bits = 0;
   struct type *type;
   struct attribute *attr;
   int encoding = 0, bits = 0;


@@ -17363,7 +17446,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
            if (name == nullptr)
              {
                struct obstack *obstack
            if (name == nullptr)
              {
                struct obstack *obstack

-                 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
+                 = &cu->per_objfile->objfile->objfile_obstack;

                name = obconcat (obstack, "_Complex ", type->name (),
                                 nullptr);
              }
                name = obconcat (obstack, "_Complex ", type->name (),
                                 nullptr);
              }


@@ -17449,8 +17532,9 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
                      struct type *default_type)
 {
   struct dwarf2_property_baton *baton;
                      struct type *default_type)
 {
   struct dwarf2_property_baton *baton;

-  struct obstack *obstack
-    = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;
+  struct obstack *obstack = &objfile->objfile_obstack;

 
   gdb_assert (default_type != NULL);
 
 
   gdb_assert (default_type != NULL);
 


@@ -17462,6 +17546,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
       baton = XOBNEW (obstack, struct dwarf2_property_baton);
       baton->property_type = default_type;
       baton->locexpr.per_cu = cu->per_cu;
       baton = XOBNEW (obstack, struct dwarf2_property_baton);
       baton->property_type = default_type;
       baton->locexpr.per_cu = cu->per_cu;

+      baton->locexpr.per_objfile = per_objfile;

       baton->locexpr.size = DW_BLOCK (attr)->size;
       baton->locexpr.data = DW_BLOCK (attr)->data;
       switch (attr->name)
       baton->locexpr.size = DW_BLOCK (attr)->size;
       baton->locexpr.data = DW_BLOCK (attr)->data;
       switch (attr->name)


@@ -17508,6 +17593,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
                baton = XOBNEW (obstack, struct dwarf2_property_baton);
                baton->property_type = die_type (target_die, target_cu);
                baton->locexpr.per_cu = cu->per_cu;
                baton = XOBNEW (obstack, struct dwarf2_property_baton);
                baton->property_type = die_type (target_die, target_cu);
                baton->locexpr.per_cu = cu->per_cu;

+               baton->locexpr.per_objfile = per_objfile;

                baton->locexpr.size = DW_BLOCK (target_attr)->size;
                baton->locexpr.data = DW_BLOCK (target_attr)->data;
                baton->locexpr.is_reference = true;
                baton->locexpr.size = DW_BLOCK (target_attr)->size;
                baton->locexpr.data = DW_BLOCK (target_attr)->data;
                baton->locexpr.is_reference = true;


@@ -17559,9 +17645,8 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
 /* See read.h.  */
 
 struct type *
 /* See read.h.  */
 
 struct type *

-dwarf2_per_cu_data::int_type (int size_in_bytes, bool unsigned_p) const
+dwarf2_per_objfile::int_type (int size_in_bytes, bool unsigned_p) const

 {
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;

   struct type *int_type;
 
   /* Helper macro to examine the various builtin types.  */
   struct type *int_type;
 
   /* Helper macro to examine the various builtin types.  */


@@ -17586,10 +17671,10 @@ dwarf2_per_cu_data::int_type (int size_in_bytes, bool unsigned_p) const
 /* See read.h.  */
 
 struct type *
 /* See read.h.  */
 
 struct type *

-dwarf2_per_cu_data::addr_sized_int_type (bool unsigned_p) const
+dwarf2_cu::addr_sized_int_type (bool unsigned_p) const

 {
 {

-  int addr_size = this->addr_size ();
-  return int_type (addr_size, unsigned_p);
+  int addr_size = this->per_cu->addr_size ();
+  return this->per_objfile->int_type (addr_size, unsigned_p);

 }
 
 /* Read the DW_AT_type attribute for a sub-range.  If this attribute is not
 }
 
 /* Read the DW_AT_type attribute for a sub-range.  If this attribute is not


@@ -17614,7 +17699,7 @@ read_subrange_index_type (struct die_info *die, struct dwarf2_cu *cu)
      FIXME: muller/2010-05-28: Possible references to object for low bound,
      high bound or count are not yet handled by this code.  */
   if (index_type->code () == TYPE_CODE_VOID)
      FIXME: muller/2010-05-28: Possible references to object for low bound,
      high bound or count are not yet handled by this code.  */
   if (index_type->code () == TYPE_CODE_VOID)

-    index_type = cu->per_cu->addr_sized_int_type (false);
+    index_type = cu->addr_sized_int_type (false);

 
   return index_type;
 }
 
   return index_type;
 }


@@ -17688,7 +17773,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
     complaint (_("Missing DW_AT_lower_bound "
                                      "- DIE at %s [in module %s]"),
               sect_offset_str (die->sect_off),
     complaint (_("Missing DW_AT_lower_bound "
                                      "- DIE at %s [in module %s]"),
               sect_offset_str (die->sect_off),

-              objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+              objfile_name (cu->per_objfile->objfile));

 
   struct attribute *attr_ub, *attr_count;
   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
 
   struct attribute *attr_ub, *attr_count;
   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);


@@ -17709,12 +17794,12 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
            complaint (_("Unresolved DW_AT_upper_bound "
                         "- DIE at %s [in module %s]"),
                       sect_offset_str (die->sect_off),
            complaint (_("Unresolved DW_AT_upper_bound "
                         "- DIE at %s [in module %s]"),
                       sect_offset_str (die->sect_off),

-                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                      objfile_name (cu->per_objfile->objfile));

          if (attr_count != NULL)
            complaint (_("Unresolved DW_AT_count "
                         "- DIE at %s [in module %s]"),
                       sect_offset_str (die->sect_off),
          if (attr_count != NULL)
            complaint (_("Unresolved DW_AT_count "
                         "- DIE at %s [in module %s]"),
                       sect_offset_str (die->sect_off),

-                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                      objfile_name (cu->per_objfile->objfile));

        }
     }
 
        }
     }
 


@@ -17744,7 +17829,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
   attribute *attr_byte_stride = dwarf2_attr (die, DW_AT_byte_stride, cu);
   if (attr_byte_stride != nullptr)
     {
   attribute *attr_byte_stride = dwarf2_attr (die, DW_AT_byte_stride, cu);
   if (attr_byte_stride != nullptr)
     {

-      struct type *prop_type = cu->per_cu->addr_sized_int_type (false);
+      struct type *prop_type = cu->addr_sized_int_type (false);

       attr_to_dynamic_prop (attr_byte_stride, die, cu, &byte_stride_prop,
                            prop_type);
     }
       attr_to_dynamic_prop (attr_byte_stride, die, cu, &byte_stride_prop,
                            prop_type);
     }


@@ -17759,12 +17844,12 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
          complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
                       "- DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),
          complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
                       "- DIE at %s [in module %s]"),
                     sect_offset_str (die->sect_off),

-                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                    objfile_name (cu->per_objfile->objfile));

          attr_bit_stride = nullptr;
        }
       else
        {
          attr_bit_stride = nullptr;
        }
       else
        {

-         struct type *prop_type = cu->per_cu->addr_sized_int_type (false);
+         struct type *prop_type = cu->addr_sized_int_type (false);

          attr_to_dynamic_prop (attr_bit_stride, die, cu, &bit_stride_prop,
                                prop_type);
        }
          attr_to_dynamic_prop (attr_bit_stride, die, cu, &bit_stride_prop,
                                prop_type);
        }


@@ -17814,8 +17899,7 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct type *type;
 
 {
   struct type *type;
 

-  type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
-                   NULL);
+  type = init_type (cu->per_objfile->objfile, TYPE_CODE_VOID, 0, NULL);

   type->set_name (dwarf2_name (die, cu));
 
   /* In Ada, an unspecified type is typically used when the description
   type->set_name (dwarf2_name (die, cu));
 
   /* In Ada, an unspecified type is typically used when the description


@@ -18064,7 +18148,7 @@ load_partial_dies (const struct die_reader_specs *reader,
                   const gdb_byte *info_ptr, int building_psymtab)
 {
   struct dwarf2_cu *cu = reader->cu;
                   const gdb_byte *info_ptr, int building_psymtab)
 {
   struct dwarf2_cu *cu = reader->cu;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
   unsigned int bytes_read;
   unsigned int load_all = 0;
   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
   unsigned int bytes_read;
   unsigned int load_all = 0;


@@ -18338,8 +18422,7 @@ partial_die_info::read (const struct die_reader_specs *reader,
                        const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
 {
   struct dwarf2_cu *cu = reader->cu;
                        const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
 {
   struct dwarf2_cu *cu = reader->cu;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   unsigned int i;
   int has_low_pc_attr = 0;
   int has_high_pc_attr = 0;
   unsigned int i;
   int has_low_pc_attr = 0;
   int has_high_pc_attr = 0;


@@ -18547,7 +18630,7 @@ partial_die_info::read (const struct die_reader_specs *reader,
         labels are not in the output, so the relocs get a value of 0.
         If this is a discarded function, mark the pc bounds as invalid,
         so that GDB will ignore it.  */
         labels are not in the output, so the relocs get a value of 0.
         If this is a discarded function, mark the pc bounds as invalid,
         so that GDB will ignore it.  */

-      if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
+      if (lowpc == 0 && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

        {
          struct objfile *objfile = dwarf2_per_objfile->objfile;
          struct gdbarch *gdbarch = objfile->arch ();
        {
          struct objfile *objfile = dwarf2_per_objfile->objfile;
          struct gdbarch *gdbarch = objfile->arch ();


@@ -18601,8 +18684,7 @@ dwarf2_cu::find_partial_die (sect_offset sect_off)
 static const struct cu_partial_die_info
 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
 {
 static const struct cu_partial_die_info
 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_per_cu_data *per_cu = NULL;
   struct partial_die_info *pd = NULL;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_per_cu_data *per_cu = NULL;
   struct partial_die_info *pd = NULL;


@@ -18631,7 +18713,7 @@ find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
                                                 dwarf2_per_objfile);
 
       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
                                                 dwarf2_per_objfile);
 
       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)

-       load_partial_comp_unit (per_cu);
+       load_partial_comp_unit (per_cu, cu->per_objfile);

 
       per_cu->cu->last_used = 0;
       pd = per_cu->cu->find_partial_die (sect_off);
 
       per_cu->cu->last_used = 0;
       pd = per_cu->cu->find_partial_die (sect_off);


@@ -18650,7 +18732,7 @@ find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
         DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
         and clobber THIS_CU->cu->partial_dies with the hash table for the new
         set.  */
         DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
         and clobber THIS_CU->cu->partial_dies with the hash table for the new
         set.  */

-      load_partial_comp_unit (per_cu);
+      load_partial_comp_unit (per_cu, cu->per_objfile);

 
       pd = per_cu->cu->find_partial_die (sect_off);
     }
 
       pd = per_cu->cu->find_partial_die (sect_off);
     }


@@ -18708,7 +18790,7 @@ guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
                                                child_pdi->linkage_name));
          if (actual_class_name != NULL)
            {
                                                child_pdi->linkage_name));
          if (actual_class_name != NULL)
            {

-             struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+             struct objfile *objfile = cu->per_objfile->objfile;

              struct_pdi->name = objfile->intern (actual_class_name.get ());
            }
          break;
              struct_pdi->name = objfile->intern (actual_class_name.get ());
            }
          break;


@@ -18794,7 +18876,7 @@ partial_die_info::fixup (struct dwarf2_cu *cu)
      children, see if we can determine the namespace from their linkage
      name.  */
   if (cu->language == language_cplus
      children, see if we can determine the namespace from their linkage
      name.  */
   if (cu->language == language_cplus

-      && !cu->per_cu->dwarf2_per_objfile->types.empty ()
+      && !cu->per_objfile->per_bfd->types.empty ()

       && die_parent == NULL
       && has_children
       && (tag == DW_TAG_class_type
       && die_parent == NULL
       && has_children
       && (tag == DW_TAG_class_type


@@ -18825,7 +18907,7 @@ partial_die_info::fixup (struct dwarf2_cu *cu)
          else
            base = demangled.get ();
 
          else
            base = demangled.get ();
 

-         struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+         struct objfile *objfile = cu->per_objfile->objfile;

          name = objfile->intern (base);
        }
     }
          name = objfile->intern (base);
        }
     }


@@ -18880,8 +18962,7 @@ lookup_loclist_base (struct dwarf2_cu *cu)
 static CORE_ADDR
 read_loclist_index (struct dwarf2_cu *cu, ULONGEST loclist_index)
 {
 static CORE_ADDR
 read_loclist_index (struct dwarf2_cu *cu, ULONGEST loclist_index)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *abfd = objfile->obfd;
   ULONGEST loclist_base = lookup_loclist_base (cu);
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *abfd = objfile->obfd;
   ULONGEST loclist_base = lookup_loclist_base (cu);


@@ -18963,8 +19044,7 @@ read_attribute_value (const struct die_reader_specs *reader,
                      bool *need_reprocess)
 {
   struct dwarf2_cu *cu = reader->cu;
                      bool *need_reprocess)
 {
   struct dwarf2_cu *cu = reader->cu;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *abfd = reader->abfd;
   struct comp_unit_head *cu_header = &cu->header;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   bfd *abfd = reader->abfd;
   struct comp_unit_head *cu_header = &cu->header;


@@ -19071,7 +19151,7 @@ read_attribute_value (const struct die_reader_specs *reader,
       /* FALLTHROUGH */
     case DW_FORM_GNU_strp_alt:
       {
       /* FALLTHROUGH */
     case DW_FORM_GNU_strp_alt:
       {

-       struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+       dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);

        LONGEST str_offset = cu_header->read_offset (abfd, info_ptr,
                                                     &bytes_read);
 
        LONGEST str_offset = cu_header->read_offset (abfd, info_ptr,
                                                     &bytes_read);
 


@@ -19251,8 +19331,8 @@ static const char *
 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
                                LONGEST str_offset)
 {
 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
                                LONGEST str_offset)
 {

-  return dwarf2_per_objfile->str.read_string (dwarf2_per_objfile->objfile,
-                                             str_offset, "DW_FORM_strp");
+  return dwarf2_per_objfile->per_bfd->str.read_string
+    (dwarf2_per_objfile->objfile, str_offset, "DW_FORM_strp");

 }
 
 /* Return pointer to string at .debug_str offset as read from BUF.
 }
 
 /* Return pointer to string at .debug_str offset as read from BUF.


@@ -19274,13 +19354,13 @@ read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
 
 const char *
 dwarf2_per_objfile::read_line_string (const gdb_byte *buf,
 
 const char *
 dwarf2_per_objfile::read_line_string (const gdb_byte *buf,

-                          const struct comp_unit_head *cu_header,
-                          unsigned int *bytes_read_ptr)
+                                     const struct comp_unit_head *cu_header,
+                                     unsigned int *bytes_read_ptr)

 {
   bfd *abfd = objfile->obfd;
   LONGEST str_offset = cu_header->read_offset (abfd, buf, bytes_read_ptr);
 
 {
   bfd *abfd = objfile->obfd;
   LONGEST str_offset = cu_header->read_offset (abfd, buf, bytes_read_ptr);
 

-  return line_str.read_string (objfile, str_offset, "DW_FORM_line_strp");
+  return per_bfd->line_str.read_string (objfile, str_offset, "DW_FORM_line_strp");

 }
 
 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
 }
 
 /* Given index ADDR_INDEX in .debug_addr, fetch the value.


@@ -19297,16 +19377,16 @@ read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
   const gdb_byte *info_ptr;
   ULONGEST addr_base_or_zero = addr_base.has_value () ? *addr_base : 0;
 
   const gdb_byte *info_ptr;
   ULONGEST addr_base_or_zero = addr_base.has_value () ? *addr_base : 0;
 

-  dwarf2_per_objfile->addr.read (objfile);
-  if (dwarf2_per_objfile->addr.buffer == NULL)
+  dwarf2_per_objfile->per_bfd->addr.read (objfile);
+  if (dwarf2_per_objfile->per_bfd->addr.buffer == NULL)

     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
           objfile_name (objfile));
   if (addr_base_or_zero + addr_index * addr_size
     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
           objfile_name (objfile));
   if (addr_base_or_zero + addr_index * addr_size

-      >= dwarf2_per_objfile->addr.size)
+      >= dwarf2_per_objfile->per_bfd->addr.size)

     error (_("DW_FORM_addr_index pointing outside of "
             ".debug_addr section [in module %s]"),
           objfile_name (objfile));
     error (_("DW_FORM_addr_index pointing outside of "
             ".debug_addr section [in module %s]"),
           objfile_name (objfile));

-  info_ptr = (dwarf2_per_objfile->addr.buffer
+  info_ptr = (dwarf2_per_objfile->per_bfd->addr.buffer

              + addr_base_or_zero + addr_index * addr_size);
   if (addr_size == 4)
     return bfd_get_32 (abfd, info_ptr);
              + addr_base_or_zero + addr_index * addr_size);
   if (addr_size == 4)
     return bfd_get_32 (abfd, info_ptr);


@@ -19319,7 +19399,7 @@ read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
 static CORE_ADDR
 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
 {
 static CORE_ADDR
 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
 {

-  return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
+  return read_addr_index_1 (cu->per_objfile, addr_index,

                            cu->addr_base, cu->header.addr_size);
 }
 
                            cu->addr_base, cu->header.addr_size);
 }
 


@@ -19329,7 +19409,7 @@ static CORE_ADDR
 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
                             unsigned int *bytes_read)
 {
 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
                             unsigned int *bytes_read)
 {

-  bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
+  bfd *abfd = cu->per_objfile->objfile->obfd;

   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
 
   return read_addr_index (cu, addr_index);
   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
 
   return read_addr_index (cu, addr_index);


@@ -19338,9 +19418,10 @@ read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
 /* See read.h.  */
 
 CORE_ADDR
 /* See read.h.  */
 
 CORE_ADDR

-dwarf2_read_addr_index (dwarf2_per_cu_data *per_cu, unsigned int addr_index)
+dwarf2_read_addr_index (dwarf2_per_cu_data *per_cu,
+                       dwarf2_per_objfile *dwarf2_per_objfile,
+                       unsigned int addr_index)

 {
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;

   struct dwarf2_cu *cu = per_cu->cu;
   gdb::optional<ULONGEST> addr_base;
   int addr_size;
   struct dwarf2_cu *cu = per_cu->cu;
   gdb::optional<ULONGEST> addr_base;
   int addr_size;


@@ -19368,7 +19449,7 @@ dwarf2_read_addr_index (dwarf2_per_cu_data *per_cu, unsigned int addr_index)
     }
   else
     {
     }
   else
     {

-      cutu_reader reader (per_cu, NULL, 0, false);
+      cutu_reader reader (per_cu, dwarf2_per_objfile, NULL, 0, false);

       addr_base = reader.cu->addr_base;
       addr_size = reader.cu->header.addr_size;
     }
       addr_base = reader.cu->addr_base;
       addr_size = reader.cu->header.addr_size;
     }


@@ -19387,8 +19468,7 @@ read_str_index (struct dwarf2_cu *cu,
                struct dwarf2_section_info *str_offsets_section,
                ULONGEST str_offsets_base, ULONGEST str_index)
 {
                struct dwarf2_section_info *str_offsets_section,
                ULONGEST str_offsets_base, ULONGEST str_index)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const char *objf_name = objfile_name (objfile);
   bfd *abfd = objfile->obfd;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const char *objf_name = objfile_name (objfile);
   bfd *abfd = objfile->obfd;


@@ -19440,7 +19520,7 @@ read_dwo_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
 static const char *
 read_stub_str_index (struct dwarf2_cu *cu, ULONGEST str_index)
 {
 static const char *
 read_stub_str_index (struct dwarf2_cu *cu, ULONGEST str_index)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const char *objf_name = objfile_name (objfile);
   static const char form_name[] = "DW_FORM_GNU_str_index";
   static const char str_offsets_attr_name[] = "DW_AT_str_offsets";
   const char *objf_name = objfile_name (objfile);
   static const char form_name[] = "DW_FORM_GNU_str_index";
   static const char str_offsets_attr_name[] = "DW_AT_str_offsets";


@@ -19452,8 +19532,8 @@ read_stub_str_index (struct dwarf2_cu *cu, ULONGEST str_index)
           (long) cu->header.offset_size, objf_name);
 
   return read_str_index (cu,
           (long) cu->header.offset_size, objf_name);
 
   return read_str_index (cu,

-                        &cu->per_cu->dwarf2_per_objfile->str,
-                        &cu->per_cu->dwarf2_per_objfile->str_offsets,
+                        &cu->per_objfile->per_bfd->str,
+                        &cu->per_objfile->per_bfd->str_offsets,

                         *cu->str_offsets_base, str_index);
 }
 
                         *cu->str_offsets_base, str_index);
 }
 


@@ -19579,7 +19659,7 @@ dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *c
         complaint (_("string type expected for attribute %s for "
                     "DIE at %s in module %s"),
                   dwarf_attr_name (name), sect_offset_str (die->sect_off),
         complaint (_("string type expected for attribute %s for "
                     "DIE at %s in module %s"),
                   dwarf_attr_name (name), sect_offset_str (die->sect_off),

-                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+                  objfile_name (cu->per_objfile->objfile));

     }
 
   return str;
     }
 
   return str;


@@ -19659,8 +19739,7 @@ static struct dwarf2_section_info *
 get_debug_line_section (struct dwarf2_cu *cu)
 {
   struct dwarf2_section_info *section;
 get_debug_line_section (struct dwarf2_cu *cu)
 {
   struct dwarf2_section_info *section;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
      DWO file.  */
 
   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
      DWO file.  */


@@ -19668,12 +19747,12 @@ get_debug_line_section (struct dwarf2_cu *cu)
     section = &cu->dwo_unit->dwo_file->sections.line;
   else if (cu->per_cu->is_dwz)
     {
     section = &cu->dwo_unit->dwo_file->sections.line;
   else if (cu->per_cu->is_dwz)
     {

-      struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+      dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);

 
       section = &dwz->line;
     }
   else
 
       section = &dwz->line;
     }
   else

-    section = &dwarf2_per_objfile->line;
+    section = &dwarf2_per_objfile->per_bfd->line;

 
   return section;
 }
 
   return section;
 }


@@ -19692,8 +19771,7 @@ static line_header_up
 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
 {
   struct dwarf2_section_info *section;
 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
 {
   struct dwarf2_section_info *section;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   section = get_debug_line_section (cu);
   section->read (dwarf2_per_objfile->objfile);
 
   section = get_debug_line_section (cu);
   section->read (dwarf2_per_objfile->objfile);


@@ -20170,7 +20248,7 @@ lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
       /* This line table is for a function which has been
         GCd by the linker.  Ignore it.  PR gdb/12528 */
 
       /* This line table is for a function which has been
         GCd by the linker.  Ignore it.  PR gdb/12528 */
 

-      struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+      struct objfile *objfile = cu->per_objfile->objfile;

       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
 
       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
 
       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),


@@ -20195,7 +20273,7 @@ dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
   unsigned int bytes_read, extended_len;
   unsigned char op_code, extended_op;
   CORE_ADDR baseaddr;
   unsigned int bytes_read, extended_len;
   unsigned char op_code, extended_op;
   CORE_ADDR baseaddr;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   bfd *abfd = objfile->obfd;
   struct gdbarch *gdbarch = objfile->arch ();
   /* True if we're recording line info (as opposed to building partial
   bfd *abfd = objfile->obfd;
   struct gdbarch *gdbarch = objfile->arch ();
   /* True if we're recording line info (as opposed to building partial


@@ -20424,7 +20502,7 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
                    struct dwarf2_cu *cu, dwarf2_psymtab *pst,
                    CORE_ADDR lowpc, int decode_mapping)
 {
                    struct dwarf2_cu *cu, dwarf2_psymtab *pst,
                    CORE_ADDR lowpc, int decode_mapping)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   const int decode_for_pst_p = (pst != NULL);
 
   if (decode_mapping)
   const int decode_for_pst_p = (pst != NULL);
 
   if (decode_mapping)


@@ -20522,7 +20600,7 @@ dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
   gdb_assert (m_builder == nullptr);
 
   m_builder.reset (new struct buildsym_compunit
   gdb_assert (m_builder == nullptr);
 
   m_builder.reset (new struct buildsym_compunit

-                  (per_cu->dwarf2_per_objfile->objfile,
+                  (this->per_objfile->objfile,

                    name, comp_dir, language, low_pc));
 
   list_in_scope = get_builder ()->get_file_symbols ();
                    name, comp_dir, language, low_pc));
 
   list_in_scope = get_builder ()->get_file_symbols ();


@@ -20539,7 +20617,7 @@ static void
 var_decode_location (struct attribute *attr, struct symbol *sym,
                     struct dwarf2_cu *cu)
 {
 var_decode_location (struct attribute *attr, struct symbol *sym,
                     struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   struct comp_unit_head *cu_header = &cu->header;
 
   /* NOTE drow/2003-01-30: There used to be a comment and some special
   struct comp_unit_head *cu_header = &cu->header;
 
   /* NOTE drow/2003-01-30: There used to be a comment and some special


@@ -20618,8 +20696,7 @@ static struct symbol *
 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
            struct symbol *space)
 {
 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
            struct symbol *space)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   struct symbol *sym = NULL;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   struct symbol *sym = NULL;


@@ -20792,7 +20869,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
 
              if (SYMBOL_CLASS (sym) == LOC_STATIC
                  && SYMBOL_VALUE_ADDRESS (sym) == 0
 
              if (SYMBOL_CLASS (sym) == LOC_STATIC
                  && SYMBOL_VALUE_ADDRESS (sym) == 0

-                 && !dwarf2_per_objfile->has_section_at_zero)
+                 && !dwarf2_per_objfile->per_bfd->has_section_at_zero)

                {
                  /* When a static variable is eliminated by the linker,
                     the corresponding debug information is not stripped
                {
                  /* When a static variable is eliminated by the linker,
                     the corresponding debug information is not stripped


@@ -20803,7 +20880,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
                {
                  if (SYMBOL_CLASS (sym) == LOC_STATIC
                      && (objfile->flags & OBJF_MAINLINE) == 0
                {
                  if (SYMBOL_CLASS (sym) == LOC_STATIC
                      && (objfile->flags & OBJF_MAINLINE) == 0

-                     && dwarf2_per_objfile->can_copy)
+                     && dwarf2_per_objfile->per_bfd->can_copy)

                    {
                      /* A global static variable might be subject to
                         copy relocation.  We first check for a local
                    {
                      /* A global static variable might be subject to
                         copy relocation.  We first check for a local


@@ -21030,7 +21107,7 @@ static gdb_byte *
 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
                         struct dwarf2_cu *cu, LONGEST *value, int bits)
 {
 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
                         struct dwarf2_cu *cu, LONGEST *value, int bits)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
                                BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
   LONGEST l = DW_UNSND (attr);
   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
                                BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
   LONGEST l = DW_UNSND (attr);


@@ -21065,7 +21142,8 @@ dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
                         LONGEST *value, const gdb_byte **bytes,
                         struct dwarf2_locexpr_baton **baton)
 {
                         LONGEST *value, const gdb_byte **bytes,
                         struct dwarf2_locexpr_baton **baton)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  dwarf2_per_objfile *per_objfile = cu->per_objfile;
+  struct objfile *objfile = per_objfile->objfile;

   struct comp_unit_head *cu_header = &cu->header;
   struct dwarf_block *blk;
   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
   struct comp_unit_head *cu_header = &cu->header;
   struct dwarf_block *blk;
   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?


@@ -21091,6 +21169,7 @@ dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
           piggyback on the existing location code rather than writing
           a new implementation of symbol_computed_ops.  */
        *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
           piggyback on the existing location code rather than writing
           a new implementation of symbol_computed_ops.  */
        *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);

+       (*baton)->per_objfile = per_objfile;

        (*baton)->per_cu = cu->per_cu;
        gdb_assert ((*baton)->per_cu);
 
        (*baton)->per_cu = cu->per_cu;
        gdb_assert ((*baton)->per_cu);
 


@@ -21168,7 +21247,7 @@ static void
 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
                    struct dwarf2_cu *cu)
 {
 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
                    struct dwarf2_cu *cu)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   LONGEST value;
   const gdb_byte *bytes;
   struct dwarf2_locexpr_baton *baton;
   LONGEST value;
   const gdb_byte *bytes;
   struct dwarf2_locexpr_baton *baton;


@@ -21205,7 +21284,7 @@ die_type (struct die_info *die, struct dwarf2_cu *cu)
   type_attr = dwarf2_attr (die, DW_AT_type, cu);
   if (!type_attr)
     {
   type_attr = dwarf2_attr (die, DW_AT_type, cu);
   if (!type_attr)
     {

-      struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+      struct objfile *objfile = cu->per_objfile->objfile;

       /* A missing DW_AT_type represents a void type.  */
       return objfile_type (objfile)->builtin_void;
     }
       /* A missing DW_AT_type represents a void type.  */
       return objfile_type (objfile)->builtin_void;
     }


@@ -21264,7 +21343,7 @@ static struct type *
 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct attribute *type_attr;
 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct attribute *type_attr;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

 
   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
   if (!type_attr)
 
   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
   if (!type_attr)


@@ -21279,8 +21358,7 @@ die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
 static struct type *
 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
 {
 static struct type *
 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   char *saved;
 
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   char *saved;
 


@@ -21303,8 +21381,7 @@ static struct type *
 lookup_die_type (struct die_info *die, const struct attribute *attr,
                 struct dwarf2_cu *cu)
 {
 lookup_die_type (struct die_info *die, const struct attribute *attr,
                 struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct type *this_type;
 
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct type *this_type;
 


@@ -21321,13 +21398,14 @@ lookup_die_type (struct die_info *die, const struct attribute *attr,
 
       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
                                                 dwarf2_per_objfile);
 
       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
                                                 dwarf2_per_objfile);

-      this_type = get_die_type_at_offset (sect_off, per_cu);
+      this_type = get_die_type_at_offset (sect_off, per_cu, dwarf2_per_objfile);

     }
   else if (attr->form_is_ref ())
     {
       sect_offset sect_off = attr->get_ref_die_offset ();
 
     }
   else if (attr->form_is_ref ())
     {
       sect_offset sect_off = attr->get_ref_die_offset ();
 

-      this_type = get_die_type_at_offset (sect_off, cu->per_cu);
+      this_type = get_die_type_at_offset (sect_off, cu->per_cu,
+                                         dwarf2_per_objfile);

     }
   else if (attr->form == DW_FORM_ref_sig8)
     {
     }
   else if (attr->form == DW_FORM_ref_sig8)
     {


@@ -21487,7 +21565,7 @@ guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
   struct die_info *spec_die;
   struct dwarf2_cu *spec_cu;
   struct die_info *child;
   struct die_info *spec_die;
   struct dwarf2_cu *spec_cu;
   struct die_info *child;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

 
   spec_cu = cu;
   spec_die = die_specification (die, &spec_cu);
 
   spec_cu = cu;
   spec_die = die_specification (die, &spec_cu);


@@ -21570,7 +21648,7 @@ anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
     return "";
 
   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
     return "";
 

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   return obstack_strndup (&objfile->per_bfd->storage_obstack,
                          DW_STRING (attr),
                          &base[-1] - DW_STRING (attr));
   return obstack_strndup (&objfile->per_bfd->storage_obstack,
                          DW_STRING (attr),
                          &base[-1] - DW_STRING (attr));


@@ -21594,8 +21672,7 @@ anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
 static const char *
 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
 {
 static const char *
 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct die_info *parent, *spec_die;
   struct dwarf2_cu *spec_cu;
   struct type *parent_type;
   struct die_info *parent, *spec_die;
   struct dwarf2_cu *spec_cu;
   struct type *parent_type;


@@ -21713,7 +21790,7 @@ determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
       case DW_TAG_partial_unit:
        /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
        if (cu->language == language_cplus
       case DW_TAG_partial_unit:
        /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
        if (cu->language == language_cplus

-           && !dwarf2_per_objfile->types.empty ()
+           && !dwarf2_per_objfile->per_bfd->types.empty ()

            && die->child != NULL
            && (die->tag == DW_TAG_class_type
                || die->tag == DW_TAG_structure_type
            && die->child != NULL
            && (die->tag == DW_TAG_class_type
                || die->tag == DW_TAG_structure_type


@@ -21838,7 +21915,7 @@ static const char *
 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct attribute *attr;
 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct attribute *attr;

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

 
   attr = dwarf2_attr (die, DW_AT_name, cu);
   if ((!attr || !DW_STRING (attr))
 
   attr = dwarf2_attr (die, DW_AT_name, cu);
   if ((!attr || !DW_STRING (attr))


@@ -22143,7 +22220,7 @@ follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
     {
       dump_die_for_error (src_die);
       error (_("Dwarf Error: Expected reference attribute [in module %s]"),
     {
       dump_die_for_error (src_die);
       error (_("Dwarf Error: Expected reference attribute [in module %s]"),

-            objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+            objfile_name ((*ref_cu)->per_objfile->objfile));

     }
 
   return die;
     }
 
   return die;


@@ -22160,8 +22237,7 @@ follow_die_offset (sect_offset sect_off, int offset_in_dwz,
 {
   struct die_info temp_die;
   struct dwarf2_cu *target_cu, *cu = *ref_cu;
 {
   struct die_info temp_die;
   struct dwarf2_cu *target_cu, *cu = *ref_cu;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   gdb_assert (cu->per_cu != NULL);
 
 
   gdb_assert (cu->per_cu != NULL);
 


@@ -22184,16 +22260,17 @@ follow_die_offset (sect_offset sect_off, int offset_in_dwz,
                                                 dwarf2_per_objfile);
 
       /* If necessary, add it to the queue and load its DIEs.  */
                                                 dwarf2_per_objfile);
 
       /* If necessary, add it to the queue and load its DIEs.  */

-      if (maybe_queue_comp_unit (cu, per_cu, cu->language))
-       load_full_comp_unit (per_cu, false, cu->language);
+      if (maybe_queue_comp_unit (cu, per_cu, dwarf2_per_objfile, cu->language))
+       load_full_comp_unit (per_cu, dwarf2_per_objfile, false, cu->language);

 
       target_cu = per_cu->cu;
     }
   else if (cu->dies == NULL)
     {
       /* We're loading full DIEs during partial symbol reading.  */
 
       target_cu = per_cu->cu;
     }
   else if (cu->dies == NULL)
     {
       /* We're loading full DIEs during partial symbol reading.  */

-      gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
-      load_full_comp_unit (cu->per_cu, false, language_minimal);
+      gdb_assert (dwarf2_per_objfile->per_bfd->reading_partial_symbols);
+      load_full_comp_unit (cu->per_cu, dwarf2_per_objfile, false,
+                          language_minimal);

     }
 
   *ref_cu = target_cu;
     }
 
   *ref_cu = target_cu;


@@ -22227,7 +22304,7 @@ follow_die_ref (struct die_info *src_die, const struct attribute *attr,
     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
           "at %s [in module %s]"),
           sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
           "at %s [in module %s]"),
           sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),

-          objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+          objfile_name (cu->per_objfile->objfile));

 
   return die;
 }
 
   return die;
 }


@@ -22237,20 +22314,20 @@ follow_die_ref (struct die_info *src_die, const struct attribute *attr,
 struct dwarf2_locexpr_baton
 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
                               dwarf2_per_cu_data *per_cu,
 struct dwarf2_locexpr_baton
 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
                               dwarf2_per_cu_data *per_cu,

+                              dwarf2_per_objfile *dwarf2_per_objfile,

                               CORE_ADDR (*get_frame_pc) (void *baton),
                               void *baton, bool resolve_abstract_p)
 {
                               CORE_ADDR (*get_frame_pc) (void *baton),
                               void *baton, bool resolve_abstract_p)
 {

-  struct dwarf2_cu *cu;

   struct die_info *die;
   struct attribute *attr;
   struct dwarf2_locexpr_baton retval;
   struct die_info *die;
   struct attribute *attr;
   struct dwarf2_locexpr_baton retval;

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
 
   struct objfile *objfile = dwarf2_per_objfile->objfile;
 

-  if (per_cu->cu == NULL)
-    load_cu (per_cu, false);
-  cu = per_cu->cu;
-  if (cu == NULL)
+  dwarf2_cu *cu = per_cu->cu;
+  if (cu == nullptr)
+    cu = load_cu (per_cu, dwarf2_per_objfile, false);
+
+  if (cu == nullptr)

     {
       /* We shouldn't get here for a dummy CU, but don't crash on the user.
         Instead just throw an error, not much else we can do.  */
     {
       /* We shouldn't get here for a dummy CU, but don't crash on the user.
         Instead just throw an error, not much else we can do.  */


@@ -22265,15 +22342,15 @@ dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
 
   attr = dwarf2_attr (die, DW_AT_location, cu);
   if (!attr && resolve_abstract_p
 
   attr = dwarf2_attr (die, DW_AT_location, cu);
   if (!attr && resolve_abstract_p

-      && (dwarf2_per_objfile->abstract_to_concrete.find (die->sect_off)
-         != dwarf2_per_objfile->abstract_to_concrete.end ()))
+      && (dwarf2_per_objfile->per_bfd->abstract_to_concrete.find (die->sect_off)
+         != dwarf2_per_objfile->per_bfd->abstract_to_concrete.end ()))

     {
       CORE_ADDR pc = (*get_frame_pc) (baton);
       CORE_ADDR baseaddr = objfile->text_section_offset ();
       struct gdbarch *gdbarch = objfile->arch ();
 
       for (const auto &cand_off
     {
       CORE_ADDR pc = (*get_frame_pc) (baton);
       CORE_ADDR baseaddr = objfile->text_section_offset ();
       struct gdbarch *gdbarch = objfile->arch ();
 
       for (const auto &cand_off

-            : dwarf2_per_objfile->abstract_to_concrete[die->sect_off])
+            : dwarf2_per_objfile->per_bfd->abstract_to_concrete[die->sect_off])

        {
          struct dwarf2_cu *cand_cu = cu;
          struct die_info *cand
        {
          struct dwarf2_cu *cand_cu = cu;
          struct die_info *cand


@@ -22328,6 +22405,7 @@ dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
       retval.data = DW_BLOCK (attr)->data;
       retval.size = DW_BLOCK (attr)->size;
     }
       retval.data = DW_BLOCK (attr)->data;
       retval.size = DW_BLOCK (attr)->size;
     }

+  retval.per_objfile = dwarf2_per_objfile;

   retval.per_cu = cu->per_cu;
 
   age_cached_comp_units (dwarf2_per_objfile);
   retval.per_cu = cu->per_cu;
 
   age_cached_comp_units (dwarf2_per_objfile);


@@ -22340,12 +22418,14 @@ dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
 struct dwarf2_locexpr_baton
 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
                             dwarf2_per_cu_data *per_cu,
 struct dwarf2_locexpr_baton
 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
                             dwarf2_per_cu_data *per_cu,

+                            dwarf2_per_objfile *per_objfile,

                             CORE_ADDR (*get_frame_pc) (void *baton),
                             void *baton)
 {
   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
 
                             CORE_ADDR (*get_frame_pc) (void *baton),
                             void *baton)
 {
   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
 

-  return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
+  return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, per_objfile,
+                                       get_frame_pc, baton);

 }
 
 /* Write a constant of a given type as target-ordered bytes into
 }
 
 /* Write a constant of a given type as target-ordered bytes into


@@ -22372,22 +22452,23 @@ write_constant_as_bytes (struct obstack *obstack,
 const gdb_byte *
 dwarf2_fetch_constant_bytes (sect_offset sect_off,
                             dwarf2_per_cu_data *per_cu,
 const gdb_byte *
 dwarf2_fetch_constant_bytes (sect_offset sect_off,
                             dwarf2_per_cu_data *per_cu,

+                            dwarf2_per_objfile *per_objfile,

                             obstack *obstack,
                             LONGEST *len)
 {
                             obstack *obstack,
                             LONGEST *len)
 {

-  struct dwarf2_cu *cu;

   struct die_info *die;
   struct attribute *attr;
   const gdb_byte *result = NULL;
   struct type *type;
   LONGEST value;
   enum bfd_endian byte_order;
   struct die_info *die;
   struct attribute *attr;
   const gdb_byte *result = NULL;
   struct type *type;
   LONGEST value;
   enum bfd_endian byte_order;

-  struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = per_objfile->objfile;

 
 

-  if (per_cu->cu == NULL)
-    load_cu (per_cu, false);
-  cu = per_cu->cu;
-  if (cu == NULL)
+  dwarf2_cu *cu = per_cu->cu;
+  if (cu == nullptr)
+    cu = load_cu (per_cu, per_objfile, false);
+
+  if (cu == nullptr)

     {
       /* We shouldn't get here for a dummy CU, but don't crash on the user.
         Instead just throw an error, not much else we can do.  */
     {
       /* We shouldn't get here for a dummy CU, but don't crash on the user.
         Instead just throw an error, not much else we can do.  */


@@ -22501,16 +22582,17 @@ dwarf2_fetch_constant_bytes (sect_offset sect_off,
 
 struct type *
 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
 
 struct type *
 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,

-                               dwarf2_per_cu_data *per_cu)
+                               dwarf2_per_cu_data *per_cu,
+                               dwarf2_per_objfile *per_objfile)

 {
 {

-  struct dwarf2_cu *cu;

   struct die_info *die;
 
   struct die_info *die;
 

-  if (per_cu->cu == NULL)
-    load_cu (per_cu, false);
-  cu = per_cu->cu;
-  if (!cu)
-    return NULL;
+  dwarf2_cu *cu = per_cu->cu;
+  if (cu == nullptr)
+    cu = load_cu (per_cu, per_objfile, false);
+
+  if (cu == nullptr)
+    return nullptr;

 
   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
   if (!die)
 
   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
   if (!die)


@@ -22523,10 +22605,11 @@ dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
 
 struct type *
 dwarf2_get_die_type (cu_offset die_offset,
 
 struct type *
 dwarf2_get_die_type (cu_offset die_offset,

-                    struct dwarf2_per_cu_data *per_cu)
+                    dwarf2_per_cu_data *per_cu,
+                    dwarf2_per_objfile *per_objfile)

 {
   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
 {
   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);

-  return get_die_type_at_offset (die_offset_sect, per_cu);
+  return get_die_type_at_offset (die_offset_sect, per_cu, per_objfile);

 }
 
 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
 }
 
 /* Follow type unit SIG_TYPE referenced by SRC_DIE.


@@ -22541,6 +22624,8 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
   struct die_info temp_die;
   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
   struct die_info *die;
   struct die_info temp_die;
   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
   struct die_info *die;

+  dwarf2_per_objfile *dwarf2_per_objfile = (*ref_cu)->per_objfile;
+

 
   /* While it might be nice to assert sig_type->type == NULL here,
      we can get here for DW_AT_imported_declaration where we need
 
   /* While it might be nice to assert sig_type->type == NULL here,
      we can get here for DW_AT_imported_declaration where we need


@@ -22548,8 +22633,9 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
 
   /* If necessary, add it to the queue and load its DIEs.  */
 
 
   /* If necessary, add it to the queue and load its DIEs.  */
 

-  if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
-    read_signatured_type (sig_type);
+  if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, dwarf2_per_objfile,
+                            language_minimal))
+    read_signatured_type (sig_type, dwarf2_per_objfile);

 
   sig_cu = sig_type->per_cu.cu;
   gdb_assert (sig_cu != NULL);
 
   sig_cu = sig_type->per_cu.cu;
   gdb_assert (sig_cu != NULL);


@@ -22559,13 +22645,10 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
                                                 to_underlying (temp_die.sect_off));
   if (die)
     {
                                                 to_underlying (temp_die.sect_off));
   if (die)
     {

-      struct dwarf2_per_objfile *dwarf2_per_objfile
-       = (*ref_cu)->per_cu->dwarf2_per_objfile;
-

       /* For .gdb_index version 7 keep track of included TUs.
         http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */
       /* For .gdb_index version 7 keep track of included TUs.
         http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */

-      if (dwarf2_per_objfile->index_table != NULL
-         && dwarf2_per_objfile->index_table->version <= 7)
+      if (dwarf2_per_objfile->per_bfd->index_table != NULL
+         && dwarf2_per_objfile->per_bfd->index_table->version <= 7)

        {
          (*ref_cu)->per_cu->imported_symtabs_push (sig_cu->per_cu);
        }
        {
          (*ref_cu)->per_cu->imported_symtabs_push (sig_cu->per_cu);
        }


@@ -22604,7 +22687,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr,
       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
                " from DIE at %s [in module %s]"),
              hex_string (signature), sect_offset_str (src_die->sect_off),
       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
                " from DIE at %s [in module %s]"),
              hex_string (signature), sect_offset_str (src_die->sect_off),

-            objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+            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, ref_cu);


@@ -22614,7 +22697,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr,
       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
               " from DIE at %s [in module %s]"),
             hex_string (signature), sect_offset_str (src_die->sect_off),
       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
               " from DIE at %s [in module %s]"),
             hex_string (signature), sect_offset_str (src_die->sect_off),

-            objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+            objfile_name ((*ref_cu)->per_objfile->objfile));

     }
 
   return die;
     }
 
   return die;


@@ -22627,8 +22710,7 @@ static struct type *
 get_signatured_type (struct die_info *die, ULONGEST signature,
                     struct dwarf2_cu *cu)
 {
 get_signatured_type (struct die_info *die, ULONGEST signature,
                     struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct signatured_type *sig_type;
   struct dwarf2_cu *type_cu;
   struct die_info *type_die;
   struct signatured_type *sig_type;
   struct dwarf2_cu *type_cu;
   struct die_info *type_die;


@@ -22647,8 +22729,9 @@ get_signatured_type (struct die_info *die, ULONGEST signature,
     }
 
   /* If we already know the type we're done.  */
     }
 
   /* If we already know the type we're done.  */

-  if (sig_type->type != NULL)
-    return sig_type->type;
+  type = dwarf2_per_objfile->get_type_for_signatured_type (sig_type);
+  if (type != nullptr)
+    return type;

 
   type_cu = cu;
   type_die = follow_die_sig_1 (die, sig_type, &type_cu);
 
   type_cu = cu;
   type_die = follow_die_sig_1 (die, sig_type, &type_cu);


@@ -22675,7 +22758,8 @@ get_signatured_type (struct die_info *die, ULONGEST signature,
                 objfile_name (dwarf2_per_objfile->objfile));
       type = build_error_marker_type (cu, die);
     }
                 objfile_name (dwarf2_per_objfile->objfile));
       type = build_error_marker_type (cu, die);
     }

-  sig_type->type = type;
+
+  dwarf2_per_objfile->set_type_for_signatured_type (sig_type, type);

 
   return type;
 }
 
   return type;
 }


@@ -22701,8 +22785,7 @@ get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
     }
   else
     {
     }
   else
     {

-      struct dwarf2_per_objfile *dwarf2_per_objfile
-       = cu->per_cu->dwarf2_per_objfile;
+      struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
                   " at %s [in module %s]"),
 
       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
                   " at %s [in module %s]"),


@@ -22715,7 +22798,8 @@ get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
 /* Load the DIEs associated with type unit PER_CU into memory.  */
 
 static void
 /* Load the DIEs associated with type unit PER_CU into memory.  */
 
 static void

-load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
+load_full_type_unit (dwarf2_per_cu_data *per_cu,
+                    dwarf2_per_objfile *per_objfile)

 {
   struct signatured_type *sig_type;
 
 {
   struct signatured_type *sig_type;
 


@@ -22729,7 +22813,7 @@ load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
 
   gdb_assert (per_cu->cu == NULL);
 
 
   gdb_assert (per_cu->cu == NULL);
 

-  read_signatured_type (sig_type);
+  read_signatured_type (sig_type, per_objfile);

 
   gdb_assert (per_cu->cu != NULL);
 }
 
   gdb_assert (per_cu->cu != NULL);
 }


@@ -22739,14 +22823,15 @@ load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
    read in the real type from the DWO file as well.  */
 
 static void
    read in the real type from the DWO file as well.  */
 
 static void

-read_signatured_type (struct signatured_type *sig_type)
+read_signatured_type (signatured_type *sig_type,
+                     dwarf2_per_objfile *per_objfile)

 {
   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
 
   gdb_assert (per_cu->is_debug_types);
   gdb_assert (per_cu->cu == NULL);
 
 {
   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
 
   gdb_assert (per_cu->is_debug_types);
   gdb_assert (per_cu->cu == NULL);
 

-  cutu_reader reader (per_cu, NULL, 0, false);
+  cutu_reader reader (per_cu, per_objfile, NULL, 0, false);

 
   if (!reader.dummy_p)
     {
 
   if (!reader.dummy_p)
     {


@@ -22794,7 +22879,7 @@ read_signatured_type (struct signatured_type *sig_type)
 static CORE_ADDR
 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu, bool *computed)
 {
 static CORE_ADDR
 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu, bool *computed)
 {

-  struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+  struct objfile *objfile = cu->per_objfile->objfile;

   size_t i;
   size_t size = blk->size;
   const gdb_byte *data = blk->data;
   size_t i;
   size_t size = blk->size;
   const gdb_byte *data = blk->data;


@@ -23097,8 +23182,7 @@ static void
 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
                     int section_is_gnu)
 {
 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
                     int section_is_gnu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const struct line_header *lh = cu->line_header;
   unsigned int offset_size = cu->header.offset_size;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   const struct line_header *lh = cu->line_header;
   unsigned int offset_size = cu->header.offset_size;


@@ -23122,12 +23206,12 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
     {
       if (section_is_gnu)
        {
     {
       if (section_is_gnu)
        {

-         section = &dwarf2_per_objfile->macro;
+         section = &dwarf2_per_objfile->per_bfd->macro;

          section_name = ".debug_macro";
        }
       else
        {
          section_name = ".debug_macro";
        }
       else
        {

-         section = &dwarf2_per_objfile->macinfo;
+         section = &dwarf2_per_objfile->per_bfd->macinfo;

          section_name = ".debug_macinfo";
        }
     }
          section_name = ".debug_macinfo";
        }
     }


@@ -23151,8 +23235,7 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
 static struct dwarf2_section_info *
 cu_debug_loc_section (struct dwarf2_cu *cu)
 {
 static struct dwarf2_section_info *
 cu_debug_loc_section (struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

 
   if (cu->dwo_unit)
     {
 
   if (cu->dwo_unit)
     {


@@ -23160,8 +23243,8 @@ cu_debug_loc_section (struct dwarf2_cu *cu)
 
       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
     }
 
       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
     }

-  return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
-                                 : &dwarf2_per_objfile->loc);
+  return (cu->header.version >= 5 ? &dwarf2_per_objfile->per_bfd->loclists
+                                 : &dwarf2_per_objfile->per_bfd->loc);

 }
 
 /* A helper function that fills in a dwarf2_loclist_baton.  */
 }
 
 /* A helper function that fills in a dwarf2_loclist_baton.  */


@@ -23171,12 +23254,12 @@ fill_in_loclist_baton (struct dwarf2_cu *cu,
                       struct dwarf2_loclist_baton *baton,
                       const struct attribute *attr)
 {
                       struct dwarf2_loclist_baton *baton,
                       const struct attribute *attr)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
 
   section->read (dwarf2_per_objfile->objfile);
 
   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
 
   section->read (dwarf2_per_objfile->objfile);
 

+  baton->per_objfile = dwarf2_per_objfile;

   baton->per_cu = cu->per_cu;
   gdb_assert (baton->per_cu);
   /* We don't know how long the location list is, but make sure we
   baton->per_cu = cu->per_cu;
   gdb_assert (baton->per_cu);
   /* We don't know how long the location list is, but make sure we


@@ -23194,8 +23277,7 @@ static void
 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
                             struct dwarf2_cu *cu, int is_block)
 {
 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
                             struct dwarf2_cu *cu, int is_block)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
 
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
 


@@ -23225,6 +23307,7 @@ dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
       struct dwarf2_locexpr_baton *baton;
 
       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
       struct dwarf2_locexpr_baton *baton;
 
       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);

+      baton->per_objfile = dwarf2_per_objfile;

       baton->per_cu = cu->per_cu;
       gdb_assert (baton->per_cu);
 
       baton->per_cu = cu->per_cu;
       gdb_assert (baton->per_cu);
 


@@ -23252,21 +23335,6 @@ dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
     }
 }
 
     }
 }
 

-/* See read.h.  */
-
-struct objfile *
-dwarf2_per_cu_data::objfile () const
-{
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
-
-  /* Return the master objfile, so that we can report and look up the
-     correct file containing this variable.  */
-  if (objfile->separate_debug_objfile_backlink)
-    objfile = objfile->separate_debug_objfile_backlink;
-
-  return objfile;
-}
-

 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
    (CU_HEADERP is unused in such case) or prepare a temporary copy at
    CU_HEADERP first.  */
 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
    (CU_HEADERP is unused in such case) or prepare a temporary copy at
    CU_HEADERP first.  */


@@ -23333,23 +23401,13 @@ dwarf2_per_cu_data::ref_addr_size () const
 
 /* See read.h.  */
 
 
 /* See read.h.  */
 

-CORE_ADDR
-dwarf2_per_cu_data::text_offset () const
-{
-  struct objfile *objfile = dwarf2_per_objfile->objfile;
-
-  return objfile->text_section_offset ();
-}
-
-/* See read.h.  */
-

 struct type *
 struct type *

-dwarf2_per_cu_data::addr_type () const
+dwarf2_cu::addr_type () const

 {
 {

-  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct objfile *objfile = this->per_objfile->objfile;

   struct type *void_type = objfile_type (objfile)->builtin_void;
   struct type *addr_type = lookup_pointer_type (void_type);
   struct type *void_type = objfile_type (objfile)->builtin_void;
   struct type *addr_type = lookup_pointer_type (void_type);

-  int addr_size = this->addr_size ();
+  int addr_size = this->per_cu->addr_size ();

 
   if (TYPE_LENGTH (addr_type) == addr_size)
     return addr_type;
 
   if (TYPE_LENGTH (addr_type) == addr_size)
     return addr_type;


@@ -23401,9 +23459,9 @@ dwarf2_find_containing_comp_unit (sect_offset sect_off,
 {
   int low
     = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
 {
   int low
     = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,

-                                       dwarf2_per_objfile->all_comp_units);
+                                       dwarf2_per_objfile->per_bfd->all_comp_units);

   struct dwarf2_per_cu_data *this_cu
   struct dwarf2_per_cu_data *this_cu

-    = dwarf2_per_objfile->all_comp_units[low];
+    = dwarf2_per_objfile->per_bfd->all_comp_units[low];

 
   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
     {
 
   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
     {


@@ -23413,13 +23471,13 @@ dwarf2_find_containing_comp_unit (sect_offset sect_off,
               sect_offset_str (sect_off),
               bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
 
               sect_offset_str (sect_off),
               bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
 

-      gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
+      gdb_assert (dwarf2_per_objfile->per_bfd->all_comp_units[low-1]->sect_off

                  <= sect_off);
                  <= sect_off);

-      return dwarf2_per_objfile->all_comp_units[low-1];
+      return dwarf2_per_objfile->per_bfd->all_comp_units[low-1];

     }
   else
     {
     }
   else
     {

-      if (low == dwarf2_per_objfile->all_comp_units.size () - 1
+      if (low == dwarf2_per_objfile->per_bfd->all_comp_units.size () - 1

          && sect_off >= this_cu->sect_off + this_cu->length)
        error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
          && sect_off >= this_cu->sect_off + this_cu->length)
        error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);


@@ -23478,10 +23536,12 @@ run_test ()
 
 #endif /* GDB_SELF_TEST */
 
 
 #endif /* GDB_SELF_TEST */
 

-/* Initialize dwarf2_cu CU, owned by PER_CU.  */
+/* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE.  */

 
 

-dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
-  : per_cu (per_cu_),
+dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data *per_cu,
+                     dwarf2_per_objfile *per_objfile)
+  : per_cu (per_cu),
+    per_objfile (per_objfile),

     mark (false),
     has_loclist (false),
     checked_producer (false),
     mark (false),
     has_loclist (false),
     checked_producer (false),


@@ -23531,8 +23591,8 @@ age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 {
   struct dwarf2_per_cu_data *per_cu, **last_chain;
 
 {
   struct dwarf2_per_cu_data *per_cu, **last_chain;
 

-  dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
-  per_cu = dwarf2_per_objfile->read_in_chain;
+  dwarf2_clear_marks (dwarf2_per_objfile->per_bfd->read_in_chain);
+  per_cu = dwarf2_per_objfile->per_bfd->read_in_chain;

   while (per_cu != NULL)
     {
       per_cu->cu->last_used ++;
   while (per_cu != NULL)
     {
       per_cu->cu->last_used ++;


@@ -23541,8 +23601,8 @@ age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
       per_cu = per_cu->cu->read_in_chain;
     }
 
       per_cu = per_cu->cu->read_in_chain;
     }
 

-  per_cu = dwarf2_per_objfile->read_in_chain;
-  last_chain = &dwarf2_per_objfile->read_in_chain;
+  per_cu = dwarf2_per_objfile->per_bfd->read_in_chain;
+  last_chain = &dwarf2_per_objfile->per_bfd->read_in_chain;

   while (per_cu != NULL)
     {
       struct dwarf2_per_cu_data *next_cu;
   while (per_cu != NULL)
     {
       struct dwarf2_per_cu_data *next_cu;


@@ -23564,14 +23624,13 @@ age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
 /* Remove a single compilation unit from the cache.  */
 
 static void
 /* Remove a single compilation unit from the cache.  */
 
 static void

-free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
+free_one_cached_comp_unit (dwarf2_per_cu_data *target_per_cu,
+                          dwarf2_per_objfile *dwarf2_per_objfile)

 {
   struct dwarf2_per_cu_data *per_cu, **last_chain;
 {
   struct dwarf2_per_cu_data *per_cu, **last_chain;

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = target_per_cu->dwarf2_per_objfile;

 
 

-  per_cu = dwarf2_per_objfile->read_in_chain;
-  last_chain = &dwarf2_per_objfile->read_in_chain;
+  per_cu = dwarf2_per_objfile->per_bfd->read_in_chain;
+  last_chain = &dwarf2_per_objfile->per_bfd->read_in_chain;

   while (per_cu != NULL)
     {
       struct dwarf2_per_cu_data *next_cu;
   while (per_cu != NULL)
     {
       struct dwarf2_per_cu_data *next_cu;


@@ -23659,8 +23718,7 @@ per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
 static struct type *
 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 {
 static struct type *
 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 {

-  struct dwarf2_per_objfile *dwarf2_per_objfile
-    = cu->per_cu->dwarf2_per_objfile;
+  struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;

   struct dwarf2_per_cu_offset_and_type **slot, ofs;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct attribute *attr;
   struct dwarf2_per_cu_offset_and_type **slot, ofs;
   struct objfile *objfile = dwarf2_per_objfile->objfile;
   struct attribute *attr;


@@ -23686,7 +23744,7 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
   attr = dwarf2_attr (die, DW_AT_allocated, cu);
   if (attr != NULL && attr->form_is_block ())
     {
   attr = dwarf2_attr (die, DW_AT_allocated, cu);
   if (attr != NULL && attr->form_is_block ())
     {

-      struct type *prop_type = cu->per_cu->addr_sized_int_type (false);
+      struct type *prop_type = cu->addr_sized_int_type (false);

       if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
         type->add_dyn_prop (DYN_PROP_ALLOCATED, prop);
     }
       if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
         type->add_dyn_prop (DYN_PROP_ALLOCATED, prop);
     }


@@ -23701,7 +23759,7 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
   attr = dwarf2_attr (die, DW_AT_associated, cu);
   if (attr != NULL && attr->form_is_block ())
     {
   attr = dwarf2_attr (die, DW_AT_associated, cu);
   if (attr != NULL && attr->form_is_block ())
     {

-      struct type *prop_type = cu->per_cu->addr_sized_int_type (false);
+      struct type *prop_type = cu->addr_sized_int_type (false);

       if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
         type->add_dyn_prop (DYN_PROP_ASSOCIATED, prop);
     }
       if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
         type->add_dyn_prop (DYN_PROP_ASSOCIATED, prop);
     }


@@ -23714,8 +23772,7 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 
   /* Read DW_AT_data_location and set in type.  */
   attr = dwarf2_attr (die, DW_AT_data_location, cu);
 
   /* Read DW_AT_data_location and set in type.  */
   attr = dwarf2_attr (die, DW_AT_data_location, cu);

-  if (attr_to_dynamic_prop (attr, die, cu, &prop,
-                           cu->per_cu->addr_type ()))
+  if (attr_to_dynamic_prop (attr, die, cu, &prop, cu->addr_type ()))

     type->add_dyn_prop (DYN_PROP_DATA_LOCATION, prop);
 
   if (dwarf2_per_objfile->die_type_hash == NULL)
     type->add_dyn_prop (DYN_PROP_DATA_LOCATION, prop);
 
   if (dwarf2_per_objfile->die_type_hash == NULL)


@@ -23744,10 +23801,10 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 
 static struct type *
 get_die_type_at_offset (sect_offset sect_off,
 
 static struct type *
 get_die_type_at_offset (sect_offset sect_off,

-                       struct dwarf2_per_cu_data *per_cu)
+                       dwarf2_per_cu_data *per_cu,
+                       dwarf2_per_objfile *dwarf2_per_objfile)

 {
   struct dwarf2_per_cu_offset_and_type *slot, ofs;
 {
   struct dwarf2_per_cu_offset_and_type *slot, ofs;

-  struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;

 
   if (dwarf2_per_objfile->die_type_hash == NULL)
     return NULL;
 
   if (dwarf2_per_objfile->die_type_hash == NULL)
     return NULL;


@@ -23768,7 +23825,7 @@ get_die_type_at_offset (sect_offset sect_off,
 static struct type *
 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
 {
 static struct type *
 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
 {

-  return get_die_type_at_offset (die->sect_off, cu->per_cu);
+  return get_die_type_at_offset (die->sect_off, cu->per_cu, cu->per_objfile);

 }
 
 /* Add a dependence relationship from CU to REF_PER_CU.  */
 }
 
 /* Add a dependence relationship from CU to REF_PER_CU.  */