Merge GDB 7.5.1

gdb/dwarf2read.c

 /* DWARF 2 debugging format support for GDB.
 
    Copyright (C) 1994-2012 Free Software Foundation, Inc.
 
    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
    Inc.  with support from Florida State University (under contract
    with the Ada Joint Program Office), and Silicon Graphics, Inc.
    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
    support.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    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 "symtab.h"
 #include "gdbtypes.h"
 #include "objfiles.h"
 #include "dwarf2.h"
 #include "buildsym.h"
 #include "demangle.h"
 #include "gdb-demangle.h"
 #include "expression.h"
@@ skipping 11 matching lines @@
 #include "block.h"
 #include "addrmap.h"
 #include "typeprint.h"
 #include "jv-lang.h"
 #include "psympriv.h"
 #include "exceptions.h"
 #include "gdb_stat.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 <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;
 
 /* When non-zero, cross-check physname against demangler.  */
 static int check_physname = 0;
 
+/* When non-zero, do not reject deprecated .gdb_index sections.  */
+static int use_deprecated_index_sections = 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;
 
 static const struct objfile_data *dwarf2_objfile_data_key;
 
@@ skipping 12 matching lines @@
 
 typedef struct dwarf2_section_info dwarf2_section_info_def;
 DEF_VEC_O (dwarf2_section_info_def);
 
 /* All offsets in the index are of this type.  It must be
    architecture-independent.  */
 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
 {
   /* Index data format version.  */
   int version;
 
   /* The total length of the buffer.  */
   off_t total_size;
 
   /* A pointer to the address table data.  */
   const gdb_byte *address_table;
 
   /* Size of the address table data in bytes.  */
   offset_type address_table_size;
 
   /* The symbol table, implemented as a hash table.  */
   const offset_type *symbol_table;
 
   /* Size in slots, each slot is 2 offset_types.  */
   offset_type symbol_table_slots;
 
   /* A pointer to the constant pool.  */
   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;
   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 ranges;
+  struct dwarf2_section_info addr;
   struct dwarf2_section_info frame;
   struct dwarf2_section_info eh_frame;
   struct dwarf2_section_info gdb_index;
 
   VEC (dwarf2_section_info_def) *types;
 
   /* 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;
 
   /* The number of compilation units in ALL_COMP_UNITS.  */
   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;
+
+  /* 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 .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;
+  /* 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;
 
   /* A flag indicating wether this objfile has a section loaded at a
      VMA of 0.  */
   int has_section_at_zero;
 
   /* True if we are using the mapped index,
      or we are faking it for OBJF_READNOW's sake.  */
   unsigned char using_index;
 
   /* The mapped index, or NULL if .gdb_index is missing or not being used.  */
   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.  */
   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;
 
 /* Default names of the debugging sections.  */
 
 /* 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" },
   { ".debug_loc", ".zdebug_loc" },
   { ".debug_macinfo", ".zdebug_macinfo" },
   { ".debug_macro", ".zdebug_macro" },
   { ".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
 };
 
+/* List of DWO sections.  */
+
+static const struct dwo_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;
+}
+dwo_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" },
+};
+
 /* local data types */
 
-/* We hold several abbreviation tables in memory at the same time.  */
-#ifndef ABBREV_HASH_SIZE
-#define ABBREV_HASH_SIZE 121
-#endif
-
 /* The data in a compilation unit header, after target2host
    translation, looks like this.  */
 struct comp_unit_head
 {
   unsigned int length;
   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;
 
   /* Size of the length field; either 4 or 12.  */
   unsigned int initial_length_size;
 
   /* 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.
    See comments for compute_delayed_physnames.  */
 struct delayed_method_info
 {
   /* The type to which the method is attached, i.e., its parent class.  */
   struct type *type;
 
   /* The index of the method in the type's function fieldlists.  */
@@ skipping 20 matching lines @@
 
   /* The header of the compilation unit.  */
   struct comp_unit_head header;
 
   /* Base address of this compilation unit.  */
   CORE_ADDR base_address;
 
   /* 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;
 
   const char *producer;
 
   /* The generic symbol table building routines have separate lists for
      file scope symbols and all all other scopes (local scopes).  So
      we need to select the right one to pass to add_symbol_to_list().
      We do it by keeping a pointer to the correct list in list_in_scope.
 
      FIXME: The original dwarf code just treated the file scope as the
      first local scope, and all other local scopes as nested local
      scopes, and worked fine.  Check to see if we really need to
      distinguish these in buildsym.c.  */
   struct pending **list_in_scope;
 
-  /* DWARF abbreviation table associated with this compilation unit.  */
-  struct abbrev_info **dwarf2_abbrevs;
+  /* 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;
 
-  /* Storage for the abbrev table.  */
-  struct obstack abbrev_obstack;
-
-  /* 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
      unit, including partial DIEs.  */
   struct obstack comp_unit_obstack;
 
   /* When multiple dwarf2_cu structures are living in memory, this field
      chains them all together, so that they can be released efficiently.
      We will probably also want a generation counter so that most-recently-used
      compilation units are cached...  */
   struct dwarf2_per_cu_data *read_in_chain;
 
   /* Backchain to our per_cu entry if the tree has been built.  */
   struct dwarf2_per_cu_data *per_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.  */
   struct die_info *dies;
 
   /* A set of pointers to dwarf2_per_cu_data objects for compilation
      units referenced by this one.  Only set during full symbol processing;
      partial symbol tables do not have dependencies.  */
   htab_t dependencies;
 
   /* Header data from the line table, during full symbol processing.  */
   struct line_header *line_header;
 
   /* A list of methods which need to have physnames computed
      after all type information has been read.  */
   VEC (delayed_method_info) *method_list;
 
   /* 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.  */
+  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;
 
-  unsigned int has_loclist : 1;
+  /* These cache the results for producer_is_gxx_lt_4_6 and producer_is_icc.
+     CHECKED_PRODUCER is set if both PRODUCER_IS_GXX_LT_4_6 and PRODUCER_IS_ICC
+     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_icc : 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.
      NOTE: Unlike comp_unit_head.length, this length includes
-     initial_length_size.  */
-  unsigned int offset;
+     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 : 29;
 
   /* 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;
+
+  /* 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.
      Otherwise the 'quick' field is active.  */
   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;
+
+  union
+  {
+    /* 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.  */
+    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;
+  } s;
 };
 
 /* 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;
-
-  /* The CU(/TU) of this type.  */
+  /* 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.  */
+
+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 info;
+  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;
+  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.  */
+
+struct dwo_file
+{
+  /* The DW_AT_GNU_dwo_name attribute.
+     We don't manage space for this, it's an attribute.  */
+  const char *dwo_name;
+
+  /* The bfd, when the file is open.  Otherwise this is NULL.  */
+  bfd *dwo_bfd;
+
+  /* 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;
 };
 
 /* 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.  */
+  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.  */
 struct line_header
 {
   unsigned int total_length;
   unsigned short version;
   unsigned int header_length;
   unsigned char minimum_instruction_length;
@@ skipping 33 matching lines @@
   /* The start and end of the statement program following this
      header.  These point into dwarf2_per_objfile->line_buffer.  */
   gdb_byte *statement_program_start, *statement_program_end;
 };
 
 /* When we construct a partial symbol table entry we only
    need this much information.  */
 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;
 
     /* Assorted flags describing the data found in this DIE.  */
     unsigned int has_children : 1;
     unsigned int is_external : 1;
     unsigned int is_declaration : 1;
     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.  */
     unsigned int scope_set : 1;
 
     /* Flag set if the DIE has a byte_size attribute.  */
     unsigned int has_byte_size : 1;
 
     /* Flag set if any of the DIE's children are template arguments.  */
     unsigned int has_template_arguments : 1;
 
     /* Flag set if fixup_partial_die has been called on this die.  */
     unsigned int fixup_called : 1;
 
     /* The name of this DIE.  Normally the value of DW_AT_name, but
        sometimes a default name for unnamed DIEs.  */
     char *name;
 
     /* The linkage name, if present.  */
     const char *linkage_name;
 
     /* 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;
 
-    /* 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;
     CORE_ADDR highpc;
 
     /* Pointer into the info_buffer (or types_buffer) pointing at the target of
        DW_AT_sibling, if any.  */
     /* NOTE: This member isn't strictly necessary, read_partial_die could
        return DW_AT_sibling values to its caller load_partial_dies.  */
     gdb_byte *sibling;
 
     /* 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.  */
     struct partial_die_info *die_parent, *die_child, *die_sibling;
   };
 
 /* This data structure holds the information of an abbrev.  */
 struct abbrev_info
   {
     unsigned int number;        /* number identifying abbrev */
     enum dwarf_tag tag;         /* dwarf tag */
     unsigned short has_children;                /* boolean */
     unsigned short num_attrs;   /* number of attributes */
     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
     struct abbrev_info *next;   /* next in chain */
   };
 
 struct attr_abbrev
   {
     ENUM_BITFIELD(dwarf_attribute) name : 16;
     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
   {
     ENUM_BITFIELD(dwarf_attribute) name : 16;
     ENUM_BITFIELD(dwarf_form) form : 15;
 
     /* Has DW_STRING already been updated by dwarf2_canonicalize_name?  This
        field should be in u.str (existing only for DW_STRING) but it is kept
        here for better struct attribute alignment.  */
     unsigned int string_is_canonical : 1;
@@ skipping 20 matching lines @@
     unsigned char num_attrs;
 
     /* True if we're presently building the full type name for the
        type derived from this DIE.  */
     unsigned char building_fullname : 1;
 
     /* Abbrev number */
     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
        this node; and all the children of a given node are chained
        together via their SIBLING fields.  */
     struct die_info *child;     /* Its first child, if any.  */
     struct die_info *sibling;   /* Its next sibling, if any.  */
     struct die_info *parent;    /* Its parent, if any.  */
 
     /* An array of attributes, with NUM_ATTRS elements.  There may be
        zero, but it's not common and zero-sized arrays are not
        sufficiently portable C.  */
     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)
 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
 #define DW_UNSND(attr)     ((attr)->u.unsnd)
 #define DW_BLOCK(attr)     ((attr)->u.blk)
 #define DW_SND(attr)       ((attr)->u.snd)
 #define DW_ADDR(attr)      ((attr)->u.addr)
 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
 
@@ skipping 76 matching lines @@
       }
     *typedef_field_list;
     unsigned typedef_field_list_count;
   };
 
 /* One item on the queue of compilation units to read in full symbols
    for.  */
 struct dwarf2_queue_item
 {
   struct dwarf2_per_cu_data *per_cu;
+  enum language pretend_language;
   struct dwarf2_queue_item *next;
 };
 
 /* The current queue.  */
 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
 
 /* Loaded secondary compilation units are kept in memory until they
    have not been referenced for the processing of this many
    compilation units.  Set this to zero to disable caching.  Cache
    sizes of up to at least twenty will improve startup time for
@@ skipping 42 matching lines @@
 static void
 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
                                               int arg3)
 {
   complaint (&symfile_complaints,
              _("const value length mismatch for '%s', got %d, expected %d"),
              arg1, arg2, arg3);
 }
 
 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
 dwarf2_macro_malformed_definition_complaint (const char *arg1)
 {
   complaint (&symfile_complaints,
              _("macro debug info contains a "
                "malformed macro definition:\n`%s'"),
              arg1);
 }
@@ skipping 33 matching lines @@
                                 CORE_ADDR *highpc, int need_pc,
                                 struct dwarf2_cu *cu);
 
 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
                                      struct dwarf2_cu *cu);
 
 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 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 struct abbrev_table *abbrev_table_read_table
+  (struct dwarf2_section_info *, sect_offset);
+
+static void abbrev_table_free (struct abbrev_table *);
+
+static void abbrev_table_free_cleanup (void *);
+
+static void dwarf2_read_abbrevs (struct dwarf2_cu *,
+                                 struct dwarf2_section_info *);
 
 static void dwarf2_free_abbrev_table (void *);
 
 static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
 
-static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
-                                            struct dwarf2_cu *);
+static struct partial_die_info *load_partial_dies
+  (const struct die_reader_specs *, gdb_byte *, int);
 
-static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
-                                                 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 *load_partial_dies (bfd *,
-                                                   gdb_byte *, gdb_byte *,
-                                                   int, struct dwarf2_cu *);
-
-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 struct partial_die_info *find_partial_die (unsigned int,
+static struct partial_die_info *find_partial_die (sect_offset,
                                                   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 int read_1_signed_byte (bfd *, gdb_byte *);
 
 static unsigned int read_2_bytes (bfd *, gdb_byte *);
 
 static unsigned int read_4_bytes (bfd *, gdb_byte *);
 
 static ULONGEST read_8_bytes (bfd *, gdb_byte *);
 
 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
                                unsigned int *);
 
 static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *);
 
 static LONGEST read_checked_initial_length_and_offset
   (bfd *, gdb_byte *, const struct comp_unit_head *,
    unsigned int *, unsigned int *);
 
 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
                             unsigned int *);
 
 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 *);
 
 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 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 *);
 
 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);
 
 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
 
 static struct die_info *die_specification (struct die_info *die,
                                            struct dwarf2_cu **);
 
 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 *,
                                 int);
 
 static void dwarf2_start_subfile (char *, const char *, const char *);
 
+static void dwarf2_start_symtab (struct dwarf2_cu *,
+                                 char *, char *, CORE_ADDR);
+
 static struct symbol *new_symbol (struct die_info *, struct type *,
                                   struct dwarf2_cu *);
 
 static struct symbol *new_symbol_full (struct die_info *, struct type *,
                                        struct dwarf2_cu *, struct symbol *);
 
 static void dwarf2_const_value (struct attribute *, struct symbol *,
                                 struct dwarf2_cu *);
 
 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);
 
 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
 
 static int need_gnat_info (struct dwarf2_cu *);
 
 static struct type *die_descriptive_type (struct die_info *,
                                           struct dwarf2_cu *);
 
 static void set_descriptive_type (struct type *, struct die_info *,
                                   struct dwarf2_cu *);
 
 static struct type *die_containing_type (struct die_info *,
                                          struct dwarf2_cu *);
 
 static struct type *lookup_die_type (struct die_info *, struct attribute *,
                                      struct dwarf2_cu *);
 
 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,
                               struct dwarf2_cu *cu);
 
 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
 
 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
 
 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
@@ skipping 46 matching lines @@
 static const char *namespace_name (struct die_info *die,
                                    int *is_anonymous, struct dwarf2_cu *);
 
 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
 
 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 char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
 
 static const char *dwarf2_full_name (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 *);
 
 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
 
 static void dump_die_for_error (struct die_info *);
 
 static void dump_die_1 (struct ui_file *, int level, int max_level,
                         struct die_info *);
 
 /*static*/ void dump_die (struct die_info *, int max_level);
 
 static void store_in_ref_table (struct die_info *,
                                 struct dwarf2_cu *);
 
 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);
 
 static struct die_info *follow_die_ref_or_sig (struct die_info *,
                                                struct attribute *,
                                                struct dwarf2_cu **);
 
 static struct die_info *follow_die_ref (struct die_info *,
                                         struct attribute *,
                                         struct dwarf2_cu **);
 
 static struct die_info *follow_die_sig (struct die_info *,
                                         struct attribute *,
                                         struct dwarf2_cu **);
 
 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,
+                                 char *, int);
 
 static int attr_form_is_block (struct attribute *);
 
 static int attr_form_is_section_offset (struct attribute *);
 
 static int attr_form_is_constant (struct attribute *);
 
 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
                                    struct dwarf2_loclist_baton *baton,
                                    struct attribute *attr);
 
 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 *);
 
 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, 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 *);
+static void process_full_comp_unit (struct dwarf2_per_cu_data *,
+                                    enum language);
+
+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 *);
 
 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);
 
 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);
 
 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 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_cu_die_reader (struct die_reader_specs *reader,
-                                struct dwarf2_cu *cu);
+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 *, char *, const char *, ULONGEST);
+
+static struct dwo_unit *lookup_dwo_type_unit
+  (struct signatured_type *, char *, const char *);
+
+static void free_dwo_file_cleanup (void *);
+
+static void munmap_section_buffer (struct dwarf2_section_info *);
+
+static void process_cu_includes (void);
+
 #if WORDS_BIGENDIAN
 
 /* Convert VALUE between big- and little-endian.  */
 static offset_type
 byte_swap (offset_type value)
 {
   offset_type result;
 
   result = (value & 0xff) << 24;
   result |= (value & 0xff00) << 8;
@@ skipping 59 matching lines @@
 }
 
 /* This function is mapped across the sections and remembers the
    offset and size of each of the debugging sections we are interested
    in.  */
 
 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);
     }
   else if (section_is_p (sectp->name, &names->abbrev))
     {
       dwarf2_per_objfile->abbrev.asection = sectp;
       dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
     }
   else if (section_is_p (sectp->name, &names->line))
@@ skipping 14 matching lines @@
   else if (section_is_p (sectp->name, &names->macro))
     {
       dwarf2_per_objfile->macro.asection = sectp;
       dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
     }
   else if (section_is_p (sectp->name, &names->str))
     {
       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;
       dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
     }
   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))
     {
       dwarf2_per_objfile->ranges.asection = sectp;
       dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
     }
   else if (section_is_p (sectp->name, &names->types))
     {
       struct dwarf2_section_info type_section;
 
@@ skipping 15 matching lines @@
     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;
+  bfd *abfd = sectp->owner;
 #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;
@@ skipping 51 matching lines @@
       || 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)
 {
   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;
 
+  /* Note that ABFD may not be from OBJFILE, e.g. a DWO section.  */
+  abfd = sectp->owner;
+
   /* 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);
@@ skipping 103 matching lines @@
   *sizep = info->size;
 }
 
 
 
 /* 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.