Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / dwarf2read.c
index 8c81c8a..6151b3d 100644 (file)
@@ -1,6 +1,6 @@
 /* DWARF 2 debugging format support for GDB.
 
-   Copyright (C) 1994-2012 Free Software Foundation, Inc.
+   Copyright (C) 1994-2013 Free Software Foundation, Inc.
 
    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
    Inc.  with support from Florida State University (under contract
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
+/* FIXME: Various die-reading functions need to be more careful with
+   reading off the end of the section.
+   E.g., load_partial_dies, read_partial_die.  */
+
 #include "defs.h"
 #include "bfd.h"
+#include "elf-bfd.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "objfiles.h"
 #include "completer.h"
 #include "vec.h"
 #include "c-lang.h"
+#include "go-lang.h"
 #include "valprint.h"
+#include "gdbcore.h" /* for gnutarget */
+#include "gdb/gdb-index.h"
 #include <ctype.h>
+#include "gdb_bfd.h"
+#include "f-lang.h"
+#include "source.h"
 
 #include <fcntl.h>
 #include "gdb_string.h"
 #include "gdb_assert.h"
 #include <sys/types.h>
-#ifdef HAVE_ZLIB_H
-#include <zlib.h>
-#endif
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void *) -1)
-#endif
-#endif
 
 typedef struct symbol *symbolp;
 DEF_VEC_P (symbolp);
 
-#if 0
-/* .debug_info header for a compilation unit
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct comp_unit_header
-  {
-    unsigned int length;       /* length of the .debug_info
-                                  contribution */
-    unsigned short version;    /* version number -- 2 for DWARF
-                                  version 2 */
-    unsigned int abbrev_offset;        /* offset into .debug_abbrev section */
-    unsigned char addr_size;   /* byte size of an address -- 4 */
-  }
-_COMP_UNIT_HEADER;
-#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
-#endif
-
-/* .debug_line statement program prologue
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct statement_prologue
-  {
-    unsigned int total_length; /* byte length of the statement
-                                  information */
-    unsigned short version;    /* version number -- 2 for DWARF
-                                  version 2 */
-    unsigned int prologue_length;      /* # bytes between prologue &
-                                          stmt program */
-    unsigned char minimum_instruction_length;  /* byte size of
-                                                  smallest instr */
-    unsigned char default_is_stmt;     /* initial value of is_stmt
-                                          register */
-    char line_base;
-    unsigned char line_range;
-    unsigned char opcode_base; /* number assigned to first special
-                                  opcode */
-    unsigned char *standard_opcode_lengths;
-  }
-_STATEMENT_PROLOGUE;
+/* When non-zero, print basic high level tracing messages.
+   This is in contrast to the low level DIE reading of dwarf2_die_debug.  */
+static int dwarf2_read_debug = 0;
 
 /* When non-zero, dump DIEs after they are read in.  */
-static int dwarf2_die_debug = 0;
+static unsigned int dwarf2_die_debug = 0;
 
 /* When non-zero, cross-check physname against demangler.  */
 static int check_physname = 0;
 
-static int pagesize;
-
-/* When set, the file that we're processing is known to have debugging
-   info for C++ namespaces.  GCC 3.3.x did not produce this information,
-   but later versions do.  */
-
-static int processing_has_namespace_info;
+/* When non-zero, do not reject deprecated .gdb_index sections.  */
+static int use_deprecated_index_sections = 0;
 
 static const struct objfile_data *dwarf2_objfile_data_key;
 
@@ -136,10 +97,6 @@ struct dwarf2_section_info
   asection *asection;
   gdb_byte *buffer;
   bfd_size_type size;
-  /* Not NULL if the section was actually mmapped.  */
-  void *map_addr;
-  /* Page aligned size of mmapped area.  */
-  bfd_size_type map_len;
   /* True if we have tried to read this section.  */
   int readin;
 };
@@ -153,6 +110,28 @@ typedef uint32_t offset_type;
 
 DEF_VEC_I (offset_type);
 
+/* Ensure only legit values are used.  */
+#define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
+  do { \
+    gdb_assert ((unsigned int) (value) <= 1); \
+    GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
+  } while (0)
+
+/* Ensure only legit values are used.  */
+#define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
+  do { \
+    gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
+                && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
+    GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
+  } while (0)
+
+/* Ensure we don't use more than the alloted nuber of bits for the CU.  */
+#define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
+  do { \
+    gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
+    GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
+  } while (0)
+
 /* A description of the mapped index.  The file format is described in
    a comment by the code that writes the index.  */
 struct mapped_index
@@ -179,6 +158,12 @@ struct mapped_index
   const char *constant_pool;
 };
 
+typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
+DEF_VEC_P (dwarf2_per_cu_ptr);
+
+/* Collection of data recorded per objfile.
+   This hangs off of dwarf2_objfile_data_key.  */
+
 struct dwarf2_per_objfile
 {
   struct dwarf2_section_info info;
@@ -189,6 +174,7 @@ struct dwarf2_per_objfile
   struct dwarf2_section_info macro;
   struct dwarf2_section_info str;
   struct dwarf2_section_info ranges;
+  struct dwarf2_section_info addr;
   struct dwarf2_section_info frame;
   struct dwarf2_section_info eh_frame;
   struct dwarf2_section_info gdb_index;
@@ -198,7 +184,7 @@ struct dwarf2_per_objfile
   /* Back link.  */
   struct objfile *objfile;
 
-  /* A list of all the compilation units.  This is used to locate
+  /* Table of all the compilation units.  This is used to locate
      the target compilation unit of a particular reference.  */
   struct dwarf2_per_cu_data **all_comp_units;
 
@@ -206,19 +192,54 @@ struct dwarf2_per_objfile
   int n_comp_units;
 
   /* The number of .debug_types-related CUs.  */
-  int n_type_comp_units;
+  int n_type_units;
 
-  /* The .debug_types-related CUs.  */
-  struct dwarf2_per_cu_data **type_comp_units;
+  /* The .debug_types-related CUs (TUs).  */
+  struct signatured_type **all_type_units;
 
-  /* A chain of compilation units that are currently read in, so that
-     they can be freed later.  */
-  struct dwarf2_per_cu_data *read_in_chain;
+  /* The number of entries in all_type_unit_groups.  */
+  int n_type_unit_groups;
+
+  /* Table of type unit groups.
+     This exists to make it easy to iterate over all CUs and TU groups.  */
+  struct type_unit_group **all_type_unit_groups;
+
+  /* Table of struct type_unit_group objects.
+     The hash key is the DW_AT_stmt_list value.  */
+  htab_t type_unit_groups;
 
   /* A table mapping .debug_types signatures to its signatured_type entry.
      This is NULL if the .debug_types section hasn't been read in yet.  */
   htab_t signatured_types;
 
+  /* Type unit statistics, to see how well the scaling improvements
+     are doing.  */
+  struct tu_stats
+  {
+    int nr_uniq_abbrev_tables;
+    int nr_symtabs;
+    int nr_symtab_sharers;
+    int nr_stmt_less_type_units;
+  } tu_stats;
+
+  /* A chain of compilation units that are currently read in, so that
+     they can be freed later.  */
+  struct dwarf2_per_cu_data *read_in_chain;
+
+  /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
+     This is NULL if the table hasn't been allocated yet.  */
+  htab_t dwo_files;
+
+  /* Non-zero if we've check for whether there is a DWP file.  */
+  int dwp_checked;
+
+  /* The DWP file if there is one, or NULL.  */
+  struct dwp_file *dwp_file;
+
+  /* The shared '.dwz' file, if one exists.  This is used when the
+     original data was compressed using 'dwz -m'.  */
+  struct dwz_file *dwz_file;
+
   /* A flag indicating wether this objfile has a section loaded at a
      VMA of 0.  */
   int has_section_at_zero;
@@ -231,24 +252,25 @@ struct dwarf2_per_objfile
   struct mapped_index *index_table;
 
   /* When using index_table, this keeps track of all quick_file_names entries.
-     TUs can share line table entries with CUs or other TUs, and there can be
-     a lot more TUs than unique line tables, so we maintain a separate table
-     of all line table entries to support the sharing.  */
+     TUs typically share line table entries with a CU, so we maintain a
+     separate table of all line table entries to support the sharing.
+     Note that while there can be way more TUs than CUs, we've already
+     sorted all the TUs into "type unit groups", grouped by their
+     DW_AT_stmt_list value.  Therefore the only sharing done here is with a
+     CU and its associated TU group if there is one.  */
   htab_t quick_file_names_table;
 
   /* Set during partial symbol reading, to prevent queueing of full
      symbols.  */
   int reading_partial_symbols;
 
-  /* Table mapping type .debug_info DIE offsets to types.
+  /* Table mapping type DIEs to their struct type *.
      This is NULL if not allocated yet.
-     It (currently) makes sense to allocate debug_types_type_hash lazily.
-     To keep things simple we allocate both lazily.  */
-  htab_t debug_info_type_hash;
+     The mapping is done via (CU/TU signature + DIE offset) -> type.  */
+  htab_t die_type_hash;
 
-  /* Table mapping type .debug_types DIE offsets to types.
-     This is NULL if not allocated yet.  */
-  htab_t debug_types_type_hash;
+  /* The CUs we recently read.  */
+  VEC (dwarf2_per_cu_ptr) *just_read_cus;
 };
 
 static struct dwarf2_per_objfile *dwarf2_per_objfile;
@@ -258,7 +280,8 @@ static struct dwarf2_per_objfile *dwarf2_per_objfile;
 /* Note that if the debugging section has been compressed, it might
    have a name like .zdebug_info.  */
 
-static const struct dwarf2_debug_sections dwarf2_elf_names = {
+static const struct dwarf2_debug_sections dwarf2_elf_names =
+{
   { ".debug_info", ".zdebug_info" },
   { ".debug_abbrev", ".zdebug_abbrev" },
   { ".debug_line", ".zdebug_line" },
@@ -268,18 +291,45 @@ static const struct dwarf2_debug_sections dwarf2_elf_names = {
   { ".debug_str", ".zdebug_str" },
   { ".debug_ranges", ".zdebug_ranges" },
   { ".debug_types", ".zdebug_types" },
+  { ".debug_addr", ".zdebug_addr" },
   { ".debug_frame", ".zdebug_frame" },
   { ".eh_frame", NULL },
   { ".gdb_index", ".zgdb_index" },
   23
 };
 
-/* local data types */
+/* List of DWO/DWP sections.  */
+
+static const struct dwop_section_names
+{
+  struct dwarf2_section_names abbrev_dwo;
+  struct dwarf2_section_names info_dwo;
+  struct dwarf2_section_names line_dwo;
+  struct dwarf2_section_names loc_dwo;
+  struct dwarf2_section_names macinfo_dwo;
+  struct dwarf2_section_names macro_dwo;
+  struct dwarf2_section_names str_dwo;
+  struct dwarf2_section_names str_offsets_dwo;
+  struct dwarf2_section_names types_dwo;
+  struct dwarf2_section_names cu_index;
+  struct dwarf2_section_names tu_index;
+}
+dwop_section_names =
+{
+  { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
+  { ".debug_info.dwo", ".zdebug_info.dwo" },
+  { ".debug_line.dwo", ".zdebug_line.dwo" },
+  { ".debug_loc.dwo", ".zdebug_loc.dwo" },
+  { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
+  { ".debug_macro.dwo", ".zdebug_macro.dwo" },
+  { ".debug_str.dwo", ".zdebug_str.dwo" },
+  { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
+  { ".debug_types.dwo", ".zdebug_types.dwo" },
+  { ".debug_cu_index", ".zdebug_cu_index" },
+  { ".debug_tu_index", ".zdebug_tu_index" },
+};
 
-/* We hold several abbreviation tables in memory at the same time.  */
-#ifndef ABBREV_HASH_SIZE
-#define ABBREV_HASH_SIZE 121
-#endif
+/* local data types */
 
 /* The data in a compilation unit header, after target2host
    translation, looks like this.  */
@@ -289,7 +339,7 @@ struct comp_unit_head
   short version;
   unsigned char addr_size;
   unsigned char signed_addr_p;
-  unsigned int abbrev_offset;
+  sect_offset abbrev_offset;
 
   /* Size of file offsets; either 4 or 8.  */
   unsigned int offset_size;
@@ -299,11 +349,11 @@ struct comp_unit_head
 
   /* Offset to the first byte of this compilation unit header in the
      .debug_info section, for resolving relative reference dies.  */
-  unsigned int offset;
+  sect_offset offset;
 
   /* Offset to first die in this cu from the start of the cu.
      This will be the first byte following the compilation unit header.  */
-  unsigned int first_die_offset;
+  cu_offset first_die_offset;
 };
 
 /* Type used for delaying computation of method physnames.
@@ -344,8 +394,6 @@ struct dwarf2_cu
   /* Non-zero if base_address has been set.  */
   int base_known;
 
-  struct function_range *first_fn, *last_fn, *cached_fn;
-
   /* The language we are debugging.  */
   enum language language;
   const struct language_defn *language_defn;
@@ -363,13 +411,13 @@ struct dwarf2_cu
      distinguish these in buildsym.c.  */
   struct pending **list_in_scope;
 
-  /* DWARF abbreviation table associated with this compilation unit.  */
-  struct abbrev_info **dwarf2_abbrevs;
-
-  /* Storage for the abbrev table.  */
-  struct obstack abbrev_obstack;
+  /* The abbrev table for this CU.
+     Normally this points to the abbrev table in the objfile.
+     But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file.  */
+  struct abbrev_table *abbrev_table;
 
-  /* Hash table holding all the loaded partial DIEs.  */
+  /* Hash table holding all the loaded partial DIEs
+     with partial_die->offset.SECT_OFF as hash.  */
   htab_t partial_dies;
 
   /* Storage for things with the same lifetime as this read-in compilation
@@ -388,7 +436,8 @@ struct dwarf2_cu
   /* How many compilation units ago was this CU last referenced?  */
   int last_used;
 
-  /* A hash table of die offsets for following references.  */
+  /* A hash table of DIE cu_offset for following references with
+     die_info->offset.sect_off as hash.  */
   htab_t die_hash;
 
   /* Full DIEs if read in.  */
@@ -409,62 +458,101 @@ struct dwarf2_cu
   /* To be copied to symtab->call_site_htab.  */
   htab_t call_site_htab;
 
+  /* Non-NULL if this CU came from a DWO file.
+     There is an invariant here that is important to remember:
+     Except for attributes copied from the top level DIE in the "main"
+     (or "stub") file in preparation for reading the DWO file
+     (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
+     Either there isn't a DWO file (in which case this is NULL and the point
+     is moot), or there is and either we're not going to read it (in which
+     case this is NULL) or there is and we are reading it (in which case this
+     is non-NULL).  */
+  struct dwo_unit *dwo_unit;
+
+  /* The DW_AT_addr_base attribute if present, zero otherwise
+     (zero is a valid value though).
+     Note this value comes from the stub CU/TU's DIE.  */
+  ULONGEST addr_base;
+
+  /* The DW_AT_ranges_base attribute if present, zero otherwise
+     (zero is a valid value though).
+     Note this value comes from the stub CU/TU's DIE.
+     Also note that the value is zero in the non-DWO case so this value can
+     be used without needing to know whether DWO files are in use or not.
+     N.B. This does not apply to DW_AT_ranges appearing in
+     DW_TAG_compile_unit dies.  This is a bit of a wart, consider if ever
+     DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
+     DW_AT_ranges_base *would* have to be applied, and we'd have to care
+     whether the DW_AT_ranges attribute came from the skeleton or DWO.  */
+  ULONGEST ranges_base;
+
   /* Mark used when releasing cached dies.  */
   unsigned int mark : 1;
 
-  /* This flag will be set if this compilation unit might include
-     inter-compilation-unit references.  */
-  unsigned int has_form_ref_addr : 1;
-
-  /* This flag will be set if this compilation unit includes any
-     DW_TAG_namespace DIEs.  If we know that there are explicit
-     DIEs for namespaces, we don't need to try to infer them
-     from mangled names.  */
-  unsigned int has_namespace_info : 1;
-
   /* This CU references .debug_loc.  See the symtab->locations_valid field.
      This test is imperfect as there may exist optimized debug code not using
      any location list and still facing inlining issues if handled as
      unoptimized code.  For a future better test see GCC PR other/32998.  */
-
   unsigned int has_loclist : 1;
+
+  /* These cache the results for producer_is_* fields.  CHECKED_PRODUCER is set
+     if all the producer_is_* fields are valid.  This information is cached
+     because profiling CU expansion showed excessive time spent in
+     producer_is_gxx_lt_4_6.  */
+  unsigned int checked_producer : 1;
+  unsigned int producer_is_gxx_lt_4_6 : 1;
+  unsigned int producer_is_gcc_lt_4_3 : 1;
+  unsigned int producer_is_icc : 1;
+
+  /* When set, the file that we're processing is known to have
+     debugging info for C++ namespaces.  GCC 3.3.x did not produce
+     this information, but later versions do.  */
+
+  unsigned int processing_has_namespace_info : 1;
 };
 
 /* Persistent data held for a compilation unit, even when not
    processing it.  We put a pointer to this structure in the
-   read_symtab_private field of the psymtab.  If we encounter
-   inter-compilation-unit references, we also maintain a sorted
-   list of all compilation units.  */
+   read_symtab_private field of the psymtab.  */
 
 struct dwarf2_per_cu_data
 {
-  /* The start offset and length of this compilation unit.  2**29-1
-     bytes should suffice to store the length of any compilation unit
-     - if it doesn't, GDB will fall over anyway.
+  /* The start offset and length of this compilation unit.
      NOTE: Unlike comp_unit_head.length, this length includes
-     initial_length_size.  */
-  unsigned int offset;
-  unsigned int length : 29;
+     initial_length_size.
+     If the DIE refers to a DWO file, this is always of the original die,
+     not the DWO file.  */
+  sect_offset offset;
+  unsigned int length;
 
   /* Flag indicating this compilation unit will be read in before
      any of the current compilation units are processed.  */
   unsigned int queued : 1;
 
-  /* This flag will be set if we need to load absolutely all DIEs
-     for this compilation unit, instead of just the ones we think
-     are interesting.  It gets set if we look for a DIE in the
+  /* This flag will be set when reading partial DIEs if we need to load
+     absolutely all DIEs for this compilation unit, instead of just the ones
+     we think are interesting.  It gets set if we look for a DIE in the
      hash table and don't find it.  */
   unsigned int load_all_dies : 1;
 
-  /* Non-null if this CU is from .debug_types; in which case it points
-     to the section.  Otherwise it's from .debug_info.  */
-  struct dwarf2_section_info *debug_types_section;
+  /* Non-zero if this CU is from .debug_types.  */
+  unsigned int is_debug_types : 1;
+
+  /* Non-zero if this CU is from the .dwz file.  */
+  unsigned int is_dwz : 1;
+
+  /* The section this CU/TU lives in.
+     If the DIE refers to a DWO file, this is always the original die,
+     not the DWO file.  */
+  struct dwarf2_section_info *info_or_types_section;
 
   /* Set to non-NULL iff this CU is currently loaded.  When it gets freed out
      of the CU cache it gets reset to NULL again.  */
   struct dwarf2_cu *cu;
 
-  /* The corresponding objfile.  */
+  /* The corresponding objfile.
+     Normally we can get the objfile from dwarf2_per_objfile.
+     However we can enter this file with just a "per_cu" handle.  */
   struct objfile *objfile;
 
   /* When using partial symbol tables, the 'psymtab' field is active.
@@ -472,47 +560,301 @@ struct dwarf2_per_cu_data
   union
   {
     /* The partial symbol table associated with this compilation unit,
-       or NULL for partial units (which do not have an associated
-       symtab).  */
+       or NULL for unread partial units.  */
     struct partial_symtab *psymtab;
 
     /* Data needed by the "quick" functions.  */
     struct dwarf2_per_cu_quick_data *quick;
   } v;
+
+  /* The CUs we import using DW_TAG_imported_unit.  This is filled in
+     while reading psymtabs, used to compute the psymtab dependencies,
+     and then cleared.  Then it is filled in again while reading full
+     symbols, and only deleted when the objfile is destroyed.
+
+     This is also used to work around a difference between the way gold
+     generates .gdb_index version <=7 and the way gdb does.  Arguably this
+     is a gold bug.  For symbols coming from TUs, gold records in the index
+     the CU that includes the TU instead of the TU itself.  This breaks
+     dw2_lookup_symbol: It assumes that if the index says symbol X lives
+     in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
+     will find X.  Alas TUs live in their own symtab, so after expanding CU Y
+     we need to look in TU Z to find X.  Fortunately, this is akin to
+     DW_TAG_imported_unit, so we just use the same mechanism: For
+     .gdb_index version <=7 this also records the TUs that the CU referred
+     to.  Concurrently with this change gdb was modified to emit version 8
+     indices so we only pay a price for gold generated indices.  */
+  VEC (dwarf2_per_cu_ptr) *imported_symtabs;
+
+  /* Type units are grouped by their DW_AT_stmt_list entry so that they
+     can share them.  If this is a TU, this points to the containing
+     symtab.  */
+  struct type_unit_group *type_unit_group;
 };
 
 /* Entry in the signatured_types hash table.  */
 
 struct signatured_type
 {
+  /* The "per_cu" object of this type.
+     N.B.: This is the first member so that it's easy to convert pointers
+     between them.  */
+  struct dwarf2_per_cu_data per_cu;
+
+  /* The type's signature.  */
   ULONGEST signature;
 
-  /* Offset in .debug_types of the type defined by this TU.  */
-  unsigned int type_offset;
+  /* Offset in the TU of the type's DIE, as read from the TU header.
+     If the definition lives in a DWO file, this value is unusable.  */
+  cu_offset type_offset_in_tu;
+
+  /* Offset in the section of the type's DIE.
+     If the definition lives in a DWO file, this is the offset in the
+     .debug_types.dwo section.
+     The value is zero until the actual value is known.
+     Zero is otherwise not a valid section offset.  */
+  sect_offset type_offset_in_section;
+};
+
+/* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
+   This includes type_unit_group and quick_file_names.  */
+
+struct stmt_list_hash
+{
+  /* The DWO unit this table is from or NULL if there is none.  */
+  struct dwo_unit *dwo_unit;
+
+  /* Offset in .debug_line or .debug_line.dwo.  */
+  sect_offset line_offset;
+};
+
+/* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
+   an object of this type.  */
 
-  /* The CU(/TU) of this type.  */
+struct type_unit_group
+{
+  /* dwarf2read.c's main "handle" on the symtab.
+     To simplify things we create an artificial CU that "includes" all the
+     type units using this stmt_list so that the rest of the code still has
+     a "per_cu" handle on the symtab.
+     This PER_CU is recognized by having no section.  */
+#define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->info_or_types_section == NULL)
   struct dwarf2_per_cu_data per_cu;
+
+  union
+  {
+    /* The TUs that share this DW_AT_stmt_list entry.
+       This is added to while parsing type units to build partial symtabs,
+       and is deleted afterwards and not used again.  */
+    VEC (dwarf2_per_cu_ptr) *tus;
+
+    /* When reading the line table in "quick" functions, we need a real TU.
+       Any will do, we know they all share the same DW_AT_stmt_list entry.
+       For simplicity's sake, we pick the first one.  */
+    struct dwarf2_per_cu_data *first_tu;
+  } t;
+
+  /* The primary 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 primary symtab.  */
+  struct symtab *primary_symtab;
+
+  /* The data used to construct the hash key.  */
+  struct stmt_list_hash hash;
+
+  /* The number of symtabs from the line header.
+     The value here must match line_header.num_file_names.  */
+  unsigned int num_symtabs;
+
+  /* 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 DWO file.  */
+
+struct dwo_sections
+{
+  struct dwarf2_section_info abbrev;
+  struct dwarf2_section_info line;
+  struct dwarf2_section_info loc;
+  struct dwarf2_section_info macinfo;
+  struct dwarf2_section_info macro;
+  struct dwarf2_section_info str;
+  struct dwarf2_section_info str_offsets;
+  /* In the case of a virtual DWO file, these two are unused.  */
+  struct dwarf2_section_info info;
+  VEC (dwarf2_section_info_def) *types;
+};
+
+/* Common bits of DWO CUs/TUs.  */
+
+struct dwo_unit
+{
+  /* Backlink to the containing struct dwo_file.  */
+  struct dwo_file *dwo_file;
+
+  /* The "id" that distinguishes this CU/TU.
+     .debug_info calls this "dwo_id", .debug_types calls this "signature".
+     Since signatures came first, we stick with it for consistency.  */
+  ULONGEST signature;
+
+  /* The section this CU/TU lives in, in the DWO file.  */
+  struct dwarf2_section_info *info_or_types_section;
+
+  /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section.  */
+  sect_offset offset;
+  unsigned int length;
+
+  /* For types, offset in the type's DIE of the type defined by this TU.  */
+  cu_offset type_offset_in_tu;
+};
+
+/* Data for one DWO file.
+   This includes virtual DWO files that have been packaged into a
+   DWP file.  */
+
+struct dwo_file
+{
+  /* The DW_AT_GNU_dwo_name attribute.  This is the hash key.
+     For virtual DWO files the name is constructed from the section offsets
+     of abbrev,line,loc,str_offsets so that we combine virtual DWO files
+     from related CU+TUs.  */
+  const char *name;
+
+  /* The bfd, when the file is open.  Otherwise this is NULL.
+     This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd.  */
+  bfd *dbfd;
+
+  /* Section info for this file.  */
+  struct dwo_sections sections;
+
+  /* Table of CUs in the file.
+     Each element is a struct dwo_unit.  */
+  htab_t cus;
+
+  /* Table of TUs in the file.
+     Each element is a struct dwo_unit.  */
+  htab_t tus;
+};
+
+/* These sections are what may appear in a DWP file.  */
+
+struct dwp_sections
+{
+  struct dwarf2_section_info str;
+  struct dwarf2_section_info cu_index;
+  struct dwarf2_section_info tu_index;
+  /* The .debug_info.dwo, .debug_types.dwo, and other sections are referenced
+     by section number.  We don't need to record them here.  */
+};
+
+/* These sections are what may appear in a virtual DWO file.  */
+
+struct virtual_dwo_sections
+{
+  struct dwarf2_section_info abbrev;
+  struct dwarf2_section_info line;
+  struct dwarf2_section_info loc;
+  struct dwarf2_section_info macinfo;
+  struct dwarf2_section_info macro;
+  struct dwarf2_section_info str_offsets;
+  /* Each DWP hash table entry records one CU or one TU.
+     That is recorded here, and copied to dwo_unit.info_or_types_section.  */
+  struct dwarf2_section_info info_or_types;
+};
+
+/* Contents of DWP hash tables.  */
+
+struct dwp_hash_table
+{
+  uint32_t nr_units, nr_slots;
+  const gdb_byte *hash_table, *unit_table, *section_pool;
+};
+
+/* Data for one DWP file.  */
+
+struct dwp_file
+{
+  /* Name of the file.  */
+  const char *name;
+
+  /* The bfd, when the file is open.  Otherwise this is NULL.  */
+  bfd *dbfd;
+
+  /* Section info for this file.  */
+  struct dwp_sections sections;
+
+  /* Table of CUs in the file. */
+  const struct dwp_hash_table *cus;
+
+  /* Table of TUs in the file.  */
+  const struct dwp_hash_table *tus;
+
+  /* Table of loaded CUs/TUs.  Each entry is a struct dwo_unit *.  */
+  htab_t loaded_cutus;
+
+  /* Table to map ELF section numbers to their sections.  */
+  unsigned int num_sections;
+  asection **elf_sections;
+};
+
+/* This represents a '.dwz' file.  */
+
+struct dwz_file
+{
+  /* A dwz file can only contain a few sections.  */
+  struct dwarf2_section_info abbrev;
+  struct dwarf2_section_info info;
+  struct dwarf2_section_info str;
+  struct dwarf2_section_info line;
+  struct dwarf2_section_info macro;
+  struct dwarf2_section_info gdb_index;
+
+  /* The dwz's BFD.  */
+  bfd *dwz_bfd;
 };
 
 /* Struct used to pass misc. parameters to read_die_and_children, et
    al.  which are used for both .debug_info and .debug_types dies.
    All parameters here are unchanging for the life of the call.  This
-   struct exists to abstract away the constant parameters of die
-   reading.  */
+   struct exists to abstract away the constant parameters of die reading.  */
 
 struct die_reader_specs
 {
-  /* The bfd of this objfile.  */
+  /* die_section->asection->owner.  */
   bfd* abfd;
 
   /* The CU of the DIE we are parsing.  */
   struct dwarf2_cu *cu;
 
-  /* Pointer to start of section buffer.
-     This is either the start of .debug_info or .debug_types.  */
-  const gdb_byte *buffer;
+  /* Non-NULL if reading a DWO file (including one packaged into a DWP).  */
+  struct dwo_file *dwo_file;
+
+  /* The section the die comes from.
+     This is either .debug_info or .debug_types, or the .dwo variants.  */
+  struct dwarf2_section_info *die_section;
+
+  /* die_section->buffer.  */
+  gdb_byte *buffer;
+
+  /* The end of the buffer.  */
+  const gdb_byte *buffer_end;
 };
 
+/* Type of function passed to init_cutu_and_read_dies, et.al.  */
+typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
+                                     gdb_byte *info_ptr,
+                                     struct die_info *comp_unit_die,
+                                     int has_children,
+                                     void *data);
+
 /* The line number information for a compilation unit (found in the
    .debug_line section) begins with a "statement program header",
    which contains the following information.  */
@@ -565,7 +907,7 @@ struct line_header
 struct partial_die_info
   {
     /* Offset of this DIE.  */
-    unsigned int offset;
+    sect_offset offset;
 
     /* DWARF-2 tag for this DIE.  */
     ENUM_BITFIELD(dwarf_tag) tag : 16;
@@ -577,6 +919,7 @@ struct partial_die_info
     unsigned int has_type : 1;
     unsigned int has_specification : 1;
     unsigned int has_pc_info : 1;
+    unsigned int may_be_inlined : 1;
 
     /* Flag set if the SCOPE field of this structure has been
        computed.  */
@@ -591,9 +934,15 @@ struct partial_die_info
     /* Flag set if fixup_partial_die has been called on this die.  */
     unsigned int fixup_called : 1;
 
+    /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt.  */
+    unsigned int is_dwz : 1;
+
+    /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt.  */
+    unsigned int spec_is_dwz : 1;
+
     /* The name of this DIE.  Normally the value of DW_AT_name, but
        sometimes a default name for unnamed DIEs.  */
-    char *name;
+    const char *name;
 
     /* The linkage name, if present.  */
     const char *linkage_name;
@@ -601,10 +950,17 @@ struct partial_die_info
     /* The scope to prepend to our children.  This is generally
        allocated on the comp_unit_obstack, so will disappear
        when this compilation unit leaves the cache.  */
-    char *scope;
+    const char *scope;
 
-    /* The location description associated with this DIE, if any.  */
-    struct dwarf_block *locdesc;
+    /* Some data associated with the partial DIE.  The tag determines
+       which field is live.  */
+    union
+    {
+      /* The location description associated with this DIE, if any.  */
+      struct dwarf_block *locdesc;
+      /* The offset of an import, for DW_TAG_imported_unit.  */
+      sect_offset offset;
+    } d;
 
     /* If HAS_PC_INFO, the PC range associated with this DIE.  */
     CORE_ADDR lowpc;
@@ -619,7 +975,7 @@ struct partial_die_info
     /* If HAS_SPECIFICATION, the offset of the DIE referred to by
        DW_AT_specification (or DW_AT_abstract_origin or
        DW_AT_extension).  */
-    unsigned int spec_offset;
+    sect_offset spec_offset;
 
     /* Pointers to this DIE's parent, first child, and next sibling,
        if any.  */
@@ -643,6 +999,27 @@ struct attr_abbrev
     ENUM_BITFIELD(dwarf_form) form : 16;
   };
 
+/* Size of abbrev_table.abbrev_hash_table.  */
+#define ABBREV_HASH_SIZE 121
+
+/* Top level data structure to contain an abbreviation table.  */
+
+struct abbrev_table
+{
+  /* Where the abbrev table came from.
+     This is used as a sanity check when the table is used.  */
+  sect_offset offset;
+
+  /* Storage for the abbrev table.  */
+  struct obstack abbrev_obstack;
+
+  /* Hash table of abbrevs.
+     This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
+     It could be statically allocated, but the previous code didn't so we
+     don't either.  */
+  struct abbrev_info **abbrevs;
+};
+
 /* Attributes have a name and a value.  */
 struct attribute
   {
@@ -656,7 +1033,7 @@ struct attribute
 
     union
       {
-       char *str;
+       const char *str;
        struct dwarf_block *blk;
        ULONGEST unsnd;
        LONGEST snd;
@@ -683,7 +1060,7 @@ struct die_info
     unsigned int abbrev;
 
     /* Offset in .debug_info or .debug_types section.  */
-    unsigned int offset;
+    sect_offset offset;
 
     /* The dies in a compilation unit form an n-ary tree.  PARENT
        points to this die's parent; CHILD points to the first child of
@@ -699,14 +1076,6 @@ struct die_info
     struct attribute attrs[1];
   };
 
-struct function_range
-{
-  const char *name;
-  CORE_ADDR lowpc, highpc;
-  int seen_line;
-  struct function_range *next;
-};
-
 /* Get at parts of an attribute structure.  */
 
 #define DW_STRING(attr)    ((attr)->u.str)
@@ -720,7 +1089,7 @@ struct function_range
 /* Blocks are a bunch of untyped bytes.  */
 struct dwarf_block
   {
-    unsigned int size;
+    size_t size;
 
     /* Valid only if SIZE is not zero.  */
     gdb_byte *data;
@@ -778,7 +1147,7 @@ struct field_info
        to the head of the member function field chain.  */
     struct fnfieldlist
       {
-       char *name;
+       const char *name;
        int length;
        struct nextfnfield *head;
       }
@@ -803,6 +1172,7 @@ struct field_info
 struct dwarf2_queue_item
 {
   struct dwarf2_per_cu_data *per_cu;
+  enum language pretend_language;
   struct dwarf2_queue_item *next;
 };
 
@@ -865,11 +1235,13 @@ dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
 }
 
 static void
-dwarf2_macros_too_long_complaint (struct dwarf2_section_info *section)
+dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
 {
   complaint (&symfile_complaints,
-            _("macro info runs off end of `%s' section"),
-            section->asection->name);
+            _("debug info runs off end of %s section"
+              " [in module %s]"),
+            section->asection->name,
+            bfd_get_filename (section->asection->owner));
 }
 
 static void
@@ -923,57 +1295,56 @@ static void add_partial_subprogram (struct partial_die_info *pdi,
                                    CORE_ADDR *lowpc, CORE_ADDR *highpc,
                                    int need_pc, struct dwarf2_cu *cu);
 
-static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
-                                    gdb_byte *buffer, gdb_byte *info_ptr,
-                                     bfd *abfd, struct dwarf2_cu *cu);
-
-static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
+static void dwarf2_read_symtab (struct partial_symtab *,
+                               struct objfile *);
 
 static void psymtab_to_symtab_1 (struct partial_symtab *);
 
-static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
+static struct abbrev_info *abbrev_table_lookup_abbrev
+  (const struct abbrev_table *, unsigned int);
 
-static void dwarf2_free_abbrev_table (void *);
+static struct abbrev_table *abbrev_table_read_table
+  (struct dwarf2_section_info *, sect_offset);
 
-static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
+static void abbrev_table_free (struct abbrev_table *);
+
+static void abbrev_table_free_cleanup (void *);
 
-static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
-                                           struct dwarf2_cu *);
+static void dwarf2_read_abbrevs (struct dwarf2_cu *,
+                                struct dwarf2_section_info *);
+
+static void dwarf2_free_abbrev_table (void *);
 
-static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
-                                                struct dwarf2_cu *);
+static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
 
-static struct partial_die_info *load_partial_dies (bfd *,
-                                                  gdb_byte *, gdb_byte *,
-                                                  int, struct dwarf2_cu *);
+static struct partial_die_info *load_partial_dies
+  (const struct die_reader_specs *, gdb_byte *, int);
 
-static gdb_byte *read_partial_die (struct partial_die_info *,
-                                   struct abbrev_info *abbrev,
-                                  unsigned int, bfd *,
-                                  gdb_byte *, gdb_byte *,
-                                  struct dwarf2_cu *);
+static gdb_byte *read_partial_die (const struct die_reader_specs *,
+                                  struct partial_die_info *,
+                                  struct abbrev_info *,
+                                  unsigned int,
+                                  gdb_byte *);
 
-static struct partial_die_info *find_partial_die (unsigned int,
+static struct partial_die_info *find_partial_die (sect_offset, int,
                                                  struct dwarf2_cu *);
 
 static void fixup_partial_die (struct partial_die_info *,
                               struct dwarf2_cu *);
 
-static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
-                                 bfd *, gdb_byte *, struct dwarf2_cu *);
-
-static gdb_byte *read_attribute_value (struct attribute *, unsigned,
-                                       bfd *, gdb_byte *, struct dwarf2_cu *);
+static gdb_byte *read_attribute (const struct die_reader_specs *,
+                                struct attribute *, struct attr_abbrev *,
+                                gdb_byte *);
 
-static unsigned int read_1_byte (bfd *, gdb_byte *);
+static unsigned int read_1_byte (bfd *, const gdb_byte *);
 
-static int read_1_signed_byte (bfd *, gdb_byte *);
+static int read_1_signed_byte (bfd *, const gdb_byte *);
 
-static unsigned int read_2_bytes (bfd *, gdb_byte *);
+static unsigned int read_2_bytes (bfd *, const gdb_byte *);
 
-static unsigned int read_4_bytes (bfd *, gdb_byte *);
+static unsigned int read_4_bytes (bfd *, const gdb_byte *);
 
-static ULONGEST read_8_bytes (bfd *, gdb_byte *);
+static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
 
 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
                               unsigned int *);
@@ -989,6 +1360,9 @@ static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
 
 static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int);
 
+static sect_offset read_abbrev_offset (struct dwarf2_section_info *,
+                                      sect_offset);
+
 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
 
 static char *read_direct_string (bfd *, gdb_byte *, unsigned int *);
@@ -997,11 +1371,17 @@ static char *read_indirect_string (bfd *, gdb_byte *,
                                    const struct comp_unit_head *,
                                    unsigned int *);
 
-static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
+static char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
+
+static ULONGEST read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
 
-static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
+static LONGEST read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
 
-static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
+static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *, gdb_byte *,
+                                             unsigned int *);
+
+static char *read_str_index (const struct die_reader_specs *reader,
+                            struct dwarf2_cu *cu, ULONGEST str_index);
 
 static void set_cu_language (unsigned int, struct dwarf2_cu *);
 
@@ -1009,8 +1389,7 @@ static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
                                      struct dwarf2_cu *);
 
 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
-                                               unsigned int,
-                                               struct dwarf2_cu *);
+                                               unsigned int);
 
 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
                                struct dwarf2_cu *cu);
@@ -1025,9 +1404,8 @@ static void free_line_header (struct line_header *lh);
 static void add_file_name (struct line_header *, char *, unsigned int,
                            unsigned int, unsigned int);
 
-static struct line_header *(dwarf_decode_line_header
-                            (unsigned int offset,
-                             bfd *abfd, struct dwarf2_cu *cu));
+static struct line_header *dwarf_decode_line_header (unsigned int offset,
+                                                    struct dwarf2_cu *cu);
 
 static void dwarf_decode_lines (struct line_header *, const char *,
                                struct dwarf2_cu *, struct partial_symtab *,
@@ -1035,6 +1413,9 @@ static void dwarf_decode_lines (struct line_header *, const char *,
 
 static void dwarf2_start_subfile (char *, const char *, const char *);
 
+static void dwarf2_start_symtab (struct dwarf2_cu *,
+                                const char *, const char *, CORE_ADDR);
+
 static struct symbol *new_symbol (struct die_info *, struct type *,
                                  struct dwarf2_cu *);
 
@@ -1048,7 +1429,7 @@ static void dwarf2_const_value_attr (struct attribute *attr,
                                     struct type *type,
                                     const char *name,
                                     struct obstack *obstack,
-                                    struct dwarf2_cu *cu, long *value,
+                                    struct dwarf2_cu *cu, LONGEST *value,
                                     gdb_byte **bytes,
                                     struct dwarf2_locexpr_baton **baton);
 
@@ -1072,7 +1453,7 @@ static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
 
 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
 
-static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
+static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
 
 static char *typename_concat (struct obstack *obs, const char *prefix,
                              const char *suffix, int physname,
@@ -1139,54 +1520,45 @@ static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
                                                       struct dwarf2_cu *);
 
-static struct die_info *read_comp_unit (gdb_byte *, struct dwarf2_cu *);
-
-static struct die_info *read_die_and_children_1 (const struct die_reader_specs *reader,
-                                                gdb_byte *info_ptr,
-                                                gdb_byte **new_info_ptr,
-                                                struct die_info *parent);
-
-static struct die_info *read_die_and_children (const struct die_reader_specs *reader,
+static struct die_info *read_die_and_children (const struct die_reader_specs *,
                                               gdb_byte *info_ptr,
                                               gdb_byte **new_info_ptr,
                                               struct die_info *parent);
 
-static struct die_info *read_die_and_siblings (const struct die_reader_specs *reader,
+static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
                                               gdb_byte *info_ptr,
                                               gdb_byte **new_info_ptr,
                                               struct die_info *parent);
 
-static gdb_byte *read_full_die (const struct die_reader_specs *reader,
-                               struct die_info **, gdb_byte *,
-                               int *);
+static gdb_byte *read_full_die_1 (const struct die_reader_specs *,
+                                 struct die_info **, gdb_byte *, int *, int);
+
+static gdb_byte *read_full_die (const struct die_reader_specs *,
+                               struct die_info **, gdb_byte *, int *);
 
 static void process_die (struct die_info *, struct dwarf2_cu *);
 
-static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
-                                      struct obstack *);
+static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
+                                            struct obstack *);
 
-static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
+static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
 
-static const char *dwarf2_full_name (char *name,
+static const char *dwarf2_full_name (const char *name,
                                     struct die_info *die,
                                     struct dwarf2_cu *cu);
 
 static struct die_info *dwarf2_extension (struct die_info *die,
                                          struct dwarf2_cu **);
 
-static char *dwarf_tag_name (unsigned int);
+static const char *dwarf_tag_name (unsigned int);
 
-static char *dwarf_attr_name (unsigned int);
+static const char *dwarf_attr_name (unsigned int);
 
-static char *dwarf_form_name (unsigned int);
+static const char *dwarf_form_name (unsigned int);
 
 static char *dwarf_bool_name (unsigned int);
 
-static char *dwarf_type_encoding_name (unsigned int);
-
-#if 0
-static char *dwarf_cfi_name (unsigned int);
-#endif
+static const char *dwarf_type_encoding_name (unsigned int);
 
 static struct die_info *sibling_die (struct die_info *);
 
@@ -1204,7 +1576,7 @@ static void store_in_ref_table (struct die_info *,
 
 static int is_ref_attr (struct attribute *);
 
-static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
+static sect_offset dwarf2_get_ref_die_offset (struct attribute *);
 
 static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
 
@@ -1222,33 +1594,25 @@ static struct die_info *follow_die_sig (struct die_info *,
 
 static struct signatured_type *lookup_signatured_type_at_offset
     (struct objfile *objfile,
-     struct dwarf2_section_info *section,
-     unsigned int offset);
+     struct dwarf2_section_info *section, sect_offset offset);
 
-static void read_signatured_type_at_offset (struct objfile *objfile,
-                                           struct dwarf2_section_info *sect,
-                                           unsigned int offset);
+static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
 
-static void read_signatured_type (struct objfile *,
-                                 struct signatured_type *type_sig);
+static void read_signatured_type (struct signatured_type *);
+
+static struct type_unit_group *get_type_unit_group
+    (struct dwarf2_cu *, struct attribute *);
+
+static void build_type_unit_groups (die_reader_func_ftype *, void *);
 
 /* memory allocation interface */
 
 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
 
-static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
-
 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
 
-static void initialize_cu_func_list (struct dwarf2_cu *);
-
-static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
-                                struct dwarf2_cu *);
-
-static void dwarf_decode_macros (struct line_header *, unsigned int,
-                                 char *, bfd *, struct dwarf2_cu *,
-                                struct dwarf2_section_info *,
-                                int);
+static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
+                                const char *, int);
 
 static int attr_form_is_block (struct attribute *);
 
@@ -1264,9 +1628,9 @@ static void dwarf2_symbol_mark_computed (struct attribute *attr,
                                         struct symbol *sym,
                                         struct dwarf2_cu *cu);
 
-static gdb_byte *skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
-                              struct abbrev_info *abbrev,
-                              struct dwarf2_cu *cu);
+static gdb_byte *skip_one_die (const struct die_reader_specs *reader,
+                              gdb_byte *info_ptr,
+                              struct abbrev_info *abbrev);
 
 static void free_stack_comp_unit (void *);
 
@@ -1275,36 +1639,38 @@ static hashval_t partial_die_hash (const void *item);
 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
 
 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
-  (unsigned int offset, struct objfile *objfile);
-
-static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
-  (unsigned int offset, struct objfile *objfile);
+  (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
 
 static void init_one_comp_unit (struct dwarf2_cu *cu,
-                               struct objfile *objfile);
+                               struct dwarf2_per_cu_data *per_cu);
 
 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
-                                  struct die_info *comp_unit_die);
+                                  struct die_info *comp_unit_die,
+                                  enum language pretend_language);
 
-static void free_one_comp_unit (void *);
+static void free_heap_comp_unit (void *);
 
 static void free_cached_comp_units (void *);
 
 static void age_cached_comp_units (void);
 
-static void free_one_cached_comp_unit (void *);
+static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
 
 static struct type *set_die_type (struct die_info *, struct type *,
                                  struct dwarf2_cu *);
 
 static void create_all_comp_units (struct objfile *);
 
-static int create_debug_types_hash_table (struct objfile *objfile);
+static int create_all_type_units (struct objfile *);
 
 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
-                                struct objfile *);
+                                enum language);
+
+static void process_full_comp_unit (struct dwarf2_per_cu_data *,
+                                   enum language);
 
-static void process_full_comp_unit (struct dwarf2_per_cu_data *);
+static void process_full_type_unit (struct dwarf2_per_cu_data *,
+                                   enum language);
 
 static void dwarf2_add_dependence (struct dwarf2_cu *,
                                   struct dwarf2_per_cu_data *);
@@ -1313,7 +1679,7 @@ 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 (unsigned int,
+static struct type *get_die_type_at_offset (sect_offset,
                                            struct dwarf2_per_cu_data *per_cu);
 
 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
@@ -1321,29 +1687,52 @@ static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
 static void dwarf2_release_queue (void *dummy);
 
 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
-                            struct objfile *objfile);
+                            enum language pretend_language);
 
-static void process_queue (struct objfile *objfile);
+static int maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
+                                 struct dwarf2_per_cu_data *per_cu,
+                                 enum language pretend_language);
+
+static void process_queue (void);
 
 static void find_file_and_directory (struct die_info *die,
                                     struct dwarf2_cu *cu,
-                                    char **name, char **comp_dir);
+                                    const char **name, const char **comp_dir);
 
 static char *file_full_name (int file, struct line_header *lh,
                             const char *comp_dir);
 
-static gdb_byte *partial_read_comp_unit_head (struct comp_unit_head *header,
-                                             gdb_byte *info_ptr,
-                                             gdb_byte *buffer,
-                                             unsigned int buffer_size,
-                                             bfd *abfd,
-                                             int is_debug_types_section);
+static gdb_byte *read_and_check_comp_unit_head
+  (struct comp_unit_head *header,
+   struct dwarf2_section_info *section,
+   struct dwarf2_section_info *abbrev_section, gdb_byte *info_ptr,
+   int is_debug_types_section);
 
-static void init_cu_die_reader (struct die_reader_specs *reader,
-                               struct dwarf2_cu *cu);
+static void init_cutu_and_read_dies
+  (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
+   int use_existing_cu, int keep,
+   die_reader_func_ftype *die_reader_func, void *data);
+
+static void init_cutu_and_read_dies_simple
+  (struct dwarf2_per_cu_data *this_cu,
+   die_reader_func_ftype *die_reader_func, void *data);
 
 static htab_t allocate_signatured_type_table (struct objfile *objfile);
 
+static htab_t allocate_dwo_unit_table (struct objfile *objfile);
+
+static struct dwo_unit *lookup_dwo_comp_unit
+  (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
+
+static struct dwo_unit *lookup_dwo_type_unit
+  (struct signatured_type *, const char *, const char *);
+
+static void free_dwo_file_cleanup (void *);
+
+static void process_cu_includes (void);
+
+static void check_producer (struct dwarf2_cu *cu);
+
 #if WORDS_BIGENDIAN
 
 /* Convert VALUE between big- and little-endian.  */
@@ -1368,7 +1757,7 @@ byte_swap (offset_type value)
 /* The suffix for an index file.  */
 #define INDEX_SUFFIX ".gdb-index"
 
-static const char *dwarf2_physname (char *name, struct die_info *die,
+static const char *dwarf2_physname (const char *name, struct die_info *die,
                                    struct dwarf2_cu *cu);
 
 /* Try to locate the sections we need for DWARF 2 debugging
@@ -1423,13 +1812,17 @@ static void
 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
 {
   const struct dwarf2_debug_sections *names;
+  flagword aflag = bfd_get_section_flags (abfd, sectp);
 
   if (vnames == NULL)
     names = &dwarf2_elf_names;
   else
     names = (const struct dwarf2_debug_sections *) vnames;
 
-  if (section_is_p (sectp->name, &names->info))
+  if ((aflag & SEC_HAS_CONTENTS) == 0)
+    {
+    }
+  else if (section_is_p (sectp->name, &names->info))
     {
       dwarf2_per_objfile->info.asection = sectp;
       dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
@@ -1464,6 +1857,11 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
       dwarf2_per_objfile->str.asection = sectp;
       dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
     }
+  else if (section_is_p (sectp->name, &names->addr))
+    {
+      dwarf2_per_objfile->addr.asection = sectp;
+      dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
+    }
   else if (section_is_p (sectp->name, &names->frame))
     {
       dwarf2_per_objfile->frame.asection = sectp;
@@ -1471,13 +1869,8 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
     }
   else if (section_is_p (sectp->name, &names->eh_frame))
     {
-      flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
-
-      if (aflag & SEC_HAS_CONTENTS)
-        {
-         dwarf2_per_objfile->eh_frame.asection = sectp;
-          dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
-        }
+      dwarf2_per_objfile->eh_frame.asection = sectp;
+      dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
     }
   else if (section_is_p (sectp->name, &names->ranges))
     {
@@ -1506,86 +1899,8 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
     dwarf2_per_objfile->has_section_at_zero = 1;
 }
 
-/* Decompress a section that was compressed using zlib.  Store the
-   decompressed buffer, and its size, in OUTBUF and OUTSIZE.  */
-
-static void
-zlib_decompress_section (struct objfile *objfile, asection *sectp,
-                         gdb_byte **outbuf, bfd_size_type *outsize)
-{
-  bfd *abfd = objfile->obfd;
-#ifndef HAVE_ZLIB_H
-  error (_("Support for zlib-compressed DWARF data (from '%s') "
-           "is disabled in this copy of GDB"),
-         bfd_get_filename (abfd));
-#else
-  bfd_size_type compressed_size = bfd_get_section_size (sectp);
-  gdb_byte *compressed_buffer = xmalloc (compressed_size);
-  struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer);
-  bfd_size_type uncompressed_size;
-  gdb_byte *uncompressed_buffer;
-  z_stream strm;
-  int rc;
-  int header_size = 12;
-
-  if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
-      || bfd_bread (compressed_buffer,
-                   compressed_size, abfd) != compressed_size)
-    error (_("Dwarf Error: Can't read DWARF data from '%s'"),
-           bfd_get_filename (abfd));
-
-  /* Read the zlib header.  In this case, it should be "ZLIB" followed
-     by the uncompressed section size, 8 bytes in big-endian order.  */
-  if (compressed_size < header_size
-      || strncmp (compressed_buffer, "ZLIB", 4) != 0)
-    error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
-           bfd_get_filename (abfd));
-  uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
-  uncompressed_size += compressed_buffer[11];
-
-  /* It is possible the section consists of several compressed
-     buffers concatenated together, so we uncompress in a loop.  */
-  strm.zalloc = NULL;
-  strm.zfree = NULL;
-  strm.opaque = NULL;
-  strm.avail_in = compressed_size - header_size;
-  strm.next_in = (Bytef*) compressed_buffer + header_size;
-  strm.avail_out = uncompressed_size;
-  uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack,
-                                       uncompressed_size);
-  rc = inflateInit (&strm);
-  while (strm.avail_in > 0)
-    {
-      if (rc != Z_OK)
-        error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
-               bfd_get_filename (abfd), rc);
-      strm.next_out = ((Bytef*) uncompressed_buffer
-                       + (uncompressed_size - strm.avail_out));
-      rc = inflate (&strm, Z_FINISH);
-      if (rc != Z_STREAM_END)
-        error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
-               bfd_get_filename (abfd), rc);
-      rc = inflateReset (&strm);
-    }
-  rc = inflateEnd (&strm);
-  if (rc != Z_OK
-      || strm.avail_out != 0)
-    error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
-           bfd_get_filename (abfd), rc);
-
-  do_cleanups (cleanup);
-  *outbuf = uncompressed_buffer;
-  *outsize = uncompressed_size;
-#endif
-}
-
-/* A helper function that decides whether a section is empty.  */
+/* A helper function that decides whether a section is empty,
+   or not present.  */
 
 static int
 dwarf2_section_empty_p (struct dwarf2_section_info *info)
@@ -1593,68 +1908,44 @@ dwarf2_section_empty_p (struct dwarf2_section_info *info)
   return info->asection == NULL || info->size == 0;
 }
 
-/* Read the contents of the section SECTP from object file specified by
-   OBJFILE, store info about the section into INFO.
+/* Read the contents of the section INFO.
+   OBJFILE is the main object file, but not necessarily the file where
+   the section comes from.  E.g., for DWO files INFO->asection->owner
+   is the bfd of the DWO file.
    If the section is compressed, uncompress it before returning.  */
 
 static void
 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
 {
-  bfd *abfd = objfile->obfd;
   asection *sectp = info->asection;
+  bfd *abfd;
   gdb_byte *buf, *retbuf;
   unsigned char header[4];
 
   if (info->readin)
     return;
   info->buffer = NULL;
-  info->map_addr = NULL;
   info->readin = 1;
 
   if (dwarf2_section_empty_p (info))
     return;
 
-  /* Check if the file has a 4-byte header indicating compression.  */
-  if (info->size > sizeof (header)
-      && bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0
-      && bfd_bread (header, sizeof (header), abfd) == sizeof (header))
-    {
-      /* Upon decompression, update the buffer and its size.  */
-      if (strncmp (header, "ZLIB", sizeof (header)) == 0)
-        {
-          zlib_decompress_section (objfile, sectp, &info->buffer,
-                                  &info->size);
-          return;
-        }
-    }
-
-#ifdef HAVE_MMAP
-  if (pagesize == 0)
-    pagesize = getpagesize ();
+  abfd = sectp->owner;
 
-  /* Only try to mmap sections which are large enough: we don't want to
-     waste space due to fragmentation.  Also, only try mmap for sections
-     without relocations.  */
-
-  if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0)
+  /* If the section has relocations, we must read it ourselves.
+     Otherwise we attach it to the BFD.  */
+  if ((sectp->flags & SEC_RELOC) == 0)
     {
-      info->buffer = bfd_mmap (abfd, 0, info->size, PROT_READ,
-                         MAP_PRIVATE, sectp->filepos,
-                         &info->map_addr, &info->map_len);
+      const gdb_byte *bytes = gdb_bfd_map_section (sectp, &info->size);
 
-      if ((caddr_t)info->buffer != MAP_FAILED)
-       {
-#if HAVE_POSIX_MADVISE
-         posix_madvise (info->map_addr, info->map_len, POSIX_MADV_WILLNEED);
-#endif
-         return;
-       }
+      /* We have to cast away const here for historical reasons.
+        Fixing dwarf2read to be const-correct would be quite nice.  */
+      info->buffer = (gdb_byte *) bytes;
+      return;
     }
-#endif
 
-  /* If we get here, we are a normal, not-compressed section.  */
-  info->buffer = buf
-    = obstack_alloc (&objfile->objfile_obstack, info->size);
+  buf = obstack_alloc (&objfile->objfile_obstack, info->size);
+  info->buffer = buf;
 
   /* When debugging .o files, we may need to apply relocations; see
      http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
@@ -1730,23 +2021,129 @@ dwarf2_get_section_info (struct objfile *objfile,
   *sizep = info->size;
 }
 
-\f
-/* DWARF quick_symbols_functions support.  */
+/* A helper function to find the sections for a .dwz file.  */
 
-/* TUs can share .debug_line entries, and there can be a lot more TUs than
-   unique line tables, so we maintain a separate table of all .debug_line
-   derived entries to support the sharing.
-   All the quick functions need is the list of file names.  We discard the
-   line_header when we're done and don't need to record it here.  */
-struct quick_file_names
+static void
+locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
 {
-  /* The offset in .debug_line of the line table.  We hash on this.  */
-  unsigned int offset;
+  struct dwz_file *dwz_file = arg;
 
-  /* The number of entries in file_names, real_names.  */
-  unsigned int num_file_names;
+  /* Note that we only support the standard ELF names, because .dwz
+     is ELF-only (at the time of writing).  */
+  if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
+    {
+      dwz_file->abbrev.asection = sectp;
+      dwz_file->abbrev.size = bfd_get_section_size (sectp);
+    }
+  else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
+    {
+      dwz_file->info.asection = sectp;
+      dwz_file->info.size = bfd_get_section_size (sectp);
+    }
+  else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
+    {
+      dwz_file->str.asection = sectp;
+      dwz_file->str.size = bfd_get_section_size (sectp);
+    }
+  else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
+    {
+      dwz_file->line.asection = sectp;
+      dwz_file->line.size = bfd_get_section_size (sectp);
+    }
+  else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
+    {
+      dwz_file->macro.asection = sectp;
+      dwz_file->macro.size = bfd_get_section_size (sectp);
+    }
+  else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
+    {
+      dwz_file->gdb_index.asection = sectp;
+      dwz_file->gdb_index.size = bfd_get_section_size (sectp);
+    }
+}
 
-  /* The file names from the line table, after being run through
+/* Open the separate '.dwz' debug file, if needed.  Error if the file
+   cannot be found.  */
+
+static struct dwz_file *
+dwarf2_get_dwz_file (void)
+{
+  bfd *abfd, *dwz_bfd;
+  asection *section;
+  gdb_byte *data;
+  struct cleanup *cleanup;
+  const char *filename;
+  struct dwz_file *result;
+
+  if (dwarf2_per_objfile->dwz_file != NULL)
+    return dwarf2_per_objfile->dwz_file;
+
+  abfd = dwarf2_per_objfile->objfile->obfd;
+  section = bfd_get_section_by_name (abfd, ".gnu_debugaltlink");
+  if (section == NULL)
+    error (_("could not find '.gnu_debugaltlink' section"));
+  if (!bfd_malloc_and_get_section (abfd, section, &data))
+    error (_("could not read '.gnu_debugaltlink' section: %s"),
+          bfd_errmsg (bfd_get_error ()));
+  cleanup = make_cleanup (xfree, data);
+
+  filename = data;
+  if (!IS_ABSOLUTE_PATH (filename))
+    {
+      char *abs = gdb_realpath (dwarf2_per_objfile->objfile->name);
+      char *rel;
+
+      make_cleanup (xfree, abs);
+      abs = ldirname (abs);
+      make_cleanup (xfree, abs);
+
+      rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
+      make_cleanup (xfree, rel);
+      filename = rel;
+    }
+
+  /* The format is just a NUL-terminated file name, followed by the
+     build-id.  For now, though, we ignore the build-id.  */
+  dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
+  if (dwz_bfd == NULL)
+    error (_("could not read '%s': %s"), filename,
+          bfd_errmsg (bfd_get_error ()));
+
+  if (!bfd_check_format (dwz_bfd, bfd_object))
+    {
+      gdb_bfd_unref (dwz_bfd);
+      error (_("file '%s' was not usable: %s"), filename,
+            bfd_errmsg (bfd_get_error ()));
+    }
+
+  result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
+                          struct dwz_file);
+  result->dwz_bfd = dwz_bfd;
+
+  bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
+
+  do_cleanups (cleanup);
+
+  dwarf2_per_objfile->dwz_file = result;
+  return result;
+}
+\f
+/* DWARF quick_symbols_functions support.  */
+
+/* TUs can share .debug_line entries, and there can be a lot more TUs than
+   unique line tables, so we maintain a separate table of all .debug_line
+   derived entries to support the sharing.
+   All the quick functions need is the list of file names.  We discard the
+   line_header when we're done and don't need to record it here.  */
+struct quick_file_names
+{
+  /* The data used to construct the hash key.  */
+  struct stmt_list_hash hash;
+
+  /* The number of entries in file_names, real_names.  */
+  unsigned int num_file_names;
+
+  /* The file names from the line table, after being run through
      file_full_name.  */
   const char **file_names;
 
@@ -1778,6 +2175,34 @@ struct dwarf2_per_cu_quick_data
   unsigned int no_file_data : 1;
 };
 
+/* Utility hash function for a stmt_list_hash.  */
+
+static hashval_t
+hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
+{
+  hashval_t v = 0;
+
+  if (stmt_list_hash->dwo_unit != NULL)
+    v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
+  v += stmt_list_hash->line_offset.sect_off;
+  return v;
+}
+
+/* Utility equality function for a stmt_list_hash.  */
+
+static int
+eq_stmt_list_entry (const struct stmt_list_hash *lhs,
+                   const struct stmt_list_hash *rhs)
+{
+  if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
+    return 0;
+  if (lhs->dwo_unit != NULL
+      && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
+    return 0;
+
+  return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
+}
+
 /* Hash function for a quick_file_names.  */
 
 static hashval_t
@@ -1785,7 +2210,7 @@ hash_file_name_entry (const void *e)
 {
   const struct quick_file_names *file_data = e;
 
-  return file_data->offset;
+  return hash_stmt_list_entry (&file_data->hash);
 }
 
 /* Equality function for a quick_file_names.  */
@@ -1796,7 +2221,7 @@ eq_file_name_entry (const void *a, const void *b)
   const struct quick_file_names *ea = a;
   const struct quick_file_names *eb = b;
 
-  return ea->offset == eb->offset;
+  return eq_stmt_list_entry (&ea->hash, &eb->hash);
 }
 
 /* Delete function for a quick_file_names.  */
@@ -1835,34 +2260,39 @@ create_quick_file_names_table (unsigned int nr_initial_entries)
 static void
 load_cu (struct dwarf2_per_cu_data *per_cu)
 {
-  if (per_cu->debug_types_section)
-    read_signatured_type_at_offset (per_cu->objfile,
-                                   per_cu->debug_types_section,
-                                   per_cu->offset);
+  if (per_cu->is_debug_types)
+    load_full_type_unit (per_cu);
   else
-    load_full_comp_unit (per_cu, per_cu->objfile);
-
-  dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
+    load_full_comp_unit (per_cu, language_minimal);
 
   gdb_assert (per_cu->cu != NULL);
+
+  dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
 }
 
-/* Read in the symbols for PER_CU.  OBJFILE is the objfile from which
-   this CU came.  */
+/* Read in the symbols for PER_CU.  */
 
 static void
-dw2_do_instantiate_symtab (struct objfile *objfile,
-                          struct dwarf2_per_cu_data *per_cu)
+dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
 {
   struct cleanup *back_to;
 
-  back_to = make_cleanup (dwarf2_release_queue, NULL);
+  /* Skip type_unit_groups, reading the type units they contain
+     is handled elsewhere.  */
+  if (IS_TYPE_UNIT_GROUP (per_cu))
+    return;
 
-  queue_comp_unit (per_cu, objfile);
+  back_to = make_cleanup (dwarf2_release_queue, NULL);
 
-  load_cu (per_cu);
+  if (dwarf2_per_objfile->using_index
+      ? per_cu->v.quick->symtab == NULL
+      : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
+    {
+      queue_comp_unit (per_cu, language_minimal);
+      load_cu (per_cu);
+    }
 
-  process_queue (objfile);
+  process_queue ();
 
   /* Age the cache, releasing compilation units that have not
      been used recently.  */
@@ -1876,20 +2306,32 @@ dw2_do_instantiate_symtab (struct objfile *objfile,
    table.  */
 
 static struct symtab *
-dw2_instantiate_symtab (struct objfile *objfile,
-                       struct dwarf2_per_cu_data *per_cu)
+dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
 {
+  gdb_assert (dwarf2_per_objfile->using_index);
   if (!per_cu->v.quick->symtab)
     {
       struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
       increment_reading_symtab ();
-      dw2_do_instantiate_symtab (objfile, per_cu);
+      dw2_do_instantiate_symtab (per_cu);
+      process_cu_includes ();
       do_cleanups (back_to);
     }
   return per_cu->v.quick->symtab;
 }
 
-/* Return the CU given its index.  */
+/* Return the CU given its index.
+
+   This is intended for loops like:
+
+   for (i = 0; i < (dwarf2_per_objfile->n_comp_units
+                   + dwarf2_per_objfile->n_type_units); ++i)
+     {
+       struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
+
+       ...;
+     }
+*/
 
 static struct dwarf2_per_cu_data *
 dw2_get_cu (int index)
@@ -1897,76 +2339,106 @@ dw2_get_cu (int index)
   if (index >= dwarf2_per_objfile->n_comp_units)
     {
       index -= dwarf2_per_objfile->n_comp_units;
-      return dwarf2_per_objfile->type_comp_units[index];
+      gdb_assert (index < dwarf2_per_objfile->n_type_units);
+      return &dwarf2_per_objfile->all_type_units[index]->per_cu;
     }
+
   return dwarf2_per_objfile->all_comp_units[index];
 }
 
-/* A helper function that knows how to read a 64-bit value in a way
-   that doesn't make gdb die.  Returns 1 if the conversion went ok, 0
-   otherwise.  */
+/* Return the primary CU given its index.
+   The difference between this function and dw2_get_cu is in the handling
+   of type units (TUs).  Here we return the type_unit_group object.
 
-static int
-extract_cu_value (const char *bytes, ULONGEST *result)
-{
-  if (sizeof (ULONGEST) < 8)
-    {
-      int i;
+   This is intended for loops like:
 
-      /* Ignore the upper 4 bytes if they are all zero.  */
-      for (i = 0; i < 4; ++i)
-       if (bytes[i + 4] != 0)
-         return 0;
+   for (i = 0; i < (dwarf2_per_objfile->n_comp_units
+                   + dwarf2_per_objfile->n_type_unit_groups); ++i)
+     {
+       struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
+
+       ...;
+     }
+*/
 
-      *result = extract_unsigned_integer (bytes, 4, BFD_ENDIAN_LITTLE);
+static struct dwarf2_per_cu_data *
+dw2_get_primary_cu (int index)
+{
+  if (index >= dwarf2_per_objfile->n_comp_units)
+    {
+      index -= dwarf2_per_objfile->n_comp_units;
+      gdb_assert (index < dwarf2_per_objfile->n_type_unit_groups);
+      return &dwarf2_per_objfile->all_type_unit_groups[index]->per_cu;
     }
-  else
-    *result = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
-  return 1;
+
+  return dwarf2_per_objfile->all_comp_units[index];
 }
 
-/* Read the CU list from the mapped index, and use it to create all
-   the CU objects for this objfile.  Return 0 if something went wrong,
-   1 if everything went ok.  */
+/* A helper for create_cus_from_index that handles a given list of
+   CUs.  */
 
-static int
-create_cus_from_index (struct objfile *objfile, const gdb_byte *cu_list,
-                      offset_type cu_list_elements)
+static void
+create_cus_from_index_list (struct objfile *objfile,
+                           const gdb_byte *cu_list, offset_type n_elements,
+                           struct dwarf2_section_info *section,
+                           int is_dwz,
+                           int base_offset)
 {
   offset_type i;
 
-  dwarf2_per_objfile->n_comp_units = cu_list_elements / 2;
-  dwarf2_per_objfile->all_comp_units
-    = obstack_alloc (&objfile->objfile_obstack,
-                    dwarf2_per_objfile->n_comp_units
-                    * sizeof (struct dwarf2_per_cu_data *));
-
-  for (i = 0; i < cu_list_elements; i += 2)
+  for (i = 0; i < n_elements; i += 2)
     {
       struct dwarf2_per_cu_data *the_cu;
       ULONGEST offset, length;
 
-      if (!extract_cu_value (cu_list, &offset)
-         || !extract_cu_value (cu_list + 8, &length))
-       return 0;
+      gdb_static_assert (sizeof (ULONGEST) >= 8);
+      offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
+      length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
       cu_list += 2 * 8;
 
       the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
                               struct dwarf2_per_cu_data);
-      the_cu->offset = offset;
+      the_cu->offset.sect_off = offset;
       the_cu->length = length;
       the_cu->objfile = objfile;
+      the_cu->info_or_types_section = section;
       the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
                                        struct dwarf2_per_cu_quick_data);
-      dwarf2_per_objfile->all_comp_units[i / 2] = the_cu;
+      the_cu->is_dwz = is_dwz;
+      dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
     }
+}
 
-  return 1;
+/* Read the CU list from the mapped index, and use it to create all
+   the CU objects for this objfile.  */
+
+static void
+create_cus_from_index (struct objfile *objfile,
+                      const gdb_byte *cu_list, offset_type cu_list_elements,
+                      const gdb_byte *dwz_list, offset_type dwz_elements)
+{
+  struct dwz_file *dwz;
+
+  dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
+  dwarf2_per_objfile->all_comp_units
+    = obstack_alloc (&objfile->objfile_obstack,
+                    dwarf2_per_objfile->n_comp_units
+                    * sizeof (struct dwarf2_per_cu_data *));
+
+  create_cus_from_index_list (objfile, cu_list, cu_list_elements,
+                             &dwarf2_per_objfile->info, 0, 0);
+
+  if (dwz_elements == 0)
+    return;
+
+  dwz = dwarf2_get_dwz_file ();
+  create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
+                             cu_list_elements / 2);
 }
 
 /* Create the signatured type hash table from the index.  */
 
-static int
+static void
 create_signatured_type_table_from_index (struct objfile *objfile,
                                         struct dwarf2_section_info *section,
                                         const gdb_byte *bytes,
@@ -1975,46 +2447,46 @@ create_signatured_type_table_from_index (struct objfile *objfile,
   offset_type i;
   htab_t sig_types_hash;
 
-  dwarf2_per_objfile->n_type_comp_units = elements / 3;
-  dwarf2_per_objfile->type_comp_units
+  dwarf2_per_objfile->n_type_units = elements / 3;
+  dwarf2_per_objfile->all_type_units
     = obstack_alloc (&objfile->objfile_obstack,
-                    dwarf2_per_objfile->n_type_comp_units
-                    * sizeof (struct dwarf2_per_cu_data *));
+                    dwarf2_per_objfile->n_type_units
+                    * sizeof (struct signatured_type *));
 
   sig_types_hash = allocate_signatured_type_table (objfile);
 
   for (i = 0; i < elements; i += 3)
     {
-      struct signatured_type *type_sig;
-      ULONGEST offset, type_offset, signature;
+      struct signatured_type *sig_type;
+      ULONGEST offset, type_offset_in_tu, signature;
       void **slot;
 
-      if (!extract_cu_value (bytes, &offset)
-         || !extract_cu_value (bytes + 8, &type_offset))
-       return 0;
+      gdb_static_assert (sizeof (ULONGEST) >= 8);
+      offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
+      type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
+                                                   BFD_ENDIAN_LITTLE);
       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
       bytes += 3 * 8;
 
-      type_sig = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+      sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
                                 struct signatured_type);
-      type_sig->signature = signature;
-      type_sig->type_offset = type_offset;
-      type_sig->per_cu.debug_types_section = section;
-      type_sig->per_cu.offset = offset;
-      type_sig->per_cu.objfile = objfile;
-      type_sig->per_cu.v.quick
+      sig_type->signature = signature;
+      sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
+      sig_type->per_cu.is_debug_types = 1;
+      sig_type->per_cu.info_or_types_section = section;
+      sig_type->per_cu.offset.sect_off = offset;
+      sig_type->per_cu.objfile = objfile;
+      sig_type->per_cu.v.quick
        = OBSTACK_ZALLOC (&objfile->objfile_obstack,
                          struct dwarf2_per_cu_quick_data);
 
-      slot = htab_find_slot (sig_types_hash, type_sig, INSERT);
-      *slot = type_sig;
+      slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
+      *slot = sig_type;
 
-      dwarf2_per_objfile->type_comp_units[i / 3] = &type_sig->per_cu;
+      dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
     }
 
   dwarf2_per_objfile->signatured_types = sig_types_hash;
-
-  return 1;
 }
 
 /* Read the address map data from the mapped index, and use it to
@@ -2117,7 +2589,7 @@ find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
     }
 
   /* Index version 4 did not support case insensitive searches.  But the
-     indexes for case insensitive languages are built in lowercase, therefore
+     indices for case insensitive languages are built in lowercase, therefore
      simulate our NAME being searched is also lowercased.  */
   hash = mapped_index_string_hash ((index->version == 4
                                     && case_sensitivity == case_sensitive_off
@@ -2152,63 +2624,108 @@ find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
     }
 }
 
-/* Read the index file.  If everything went ok, initialize the "quick"
-   elements of all the CUs and return 1.  Otherwise, return 0.  */
+/* A helper function that reads the .gdb_index from SECTION and fills
+   in MAP.  FILENAME is the name of the file containing the section;
+   it is used for error reporting.  DEPRECATED_OK is nonzero if it is
+   ok to use deprecated sections.
+
+   CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
+   out parameters that are filled in with information about the CU and
+   TU lists in the section.
+
+   Returns 1 if all went well, 0 otherwise.  */
 
 static int
-dwarf2_read_index (struct objfile *objfile)
+read_index_from_section (struct objfile *objfile,
+                        const char *filename,
+                        int deprecated_ok,
+                        struct dwarf2_section_info *section,
+                        struct mapped_index *map,
+                        const gdb_byte **cu_list,
+                        offset_type *cu_list_elements,
+                        const gdb_byte **types_list,
+                        offset_type *types_list_elements)
 {
   char *addr;
-  struct mapped_index *map;
+  offset_type version;
   offset_type *metadata;
-  const gdb_byte *cu_list;
-  const gdb_byte *types_list = NULL;
-  offset_type version, cu_list_elements;
-  offset_type types_list_elements = 0;
   int i;
 
-  if (dwarf2_section_empty_p (&dwarf2_per_objfile->gdb_index))
+  if (dwarf2_section_empty_p (section))
     return 0;
 
   /* Older elfutils strip versions could keep the section in the main
      executable while splitting it for the separate debug info file.  */
-  if ((bfd_get_file_flags (dwarf2_per_objfile->gdb_index.asection)
-       & SEC_HAS_CONTENTS) == 0)
+  if ((bfd_get_file_flags (section->asection) & SEC_HAS_CONTENTS) == 0)
     return 0;
 
-  dwarf2_read_section (objfile, &dwarf2_per_objfile->gdb_index);
+  dwarf2_read_section (objfile, section);
 
-  addr = dwarf2_per_objfile->gdb_index.buffer;
+  addr = section->buffer;
   /* Version check.  */
   version = MAYBE_SWAP (*(offset_type *) addr);
   /* Versions earlier than 3 emitted every copy of a psymbol.  This
      causes the index to behave very poorly for certain requests.  Version 3
      contained incomplete addrmap.  So, it seems better to just ignore such
-     indices.  Index version 4 uses a different hash function than index
-     version 5 and later.  */
+     indices.  */
   if (version < 4)
-    return 0;
+    {
+      static int warning_printed = 0;
+      if (!warning_printed)
+       {
+         warning (_("Skipping obsolete .gdb_index section in %s."),
+                  filename);
+         warning_printed = 1;
+       }
+      return 0;
+    }
+  /* Index version 4 uses a different hash function than index version
+     5 and later.
+
+     Versions earlier than 6 did not emit psymbols for inlined
+     functions.  Using these files will cause GDB not to be able to
+     set breakpoints on inlined functions by name, so we ignore these
+     indices unless the user has done
+     "set use-deprecated-index-sections on".  */
+  if (version < 6 && !deprecated_ok)
+    {
+      static int warning_printed = 0;
+      if (!warning_printed)
+       {
+         warning (_("\
+Skipping deprecated .gdb_index section in %s.\n\
+Do \"set use-deprecated-index-sections on\" before the file is read\n\
+to use the section anyway."),
+                  filename);
+         warning_printed = 1;
+       }
+      return 0;
+    }
+  /* Version 7 indices generated by gold refer to the CU for a symbol instead
+     of the TU (for symbols coming from TUs).  It's just a performance bug, and
+     we can't distinguish gdb-generated indices from gold-generated ones, so
+     nothing to do here.  */
+
   /* Indexes with higher version than the one supported by GDB may be no
      longer backward compatible.  */
-  if (version > 5)
+  if (version > 8)
     return 0;
 
-  map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index);
   map->version = version;
-  map->total_size = dwarf2_per_objfile->gdb_index.size;
+  map->total_size = section->size;
 
   metadata = (offset_type *) (addr + sizeof (offset_type));
 
   i = 0;
-  cu_list = addr + MAYBE_SWAP (metadata[i]);
-  cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
-                     / 8);
+  *cu_list = addr + MAYBE_SWAP (metadata[i]);
+  *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
+                      / 8);
   ++i;
 
-  types_list = addr + MAYBE_SWAP (metadata[i]);
-  types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
-                         - MAYBE_SWAP (metadata[i]))
-                        / 8);
+  *types_list = addr + MAYBE_SWAP (metadata[i]);
+  *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
+                          - MAYBE_SWAP (metadata[i]))
+                         / 8);
   ++i;
 
   map->address_table = addr + MAYBE_SWAP (metadata[i]);
@@ -2224,9 +2741,56 @@ dwarf2_read_index (struct objfile *objfile)
 
   map->constant_pool = addr + MAYBE_SWAP (metadata[i]);
 
-  if (!create_cus_from_index (objfile, cu_list, cu_list_elements))
+  return 1;
+}
+
+
+/* Read the index file.  If everything went ok, initialize the "quick"
+   elements of all the CUs and return 1.  Otherwise, return 0.  */
+
+static int
+dwarf2_read_index (struct objfile *objfile)
+{
+  struct mapped_index local_map, *map;
+  const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
+  offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
+
+  if (!read_index_from_section (objfile, objfile->name,
+                               use_deprecated_index_sections,
+                               &dwarf2_per_objfile->gdb_index, &local_map,
+                               &cu_list, &cu_list_elements,
+                               &types_list, &types_list_elements))
+    return 0;
+
+  /* Don't use the index if it's empty.  */
+  if (local_map.symbol_table_slots == 0)
     return 0;
 
+  /* If there is a .dwz file, read it so we can get its CU list as
+     well.  */
+  if (bfd_get_section_by_name (objfile->obfd, ".gnu_debugaltlink") != NULL)
+    {
+      struct dwz_file *dwz = dwarf2_get_dwz_file ();
+      struct mapped_index dwz_map;
+      const gdb_byte *dwz_types_ignore;
+      offset_type dwz_types_elements_ignore;
+
+      if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
+                                   1,
+                                   &dwz->gdb_index, &dwz_map,
+                                   &dwz_list, &dwz_list_elements,
+                                   &dwz_types_ignore,
+                                   &dwz_types_elements_ignore))
+       {
+         warning (_("could not read '.gdb_index' section from %s; skipping"),
+                  bfd_get_filename (dwz->dwz_bfd));
+         return 0;
+       }
+    }
+
+  create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
+                        dwz_list_elements);
+
   if (types_list_elements)
     {
       struct dwarf2_section_info *section;
@@ -2239,13 +2803,14 @@ dwarf2_read_index (struct objfile *objfile)
       section = VEC_index (dwarf2_section_info_def,
                           dwarf2_per_objfile->types, 0);
 
-      if (!create_signatured_type_table_from_index (objfile, section,
-                                                   types_list,
-                                                   types_list_elements))
-       return 0;
+      create_signatured_type_table_from_index (objfile, section, types_list,
+                                              types_list_elements);
     }
 
-  create_addrmap_from_index (objfile, map);
+  create_addrmap_from_index (objfile, &local_map);
+
+  map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
+  *map = local_map;
 
   dwarf2_per_objfile->index_table = map;
   dwarf2_per_objfile->using_index = 1;
@@ -2265,74 +2830,52 @@ dw2_setup (struct objfile *objfile)
   gdb_assert (dwarf2_per_objfile);
 }
 
-/* A helper for the "quick" functions which attempts to read the line
-   table for THIS_CU.  */
+/* die_reader_func for dw2_get_file_names.  */
 
-static struct quick_file_names *
-dw2_get_file_names (struct objfile *objfile,
-                   struct dwarf2_per_cu_data *this_cu)
+static void
+dw2_get_file_names_reader (const struct die_reader_specs *reader,
+                          gdb_byte *info_ptr,
+                          struct die_info *comp_unit_die,
+                          int has_children,
+                          void *data)
 {
-  bfd *abfd = objfile->obfd;
+  struct dwarf2_cu *cu = reader->cu;
+  struct dwarf2_per_cu_data *this_cu = cu->per_cu;  
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_per_cu_data *lh_cu;
   struct line_header *lh;
   struct attribute *attr;
-  struct cleanup *cleanups;
-  struct die_info *comp_unit_die;
-  struct dwarf2_section_info* sec;
-  gdb_byte *info_ptr, *buffer;
-  int has_children, i;
-  struct dwarf2_cu cu;
-  unsigned int bytes_read, buffer_size;
-  struct die_reader_specs reader_specs;
-  char *name, *comp_dir;
+  int i;
+  const char *name, *comp_dir;
   void **slot;
   struct quick_file_names *qfn;
   unsigned int line_offset;
 
-  if (this_cu->v.quick->file_names != NULL)
-    return this_cu->v.quick->file_names;
-  /* If we know there is no line data, no point in looking again.  */
-  if (this_cu->v.quick->no_file_data)
-    return NULL;
-
-  init_one_comp_unit (&cu, objfile);
-  cleanups = make_cleanup (free_stack_comp_unit, &cu);
-
-  if (this_cu->debug_types_section)
-    sec = this_cu->debug_types_section;
-  else
-    sec = &dwarf2_per_objfile->info;
-  dwarf2_read_section (objfile, sec);
-  buffer_size = sec->size;
-  buffer = sec->buffer;
-  info_ptr = buffer + this_cu->offset;
-
-  info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr,
-                                         buffer, buffer_size,
-                                         abfd,
-                                         this_cu->debug_types_section != NULL);
-
-  /* Skip dummy compilation units.  */
-  if (info_ptr >= buffer + buffer_size
-      || peek_abbrev_code (abfd, info_ptr) == 0)
+  /* Our callers never want to match partial units -- instead they
+     will match the enclosing full CU.  */
+  if (comp_unit_die->tag == DW_TAG_partial_unit)
     {
-      do_cleanups (cleanups);
-      return NULL;
+      this_cu->v.quick->no_file_data = 1;
+      return;
     }
 
-  this_cu->cu = &cu;
-  cu.per_cu = this_cu;
-
-  dwarf2_read_abbrevs (abfd, &cu);
-  make_cleanup (dwarf2_free_abbrev_table, &cu);
+  /* If we're reading the line header for TUs, store it in the "per_cu"
+     for tu_group.  */
+  if (this_cu->is_debug_types)
+    {
+      struct type_unit_group *tu_group = data;
 
-  init_cu_die_reader (&reader_specs, &cu);
-  read_full_die (&reader_specs, &comp_unit_die, info_ptr,
-                &has_children);
+      gdb_assert (tu_group != NULL);
+      lh_cu = &tu_group->per_cu;
+    }
+  else
+    lh_cu = this_cu;
 
   lh = NULL;
   slot = NULL;
   line_offset = 0;
-  attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, &cu);
+
+  attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
   if (attr)
     {
       struct quick_file_names find_entry;
@@ -2341,31 +2884,31 @@ dw2_get_file_names (struct objfile *objfile,
 
       /* We may have already read in this line header (TU line header sharing).
         If we have we're done.  */
-      find_entry.offset = line_offset;
+      find_entry.hash.dwo_unit = cu->dwo_unit;
+      find_entry.hash.line_offset.sect_off = line_offset;
       slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
                             &find_entry, INSERT);
       if (*slot != NULL)
        {
-         do_cleanups (cleanups);
-         this_cu->v.quick->file_names = *slot;
-         return *slot;
+         lh_cu->v.quick->file_names = *slot;
+         return;
        }
 
-      lh = dwarf_decode_line_header (line_offset, abfd, &cu);
+      lh = dwarf_decode_line_header (line_offset, cu);
     }
   if (lh == NULL)
     {
-      do_cleanups (cleanups);
-      this_cu->v.quick->no_file_data = 1;
-      return NULL;
+      lh_cu->v.quick->no_file_data = 1;
+      return;
     }
 
   qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
-  qfn->offset = line_offset;
+  qfn->hash.dwo_unit = cu->dwo_unit;
+  qfn->hash.line_offset.sect_off = line_offset;
   gdb_assert (slot != NULL);
   *slot = qfn;
 
-  find_file_and_directory (comp_unit_die, &cu, &name, &comp_dir);
+  find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
 
   qfn->num_file_names = lh->num_file_names;
   qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
@@ -2375,10 +2918,44 @@ dw2_get_file_names (struct objfile *objfile,
   qfn->real_names = NULL;
 
   free_line_header (lh);
-  do_cleanups (cleanups);
 
-  this_cu->v.quick->file_names = qfn;
-  return qfn;
+  lh_cu->v.quick->file_names = qfn;
+}
+
+/* A helper for the "quick" functions which attempts to read the line
+   table for THIS_CU.  */
+
+static struct quick_file_names *
+dw2_get_file_names (struct objfile *objfile,
+                   struct dwarf2_per_cu_data *this_cu)
+{
+  /* For TUs this should only be called on the parent group.  */
+  if (this_cu->is_debug_types)
+    gdb_assert (IS_TYPE_UNIT_GROUP (this_cu));
+
+  if (this_cu->v.quick->file_names != NULL)
+    return this_cu->v.quick->file_names;
+  /* If we know there is no line data, no point in looking again.  */
+  if (this_cu->v.quick->no_file_data)
+    return NULL;
+
+  /* If DWO files are in use, we can still find the DW_AT_stmt_list attribute
+     in the stub for CUs, there's is no need to lookup the DWO file.
+     However, that's not the case for TUs where DW_AT_stmt_list lives in the
+     DWO file.  */
+  if (this_cu->is_debug_types)
+    {
+      struct type_unit_group *tu_group = this_cu->type_unit_group;
+
+      init_cutu_and_read_dies (tu_group->t.first_tu, NULL, 0, 0,
+                              dw2_get_file_names_reader, tu_group);
+    }
+  else
+    init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
+
+  if (this_cu->v.quick->no_file_data)
+    return NULL;
+  return this_cu->v.quick->file_names;
 }
 
 /* A helper for the "quick" functions which computes and caches the
@@ -2405,7 +2982,7 @@ dw2_find_last_source_symtab (struct objfile *objfile)
 
   dw2_setup (objfile);
   index = dwarf2_per_objfile->n_comp_units - 1;
-  return dw2_instantiate_symtab (objfile, dw2_get_cu (index));
+  return dw2_instantiate_symtab (dw2_get_cu (index));
 }
 
 /* Traversal function for dw2_forget_cached_source_info.  */
@@ -2444,8 +3021,7 @@ dw2_forget_cached_source_info (struct objfile *objfile)
 static int
 dw2_map_expand_apply (struct objfile *objfile,
                      struct dwarf2_per_cu_data *per_cu,
-                     const char *name,
-                     const char *full_path, const char *real_path,
+                     const char *name, const char *real_path,
                      int (*callback) (struct symtab *, void *),
                      void *data)
 {
@@ -2457,9 +3033,9 @@ dw2_map_expand_apply (struct objfile *objfile,
 
   /* This may expand more than one symtab, and we want to iterate over
      all of them.  */
-  dw2_instantiate_symtab (objfile, per_cu);
+  dw2_instantiate_symtab (per_cu);
 
-  return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
+  return iterate_over_some_symtabs (name, real_path, callback, data,
                                    objfile->symtabs, last_made);
 }
 
@@ -2467,22 +3043,22 @@ dw2_map_expand_apply (struct objfile *objfile,
 
 static int
 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
-                                  const char *full_path, const char *real_path,
+                                  const char *real_path,
                                   int (*callback) (struct symtab *, void *),
                                   void *data)
 {
   int i;
   const char *name_basename = lbasename (name);
-  int check_basename = name_basename == name;
-  struct dwarf2_per_cu_data *base_cu = NULL;
 
   dw2_setup (objfile);
 
-  for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                  + dwarf2_per_objfile->n_type_comp_units); ++i)
+  /* The rule is CUs specify all the files, including those used by
+     any TU, so there's no need to scan TUs here.  */
+
+  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
     {
       int j;
-      struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
+      struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
       struct quick_file_names *file_data;
 
       /* We only need to look at symtabs not already expanded.  */
@@ -2496,50 +3072,37 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
       for (j = 0; j < file_data->num_file_names; ++j)
        {
          const char *this_name = file_data->file_names[j];
+         const char *this_real_name;
 
-         if (FILENAME_CMP (name, this_name) == 0)
+         if (compare_filenames_for_search (this_name, name))
            {
-             if (dw2_map_expand_apply (objfile, per_cu,
-                                       name, full_path, real_path,
+             if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
                                        callback, data))
                return 1;
            }
 
-         if (check_basename && ! base_cu
-             && FILENAME_CMP (lbasename (this_name), name) == 0)
-           base_cu = per_cu;
-
          /* Before we invoke realpath, which can get expensive when many
             files are involved, do a quick comparison of the basenames.  */
          if (! basenames_may_differ
              && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
            continue;
 
-         if (full_path != NULL)
+         this_real_name = dw2_get_real_path (objfile, file_data, j);
+         if (compare_filenames_for_search (this_real_name, name))
            {
-             const char *this_real_name = dw2_get_real_path (objfile,
-                                                             file_data, j);
-
-             if (this_real_name != NULL
-                 && FILENAME_CMP (full_path, this_real_name) == 0)
-               {
-                 if (dw2_map_expand_apply (objfile, per_cu,
-                                           name, full_path, real_path,
-                                           callback, data))
-                   return 1;
-               }
+             if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
+                                       callback, data))
+               return 1;
            }
 
          if (real_path != NULL)
            {
-             const char *this_real_name = dw2_get_real_path (objfile,
-                                                             file_data, j);
-
+             gdb_assert (IS_ABSOLUTE_PATH (real_path));
+             gdb_assert (IS_ABSOLUTE_PATH (name));
              if (this_real_name != NULL
                  && FILENAME_CMP (real_path, this_real_name) == 0)
                {
-                 if (dw2_map_expand_apply (objfile, per_cu,
-                                           name, full_path, real_path,
+                 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
                                            callback, data))
                    return 1;
                }
@@ -2547,60 +3110,171 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
        }
     }
 
-  if (base_cu)
-    {
-      if (dw2_map_expand_apply (objfile, base_cu,
-                               name, full_path, real_path,
-                               callback, data))
-       return 1;
-    }
-
   return 0;
 }
 
-static struct symtab *
-dw2_lookup_symbol (struct objfile *objfile, int block_index,
-                  const char *name, domain_enum domain)
+/* Struct used to manage iterating over all CUs looking for a symbol.  */
+
+struct dw2_symtab_iterator
 {
-  /* We do all the work in the pre_expand_symtabs_matching hook
-     instead.  */
-  return NULL;
-}
+  /* The internalized form of .gdb_index.  */
+  struct mapped_index *index;
+  /* If non-zero, only look for symbols that match BLOCK_INDEX.  */
+  int want_specific_block;
+  /* One of GLOBAL_BLOCK or STATIC_BLOCK.
+     Unused if !WANT_SPECIFIC_BLOCK.  */
+  int block_index;
+  /* The kind of symbol we're looking for.  */
+  domain_enum domain;
+  /* The list of CUs from the index entry of the symbol,
+     or NULL if not found.  */
+  offset_type *vec;
+  /* The next element in VEC to look at.  */
+  int next;
+  /* The number of elements in VEC, or zero if there is no match.  */
+  int length;
+};
 
-/* A helper function that expands all symtabs that hold an object
-   named NAME.  */
+/* Initialize the index symtab iterator ITER.
+   If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
+   in block BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
 
 static void
-dw2_do_expand_symtabs_matching (struct objfile *objfile, const char *name)
-{
-  dw2_setup (objfile);
-
-  /* index_table is NULL if OBJF_READNOW.  */
-  if (dwarf2_per_objfile->index_table)
+dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
+                     struct mapped_index *index,
+                     int want_specific_block,
+                     int block_index,
+                     domain_enum domain,
+                     const char *name)
+{
+  iter->index = index;
+  iter->want_specific_block = want_specific_block;
+  iter->block_index = block_index;
+  iter->domain = domain;
+  iter->next = 0;
+
+  if (find_slot_in_mapped_hash (index, name, &iter->vec))
+    iter->length = MAYBE_SWAP (*iter->vec);
+  else
     {
-      offset_type *vec;
+      iter->vec = NULL;
+      iter->length = 0;
+    }
+}
 
-      if (find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
-                                   name, &vec))
+/* Return the next matching CU or NULL if there are no more.  */
+
+static struct dwarf2_per_cu_data *
+dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
+{
+  for ( ; iter->next < iter->length; ++iter->next)
+    {
+      offset_type cu_index_and_attrs =
+       MAYBE_SWAP (iter->vec[iter->next + 1]);
+      offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
+      struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index);
+      int want_static = iter->block_index != GLOBAL_BLOCK;
+      /* This value is only valid for index versions >= 7.  */
+      int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
+      gdb_index_symbol_kind symbol_kind =
+       GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
+      /* Only check the symbol attributes if they're present.
+        Indices prior to version 7 don't record them,
+        and indices >= 7 may elide them for certain symbols
+        (gold does this).  */
+      int attrs_valid =
+       (iter->index->version >= 7
+        && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
+
+      /* Skip if already read in.  */
+      if (per_cu->v.quick->symtab)
+       continue;
+
+      if (attrs_valid
+         && iter->want_specific_block
+         && want_static != is_static)
+       continue;
+
+      /* Only check the symbol's kind if it has one.  */
+      if (attrs_valid)
        {
-         offset_type i, len = MAYBE_SWAP (*vec);
-         for (i = 0; i < len; ++i)
+         switch (iter->domain)
            {
-             offset_type cu_index = MAYBE_SWAP (vec[i + 1]);
-             struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index);
-
-             dw2_instantiate_symtab (objfile, per_cu);
+           case VAR_DOMAIN:
+             if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
+                 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
+                 /* Some types are also in VAR_DOMAIN.  */
+                 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
+               continue;
+             break;
+           case STRUCT_DOMAIN:
+             if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
+               continue;
+             break;
+           case LABEL_DOMAIN:
+             if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
+               continue;
+             break;
+           default:
+             break;
            }
        }
+
+      ++iter->next;
+      return per_cu;
     }
+
+  return NULL;
 }
 
-static void
-dw2_pre_expand_symtabs_matching (struct objfile *objfile,
-                                enum block_enum block_kind, const char *name,
-                                domain_enum domain)
+static struct symtab *
+dw2_lookup_symbol (struct objfile *objfile, int block_index,
+                  const char *name, domain_enum domain)
 {
-  dw2_do_expand_symtabs_matching (objfile, name);
+  struct symtab *stab_best = NULL;
+  struct mapped_index *index;
+
+  dw2_setup (objfile);
+
+  index = dwarf2_per_objfile->index_table;
+
+  /* index is NULL if OBJF_READNOW.  */
+  if (index)
+    {
+      struct dw2_symtab_iterator iter;
+      struct dwarf2_per_cu_data *per_cu;
+
+      dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
+
+      while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
+       {
+         struct symbol *sym = NULL;
+         struct symtab *stab = dw2_instantiate_symtab (per_cu);
+
+         /* Some caution must be observed with overloaded functions
+            and methods, since the index will not contain any overload
+            information (but NAME might contain it).  */
+         if (stab->primary)
+           {
+             struct blockvector *bv = BLOCKVECTOR (stab);
+             struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
+
+             sym = lookup_block_symbol (block, name, domain);
+           }
+
+         if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
+           {
+             if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+               return stab;
+
+             stab_best = stab;
+           }
+
+         /* Keep looking through other CUs.  */
+       }
+    }
+
+  return stab_best;
 }
 
 static void
@@ -2611,7 +3285,7 @@ dw2_print_stats (struct objfile *objfile)
   dw2_setup (objfile);
   count = 0;
   for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                  + dwarf2_per_objfile->n_type_comp_units); ++i)
+                  + dwarf2_per_objfile->n_type_units); ++i)
     {
       struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
 
@@ -2638,7 +3312,25 @@ static void
 dw2_expand_symtabs_for_function (struct objfile *objfile,
                                 const char *func_name)
 {
-  dw2_do_expand_symtabs_matching (objfile, func_name);
+  struct mapped_index *index;
+
+  dw2_setup (objfile);
+
+  index = dwarf2_per_objfile->index_table;
+
+  /* index is NULL if OBJF_READNOW.  */
+  if (index)
+    {
+      struct dw2_symtab_iterator iter;
+      struct dwarf2_per_cu_data *per_cu;
+
+      /* Note: It doesn't matter what we pass for block_index here.  */
+      dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
+                           func_name);
+
+      while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
+       dw2_instantiate_symtab (per_cu);
+    }
 }
 
 static void
@@ -2649,17 +3341,17 @@ dw2_expand_all_symtabs (struct objfile *objfile)
   dw2_setup (objfile);
 
   for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                  + dwarf2_per_objfile->n_type_comp_units); ++i)
+                  + dwarf2_per_objfile->n_type_units); ++i)
     {
       struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
 
-      dw2_instantiate_symtab (objfile, per_cu);
+      dw2_instantiate_symtab (per_cu);
     }
 }
 
 static void
-dw2_expand_symtabs_with_filename (struct objfile *objfile,
-                                 const char *filename)
+dw2_expand_symtabs_with_fullname (struct objfile *objfile,
+                                 const char *fullname)
 {
   int i;
 
@@ -2686,22 +3378,44 @@ dw2_expand_symtabs_with_filename (struct objfile *objfile,
 
       for (j = 0; j < file_data->num_file_names; ++j)
        {
-         const char *this_name = file_data->file_names[j];
-         if (FILENAME_CMP (this_name, filename) == 0)
+         const char *this_fullname = file_data->file_names[j];
+
+         if (filename_cmp (this_fullname, fullname) == 0)
            {
-             dw2_instantiate_symtab (objfile, per_cu);
+             dw2_instantiate_symtab (per_cu);
              break;
            }
        }
     }
 }
 
+/* A helper function for dw2_find_symbol_file that finds the primary
+   file name for a given CU.  This is a die_reader_func.  */
+
+static void
+dw2_get_primary_filename_reader (const struct die_reader_specs *reader,
+                                gdb_byte *info_ptr,
+                                struct die_info *comp_unit_die,
+                                int has_children,
+                                void *data)
+{
+  const char **result_ptr = data;
+  struct dwarf2_cu *cu = reader->cu;
+  struct attribute *attr;
+
+  attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
+  if (attr == NULL)
+    *result_ptr = NULL;
+  else
+    *result_ptr = DW_STRING (attr);
+}
+
 static const char *
 dw2_find_symbol_file (struct objfile *objfile, const char *name)
 {
   struct dwarf2_per_cu_data *per_cu;
   offset_type *vec;
-  struct quick_file_names *file_data;
+  const char *filename;
 
   dw2_setup (objfile);
 
@@ -2710,16 +3424,18 @@ dw2_find_symbol_file (struct objfile *objfile, const char *name)
     {
       struct symtab *s;
 
-      ALL_OBJFILE_SYMTABS (objfile, s)
-       if (s->primary)
-         {
-           struct blockvector *bv = BLOCKVECTOR (s);
-           const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-           struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
+      ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
+       {
+         struct blockvector *bv = BLOCKVECTOR (s);
+         const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+         struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
 
-           if (sym)
-             return sym->symtab->filename;
-         }
+         if (sym)
+           {
+             /* Only file extension of returned filename is recognized.  */
+             return SYMBOL_SYMTAB (sym)->filename;
+           }
+       }
       return NULL;
     }
 
@@ -2732,13 +3448,19 @@ dw2_find_symbol_file (struct objfile *objfile, const char *name)
      should be rewritten so that it doesn't require a custom hook.  It
      could just use the ordinary symbol tables.  */
   /* vec[0] is the length, which must always be >0.  */
-  per_cu = dw2_get_cu (MAYBE_SWAP (vec[1]));
+  per_cu = dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec[1])));
 
-  file_data = dw2_get_file_names (objfile, per_cu);
-  if (file_data == NULL)
-    return NULL;
+  if (per_cu->v.quick->symtab != NULL)
+    {
+      /* Only file extension of returned filename is recognized.  */
+      return per_cu->v.quick->symtab->filename;
+    }
+
+  init_cutu_and_read_dies (per_cu, NULL, 0, 0,
+                          dw2_get_primary_filename_reader, &filename);
 
-  return file_data->file_names[file_data->num_file_names - 1];
+  /* Only file extension of returned filename is recognized.  */
+  return filename;
 }
 
 static void
@@ -2757,8 +3479,8 @@ dw2_map_matching_symbols (const char * name, domain_enum namespace,
 static void
 dw2_expand_symtabs_matching
   (struct objfile *objfile,
-   int (*file_matcher) (const char *, void *),
-   int (*name_matcher) (const struct language_defn *, const char *, void *),
+   int (*file_matcher) (const char *, void *, int basenames),
+   int (*name_matcher) (const char *, void *),
    enum search_domain kind,
    void *data)
 {
@@ -2774,32 +3496,81 @@ dw2_expand_symtabs_matching
   index = dwarf2_per_objfile->index_table;
 
   if (file_matcher != NULL)
-    for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                    + dwarf2_per_objfile->n_type_comp_units); ++i)
-      {
-       int j;
-       struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
-       struct quick_file_names *file_data;
+    {
+      struct cleanup *cleanup;
+      htab_t visited_found, visited_not_found;
 
-       per_cu->v.quick->mark = 0;
+      visited_found = htab_create_alloc (10,
+                                        htab_hash_pointer, htab_eq_pointer,
+                                        NULL, xcalloc, xfree);
+      cleanup = make_cleanup_htab_delete (visited_found);
+      visited_not_found = htab_create_alloc (10,
+                                            htab_hash_pointer, htab_eq_pointer,
+                                            NULL, xcalloc, xfree);
+      make_cleanup_htab_delete (visited_not_found);
 
-       /* We only need to look at symtabs not already expanded.  */
-       if (per_cu->v.quick->symtab)
-         continue;
+      /* The rule is CUs specify all the files, including those used by
+        any TU, so there's no need to scan TUs here.  */
 
-       file_data = dw2_get_file_names (objfile, per_cu);
-       if (file_data == NULL)
-         continue;
+      for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+       {
+         int j;
+         struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
+         struct quick_file_names *file_data;
+         void **slot;
 
-       for (j = 0; j < file_data->num_file_names; ++j)
-         {
-           if (file_matcher (file_data->file_names[j], data))
-             {
-               per_cu->v.quick->mark = 1;
-               break;
-             }
-         }
-      }
+         per_cu->v.quick->mark = 0;
+
+         /* We only need to look at symtabs not already expanded.  */
+         if (per_cu->v.quick->symtab)
+           continue;
+
+         file_data = dw2_get_file_names (objfile, per_cu);
+         if (file_data == NULL)
+           continue;
+
+         if (htab_find (visited_not_found, file_data) != NULL)
+           continue;
+         else if (htab_find (visited_found, file_data) != NULL)
+           {
+             per_cu->v.quick->mark = 1;
+             continue;
+           }
+
+         for (j = 0; j < file_data->num_file_names; ++j)
+           {
+             const char *this_real_name;
+
+             if (file_matcher (file_data->file_names[j], data, 0))
+               {
+                 per_cu->v.quick->mark = 1;
+                 break;
+               }
+
+             /* Before we invoke realpath, which can get expensive when many
+                files are involved, do a quick comparison of the basenames.  */
+             if (!basenames_may_differ
+                 && !file_matcher (lbasename (file_data->file_names[j]),
+                                   data, 1))
+               continue;
+
+             this_real_name = dw2_get_real_path (objfile, file_data, j);
+             if (file_matcher (this_real_name, data, 0))
+               {
+                 per_cu->v.quick->mark = 1;
+                 break;
+               }
+           }
+
+         slot = htab_find_slot (per_cu->v.quick->mark
+                                ? visited_found
+                                : visited_not_found,
+                                file_data, INSERT);
+         *slot = file_data;
+       }
+
+      do_cleanups (cleanup);
+    }
 
   for (iter = 0; iter < index->symbol_table_slots; ++iter)
     {
@@ -2812,7 +3583,7 @@ dw2_expand_symtabs_matching
 
       name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
 
-      if (! (*name_matcher) (current_language, name, data))
+      if (! (*name_matcher) (name, data))
        continue;
 
       /* The name was matched, now expand corresponding CUs that were
@@ -2823,14 +3594,73 @@ dw2_expand_symtabs_matching
       for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
        {
          struct dwarf2_per_cu_data *per_cu;
+         offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
+         gdb_index_symbol_kind symbol_kind =
+           GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
+         int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
+
+         /* Don't crash on bad data.  */
+         if (cu_index >= (dwarf2_per_objfile->n_comp_units
+                          + dwarf2_per_objfile->n_type_units))
+           continue;
+
+         /* Only check the symbol's kind if it has one.
+            Indices prior to version 7 don't record it.  */
+         if (index->version >= 7)
+           {
+             switch (kind)
+               {
+               case VARIABLES_DOMAIN:
+                 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
+                   continue;
+                 break;
+               case FUNCTIONS_DOMAIN:
+                 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
+                   continue;
+                 break;
+               case TYPES_DOMAIN:
+                 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
+                   continue;
+                 break;
+               default:
+                 break;
+               }
+           }
 
-         per_cu = dw2_get_cu (MAYBE_SWAP (vec[vec_idx + 1]));
+         per_cu = dw2_get_cu (cu_index);
          if (file_matcher == NULL || per_cu->v.quick->mark)
-           dw2_instantiate_symtab (objfile, per_cu);
+           dw2_instantiate_symtab (per_cu);
        }
     }
 }
 
+/* A helper for dw2_find_pc_sect_symtab which finds the most specific
+   symtab.  */
+
+static struct symtab *
+recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
+{
+  int i;
+
+  if (BLOCKVECTOR (symtab) != NULL
+      && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
+    return symtab;
+
+  if (symtab->includes == NULL)
+    return NULL;
+
+  for (i = 0; symtab->includes[i]; ++i)
+    {
+      struct symtab *s = symtab->includes[i];
+
+      s = recursively_find_pc_sect_symtab (s, pc);
+      if (s != NULL)
+       return s;
+    }
+
+  return NULL;
+}
+
 static struct symtab *
 dw2_find_pc_sect_symtab (struct objfile *objfile,
                         struct minimal_symbol *msymbol,
@@ -2839,6 +3669,7 @@ dw2_find_pc_sect_symtab (struct objfile *objfile,
                         int warn_if_readin)
 {
   struct dwarf2_per_cu_data *data;
+  struct symtab *result;
 
   dw2_setup (objfile);
 
@@ -2853,7 +3684,9 @@ dw2_find_pc_sect_symtab (struct objfile *objfile,
     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
             paddress (get_objfile_arch (objfile), pc));
 
-  return dw2_instantiate_symtab (objfile, data);
+  result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
+  gdb_assert (result != NULL);
+  return result;
 }
 
 static void
@@ -2861,15 +3694,36 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
                          void *data, int need_fullname)
 {
   int i;
+  struct cleanup *cleanup;
+  htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
+                                     NULL, xcalloc, xfree);
 
+  cleanup = make_cleanup_htab_delete (visited);
   dw2_setup (objfile);
 
-  for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                  + dwarf2_per_objfile->n_type_comp_units); ++i)
+  /* The rule is CUs specify all the files, including those used by
+     any TU, so there's no need to scan TUs here.
+     We can ignore file names coming from already-expanded CUs.  */
+
+  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
     {
-      int j;
       struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
+
+      if (per_cu->v.quick->symtab)
+       {
+         void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
+                                       INSERT);
+
+         *slot = per_cu->v.quick->file_names;
+       }
+    }
+
+  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+    {
+      int j;
+      struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
       struct quick_file_names *file_data;
+      void **slot;
 
       /* We only need to look at symtabs not already expanded.  */
       if (per_cu->v.quick->symtab)
@@ -2879,6 +3733,14 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
       if (file_data == NULL)
        continue;
 
+      slot = htab_find_slot (visited, file_data, INSERT);
+      if (*slot)
+       {
+         /* Already visited.  */
+         continue;
+       }
+      *slot = file_data;
+
       for (j = 0; j < file_data->num_file_names; ++j)
        {
          const char *this_real_name;
@@ -2890,6 +3752,8 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
          (*fun) (file_data->file_names[j], this_real_name, data);
        }
     }
+
+  do_cleanups (cleanup);
 }
 
 static int
@@ -2905,13 +3769,12 @@ const struct quick_symbol_functions dwarf2_gdb_index_functions =
   dw2_forget_cached_source_info,
   dw2_map_symtabs_matching_filename,
   dw2_lookup_symbol,
-  dw2_pre_expand_symtabs_matching,
   dw2_print_stats,
   dw2_dump,
   dw2_relocate,
   dw2_expand_symtabs_for_function,
   dw2_expand_all_symtabs,
-  dw2_expand_symtabs_with_filename,
+  dw2_expand_symtabs_with_fullname,
   dw2_find_symbol_file,
   dw2_map_matching_symbols,
   dw2_expand_symtabs_matching,
@@ -2935,12 +3798,12 @@ dwarf2_initialize_objfile (struct objfile *objfile)
 
       dwarf2_per_objfile->using_index = 1;
       create_all_comp_units (objfile);
-      create_debug_types_hash_table (objfile);
+      create_all_type_units (objfile);
       dwarf2_per_objfile->quick_file_names_table =
        create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
 
       for (i = 0; i < (dwarf2_per_objfile->n_comp_units
-                      + dwarf2_per_objfile->n_type_comp_units); ++i)
+                      + dwarf2_per_objfile->n_type_units); ++i)
        {
          struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
 
@@ -2967,25 +3830,75 @@ dwarf2_initialize_objfile (struct objfile *objfile)
 void
 dwarf2_build_psymtabs (struct objfile *objfile)
 {
+  volatile struct gdb_exception except;
+
   if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
     {
       init_psymbol_list (objfile, 1024);
     }
 
-  dwarf2_build_psymtabs_hard (objfile);
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      /* This isn't really ideal: all the data we allocate on the
+        objfile's obstack is still uselessly kept around.  However,
+        freeing it seems unsafe.  */
+      struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
+
+      dwarf2_build_psymtabs_hard (objfile);
+      discard_cleanups (cleanups);
+    }
+  if (except.reason < 0)
+    exception_print (gdb_stderr, except);
+}
+
+/* Return the total length of the CU described by HEADER.  */
+
+static unsigned int
+get_cu_length (const struct comp_unit_head *header)
+{
+  return header->initial_length_size + header->length;
 }
 
 /* Return TRUE if OFFSET is within CU_HEADER.  */
 
 static inline int
-offset_in_cu_p (const struct comp_unit_head *cu_header, unsigned int offset)
+offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
+{
+  sect_offset bottom = { cu_header->offset.sect_off };
+  sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
+
+  return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
+}
+
+/* Find the base address of the compilation unit for range lists and
+   location lists.  It will normally be specified by DW_AT_low_pc.
+   In DWARF-3 draft 4, the base address could be overridden by
+   DW_AT_entry_pc.  It's been removed, but GCC still uses this for
+   compilation units with discontinuous ranges.  */
+
+static void
+dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
 {
-  unsigned int bottom = cu_header->offset;
-  unsigned int top = (cu_header->offset
-                     + cu_header->length
-                     + cu_header->initial_length_size);
+  struct attribute *attr;
 
-  return (offset >= bottom && offset < top);
+  cu->base_known = 0;
+  cu->base_address = 0;
+
+  attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
+  if (attr)
+    {
+      cu->base_address = DW_ADDR (attr);
+      cu->base_known = 1;
+    }
+  else
+    {
+      attr = dwarf2_attr (die, DW_AT_low_pc, cu);
+      if (attr)
+       {
+         cu->base_address = DW_ADDR (attr);
+         cu->base_known = 1;
+       }
+    }
 }
 
 /* Read in the comp unit header information from the debug_info at info_ptr.
@@ -3005,8 +3918,8 @@ read_comp_unit_head (struct comp_unit_head *cu_header,
   info_ptr += bytes_read;
   cu_header->version = read_2_bytes (abfd, info_ptr);
   info_ptr += 2;
-  cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
-                                         &bytes_read);
+  cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
+                                            &bytes_read);
   info_ptr += bytes_read;
   cu_header->addr_size = read_1_byte (abfd, info_ptr);
   info_ptr += 1;
@@ -3019,47 +3932,82 @@ read_comp_unit_head (struct comp_unit_head *cu_header,
   return info_ptr;
 }
 
-/* Read in a CU header and perform some basic error checking.  */
+/* Helper function that returns the proper abbrev section for
+   THIS_CU.  */
 
-static gdb_byte *
-partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
-                            gdb_byte *buffer, unsigned int buffer_size,
-                            bfd *abfd, int is_debug_types_section)
+static struct dwarf2_section_info *
+get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
 {
-  gdb_byte *beg_of_comp_unit = info_ptr;
+  struct dwarf2_section_info *abbrev;
 
-  header->offset = beg_of_comp_unit - buffer;
+  if (this_cu->is_dwz)
+    abbrev = &dwarf2_get_dwz_file ()->abbrev;
+  else
+    abbrev = &dwarf2_per_objfile->abbrev;
 
-  info_ptr = read_comp_unit_head (header, info_ptr, abfd);
+  return abbrev;
+}
 
-  /* If we're reading a type unit, skip over the signature and
-     type_offset fields.  */
-  if (is_debug_types_section)
-    info_ptr += 8 /*signature*/ + header->offset_size;
+/* Subroutine of read_and_check_comp_unit_head and
+   read_and_check_type_unit_head to simplify them.
+   Perform various error checking on the header.  */
 
-  header->first_die_offset = info_ptr - beg_of_comp_unit;
+static void
+error_check_comp_unit_head (struct comp_unit_head *header,
+                           struct dwarf2_section_info *section,
+                           struct dwarf2_section_info *abbrev_section)
+{
+  bfd *abfd = section->asection->owner;
+  const char *filename = bfd_get_filename (abfd);
 
   if (header->version != 2 && header->version != 3 && header->version != 4)
     error (_("Dwarf Error: wrong version in compilation unit header "
           "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
-          bfd_get_filename (abfd));
+          filename);
 
-  if (header->abbrev_offset
-      >= dwarf2_section_size (dwarf2_per_objfile->objfile,
-                             &dwarf2_per_objfile->abbrev))
+  if (header->abbrev_offset.sect_off
+      >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
     error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
           "(offset 0x%lx + 6) [in module %s]"),
-          (long) header->abbrev_offset,
-          (long) (beg_of_comp_unit - buffer),
-          bfd_get_filename (abfd));
+          (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
+          filename);
 
-  if (beg_of_comp_unit + header->length + header->initial_length_size
-      > buffer + buffer_size)
+  /* Cast to unsigned long to use 64-bit arithmetic when possible to
+     avoid potential 32-bit overflow.  */
+  if (((unsigned long) header->offset.sect_off + get_cu_length (header))
+      > section->size)
     error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
           "(offset 0x%lx + 0) [in module %s]"),
-          (long) header->length,
-          (long) (beg_of_comp_unit - buffer),
-          bfd_get_filename (abfd));
+          (long) header->length, (long) header->offset.sect_off,
+          filename);
+}
+
+/* Read in a CU/TU header and perform some basic error checking.
+   The contents of the header are stored in HEADER.
+   The result is a pointer to the start of the first DIE.  */
+
+static gdb_byte *
+read_and_check_comp_unit_head (struct comp_unit_head *header,
+                              struct dwarf2_section_info *section,
+                              struct dwarf2_section_info *abbrev_section,
+                              gdb_byte *info_ptr,
+                              int is_debug_types_section)
+{
+  gdb_byte *beg_of_comp_unit = info_ptr;
+  bfd *abfd = section->asection->owner;
+
+  header->offset.sect_off = beg_of_comp_unit - section->buffer;
+
+  info_ptr = read_comp_unit_head (header, info_ptr, abfd);
+
+  /* If we're reading a type unit, skip over the signature and
+     type_offset fields.  */
+  if (is_debug_types_section)
+    info_ptr += 8 /*signature*/ + header->offset_size;
+
+  header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
+
+  error_check_comp_unit_head (header, section, abbrev_section);
 
   return info_ptr;
 }
@@ -3068,35 +4016,72 @@ partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
    types_ptr.  The result is a pointer to one past the end of the header.  */
 
 static gdb_byte *
-read_type_comp_unit_head (struct comp_unit_head *cu_header,
-                         struct dwarf2_section_info *section,
-                         ULONGEST *signature,
-                         gdb_byte *types_ptr, bfd *abfd)
+read_and_check_type_unit_head (struct comp_unit_head *header,
+                              struct dwarf2_section_info *section,
+                              struct dwarf2_section_info *abbrev_section,
+                              gdb_byte *info_ptr,
+                              ULONGEST *signature,
+                              cu_offset *type_offset_in_tu)
 {
-  gdb_byte *initial_types_ptr = types_ptr;
+  gdb_byte *beg_of_comp_unit = info_ptr;
+  bfd *abfd = section->asection->owner;
 
-  dwarf2_read_section (dwarf2_per_objfile->objfile, section);
-  cu_header->offset = types_ptr - section->buffer;
+  header->offset.sect_off = beg_of_comp_unit - section->buffer;
+
+  info_ptr = read_comp_unit_head (header, info_ptr, abfd);
+
+  /* If we're reading a type unit, skip over the signature and
+     type_offset fields.  */
+  if (signature != NULL)
+    *signature = read_8_bytes (abfd, info_ptr);
+  info_ptr += 8;
+  if (type_offset_in_tu != NULL)
+    type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
+                                              header->offset_size);
+  info_ptr += header->offset_size;
 
-  types_ptr = read_comp_unit_head (cu_header, types_ptr, abfd);
+  header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
 
-  *signature = read_8_bytes (abfd, types_ptr);
-  types_ptr += 8;
-  types_ptr += cu_header->offset_size;
-  cu_header->first_die_offset = types_ptr - initial_types_ptr;
+  error_check_comp_unit_head (header, section, abbrev_section);
 
-  return types_ptr;
+  return info_ptr;
 }
 
-/* Allocate a new partial symtab for file named NAME and mark this new
-   partial symtab as being an include of PST.  */
+/* Fetch the abbreviation table offset from a comp or type unit header.  */
 
-static void
-dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
-                               struct objfile *objfile)
+static sect_offset
+read_abbrev_offset (struct dwarf2_section_info *section,
+                   sect_offset offset)
+{
+  bfd *abfd = section->asection->owner;
+  gdb_byte *info_ptr;
+  unsigned int length, initial_length_size, offset_size;
+  sect_offset abbrev_offset;
+
+  dwarf2_read_section (dwarf2_per_objfile->objfile, section);
+  info_ptr = section->buffer + offset.sect_off;
+  length = read_initial_length (abfd, info_ptr, &initial_length_size);
+  offset_size = initial_length_size == 4 ? 4 : 8;
+  info_ptr += initial_length_size + 2 /*version*/;
+  abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
+  return abbrev_offset;
+}
+
+/* Allocate a new partial symtab for file named NAME and mark this new
+   partial symtab as being an include of PST.  */
+
+static void
+dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
+                               struct objfile *objfile)
 {
   struct partial_symtab *subpst = allocate_psymtab (name, objfile);
 
+  if (!IS_ABSOLUTE_PATH (subpst->filename))
+    {
+      /* It shares objfile->objfile_obstack.  */
+      subpst->dirname = pst->dirname;
+    }
+
   subpst->section_offsets = pst->section_offsets;
   subpst->textlow = 0;
   subpst->texthigh = 0;
@@ -3127,21 +4112,15 @@ dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
 
 static void
 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
-                               struct die_info *die,
-                               struct partial_symtab *pst)
+                              struct die_info *die,
+                              struct partial_symtab *pst)
 {
-  struct objfile *objfile = cu->objfile;
-  bfd *abfd = objfile->obfd;
   struct line_header *lh = NULL;
   struct attribute *attr;
 
   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
   if (attr)
-    {
-      unsigned int line_offset = DW_UNSND (attr);
-
-      lh = dwarf_decode_line_header (line_offset, abfd, cu);
-    }
+    lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
   if (lh == NULL)
     return;  /* No linetable, so no includes.  */
 
@@ -3152,16 +4131,16 @@ dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
 }
 
 static hashval_t
-hash_type_signature (const void *item)
+hash_signatured_type (const void *item)
 {
-  const struct signatured_type *type_sig = item;
+  const struct signatured_type *sig_type = item;
 
   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
-  return type_sig->signature;
+  return sig_type->signature;
 }
 
 static int
-eq_type_signature (const void *item_lhs, const void *item_rhs)
+eq_signatured_type (const void *item_lhs, const void *item_rhs)
 {
   const struct signatured_type *lhs = item_lhs;
   const struct signatured_type *rhs = item_rhs;
@@ -3175,52 +4154,64 @@ static htab_t
 allocate_signatured_type_table (struct objfile *objfile)
 {
   return htab_create_alloc_ex (41,
-                              hash_type_signature,
-                              eq_type_signature,
+                              hash_signatured_type,
+                              eq_signatured_type,
                               NULL,
                               &objfile->objfile_obstack,
                               hashtab_obstack_allocate,
                               dummy_obstack_deallocate);
 }
 
-/* A helper function to add a signatured type CU to a list.  */
+/* A helper function to add a signatured type CU to a table.  */
 
 static int
-add_signatured_type_cu_to_list (void **slot, void *datum)
+add_signatured_type_cu_to_table (void **slot, void *datum)
 {
   struct signatured_type *sigt = *slot;
-  struct dwarf2_per_cu_data ***datap = datum;
+  struct signatured_type ***datap = datum;
 
-  **datap = &sigt->per_cu;
+  **datap = sigt;
   ++*datap;
 
   return 1;
 }
 
 /* Create the hash table of all entries in the .debug_types section.
-   The result is zero if there is an error (e.g. missing .debug_types section),
-   otherwise non-zero. */
+   DWO_FILE is a pointer to the DWO file for .debug_types.dwo,
+   NULL otherwise.
+   Note: This function processes DWO files only, not DWP files.
+   The result is a pointer to the hash table or NULL if there are
+   no types.  */
 
-static int
-create_debug_types_hash_table (struct objfile *objfile)
+static htab_t
+create_debug_types_hash_table (struct dwo_file *dwo_file,
+                              VEC (dwarf2_section_info_def) *types)
 {
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
   htab_t types_htab = NULL;
-  struct dwarf2_per_cu_data **iter;
   int ix;
   struct dwarf2_section_info *section;
+  struct dwarf2_section_info *abbrev_section;
 
-  if (VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types))
-    {
-      dwarf2_per_objfile->signatured_types = NULL;
-      return 0;
-    }
+  if (VEC_empty (dwarf2_section_info_def, types))
+    return NULL;
+
+  abbrev_section = (dwo_file != NULL
+                   ? &dwo_file->sections.abbrev
+                   : &dwarf2_per_objfile->abbrev);
+
+  if (dwarf2_read_debug)
+    fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
+                       dwo_file ? ".dwo" : "",
+                       bfd_get_filename (abbrev_section->asection->owner));
 
   for (ix = 0;
-       VEC_iterate (dwarf2_section_info_def, dwarf2_per_objfile->types,
-                   ix, section);
+       VEC_iterate (dwarf2_section_info_def, types, ix, section);
        ++ix)
     {
+      bfd *abfd;
       gdb_byte *info_ptr, *end_ptr;
+      struct dwarf2_section_info *abbrev_section;
 
       dwarf2_read_section (objfile, section);
       info_ptr = section->buffer;
@@ -3228,110 +4219,166 @@ create_debug_types_hash_table (struct objfile *objfile)
       if (info_ptr == NULL)
        continue;
 
+      /* We can't set abfd until now because the section may be empty or
+        not present, in which case section->asection will be NULL.  */
+      abfd = section->asection->owner;
+
+      if (dwo_file)
+       abbrev_section = &dwo_file->sections.abbrev;
+      else
+       abbrev_section = &dwarf2_per_objfile->abbrev;
+
       if (types_htab == NULL)
-       types_htab = allocate_signatured_type_table (objfile);
+       {
+         if (dwo_file)
+           types_htab = allocate_dwo_unit_table (objfile);
+         else
+           types_htab = allocate_signatured_type_table (objfile);
+       }
 
-      if (dwarf2_die_debug)
-       fprintf_unfiltered (gdb_stdlog, "Signatured types:\n");
+      /* We don't use init_cutu_and_read_dies_simple, or some such, here
+        because we don't need to read any dies: the signature is in the
+        header.  */
 
       end_ptr = info_ptr + section->size;
       while (info_ptr < end_ptr)
        {
-         unsigned int offset;
-         unsigned int offset_size;
-         unsigned int type_offset;
-         unsigned int length, initial_length_size;
-         unsigned short version;
+         sect_offset offset;
+         cu_offset type_offset_in_tu;
          ULONGEST signature;
-         struct signatured_type *type_sig;
+         struct signatured_type *sig_type;
+         struct dwo_unit *dwo_tu;
          void **slot;
          gdb_byte *ptr = info_ptr;
+         struct comp_unit_head header;
+         unsigned int length;
 
-         offset = ptr - section->buffer;
+         offset.sect_off = ptr - section->buffer;
 
          /* We need to read the type's signature in order to build the hash
-            table, but we don't need to read anything else just yet.  */
+            table, but we don't need anything else just yet.  */
 
-         /* Sanity check to ensure entire cu is present.  */
-         length = read_initial_length (objfile->obfd, ptr,
-                                       &initial_length_size);
-         if (ptr + length + initial_length_size > end_ptr)
-           {
-             complaint (&symfile_complaints,
-                        _("debug type entry runs off end "
-                          "of `.debug_types' section, ignored"));
-             break;
-           }
+         ptr = read_and_check_type_unit_head (&header, section,
+                                              abbrev_section, ptr,
+                                              &signature, &type_offset_in_tu);
 
-         offset_size = initial_length_size == 4 ? 4 : 8;
-         ptr += initial_length_size;
-         version = bfd_get_16 (objfile->obfd, ptr);
-         ptr += 2;
-         ptr += offset_size; /* abbrev offset */
-         ptr += 1; /* address size */
-         signature = bfd_get_64 (objfile->obfd, ptr);
-         ptr += 8;
-         type_offset = read_offset_1 (objfile->obfd, ptr, offset_size);
-         ptr += offset_size;
+         length = get_cu_length (&header);
 
          /* Skip dummy type units.  */
-         if (ptr >= end_ptr || peek_abbrev_code (objfile->obfd, ptr) == 0)
+         if (ptr >= info_ptr + length
+             || peek_abbrev_code (abfd, ptr) == 0)
            {
-             info_ptr = info_ptr + initial_length_size + length;
+             info_ptr += length;
              continue;
            }
 
-         type_sig = obstack_alloc (&objfile->objfile_obstack, sizeof (*type_sig));
-         memset (type_sig, 0, sizeof (*type_sig));
-         type_sig->signature = signature;
-         type_sig->type_offset = type_offset;
-         type_sig->per_cu.objfile = objfile;
-         type_sig->per_cu.debug_types_section = section;
-         type_sig->per_cu.offset = offset;
+         if (dwo_file)
+           {
+             sig_type = NULL;
+             dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+                                      struct dwo_unit);
+             dwo_tu->dwo_file = dwo_file;
+             dwo_tu->signature = signature;
+             dwo_tu->type_offset_in_tu = type_offset_in_tu;
+             dwo_tu->info_or_types_section = section;
+             dwo_tu->offset = offset;
+             dwo_tu->length = length;
+           }
+         else
+           {
+             /* 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->signature = signature;
+             sig_type->type_offset_in_tu = type_offset_in_tu;
+             sig_type->per_cu.objfile = objfile;
+             sig_type->per_cu.is_debug_types = 1;
+             sig_type->per_cu.info_or_types_section = section;
+             sig_type->per_cu.offset = offset;
+             sig_type->per_cu.length = length;
+           }
 
-         slot = htab_find_slot (types_htab, type_sig, INSERT);
+         slot = htab_find_slot (types_htab,
+                                dwo_file ? (void*) dwo_tu : (void *) sig_type,
+                                INSERT);
          gdb_assert (slot != NULL);
          if (*slot != NULL)
            {
-             const struct signatured_type *dup_sig = *slot;
+             sect_offset dup_offset;
+
+             if (dwo_file)
+               {
+                 const struct dwo_unit *dup_tu = *slot;
+
+                 dup_offset = dup_tu->offset;
+               }
+             else
+               {
+                 const struct signatured_type *dup_tu = *slot;
+
+                 dup_offset = dup_tu->per_cu.offset;
+               }
 
              complaint (&symfile_complaints,
                         _("debug type entry at offset 0x%x is duplicate to the "
                           "entry at offset 0x%x, signature 0x%s"),
-                        offset, dup_sig->per_cu.offset,
+                        offset.sect_off, dup_offset.sect_off,
                         phex (signature, sizeof (signature)));
-             gdb_assert (signature == dup_sig->signature);
            }
-         *slot = type_sig;
+         *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
 
-         if (dwarf2_die_debug)
+         if (dwarf2_read_debug)
            fprintf_unfiltered (gdb_stdlog, "  offset 0x%x, signature 0x%s\n",
-                               offset, phex (signature, sizeof (signature)));
+                               offset.sect_off,
+                               phex (signature, sizeof (signature)));
 
-         info_ptr = info_ptr + initial_length_size + length;
+         info_ptr += length;
        }
     }
 
+  return types_htab;
+}
+
+/* Create the hash table of all entries in the .debug_types section,
+   and initialize all_type_units.
+   The result is zero if there is an error (e.g. missing .debug_types section),
+   otherwise non-zero. */
+
+static int
+create_all_type_units (struct objfile *objfile)
+{
+  htab_t types_htab;
+  struct signatured_type **iter;
+
+  types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
+  if (types_htab == NULL)
+    {
+      dwarf2_per_objfile->signatured_types = NULL;
+      return 0;
+    }
+
   dwarf2_per_objfile->signatured_types = types_htab;
 
-  dwarf2_per_objfile->n_type_comp_units = htab_elements (types_htab);
-  dwarf2_per_objfile->type_comp_units
+  dwarf2_per_objfile->n_type_units = htab_elements (types_htab);
+  dwarf2_per_objfile->all_type_units
     = obstack_alloc (&objfile->objfile_obstack,
-                    dwarf2_per_objfile->n_type_comp_units
-                    * sizeof (struct dwarf2_per_cu_data *));
-  iter = &dwarf2_per_objfile->type_comp_units[0];
-  htab_traverse_noresize (types_htab, add_signatured_type_cu_to_list, &iter);
-  gdb_assert (iter - &dwarf2_per_objfile->type_comp_units[0]
-             == dwarf2_per_objfile->n_type_comp_units);
+                    dwarf2_per_objfile->n_type_units
+                    * sizeof (struct signatured_type *));
+  iter = &dwarf2_per_objfile->all_type_units[0];
+  htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
+  gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
+             == dwarf2_per_objfile->n_type_units);
 
   return 1;
 }
 
-/* Lookup a signature based type.
-   Returns NULL if SIG is not present in the table.  */
+/* Lookup a signature based type for DW_FORM_ref_sig8.
+   Returns NULL if signature SIG is not present in the table.  */
 
 static struct signatured_type *
-lookup_signatured_type (struct objfile *objfile, ULONGEST sig)
+lookup_signatured_type (ULONGEST sig)
 {
   struct signatured_type find_entry, *entry;
 
@@ -3339,1109 +4386,1919 @@ lookup_signatured_type (struct objfile *objfile, ULONGEST sig)
     {
       complaint (&symfile_complaints,
                 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
-      return 0;
+      return NULL;
     }
 
   find_entry.signature = sig;
   entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
   return entry;
 }
+\f
+/* Low level DIE reading support.  */
 
 /* Initialize a die_reader_specs struct from a dwarf2_cu struct.  */
 
 static void
 init_cu_die_reader (struct die_reader_specs *reader,
-                   struct dwarf2_cu *cu)
+                   struct dwarf2_cu *cu,
+                   struct dwarf2_section_info *section,
+                   struct dwo_file *dwo_file)
 {
-  reader->abfd = cu->objfile->obfd;
+  gdb_assert (section->readin && section->buffer != NULL);
+  reader->abfd = section->asection->owner;
   reader->cu = cu;
-  if (cu->per_cu->debug_types_section)
-    {
-      gdb_assert (cu->per_cu->debug_types_section->readin);
-      reader->buffer = cu->per_cu->debug_types_section->buffer;
-    }
-  else
-    {
-      gdb_assert (dwarf2_per_objfile->info.readin);
-      reader->buffer = dwarf2_per_objfile->info.buffer;
-    }
+  reader->dwo_file = dwo_file;
+  reader->die_section = section;
+  reader->buffer = section->buffer;
+  reader->buffer_end = section->buffer + section->size;
 }
 
-/* Find the base address of the compilation unit for range lists and
-   location lists.  It will normally be specified by DW_AT_low_pc.
-   In DWARF-3 draft 4, the base address could be overridden by
-   DW_AT_entry_pc.  It's been removed, but GCC still uses this for
-   compilation units with discontinuous ranges.  */
+/* Initialize a CU (or TU) and read its DIEs.
+   If the CU defers to a DWO file, read the DWO file as well.
+
+   ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
+   Otherwise the table specified in the comp unit header is read in and used.
+   This is an optimization for when we already have the abbrev table.
+
+   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 KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
+   read_in_chain.  Otherwise the dwarf2_cu data is freed at the end.
+
+   WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
+   linker) then DIE_READER_FUNC will not get called.  */
 
 static void
-dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
-{
+init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
+                        struct abbrev_table *abbrev_table,
+                        int use_existing_cu, int keep,
+                        die_reader_func_ftype *die_reader_func,
+                        void *data)
+{
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_section_info *section = this_cu->info_or_types_section;
+  bfd *abfd = section->asection->owner;
+  struct dwarf2_cu *cu;
+  gdb_byte *begin_info_ptr, *info_ptr;
+  struct die_reader_specs reader;
+  struct die_info *comp_unit_die;
+  int has_children;
   struct attribute *attr;
+  struct cleanup *cleanups, *free_cu_cleanup = NULL;
+  struct signatured_type *sig_type = NULL;
+  struct dwarf2_section_info *abbrev_section;
+  /* Non-zero if CU currently points to a DWO file and we need to
+     reread it.  When this happens we need to reread the skeleton die
+     before we can reread the DWO file.  */
+  int rereading_dwo_cu = 0;
 
-  cu->base_known = 0;
-  cu->base_address = 0;
+  if (dwarf2_die_debug)
+    fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
+                       this_cu->is_debug_types ? "type" : "comp",
+                       this_cu->offset.sect_off);
 
-  attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
-  if (attr)
+  if (use_existing_cu)
+    gdb_assert (keep);
+
+  cleanups = make_cleanup (null_cleanup, NULL);
+
+  /* This is cheap if the section is already read in.  */
+  dwarf2_read_section (objfile, section);
+
+  begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
+
+  abbrev_section = get_abbrev_section_for_cu (this_cu);
+
+  if (use_existing_cu && this_cu->cu != NULL)
     {
-      cu->base_address = DW_ADDR (attr);
-      cu->base_known = 1;
+      cu = this_cu->cu;
+
+      /* If this CU is from a DWO file we need to start over, we need to
+        refetch the attributes from the skeleton CU.
+        This could be optimized by retrieving those attributes from when we
+        were here the first time: the previous comp_unit_die was stored in
+        comp_unit_obstack.  But there's no data yet that we need this
+        optimization.  */
+      if (cu->dwo_unit != NULL)
+       rereading_dwo_cu = 1;
     }
   else
     {
-      attr = dwarf2_attr (die, DW_AT_low_pc, cu);
-      if (attr)
-       {
-         cu->base_address = DW_ADDR (attr);
-         cu->base_known = 1;
-       }
-    }
-}
+      /* If !use_existing_cu, this_cu->cu must be NULL.  */
+      gdb_assert (this_cu->cu == NULL);
 
-/* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
-   to combine the common parts.
-   Process a compilation unit for a psymtab.
-   BUFFER is a pointer to the beginning of the dwarf section buffer,
-   either .debug_info or debug_types.
-   INFO_PTR is a pointer to the start of the CU.
-   Returns a pointer to the next CU.  */
+      cu = xmalloc (sizeof (*cu));
+      init_one_comp_unit (cu, this_cu);
 
-static gdb_byte *
-process_psymtab_comp_unit (struct objfile *objfile,
-                          struct dwarf2_per_cu_data *this_cu,
-                          gdb_byte *buffer, gdb_byte *info_ptr,
-                          unsigned int buffer_size)
-{
-  bfd *abfd = objfile->obfd;
-  gdb_byte *beg_of_comp_unit = info_ptr;
-  struct die_info *comp_unit_die;
-  struct partial_symtab *pst;
-  CORE_ADDR baseaddr;
-  struct cleanup *back_to_inner;
-  struct dwarf2_cu cu;
-  int has_children, has_pc_info;
-  struct attribute *attr;
-  CORE_ADDR best_lowpc = 0, best_highpc = 0;
-  struct die_reader_specs reader_specs;
-  const char *filename;
+      /* If an error occurs while loading, release our storage.  */
+      free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
+    }
 
-  init_one_comp_unit (&cu, objfile);
-  back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
+  if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
+    {
+      /* We already have the header, there's no need to read it in again.  */
+      info_ptr += cu->header.first_die_offset.cu_off;
+    }
+  else
+    {
+      if (this_cu->is_debug_types)
+       {
+         ULONGEST signature;
+         cu_offset type_offset_in_tu;
+
+         info_ptr = read_and_check_type_unit_head (&cu->header, section,
+                                                   abbrev_section, info_ptr,
+                                                   &signature,
+                                                   &type_offset_in_tu);
+
+         /* Since per_cu is the first member of struct signatured_type,
+            we can go from a pointer to one to a pointer to the other.  */
+         sig_type = (struct signatured_type *) this_cu;
+         gdb_assert (sig_type->signature == signature);
+         gdb_assert (sig_type->type_offset_in_tu.cu_off
+                     == type_offset_in_tu.cu_off);
+         gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
+
+         /* LENGTH has not been set yet for type units if we're
+            using .gdb_index.  */
+         this_cu->length = get_cu_length (&cu->header);
+
+         /* Establish the type offset that can be used to lookup the type.  */
+         sig_type->type_offset_in_section.sect_off =
+           this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
+       }
+      else
+       {
+         info_ptr = read_and_check_comp_unit_head (&cu->header, section,
+                                                   abbrev_section,
+                                                   info_ptr, 0);
 
-  info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr,
-                                         buffer, buffer_size,
-                                         abfd,
-                                         this_cu->debug_types_section != NULL);
+         gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
+         gdb_assert (this_cu->length == get_cu_length (&cu->header));
+       }
+    }
 
   /* Skip dummy compilation units.  */
-  if (info_ptr >= buffer + buffer_size
+  if (info_ptr >= begin_info_ptr + this_cu->length
       || peek_abbrev_code (abfd, info_ptr) == 0)
     {
-      info_ptr = (beg_of_comp_unit + cu.header.length
-                 + cu.header.initial_length_size);
-      do_cleanups (back_to_inner);
-      return info_ptr;
+      do_cleanups (cleanups);
+      return;
     }
 
-  cu.list_in_scope = &file_symbols;
-
-  /* If this compilation unit was already read in, free the
-     cached copy in order to read it in again. This is
-     necessary because we skipped some symbols when we first
-     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->cu);
-
-  /* Note that this is a pointer to our stack frame, being
-     added to a global data structure. It will be cleaned up
-     in free_stack_comp_unit when we finish with this
-     compilation unit. */
-  this_cu->cu = &cu;
-  cu.per_cu = this_cu;
-
-  /* Read the abbrevs for this compilation unit into a table.  */
-  dwarf2_read_abbrevs (abfd, &cu);
-  make_cleanup (dwarf2_free_abbrev_table, &cu);
-
-  /* Read the compilation unit die.  */
-  init_cu_die_reader (&reader_specs, &cu);
-  info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
-                           &has_children);
-
-  if (this_cu->debug_types_section)
+  /* If we don't have them yet, read the abbrevs for this compilation unit.
+     And if we need to read them now, make sure they're freed when we're
+     done.  Note that it's important that if the CU had an abbrev table
+     on entry we don't free it when we're done: Somewhere up the call stack
+     it may be in use.  */
+  if (abbrev_table != NULL)
     {
-      /* LENGTH has not been set yet for type units.  */
-      gdb_assert (this_cu->offset == cu.header.offset);
-      this_cu->length = cu.header.length + cu.header.initial_length_size;
+      gdb_assert (cu->abbrev_table == NULL);
+      gdb_assert (cu->header.abbrev_offset.sect_off
+                 == abbrev_table->offset.sect_off);
+      cu->abbrev_table = abbrev_table;
     }
-  else if (comp_unit_die->tag == DW_TAG_partial_unit)
+  else if (cu->abbrev_table == NULL)
     {
-      info_ptr = (beg_of_comp_unit + cu.header.length
-                 + cu.header.initial_length_size);
-      do_cleanups (back_to_inner);
-      return info_ptr;
+      dwarf2_read_abbrevs (cu, abbrev_section);
+      make_cleanup (dwarf2_free_abbrev_table, cu);
+    }
+  else if (rereading_dwo_cu)
+    {
+      dwarf2_free_abbrev_table (cu);
+      dwarf2_read_abbrevs (cu, abbrev_section);
     }
 
-  prepare_one_comp_unit (&cu, comp_unit_die);
-
-  /* Allocate a new partial symbol table structure.  */
-  attr = dwarf2_attr (comp_unit_die, DW_AT_name, &cu);
-  if (attr == NULL || !DW_STRING (attr))
-    filename = "";
-  else
-    filename = DW_STRING (attr);
-  pst = start_psymtab_common (objfile, objfile->section_offsets,
-                             filename,
-                             /* TEXTLOW and TEXTHIGH are set below.  */
-                             0,
-                             objfile->global_psymbols.next,
-                             objfile->static_psymbols.next);
-  pst->psymtabs_addrmap_supported = 1;
-
-  attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, &cu);
-  if (attr != NULL)
-    pst->dirname = DW_STRING (attr);
-
-  pst->read_symtab_private = this_cu;
+  /* Read the top level CU/TU die.  */
+  init_cu_die_reader (&reader, cu, section, NULL);
+  info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
 
-  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+  /* If we have a DWO stub, process it and then read in the DWO file.
+     Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains
+     a DWO CU, that this test will fail.  */
+  attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
+  if (attr)
+    {
+      const char *dwo_name = DW_STRING (attr);
+      const char *comp_dir_string;
+      struct dwo_unit *dwo_unit;
+      ULONGEST signature; /* Or dwo_id.  */
+      struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
+      int i,num_extra_attrs;
+      struct dwarf2_section_info *dwo_abbrev_section;
+
+      if (has_children)
+       error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name"
+                " has children (offset 0x%x) [in module %s]"),
+              this_cu->offset.sect_off, bfd_get_filename (abfd));
+
+      /* These attributes aren't processed until later:
+        DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
+        However, the attribute is found in the stub which we won't have later.
+        In order to not impose this complication on the rest of the code,
+        we read them here and copy them to the DWO CU/TU die.  */
+
+      /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
+        DWO file.  */
+      stmt_list = NULL;
+      if (! this_cu->is_debug_types)
+       stmt_list = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
+      low_pc = dwarf2_attr (comp_unit_die, DW_AT_low_pc, cu);
+      high_pc = dwarf2_attr (comp_unit_die, DW_AT_high_pc, cu);
+      ranges = dwarf2_attr (comp_unit_die, DW_AT_ranges, cu);
+      comp_dir = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
+
+      /* There should be a DW_AT_addr_base attribute here (if needed).
+        We need the value before we can process DW_FORM_GNU_addr_index.  */
+      cu->addr_base = 0;
+      attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_addr_base, cu);
+      if (attr)
+       cu->addr_base = DW_UNSND (attr);
 
-  /* Store the function that reads in the rest of the symbol table.  */
-  pst->read_symtab = dwarf2_psymtab_to_symtab;
+      /* There should be a DW_AT_ranges_base attribute here (if needed).
+        We need the value before we can process DW_AT_ranges.  */
+      cu->ranges_base = 0;
+      attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_ranges_base, cu);
+      if (attr)
+       cu->ranges_base = DW_UNSND (attr);
 
-  this_cu->v.psymtab = pst;
+      if (this_cu->is_debug_types)
+       {
+         gdb_assert (sig_type != NULL);
+         signature = sig_type->signature;
+       }
+      else
+       {
+         attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
+         if (! attr)
+           error (_("Dwarf Error: missing dwo_id [in module %s]"),
+                  dwo_name);
+         signature = DW_UNSND (attr);
+       }
 
-  dwarf2_find_base_address (comp_unit_die, &cu);
+      /* We may need the comp_dir in order to find the DWO file.  */
+      comp_dir_string = NULL;
+      if (comp_dir)
+       comp_dir_string = DW_STRING (comp_dir);
 
-  /* Possibly set the default values of LOWPC and HIGHPC from
-     `DW_AT_ranges'.  */
-  has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
-                                     &best_highpc, &cu, pst);
-  if (has_pc_info == 1 && best_lowpc < best_highpc)
-    /* Store the contiguous range if it is not empty; it can be empty for
-       CUs with no code.  */
-    addrmap_set_empty (objfile->psymtabs_addrmap,
-                      best_lowpc + baseaddr,
-                      best_highpc + baseaddr - 1, pst);
+      if (this_cu->is_debug_types)
+       dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir_string);
+      else
+       dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir_string,
+                                        signature);
 
-  /* Check if comp unit has_children.
-     If so, read the rest of the partial symbols from this comp unit.
-     If not, there's no more debug_info for this comp unit.  */
-  if (has_children)
-    {
-      struct partial_die_info *first_die;
-      CORE_ADDR lowpc, highpc;
+      if (dwo_unit == NULL)
+       {
+         error (_("Dwarf Error: CU at offset 0x%x references unknown DWO"
+                  " with ID %s [in module %s]"),
+                this_cu->offset.sect_off,
+                phex (signature, sizeof (signature)),
+                objfile->name);
+       }
 
-      lowpc = ((CORE_ADDR) -1);
-      highpc = ((CORE_ADDR) 0);
+      /* Set up for reading the DWO CU/TU.  */
+      cu->dwo_unit = dwo_unit;
+      section = dwo_unit->info_or_types_section;
+      dwarf2_read_section (objfile, section);
+      begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
+      dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
+      init_cu_die_reader (&reader, cu, section, dwo_unit->dwo_file);
 
-      first_die = load_partial_dies (abfd, buffer, info_ptr, 1, &cu);
+      if (this_cu->is_debug_types)
+       {
+         ULONGEST signature;
+         cu_offset type_offset_in_tu;
+
+         info_ptr = read_and_check_type_unit_head (&cu->header, section,
+                                                   dwo_abbrev_section,
+                                                   info_ptr,
+                                                   &signature,
+                                                   &type_offset_in_tu);
+         gdb_assert (sig_type->signature == signature);
+         gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
+         /* For DWOs coming from DWP files, we don't know the CU length
+            nor the type's offset in the TU until now.  */
+         dwo_unit->length = get_cu_length (&cu->header);
+         dwo_unit->type_offset_in_tu = type_offset_in_tu;
+
+         /* Establish the type offset that can be used to lookup the type.
+            For DWO files, we don't know it until now.  */
+         sig_type->type_offset_in_section.sect_off =
+           dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
+       }
+      else
+       {
+         info_ptr = read_and_check_comp_unit_head (&cu->header, section,
+                                                   dwo_abbrev_section,
+                                                   info_ptr, 0);
+         gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
+         /* For DWOs coming from DWP files, we don't know the CU length
+            until now.  */
+         dwo_unit->length = get_cu_length (&cu->header);
+       }
 
-      scan_partial_symbols (first_die, &lowpc, &highpc,
-                           ! has_pc_info, &cu);
+      /* Discard the original CU's abbrev table, and read the DWO's.  */
+      if (abbrev_table == NULL)
+       {
+         dwarf2_free_abbrev_table (cu);
+         dwarf2_read_abbrevs (cu, dwo_abbrev_section);
+       }
+      else
+       {
+         dwarf2_read_abbrevs (cu, dwo_abbrev_section);
+         make_cleanup (dwarf2_free_abbrev_table, cu);
+       }
 
-      /* If we didn't find a lowpc, set it to highpc to avoid
-        complaints from `maint check'.  */
-      if (lowpc == ((CORE_ADDR) -1))
-       lowpc = highpc;
+      /* Read in the die, but leave space to copy over the attributes
+        from the stub.  This has the benefit of simplifying the rest of
+        the code - all the real work is done here.  */
+      num_extra_attrs = ((stmt_list != NULL)
+                        + (low_pc != NULL)
+                        + (high_pc != NULL)
+                        + (ranges != NULL)
+                        + (comp_dir != NULL));
+      info_ptr = read_full_die_1 (&reader, &comp_unit_die, info_ptr,
+                                 &has_children, num_extra_attrs);
+
+      /* Copy over the attributes from the stub to the DWO die.  */
+      i = comp_unit_die->num_attrs;
+      if (stmt_list != NULL)
+       comp_unit_die->attrs[i++] = *stmt_list;
+      if (low_pc != NULL)
+       comp_unit_die->attrs[i++] = *low_pc;
+      if (high_pc != NULL)
+       comp_unit_die->attrs[i++] = *high_pc;
+      if (ranges != NULL)
+       comp_unit_die->attrs[i++] = *ranges;
+      if (comp_dir != NULL)
+       comp_unit_die->attrs[i++] = *comp_dir;
+      comp_unit_die->num_attrs += num_extra_attrs;
 
-      /* If the compilation unit didn't have an explicit address range,
-        then use the information extracted from its child dies.  */
-      if (! has_pc_info)
+      /* Skip dummy compilation units.  */
+      if (info_ptr >= begin_info_ptr + dwo_unit->length
+         || peek_abbrev_code (abfd, info_ptr) == 0)
        {
-         best_lowpc = lowpc;
-         best_highpc = highpc;
+         do_cleanups (cleanups);
+         return;
        }
     }
-  pst->textlow = best_lowpc + baseaddr;
-  pst->texthigh = best_highpc + baseaddr;
-
-  pst->n_global_syms = objfile->global_psymbols.next -
-    (objfile->global_psymbols.list + pst->globals_offset);
-  pst->n_static_syms = objfile->static_psymbols.next -
-    (objfile->static_psymbols.list + pst->statics_offset);
-  sort_pst_symbols (pst);
 
-  info_ptr = (beg_of_comp_unit + cu.header.length
-             + cu.header.initial_length_size);
+  die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
 
-  if (this_cu->debug_types_section)
+  if (free_cu_cleanup != NULL)
     {
-      /* It's not clear we want to do anything with stmt lists here.
-        Waiting to see what gcc ultimately does.  */
-    }
-  else
-    {
-      /* Get the list of files included in the current compilation unit,
-        and build a psymtab for each of them.  */
-      dwarf2_build_include_psymtabs (&cu, comp_unit_die, pst);
-    }
+      if (keep)
+       {
+         /* We've successfully allocated this compilation unit.  Let our
+            caller clean it up when finished with it.  */
+         discard_cleanups (free_cu_cleanup);
 
-  do_cleanups (back_to_inner);
+         /* We can only discard free_cu_cleanup and all subsequent cleanups.
+            So we have to manually free the abbrev table.  */
+         dwarf2_free_abbrev_table (cu);
 
-  return info_ptr;
+         /* Link this CU into read_in_chain.  */
+         this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
+         dwarf2_per_objfile->read_in_chain = this_cu;
+       }
+      else
+       do_cleanups (free_cu_cleanup);
+    }
+
+  do_cleanups (cleanups);
 }
 
-/* Traversal function for htab_traverse_noresize.
-   Process one .debug_types comp-unit. */
+/* Read CU/TU THIS_CU in section SECTION,
+   but do not follow DW_AT_GNU_dwo_name if present.
+   DWOP_FILE, if non-NULL, is the DWO/DWP file to read (the caller is assumed
+   to have already done the lookup to find the DWO/DWP file).
 
-static int
-process_type_comp_unit (void **slot, void *info)
-{
-  struct signatured_type *entry = (struct signatured_type *) *slot;
-  struct objfile *objfile = (struct objfile *) info;
-  struct dwarf2_per_cu_data *this_cu;
+   The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
+   THIS_CU->is_debug_types, but nothing else.
 
-  this_cu = &entry->per_cu;
+   We fill in THIS_CU->length.
 
-  gdb_assert (this_cu->debug_types_section->readin);
-  process_psymtab_comp_unit (objfile, this_cu,
-                            this_cu->debug_types_section->buffer,
-                            (this_cu->debug_types_section->buffer
-                             + this_cu->offset),
-                            this_cu->debug_types_section->size);
+   WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
+   linker) then DIE_READER_FUNC will not get called.
 
-  return 1;
-}
-
-/* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
-   Build partial symbol tables for the .debug_types comp-units.  */
+   THIS_CU->cu is always freed when done.
+   This is done in order to not leave THIS_CU->cu in a state where we have
+   to care whether it refers to the "main" CU or the DWO CU.  */
 
 static void
-build_type_psymtabs (struct objfile *objfile)
+init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
+                                  struct dwarf2_section_info *abbrev_section,
+                                  struct dwo_file *dwo_file,
+                                  die_reader_func_ftype *die_reader_func,
+                                  void *data)
 {
-  if (! create_debug_types_hash_table (objfile))
-    return;
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_section_info *section = this_cu->info_or_types_section;
+  bfd *abfd = section->asection->owner;
+  struct dwarf2_cu cu;
+  gdb_byte *begin_info_ptr, *info_ptr;
+  struct die_reader_specs reader;
+  struct cleanup *cleanups;
+  struct die_info *comp_unit_die;
+  int has_children;
 
-  htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
-                         process_type_comp_unit, objfile);
-}
+  if (dwarf2_die_debug)
+    fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
+                       this_cu->is_debug_types ? "type" : "comp",
+                       this_cu->offset.sect_off);
 
-/* A cleanup function that clears objfile's psymtabs_addrmap field.  */
+  gdb_assert (this_cu->cu == NULL);
 
-static void
-psymtabs_addrmap_cleanup (void *o)
-{
-  struct objfile *objfile = o;
+  /* This is cheap if the section is already read in.  */
+  dwarf2_read_section (objfile, section);
 
-  objfile->psymtabs_addrmap = NULL;
-}
+  init_one_comp_unit (&cu, this_cu);
 
-/* Build the partial symbol table by doing a quick pass through the
-   .debug_info and .debug_abbrev sections.  */
+  cleanups = make_cleanup (free_stack_comp_unit, &cu);
 
-static void
-dwarf2_build_psymtabs_hard (struct objfile *objfile)
-{
-  gdb_byte *info_ptr;
-  struct cleanup *back_to, *addrmap_cleanup;
-  struct obstack temp_obstack;
+  begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
+  info_ptr = read_and_check_comp_unit_head (&cu.header, section,
+                                           abbrev_section, info_ptr,
+                                           this_cu->is_debug_types);
 
-  dwarf2_per_objfile->reading_partial_symbols = 1;
+  this_cu->length = get_cu_length (&cu.header);
 
-  dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
-  info_ptr = dwarf2_per_objfile->info.buffer;
+  /* Skip dummy compilation units.  */
+  if (info_ptr >= begin_info_ptr + this_cu->length
+      || peek_abbrev_code (abfd, info_ptr) == 0)
+    {
+      do_cleanups (cleanups);
+      return;
+    }
 
-  /* Any cached compilation units will be linked by the per-objfile
-     read_in_chain.  Make sure to free them when we're done.  */
-  back_to = make_cleanup (free_cached_comp_units, NULL);
+  dwarf2_read_abbrevs (&cu, abbrev_section);
+  make_cleanup (dwarf2_free_abbrev_table, &cu);
 
-  build_type_psymtabs (objfile);
+  init_cu_die_reader (&reader, &cu, section, dwo_file);
+  info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
 
-  create_all_comp_units (objfile);
+  die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
 
-  /* Create a temporary address map on a temporary obstack.  We later
-     copy this to the final obstack.  */
-  obstack_init (&temp_obstack);
-  make_cleanup_obstack_free (&temp_obstack);
-  objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
-  addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
+  do_cleanups (cleanups);
+}
 
-  /* Since the objects we're extracting from .debug_info vary in
-     length, only the individual functions to extract them (like
-     read_comp_unit_head and load_partial_die) can really know whether
-     the buffer is large enough to hold another complete object.
+/* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
+   does not lookup the specified DWO file.
+   This cannot be used to read DWO files.
 
-     At the moment, they don't actually check that.  If .debug_info
-     holds just one extra byte after the last compilation unit's dies,
-     then read_comp_unit_head will happily read off the end of the
-     buffer.  read_partial_die is similarly casual.  Those functions
-     should be fixed.
+   THIS_CU->cu is always freed when done.
+   This is done in order to not leave THIS_CU->cu in a state where we have
+   to care whether it refers to the "main" CU or the DWO CU.
+   We can revisit this if the data shows there's a performance issue.  */
 
-     For this loop condition, simply checking whether there's any data
-     left at all should be sufficient.  */
+static void
+init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
+                               die_reader_func_ftype *die_reader_func,
+                               void *data)
+{
+  init_cutu_and_read_dies_no_follow (this_cu,
+                                    get_abbrev_section_for_cu (this_cu),
+                                    NULL,
+                                    die_reader_func, data);
+}
 
-  while (info_ptr < (dwarf2_per_objfile->info.buffer
-                    + dwarf2_per_objfile->info.size))
-    {
-      struct dwarf2_per_cu_data *this_cu;
+/* Create a psymtab named NAME and assign it to PER_CU.
 
-      this_cu = dwarf2_find_comp_unit (info_ptr
-                                      - dwarf2_per_objfile->info.buffer,
-                                      objfile);
+   The caller must fill in the following details:
+   dirname, textlow, texthigh.  */
 
-      info_ptr = process_psymtab_comp_unit (objfile, this_cu,
-                                           dwarf2_per_objfile->info.buffer,
-                                           info_ptr,
-                                           dwarf2_per_objfile->info.size);
-    }
+static struct partial_symtab *
+create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
+{
+  struct objfile *objfile = per_cu->objfile;
+  struct partial_symtab *pst;
 
-  objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
-                                                   &objfile->objfile_obstack);
-  discard_cleanups (addrmap_cleanup);
+  pst = start_psymtab_common (objfile, objfile->section_offsets,
+                             name, 0,
+                             objfile->global_psymbols.next,
+                             objfile->static_psymbols.next);
 
-  do_cleanups (back_to);
+  pst->psymtabs_addrmap_supported = 1;
+
+  /* This is the glue that links PST into GDB's symbol API.  */
+  pst->read_symtab_private = per_cu;
+  pst->read_symtab = dwarf2_read_symtab;
+  per_cu->v.psymtab = pst;
+
+  return pst;
 }
 
-/* Load the partial DIEs for a secondary CU into memory.  */
+/* die_reader_func for process_psymtab_comp_unit.  */
 
 static void
-load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu,
-                       struct objfile *objfile)
+process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
+                                 gdb_byte *info_ptr,
+                                 struct die_info *comp_unit_die,
+                                 int has_children,
+                                 void *data)
 {
-  bfd *abfd = objfile->obfd;
-  gdb_byte *info_ptr;
-  struct die_info *comp_unit_die;
-  struct dwarf2_cu *cu;
-  struct cleanup *free_abbrevs_cleanup, *free_cu_cleanup = NULL;
-  int has_children;
-  struct die_reader_specs reader_specs;
-  int read_cu = 0;
+  struct dwarf2_cu *cu = reader->cu;
+  struct objfile *objfile = cu->objfile;
+  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
+  struct attribute *attr;
+  CORE_ADDR baseaddr;
+  CORE_ADDR best_lowpc = 0, best_highpc = 0;
+  struct partial_symtab *pst;
+  int has_pc_info;
+  const char *filename;
+  int *want_partial_unit_ptr = data;
+
+  if (comp_unit_die->tag == DW_TAG_partial_unit
+      && (want_partial_unit_ptr == NULL
+         || !*want_partial_unit_ptr))
+    return;
+
+  gdb_assert (! per_cu->is_debug_types);
+
+  prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
+
+  cu->list_in_scope = &file_symbols;
+
+  /* Allocate a new partial symbol table structure.  */
+  attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
+  if (attr == NULL || !DW_STRING (attr))
+    filename = "";
+  else
+    filename = DW_STRING (attr);
+
+  pst = create_partial_symtab (per_cu, filename);
+
+  /* This must be done before calling dwarf2_build_include_psymtabs.  */
+  attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
+  if (attr != NULL)
+    pst->dirname = DW_STRING (attr);
 
-  gdb_assert (! this_cu->debug_types_section);
+  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+
+  dwarf2_find_base_address (comp_unit_die, cu);
 
-  gdb_assert (dwarf2_per_objfile->info.readin);
-  info_ptr = dwarf2_per_objfile->info.buffer + this_cu->offset;
+  /* Possibly set the default values of LOWPC and HIGHPC from
+     `DW_AT_ranges'.  */
+  has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
+                                     &best_highpc, cu, pst);
+  if (has_pc_info == 1 && best_lowpc < best_highpc)
+    /* Store the contiguous range if it is not empty; it can be empty for
+       CUs with no code.  */
+    addrmap_set_empty (objfile->psymtabs_addrmap,
+                      best_lowpc + baseaddr,
+                      best_highpc + baseaddr - 1, pst);
 
-  if (this_cu->cu == NULL)
+  /* Check if comp unit has_children.
+     If so, read the rest of the partial symbols from this comp unit.
+     If not, there's no more debug_info for this comp unit.  */
+  if (has_children)
     {
-      cu = xmalloc (sizeof (*cu));
-      init_one_comp_unit (cu, objfile);
+      struct partial_die_info *first_die;
+      CORE_ADDR lowpc, highpc;
 
-      read_cu = 1;
+      lowpc = ((CORE_ADDR) -1);
+      highpc = ((CORE_ADDR) 0);
 
-      /* If an error occurs while loading, release our storage.  */
-      free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
+      first_die = load_partial_dies (reader, info_ptr, 1);
 
-      info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr,
-                                             dwarf2_per_objfile->info.buffer,
-                                             dwarf2_per_objfile->info.size,
-                                             abfd, 0);
+      scan_partial_symbols (first_die, &lowpc, &highpc,
+                           ! has_pc_info, cu);
 
-      /* Skip dummy compilation units.  */
-      if (info_ptr >= (dwarf2_per_objfile->info.buffer
-                      + dwarf2_per_objfile->info.size)
-         || peek_abbrev_code (abfd, info_ptr) == 0)
+      /* If we didn't find a lowpc, set it to highpc to avoid
+        complaints from `maint check'.  */
+      if (lowpc == ((CORE_ADDR) -1))
+       lowpc = highpc;
+
+      /* If the compilation unit didn't have an explicit address range,
+        then use the information extracted from its child dies.  */
+      if (! has_pc_info)
        {
-         do_cleanups (free_cu_cleanup);
-         return;
+         best_lowpc = lowpc;
+         best_highpc = highpc;
        }
+    }
+  pst->textlow = best_lowpc + baseaddr;
+  pst->texthigh = best_highpc + baseaddr;
+
+  pst->n_global_syms = objfile->global_psymbols.next -
+    (objfile->global_psymbols.list + pst->globals_offset);
+  pst->n_static_syms = objfile->static_psymbols.next -
+    (objfile->static_psymbols.list + pst->statics_offset);
+  sort_pst_symbols (objfile, pst);
 
-      /* Link this compilation unit into the compilation unit tree.  */
-      this_cu->cu = cu;
-      cu->per_cu = this_cu;
+  if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
+    {
+      int i;
+      int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
+      struct dwarf2_per_cu_data *iter;
+
+      /* Fill in 'dependencies' here; we fill in 'users' in a
+        post-pass.  */
+      pst->number_of_dependencies = len;
+      pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
+                                        len * sizeof (struct symtab *));
+      for (i = 0;
+          VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
+                       i, iter);
+          ++i)
+       pst->dependencies[i] = iter->v.psymtab;
 
-      /* Link this CU into read_in_chain.  */
-      this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
-      dwarf2_per_objfile->read_in_chain = this_cu;
+      VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
     }
-  else
+
+  /* Get the list of files included in the current compilation unit,
+     and build a psymtab for each of them.  */
+  dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
+
+  if (dwarf2_read_debug)
     {
-      cu = this_cu->cu;
-      info_ptr += cu->header.first_die_offset;
+      struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
+      fprintf_unfiltered (gdb_stdlog,
+                         "Psymtab for %s unit @0x%x: %s - %s"
+                         ", %d global, %d static syms\n",
+                         per_cu->is_debug_types ? "type" : "comp",
+                         per_cu->offset.sect_off,
+                         paddress (gdbarch, pst->textlow),
+                         paddress (gdbarch, pst->texthigh),
+                         pst->n_global_syms, pst->n_static_syms);
     }
+}
 
-  /* Read the abbrevs for this compilation unit into a table.  */
-  gdb_assert (cu->dwarf2_abbrevs == NULL);
-  dwarf2_read_abbrevs (abfd, cu);
-  free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
+/* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
+   Process compilation unit THIS_CU for a psymtab.  */
 
-  /* Read the compilation unit die.  */
-  init_cu_die_reader (&reader_specs, cu);
-  info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
-                           &has_children);
+static void
+process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
+                          int want_partial_unit)
+{
+  /* If this compilation unit was already read in, free the
+     cached copy in order to read it in again. This is
+     necessary because we skipped some symbols when we first
+     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);
 
-  prepare_one_comp_unit (cu, comp_unit_die);
+  gdb_assert (! this_cu->is_debug_types);
+  init_cutu_and_read_dies (this_cu, NULL, 0, 0,
+                          process_psymtab_comp_unit_reader,
+                          &want_partial_unit);
 
-  /* Check if comp unit has_children.
-     If so, read the rest of the partial symbols from this comp unit.
-     If not, there's no more debug_info for this comp unit.  */
-  if (has_children)
-    load_partial_dies (abfd, dwarf2_per_objfile->info.buffer, info_ptr, 0, cu);
+  /* Age out any secondary CUs.  */
+  age_cached_comp_units ();
+}
 
-  do_cleanups (free_abbrevs_cleanup);
+static hashval_t
+hash_type_unit_group (const void *item)
+{
+  const struct type_unit_group *tu_group = item;
 
-  if (read_cu)
-    {
-      /* We've successfully allocated this compilation unit.  Let our
-        caller clean it up when finished with it.  */
-      discard_cleanups (free_cu_cleanup);
-    }
+  return hash_stmt_list_entry (&tu_group->hash);
 }
 
-/* Create a list of all compilation units in OBJFILE.  We do this only
-   if an inter-comp-unit reference is found; presumably if there is one,
-   there will be many, and one will occur early in the .debug_info section.
-   So there's no point in building this list incrementally.  */
+static int
+eq_type_unit_group (const void *item_lhs, const void *item_rhs)
+{
+  const struct type_unit_group *lhs = item_lhs;
+  const struct type_unit_group *rhs = item_rhs;
 
-static void
-create_all_comp_units (struct objfile *objfile)
+  return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
+}
+
+/* Allocate a hash table for type unit groups.  */
+
+static htab_t
+allocate_type_unit_groups_table (void)
 {
-  int n_allocated;
-  int n_comp_units;
-  struct dwarf2_per_cu_data **all_comp_units;
-  gdb_byte *info_ptr;
+  return htab_create_alloc_ex (3,
+                              hash_type_unit_group,
+                              eq_type_unit_group,
+                              NULL,
+                              &dwarf2_per_objfile->objfile->objfile_obstack,
+                              hashtab_obstack_allocate,
+                              dummy_obstack_deallocate);
+}
 
-  dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
-  info_ptr = dwarf2_per_objfile->info.buffer;
+/* Type units that don't have DW_AT_stmt_list are grouped into their own
+   partial symtabs.  We combine several TUs per psymtab to not let the size
+   of any one psymtab grow too big.  */
+#define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
+#define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
 
-  n_comp_units = 0;
-  n_allocated = 10;
-  all_comp_units = xmalloc (n_allocated
-                           * sizeof (struct dwarf2_per_cu_data *));
+/* Helper routine for get_type_unit_group.
+   Create the type_unit_group object used to hold one or more TUs.  */
 
-  while (info_ptr < dwarf2_per_objfile->info.buffer
-        + dwarf2_per_objfile->info.size)
-    {
-      unsigned int length, initial_length_size;
-      struct dwarf2_per_cu_data *this_cu;
-      unsigned int offset;
+static struct type_unit_group *
+create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
+{
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_per_cu_data *per_cu;
+  struct type_unit_group *tu_group;
 
-      offset = info_ptr - dwarf2_per_objfile->info.buffer;
+  tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+                            struct type_unit_group);
+  per_cu = &tu_group->per_cu;
+  per_cu->objfile = objfile;
+  per_cu->is_debug_types = 1;
+  per_cu->type_unit_group = tu_group;
 
-      /* Read just enough information to find out where the next
-        compilation unit is.  */
-      length = read_initial_length (objfile->obfd, info_ptr,
-                                   &initial_length_size);
+  if (dwarf2_per_objfile->using_index)
+    {
+      per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+                                       struct dwarf2_per_cu_quick_data);
+      tu_group->t.first_tu = cu->per_cu;
+    }
+  else
+    {
+      unsigned int line_offset = line_offset_struct.sect_off;
+      struct partial_symtab *pst;
+      char *name;
 
-      /* Save the compilation unit for later lookup.  */
-      this_cu = obstack_alloc (&objfile->objfile_obstack,
-                              sizeof (struct dwarf2_per_cu_data));
-      memset (this_cu, 0, sizeof (*this_cu));
-      this_cu->offset = offset;
-      this_cu->length = length + initial_length_size;
-      this_cu->objfile = objfile;
+      /* Give the symtab a useful name for debug purposes.  */
+      if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
+       name = xstrprintf ("<type_units_%d>",
+                          (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
+      else
+       name = xstrprintf ("<type_units_at_0x%x>", line_offset);
 
-      if (n_comp_units == n_allocated)
-       {
-         n_allocated *= 2;
-         all_comp_units = xrealloc (all_comp_units,
-                                    n_allocated
-                                    * sizeof (struct dwarf2_per_cu_data *));
-       }
-      all_comp_units[n_comp_units++] = this_cu;
+      pst = create_partial_symtab (per_cu, name);
+      pst->anonymous = 1;
 
-      info_ptr = info_ptr + this_cu->length;
+      xfree (name);
     }
 
-  dwarf2_per_objfile->all_comp_units
-    = obstack_alloc (&objfile->objfile_obstack,
-                    n_comp_units * sizeof (struct dwarf2_per_cu_data *));
-  memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
-         n_comp_units * sizeof (struct dwarf2_per_cu_data *));
-  xfree (all_comp_units);
-  dwarf2_per_objfile->n_comp_units = n_comp_units;
+  tu_group->hash.dwo_unit = cu->dwo_unit;
+  tu_group->hash.line_offset = line_offset_struct;
+
+  return tu_group;
 }
 
-/* Process all loaded DIEs for compilation unit CU, starting at
-   FIRST_DIE.  The caller should pass NEED_PC == 1 if the compilation
-   unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
-   DW_AT_ranges).  If NEED_PC is set, then this function will set
-   *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
-   and record the covered ranges in the addrmap.  */
+/* Look up the type_unit_group for type unit CU, and create it if necessary.
+   STMT_LIST is a DW_AT_stmt_list attribute.  */
 
-static void
-scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
-                     CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
+static struct type_unit_group *
+get_type_unit_group (struct dwarf2_cu *cu, struct attribute *stmt_list)
 {
-  struct partial_die_info *pdi;
+  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
+  struct type_unit_group *tu_group;
+  void **slot;
+  unsigned int line_offset;
+  struct type_unit_group type_unit_group_for_lookup;
 
-  /* Now, march along the PDI's, descending into ones which have
-     interesting children but skipping the children of the other ones,
-     until we reach the end of the compilation unit.  */
+  if (dwarf2_per_objfile->type_unit_groups == NULL)
+    {
+      dwarf2_per_objfile->type_unit_groups =
+       allocate_type_unit_groups_table ();
+    }
 
-  pdi = first_die;
+  /* Do we need to create a new group, or can we use an existing one?  */
 
-  while (pdi != NULL)
+  if (stmt_list)
     {
-      fixup_partial_die (pdi, cu);
+      line_offset = DW_UNSND (stmt_list);
+      ++tu_stats->nr_symtab_sharers;
+    }
+  else
+    {
+      /* Ugh, no stmt_list.  Rare, but we have to handle it.
+        We can do various things here like create one group per TU or
+        spread them over multiple groups to split up the expansion work.
+        To avoid worst case scenarios (too many groups or too large groups)
+        we, umm, group them in bunches.  */
+      line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
+                    | (tu_stats->nr_stmt_less_type_units
+                       / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
+      ++tu_stats->nr_stmt_less_type_units;
+    }
+
+  type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
+  type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
+  slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
+                        &type_unit_group_for_lookup, INSERT);
+  if (*slot != NULL)
+    {
+      tu_group = *slot;
+      gdb_assert (tu_group != NULL);
+    }
+  else
+    {
+      sect_offset line_offset_struct;
 
-      /* Anonymous namespaces or modules have no name but have interesting
-        children, so we need to look at them.  Ditto for anonymous
-        enums.  */
+      line_offset_struct.sect_off = line_offset;
+      tu_group = create_type_unit_group (cu, line_offset_struct);
+      *slot = tu_group;
+      ++tu_stats->nr_symtabs;
+    }
 
-      if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
-         || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type)
-       {
-         switch (pdi->tag)
-           {
-           case DW_TAG_subprogram:
-             add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
-             break;
-           case DW_TAG_constant:
-           case DW_TAG_variable:
-           case DW_TAG_typedef:
-           case DW_TAG_union_type:
-             if (!pdi->is_declaration)
-               {
-                 add_partial_symbol (pdi, cu);
-               }
-             break;
-           case DW_TAG_class_type:
-           case DW_TAG_interface_type:
-           case DW_TAG_structure_type:
-             if (!pdi->is_declaration)
-               {
-                 add_partial_symbol (pdi, cu);
-               }
-             break;
-           case DW_TAG_enumeration_type:
-             if (!pdi->is_declaration)
-               add_partial_enumeration (pdi, cu);
-             break;
-           case DW_TAG_base_type:
-            case DW_TAG_subrange_type:
-             /* File scope base type definitions are added to the partial
-                symbol table.  */
-             add_partial_symbol (pdi, cu);
-             break;
-           case DW_TAG_namespace:
-             add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
-             break;
-           case DW_TAG_module:
-             add_partial_module (pdi, lowpc, highpc, need_pc, cu);
-             break;
-           default:
-             break;
-           }
-       }
+  return tu_group;
+}
 
-      /* If the die has a sibling, skip to the sibling.  */
+/* Struct used to sort TUs by their abbreviation table offset.  */
 
-      pdi = pdi->die_sibling;
-    }
+struct tu_abbrev_offset
+{
+  struct signatured_type *sig_type;
+  sect_offset abbrev_offset;
+};
+
+/* Helper routine for build_type_unit_groups, passed to qsort.  */
+
+static int
+sort_tu_by_abbrev_offset (const void *ap, const void *bp)
+{
+  const struct tu_abbrev_offset * const *a = ap;
+  const struct tu_abbrev_offset * const *b = bp;
+  unsigned int aoff = (*a)->abbrev_offset.sect_off;
+  unsigned int boff = (*b)->abbrev_offset.sect_off;
+
+  return (aoff > boff) - (aoff < boff);
 }
 
-/* Functions used to compute the fully scoped name of a partial DIE.
+/* A helper function to add a type_unit_group to a table.  */
 
-   Normally, this is simple.  For C++, the parent DIE's fully scoped
-   name is concatenated with "::" and the partial DIE's name.  For
-   Java, the same thing occurs except that "." is used instead of "::".
-   Enumerators are an exception; they use the scope of their parent
-   enumeration type, i.e. the name of the enumeration type is not
-   prepended to the enumerator.
+static int
+add_type_unit_group_to_table (void **slot, void *datum)
+{
+  struct type_unit_group *tu_group = *slot;
+  struct type_unit_group ***datap = datum;
 
-   There are two complexities.  One is DW_AT_specification; in this
-   case "parent" means the parent of the target of the specification,
-   instead of the direct parent of the DIE.  The other is compilers
-   which do not emit DW_TAG_namespace; in this case we try to guess
-   the fully qualified name of structure types from their members'
-   linkage names.  This must be done using the DIE's children rather
-   than the children of any DW_AT_specification target.  We only need
-   to do this for structures at the top level, i.e. if the target of
-   any DW_AT_specification (if any; otherwise the DIE itself) does not
-   have a parent.  */
+  **datap = tu_group;
+  ++*datap;
 
-/* Compute the scope prefix associated with PDI's parent, in
-   compilation unit CU.  The result will be allocated on CU's
-   comp_unit_obstack, or a copy of the already allocated PDI->NAME
-   field.  NULL is returned if no prefix is necessary.  */
-static char *
-partial_die_parent_scope (struct partial_die_info *pdi,
-                         struct dwarf2_cu *cu)
+  return 1;
+}
+
+/* Efficiently read all the type units, calling init_cutu_and_read_dies on
+   each one passing FUNC,DATA.
+
+   The efficiency is because we sort TUs by the abbrev table they use and
+   only read each abbrev table once.  In one program there are 200K TUs
+   sharing 8K abbrev tables.
+
+   The main purpose of this function is to support building the
+   dwarf2_per_objfile->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
+   share 8K stmt_list tables.
+
+   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.  */
+
+static void
+build_type_unit_groups (die_reader_func_ftype *func, void *data)
 {
-  char *grandparent_scope;
-  struct partial_die_info *parent, *real_pdi;
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
+  struct cleanup *cleanups;
+  struct abbrev_table *abbrev_table;
+  sect_offset abbrev_offset;
+  struct tu_abbrev_offset *sorted_by_abbrev;
+  struct type_unit_group **iter;
+  int i;
 
-  /* We need to look at our parent DIE; if we have a DW_AT_specification,
-     then this means the parent of the specification DIE.  */
+  /* It's up to the caller to not call us multiple times.  */
+  gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
 
-  real_pdi = pdi;
-  while (real_pdi->has_specification)
-    real_pdi = find_partial_die (real_pdi->spec_offset, cu);
+  if (dwarf2_per_objfile->n_type_units == 0)
+    return;
 
-  parent = real_pdi->die_parent;
-  if (parent == NULL)
-    return NULL;
+  /* TUs typically share abbrev tables, and there can be way more TUs than
+     abbrev tables.  Sort by abbrev table to reduce the number of times we
+     read each abbrev table in.
+     Alternatives are to punt or to maintain a cache of abbrev tables.
+     This is simpler and efficient enough for now.
 
-  if (parent->scope_set)
-    return parent->scope;
+     Later we group TUs by their DW_AT_stmt_list value (as this defines the
+     symtab to use).  Typically TUs with the same abbrev offset have the same
+     stmt_list value too so in practice this should work well.
 
-  fixup_partial_die (parent, cu);
+     The basic algorithm here is:
 
-  grandparent_scope = partial_die_parent_scope (parent, cu);
+      sort TUs by abbrev table
+      for each TU with same abbrev table:
+       read abbrev table if first user
+       read TU top level DIE
+         [IWBN if DWO skeletons had DW_AT_stmt_list]
+       call FUNC  */
 
-  /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
-     DW_TAG_namespace DIEs with a name of "::" for the global namespace.
-     Work around this problem here.  */
-  if (cu->language == language_cplus
-      && parent->tag == DW_TAG_namespace
-      && strcmp (parent->name, "::") == 0
-      && grandparent_scope == NULL)
+  if (dwarf2_read_debug)
+    fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
+
+  /* Sort in a separate table to maintain the order of all_type_units
+     for .gdb_index: TU indices directly index all_type_units.  */
+  sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
+                             dwarf2_per_objfile->n_type_units);
+  for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
     {
-      parent->scope = NULL;
-      parent->scope_set = 1;
-      return NULL;
+      struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
+
+      sorted_by_abbrev[i].sig_type = sig_type;
+      sorted_by_abbrev[i].abbrev_offset =
+       read_abbrev_offset (sig_type->per_cu.info_or_types_section,
+                           sig_type->per_cu.offset);
     }
+  cleanups = make_cleanup (xfree, sorted_by_abbrev);
+  qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
+        sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
 
-  if (pdi->tag == DW_TAG_enumerator)
-    /* Enumerators should not get the name of the enumeration as a prefix.  */
-    parent->scope = grandparent_scope;
-  else if (parent->tag == DW_TAG_namespace
-      || parent->tag == DW_TAG_module
-      || parent->tag == DW_TAG_structure_type
-      || parent->tag == DW_TAG_class_type
-      || parent->tag == DW_TAG_interface_type
-      || parent->tag == DW_TAG_union_type
-      || parent->tag == DW_TAG_enumeration_type)
+  /* Note: In the .gdb_index case, get_type_unit_group may have already been
+     called any number of times, so we don't reset tu_stats here.  */
+
+  abbrev_offset.sect_off = ~(unsigned) 0;
+  abbrev_table = NULL;
+  make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
+
+  for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
     {
-      if (grandparent_scope == NULL)
-       parent->scope = parent->name;
-      else
-       parent->scope = typename_concat (&cu->comp_unit_obstack,
-                                        grandparent_scope,
-                                        parent->name, 0, cu);
+      const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
+
+      /* Switch to the next abbrev table if necessary.  */
+      if (abbrev_table == NULL
+         || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
+       {
+         if (abbrev_table != NULL)
+           {
+             abbrev_table_free (abbrev_table);
+             /* Reset to NULL in case abbrev_table_read_table throws
+                an error: abbrev_table_free_cleanup will get called.  */
+             abbrev_table = NULL;
+           }
+         abbrev_offset = tu->abbrev_offset;
+         abbrev_table =
+           abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
+                                    abbrev_offset);
+         ++tu_stats->nr_uniq_abbrev_tables;
+       }
+
+      init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
+                              func, data);
     }
-  else
+
+  /* Create a vector of pointers to primary type units to make it easy to
+     iterate over them and CUs.  See dw2_get_primary_cu.  */
+  dwarf2_per_objfile->n_type_unit_groups =
+    htab_elements (dwarf2_per_objfile->type_unit_groups);
+  dwarf2_per_objfile->all_type_unit_groups =
+    obstack_alloc (&objfile->objfile_obstack,
+                  dwarf2_per_objfile->n_type_unit_groups
+                  * sizeof (struct type_unit_group *));
+  iter = &dwarf2_per_objfile->all_type_unit_groups[0];
+  htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
+                         add_type_unit_group_to_table, &iter);
+  gdb_assert (iter - &dwarf2_per_objfile->all_type_unit_groups[0]
+             == dwarf2_per_objfile->n_type_unit_groups);
+
+  do_cleanups (cleanups);
+
+  if (dwarf2_read_debug)
     {
-      /* FIXME drow/2004-04-01: What should we be doing with
-        function-local names?  For partial symbols, we should probably be
-        ignoring them.  */
-      complaint (&symfile_complaints,
-                _("unhandled containing DIE tag %d for DIE at %d"),
-                parent->tag, pdi->offset);
-      parent->scope = grandparent_scope;
+      fprintf_unfiltered (gdb_stdlog, "Done building type unit groups:\n");
+      fprintf_unfiltered (gdb_stdlog, "  %d TUs\n",
+                         dwarf2_per_objfile->n_type_units);
+      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",
+                         tu_stats->nr_symtabs);
+      fprintf_unfiltered (gdb_stdlog, "  %d symtab sharers\n",
+                         tu_stats->nr_symtab_sharers);
+      fprintf_unfiltered (gdb_stdlog, "  %d type units without a stmt_list\n",
+                         tu_stats->nr_stmt_less_type_units);
     }
-
-  parent->scope_set = 1;
-  return parent->scope;
 }
 
-/* Return the fully scoped name associated with PDI, from compilation unit
-   CU.  The result will be allocated with malloc.  */
-static char *
-partial_die_full_name (struct partial_die_info *pdi,
-                      struct dwarf2_cu *cu)
+/* Reader function for build_type_psymtabs.  */
+
+static void
+build_type_psymtabs_reader (const struct die_reader_specs *reader,
+                           gdb_byte *info_ptr,
+                           struct die_info *type_unit_die,
+                           int has_children,
+                           void *data)
 {
-  char *parent_scope;
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_cu *cu = reader->cu;
+  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
+  struct type_unit_group *tu_group;
+  struct attribute *attr;
+  struct partial_die_info *first_die;
+  CORE_ADDR lowpc, highpc;
+  struct partial_symtab *pst;
 
-  /* If this is a template instantiation, we can not work out the
-     template arguments from partial DIEs.  So, unfortunately, we have
-     to go through the full DIEs.  At least any work we do building
-     types here will be reused if full symbols are loaded later.  */
-  if (pdi->has_template_arguments)
-    {
-      fixup_partial_die (pdi, cu);
+  gdb_assert (data == NULL);
 
-      if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
-       {
-         struct die_info *die;
-         struct attribute attr;
-         struct dwarf2_cu *ref_cu = cu;
+  if (! has_children)
+    return;
 
-         attr.name = 0;
-         attr.form = DW_FORM_ref_addr;
-         attr.u.addr = pdi->offset;
-         die = follow_die_ref (NULL, &attr, &ref_cu);
+  attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
+  tu_group = get_type_unit_group (cu, attr);
 
-         return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
-       }
+  VEC_safe_push (dwarf2_per_cu_ptr, tu_group->t.tus, per_cu);
+
+  prepare_one_comp_unit (cu, type_unit_die, language_minimal);
+  cu->list_in_scope = &file_symbols;
+  pst = create_partial_symtab (per_cu, "");
+  pst->anonymous = 1;
+
+  first_die = load_partial_dies (reader, info_ptr, 1);
+
+  lowpc = (CORE_ADDR) -1;
+  highpc = (CORE_ADDR) 0;
+  scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
+
+  pst->n_global_syms = objfile->global_psymbols.next -
+    (objfile->global_psymbols.list + pst->globals_offset);
+  pst->n_static_syms = objfile->static_psymbols.next -
+    (objfile->static_psymbols.list + pst->statics_offset);
+  sort_pst_symbols (objfile, pst);
+}
+
+/* Traversal function for build_type_psymtabs.  */
+
+static int
+build_type_psymtab_dependencies (void **slot, void *info)
+{
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
+  struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
+  struct partial_symtab *pst = per_cu->v.psymtab;
+  int len = VEC_length (dwarf2_per_cu_ptr, tu_group->t.tus);
+  struct dwarf2_per_cu_data *iter;
+  int i;
+
+  gdb_assert (len > 0);
+
+  pst->number_of_dependencies = len;
+  pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
+                                    len * sizeof (struct psymtab *));
+  for (i = 0;
+       VEC_iterate (dwarf2_per_cu_ptr, tu_group->t.tus, i, iter);
+       ++i)
+    {
+      pst->dependencies[i] = iter->v.psymtab;
+      iter->type_unit_group = tu_group;
     }
 
-  parent_scope = partial_die_parent_scope (pdi, cu);
-  if (parent_scope == NULL)
-    return NULL;
-  else
-    return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
+  VEC_free (dwarf2_per_cu_ptr, tu_group->t.tus);
+
+  return 1;
 }
 
+/* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
+   Build partial symbol tables for the .debug_types comp-units.  */
+
 static void
-add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
+build_type_psymtabs (struct objfile *objfile)
 {
-  struct objfile *objfile = cu->objfile;
-  CORE_ADDR addr = 0;
-  char *actual_name = NULL;
-  const struct partial_symbol *psym = NULL;
-  CORE_ADDR baseaddr;
-  int built_actual_name = 0;
+  if (! create_all_type_units (objfile))
+    return;
 
-  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+  build_type_unit_groups (build_type_psymtabs_reader, NULL);
 
-  actual_name = partial_die_full_name (pdi, cu);
-  if (actual_name)
-    built_actual_name = 1;
+  /* Now that all TUs have been processed we can fill in the dependencies.  */
+  htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
+                         build_type_psymtab_dependencies, NULL);
+}
 
-  if (actual_name == NULL)
-    actual_name = pdi->name;
+/* A cleanup function that clears objfile's psymtabs_addrmap field.  */
 
-  switch (pdi->tag)
+static void
+psymtabs_addrmap_cleanup (void *o)
+{
+  struct objfile *objfile = o;
+
+  objfile->psymtabs_addrmap = NULL;
+}
+
+/* Compute the 'user' field for each psymtab in OBJFILE.  */
+
+static void
+set_partial_user (struct objfile *objfile)
+{
+  int i;
+
+  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
     {
-    case DW_TAG_subprogram:
-      if (pdi->is_external || cu->language == language_ada)
+      struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
+      struct partial_symtab *pst = per_cu->v.psymtab;
+      int j;
+
+      if (pst == NULL)
+       continue;
+
+      for (j = 0; j < pst->number_of_dependencies; ++j)
        {
-          /* brobecker/2007-12-26: Normally, only "external" DIEs are part
-             of the global scope.  But in Ada, we want to be able to access
-             nested procedures globally.  So all Ada subprograms are stored
-             in the global scope.  */
-         /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
-            mst_text, objfile); */
-         add_psymbol_to_list (actual_name, strlen (actual_name),
-                              built_actual_name,
-                              VAR_DOMAIN, LOC_BLOCK,
-                              &objfile->global_psymbols,
-                              0, pdi->lowpc + baseaddr,
-                              cu->language, objfile);
-       }
-      else
-       {
-         /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
-            mst_file_text, objfile); */
-         add_psymbol_to_list (actual_name, strlen (actual_name),
-                              built_actual_name,
-                              VAR_DOMAIN, LOC_BLOCK,
-                              &objfile->static_psymbols,
-                              0, pdi->lowpc + baseaddr,
-                              cu->language, objfile);
+         /* Set the 'user' field only if it is not already set.  */
+         if (pst->dependencies[j]->user == NULL)
+           pst->dependencies[j]->user = pst;
        }
-      break;
-    case DW_TAG_constant:
-      {
-        struct psymbol_allocation_list *list;
+    }
+}
 
-       if (pdi->is_external)
-         list = &objfile->global_psymbols;
-       else
-         list = &objfile->static_psymbols;
-       add_psymbol_to_list (actual_name, strlen (actual_name),
-                            built_actual_name, VAR_DOMAIN, LOC_STATIC,
-                            list, 0, 0, cu->language, objfile);
-      }
-      break;
-    case DW_TAG_variable:
-      if (pdi->locdesc)
-       addr = decode_locdesc (pdi->locdesc, cu);
+/* Build the partial symbol table by doing a quick pass through the
+   .debug_info and .debug_abbrev sections.  */
 
-      if (pdi->locdesc
-         && addr == 0
-         && !dwarf2_per_objfile->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
-            will be nullified; do not add such variables into partial
-            symbol table then.  */
-       }
-      else if (pdi->is_external)
-       {
-         /* Global Variable.
-            Don't enter into the minimal symbol tables as there is
-            a minimal symbol table entry from the ELF symbols already.
-            Enter into partial symbol table if it has a location
-            descriptor or a type.
-            If the location descriptor is missing, new_symbol will create
-            a LOC_UNRESOLVED symbol, the address of the variable will then
-            be determined from the minimal symbol table whenever the variable
-            is referenced.
-            The address for the partial symbol table entry is not
-            used by GDB, but it comes in handy for debugging partial symbol
-            table building.  */
+static void
+dwarf2_build_psymtabs_hard (struct objfile *objfile)
+{
+  struct cleanup *back_to, *addrmap_cleanup;
+  struct obstack temp_obstack;
+  int i;
 
-         if (pdi->locdesc || pdi->has_type)
-           add_psymbol_to_list (actual_name, strlen (actual_name),
-                                built_actual_name,
-                                VAR_DOMAIN, LOC_STATIC,
-                                &objfile->global_psymbols,
-                                0, addr + baseaddr,
-                                cu->language, objfile);
-       }
-      else
-       {
-         /* Static Variable.  Skip symbols without location descriptors.  */
-         if (pdi->locdesc == NULL)
-           {
-             if (built_actual_name)
-               xfree (actual_name);
-             return;
-           }
-         /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
-            mst_file_data, objfile); */
-         add_psymbol_to_list (actual_name, strlen (actual_name),
-                              built_actual_name,
-                              VAR_DOMAIN, LOC_STATIC,
-                              &objfile->static_psymbols,
-                              0, addr + baseaddr,
-                              cu->language, objfile);
-       }
-      break;
-    case DW_TAG_typedef:
-    case DW_TAG_base_type:
-    case DW_TAG_subrange_type:
-      add_psymbol_to_list (actual_name, strlen (actual_name),
-                          built_actual_name,
-                          VAR_DOMAIN, LOC_TYPEDEF,
-                          &objfile->static_psymbols,
-                          0, (CORE_ADDR) 0, cu->language, objfile);
-      break;
-    case DW_TAG_namespace:
-      add_psymbol_to_list (actual_name, strlen (actual_name),
-                          built_actual_name,
-                          VAR_DOMAIN, LOC_TYPEDEF,
-                          &objfile->global_psymbols,
-                          0, (CORE_ADDR) 0, cu->language, objfile);
-      break;
-    case DW_TAG_class_type:
-    case DW_TAG_interface_type:
-    case DW_TAG_structure_type:
-    case DW_TAG_union_type:
-    case DW_TAG_enumeration_type:
-      /* Skip external references.  The DWARF standard says in the section
-         about "Structure, Union, and Class Type Entries": "An incomplete
-         structure, union or class type is represented by a structure,
-         union or class entry that does not have a byte size attribute
-         and that has a DW_AT_declaration attribute."  */
-      if (!pdi->has_byte_size && pdi->is_declaration)
-       {
-         if (built_actual_name)
-           xfree (actual_name);
-         return;
-       }
+  if (dwarf2_read_debug)
+    {
+      fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
+                         objfile->name);
+    }
 
-      /* NOTE: carlton/2003-10-07: See comment in new_symbol about
-        static vs. global.  */
-      add_psymbol_to_list (actual_name, strlen (actual_name),
-                          built_actual_name,
-                          STRUCT_DOMAIN, LOC_TYPEDEF,
-                          (cu->language == language_cplus
-                           || cu->language == language_java)
-                          ? &objfile->global_psymbols
-                          : &objfile->static_psymbols,
-                          0, (CORE_ADDR) 0, cu->language, objfile);
+  dwarf2_per_objfile->reading_partial_symbols = 1;
 
-      break;
-    case DW_TAG_enumerator:
-      add_psymbol_to_list (actual_name, strlen (actual_name),
-                          built_actual_name,
-                          VAR_DOMAIN, LOC_CONST,
-                          (cu->language == language_cplus
-                           || cu->language == language_java)
-                          ? &objfile->global_psymbols
-                          : &objfile->static_psymbols,
-                          0, (CORE_ADDR) 0, cu->language, objfile);
-      break;
-    default:
-      break;
-    }
+  dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
 
-  if (built_actual_name)
-    xfree (actual_name);
-}
+  /* Any cached compilation units will be linked by the per-objfile
+     read_in_chain.  Make sure to free them when we're done.  */
+  back_to = make_cleanup (free_cached_comp_units, NULL);
 
-/* Read a partial die corresponding to a namespace; also, add a symbol
-   corresponding to that namespace to the symbol table.  NAMESPACE is
-   the name of the enclosing namespace.  */
+  build_type_psymtabs (objfile);
 
-static void
-add_partial_namespace (struct partial_die_info *pdi,
-                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
-                      int need_pc, struct dwarf2_cu *cu)
-{
-  /* Add a symbol for the namespace.  */
+  create_all_comp_units (objfile);
 
-  add_partial_symbol (pdi, cu);
+  /* Create a temporary address map on a temporary obstack.  We later
+     copy this to the final obstack.  */
+  obstack_init (&temp_obstack);
+  make_cleanup_obstack_free (&temp_obstack);
+  objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
+  addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
 
-  /* Now scan partial symbols in that namespace.  */
+  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+    {
+      struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
 
-  if (pdi->has_children)
-    scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
+      process_psymtab_comp_unit (per_cu, 0);
+    }
+
+  set_partial_user (objfile);
+
+  objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
+                                                   &objfile->objfile_obstack);
+  discard_cleanups (addrmap_cleanup);
+
+  do_cleanups (back_to);
+
+  if (dwarf2_read_debug)
+    fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
+                       objfile->name);
 }
 
-/* Read a partial die corresponding to a Fortran module.  */
+/* die_reader_func for load_partial_comp_unit.  */
 
 static void
-add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
-                   CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
+load_partial_comp_unit_reader (const struct die_reader_specs *reader,
+                              gdb_byte *info_ptr,
+                              struct die_info *comp_unit_die,
+                              int has_children,
+                              void *data)
 {
-  /* Now scan partial symbols in that module.  */
+  struct dwarf2_cu *cu = reader->cu;
 
-  if (pdi->has_children)
-    scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
+  prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
+
+  /* Check if comp unit has_children.
+     If so, read the rest of the partial symbols from this comp unit.
+     If not, there's no more debug_info for this comp unit.  */
+  if (has_children)
+    load_partial_dies (reader, info_ptr, 0);
 }
 
-/* Read a partial die corresponding to a subprogram and create a partial
-   symbol for that subprogram.  When the CU language allows it, this
-   routine also defines a partial symbol for each nested subprogram
-   that this subprogram contains.
+/* Load the partial DIEs for a secondary CU into memory.
+   This is also used when rereading a primary CU with load_all_dies.  */
 
-   DIE my also be a lexical block, in which case we simply search
-   recursively for suprograms defined inside that lexical block.
-   Again, this is only performed when the CU language allows this
-   type of definitions.  */
+static void
+load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
+{
+  init_cutu_and_read_dies (this_cu, NULL, 1, 1,
+                          load_partial_comp_unit_reader, NULL);
+}
 
 static void
-add_partial_subprogram (struct partial_die_info *pdi,
-                       CORE_ADDR *lowpc, CORE_ADDR *highpc,
-                       int need_pc, struct dwarf2_cu *cu)
+read_comp_units_from_section (struct objfile *objfile,
+                             struct dwarf2_section_info *section,
+                             unsigned int is_dwz,
+                             int *n_allocated,
+                             int *n_comp_units,
+                             struct dwarf2_per_cu_data ***all_comp_units)
 {
-  if (pdi->tag == DW_TAG_subprogram)
-    {
-      if (pdi->has_pc_info)
-        {
-          if (pdi->lowpc < *lowpc)
-            *lowpc = pdi->lowpc;
-          if (pdi->highpc > *highpc)
-            *highpc = pdi->highpc;
-         if (need_pc)
-           {
-             CORE_ADDR baseaddr;
-             struct objfile *objfile = cu->objfile;
+  gdb_byte *info_ptr;
+  bfd *abfd = section->asection->owner;
 
-             baseaddr = ANOFFSET (objfile->section_offsets,
-                                  SECT_OFF_TEXT (objfile));
-             addrmap_set_empty (objfile->psymtabs_addrmap,
-                                pdi->lowpc + baseaddr,
-                                pdi->highpc - 1 + baseaddr,
-                                cu->per_cu->v.psymtab);
-           }
-          if (!pdi->is_declaration)
-           /* Ignore subprogram DIEs that do not have a name, they are
-              illegal.  Do not emit a complaint at this point, we will
-              do so when we convert this psymtab into a symtab.  */
-           if (pdi->name)
-             add_partial_symbol (pdi, cu);
-        }
-    }
+  dwarf2_read_section (objfile, section);
 
-  if (! pdi->has_children)
-    return;
+  info_ptr = section->buffer;
 
-  if (cu->language == language_ada)
+  while (info_ptr < section->buffer + section->size)
     {
-      pdi = pdi->die_child;
-      while (pdi != NULL)
+      unsigned int length, initial_length_size;
+      struct dwarf2_per_cu_data *this_cu;
+      sect_offset offset;
+
+      offset.sect_off = info_ptr - section->buffer;
+
+      /* Read just enough information to find out where the next
+        compilation unit is.  */
+      length = read_initial_length (abfd, info_ptr, &initial_length_size);
+
+      /* Save the compilation unit for later lookup.  */
+      this_cu = obstack_alloc (&objfile->objfile_obstack,
+                              sizeof (struct dwarf2_per_cu_data));
+      memset (this_cu, 0, sizeof (*this_cu));
+      this_cu->offset = offset;
+      this_cu->length = length + initial_length_size;
+      this_cu->is_dwz = is_dwz;
+      this_cu->objfile = objfile;
+      this_cu->info_or_types_section = section;
+
+      if (*n_comp_units == *n_allocated)
        {
-         fixup_partial_die (pdi, cu);
-         if (pdi->tag == DW_TAG_subprogram
-             || pdi->tag == DW_TAG_lexical_block)
-           add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
-         pdi = pdi->die_sibling;
+         *n_allocated *= 2;
+         *all_comp_units = xrealloc (*all_comp_units,
+                                     *n_allocated
+                                     * sizeof (struct dwarf2_per_cu_data *));
        }
+      (*all_comp_units)[*n_comp_units] = this_cu;
+      ++*n_comp_units;
+
+      info_ptr = info_ptr + this_cu->length;
     }
 }
 
-/* Read a partial die corresponding to an enumeration type.  */
+/* Create a list of all compilation units in OBJFILE.
+   This is only done for -readnow and building partial symtabs.  */
 
 static void
-add_partial_enumeration (struct partial_die_info *enum_pdi,
-                        struct dwarf2_cu *cu)
+create_all_comp_units (struct objfile *objfile)
 {
-  struct partial_die_info *pdi;
-
-  if (enum_pdi->name != NULL)
-    add_partial_symbol (enum_pdi, cu);
+  int n_allocated;
+  int n_comp_units;
+  struct dwarf2_per_cu_data **all_comp_units;
 
-  pdi = enum_pdi->die_child;
-  while (pdi)
+  n_comp_units = 0;
+  n_allocated = 10;
+  all_comp_units = xmalloc (n_allocated
+                           * sizeof (struct dwarf2_per_cu_data *));
+
+  read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
+                               &n_allocated, &n_comp_units, &all_comp_units);
+
+  if (bfd_get_section_by_name (objfile->obfd, ".gnu_debugaltlink") != NULL)
     {
-      if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
-       complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
-      else
-       add_partial_symbol (pdi, cu);
-      pdi = pdi->die_sibling;
+      struct dwz_file *dwz = dwarf2_get_dwz_file ();
+
+      read_comp_units_from_section (objfile, &dwz->info, 1,
+                                   &n_allocated, &n_comp_units,
+                                   &all_comp_units);
     }
+
+  dwarf2_per_objfile->all_comp_units
+    = obstack_alloc (&objfile->objfile_obstack,
+                    n_comp_units * sizeof (struct dwarf2_per_cu_data *));
+  memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
+         n_comp_units * sizeof (struct dwarf2_per_cu_data *));
+  xfree (all_comp_units);
+  dwarf2_per_objfile->n_comp_units = n_comp_units;
 }
 
-/* Return the initial uleb128 in the die at INFO_PTR.  */
+/* Process all loaded DIEs for compilation unit CU, starting at
+   FIRST_DIE.  The caller should pass NEED_PC == 1 if the compilation
+   unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
+   DW_AT_ranges).  If NEED_PC is set, then this function will set
+   *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
+   and record the covered ranges in the addrmap.  */
 
-static unsigned int
-peek_abbrev_code (bfd *abfd, gdb_byte *info_ptr)
+static void
+scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
+                     CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
 {
-  unsigned int bytes_read;
+  struct partial_die_info *pdi;
 
-  return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+  /* Now, march along the PDI's, descending into ones which have
+     interesting children but skipping the children of the other ones,
+     until we reach the end of the compilation unit.  */
+
+  pdi = first_die;
+
+  while (pdi != NULL)
+    {
+      fixup_partial_die (pdi, cu);
+
+      /* Anonymous namespaces or modules have no name but have interesting
+        children, so we need to look at them.  Ditto for anonymous
+        enums.  */
+
+      if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
+         || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
+         || pdi->tag == DW_TAG_imported_unit)
+       {
+         switch (pdi->tag)
+           {
+           case DW_TAG_subprogram:
+             add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
+             break;
+           case DW_TAG_constant:
+           case DW_TAG_variable:
+           case DW_TAG_typedef:
+           case DW_TAG_union_type:
+             if (!pdi->is_declaration)
+               {
+                 add_partial_symbol (pdi, cu);
+               }
+             break;
+           case DW_TAG_class_type:
+           case DW_TAG_interface_type:
+           case DW_TAG_structure_type:
+             if (!pdi->is_declaration)
+               {
+                 add_partial_symbol (pdi, cu);
+               }
+             break;
+           case DW_TAG_enumeration_type:
+             if (!pdi->is_declaration)
+               add_partial_enumeration (pdi, cu);
+             break;
+           case DW_TAG_base_type:
+            case DW_TAG_subrange_type:
+             /* File scope base type definitions are added to the partial
+                symbol table.  */
+             add_partial_symbol (pdi, cu);
+             break;
+           case DW_TAG_namespace:
+             add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
+             break;
+           case DW_TAG_module:
+             add_partial_module (pdi, lowpc, highpc, need_pc, cu);
+             break;
+           case DW_TAG_imported_unit:
+             {
+               struct dwarf2_per_cu_data *per_cu;
+
+               /* For now we don't handle imported units in type units.  */
+               if (cu->per_cu->is_debug_types)
+                 {
+                   error (_("Dwarf Error: DW_TAG_imported_unit is not"
+                            " supported in type units [in module %s]"),
+                          cu->objfile->name);
+                 }
+
+               per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
+                                                          pdi->is_dwz,
+                                                          cu->objfile);
+
+               /* Go read the partial unit, if needed.  */
+               if (per_cu->v.psymtab == NULL)
+                 process_psymtab_comp_unit (per_cu, 1);
+
+               VEC_safe_push (dwarf2_per_cu_ptr,
+                              cu->per_cu->imported_symtabs, per_cu);
+             }
+             break;
+           default:
+             break;
+           }
+       }
+
+      /* If the die has a sibling, skip to the sibling.  */
+
+      pdi = pdi->die_sibling;
+    }
 }
 
-/* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
-   Return the corresponding abbrev, or NULL if the number is zero (indicating
-   an empty DIE).  In either case *BYTES_READ will be set to the length of
-   the initial number.  */
+/* Functions used to compute the fully scoped name of a partial DIE.
 
-static struct abbrev_info *
-peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
-                struct dwarf2_cu *cu)
+   Normally, this is simple.  For C++, the parent DIE's fully scoped
+   name is concatenated with "::" and the partial DIE's name.  For
+   Java, the same thing occurs except that "." is used instead of "::".
+   Enumerators are an exception; they use the scope of their parent
+   enumeration type, i.e. the name of the enumeration type is not
+   prepended to the enumerator.
+
+   There are two complexities.  One is DW_AT_specification; in this
+   case "parent" means the parent of the target of the specification,
+   instead of the direct parent of the DIE.  The other is compilers
+   which do not emit DW_TAG_namespace; in this case we try to guess
+   the fully qualified name of structure types from their members'
+   linkage names.  This must be done using the DIE's children rather
+   than the children of any DW_AT_specification target.  We only need
+   to do this for structures at the top level, i.e. if the target of
+   any DW_AT_specification (if any; otherwise the DIE itself) does not
+   have a parent.  */
+
+/* Compute the scope prefix associated with PDI's parent, in
+   compilation unit CU.  The result will be allocated on CU's
+   comp_unit_obstack, or a copy of the already allocated PDI->NAME
+   field.  NULL is returned if no prefix is necessary.  */
+static const char *
+partial_die_parent_scope (struct partial_die_info *pdi,
+                         struct dwarf2_cu *cu)
 {
-  bfd *abfd = cu->objfile->obfd;
-  unsigned int abbrev_number;
-  struct abbrev_info *abbrev;
+  const char *grandparent_scope;
+  struct partial_die_info *parent, *real_pdi;
 
-  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
+  /* We need to look at our parent DIE; if we have a DW_AT_specification,
+     then this means the parent of the specification DIE.  */
 
-  if (abbrev_number == 0)
+  real_pdi = pdi;
+  while (real_pdi->has_specification)
+    real_pdi = find_partial_die (real_pdi->spec_offset,
+                                real_pdi->spec_is_dwz, cu);
+
+  parent = real_pdi->die_parent;
+  if (parent == NULL)
     return NULL;
 
-  abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
-  if (!abbrev)
-    {
-      error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
-            abbrev_number, bfd_get_filename (abfd));
-    }
+  if (parent->scope_set)
+    return parent->scope;
 
-  return abbrev;
-}
+  fixup_partial_die (parent, cu);
 
-/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
-   Returns a pointer to the end of a series of DIEs, terminated by an empty
-   DIE.  Any children of the skipped DIEs will also be skipped.  */
+  grandparent_scope = partial_die_parent_scope (parent, cu);
 
-static gdb_byte *
-skip_children (gdb_byte *buffer, gdb_byte *info_ptr, struct dwarf2_cu *cu)
-{
-  struct abbrev_info *abbrev;
-  unsigned int bytes_read;
+  /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
+     DW_TAG_namespace DIEs with a name of "::" for the global namespace.
+     Work around this problem here.  */
+  if (cu->language == language_cplus
+      && parent->tag == DW_TAG_namespace
+      && strcmp (parent->name, "::") == 0
+      && grandparent_scope == NULL)
+    {
+      parent->scope = NULL;
+      parent->scope_set = 1;
+      return NULL;
+    }
 
-  while (1)
+  if (pdi->tag == DW_TAG_enumerator)
+    /* Enumerators should not get the name of the enumeration as a prefix.  */
+    parent->scope = grandparent_scope;
+  else if (parent->tag == DW_TAG_namespace
+      || parent->tag == DW_TAG_module
+      || parent->tag == DW_TAG_structure_type
+      || parent->tag == DW_TAG_class_type
+      || parent->tag == DW_TAG_interface_type
+      || parent->tag == DW_TAG_union_type
+      || parent->tag == DW_TAG_enumeration_type)
     {
-      abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
-      if (abbrev == NULL)
-       return info_ptr + bytes_read;
+      if (grandparent_scope == NULL)
+       parent->scope = parent->name;
       else
-       info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
+       parent->scope = typename_concat (&cu->comp_unit_obstack,
+                                        grandparent_scope,
+                                        parent->name, 0, cu);
+    }
+  else
+    {
+      /* FIXME drow/2004-04-01: What should we be doing with
+        function-local names?  For partial symbols, we should probably be
+        ignoring them.  */
+      complaint (&symfile_complaints,
+                _("unhandled containing DIE tag %d for DIE at %d"),
+                parent->tag, pdi->offset.sect_off);
+      parent->scope = grandparent_scope;
     }
+
+  parent->scope_set = 1;
+  return parent->scope;
 }
 
-/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
-   INFO_PTR should point just after the initial uleb128 of a DIE, and the
-   abbrev corresponding to that skipped uleb128 should be passed in
-   ABBREV.  Returns a pointer to this DIE's sibling, skipping any
-   children.  */
+/* Return the fully scoped name associated with PDI, from compilation unit
+   CU.  The result will be allocated with malloc.  */
 
-static gdb_byte *
-skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
-             struct abbrev_info *abbrev, struct dwarf2_cu *cu)
+static char *
+partial_die_full_name (struct partial_die_info *pdi,
+                      struct dwarf2_cu *cu)
 {
-  unsigned int bytes_read;
-  struct attribute attr;
-  bfd *abfd = cu->objfile->obfd;
-  unsigned int form, i;
+  const char *parent_scope;
 
-  for (i = 0; i < abbrev->num_attrs; i++)
+  /* If this is a template instantiation, we can not work out the
+     template arguments from partial DIEs.  So, unfortunately, we have
+     to go through the full DIEs.  At least any work we do building
+     types here will be reused if full symbols are loaded later.  */
+  if (pdi->has_template_arguments)
     {
-      /* The only abbrev we care about is DW_AT_sibling.  */
-      if (abbrev->attrs[i].name == DW_AT_sibling)
-       {
-         read_attribute (&attr, &abbrev->attrs[i],
-                         abfd, info_ptr, cu);
-         if (attr.form == DW_FORM_ref_addr)
-           complaint (&symfile_complaints,
-                      _("ignoring absolute DW_AT_sibling"));
-         else
-           return buffer + dwarf2_get_ref_die_offset (&attr);
-       }
+      fixup_partial_die (pdi, cu);
 
-      /* If it isn't DW_AT_sibling, skip this attribute.  */
-      form = abbrev->attrs[i].form;
-    skip_attribute:
-      switch (form)
+      if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
+       {
+         struct die_info *die;
+         struct attribute attr;
+         struct dwarf2_cu *ref_cu = cu;
+
+         /* DW_FORM_ref_addr is using section offset.  */
+         attr.name = 0;
+         attr.form = DW_FORM_ref_addr;
+         attr.u.unsnd = pdi->offset.sect_off;
+         die = follow_die_ref (NULL, &attr, &ref_cu);
+
+         return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
+       }
+    }
+
+  parent_scope = partial_die_parent_scope (pdi, cu);
+  if (parent_scope == NULL)
+    return NULL;
+  else
+    return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
+}
+
+static void
+add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
+{
+  struct objfile *objfile = cu->objfile;
+  CORE_ADDR addr = 0;
+  const char *actual_name = NULL;
+  CORE_ADDR baseaddr;
+  char *built_actual_name;
+
+  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+
+  built_actual_name = partial_die_full_name (pdi, cu);
+  if (built_actual_name != NULL)
+    actual_name = built_actual_name;
+
+  if (actual_name == NULL)
+    actual_name = pdi->name;
+
+  switch (pdi->tag)
+    {
+    case DW_TAG_subprogram:
+      if (pdi->is_external || cu->language == language_ada)
+       {
+          /* brobecker/2007-12-26: Normally, only "external" DIEs are part
+             of the global scope.  But in Ada, we want to be able to access
+             nested procedures globally.  So all Ada subprograms are stored
+             in the global scope.  */
+         /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
+            mst_text, objfile); */
+         add_psymbol_to_list (actual_name, strlen (actual_name),
+                              built_actual_name != NULL,
+                              VAR_DOMAIN, LOC_BLOCK,
+                              &objfile->global_psymbols,
+                              0, pdi->lowpc + baseaddr,
+                              cu->language, objfile);
+       }
+      else
+       {
+         /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
+            mst_file_text, objfile); */
+         add_psymbol_to_list (actual_name, strlen (actual_name),
+                              built_actual_name != NULL,
+                              VAR_DOMAIN, LOC_BLOCK,
+                              &objfile->static_psymbols,
+                              0, pdi->lowpc + baseaddr,
+                              cu->language, objfile);
+       }
+      break;
+    case DW_TAG_constant:
+      {
+        struct psymbol_allocation_list *list;
+
+       if (pdi->is_external)
+         list = &objfile->global_psymbols;
+       else
+         list = &objfile->static_psymbols;
+       add_psymbol_to_list (actual_name, strlen (actual_name),
+                            built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
+                            list, 0, 0, cu->language, objfile);
+      }
+      break;
+    case DW_TAG_variable:
+      if (pdi->d.locdesc)
+       addr = decode_locdesc (pdi->d.locdesc, cu);
+
+      if (pdi->d.locdesc
+         && addr == 0
+         && !dwarf2_per_objfile->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
+            will be nullified; do not add such variables into partial
+            symbol table then.  */
+       }
+      else if (pdi->is_external)
+       {
+         /* Global Variable.
+            Don't enter into the minimal symbol tables as there is
+            a minimal symbol table entry from the ELF symbols already.
+            Enter into partial symbol table if it has a location
+            descriptor or a type.
+            If the location descriptor is missing, new_symbol will create
+            a LOC_UNRESOLVED symbol, the address of the variable will then
+            be determined from the minimal symbol table whenever the variable
+            is referenced.
+            The address for the partial symbol table entry is not
+            used by GDB, but it comes in handy for debugging partial symbol
+            table building.  */
+
+         if (pdi->d.locdesc || pdi->has_type)
+           add_psymbol_to_list (actual_name, strlen (actual_name),
+                                built_actual_name != NULL,
+                                VAR_DOMAIN, LOC_STATIC,
+                                &objfile->global_psymbols,
+                                0, addr + baseaddr,
+                                cu->language, objfile);
+       }
+      else
+       {
+         /* Static Variable.  Skip symbols without location descriptors.  */
+         if (pdi->d.locdesc == NULL)
+           {
+             xfree (built_actual_name);
+             return;
+           }
+         /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
+            mst_file_data, objfile); */
+         add_psymbol_to_list (actual_name, strlen (actual_name),
+                              built_actual_name != NULL,
+                              VAR_DOMAIN, LOC_STATIC,
+                              &objfile->static_psymbols,
+                              0, addr + baseaddr,
+                              cu->language, objfile);
+       }
+      break;
+    case DW_TAG_typedef:
+    case DW_TAG_base_type:
+    case DW_TAG_subrange_type:
+      add_psymbol_to_list (actual_name, strlen (actual_name),
+                          built_actual_name != NULL,
+                          VAR_DOMAIN, LOC_TYPEDEF,
+                          &objfile->static_psymbols,
+                          0, (CORE_ADDR) 0, cu->language, objfile);
+      break;
+    case DW_TAG_namespace:
+      add_psymbol_to_list (actual_name, strlen (actual_name),
+                          built_actual_name != NULL,
+                          VAR_DOMAIN, LOC_TYPEDEF,
+                          &objfile->global_psymbols,
+                          0, (CORE_ADDR) 0, cu->language, objfile);
+      break;
+    case DW_TAG_class_type:
+    case DW_TAG_interface_type:
+    case DW_TAG_structure_type:
+    case DW_TAG_union_type:
+    case DW_TAG_enumeration_type:
+      /* Skip external references.  The DWARF standard says in the section
+         about "Structure, Union, and Class Type Entries": "An incomplete
+         structure, union or class type is represented by a structure,
+         union or class entry that does not have a byte size attribute
+         and that has a DW_AT_declaration attribute."  */
+      if (!pdi->has_byte_size && pdi->is_declaration)
+       {
+         xfree (built_actual_name);
+         return;
+       }
+
+      /* NOTE: carlton/2003-10-07: See comment in new_symbol about
+        static vs. global.  */
+      add_psymbol_to_list (actual_name, strlen (actual_name),
+                          built_actual_name != NULL,
+                          STRUCT_DOMAIN, LOC_TYPEDEF,
+                          (cu->language == language_cplus
+                           || cu->language == language_java)
+                          ? &objfile->global_psymbols
+                          : &objfile->static_psymbols,
+                          0, (CORE_ADDR) 0, cu->language, objfile);
+
+      break;
+    case DW_TAG_enumerator:
+      add_psymbol_to_list (actual_name, strlen (actual_name),
+                          built_actual_name != NULL,
+                          VAR_DOMAIN, LOC_CONST,
+                          (cu->language == language_cplus
+                           || cu->language == language_java)
+                          ? &objfile->global_psymbols
+                          : &objfile->static_psymbols,
+                          0, (CORE_ADDR) 0, cu->language, objfile);
+      break;
+    default:
+      break;
+    }
+
+  xfree (built_actual_name);
+}
+
+/* Read a partial die corresponding to a namespace; also, add a symbol
+   corresponding to that namespace to the symbol table.  NAMESPACE is
+   the name of the enclosing namespace.  */
+
+static void
+add_partial_namespace (struct partial_die_info *pdi,
+                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
+                      int need_pc, struct dwarf2_cu *cu)
+{
+  /* Add a symbol for the namespace.  */
+
+  add_partial_symbol (pdi, cu);
+
+  /* Now scan partial symbols in that namespace.  */
+
+  if (pdi->has_children)
+    scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
+}
+
+/* Read a partial die corresponding to a Fortran module.  */
+
+static void
+add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
+                   CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
+{
+  /* Now scan partial symbols in that module.  */
+
+  if (pdi->has_children)
+    scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
+}
+
+/* Read a partial die corresponding to a subprogram and create a partial
+   symbol for that subprogram.  When the CU language allows it, this
+   routine also defines a partial symbol for each nested subprogram
+   that this subprogram contains.
+
+   DIE my also be a lexical block, in which case we simply search
+   recursively for suprograms defined inside that lexical block.
+   Again, this is only performed when the CU language allows this
+   type of definitions.  */
+
+static void
+add_partial_subprogram (struct partial_die_info *pdi,
+                       CORE_ADDR *lowpc, CORE_ADDR *highpc,
+                       int need_pc, struct dwarf2_cu *cu)
+{
+  if (pdi->tag == DW_TAG_subprogram)
+    {
+      if (pdi->has_pc_info)
+        {
+          if (pdi->lowpc < *lowpc)
+            *lowpc = pdi->lowpc;
+          if (pdi->highpc > *highpc)
+            *highpc = pdi->highpc;
+         if (need_pc)
+           {
+             CORE_ADDR baseaddr;
+             struct objfile *objfile = cu->objfile;
+
+             baseaddr = ANOFFSET (objfile->section_offsets,
+                                  SECT_OFF_TEXT (objfile));
+             addrmap_set_empty (objfile->psymtabs_addrmap,
+                                pdi->lowpc + baseaddr,
+                                pdi->highpc - 1 + baseaddr,
+                                cu->per_cu->v.psymtab);
+           }
+        }
+
+      if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
+       {
+          if (!pdi->is_declaration)
+           /* Ignore subprogram DIEs that do not have a name, they are
+              illegal.  Do not emit a complaint at this point, we will
+              do so when we convert this psymtab into a symtab.  */
+           if (pdi->name)
+             add_partial_symbol (pdi, cu);
+        }
+    }
+
+  if (! pdi->has_children)
+    return;
+
+  if (cu->language == language_ada)
+    {
+      pdi = pdi->die_child;
+      while (pdi != NULL)
+       {
+         fixup_partial_die (pdi, cu);
+         if (pdi->tag == DW_TAG_subprogram
+             || pdi->tag == DW_TAG_lexical_block)
+           add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
+         pdi = pdi->die_sibling;
+       }
+    }
+}
+
+/* Read a partial die corresponding to an enumeration type.  */
+
+static void
+add_partial_enumeration (struct partial_die_info *enum_pdi,
+                        struct dwarf2_cu *cu)
+{
+  struct partial_die_info *pdi;
+
+  if (enum_pdi->name != NULL)
+    add_partial_symbol (enum_pdi, cu);
+
+  pdi = enum_pdi->die_child;
+  while (pdi)
+    {
+      if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
+       complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
+      else
+       add_partial_symbol (pdi, cu);
+      pdi = pdi->die_sibling;
+    }
+}
+
+/* Return the initial uleb128 in the die at INFO_PTR.  */
+
+static unsigned int
+peek_abbrev_code (bfd *abfd, gdb_byte *info_ptr)
+{
+  unsigned int bytes_read;
+
+  return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+}
+
+/* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
+   Return the corresponding abbrev, or NULL if the number is zero (indicating
+   an empty DIE).  In either case *BYTES_READ will be set to the length of
+   the initial number.  */
+
+static struct abbrev_info *
+peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
+                struct dwarf2_cu *cu)
+{
+  bfd *abfd = cu->objfile->obfd;
+  unsigned int abbrev_number;
+  struct abbrev_info *abbrev;
+
+  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
+
+  if (abbrev_number == 0)
+    return NULL;
+
+  abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
+  if (!abbrev)
+    {
+      error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
+            abbrev_number, bfd_get_filename (abfd));
+    }
+
+  return abbrev;
+}
+
+/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
+   Returns a pointer to the end of a series of DIEs, terminated by an empty
+   DIE.  Any children of the skipped DIEs will also be skipped.  */
+
+static gdb_byte *
+skip_children (const struct die_reader_specs *reader, gdb_byte *info_ptr)
+{
+  struct dwarf2_cu *cu = reader->cu;
+  struct abbrev_info *abbrev;
+  unsigned int bytes_read;
+
+  while (1)
+    {
+      abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
+      if (abbrev == NULL)
+       return info_ptr + bytes_read;
+      else
+       info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
+    }
+}
+
+/* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
+   INFO_PTR should point just after the initial uleb128 of a DIE, and the
+   abbrev corresponding to that skipped uleb128 should be passed in
+   ABBREV.  Returns a pointer to this DIE's sibling, skipping any
+   children.  */
+
+static gdb_byte *
+skip_one_die (const struct die_reader_specs *reader, gdb_byte *info_ptr,
+             struct abbrev_info *abbrev)
+{
+  unsigned int bytes_read;
+  struct attribute attr;
+  bfd *abfd = reader->abfd;
+  struct dwarf2_cu *cu = reader->cu;
+  gdb_byte *buffer = reader->buffer;
+  const gdb_byte *buffer_end = reader->buffer_end;
+  gdb_byte *start_info_ptr = info_ptr;
+  unsigned int form, i;
+
+  for (i = 0; i < abbrev->num_attrs; i++)
+    {
+      /* The only abbrev we care about is DW_AT_sibling.  */
+      if (abbrev->attrs[i].name == DW_AT_sibling)
+       {
+         read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
+         if (attr.form == DW_FORM_ref_addr)
+           complaint (&symfile_complaints,
+                      _("ignoring absolute DW_AT_sibling"));
+         else
+           return buffer + dwarf2_get_ref_die_offset (&attr).sect_off;
+       }
+
+      /* If it isn't DW_AT_sibling, skip this attribute.  */
+      form = abbrev->attrs[i].form;
+    skip_attribute:
+      switch (form)
        {
        case DW_FORM_ref_addr:
          /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
@@ -4449,1432 +6306,2988 @@ skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
          if (cu->header.version == 2)
            info_ptr += cu->header.addr_size;
          else
-           info_ptr += cu->header.offset_size;
-         break;
-       case DW_FORM_addr:
-         info_ptr += cu->header.addr_size;
-         break;
-       case DW_FORM_data1:
-       case DW_FORM_ref1:
-       case DW_FORM_flag:
-         info_ptr += 1;
-         break;
-       case DW_FORM_flag_present:
-         break;
-       case DW_FORM_data2:
-       case DW_FORM_ref2:
-         info_ptr += 2;
-         break;
-       case DW_FORM_data4:
-       case DW_FORM_ref4:
-         info_ptr += 4;
-         break;
-       case DW_FORM_data8:
-       case DW_FORM_ref8:
-       case DW_FORM_ref_sig8:
-         info_ptr += 8;
-         break;
-       case DW_FORM_string:
-         read_direct_string (abfd, info_ptr, &bytes_read);
-         info_ptr += bytes_read;
-         break;
-       case DW_FORM_sec_offset:
-       case DW_FORM_strp:
-         info_ptr += cu->header.offset_size;
-         break;
-       case DW_FORM_exprloc:
-       case DW_FORM_block:
-         info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-         info_ptr += bytes_read;
-         break;
-       case DW_FORM_block1:
-         info_ptr += 1 + read_1_byte (abfd, info_ptr);
-         break;
-       case DW_FORM_block2:
-         info_ptr += 2 + read_2_bytes (abfd, info_ptr);
-         break;
-       case DW_FORM_block4:
-         info_ptr += 4 + read_4_bytes (abfd, info_ptr);
-         break;
-       case DW_FORM_sdata:
-       case DW_FORM_udata:
-       case DW_FORM_ref_udata:
-         info_ptr = skip_leb128 (abfd, info_ptr);
-         break;
-       case DW_FORM_indirect:
-         form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-         info_ptr += bytes_read;
-         /* We need to continue parsing from here, so just go back to
-            the top.  */
-         goto skip_attribute;
+           info_ptr += cu->header.offset_size;
+         break;
+       case DW_FORM_GNU_ref_alt:
+         info_ptr += cu->header.offset_size;
+         break;
+       case DW_FORM_addr:
+         info_ptr += cu->header.addr_size;
+         break;
+       case DW_FORM_data1:
+       case DW_FORM_ref1:
+       case DW_FORM_flag:
+         info_ptr += 1;
+         break;
+       case DW_FORM_flag_present:
+         break;
+       case DW_FORM_data2:
+       case DW_FORM_ref2:
+         info_ptr += 2;
+         break;
+       case DW_FORM_data4:
+       case DW_FORM_ref4:
+         info_ptr += 4;
+         break;
+       case DW_FORM_data8:
+       case DW_FORM_ref8:
+       case DW_FORM_ref_sig8:
+         info_ptr += 8;
+         break;
+       case DW_FORM_string:
+         read_direct_string (abfd, info_ptr, &bytes_read);
+         info_ptr += bytes_read;
+         break;
+       case DW_FORM_sec_offset:
+       case DW_FORM_strp:
+       case DW_FORM_GNU_strp_alt:
+         info_ptr += cu->header.offset_size;
+         break;
+       case DW_FORM_exprloc:
+       case DW_FORM_block:
+         info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+         info_ptr += bytes_read;
+         break;
+       case DW_FORM_block1:
+         info_ptr += 1 + read_1_byte (abfd, info_ptr);
+         break;
+       case DW_FORM_block2:
+         info_ptr += 2 + read_2_bytes (abfd, info_ptr);
+         break;
+       case DW_FORM_block4:
+         info_ptr += 4 + read_4_bytes (abfd, info_ptr);
+         break;
+       case DW_FORM_sdata:
+       case DW_FORM_udata:
+       case DW_FORM_ref_udata:
+       case DW_FORM_GNU_addr_index:
+       case DW_FORM_GNU_str_index:
+         info_ptr = (gdb_byte *) safe_skip_leb128 (info_ptr, buffer_end);
+         break;
+       case DW_FORM_indirect:
+         form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+         info_ptr += bytes_read;
+         /* We need to continue parsing from here, so just go back to
+            the top.  */
+         goto skip_attribute;
+
+       default:
+         error (_("Dwarf Error: Cannot handle %s "
+                  "in DWARF reader [in module %s]"),
+                dwarf_form_name (form),
+                bfd_get_filename (abfd));
+       }
+    }
+
+  if (abbrev->has_children)
+    return skip_children (reader, info_ptr);
+  else
+    return info_ptr;
+}
+
+/* Locate ORIG_PDI's sibling.
+   INFO_PTR should point to the start of the next DIE after ORIG_PDI.  */
+
+static gdb_byte *
+locate_pdi_sibling (const struct die_reader_specs *reader,
+                   struct partial_die_info *orig_pdi,
+                   gdb_byte *info_ptr)
+{
+  /* Do we know the sibling already?  */
+
+  if (orig_pdi->sibling)
+    return orig_pdi->sibling;
+
+  /* Are there any children to deal with?  */
+
+  if (!orig_pdi->has_children)
+    return info_ptr;
+
+  /* Skip the children the long way.  */
+
+  return skip_children (reader, info_ptr);
+}
+
+/* Expand this partial symbol table into a full symbol table.  SELF is
+   not NULL.  */
+
+static void
+dwarf2_read_symtab (struct partial_symtab *self,
+                   struct objfile *objfile)
+{
+  if (self->readin)
+    {
+      warning (_("bug: psymtab for %s is already read in."),
+              self->filename);
+    }
+  else
+    {
+      if (info_verbose)
+       {
+         printf_filtered (_("Reading in symbols for %s..."),
+                          self->filename);
+         gdb_flush (gdb_stdout);
+       }
+
+      /* Restore our global data.  */
+      dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+
+      /* 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
+        associated with the (presumably stripped) associated objfile.  */
+      if (objfile->separate_debug_objfile_backlink)
+       {
+         struct dwarf2_per_objfile *dpo_backlink
+           = objfile_data (objfile->separate_debug_objfile_backlink,
+                           dwarf2_objfile_data_key);
+
+         dwarf2_per_objfile->has_section_at_zero
+           = dpo_backlink->has_section_at_zero;
+       }
+
+      dwarf2_per_objfile->reading_partial_symbols = 0;
+
+      psymtab_to_symtab_1 (self);
+
+      /* Finish up the debug error message.  */
+      if (info_verbose)
+       printf_filtered (_("done.\n"));
+    }
+
+  process_cu_includes ();
+}
+\f
+/* Reading in full CUs.  */
+
+/* Add PER_CU to the queue.  */
+
+static void
+queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
+                enum language pretend_language)
+{
+  struct dwarf2_queue_item *item;
+
+  per_cu->queued = 1;
+  item = xmalloc (sizeof (*item));
+  item->per_cu = per_cu;
+  item->pretend_language = pretend_language;
+  item->next = NULL;
+
+  if (dwarf2_queue == NULL)
+    dwarf2_queue = item;
+  else
+    dwarf2_queue_tail->next = item;
+
+  dwarf2_queue_tail = item;
+}
+
+/* THIS_CU has a reference to PER_CU.  If necessary, load the new compilation
+   unit and add it to our queue.
+   The result is non-zero if PER_CU was queued, otherwise the result is zero
+   meaning either PER_CU is already queued or it is already loaded.  */
+
+static int
+maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
+                      struct dwarf2_per_cu_data *per_cu,
+                      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 (dwarf2_per_objfile->reading_partial_symbols)
+    {
+      if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
+       return 1;
+      return 0;
+    }
+
+  /* Mark the dependence relation so that we don't flush PER_CU
+     too early.  */
+  dwarf2_add_dependence (this_cu, per_cu);
+
+  /* If it's already on the queue, we have nothing to do.  */
+  if (per_cu->queued)
+    return 0;
+
+  /* If the compilation unit is already loaded, just mark it as
+     used.  */
+  if (per_cu->cu != NULL)
+    {
+      per_cu->cu->last_used = 0;
+      return 0;
+    }
+
+  /* Add it to the queue.  */
+  queue_comp_unit (per_cu, pretend_language);
+
+  return 1;
+}
+
+/* Process the queue.  */
+
+static void
+process_queue (void)
+{
+  struct dwarf2_queue_item *item, *next_item;
+
+  if (dwarf2_read_debug)
+    {
+      fprintf_unfiltered (gdb_stdlog,
+                         "Expanding one or more symtabs of objfile %s ...\n",
+                         dwarf2_per_objfile->objfile->name);
+    }
+
+  /* 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.  */
+  for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
+    {
+      if (dwarf2_per_objfile->using_index
+         ? !item->per_cu->v.quick->symtab
+         : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
+       {
+         struct dwarf2_per_cu_data *per_cu = item->per_cu;
+
+         if (dwarf2_read_debug)
+           {
+             fprintf_unfiltered (gdb_stdlog,
+                                 "Expanding symtab of %s at offset 0x%x\n",
+                                 per_cu->is_debug_types ? "TU" : "CU",
+                                 per_cu->offset.sect_off);
+           }
+
+         if (per_cu->is_debug_types)
+           process_full_type_unit (per_cu, item->pretend_language);
+         else
+           process_full_comp_unit (per_cu, item->pretend_language);
+
+         if (dwarf2_read_debug)
+           {
+             fprintf_unfiltered (gdb_stdlog,
+                                 "Done expanding %s at offset 0x%x\n",
+                                 per_cu->is_debug_types ? "TU" : "CU",
+                                 per_cu->offset.sect_off);
+           }
+       }
+
+      item->per_cu->queued = 0;
+      next_item = item->next;
+      xfree (item);
+    }
+
+  dwarf2_queue_tail = NULL;
+
+  if (dwarf2_read_debug)
+    {
+      fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
+                         dwarf2_per_objfile->objfile->name);
+    }
+}
+
+/* Free all allocated queue entries.  This function only releases anything if
+   an error was thrown; if the queue was processed then it would have been
+   freed as we went along.  */
+
+static void
+dwarf2_release_queue (void *dummy)
+{
+  struct dwarf2_queue_item *item, *last;
+
+  item = dwarf2_queue;
+  while (item)
+    {
+      /* Anything still marked queued is likely to be in an
+        inconsistent state, so discard it.  */
+      if (item->per_cu->queued)
+       {
+         if (item->per_cu->cu != NULL)
+           free_one_cached_comp_unit (item->per_cu);
+         item->per_cu->queued = 0;
+       }
+
+      last = item;
+      item = item->next;
+      xfree (last);
+    }
+
+  dwarf2_queue = dwarf2_queue_tail = NULL;
+}
+
+/* Read in full symbols for PST, and anything it depends on.  */
+
+static void
+psymtab_to_symtab_1 (struct partial_symtab *pst)
+{
+  struct dwarf2_per_cu_data *per_cu;
+  int i;
+
+  if (pst->readin)
+    return;
+
+  for (i = 0; i < pst->number_of_dependencies; i++)
+    if (!pst->dependencies[i]->readin
+       && pst->dependencies[i]->user == NULL)
+      {
+        /* Inform about additional files that need to be read in.  */
+        if (info_verbose)
+          {
+           /* FIXME: i18n: Need to make this a single string.  */
+            fputs_filtered (" ", gdb_stdout);
+            wrap_here ("");
+            fputs_filtered ("and ", gdb_stdout);
+            wrap_here ("");
+            printf_filtered ("%s...", pst->dependencies[i]->filename);
+            wrap_here ("");     /* Flush output.  */
+            gdb_flush (gdb_stdout);
+          }
+        psymtab_to_symtab_1 (pst->dependencies[i]);
+      }
+
+  per_cu = pst->read_symtab_private;
+
+  if (per_cu == NULL)
+    {
+      /* It's an include file, no symbols to read for it.
+         Everything is in the parent symtab.  */
+      pst->readin = 1;
+      return;
+    }
+
+  dw2_do_instantiate_symtab (per_cu);
+}
+
+/* Trivial hash function for die_info: the hash value of a DIE
+   is its offset in .debug_info for this objfile.  */
+
+static hashval_t
+die_hash (const void *item)
+{
+  const struct die_info *die = item;
+
+  return die->offset.sect_off;
+}
+
+/* Trivial comparison function for die_info structures: two DIEs
+   are equal if they have the same offset.  */
+
+static int
+die_eq (const void *item_lhs, const void *item_rhs)
+{
+  const struct die_info *die_lhs = item_lhs;
+  const struct die_info *die_rhs = item_rhs;
+
+  return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
+}
+
+/* die_reader_func for load_full_comp_unit.
+   This is identical to read_signatured_type_reader,
+   but is kept separate for now.  */
+
+static void
+load_full_comp_unit_reader (const struct die_reader_specs *reader,
+                           gdb_byte *info_ptr,
+                           struct die_info *comp_unit_die,
+                           int has_children,
+                           void *data)
+{
+  struct dwarf2_cu *cu = reader->cu;
+  enum language *language_ptr = data;
+
+  gdb_assert (cu->die_hash == NULL);
+  cu->die_hash =
+    htab_create_alloc_ex (cu->header.length / 12,
+                         die_hash,
+                         die_eq,
+                         NULL,
+                         &cu->comp_unit_obstack,
+                         hashtab_obstack_allocate,
+                         dummy_obstack_deallocate);
+
+  if (has_children)
+    comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
+                                                 &info_ptr, comp_unit_die);
+  cu->dies = comp_unit_die;
+  /* comp_unit_die is not stored in die_hash, no need.  */
+
+  /* We try not to read any attributes in this function, because not
+     all CUs needed for references have been loaded yet, and symbol
+     table processing isn't initialized.  But we have to set the CU language,
+     or we won't be able to build types correctly.
+     Similarly, if we do not read the producer, we can not apply
+     producer-specific interpretation.  */
+  prepare_one_comp_unit (cu, cu->dies, *language_ptr);
+}
+
+/* Load the DIEs associated with PER_CU into memory.  */
+
+static void
+load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
+                    enum language pretend_language)
+{
+  gdb_assert (! this_cu->is_debug_types);
+
+  init_cutu_and_read_dies (this_cu, NULL, 1, 1,
+                          load_full_comp_unit_reader, &pretend_language);
+}
+
+/* Add a DIE to the delayed physname list.  */
+
+static void
+add_to_method_list (struct type *type, int fnfield_index, int index,
+                   const char *name, struct die_info *die,
+                   struct dwarf2_cu *cu)
+{
+  struct delayed_method_info mi;
+  mi.type = type;
+  mi.fnfield_index = fnfield_index;
+  mi.index = index;
+  mi.name = name;
+  mi.die = die;
+  VEC_safe_push (delayed_method_info, cu->method_list, &mi);
+}
+
+/* A cleanup for freeing the delayed method list.  */
+
+static void
+free_delayed_list (void *ptr)
+{
+  struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
+  if (cu->method_list != NULL)
+    {
+      VEC_free (delayed_method_info, cu->method_list);
+      cu->method_list = NULL;
+    }
+}
+
+/* Compute the physnames of any methods on the CU's method list.
+
+   The computation of method physnames is delayed in order to avoid the
+   (bad) condition that one of the method's formal parameters is of an as yet
+   incomplete type.  */
+
+static void
+compute_delayed_physnames (struct dwarf2_cu *cu)
+{
+  int i;
+  struct delayed_method_info *mi;
+  for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
+    {
+      const char *physname;
+      struct fn_fieldlist *fn_flp
+       = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
+      physname = dwarf2_physname (mi->name, mi->die, cu);
+      fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
+    }
+}
+
+/* Go objects should be embedded in a DW_TAG_module DIE,
+   and it's not clear if/how imported objects will appear.
+   To keep Go support simple until that's worked out,
+   go back through what we've read and create something usable.
+   We could do this while processing each DIE, and feels kinda cleaner,
+   but that way is more invasive.
+   This is to, for example, allow the user to type "p var" or "b main"
+   without having to specify the package name, and allow lookups
+   of module.object to work in contexts that use the expression
+   parser.  */
+
+static void
+fixup_go_packaging (struct dwarf2_cu *cu)
+{
+  char *package_name = NULL;
+  struct pending *list;
+  int i;
+
+  for (list = global_symbols; list != NULL; list = list->next)
+    {
+      for (i = 0; i < list->nsyms; ++i)
+       {
+         struct symbol *sym = list->symbol[i];
+
+         if (SYMBOL_LANGUAGE (sym) == language_go
+             && SYMBOL_CLASS (sym) == LOC_BLOCK)
+           {
+             char *this_package_name = go_symbol_package_name (sym);
+
+             if (this_package_name == NULL)
+               continue;
+             if (package_name == NULL)
+               package_name = this_package_name;
+             else
+               {
+                 if (strcmp (package_name, this_package_name) != 0)
+                   complaint (&symfile_complaints,
+                              _("Symtab %s has objects from two different Go packages: %s and %s"),
+                              (SYMBOL_SYMTAB (sym)
+                         ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
+                               : cu->objfile->name),
+                              this_package_name, package_name);
+                 xfree (this_package_name);
+               }
+           }
+       }
+    }
+
+  if (package_name != NULL)
+    {
+      struct objfile *objfile = cu->objfile;
+      const char *saved_package_name = obstack_copy0 (&objfile->objfile_obstack,
+                                                     package_name,
+                                                     strlen (package_name));
+      struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
+                                    saved_package_name, objfile);
+      struct symbol *sym;
+
+      TYPE_TAG_NAME (type) = TYPE_NAME (type);
+
+      sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
+      SYMBOL_SET_LANGUAGE (sym, language_go);
+      SYMBOL_SET_NAMES (sym, saved_package_name,
+                       strlen (saved_package_name), 0, objfile);
+      /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
+        e.g., "main" finds the "main" module and not C's main().  */
+      SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_TYPE (sym) = type;
+
+      add_symbol_to_list (sym, &global_symbols);
+
+      xfree (package_name);
+    }
+}
+
+static void compute_symtab_includes (struct dwarf2_per_cu_data *per_cu);
+
+/* Return the symtab for PER_CU.  This works properly regardless of
+   whether we're using the index or psymtabs.  */
+
+static struct symtab *
+get_symtab (struct dwarf2_per_cu_data *per_cu)
+{
+  return (dwarf2_per_objfile->using_index
+         ? per_cu->v.quick->symtab
+         : per_cu->v.psymtab->symtab);
+}
+
+/* A helper function for computing the list of all symbol tables
+   included by PER_CU.  */
+
+static void
+recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr) **result,
+                               htab_t all_children,
+                               struct dwarf2_per_cu_data *per_cu)
+{
+  void **slot;
+  int ix;
+  struct dwarf2_per_cu_data *iter;
+
+  slot = htab_find_slot (all_children, per_cu, INSERT);
+  if (*slot != NULL)
+    {
+      /* This inclusion and its children have been processed.  */
+      return;
+    }
+
+  *slot = per_cu;
+  /* Only add a CU if it has a symbol table.  */
+  if (get_symtab (per_cu) != NULL)
+    VEC_safe_push (dwarf2_per_cu_ptr, *result, per_cu);
+
+  for (ix = 0;
+       VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
+       ++ix)
+    recursively_compute_inclusions (result, all_children, iter);
+}
+
+/* Compute the symtab 'includes' fields for the symtab related to
+   PER_CU.  */
+
+static void
+compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
+{
+  gdb_assert (! per_cu->is_debug_types);
+
+  if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
+    {
+      int ix, len;
+      struct dwarf2_per_cu_data *iter;
+      VEC (dwarf2_per_cu_ptr) *result_children = NULL;
+      htab_t all_children;
+      struct symtab *symtab = get_symtab (per_cu);
+
+      /* If we don't have a symtab, we can just skip this case.  */
+      if (symtab == NULL)
+       return;
+
+      all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
+                                       NULL, xcalloc, xfree);
+
+      for (ix = 0;
+          VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
+                       ix, iter);
+          ++ix)
+       recursively_compute_inclusions (&result_children, all_children, iter);
+
+      /* Now we have a transitive closure of all the included CUs, and
+        for .gdb_index version 7 the included TUs, so we can convert it
+        to a list of symtabs.  */
+      len = VEC_length (dwarf2_per_cu_ptr, result_children);
+      symtab->includes
+       = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
+                        (len + 1) * sizeof (struct symtab *));
+      for (ix = 0;
+          VEC_iterate (dwarf2_per_cu_ptr, result_children, ix, iter);
+          ++ix)
+       symtab->includes[ix] = get_symtab (iter);
+      symtab->includes[len] = NULL;
+
+      VEC_free (dwarf2_per_cu_ptr, result_children);
+      htab_delete (all_children);
+    }
+}
+
+/* Compute the 'includes' field for the symtabs of all the CUs we just
+   read.  */
+
+static void
+process_cu_includes (void)
+{
+  int ix;
+  struct dwarf2_per_cu_data *iter;
+
+  for (ix = 0;
+       VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
+                   ix, iter);
+       ++ix)
+    {
+      if (! iter->is_debug_types)
+       compute_symtab_includes (iter);
+    }
+
+  VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
+}
+
+/* Generate full symbol information for PER_CU, whose DIEs have
+   already been loaded into memory.  */
+
+static void
+process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
+                       enum language pretend_language)
+{
+  struct dwarf2_cu *cu = per_cu->cu;
+  struct objfile *objfile = per_cu->objfile;
+  CORE_ADDR lowpc, highpc;
+  struct symtab *symtab;
+  struct cleanup *back_to, *delayed_list_cleanup;
+  CORE_ADDR baseaddr;
+  struct block *static_block;
+
+  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+
+  buildsym_init ();
+  back_to = make_cleanup (really_free_pendings, NULL);
+  delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
+
+  cu->list_in_scope = &file_symbols;
+
+  cu->language = pretend_language;
+  cu->language_defn = language_def (cu->language);
+
+  /* Do line number decoding in read_file_scope () */
+  process_die (cu->dies, cu);
+
+  /* For now fudge the Go package.  */
+  if (cu->language == language_go)
+    fixup_go_packaging (cu);
+
+  /* Now that we have processed all the DIEs in the CU, all the types 
+     should be complete, and it should now be safe to compute all of the
+     physnames.  */
+  compute_delayed_physnames (cu);
+  do_cleanups (delayed_list_cleanup);
+
+  /* Some compilers don't define a DW_AT_high_pc attribute for the
+     compilation unit.  If the DW_AT_high_pc is missing, synthesize
+     it, by scanning the DIE's below the compilation unit.  */
+  get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
+
+  static_block
+    = end_symtab_get_static_block (highpc + baseaddr, objfile, 0,
+                                  per_cu->imported_symtabs != NULL);
+
+  /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
+     Also, DW_AT_ranges may record ranges not belonging to any child DIEs
+     (such as virtual method tables).  Record the ranges in STATIC_BLOCK's
+     addrmap to help ensure it has an accurate map of pc values belonging to
+     this comp unit.  */
+  dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
+
+  symtab = end_symtab_from_static_block (static_block, objfile,
+                                        SECT_OFF_TEXT (objfile), 0);
+
+  if (symtab != NULL)
+    {
+      int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
+
+      /* Set symtab language to language from DW_AT_language.  If the
+        compilation is from a C file generated by language preprocessors, do
+        not set the language if it was already deduced by start_subfile.  */
+      if (!(cu->language == language_c && symtab->language != language_c))
+       symtab->language = cu->language;
+
+      /* GCC-4.0 has started to support -fvar-tracking.  GCC-3.x still can
+        produce DW_AT_location with location lists but it can be possibly
+        invalid without -fvar-tracking.  Still up to GCC-4.4.x incl. 4.4.0
+        there were bugs in prologue debug info, fixed later in GCC-4.5
+        by "unwind info for epilogues" patch (which is not directly related).
+
+        For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
+        needed, it would be wrong due to missing DW_AT_producer there.
+
+        Still one can confuse GDB by using non-standard GCC compilation
+        options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
+        */ 
+      if (cu->has_loclist && gcc_4_minor >= 5)
+       symtab->locations_valid = 1;
+
+      if (gcc_4_minor >= 5)
+       symtab->epilogue_unwind_valid = 1;
+
+      symtab->call_site_htab = cu->call_site_htab;
+    }
+
+  if (dwarf2_per_objfile->using_index)
+    per_cu->v.quick->symtab = symtab;
+  else
+    {
+      struct partial_symtab *pst = per_cu->v.psymtab;
+      pst->symtab = symtab;
+      pst->readin = 1;
+    }
+
+  /* Push it for inclusion processing later.  */
+  VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
+
+  do_cleanups (back_to);
+}
+
+/* Generate full symbol information for type unit PER_CU, whose DIEs have
+   already been loaded into memory.  */
+
+static void
+process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
+                       enum language pretend_language)
+{
+  struct dwarf2_cu *cu = per_cu->cu;
+  struct objfile *objfile = per_cu->objfile;
+  struct symtab *symtab;
+  struct cleanup *back_to, *delayed_list_cleanup;
+
+  buildsym_init ();
+  back_to = make_cleanup (really_free_pendings, NULL);
+  delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
+
+  cu->list_in_scope = &file_symbols;
+
+  cu->language = pretend_language;
+  cu->language_defn = language_def (cu->language);
+
+  /* The symbol tables are set up in read_type_unit_scope.  */
+  process_die (cu->dies, cu);
+
+  /* For now fudge the Go package.  */
+  if (cu->language == language_go)
+    fixup_go_packaging (cu);
+
+  /* Now that we have processed all the DIEs in the CU, all the types 
+     should be complete, and it should now be safe to compute all of the
+     physnames.  */
+  compute_delayed_physnames (cu);
+  do_cleanups (delayed_list_cleanup);
+
+  /* TUs share symbol tables.
+     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 (per_cu->type_unit_group->primary_symtab == NULL)
+    {
+      symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
+      per_cu->type_unit_group->primary_symtab = symtab;
+
+      if (symtab != NULL)
+       {
+         /* Set symtab language to language from DW_AT_language.  If the
+            compilation is from a C file generated by language preprocessors,
+            do not set the language if it was already deduced by
+            start_subfile.  */
+         if (!(cu->language == language_c && symtab->language != language_c))
+           symtab->language = cu->language;
+       }
+    }
+  else
+    {
+      augment_type_symtab (objfile,
+                          per_cu->type_unit_group->primary_symtab);
+      symtab = per_cu->type_unit_group->primary_symtab;
+    }
+
+  if (dwarf2_per_objfile->using_index)
+    per_cu->v.quick->symtab = symtab;
+  else
+    {
+      struct partial_symtab *pst = per_cu->v.psymtab;
+      pst->symtab = symtab;
+      pst->readin = 1;
+    }
+
+  do_cleanups (back_to);
+}
+
+/* Process an imported unit DIE.  */
+
+static void
+process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
+{
+  struct attribute *attr;
+
+  /* For now we don't handle imported units in type units.  */
+  if (cu->per_cu->is_debug_types)
+    {
+      error (_("Dwarf Error: DW_TAG_imported_unit is not"
+              " supported in type units [in module %s]"),
+            cu->objfile->name);
+    }
+
+  attr = dwarf2_attr (die, DW_AT_import, cu);
+  if (attr != NULL)
+    {
+      struct dwarf2_per_cu_data *per_cu;
+      struct symtab *imported_symtab;
+      sect_offset offset;
+      int is_dwz;
+
+      offset = dwarf2_get_ref_die_offset (attr);
+      is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
+      per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
+
+      /* Queue the unit, if needed.  */
+      if (maybe_queue_comp_unit (cu, per_cu, cu->language))
+       load_full_comp_unit (per_cu, cu->language);
+
+      VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
+                    per_cu);
+    }
+}
+
+/* Process a die and its children.  */
+
+static void
+process_die (struct die_info *die, struct dwarf2_cu *cu)
+{
+  switch (die->tag)
+    {
+    case DW_TAG_padding:
+      break;
+    case DW_TAG_compile_unit:
+    case DW_TAG_partial_unit:
+      read_file_scope (die, cu);
+      break;
+    case DW_TAG_type_unit:
+      read_type_unit_scope (die, cu);
+      break;
+    case DW_TAG_subprogram:
+    case DW_TAG_inlined_subroutine:
+      read_func_scope (die, cu);
+      break;
+    case DW_TAG_lexical_block:
+    case DW_TAG_try_block:
+    case DW_TAG_catch_block:
+      read_lexical_block_scope (die, cu);
+      break;
+    case DW_TAG_GNU_call_site:
+      read_call_site_scope (die, cu);
+      break;
+    case DW_TAG_class_type:
+    case DW_TAG_interface_type:
+    case DW_TAG_structure_type:
+    case DW_TAG_union_type:
+      process_structure_scope (die, cu);
+      break;
+    case DW_TAG_enumeration_type:
+      process_enumeration_scope (die, cu);
+      break;
+
+    /* These dies have a type, but processing them does not create
+       a symbol or recurse to process the children.  Therefore we can
+       read them on-demand through read_type_die.  */
+    case DW_TAG_subroutine_type:
+    case DW_TAG_set_type:
+    case DW_TAG_array_type:
+    case DW_TAG_pointer_type:
+    case DW_TAG_ptr_to_member_type:
+    case DW_TAG_reference_type:
+    case DW_TAG_string_type:
+      break;
+
+    case DW_TAG_base_type:
+    case DW_TAG_subrange_type:
+    case DW_TAG_typedef:
+      /* Add a typedef symbol for the type definition, if it has a
+         DW_AT_name.  */
+      new_symbol (die, read_type_die (die, cu), cu);
+      break;
+    case DW_TAG_common_block:
+      read_common_block (die, cu);
+      break;
+    case DW_TAG_common_inclusion:
+      break;
+    case DW_TAG_namespace:
+      cu->processing_has_namespace_info = 1;
+      read_namespace (die, cu);
+      break;
+    case DW_TAG_module:
+      cu->processing_has_namespace_info = 1;
+      read_module (die, cu);
+      break;
+    case DW_TAG_imported_declaration:
+    case DW_TAG_imported_module:
+      cu->processing_has_namespace_info = 1;
+      if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
+                                || cu->language != language_fortran))
+       complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
+                  dwarf_tag_name (die->tag));
+      read_import_statement (die, cu);
+      break;
+
+    case DW_TAG_imported_unit:
+      process_imported_unit_die (die, cu);
+      break;
+
+    default:
+      new_symbol (die, NULL, cu);
+      break;
+    }
+}
+
+/* A helper function for dwarf2_compute_name which determines whether DIE
+   needs to have the name of the scope prepended to the name listed in the
+   die.  */
+
+static int
+die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
+{
+  struct attribute *attr;
+
+  switch (die->tag)
+    {
+    case DW_TAG_namespace:
+    case DW_TAG_typedef:
+    case DW_TAG_class_type:
+    case DW_TAG_interface_type:
+    case DW_TAG_structure_type:
+    case DW_TAG_union_type:
+    case DW_TAG_enumeration_type:
+    case DW_TAG_enumerator:
+    case DW_TAG_subprogram:
+    case DW_TAG_member:
+      return 1;
+
+    case DW_TAG_variable:
+    case DW_TAG_constant:
+      /* We only need to prefix "globally" visible variables.  These include
+        any variable marked with DW_AT_external or any variable that
+        lives in a namespace.  [Variables in anonymous namespaces
+        require prefixing, but they are not DW_AT_external.]  */
+
+      if (dwarf2_attr (die, DW_AT_specification, cu))
+       {
+         struct dwarf2_cu *spec_cu = cu;
+
+         return die_needs_namespace (die_specification (die, &spec_cu),
+                                     spec_cu);
+       }
+
+      attr = dwarf2_attr (die, DW_AT_external, cu);
+      if (attr == NULL && die->parent->tag != DW_TAG_namespace
+         && die->parent->tag != DW_TAG_module)
+       return 0;
+      /* A variable in a lexical block of some kind does not need a
+        namespace, even though in C++ such variables may be external
+        and have a mangled name.  */
+      if (die->parent->tag ==  DW_TAG_lexical_block
+         || die->parent->tag ==  DW_TAG_try_block
+         || die->parent->tag ==  DW_TAG_catch_block
+         || die->parent->tag == DW_TAG_subprogram)
+       return 0;
+      return 1;
+
+    default:
+      return 0;
+    }
+}
+
+/* Retrieve the last character from a mem_file.  */
+
+static void
+do_ui_file_peek_last (void *object, const char *buffer, long length)
+{
+  char *last_char_p = (char *) object;
+
+  if (length > 0)
+    *last_char_p = buffer[length - 1];
+}
+
+/* Compute the fully qualified name of DIE in CU.  If PHYSNAME is nonzero,
+   compute the physname for the object, which include a method's:
+   - formal parameters (C++/Java),
+   - receiver type (Go),
+   - return type (Java).
+
+   The term "physname" is a bit confusing.
+   For C++, for example, it is the demangled name.
+   For Go, for example, it's the mangled name.
+
+   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.  */
+
+static const char *
+dwarf2_compute_name (const char *name,
+                    struct die_info *die, struct dwarf2_cu *cu,
+                    int physname)
+{
+  struct objfile *objfile = cu->objfile;
+
+  if (name == NULL)
+    name = dwarf2_name (die, cu);
+
+  /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
+     compute it by typename_concat inside GDB.  */
+  if (cu->language == language_ada
+      || (cu->language == language_fortran && physname))
+    {
+      /* For Ada unit, we prefer the linkage name over the name, as
+        the former contains the exported name, which the user expects
+        to be able to reference.  Ideally, we want the user to be able
+        to reference this entity using either natural or linkage name,
+        but we haven't started looking at this enhancement yet.  */
+      struct attribute *attr;
+
+      attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
+      if (attr == NULL)
+       attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
+      if (attr && DW_STRING (attr))
+       return DW_STRING (attr);
+    }
+
+  /* These are the only languages we know how to qualify names in.  */
+  if (name != NULL
+      && (cu->language == language_cplus || cu->language == language_java
+         || cu->language == language_fortran))
+    {
+      if (die_needs_namespace (die, cu))
+       {
+         long length;
+         const char *prefix;
+         struct ui_file *buf;
+
+         prefix = determine_prefix (die, cu);
+         buf = mem_fileopen ();
+         if (*prefix != '\0')
+           {
+             char *prefixed_name = typename_concat (NULL, prefix, name,
+                                                    physname, cu);
+
+             fputs_unfiltered (prefixed_name, buf);
+             xfree (prefixed_name);
+           }
+         else
+           fputs_unfiltered (name, buf);
+
+         /* Template parameters may be specified in the DIE's DW_AT_name, or
+            as children with DW_TAG_template_type_param or
+            DW_TAG_value_type_param.  If the latter, add them to the name
+            here.  If the name already has template parameters, then
+            skip this step; some versions of GCC emit both, and
+            it is more efficient to use the pre-computed name.
+
+            Something to keep in mind about this process: it is very
+            unlikely, or in some cases downright impossible, to produce
+            something that will match the mangled name of a function.
+            If the definition of the function has the same debug info,
+            we should be able to match up with it anyway.  But fallbacks
+            using the minimal symbol, for instance to find a method
+            implemented in a stripped copy of libstdc++, will not work.
+            If we do not have debug info for the definition, we will have to
+            match them up some other way.
+
+            When we do name matching there is a related problem with function
+            templates; two instantiated function templates are allowed to
+            differ only by their return types, which we do not add here.  */
+
+         if (cu->language == language_cplus && strchr (name, '<') == NULL)
+           {
+             struct attribute *attr;
+             struct die_info *child;
+             int first = 1;
+
+             die->building_fullname = 1;
+
+             for (child = die->child; child != NULL; child = child->sibling)
+               {
+                 struct type *type;
+                 LONGEST value;
+                 gdb_byte *bytes;
+                 struct dwarf2_locexpr_baton *baton;
+                 struct value *v;
+
+                 if (child->tag != DW_TAG_template_type_param
+                     && child->tag != DW_TAG_template_value_param)
+                   continue;
+
+                 if (first)
+                   {
+                     fputs_unfiltered ("<", buf);
+                     first = 0;
+                   }
+                 else
+                   fputs_unfiltered (", ", buf);
+
+                 attr = dwarf2_attr (child, DW_AT_type, cu);
+                 if (attr == NULL)
+                   {
+                     complaint (&symfile_complaints,
+                                _("template parameter missing DW_AT_type"));
+                     fputs_unfiltered ("UNKNOWN_TYPE", buf);
+                     continue;
+                   }
+                 type = die_type (child, cu);
+
+                 if (child->tag == DW_TAG_template_type_param)
+                   {
+                     c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
+                     continue;
+                   }
+
+                 attr = dwarf2_attr (child, DW_AT_const_value, cu);
+                 if (attr == NULL)
+                   {
+                     complaint (&symfile_complaints,
+                                _("template parameter missing "
+                                  "DW_AT_const_value"));
+                     fputs_unfiltered ("UNKNOWN_VALUE", buf);
+                     continue;
+                   }
+
+                 dwarf2_const_value_attr (attr, type, name,
+                                          &cu->comp_unit_obstack, cu,
+                                          &value, &bytes, &baton);
+
+                 if (TYPE_NOSIGN (type))
+                   /* GDB prints characters as NUMBER 'CHAR'.  If that's
+                      changed, this can use value_print instead.  */
+                   c_printchar (value, type, buf);
+                 else
+                   {
+                     struct value_print_options opts;
+
+                     if (baton != NULL)
+                       v = dwarf2_evaluate_loc_desc (type, NULL,
+                                                     baton->data,
+                                                     baton->size,
+                                                     baton->per_cu);
+                     else if (bytes != NULL)
+                       {
+                         v = allocate_value (type);
+                         memcpy (value_contents_writeable (v), bytes,
+                                 TYPE_LENGTH (type));
+                       }
+                     else
+                       v = value_from_longest (type, value);
+
+                     /* Specify decimal so that we do not depend on
+                        the radix.  */
+                     get_formatted_print_options (&opts, 'd');
+                     opts.raw = 1;
+                     value_print (v, buf, &opts);
+                     release_value (v);
+                     value_free (v);
+                   }
+               }
 
-       default:
-         error (_("Dwarf Error: Cannot handle %s "
-                  "in DWARF reader [in module %s]"),
-                dwarf_form_name (form),
-                bfd_get_filename (abfd));
+             die->building_fullname = 0;
+
+             if (!first)
+               {
+                 /* Close the argument list, with a space if necessary
+                    (nested templates).  */
+                 char last_char = '\0';
+                 ui_file_put (buf, do_ui_file_peek_last, &last_char);
+                 if (last_char == '>')
+                   fputs_unfiltered (" >", buf);
+                 else
+                   fputs_unfiltered (">", buf);
+               }
+           }
+
+         /* For Java and C++ methods, append formal parameter type
+            information, if PHYSNAME.  */
+
+         if (physname && die->tag == DW_TAG_subprogram
+             && (cu->language == language_cplus
+                 || cu->language == language_java))
+           {
+             struct type *type = read_type_die (die, cu);
+
+             c_type_print_args (type, buf, 1, cu->language,
+                                &type_print_raw_options);
+
+             if (cu->language == language_java)
+               {
+                 /* For java, we must append the return type to method
+                    names.  */
+                 if (die->tag == DW_TAG_subprogram)
+                   java_print_type (TYPE_TARGET_TYPE (type), "", buf,
+                                    0, 0, &type_print_raw_options);
+               }
+             else if (cu->language == language_cplus)
+               {
+                 /* Assume that an artificial first parameter is
+                    "this", but do not crash if it is not.  RealView
+                    marks unnamed (and thus unused) parameters as
+                    artificial; there is no way to differentiate
+                    the two cases.  */
+                 if (TYPE_NFIELDS (type) > 0
+                     && TYPE_FIELD_ARTIFICIAL (type, 0)
+                     && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
+                     && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
+                                                                       0))))
+                   fputs_unfiltered (" const", buf);
+               }
+           }
+
+         name = ui_file_obsavestring (buf, &objfile->objfile_obstack,
+                                      &length);
+         ui_file_delete (buf);
+
+         if (cu->language == language_cplus)
+           {
+             const char *cname
+               = dwarf2_canonicalize_name (name, cu,
+                                           &objfile->objfile_obstack);
+
+             if (cname != NULL)
+               name = cname;
+           }
        }
     }
 
-  if (abbrev->has_children)
-    return skip_children (buffer, info_ptr, cu);
-  else
-    return info_ptr;
+  return name;
 }
 
-/* Locate ORIG_PDI's sibling.
-   INFO_PTR should point to the start of the next DIE after ORIG_PDI
-   in BUFFER.  */
+/* Return the fully qualified name of DIE, based on its DW_AT_name.
+   If scope qualifiers are appropriate they will be added.  The result
+   will be allocated on the objfile_obstack, or NULL if the DIE does
+   not have a name.  NAME may either be from a previous call to
+   dwarf2_name or NULL.
 
-static gdb_byte *
-locate_pdi_sibling (struct partial_die_info *orig_pdi,
-                   gdb_byte *buffer, gdb_byte *info_ptr,
-                   bfd *abfd, struct dwarf2_cu *cu)
+   The output string will be canonicalized (if C++/Java).  */
+
+static const char *
+dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
 {
-  /* Do we know the sibling already?  */
+  return dwarf2_compute_name (name, die, cu, 0);
+}
 
-  if (orig_pdi->sibling)
-    return orig_pdi->sibling;
+/* Construct a physname for the given DIE in CU.  NAME may either be
+   from a previous call to dwarf2_name or NULL.  The result will be
+   allocated on the objfile_objstack or NULL if the DIE does not have a
+   name.
 
-  /* Are there any children to deal with?  */
+   The output string will be canonicalized (if C++/Java).  */
 
-  if (!orig_pdi->has_children)
-    return info_ptr;
+static const char *
+dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
+{
+  struct objfile *objfile = cu->objfile;
+  struct attribute *attr;
+  const char *retval, *mangled = NULL, *canon = NULL;
+  struct cleanup *back_to;
+  int need_copy = 1;
 
-  /* Skip the children the long way.  */
+  /* In this case dwarf2_compute_name is just a shortcut not building anything
+     on its own.  */
+  if (!die_needs_namespace (die, cu))
+    return dwarf2_compute_name (name, die, cu, 1);
 
-  return skip_children (buffer, info_ptr, cu);
-}
+  back_to = make_cleanup (null_cleanup, NULL);
 
-/* Expand this partial symbol table into a full symbol table.  */
+  attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
+  if (!attr)
+    attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
 
-static void
-dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
-{
-  if (pst != NULL)
+  /* DW_AT_linkage_name is missing in some cases - depend on what GDB
+     has computed.  */
+  if (attr && DW_STRING (attr))
+    {
+      char *demangled;
+
+      mangled = DW_STRING (attr);
+
+      /* Use DMGL_RET_DROP for C++ template functions to suppress their return
+        type.  It is easier for GDB users to search for such functions as
+        `name(params)' than `long name(params)'.  In such case the minimal
+        symbol names do not match the full symbol names but for template
+        functions there is never a need to look up their definition from their
+        declaration so the only disadvantage remains the minimal symbol
+        variant `long name(params)' does not have the proper inferior type.
+        */
+
+      if (cu->language == language_go)
+       {
+         /* This is a lie, but we already lie to the caller new_symbol_full.
+            new_symbol_full assumes we return the mangled name.
+            This just undoes that lie until things are cleaned up.  */
+         demangled = NULL;
+       }
+      else
+       {
+         demangled = cplus_demangle (mangled,
+                                     (DMGL_PARAMS | DMGL_ANSI
+                                      | (cu->language == language_java
+                                         ? DMGL_JAVA | DMGL_RET_POSTFIX
+                                         : DMGL_RET_DROP)));
+       }
+      if (demangled)
+       {
+         make_cleanup (xfree, demangled);
+         canon = demangled;
+       }
+      else
+       {
+         canon = mangled;
+         need_copy = 0;
+       }
+    }
+
+  if (canon == NULL || check_physname)
     {
-      if (pst->readin)
+      const char *physname = dwarf2_compute_name (name, die, cu, 1);
+
+      if (canon != NULL && strcmp (physname, canon) != 0)
        {
-         warning (_("bug: psymtab for %s is already read in."),
-                  pst->filename);
+         /* It may not mean a bug in GDB.  The compiler could also
+            compute DW_AT_linkage_name incorrectly.  But in such case
+            GDB would need to be bug-to-bug compatible.  */
+
+         complaint (&symfile_complaints,
+                    _("Computed physname <%s> does not match demangled <%s> "
+                      "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
+                    physname, canon, mangled, die->offset.sect_off, objfile->name);
+
+         /* Prefer DW_AT_linkage_name (in the CANON form) - when it
+            is available here - over computed PHYSNAME.  It is safer
+            against both buggy GDB and buggy compilers.  */
+
+         retval = canon;
        }
       else
        {
-         if (info_verbose)
-           {
-             printf_filtered (_("Reading in symbols for %s..."),
-                              pst->filename);
-             gdb_flush (gdb_stdout);
-           }
+         retval = physname;
+         need_copy = 0;
+       }
+    }
+  else
+    retval = canon;
+
+  if (need_copy)
+    retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval));
+
+  do_cleanups (back_to);
+  return retval;
+}
+
+/* Read the import statement specified by the given die and record it.  */
+
+static void
+read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
+{
+  struct objfile *objfile = cu->objfile;
+  struct attribute *import_attr;
+  struct die_info *imported_die, *child_die;
+  struct dwarf2_cu *imported_cu;
+  const char *imported_name;
+  const char *imported_name_prefix;
+  const char *canonical_name;
+  const char *import_alias;
+  const char *imported_declaration = NULL;
+  const char *import_prefix;
+  VEC (const_char_ptr) *excludes = NULL;
+  struct cleanup *cleanups;
+
+  import_attr = dwarf2_attr (die, DW_AT_import, cu);
+  if (import_attr == NULL)
+    {
+      complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
+                dwarf_tag_name (die->tag));
+      return;
+    }
+
+  imported_cu = cu;
+  imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
+  imported_name = dwarf2_name (imported_die, imported_cu);
+  if (imported_name == NULL)
+    {
+      /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
+
+        The import in the following code:
+        namespace A
+          {
+            typedef int B;
+          }
+
+        int main ()
+          {
+            using A::B;
+            B b;
+            return b;
+          }
+
+        ...
+         <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
+            <52>   DW_AT_decl_file   : 1
+            <53>   DW_AT_decl_line   : 6
+            <54>   DW_AT_import      : <0x75>
+         <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
+            <59>   DW_AT_name        : B
+            <5b>   DW_AT_decl_file   : 1
+            <5c>   DW_AT_decl_line   : 2
+            <5d>   DW_AT_type        : <0x6e>
+        ...
+         <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
+            <76>   DW_AT_byte_size   : 4
+            <77>   DW_AT_encoding    : 5        (signed)
+
+        imports the wrong die ( 0x75 instead of 0x58 ).
+        This case will be ignored until the gcc bug is fixed.  */
+      return;
+    }
+
+  /* Figure out the local name after import.  */
+  import_alias = dwarf2_name (die, cu);
 
-         /* Restore our global data.  */
-         dwarf2_per_objfile = objfile_data (pst->objfile,
-                                            dwarf2_objfile_data_key);
+  /* Figure out where the statement is being imported to.  */
+  import_prefix = determine_prefix (die, cu);
+
+  /* Figure out what the scope of the imported die is and prepend it
+     to the name of the imported die.  */
+  imported_name_prefix = determine_prefix (imported_die, imported_cu);
 
-         /* 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
-            associated with the (presumably stripped) associated objfile.  */
-         if (pst->objfile->separate_debug_objfile_backlink)
-           {
-             struct dwarf2_per_objfile *dpo_backlink
-               = objfile_data (pst->objfile->separate_debug_objfile_backlink,
-                               dwarf2_objfile_data_key);
+  if (imported_die->tag != DW_TAG_namespace
+      && imported_die->tag != DW_TAG_module)
+    {
+      imported_declaration = imported_name;
+      canonical_name = imported_name_prefix;
+    }
+  else if (strlen (imported_name_prefix) > 0)
+    canonical_name = obconcat (&objfile->objfile_obstack,
+                              imported_name_prefix, "::", imported_name,
+                              (char *) NULL);
+  else
+    canonical_name = imported_name;
 
-             dwarf2_per_objfile->has_section_at_zero
-               = dpo_backlink->has_section_at_zero;
-           }
+  cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
 
-         dwarf2_per_objfile->reading_partial_symbols = 0;
+  if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
+    for (child_die = die->child; child_die && child_die->tag;
+        child_die = sibling_die (child_die))
+      {
+       /* DWARF-4: A Fortran use statement with a “rename list” may be
+          represented by an imported module entry with an import attribute
+          referring to the module and owned entries corresponding to those
+          entities that are renamed as part of being imported.  */
 
-         psymtab_to_symtab_1 (pst);
+       if (child_die->tag != DW_TAG_imported_declaration)
+         {
+           complaint (&symfile_complaints,
+                      _("child DW_TAG_imported_declaration expected "
+                        "- DIE at 0x%x [in module %s]"),
+                      child_die->offset.sect_off, objfile->name);
+           continue;
+         }
 
-         /* Finish up the debug error message.  */
-         if (info_verbose)
-           printf_filtered (_("done.\n"));
-       }
-    }
-}
+       import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
+       if (import_attr == NULL)
+         {
+           complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
+                      dwarf_tag_name (child_die->tag));
+           continue;
+         }
 
-/* Add PER_CU to the queue.  */
+       imported_cu = cu;
+       imported_die = follow_die_ref_or_sig (child_die, import_attr,
+                                             &imported_cu);
+       imported_name = dwarf2_name (imported_die, imported_cu);
+       if (imported_name == NULL)
+         {
+           complaint (&symfile_complaints,
+                      _("child DW_TAG_imported_declaration has unknown "
+                        "imported name - DIE at 0x%x [in module %s]"),
+                      child_die->offset.sect_off, objfile->name);
+           continue;
+         }
 
-static void
-queue_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
-{
-  struct dwarf2_queue_item *item;
+       VEC_safe_push (const_char_ptr, excludes, imported_name);
 
-  per_cu->queued = 1;
-  item = xmalloc (sizeof (*item));
-  item->per_cu = per_cu;
-  item->next = NULL;
+       process_die (child_die, cu);
+      }
 
-  if (dwarf2_queue == NULL)
-    dwarf2_queue = item;
-  else
-    dwarf2_queue_tail->next = item;
+  cp_add_using_directive (import_prefix,
+                          canonical_name,
+                          import_alias,
+                          imported_declaration,
+                         excludes,
+                         0,
+                          &objfile->objfile_obstack);
 
-  dwarf2_queue_tail = item;
+  do_cleanups (cleanups);
 }
 
-/* Process the queue.  */
+/* Cleanup function for handle_DW_AT_stmt_list.  */
 
 static void
-process_queue (struct objfile *objfile)
+free_cu_line_header (void *arg)
 {
-  struct dwarf2_queue_item *item, *next_item;
-
-  /* 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.  */
-  for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
-    {
-      if (dwarf2_per_objfile->using_index
-         ? !item->per_cu->v.quick->symtab
-         : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
-       process_full_comp_unit (item->per_cu);
-
-      item->per_cu->queued = 0;
-      next_item = item->next;
-      xfree (item);
-    }
+  struct dwarf2_cu *cu = arg;
 
-  dwarf2_queue_tail = NULL;
+  free_line_header (cu->line_header);
+  cu->line_header = NULL;
 }
 
-/* Free all allocated queue entries.  This function only releases anything if
-   an error was thrown; if the queue was processed then it would have been
-   freed as we went along.  */
+/* Check for possibly missing DW_AT_comp_dir with relative .debug_line
+   directory paths.  GCC SVN r127613 (new option -fdebug-prefix-map) fixed
+   this, it was first present in GCC release 4.3.0.  */
 
-static void
-dwarf2_release_queue (void *dummy)
+static int
+producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
 {
-  struct dwarf2_queue_item *item, *last;
-
-  item = dwarf2_queue;
-  while (item)
-    {
-      /* Anything still marked queued is likely to be in an
-        inconsistent state, so discard it.  */
-      if (item->per_cu->queued)
-       {
-         if (item->per_cu->cu != NULL)
-           free_one_cached_comp_unit (item->per_cu->cu);
-         item->per_cu->queued = 0;
-       }
-
-      last = item;
-      item = item->next;
-      xfree (last);
-    }
+  if (!cu->checked_producer)
+    check_producer (cu);
 
-  dwarf2_queue = dwarf2_queue_tail = NULL;
+  return cu->producer_is_gcc_lt_4_3;
 }
 
-/* Read in full symbols for PST, and anything it depends on.  */
-
 static void
-psymtab_to_symtab_1 (struct partial_symtab *pst)
+find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
+                        const char **name, const char **comp_dir)
 {
-  struct dwarf2_per_cu_data *per_cu;
-  struct cleanup *back_to;
-  int i;
+  struct attribute *attr;
 
-  for (i = 0; i < pst->number_of_dependencies; i++)
-    if (!pst->dependencies[i]->readin)
-      {
-        /* Inform about additional files that need to be read in.  */
-        if (info_verbose)
-          {
-           /* FIXME: i18n: Need to make this a single string.  */
-            fputs_filtered (" ", gdb_stdout);
-            wrap_here ("");
-            fputs_filtered ("and ", gdb_stdout);
-            wrap_here ("");
-            printf_filtered ("%s...", pst->dependencies[i]->filename);
-            wrap_here ("");     /* Flush output.  */
-            gdb_flush (gdb_stdout);
-          }
-        psymtab_to_symtab_1 (pst->dependencies[i]);
-      }
+  *name = NULL;
+  *comp_dir = NULL;
 
-  per_cu = pst->read_symtab_private;
+  /* Find the filename.  Do not use dwarf2_name here, since the filename
+     is not a source language identifier.  */
+  attr = dwarf2_attr (die, DW_AT_name, cu);
+  if (attr)
+    {
+      *name = DW_STRING (attr);
+    }
 
-  if (per_cu == NULL)
+  attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
+  if (attr)
+    *comp_dir = DW_STRING (attr);
+  else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
+          && IS_ABSOLUTE_PATH (*name))
     {
-      /* It's an include file, no symbols to read for it.
-         Everything is in the parent symtab.  */
-      pst->readin = 1;
-      return;
+      char *d = ldirname (*name);
+
+      *comp_dir = d;
+      if (d != NULL)
+       make_cleanup (xfree, d);
+    }
+  if (*comp_dir != NULL)
+    {
+      /* Irix 6.2 native cc prepends <machine>.: to the compilation
+        directory, get rid of it.  */
+      char *cp = strchr (*comp_dir, ':');
+
+      if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
+       *comp_dir = cp + 1;
     }
 
-  dw2_do_instantiate_symtab (pst->objfile, per_cu);
+  if (*name == NULL)
+    *name = "<unknown>";
 }
 
-/* Load the DIEs associated with PER_CU into memory.  */
+/* Handle DW_AT_stmt_list for a compilation unit.
+   DIE is the DW_TAG_compile_unit die for CU.
+   COMP_DIR is the compilation directory.
+   WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed.  */
 
 static void
-load_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
-                    struct objfile *objfile)
+handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
+                       const char *comp_dir)
 {
-  bfd *abfd = objfile->obfd;
-  struct dwarf2_cu *cu;
-  unsigned int offset;
-  gdb_byte *info_ptr, *beg_of_comp_unit;
-  struct cleanup *free_abbrevs_cleanup = NULL, *free_cu_cleanup = NULL;
   struct attribute *attr;
-  int read_cu = 0;
 
-  gdb_assert (! per_cu->debug_types_section);
+  gdb_assert (! cu->per_cu->is_debug_types);
 
-  /* Set local variables from the partial symbol table info.  */
-  offset = per_cu->offset;
-
-  dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
-  info_ptr = dwarf2_per_objfile->info.buffer + offset;
-  beg_of_comp_unit = info_ptr;
-
-  if (per_cu->cu == NULL)
+  attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
+  if (attr)
     {
-      cu = xmalloc (sizeof (*cu));
-      init_one_comp_unit (cu, objfile);
-
-      read_cu = 1;
-
-      /* If an error occurs while loading, release our storage.  */
-      free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
-
-      /* Read in the comp_unit header.  */
-      info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
+      unsigned int line_offset = DW_UNSND (attr);
+      struct line_header *line_header
+       = dwarf_decode_line_header (line_offset, cu);
 
-      /* Skip dummy compilation units.  */
-      if (info_ptr >= (dwarf2_per_objfile->info.buffer
-                      + dwarf2_per_objfile->info.size)
-         || peek_abbrev_code (abfd, info_ptr) == 0)
+      if (line_header)
        {
-         do_cleanups (free_cu_cleanup);
-         return;
+         cu->line_header = line_header;
+         make_cleanup (free_cu_line_header, cu);
+         dwarf_decode_lines (line_header, comp_dir, cu, NULL, 1);
        }
+    }
+}
 
-      /* Complete the cu_header.  */
-      cu->header.offset = offset;
-      cu->header.first_die_offset = info_ptr - beg_of_comp_unit;
-
-      /* Read the abbrevs for this compilation unit.  */
-      dwarf2_read_abbrevs (abfd, cu);
-      free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
+/* Process DW_TAG_compile_unit or DW_TAG_partial_unit.  */
 
-      /* Link this compilation unit into the compilation unit tree.  */
-      per_cu->cu = cu;
-      cu->per_cu = per_cu;
+static void
+read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
+{
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct cleanup *back_to = make_cleanup (null_cleanup, 0);
+  CORE_ADDR lowpc = ((CORE_ADDR) -1);
+  CORE_ADDR highpc = ((CORE_ADDR) 0);
+  struct attribute *attr;
+  const char *name = NULL;
+  const char *comp_dir = NULL;
+  struct die_info *child_die;
+  bfd *abfd = objfile->obfd;
+  CORE_ADDR baseaddr;
 
-      /* Link this CU into read_in_chain.  */
-      per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
-      dwarf2_per_objfile->read_in_chain = per_cu;
-    }
-  else
-    {
-      cu = per_cu->cu;
-      info_ptr += cu->header.first_die_offset;
-    }
+  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 
-  cu->dies = read_comp_unit (info_ptr, cu);
+  get_scope_pc_bounds (die, &lowpc, &highpc, cu);
 
-  /* We try not to read any attributes in this function, because not
-     all objfiles needed for references have been loaded yet, and symbol
-     table processing isn't initialized.  But we have to set the CU language,
-     or we won't be able to build types correctly.  */
-  prepare_one_comp_unit (cu, cu->dies);
+  /* If we didn't find a lowpc, set it to highpc to avoid complaints
+     from finish_block.  */
+  if (lowpc == ((CORE_ADDR) -1))
+    lowpc = highpc;
+  lowpc += baseaddr;
+  highpc += baseaddr;
 
-  /* Similarly, if we do not read the producer, we can not apply
-     producer-specific interpretation.  */
-  attr = dwarf2_attr (cu->dies, DW_AT_producer, cu);
-  if (attr)
-    cu->producer = DW_STRING (attr);
+  find_file_and_directory (die, cu, &name, &comp_dir);
 
-  if (read_cu)
-    {
-      do_cleanups (free_abbrevs_cleanup);
+  prepare_one_comp_unit (cu, die, cu->language);
 
-      /* We've successfully allocated this compilation unit.  Let our
-        caller clean it up when finished with it.  */
-      discard_cleanups (free_cu_cleanup);
-    }
-}
+  /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
+     standardised yet.  As a workaround for the language detection we fall
+     back to the DW_AT_producer string.  */
+  if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
+    cu->language = language_opencl;
 
-/* Add a DIE to the delayed physname list.  */
+  /* Similar hack for Go.  */
+  if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
+    set_cu_language (DW_LANG_Go, cu);
 
-static void
-add_to_method_list (struct type *type, int fnfield_index, int index,
-                   const char *name, struct die_info *die,
-                   struct dwarf2_cu *cu)
-{
-  struct delayed_method_info mi;
-  mi.type = type;
-  mi.fnfield_index = fnfield_index;
-  mi.index = index;
-  mi.name = name;
-  mi.die = die;
-  VEC_safe_push (delayed_method_info, cu->method_list, &mi);
-}
+  dwarf2_start_symtab (cu, name, comp_dir, lowpc);
 
-/* A cleanup for freeing the delayed method list.  */
+  /* Decode line number information if present.  We do this before
+     processing child DIEs, so that the line header table is available
+     for DW_AT_decl_file.  */
+  handle_DW_AT_stmt_list (die, cu, comp_dir);
 
-static void
-free_delayed_list (void *ptr)
-{
-  struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
-  if (cu->method_list != NULL)
+  /* Process all dies in compilation unit.  */
+  if (die->child != NULL)
     {
-      VEC_free (delayed_method_info, cu->method_list);
-      cu->method_list = NULL;
+      child_die = die->child;
+      while (child_die && child_die->tag)
+       {
+         process_die (child_die, cu);
+         child_die = sibling_die (child_die);
+       }
     }
-}
-
-/* Compute the physnames of any methods on the CU's method list.
 
-   The computation of method physnames is delayed in order to avoid the
-   (bad) condition that one of the method's formal parameters is of an as yet
-   incomplete type.  */
+  /* Decode macro information, if present.  Dwarf 2 macro information
+     refers to information in the line number info statement program
+     header, so we can only read it if we've read the header
+     successfully.  */
+  attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
+  if (attr && cu->line_header)
+    {
+      if (dwarf2_attr (die, DW_AT_macro_info, cu))
+       complaint (&symfile_complaints,
+                  _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
 
-static void
-compute_delayed_physnames (struct dwarf2_cu *cu)
-{
-  int i;
-  struct delayed_method_info *mi;
-  for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
+      dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
+    }
+  else
     {
-      const char *physname;
-      struct fn_fieldlist *fn_flp
-       = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
-      physname = dwarf2_physname ((char *) mi->name, mi->die, cu);
-      fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
+      attr = dwarf2_attr (die, DW_AT_macro_info, cu);
+      if (attr && cu->line_header)
+       {
+         unsigned int macro_offset = DW_UNSND (attr);
+
+         dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
+       }
     }
+
+  do_cleanups (back_to);
 }
 
-/* Generate full symbol information for PST and CU, whose DIEs have
-   already been loaded into memory.  */
+/* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
+   Create the set of symtabs used by this TU, or if this TU is sharing
+   symtabs with another TU and the symtabs have already been created
+   then restore those symtabs in the line header.
+   We don't need the pc/line-number mapping for type units.  */
 
 static void
-process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
+setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
 {
-  struct dwarf2_cu *cu = per_cu->cu;
-  struct objfile *objfile = per_cu->objfile;
-  CORE_ADDR lowpc, highpc;
-  struct symtab *symtab;
-  struct cleanup *back_to, *delayed_list_cleanup;
-  CORE_ADDR baseaddr;
-
-  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+  struct objfile *objfile = dwarf2_per_objfile->objfile;
+  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
+  struct type_unit_group *tu_group;
+  int first_time;
+  struct line_header *lh;
+  struct attribute *attr;
+  unsigned int i, line_offset;
 
-  buildsym_init ();
-  back_to = make_cleanup (really_free_pendings, NULL);
-  delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
+  gdb_assert (per_cu->is_debug_types);
 
-  cu->list_in_scope = &file_symbols;
+  attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
 
-  /* Do line number decoding in read_file_scope () */
-  process_die (cu->dies, cu);
+  /* If we're using .gdb_index (includes -readnow) then
+     per_cu->s.type_unit_group may not have been set up yet.  */
+  if (per_cu->type_unit_group == NULL)
+    per_cu->type_unit_group = get_type_unit_group (cu, attr);
+  tu_group = per_cu->type_unit_group;
 
-  /* Now that we have processed all the DIEs in the CU, all the types 
-     should be complete, and it should now be safe to compute all of the
-     physnames.  */
-  compute_delayed_physnames (cu);
-  do_cleanups (delayed_list_cleanup);
+  /* If we've already processed this stmt_list there's no real need to
+     do it again, we could fake it and just recreate the part we need