Automatic date update in version.in
[external/binutils.git] / gdb / dwarf2read.c
1 /* DWARF 2 debugging format support for GDB.
2
3    Copyright (C) 1994-2019 Free Software Foundation, Inc.
4
5    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6    Inc.  with support from Florida State University (under contract
7    with the Ada Joint Program Office), and Silicon Graphics, Inc.
8    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
10    support.
11
12    This file is part of GDB.
13
14    This program is free software; you can redistribute it and/or modify
15    it under the terms of the GNU General Public License as published by
16    the Free Software Foundation; either version 3 of the License, or
17    (at your option) any later version.
18
19    This program is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22    GNU General Public License for more details.
23
24    You should have received a copy of the GNU General Public License
25    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
26
27 /* FIXME: Various die-reading functions need to be more careful with
28    reading off the end of the section.
29    E.g., load_partial_dies, read_partial_die.  */
30
31 #include "defs.h"
32 #include "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
35 #include "bfd.h"
36 #include "elf-bfd.h"
37 #include "symtab.h"
38 #include "gdbtypes.h"
39 #include "objfiles.h"
40 #include "dwarf2.h"
41 #include "buildsym.h"
42 #include "demangle.h"
43 #include "gdb-demangle.h"
44 #include "expression.h"
45 #include "filenames.h"  /* for DOSish file names */
46 #include "macrotab.h"
47 #include "language.h"
48 #include "complaints.h"
49 #include "bcache.h"
50 #include "dwarf2expr.h"
51 #include "dwarf2loc.h"
52 #include "cp-support.h"
53 #include "hashtab.h"
54 #include "command.h"
55 #include "gdbcmd.h"
56 #include "block.h"
57 #include "addrmap.h"
58 #include "typeprint.h"
59 #include "psympriv.h"
60 #include <sys/stat.h>
61 #include "completer.h"
62 #include "common/vec.h"
63 #include "c-lang.h"
64 #include "go-lang.h"
65 #include "valprint.h"
66 #include "gdbcore.h" /* for gnutarget */
67 #include "gdb/gdb-index.h"
68 #include <ctype.h>
69 #include "gdb_bfd.h"
70 #include "f-lang.h"
71 #include "source.h"
72 #include "common/filestuff.h"
73 #include "build-id.h"
74 #include "namespace.h"
75 #include "common/gdb_unlinker.h"
76 #include "common/function-view.h"
77 #include "common/gdb_optional.h"
78 #include "common/underlying.h"
79 #include "common/byte-vector.h"
80 #include "common/hash_enum.h"
81 #include "filename-seen-cache.h"
82 #include "producer.h"
83 #include <fcntl.h>
84 #include <sys/types.h>
85 #include <algorithm>
86 #include <unordered_set>
87 #include <unordered_map>
88 #include "common/selftest.h"
89 #include <cmath>
90 #include <set>
91 #include <forward_list>
92 #include "rust-lang.h"
93 #include "common/pathstuff.h"
94
95 /* When == 1, print basic high level tracing messages.
96    When > 1, be more verbose.
97    This is in contrast to the low level DIE reading of dwarf_die_debug.  */
98 static unsigned int dwarf_read_debug = 0;
99
100 /* When non-zero, dump DIEs after they are read in.  */
101 static unsigned int dwarf_die_debug = 0;
102
103 /* When non-zero, dump line number entries as they are read in.  */
104 static unsigned int dwarf_line_debug = 0;
105
106 /* When non-zero, cross-check physname against demangler.  */
107 static int check_physname = 0;
108
109 /* When non-zero, do not reject deprecated .gdb_index sections.  */
110 static int use_deprecated_index_sections = 0;
111
112 static const struct objfile_data *dwarf2_objfile_data_key;
113
114 /* The "aclass" indices for various kinds of computed DWARF symbols.  */
115
116 static int dwarf2_locexpr_index;
117 static int dwarf2_loclist_index;
118 static int dwarf2_locexpr_block_index;
119 static int dwarf2_loclist_block_index;
120
121 /* An index into a (C++) symbol name component in a symbol name as
122    recorded in the mapped_index's symbol table.  For each C++ symbol
123    in the symbol table, we record one entry for the start of each
124    component in the symbol in a table of name components, and then
125    sort the table, in order to be able to binary search symbol names,
126    ignoring leading namespaces, both completion and regular look up.
127    For example, for symbol "A::B::C", we'll have an entry that points
128    to "A::B::C", another that points to "B::C", and another for "C".
129    Note that function symbols in GDB index have no parameter
130    information, just the function/method names.  You can convert a
131    name_component to a "const char *" using the
132    'mapped_index::symbol_name_at(offset_type)' method.  */
133
134 struct name_component
135 {
136   /* Offset in the symbol name where the component starts.  Stored as
137      a (32-bit) offset instead of a pointer to save memory and improve
138      locality on 64-bit architectures.  */
139   offset_type name_offset;
140
141   /* The symbol's index in the symbol and constant pool tables of a
142      mapped_index.  */
143   offset_type idx;
144 };
145
146 /* Base class containing bits shared by both .gdb_index and
147    .debug_name indexes.  */
148
149 struct mapped_index_base
150 {
151   mapped_index_base () = default;
152   DISABLE_COPY_AND_ASSIGN (mapped_index_base);
153
154   /* The name_component table (a sorted vector).  See name_component's
155      description above.  */
156   std::vector<name_component> name_components;
157
158   /* How NAME_COMPONENTS is sorted.  */
159   enum case_sensitivity name_components_casing;
160
161   /* Return the number of names in the symbol table.  */
162   virtual size_t symbol_name_count () const = 0;
163
164   /* Get the name of the symbol at IDX in the symbol table.  */
165   virtual const char *symbol_name_at (offset_type idx) const = 0;
166
167   /* Return whether the name at IDX in the symbol table should be
168      ignored.  */
169   virtual bool symbol_name_slot_invalid (offset_type idx) const
170   {
171     return false;
172   }
173
174   /* Build the symbol name component sorted vector, if we haven't
175      yet.  */
176   void build_name_components ();
177
178   /* Returns the lower (inclusive) and upper (exclusive) bounds of the
179      possible matches for LN_NO_PARAMS in the name component
180      vector.  */
181   std::pair<std::vector<name_component>::const_iterator,
182             std::vector<name_component>::const_iterator>
183     find_name_components_bounds (const lookup_name_info &ln_no_params) const;
184
185   /* Prevent deleting/destroying via a base class pointer.  */
186 protected:
187   ~mapped_index_base() = default;
188 };
189
190 /* A description of the mapped index.  The file format is described in
191    a comment by the code that writes the index.  */
192 struct mapped_index final : public mapped_index_base
193 {
194   /* A slot/bucket in the symbol table hash.  */
195   struct symbol_table_slot
196   {
197     const offset_type name;
198     const offset_type vec;
199   };
200
201   /* Index data format version.  */
202   int version = 0;
203
204   /* The address table data.  */
205   gdb::array_view<const gdb_byte> address_table;
206
207   /* The symbol table, implemented as a hash table.  */
208   gdb::array_view<symbol_table_slot> symbol_table;
209
210   /* A pointer to the constant pool.  */
211   const char *constant_pool = nullptr;
212
213   bool symbol_name_slot_invalid (offset_type idx) const override
214   {
215     const auto &bucket = this->symbol_table[idx];
216     return bucket.name == 0 && bucket.vec;
217   }
218
219   /* Convenience method to get at the name of the symbol at IDX in the
220      symbol table.  */
221   const char *symbol_name_at (offset_type idx) const override
222   { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
223
224   size_t symbol_name_count () const override
225   { return this->symbol_table.size (); }
226 };
227
228 /* A description of the mapped .debug_names.
229    Uninitialized map has CU_COUNT 0.  */
230 struct mapped_debug_names final : public mapped_index_base
231 {
232   mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
233   : dwarf2_per_objfile (dwarf2_per_objfile_)
234   {}
235
236   struct dwarf2_per_objfile *dwarf2_per_objfile;
237   bfd_endian dwarf5_byte_order;
238   bool dwarf5_is_dwarf64;
239   bool augmentation_is_gdb;
240   uint8_t offset_size;
241   uint32_t cu_count = 0;
242   uint32_t tu_count, bucket_count, name_count;
243   const gdb_byte *cu_table_reordered, *tu_table_reordered;
244   const uint32_t *bucket_table_reordered, *hash_table_reordered;
245   const gdb_byte *name_table_string_offs_reordered;
246   const gdb_byte *name_table_entry_offs_reordered;
247   const gdb_byte *entry_pool;
248
249   struct index_val
250   {
251     ULONGEST dwarf_tag;
252     struct attr
253     {
254       /* Attribute name DW_IDX_*.  */
255       ULONGEST dw_idx;
256
257       /* Attribute form DW_FORM_*.  */
258       ULONGEST form;
259
260       /* Value if FORM is DW_FORM_implicit_const.  */
261       LONGEST implicit_const;
262     };
263     std::vector<attr> attr_vec;
264   };
265
266   std::unordered_map<ULONGEST, index_val> abbrev_map;
267
268   const char *namei_to_name (uint32_t namei) const;
269
270   /* Implementation of the mapped_index_base virtual interface, for
271      the name_components cache.  */
272
273   const char *symbol_name_at (offset_type idx) const override
274   { return namei_to_name (idx); }
275
276   size_t symbol_name_count () const override
277   { return this->name_count; }
278 };
279
280 /* See dwarf2read.h.  */
281
282 dwarf2_per_objfile *
283 get_dwarf2_per_objfile (struct objfile *objfile)
284 {
285   return ((struct dwarf2_per_objfile *)
286           objfile_data (objfile, dwarf2_objfile_data_key));
287 }
288
289 /* Set the dwarf2_per_objfile associated to OBJFILE.  */
290
291 void
292 set_dwarf2_per_objfile (struct objfile *objfile,
293                         struct dwarf2_per_objfile *dwarf2_per_objfile)
294 {
295   gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
296   set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
297 }
298
299 /* Default names of the debugging sections.  */
300
301 /* Note that if the debugging section has been compressed, it might
302    have a name like .zdebug_info.  */
303
304 static const struct dwarf2_debug_sections dwarf2_elf_names =
305 {
306   { ".debug_info", ".zdebug_info" },
307   { ".debug_abbrev", ".zdebug_abbrev" },
308   { ".debug_line", ".zdebug_line" },
309   { ".debug_loc", ".zdebug_loc" },
310   { ".debug_loclists", ".zdebug_loclists" },
311   { ".debug_macinfo", ".zdebug_macinfo" },
312   { ".debug_macro", ".zdebug_macro" },
313   { ".debug_str", ".zdebug_str" },
314   { ".debug_line_str", ".zdebug_line_str" },
315   { ".debug_ranges", ".zdebug_ranges" },
316   { ".debug_rnglists", ".zdebug_rnglists" },
317   { ".debug_types", ".zdebug_types" },
318   { ".debug_addr", ".zdebug_addr" },
319   { ".debug_frame", ".zdebug_frame" },
320   { ".eh_frame", NULL },
321   { ".gdb_index", ".zgdb_index" },
322   { ".debug_names", ".zdebug_names" },
323   { ".debug_aranges", ".zdebug_aranges" },
324   23
325 };
326
327 /* List of DWO/DWP sections.  */
328
329 static const struct dwop_section_names
330 {
331   struct dwarf2_section_names abbrev_dwo;
332   struct dwarf2_section_names info_dwo;
333   struct dwarf2_section_names line_dwo;
334   struct dwarf2_section_names loc_dwo;
335   struct dwarf2_section_names loclists_dwo;
336   struct dwarf2_section_names macinfo_dwo;
337   struct dwarf2_section_names macro_dwo;
338   struct dwarf2_section_names str_dwo;
339   struct dwarf2_section_names str_offsets_dwo;
340   struct dwarf2_section_names types_dwo;
341   struct dwarf2_section_names cu_index;
342   struct dwarf2_section_names tu_index;
343 }
344 dwop_section_names =
345 {
346   { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
347   { ".debug_info.dwo", ".zdebug_info.dwo" },
348   { ".debug_line.dwo", ".zdebug_line.dwo" },
349   { ".debug_loc.dwo", ".zdebug_loc.dwo" },
350   { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
351   { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
352   { ".debug_macro.dwo", ".zdebug_macro.dwo" },
353   { ".debug_str.dwo", ".zdebug_str.dwo" },
354   { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
355   { ".debug_types.dwo", ".zdebug_types.dwo" },
356   { ".debug_cu_index", ".zdebug_cu_index" },
357   { ".debug_tu_index", ".zdebug_tu_index" },
358 };
359
360 /* local data types */
361
362 /* The data in a compilation unit header, after target2host
363    translation, looks like this.  */
364 struct comp_unit_head
365 {
366   unsigned int length;
367   short version;
368   unsigned char addr_size;
369   unsigned char signed_addr_p;
370   sect_offset abbrev_sect_off;
371
372   /* Size of file offsets; either 4 or 8.  */
373   unsigned int offset_size;
374
375   /* Size of the length field; either 4 or 12.  */
376   unsigned int initial_length_size;
377
378   enum dwarf_unit_type unit_type;
379
380   /* Offset to the first byte of this compilation unit header in the
381      .debug_info section, for resolving relative reference dies.  */
382   sect_offset sect_off;
383
384   /* Offset to first die in this cu from the start of the cu.
385      This will be the first byte following the compilation unit header.  */
386   cu_offset first_die_cu_offset;
387
388   /* 64-bit signature of this type unit - it is valid only for
389      UNIT_TYPE DW_UT_type.  */
390   ULONGEST signature;
391
392   /* For types, offset in the type's DIE of the type defined by this TU.  */
393   cu_offset type_cu_offset_in_tu;
394 };
395
396 /* Type used for delaying computation of method physnames.
397    See comments for compute_delayed_physnames.  */
398 struct delayed_method_info
399 {
400   /* The type to which the method is attached, i.e., its parent class.  */
401   struct type *type;
402
403   /* The index of the method in the type's function fieldlists.  */
404   int fnfield_index;
405
406   /* The index of the method in the fieldlist.  */
407   int index;
408
409   /* The name of the DIE.  */
410   const char *name;
411
412   /*  The DIE associated with this method.  */
413   struct die_info *die;
414 };
415
416 /* Internal state when decoding a particular compilation unit.  */
417 struct dwarf2_cu
418 {
419   explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
420   ~dwarf2_cu ();
421
422   DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
423
424   /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
425      Create the set of symtabs used by this TU, or if this TU is sharing
426      symtabs with another TU and the symtabs have already been created
427      then restore those symtabs in the line header.
428      We don't need the pc/line-number mapping for type units.  */
429   void setup_type_unit_groups (struct die_info *die);
430
431   /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
432      buildsym_compunit constructor.  */
433   struct compunit_symtab *start_symtab (const char *name,
434                                         const char *comp_dir,
435                                         CORE_ADDR low_pc);
436
437   /* Reset the builder.  */
438   void reset_builder () { m_builder.reset (); }
439
440   /* The header of the compilation unit.  */
441   struct comp_unit_head header {};
442
443   /* Base address of this compilation unit.  */
444   CORE_ADDR base_address = 0;
445
446   /* Non-zero if base_address has been set.  */
447   int base_known = 0;
448
449   /* The language we are debugging.  */
450   enum language language = language_unknown;
451   const struct language_defn *language_defn = nullptr;
452
453   const char *producer = nullptr;
454
455 private:
456   /* The symtab builder for this CU.  This is only non-NULL when full
457      symbols are being read.  */
458   std::unique_ptr<buildsym_compunit> m_builder;
459
460 public:
461   /* The generic symbol table building routines have separate lists for
462      file scope symbols and all all other scopes (local scopes).  So
463      we need to select the right one to pass to add_symbol_to_list().
464      We do it by keeping a pointer to the correct list in list_in_scope.
465
466      FIXME: The original dwarf code just treated the file scope as the
467      first local scope, and all other local scopes as nested local
468      scopes, and worked fine.  Check to see if we really need to
469      distinguish these in buildsym.c.  */
470   struct pending **list_in_scope = nullptr;
471
472   /* Hash table holding all the loaded partial DIEs
473      with partial_die->offset.SECT_OFF as hash.  */
474   htab_t partial_dies = nullptr;
475
476   /* Storage for things with the same lifetime as this read-in compilation
477      unit, including partial DIEs.  */
478   auto_obstack comp_unit_obstack;
479
480   /* When multiple dwarf2_cu structures are living in memory, this field
481      chains them all together, so that they can be released efficiently.
482      We will probably also want a generation counter so that most-recently-used
483      compilation units are cached...  */
484   struct dwarf2_per_cu_data *read_in_chain = nullptr;
485
486   /* Backlink to our per_cu entry.  */
487   struct dwarf2_per_cu_data *per_cu;
488
489   /* How many compilation units ago was this CU last referenced?  */
490   int last_used = 0;
491
492   /* A hash table of DIE cu_offset for following references with
493      die_info->offset.sect_off as hash.  */
494   htab_t die_hash = nullptr;
495
496   /* Full DIEs if read in.  */
497   struct die_info *dies = nullptr;
498
499   /* A set of pointers to dwarf2_per_cu_data objects for compilation
500      units referenced by this one.  Only set during full symbol processing;
501      partial symbol tables do not have dependencies.  */
502   htab_t dependencies = nullptr;
503
504   /* Header data from the line table, during full symbol processing.  */
505   struct line_header *line_header = nullptr;
506   /* Non-NULL if LINE_HEADER is owned by this DWARF_CU.  Otherwise,
507      it's owned by dwarf2_per_objfile::line_header_hash.  If non-NULL,
508      this is the DW_TAG_compile_unit die for this CU.  We'll hold on
509      to the line header as long as this DIE is being processed.  See
510      process_die_scope.  */
511   die_info *line_header_die_owner = nullptr;
512
513   /* A list of methods which need to have physnames computed
514      after all type information has been read.  */
515   std::vector<delayed_method_info> method_list;
516
517   /* To be copied to symtab->call_site_htab.  */
518   htab_t call_site_htab = nullptr;
519
520   /* Non-NULL if this CU came from a DWO file.
521      There is an invariant here that is important to remember:
522      Except for attributes copied from the top level DIE in the "main"
523      (or "stub") file in preparation for reading the DWO file
524      (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
525      Either there isn't a DWO file (in which case this is NULL and the point
526      is moot), or there is and either we're not going to read it (in which
527      case this is NULL) or there is and we are reading it (in which case this
528      is non-NULL).  */
529   struct dwo_unit *dwo_unit = nullptr;
530
531   /* The DW_AT_addr_base attribute if present, zero otherwise
532      (zero is a valid value though).
533      Note this value comes from the Fission stub CU/TU's DIE.  */
534   ULONGEST addr_base = 0;
535
536   /* The DW_AT_ranges_base attribute if present, zero otherwise
537      (zero is a valid value though).
538      Note this value comes from the Fission stub CU/TU's DIE.
539      Also note that the value is zero in the non-DWO case so this value can
540      be used without needing to know whether DWO files are in use or not.
541      N.B. This does not apply to DW_AT_ranges appearing in
542      DW_TAG_compile_unit dies.  This is a bit of a wart, consider if ever
543      DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
544      DW_AT_ranges_base *would* have to be applied, and we'd have to care
545      whether the DW_AT_ranges attribute came from the skeleton or DWO.  */
546   ULONGEST ranges_base = 0;
547
548   /* When reading debug info generated by older versions of rustc, we
549      have to rewrite some union types to be struct types with a
550      variant part.  This rewriting must be done after the CU is fully
551      read in, because otherwise at the point of rewriting some struct
552      type might not have been fully processed.  So, we keep a list of
553      all such types here and process them after expansion.  */
554   std::vector<struct type *> rust_unions;
555
556   /* Mark used when releasing cached dies.  */
557   bool mark : 1;
558
559   /* This CU references .debug_loc.  See the symtab->locations_valid field.
560      This test is imperfect as there may exist optimized debug code not using
561      any location list and still facing inlining issues if handled as
562      unoptimized code.  For a future better test see GCC PR other/32998.  */
563   bool has_loclist : 1;
564
565   /* These cache the results for producer_is_* fields.  CHECKED_PRODUCER is true
566      if all the producer_is_* fields are valid.  This information is cached
567      because profiling CU expansion showed excessive time spent in
568      producer_is_gxx_lt_4_6.  */
569   bool checked_producer : 1;
570   bool producer_is_gxx_lt_4_6 : 1;
571   bool producer_is_gcc_lt_4_3 : 1;
572   bool producer_is_icc : 1;
573   bool producer_is_icc_lt_14 : 1;
574   bool producer_is_codewarrior : 1;
575
576   /* When true, the file that we're processing is known to have
577      debugging info for C++ namespaces.  GCC 3.3.x did not produce
578      this information, but later versions do.  */
579
580   bool processing_has_namespace_info : 1;
581
582   struct partial_die_info *find_partial_die (sect_offset sect_off);
583
584   /* If this CU was inherited by another CU (via specification,
585      abstract_origin, etc), this is the ancestor CU.  */
586   dwarf2_cu *ancestor;
587
588   /* Get the buildsym_compunit for this CU.  */
589   buildsym_compunit *get_builder ()
590   {
591     /* If this CU has a builder associated with it, use that.  */
592     if (m_builder != nullptr)
593       return m_builder.get ();
594
595     /* Otherwise, search ancestors for a valid builder.  */
596     if (ancestor != nullptr)
597       return ancestor->get_builder ();
598
599     return nullptr;
600   }
601 };
602
603 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
604    This includes type_unit_group and quick_file_names.  */
605
606 struct stmt_list_hash
607 {
608   /* The DWO unit this table is from or NULL if there is none.  */
609   struct dwo_unit *dwo_unit;
610
611   /* Offset in .debug_line or .debug_line.dwo.  */
612   sect_offset line_sect_off;
613 };
614
615 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
616    an object of this type.  */
617
618 struct type_unit_group
619 {
620   /* dwarf2read.c's main "handle" on a TU symtab.
621      To simplify things we create an artificial CU that "includes" all the
622      type units using this stmt_list so that the rest of the code still has
623      a "per_cu" handle on the symtab.
624      This PER_CU is recognized by having no section.  */
625 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
626   struct dwarf2_per_cu_data per_cu;
627
628   /* The TUs that share this DW_AT_stmt_list entry.
629      This is added to while parsing type units to build partial symtabs,
630      and is deleted afterwards and not used again.  */
631   VEC (sig_type_ptr) *tus;
632
633   /* The compunit symtab.
634      Type units in a group needn't all be defined in the same source file,
635      so we create an essentially anonymous symtab as the compunit symtab.  */
636   struct compunit_symtab *compunit_symtab;
637
638   /* The data used to construct the hash key.  */
639   struct stmt_list_hash hash;
640
641   /* The number of symtabs from the line header.
642      The value here must match line_header.num_file_names.  */
643   unsigned int num_symtabs;
644
645   /* The symbol tables for this TU (obtained from the files listed in
646      DW_AT_stmt_list).
647      WARNING: The order of entries here must match the order of entries
648      in the line header.  After the first TU using this type_unit_group, the
649      line header for the subsequent TUs is recreated from this.  This is done
650      because we need to use the same symtabs for each TU using the same
651      DW_AT_stmt_list value.  Also note that symtabs may be repeated here,
652      there's no guarantee the line header doesn't have duplicate entries.  */
653   struct symtab **symtabs;
654 };
655
656 /* These sections are what may appear in a (real or virtual) DWO file.  */
657
658 struct dwo_sections
659 {
660   struct dwarf2_section_info abbrev;
661   struct dwarf2_section_info line;
662   struct dwarf2_section_info loc;
663   struct dwarf2_section_info loclists;
664   struct dwarf2_section_info macinfo;
665   struct dwarf2_section_info macro;
666   struct dwarf2_section_info str;
667   struct dwarf2_section_info str_offsets;
668   /* In the case of a virtual DWO file, these two are unused.  */
669   struct dwarf2_section_info info;
670   VEC (dwarf2_section_info_def) *types;
671 };
672
673 /* CUs/TUs in DWP/DWO files.  */
674
675 struct dwo_unit
676 {
677   /* Backlink to the containing struct dwo_file.  */
678   struct dwo_file *dwo_file;
679
680   /* The "id" that distinguishes this CU/TU.
681      .debug_info calls this "dwo_id", .debug_types calls this "signature".
682      Since signatures came first, we stick with it for consistency.  */
683   ULONGEST signature;
684
685   /* The section this CU/TU lives in, in the DWO file.  */
686   struct dwarf2_section_info *section;
687
688   /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section.  */
689   sect_offset sect_off;
690   unsigned int length;
691
692   /* For types, offset in the type's DIE of the type defined by this TU.  */
693   cu_offset type_offset_in_tu;
694 };
695
696 /* include/dwarf2.h defines the DWP section codes.
697    It defines a max value but it doesn't define a min value, which we
698    use for error checking, so provide one.  */
699
700 enum dwp_v2_section_ids
701 {
702   DW_SECT_MIN = 1
703 };
704
705 /* Data for one DWO file.
706
707    This includes virtual DWO files (a virtual DWO file is a DWO file as it
708    appears in a DWP file).  DWP files don't really have DWO files per se -
709    comdat folding of types "loses" the DWO file they came from, and from
710    a high level view DWP files appear to contain a mass of random types.
711    However, to maintain consistency with the non-DWP case we pretend DWP
712    files contain virtual DWO files, and we assign each TU with one virtual
713    DWO file (generally based on the line and abbrev section offsets -
714    a heuristic that seems to work in practice).  */
715
716 struct dwo_file
717 {
718   /* The DW_AT_GNU_dwo_name attribute.
719      For virtual DWO files the name is constructed from the section offsets
720      of abbrev,line,loc,str_offsets so that we combine virtual DWO files
721      from related CU+TUs.  */
722   const char *dwo_name;
723
724   /* The DW_AT_comp_dir attribute.  */
725   const char *comp_dir;
726
727   /* The bfd, when the file is open.  Otherwise this is NULL.
728      This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd.  */
729   bfd *dbfd;
730
731   /* The sections that make up this DWO file.
732      Remember that for virtual DWO files in DWP V2, these are virtual
733      sections (for lack of a better name).  */
734   struct dwo_sections sections;
735
736   /* The CUs in the file.
737      Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
738      an extension to handle LLVM's Link Time Optimization output (where
739      multiple source files may be compiled into a single object/dwo pair). */
740   htab_t cus;
741
742   /* Table of TUs in the file.
743      Each element is a struct dwo_unit.  */
744   htab_t tus;
745 };
746
747 /* These sections are what may appear in a DWP file.  */
748
749 struct dwp_sections
750 {
751   /* These are used by both DWP version 1 and 2.  */
752   struct dwarf2_section_info str;
753   struct dwarf2_section_info cu_index;
754   struct dwarf2_section_info tu_index;
755
756   /* These are only used by DWP version 2 files.
757      In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
758      sections are referenced by section number, and are not recorded here.
759      In DWP version 2 there is at most one copy of all these sections, each
760      section being (effectively) comprised of the concatenation of all of the
761      individual sections that exist in the version 1 format.
762      To keep the code simple we treat each of these concatenated pieces as a
763      section itself (a virtual section?).  */
764   struct dwarf2_section_info abbrev;
765   struct dwarf2_section_info info;
766   struct dwarf2_section_info line;
767   struct dwarf2_section_info loc;
768   struct dwarf2_section_info macinfo;
769   struct dwarf2_section_info macro;
770   struct dwarf2_section_info str_offsets;
771   struct dwarf2_section_info types;
772 };
773
774 /* These sections are what may appear in a virtual DWO file in DWP version 1.
775    A virtual DWO file is a DWO file as it appears in a DWP file.  */
776
777 struct virtual_v1_dwo_sections
778 {
779   struct dwarf2_section_info abbrev;
780   struct dwarf2_section_info line;
781   struct dwarf2_section_info loc;
782   struct dwarf2_section_info macinfo;
783   struct dwarf2_section_info macro;
784   struct dwarf2_section_info str_offsets;
785   /* Each DWP hash table entry records one CU or one TU.
786      That is recorded here, and copied to dwo_unit.section.  */
787   struct dwarf2_section_info info_or_types;
788 };
789
790 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
791    In version 2, the sections of the DWO files are concatenated together
792    and stored in one section of that name.  Thus each ELF section contains
793    several "virtual" sections.  */
794
795 struct virtual_v2_dwo_sections
796 {
797   bfd_size_type abbrev_offset;
798   bfd_size_type abbrev_size;
799
800   bfd_size_type line_offset;
801   bfd_size_type line_size;
802
803   bfd_size_type loc_offset;
804   bfd_size_type loc_size;
805
806   bfd_size_type macinfo_offset;
807   bfd_size_type macinfo_size;
808
809   bfd_size_type macro_offset;
810   bfd_size_type macro_size;
811
812   bfd_size_type str_offsets_offset;
813   bfd_size_type str_offsets_size;
814
815   /* Each DWP hash table entry records one CU or one TU.
816      That is recorded here, and copied to dwo_unit.section.  */
817   bfd_size_type info_or_types_offset;
818   bfd_size_type info_or_types_size;
819 };
820
821 /* Contents of DWP hash tables.  */
822
823 struct dwp_hash_table
824 {
825   uint32_t version, nr_columns;
826   uint32_t nr_units, nr_slots;
827   const gdb_byte *hash_table, *unit_table;
828   union
829   {
830     struct
831     {
832       const gdb_byte *indices;
833     } v1;
834     struct
835     {
836       /* This is indexed by column number and gives the id of the section
837          in that column.  */
838 #define MAX_NR_V2_DWO_SECTIONS \
839   (1 /* .debug_info or .debug_types */ \
840    + 1 /* .debug_abbrev */ \
841    + 1 /* .debug_line */ \
842    + 1 /* .debug_loc */ \
843    + 1 /* .debug_str_offsets */ \
844    + 1 /* .debug_macro or .debug_macinfo */)
845       int section_ids[MAX_NR_V2_DWO_SECTIONS];
846       const gdb_byte *offsets;
847       const gdb_byte *sizes;
848     } v2;
849   } section_pool;
850 };
851
852 /* Data for one DWP file.  */
853
854 struct dwp_file
855 {
856   dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
857     : name (name_),
858       dbfd (std::move (abfd))
859   {
860   }
861
862   /* Name of the file.  */
863   const char *name;
864
865   /* File format version.  */
866   int version = 0;
867
868   /* The bfd.  */
869   gdb_bfd_ref_ptr dbfd;
870
871   /* Section info for this file.  */
872   struct dwp_sections sections {};
873
874   /* Table of CUs in the file.  */
875   const struct dwp_hash_table *cus = nullptr;
876
877   /* Table of TUs in the file.  */
878   const struct dwp_hash_table *tus = nullptr;
879
880   /* Tables of loaded CUs/TUs.  Each entry is a struct dwo_unit *.  */
881   htab_t loaded_cus {};
882   htab_t loaded_tus {};
883
884   /* Table to map ELF section numbers to their sections.
885      This is only needed for the DWP V1 file format.  */
886   unsigned int num_sections = 0;
887   asection **elf_sections = nullptr;
888 };
889
890 /* This represents a '.dwz' file.  */
891
892 struct dwz_file
893 {
894   dwz_file (gdb_bfd_ref_ptr &&bfd)
895     : dwz_bfd (std::move (bfd))
896   {
897   }
898
899   /* A dwz file can only contain a few sections.  */
900   struct dwarf2_section_info abbrev {};
901   struct dwarf2_section_info info {};
902   struct dwarf2_section_info str {};
903   struct dwarf2_section_info line {};
904   struct dwarf2_section_info macro {};
905   struct dwarf2_section_info gdb_index {};
906   struct dwarf2_section_info debug_names {};
907
908   /* The dwz's BFD.  */
909   gdb_bfd_ref_ptr dwz_bfd;
910
911   /* If we loaded the index from an external file, this contains the
912      resources associated to the open file, memory mapping, etc.  */
913   std::unique_ptr<index_cache_resource> index_cache_res;
914 };
915
916 /* Struct used to pass misc. parameters to read_die_and_children, et
917    al.  which are used for both .debug_info and .debug_types dies.
918    All parameters here are unchanging for the life of the call.  This
919    struct exists to abstract away the constant parameters of die reading.  */
920
921 struct die_reader_specs
922 {
923   /* The bfd of die_section.  */
924   bfd* abfd;
925
926   /* The CU of the DIE we are parsing.  */
927   struct dwarf2_cu *cu;
928
929   /* Non-NULL if reading a DWO file (including one packaged into a DWP).  */
930   struct dwo_file *dwo_file;
931
932   /* The section the die comes from.
933      This is either .debug_info or .debug_types, or the .dwo variants.  */
934   struct dwarf2_section_info *die_section;
935
936   /* die_section->buffer.  */
937   const gdb_byte *buffer;
938
939   /* The end of the buffer.  */
940   const gdb_byte *buffer_end;
941
942   /* The value of the DW_AT_comp_dir attribute.  */
943   const char *comp_dir;
944
945   /* The abbreviation table to use when reading the DIEs.  */
946   struct abbrev_table *abbrev_table;
947 };
948
949 /* Type of function passed to init_cutu_and_read_dies, et.al.  */
950 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
951                                       const gdb_byte *info_ptr,
952                                       struct die_info *comp_unit_die,
953                                       int has_children,
954                                       void *data);
955
956 /* A 1-based directory index.  This is a strong typedef to prevent
957    accidentally using a directory index as a 0-based index into an
958    array/vector.  */
959 enum class dir_index : unsigned int {};
960
961 /* Likewise, a 1-based file name index.  */
962 enum class file_name_index : unsigned int {};
963
964 struct file_entry
965 {
966   file_entry () = default;
967
968   file_entry (const char *name_, dir_index d_index_,
969               unsigned int mod_time_, unsigned int length_)
970     : name (name_),
971       d_index (d_index_),
972       mod_time (mod_time_),
973       length (length_)
974   {}
975
976   /* Return the include directory at D_INDEX stored in LH.  Returns
977      NULL if D_INDEX is out of bounds.  */
978   const char *include_dir (const line_header *lh) const;
979
980   /* The file name.  Note this is an observing pointer.  The memory is
981      owned by debug_line_buffer.  */
982   const char *name {};
983
984   /* The directory index (1-based).  */
985   dir_index d_index {};
986
987   unsigned int mod_time {};
988
989   unsigned int length {};
990
991   /* True if referenced by the Line Number Program.  */
992   bool included_p {};
993
994   /* The associated symbol table, if any.  */
995   struct symtab *symtab {};
996 };
997
998 /* The line number information for a compilation unit (found in the
999    .debug_line section) begins with a "statement program header",
1000    which contains the following information.  */
1001 struct line_header
1002 {
1003   line_header ()
1004     : offset_in_dwz {}
1005   {}
1006
1007   /* Add an entry to the include directory table.  */
1008   void add_include_dir (const char *include_dir);
1009
1010   /* Add an entry to the file name table.  */
1011   void add_file_name (const char *name, dir_index d_index,
1012                       unsigned int mod_time, unsigned int length);
1013
1014   /* Return the include dir at INDEX (1-based).  Returns NULL if INDEX
1015      is out of bounds.  */
1016   const char *include_dir_at (dir_index index) const
1017   {
1018     /* Convert directory index number (1-based) to vector index
1019        (0-based).  */
1020     size_t vec_index = to_underlying (index) - 1;
1021
1022     if (vec_index >= include_dirs.size ())
1023       return NULL;
1024     return include_dirs[vec_index];
1025   }
1026
1027   /* Return the file name at INDEX (1-based).  Returns NULL if INDEX
1028      is out of bounds.  */
1029   file_entry *file_name_at (file_name_index index)
1030   {
1031     /* Convert file name index number (1-based) to vector index
1032        (0-based).  */
1033     size_t vec_index = to_underlying (index) - 1;
1034
1035     if (vec_index >= file_names.size ())
1036       return NULL;
1037     return &file_names[vec_index];
1038   }
1039
1040   /* Const version of the above.  */
1041   const file_entry *file_name_at (unsigned int index) const
1042   {
1043     if (index >= file_names.size ())
1044       return NULL;
1045     return &file_names[index];
1046   }
1047
1048   /* Offset of line number information in .debug_line section.  */
1049   sect_offset sect_off {};
1050
1051   /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile.  */
1052   unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class.  */
1053
1054   unsigned int total_length {};
1055   unsigned short version {};
1056   unsigned int header_length {};
1057   unsigned char minimum_instruction_length {};
1058   unsigned char maximum_ops_per_instruction {};
1059   unsigned char default_is_stmt {};
1060   int line_base {};
1061   unsigned char line_range {};
1062   unsigned char opcode_base {};
1063
1064   /* standard_opcode_lengths[i] is the number of operands for the
1065      standard opcode whose value is i.  This means that
1066      standard_opcode_lengths[0] is unused, and the last meaningful
1067      element is standard_opcode_lengths[opcode_base - 1].  */
1068   std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1069
1070   /* The include_directories table.  Note these are observing
1071      pointers.  The memory is owned by debug_line_buffer.  */
1072   std::vector<const char *> include_dirs;
1073
1074   /* The file_names table.  */
1075   std::vector<file_entry> file_names;
1076
1077   /* The start and end of the statement program following this
1078      header.  These point into dwarf2_per_objfile->line_buffer.  */
1079   const gdb_byte *statement_program_start {}, *statement_program_end {};
1080 };
1081
1082 typedef std::unique_ptr<line_header> line_header_up;
1083
1084 const char *
1085 file_entry::include_dir (const line_header *lh) const
1086 {
1087   return lh->include_dir_at (d_index);
1088 }
1089
1090 /* When we construct a partial symbol table entry we only
1091    need this much information.  */
1092 struct partial_die_info : public allocate_on_obstack
1093   {
1094     partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1095
1096     /* Disable assign but still keep copy ctor, which is needed
1097        load_partial_dies.   */
1098     partial_die_info& operator=(const partial_die_info& rhs) = delete;
1099
1100     /* Adjust the partial die before generating a symbol for it.  This
1101        function may set the is_external flag or change the DIE's
1102        name.  */
1103     void fixup (struct dwarf2_cu *cu);
1104
1105     /* Read a minimal amount of information into the minimal die
1106        structure.  */
1107     const gdb_byte *read (const struct die_reader_specs *reader,
1108                           const struct abbrev_info &abbrev,
1109                           const gdb_byte *info_ptr);
1110
1111     /* Offset of this DIE.  */
1112     const sect_offset sect_off;
1113
1114     /* DWARF-2 tag for this DIE.  */
1115     const ENUM_BITFIELD(dwarf_tag) tag : 16;
1116
1117     /* Assorted flags describing the data found in this DIE.  */
1118     const unsigned int has_children : 1;
1119
1120     unsigned int is_external : 1;
1121     unsigned int is_declaration : 1;
1122     unsigned int has_type : 1;
1123     unsigned int has_specification : 1;
1124     unsigned int has_pc_info : 1;
1125     unsigned int may_be_inlined : 1;
1126
1127     /* This DIE has been marked DW_AT_main_subprogram.  */
1128     unsigned int main_subprogram : 1;
1129
1130     /* Flag set if the SCOPE field of this structure has been
1131        computed.  */
1132     unsigned int scope_set : 1;
1133
1134     /* Flag set if the DIE has a byte_size attribute.  */
1135     unsigned int has_byte_size : 1;
1136
1137     /* Flag set if the DIE has a DW_AT_const_value attribute.  */
1138     unsigned int has_const_value : 1;
1139
1140     /* Flag set if any of the DIE's children are template arguments.  */
1141     unsigned int has_template_arguments : 1;
1142
1143     /* Flag set if fixup has been called on this die.  */
1144     unsigned int fixup_called : 1;
1145
1146     /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt.  */
1147     unsigned int is_dwz : 1;
1148
1149     /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt.  */
1150     unsigned int spec_is_dwz : 1;
1151
1152     /* The name of this DIE.  Normally the value of DW_AT_name, but
1153        sometimes a default name for unnamed DIEs.  */
1154     const char *name = nullptr;
1155
1156     /* The linkage name, if present.  */
1157     const char *linkage_name = nullptr;
1158
1159     /* The scope to prepend to our children.  This is generally
1160        allocated on the comp_unit_obstack, so will disappear
1161        when this compilation unit leaves the cache.  */
1162     const char *scope = nullptr;
1163
1164     /* Some data associated with the partial DIE.  The tag determines
1165        which field is live.  */
1166     union
1167     {
1168       /* The location description associated with this DIE, if any.  */
1169       struct dwarf_block *locdesc;
1170       /* The offset of an import, for DW_TAG_imported_unit.  */
1171       sect_offset sect_off;
1172     } d {};
1173
1174     /* If HAS_PC_INFO, the PC range associated with this DIE.  */
1175     CORE_ADDR lowpc = 0;
1176     CORE_ADDR highpc = 0;
1177
1178     /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1179        DW_AT_sibling, if any.  */
1180     /* NOTE: This member isn't strictly necessary, partial_die_info::read
1181        could return DW_AT_sibling values to its caller load_partial_dies.  */
1182     const gdb_byte *sibling = nullptr;
1183
1184     /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1185        DW_AT_specification (or DW_AT_abstract_origin or
1186        DW_AT_extension).  */
1187     sect_offset spec_offset {};
1188
1189     /* Pointers to this DIE's parent, first child, and next sibling,
1190        if any.  */
1191     struct partial_die_info *die_parent = nullptr;
1192     struct partial_die_info *die_child = nullptr;
1193     struct partial_die_info *die_sibling = nullptr;
1194
1195     friend struct partial_die_info *
1196     dwarf2_cu::find_partial_die (sect_offset sect_off);
1197
1198   private:
1199     /* Only need to do look up in dwarf2_cu::find_partial_die.  */
1200     partial_die_info (sect_offset sect_off)
1201       : partial_die_info (sect_off, DW_TAG_padding, 0)
1202     {
1203     }
1204
1205     partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1206                       int has_children_)
1207       : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1208     {
1209       is_external = 0;
1210       is_declaration = 0;
1211       has_type = 0;
1212       has_specification = 0;
1213       has_pc_info = 0;
1214       may_be_inlined = 0;
1215       main_subprogram = 0;
1216       scope_set = 0;
1217       has_byte_size = 0;
1218       has_const_value = 0;
1219       has_template_arguments = 0;
1220       fixup_called = 0;
1221       is_dwz = 0;
1222       spec_is_dwz = 0;
1223     }
1224   };
1225
1226 /* This data structure holds the information of an abbrev.  */
1227 struct abbrev_info
1228   {
1229     unsigned int number;        /* number identifying abbrev */
1230     enum dwarf_tag tag;         /* dwarf tag */
1231     unsigned short has_children;                /* boolean */
1232     unsigned short num_attrs;   /* number of attributes */
1233     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
1234     struct abbrev_info *next;   /* next in chain */
1235   };
1236
1237 struct attr_abbrev
1238   {
1239     ENUM_BITFIELD(dwarf_attribute) name : 16;
1240     ENUM_BITFIELD(dwarf_form) form : 16;
1241
1242     /* It is valid only if FORM is DW_FORM_implicit_const.  */
1243     LONGEST implicit_const;
1244   };
1245
1246 /* Size of abbrev_table.abbrev_hash_table.  */
1247 #define ABBREV_HASH_SIZE 121
1248
1249 /* Top level data structure to contain an abbreviation table.  */
1250
1251 struct abbrev_table
1252 {
1253   explicit abbrev_table (sect_offset off)
1254     : sect_off (off)
1255   {
1256     m_abbrevs =
1257       XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1258     memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1259   }
1260
1261   DISABLE_COPY_AND_ASSIGN (abbrev_table);
1262
1263   /* Allocate space for a struct abbrev_info object in
1264      ABBREV_TABLE.  */
1265   struct abbrev_info *alloc_abbrev ();
1266
1267   /* Add an abbreviation to the table.  */
1268   void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1269
1270   /* Look up an abbrev in the table.
1271      Returns NULL if the abbrev is not found.  */
1272
1273   struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1274
1275
1276   /* Where the abbrev table came from.
1277      This is used as a sanity check when the table is used.  */
1278   const sect_offset sect_off;
1279
1280   /* Storage for the abbrev table.  */
1281   auto_obstack abbrev_obstack;
1282
1283 private:
1284
1285   /* Hash table of abbrevs.
1286      This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1287      It could be statically allocated, but the previous code didn't so we
1288      don't either.  */
1289   struct abbrev_info **m_abbrevs;
1290 };
1291
1292 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1293
1294 /* Attributes have a name and a value.  */
1295 struct attribute
1296   {
1297     ENUM_BITFIELD(dwarf_attribute) name : 16;
1298     ENUM_BITFIELD(dwarf_form) form : 15;
1299
1300     /* Has DW_STRING already been updated by dwarf2_canonicalize_name?  This
1301        field should be in u.str (existing only for DW_STRING) but it is kept
1302        here for better struct attribute alignment.  */
1303     unsigned int string_is_canonical : 1;
1304
1305     union
1306       {
1307         const char *str;
1308         struct dwarf_block *blk;
1309         ULONGEST unsnd;
1310         LONGEST snd;
1311         CORE_ADDR addr;
1312         ULONGEST signature;
1313       }
1314     u;
1315   };
1316
1317 /* This data structure holds a complete die structure.  */
1318 struct die_info
1319   {
1320     /* DWARF-2 tag for this DIE.  */
1321     ENUM_BITFIELD(dwarf_tag) tag : 16;
1322
1323     /* Number of attributes */
1324     unsigned char num_attrs;
1325
1326     /* True if we're presently building the full type name for the
1327        type derived from this DIE.  */
1328     unsigned char building_fullname : 1;
1329
1330     /* True if this die is in process.  PR 16581.  */
1331     unsigned char in_process : 1;
1332
1333     /* Abbrev number */
1334     unsigned int abbrev;
1335
1336     /* Offset in .debug_info or .debug_types section.  */
1337     sect_offset sect_off;
1338
1339     /* The dies in a compilation unit form an n-ary tree.  PARENT
1340        points to this die's parent; CHILD points to the first child of
1341        this node; and all the children of a given node are chained
1342        together via their SIBLING fields.  */
1343     struct die_info *child;     /* Its first child, if any.  */
1344     struct die_info *sibling;   /* Its next sibling, if any.  */
1345     struct die_info *parent;    /* Its parent, if any.  */
1346
1347     /* An array of attributes, with NUM_ATTRS elements.  There may be
1348        zero, but it's not common and zero-sized arrays are not
1349        sufficiently portable C.  */
1350     struct attribute attrs[1];
1351   };
1352
1353 /* Get at parts of an attribute structure.  */
1354
1355 #define DW_STRING(attr)    ((attr)->u.str)
1356 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1357 #define DW_UNSND(attr)     ((attr)->u.unsnd)
1358 #define DW_BLOCK(attr)     ((attr)->u.blk)
1359 #define DW_SND(attr)       ((attr)->u.snd)
1360 #define DW_ADDR(attr)      ((attr)->u.addr)
1361 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1362
1363 /* Blocks are a bunch of untyped bytes.  */
1364 struct dwarf_block
1365   {
1366     size_t size;
1367
1368     /* Valid only if SIZE is not zero.  */
1369     const gdb_byte *data;
1370   };
1371
1372 #ifndef ATTR_ALLOC_CHUNK
1373 #define ATTR_ALLOC_CHUNK 4
1374 #endif
1375
1376 /* Allocate fields for structs, unions and enums in this size.  */
1377 #ifndef DW_FIELD_ALLOC_CHUNK
1378 #define DW_FIELD_ALLOC_CHUNK 4
1379 #endif
1380
1381 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1382    but this would require a corresponding change in unpack_field_as_long
1383    and friends.  */
1384 static int bits_per_byte = 8;
1385
1386 /* When reading a variant or variant part, we track a bit more
1387    information about the field, and store it in an object of this
1388    type.  */
1389
1390 struct variant_field
1391 {
1392   /* If we see a DW_TAG_variant, then this will be the discriminant
1393      value.  */
1394   ULONGEST discriminant_value;
1395   /* If we see a DW_TAG_variant, then this will be set if this is the
1396      default branch.  */
1397   bool default_branch;
1398   /* While reading a DW_TAG_variant_part, this will be set if this
1399      field is the discriminant.  */
1400   bool is_discriminant;
1401 };
1402
1403 struct nextfield
1404 {
1405   int accessibility = 0;
1406   int virtuality = 0;
1407   /* Extra information to describe a variant or variant part.  */
1408   struct variant_field variant {};
1409   struct field field {};
1410 };
1411
1412 struct fnfieldlist
1413 {
1414   const char *name = nullptr;
1415   std::vector<struct fn_field> fnfields;
1416 };
1417
1418 /* The routines that read and process dies for a C struct or C++ class
1419    pass lists of data member fields and lists of member function fields
1420    in an instance of a field_info structure, as defined below.  */
1421 struct field_info
1422   {
1423     /* List of data member and baseclasses fields.  */
1424     std::vector<struct nextfield> fields;
1425     std::vector<struct nextfield> baseclasses;
1426
1427     /* Number of fields (including baseclasses).  */
1428     int nfields = 0;
1429
1430     /* Set if the accesibility of one of the fields is not public.  */
1431     int non_public_fields = 0;
1432
1433     /* Member function fieldlist array, contains name of possibly overloaded
1434        member function, number of overloaded member functions and a pointer
1435        to the head of the member function field chain.  */
1436     std::vector<struct fnfieldlist> fnfieldlists;
1437
1438     /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head of
1439        a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
1440     std::vector<struct decl_field> typedef_field_list;
1441
1442     /* Nested types defined by this class and the number of elements in this
1443        list.  */
1444     std::vector<struct decl_field> nested_types_list;
1445   };
1446
1447 /* One item on the queue of compilation units to read in full symbols
1448    for.  */
1449 struct dwarf2_queue_item
1450 {
1451   struct dwarf2_per_cu_data *per_cu;
1452   enum language pretend_language;
1453   struct dwarf2_queue_item *next;
1454 };
1455
1456 /* The current queue.  */
1457 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1458
1459 /* Loaded secondary compilation units are kept in memory until they
1460    have not been referenced for the processing of this many
1461    compilation units.  Set this to zero to disable caching.  Cache
1462    sizes of up to at least twenty will improve startup time for
1463    typical inter-CU-reference binaries, at an obvious memory cost.  */
1464 static int dwarf_max_cache_age = 5;
1465 static void
1466 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1467                           struct cmd_list_element *c, const char *value)
1468 {
1469   fprintf_filtered (file, _("The upper bound on the age of cached "
1470                             "DWARF compilation units is %s.\n"),
1471                     value);
1472 }
1473 \f
1474 /* local function prototypes */
1475
1476 static const char *get_section_name (const struct dwarf2_section_info *);
1477
1478 static const char *get_section_file_name (const struct dwarf2_section_info *);
1479
1480 static void dwarf2_find_base_address (struct die_info *die,
1481                                       struct dwarf2_cu *cu);
1482
1483 static struct partial_symtab *create_partial_symtab
1484   (struct dwarf2_per_cu_data *per_cu, const char *name);
1485
1486 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1487                                         const gdb_byte *info_ptr,
1488                                         struct die_info *type_unit_die,
1489                                         int has_children, void *data);
1490
1491 static void dwarf2_build_psymtabs_hard
1492   (struct dwarf2_per_objfile *dwarf2_per_objfile);
1493
1494 static void scan_partial_symbols (struct partial_die_info *,
1495                                   CORE_ADDR *, CORE_ADDR *,
1496                                   int, struct dwarf2_cu *);
1497
1498 static void add_partial_symbol (struct partial_die_info *,
1499                                 struct dwarf2_cu *);
1500
1501 static void add_partial_namespace (struct partial_die_info *pdi,
1502                                    CORE_ADDR *lowpc, CORE_ADDR *highpc,
1503                                    int set_addrmap, struct dwarf2_cu *cu);
1504
1505 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1506                                 CORE_ADDR *highpc, int set_addrmap,
1507                                 struct dwarf2_cu *cu);
1508
1509 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1510                                      struct dwarf2_cu *cu);
1511
1512 static void add_partial_subprogram (struct partial_die_info *pdi,
1513                                     CORE_ADDR *lowpc, CORE_ADDR *highpc,
1514                                     int need_pc, struct dwarf2_cu *cu);
1515
1516 static void dwarf2_read_symtab (struct partial_symtab *,
1517                                 struct objfile *);
1518
1519 static void psymtab_to_symtab_1 (struct partial_symtab *);
1520
1521 static abbrev_table_up abbrev_table_read_table
1522   (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1523    sect_offset);
1524
1525 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1526
1527 static struct partial_die_info *load_partial_dies
1528   (const struct die_reader_specs *, const gdb_byte *, int);
1529
1530 static struct partial_die_info *find_partial_die (sect_offset, int,
1531                                                   struct dwarf2_cu *);
1532
1533 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1534                                        struct attribute *, struct attr_abbrev *,
1535                                        const gdb_byte *);
1536
1537 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1538
1539 static int read_1_signed_byte (bfd *, const gdb_byte *);
1540
1541 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1542
1543 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1544
1545 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1546
1547 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1548                                unsigned int *);
1549
1550 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1551
1552 static LONGEST read_checked_initial_length_and_offset
1553   (bfd *, const gdb_byte *, const struct comp_unit_head *,
1554    unsigned int *, unsigned int *);
1555
1556 static LONGEST read_offset (bfd *, const gdb_byte *,
1557                             const struct comp_unit_head *,
1558                             unsigned int *);
1559
1560 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1561
1562 static sect_offset read_abbrev_offset
1563   (struct dwarf2_per_objfile *dwarf2_per_objfile,
1564    struct dwarf2_section_info *, sect_offset);
1565
1566 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1567
1568 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1569
1570 static const char *read_indirect_string
1571   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1572    const struct comp_unit_head *, unsigned int *);
1573
1574 static const char *read_indirect_line_string
1575   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1576    const struct comp_unit_head *, unsigned int *);
1577
1578 static const char *read_indirect_string_at_offset
1579   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1580    LONGEST str_offset);
1581
1582 static const char *read_indirect_string_from_dwz
1583   (struct objfile *objfile, struct dwz_file *, LONGEST);
1584
1585 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1586
1587 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1588                                               const gdb_byte *,
1589                                               unsigned int *);
1590
1591 static const char *read_str_index (const struct die_reader_specs *reader,
1592                                    ULONGEST str_index);
1593
1594 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1595
1596 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1597                                       struct dwarf2_cu *);
1598
1599 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1600                                                 unsigned int);
1601
1602 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1603                                        struct dwarf2_cu *cu);
1604
1605 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1606                                struct dwarf2_cu *cu);
1607
1608 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1609
1610 static struct die_info *die_specification (struct die_info *die,
1611                                            struct dwarf2_cu **);
1612
1613 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1614                                                 struct dwarf2_cu *cu);
1615
1616 static void dwarf_decode_lines (struct line_header *, const char *,
1617                                 struct dwarf2_cu *, struct partial_symtab *,
1618                                 CORE_ADDR, int decode_mapping);
1619
1620 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1621                                   const char *);
1622
1623 static struct symbol *new_symbol (struct die_info *, struct type *,
1624                                   struct dwarf2_cu *, struct symbol * = NULL);
1625
1626 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1627                                 struct dwarf2_cu *);
1628
1629 static void dwarf2_const_value_attr (const struct attribute *attr,
1630                                      struct type *type,
1631                                      const char *name,
1632                                      struct obstack *obstack,
1633                                      struct dwarf2_cu *cu, LONGEST *value,
1634                                      const gdb_byte **bytes,
1635                                      struct dwarf2_locexpr_baton **baton);
1636
1637 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1638
1639 static int need_gnat_info (struct dwarf2_cu *);
1640
1641 static struct type *die_descriptive_type (struct die_info *,
1642                                           struct dwarf2_cu *);
1643
1644 static void set_descriptive_type (struct type *, struct die_info *,
1645                                   struct dwarf2_cu *);
1646
1647 static struct type *die_containing_type (struct die_info *,
1648                                          struct dwarf2_cu *);
1649
1650 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1651                                      struct dwarf2_cu *);
1652
1653 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1654
1655 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1656
1657 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1658
1659 static char *typename_concat (struct obstack *obs, const char *prefix,
1660                               const char *suffix, int physname,
1661                               struct dwarf2_cu *cu);
1662
1663 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1664
1665 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1666
1667 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1668
1669 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1670
1671 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1672
1673 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1674
1675 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1676                                struct dwarf2_cu *, struct partial_symtab *);
1677
1678 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1679    values.  Keep the items ordered with increasing constraints compliance.  */
1680 enum pc_bounds_kind
1681 {
1682   /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found.  */
1683   PC_BOUNDS_NOT_PRESENT,
1684
1685   /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1686      were present but they do not form a valid range of PC addresses.  */
1687   PC_BOUNDS_INVALID,
1688
1689   /* Discontiguous range was found - that is DW_AT_ranges was found.  */
1690   PC_BOUNDS_RANGES,
1691
1692   /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found.  */
1693   PC_BOUNDS_HIGH_LOW,
1694 };
1695
1696 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1697                                                  CORE_ADDR *, CORE_ADDR *,
1698                                                  struct dwarf2_cu *,
1699                                                  struct partial_symtab *);
1700
1701 static void get_scope_pc_bounds (struct die_info *,
1702                                  CORE_ADDR *, CORE_ADDR *,
1703                                  struct dwarf2_cu *);
1704
1705 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1706                                         CORE_ADDR, struct dwarf2_cu *);
1707
1708 static void dwarf2_add_field (struct field_info *, struct die_info *,
1709                               struct dwarf2_cu *);
1710
1711 static void dwarf2_attach_fields_to_type (struct field_info *,
1712                                           struct type *, struct dwarf2_cu *);
1713
1714 static void dwarf2_add_member_fn (struct field_info *,
1715                                   struct die_info *, struct type *,
1716                                   struct dwarf2_cu *);
1717
1718 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1719                                              struct type *,
1720                                              struct dwarf2_cu *);
1721
1722 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1723
1724 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1725
1726 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1727
1728 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1729
1730 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1731
1732 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1733
1734 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1735
1736 static struct type *read_module_type (struct die_info *die,
1737                                       struct dwarf2_cu *cu);
1738
1739 static const char *namespace_name (struct die_info *die,
1740                                    int *is_anonymous, struct dwarf2_cu *);
1741
1742 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1743
1744 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1745
1746 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1747                                                        struct dwarf2_cu *);
1748
1749 static struct die_info *read_die_and_siblings_1
1750   (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1751    struct die_info *);
1752
1753 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1754                                                const gdb_byte *info_ptr,
1755                                                const gdb_byte **new_info_ptr,
1756                                                struct die_info *parent);
1757
1758 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1759                                         struct die_info **, const gdb_byte *,
1760                                         int *, int);
1761
1762 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1763                                       struct die_info **, const gdb_byte *,
1764                                       int *);
1765
1766 static void process_die (struct die_info *, struct dwarf2_cu *);
1767
1768 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1769                                              struct obstack *);
1770
1771 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1772
1773 static const char *dwarf2_full_name (const char *name,
1774                                      struct die_info *die,
1775                                      struct dwarf2_cu *cu);
1776
1777 static const char *dwarf2_physname (const char *name, struct die_info *die,
1778                                     struct dwarf2_cu *cu);
1779
1780 static struct die_info *dwarf2_extension (struct die_info *die,
1781                                           struct dwarf2_cu **);
1782
1783 static const char *dwarf_tag_name (unsigned int);
1784
1785 static const char *dwarf_attr_name (unsigned int);
1786
1787 static const char *dwarf_form_name (unsigned int);
1788
1789 static const char *dwarf_bool_name (unsigned int);
1790
1791 static const char *dwarf_type_encoding_name (unsigned int);
1792
1793 static struct die_info *sibling_die (struct die_info *);
1794
1795 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1796
1797 static void dump_die_for_error (struct die_info *);
1798
1799 static void dump_die_1 (struct ui_file *, int level, int max_level,
1800                         struct die_info *);
1801
1802 /*static*/ void dump_die (struct die_info *, int max_level);
1803
1804 static void store_in_ref_table (struct die_info *,
1805                                 struct dwarf2_cu *);
1806
1807 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1808
1809 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1810
1811 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1812                                                const struct attribute *,
1813                                                struct dwarf2_cu **);
1814
1815 static struct die_info *follow_die_ref (struct die_info *,
1816                                         const struct attribute *,
1817                                         struct dwarf2_cu **);
1818
1819 static struct die_info *follow_die_sig (struct die_info *,
1820                                         const struct attribute *,
1821                                         struct dwarf2_cu **);
1822
1823 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1824                                          struct dwarf2_cu *);
1825
1826 static struct type *get_DW_AT_signature_type (struct die_info *,
1827                                               const struct attribute *,
1828                                               struct dwarf2_cu *);
1829
1830 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1831
1832 static void read_signatured_type (struct signatured_type *);
1833
1834 static int attr_to_dynamic_prop (const struct attribute *attr,
1835                                  struct die_info *die, struct dwarf2_cu *cu,
1836                                  struct dynamic_prop *prop);
1837
1838 /* memory allocation interface */
1839
1840 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1841
1842 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1843
1844 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1845
1846 static int attr_form_is_block (const struct attribute *);
1847
1848 static int attr_form_is_section_offset (const struct attribute *);
1849
1850 static int attr_form_is_constant (const struct attribute *);
1851
1852 static int attr_form_is_ref (const struct attribute *);
1853
1854 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1855                                    struct dwarf2_loclist_baton *baton,
1856                                    const struct attribute *attr);
1857
1858 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1859                                          struct symbol *sym,
1860                                          struct dwarf2_cu *cu,
1861                                          int is_block);
1862
1863 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1864                                      const gdb_byte *info_ptr,
1865                                      struct abbrev_info *abbrev);
1866
1867 static hashval_t partial_die_hash (const void *item);
1868
1869 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1870
1871 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1872   (sect_offset sect_off, unsigned int offset_in_dwz,
1873    struct dwarf2_per_objfile *dwarf2_per_objfile);
1874
1875 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1876                                    struct die_info *comp_unit_die,
1877                                    enum language pretend_language);
1878
1879 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1880
1881 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1882
1883 static struct type *set_die_type (struct die_info *, struct type *,
1884                                   struct dwarf2_cu *);
1885
1886 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1887
1888 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1889
1890 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1891                                  enum language);
1892
1893 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1894                                     enum language);
1895
1896 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1897                                     enum language);
1898
1899 static void dwarf2_add_dependence (struct dwarf2_cu *,
1900                                    struct dwarf2_per_cu_data *);
1901
1902 static void dwarf2_mark (struct dwarf2_cu *);
1903
1904 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1905
1906 static struct type *get_die_type_at_offset (sect_offset,
1907                                             struct dwarf2_per_cu_data *);
1908
1909 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1910
1911 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1912                              enum language pretend_language);
1913
1914 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1915
1916 /* Class, the destructor of which frees all allocated queue entries.  This
1917    will only have work to do if an error was thrown while processing the
1918    dwarf.  If no error was thrown then the queue entries should have all
1919    been processed, and freed, as we went along.  */
1920
1921 class dwarf2_queue_guard
1922 {
1923 public:
1924   dwarf2_queue_guard () = default;
1925
1926   /* Free any entries remaining on the queue.  There should only be
1927      entries left if we hit an error while processing the dwarf.  */
1928   ~dwarf2_queue_guard ()
1929   {
1930     struct dwarf2_queue_item *item, *last;
1931
1932     item = dwarf2_queue;
1933     while (item)
1934       {
1935         /* Anything still marked queued is likely to be in an
1936            inconsistent state, so discard it.  */
1937         if (item->per_cu->queued)
1938           {
1939             if (item->per_cu->cu != NULL)
1940               free_one_cached_comp_unit (item->per_cu);
1941             item->per_cu->queued = 0;
1942           }
1943
1944         last = item;
1945         item = item->next;
1946         xfree (last);
1947       }
1948
1949     dwarf2_queue = dwarf2_queue_tail = NULL;
1950   }
1951 };
1952
1953 /* The return type of find_file_and_directory.  Note, the enclosed
1954    string pointers are only valid while this object is valid.  */
1955
1956 struct file_and_directory
1957 {
1958   /* The filename.  This is never NULL.  */
1959   const char *name;
1960
1961   /* The compilation directory.  NULL if not known.  If we needed to
1962      compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1963      points directly to the DW_AT_comp_dir string attribute owned by
1964      the obstack that owns the DIE.  */
1965   const char *comp_dir;
1966
1967   /* If we needed to build a new string for comp_dir, this is what
1968      owns the storage.  */
1969   std::string comp_dir_storage;
1970 };
1971
1972 static file_and_directory find_file_and_directory (struct die_info *die,
1973                                                    struct dwarf2_cu *cu);
1974
1975 static char *file_full_name (int file, struct line_header *lh,
1976                              const char *comp_dir);
1977
1978 /* Expected enum dwarf_unit_type for read_comp_unit_head.  */
1979 enum class rcuh_kind { COMPILE, TYPE };
1980
1981 static const gdb_byte *read_and_check_comp_unit_head
1982   (struct dwarf2_per_objfile* dwarf2_per_objfile,
1983    struct comp_unit_head *header,
1984    struct dwarf2_section_info *section,
1985    struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1986    rcuh_kind section_kind);
1987
1988 static void init_cutu_and_read_dies
1989   (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1990    int use_existing_cu, int keep, bool skip_partial,
1991    die_reader_func_ftype *die_reader_func, void *data);
1992
1993 static void init_cutu_and_read_dies_simple
1994   (struct dwarf2_per_cu_data *this_cu,
1995    die_reader_func_ftype *die_reader_func, void *data);
1996
1997 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1998
1999 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
2000
2001 static struct dwo_unit *lookup_dwo_unit_in_dwp
2002   (struct dwarf2_per_objfile *dwarf2_per_objfile,
2003    struct dwp_file *dwp_file, const char *comp_dir,
2004    ULONGEST signature, int is_debug_types);
2005
2006 static struct dwp_file *get_dwp_file
2007   (struct dwarf2_per_objfile *dwarf2_per_objfile);
2008
2009 static struct dwo_unit *lookup_dwo_comp_unit
2010   (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
2011
2012 static struct dwo_unit *lookup_dwo_type_unit
2013   (struct signatured_type *, const char *, const char *);
2014
2015 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
2016
2017 static void free_dwo_file (struct dwo_file *);
2018
2019 /* A unique_ptr helper to free a dwo_file.  */
2020
2021 struct dwo_file_deleter
2022 {
2023   void operator() (struct dwo_file *df) const
2024   {
2025     free_dwo_file (df);
2026   }
2027 };
2028
2029 /* A unique pointer to a dwo_file.  */
2030
2031 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2032
2033 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2034
2035 static void check_producer (struct dwarf2_cu *cu);
2036
2037 static void free_line_header_voidp (void *arg);
2038 \f
2039 /* Various complaints about symbol reading that don't abort the process.  */
2040
2041 static void
2042 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2043 {
2044   complaint (_("statement list doesn't fit in .debug_line section"));
2045 }
2046
2047 static void
2048 dwarf2_debug_line_missing_file_complaint (void)
2049 {
2050   complaint (_(".debug_line section has line data without a file"));
2051 }
2052
2053 static void
2054 dwarf2_debug_line_missing_end_sequence_complaint (void)
2055 {
2056   complaint (_(".debug_line section has line "
2057                "program sequence without an end"));
2058 }
2059
2060 static void
2061 dwarf2_complex_location_expr_complaint (void)
2062 {
2063   complaint (_("location expression too complex"));
2064 }
2065
2066 static void
2067 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2068                                               int arg3)
2069 {
2070   complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2071              arg1, arg2, arg3);
2072 }
2073
2074 static void
2075 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2076 {
2077   complaint (_("debug info runs off end of %s section"
2078                " [in module %s]"),
2079              get_section_name (section),
2080              get_section_file_name (section));
2081 }
2082
2083 static void
2084 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2085 {
2086   complaint (_("macro debug info contains a "
2087                "malformed macro definition:\n`%s'"),
2088              arg1);
2089 }
2090
2091 static void
2092 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2093 {
2094   complaint (_("invalid attribute class or form for '%s' in '%s'"),
2095              arg1, arg2);
2096 }
2097
2098 /* Hash function for line_header_hash.  */
2099
2100 static hashval_t
2101 line_header_hash (const struct line_header *ofs)
2102 {
2103   return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2104 }
2105
2106 /* Hash function for htab_create_alloc_ex for line_header_hash.  */
2107
2108 static hashval_t
2109 line_header_hash_voidp (const void *item)
2110 {
2111   const struct line_header *ofs = (const struct line_header *) item;
2112
2113   return line_header_hash (ofs);
2114 }
2115
2116 /* Equality function for line_header_hash.  */
2117
2118 static int
2119 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2120 {
2121   const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2122   const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2123
2124   return (ofs_lhs->sect_off == ofs_rhs->sect_off
2125           && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2126 }
2127
2128 \f
2129
2130 /* Read the given attribute value as an address, taking the attribute's
2131    form into account.  */
2132
2133 static CORE_ADDR
2134 attr_value_as_address (struct attribute *attr)
2135 {
2136   CORE_ADDR addr;
2137
2138   if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2139     {
2140       /* Aside from a few clearly defined exceptions, attributes that
2141          contain an address must always be in DW_FORM_addr form.
2142          Unfortunately, some compilers happen to be violating this
2143          requirement by encoding addresses using other forms, such
2144          as DW_FORM_data4 for example.  For those broken compilers,
2145          we try to do our best, without any guarantee of success,
2146          to interpret the address correctly.  It would also be nice
2147          to generate a complaint, but that would require us to maintain
2148          a list of legitimate cases where a non-address form is allowed,
2149          as well as update callers to pass in at least the CU's DWARF
2150          version.  This is more overhead than what we're willing to
2151          expand for a pretty rare case.  */
2152       addr = DW_UNSND (attr);
2153     }
2154   else
2155     addr = DW_ADDR (attr);
2156
2157   return addr;
2158 }
2159
2160 /* See declaration.  */
2161
2162 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2163                                         const dwarf2_debug_sections *names)
2164   : objfile (objfile_)
2165 {
2166   if (names == NULL)
2167     names = &dwarf2_elf_names;
2168
2169   bfd *obfd = objfile->obfd;
2170
2171   for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2172     locate_sections (obfd, sec, *names);
2173 }
2174
2175 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2176
2177 dwarf2_per_objfile::~dwarf2_per_objfile ()
2178 {
2179   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
2180   free_cached_comp_units ();
2181
2182   if (quick_file_names_table)
2183     htab_delete (quick_file_names_table);
2184
2185   if (line_header_hash)
2186     htab_delete (line_header_hash);
2187
2188   for (dwarf2_per_cu_data *per_cu : all_comp_units)
2189     VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2190
2191   for (signatured_type *sig_type : all_type_units)
2192     VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2193
2194   VEC_free (dwarf2_section_info_def, types);
2195
2196   if (dwo_files != NULL)
2197     free_dwo_files (dwo_files, objfile);
2198
2199   /* Everything else should be on the objfile obstack.  */
2200 }
2201
2202 /* See declaration.  */
2203
2204 void
2205 dwarf2_per_objfile::free_cached_comp_units ()
2206 {
2207   dwarf2_per_cu_data *per_cu = read_in_chain;
2208   dwarf2_per_cu_data **last_chain = &read_in_chain;
2209   while (per_cu != NULL)
2210     {
2211       dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2212
2213       delete per_cu->cu;
2214       *last_chain = next_cu;
2215       per_cu = next_cu;
2216     }
2217 }
2218
2219 /* A helper class that calls free_cached_comp_units on
2220    destruction.  */
2221
2222 class free_cached_comp_units
2223 {
2224 public:
2225
2226   explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2227     : m_per_objfile (per_objfile)
2228   {
2229   }
2230
2231   ~free_cached_comp_units ()
2232   {
2233     m_per_objfile->free_cached_comp_units ();
2234   }
2235
2236   DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2237
2238 private:
2239
2240   dwarf2_per_objfile *m_per_objfile;
2241 };
2242
2243 /* Try to locate the sections we need for DWARF 2 debugging
2244    information and return true if we have enough to do something.
2245    NAMES points to the dwarf2 section names, or is NULL if the standard
2246    ELF names are used.  */
2247
2248 int
2249 dwarf2_has_info (struct objfile *objfile,
2250                  const struct dwarf2_debug_sections *names)
2251 {
2252   if (objfile->flags & OBJF_READNEVER)
2253     return 0;
2254
2255   struct dwarf2_per_objfile *dwarf2_per_objfile
2256     = get_dwarf2_per_objfile (objfile);
2257
2258   if (dwarf2_per_objfile == NULL)
2259     {
2260       /* Initialize per-objfile state.  */
2261       dwarf2_per_objfile
2262         = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2263                                                                      names);
2264       set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2265     }
2266   return (!dwarf2_per_objfile->info.is_virtual
2267           && dwarf2_per_objfile->info.s.section != NULL
2268           && !dwarf2_per_objfile->abbrev.is_virtual
2269           && dwarf2_per_objfile->abbrev.s.section != NULL);
2270 }
2271
2272 /* Return the containing section of virtual section SECTION.  */
2273
2274 static struct dwarf2_section_info *
2275 get_containing_section (const struct dwarf2_section_info *section)
2276 {
2277   gdb_assert (section->is_virtual);
2278   return section->s.containing_section;
2279 }
2280
2281 /* Return the bfd owner of SECTION.  */
2282
2283 static struct bfd *
2284 get_section_bfd_owner (const struct dwarf2_section_info *section)
2285 {
2286   if (section->is_virtual)
2287     {
2288       section = get_containing_section (section);
2289       gdb_assert (!section->is_virtual);
2290     }
2291   return section->s.section->owner;
2292 }
2293
2294 /* Return the bfd section of SECTION.
2295    Returns NULL if the section is not present.  */
2296
2297 static asection *
2298 get_section_bfd_section (const struct dwarf2_section_info *section)
2299 {
2300   if (section->is_virtual)
2301     {
2302       section = get_containing_section (section);
2303       gdb_assert (!section->is_virtual);
2304     }
2305   return section->s.section;
2306 }
2307
2308 /* Return the name of SECTION.  */
2309
2310 static const char *
2311 get_section_name (const struct dwarf2_section_info *section)
2312 {
2313   asection *sectp = get_section_bfd_section (section);
2314
2315   gdb_assert (sectp != NULL);
2316   return bfd_section_name (get_section_bfd_owner (section), sectp);
2317 }
2318
2319 /* Return the name of the file SECTION is in.  */
2320
2321 static const char *
2322 get_section_file_name (const struct dwarf2_section_info *section)
2323 {
2324   bfd *abfd = get_section_bfd_owner (section);
2325
2326   return bfd_get_filename (abfd);
2327 }
2328
2329 /* Return the id of SECTION.
2330    Returns 0 if SECTION doesn't exist.  */
2331
2332 static int
2333 get_section_id (const struct dwarf2_section_info *section)
2334 {
2335   asection *sectp = get_section_bfd_section (section);
2336
2337   if (sectp == NULL)
2338     return 0;
2339   return sectp->id;
2340 }
2341
2342 /* Return the flags of SECTION.
2343    SECTION (or containing section if this is a virtual section) must exist.  */
2344
2345 static int
2346 get_section_flags (const struct dwarf2_section_info *section)
2347 {
2348   asection *sectp = get_section_bfd_section (section);
2349
2350   gdb_assert (sectp != NULL);
2351   return bfd_get_section_flags (sectp->owner, sectp);
2352 }
2353
2354 /* When loading sections, we look either for uncompressed section or for
2355    compressed section names.  */
2356
2357 static int
2358 section_is_p (const char *section_name,
2359               const struct dwarf2_section_names *names)
2360 {
2361   if (names->normal != NULL
2362       && strcmp (section_name, names->normal) == 0)
2363     return 1;
2364   if (names->compressed != NULL
2365       && strcmp (section_name, names->compressed) == 0)
2366     return 1;
2367   return 0;
2368 }
2369
2370 /* See declaration.  */
2371
2372 void
2373 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2374                                      const dwarf2_debug_sections &names)
2375 {
2376   flagword aflag = bfd_get_section_flags (abfd, sectp);
2377
2378   if ((aflag & SEC_HAS_CONTENTS) == 0)
2379     {
2380     }
2381   else if (section_is_p (sectp->name, &names.info))
2382     {
2383       this->info.s.section = sectp;
2384       this->info.size = bfd_get_section_size (sectp);
2385     }
2386   else if (section_is_p (sectp->name, &names.abbrev))
2387     {
2388       this->abbrev.s.section = sectp;
2389       this->abbrev.size = bfd_get_section_size (sectp);
2390     }
2391   else if (section_is_p (sectp->name, &names.line))
2392     {
2393       this->line.s.section = sectp;
2394       this->line.size = bfd_get_section_size (sectp);
2395     }
2396   else if (section_is_p (sectp->name, &names.loc))
2397     {
2398       this->loc.s.section = sectp;
2399       this->loc.size = bfd_get_section_size (sectp);
2400     }
2401   else if (section_is_p (sectp->name, &names.loclists))
2402     {
2403       this->loclists.s.section = sectp;
2404       this->loclists.size = bfd_get_section_size (sectp);
2405     }
2406   else if (section_is_p (sectp->name, &names.macinfo))
2407     {
2408       this->macinfo.s.section = sectp;
2409       this->macinfo.size = bfd_get_section_size (sectp);
2410     }
2411   else if (section_is_p (sectp->name, &names.macro))
2412     {
2413       this->macro.s.section = sectp;
2414       this->macro.size = bfd_get_section_size (sectp);
2415     }
2416   else if (section_is_p (sectp->name, &names.str))
2417     {
2418       this->str.s.section = sectp;
2419       this->str.size = bfd_get_section_size (sectp);
2420     }
2421   else if (section_is_p (sectp->name, &names.line_str))
2422     {
2423       this->line_str.s.section = sectp;
2424       this->line_str.size = bfd_get_section_size (sectp);
2425     }
2426   else if (section_is_p (sectp->name, &names.addr))
2427     {
2428       this->addr.s.section = sectp;
2429       this->addr.size = bfd_get_section_size (sectp);
2430     }
2431   else if (section_is_p (sectp->name, &names.frame))
2432     {
2433       this->frame.s.section = sectp;
2434       this->frame.size = bfd_get_section_size (sectp);
2435     }
2436   else if (section_is_p (sectp->name, &names.eh_frame))
2437     {
2438       this->eh_frame.s.section = sectp;
2439       this->eh_frame.size = bfd_get_section_size (sectp);
2440     }
2441   else if (section_is_p (sectp->name, &names.ranges))
2442     {
2443       this->ranges.s.section = sectp;
2444       this->ranges.size = bfd_get_section_size (sectp);
2445     }
2446   else if (section_is_p (sectp->name, &names.rnglists))
2447     {
2448       this->rnglists.s.section = sectp;
2449       this->rnglists.size = bfd_get_section_size (sectp);
2450     }
2451   else if (section_is_p (sectp->name, &names.types))
2452     {
2453       struct dwarf2_section_info type_section;
2454
2455       memset (&type_section, 0, sizeof (type_section));
2456       type_section.s.section = sectp;
2457       type_section.size = bfd_get_section_size (sectp);
2458
2459       VEC_safe_push (dwarf2_section_info_def, this->types,
2460                      &type_section);
2461     }
2462   else if (section_is_p (sectp->name, &names.gdb_index))
2463     {
2464       this->gdb_index.s.section = sectp;
2465       this->gdb_index.size = bfd_get_section_size (sectp);
2466     }
2467   else if (section_is_p (sectp->name, &names.debug_names))
2468     {
2469       this->debug_names.s.section = sectp;
2470       this->debug_names.size = bfd_get_section_size (sectp);
2471     }
2472   else if (section_is_p (sectp->name, &names.debug_aranges))
2473     {
2474       this->debug_aranges.s.section = sectp;
2475       this->debug_aranges.size = bfd_get_section_size (sectp);
2476     }
2477
2478   if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2479       && bfd_section_vma (abfd, sectp) == 0)
2480     this->has_section_at_zero = true;
2481 }
2482
2483 /* A helper function that decides whether a section is empty,
2484    or not present.  */
2485
2486 static int
2487 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2488 {
2489   if (section->is_virtual)
2490     return section->size == 0;
2491   return section->s.section == NULL || section->size == 0;
2492 }
2493
2494 /* See dwarf2read.h.  */
2495
2496 void
2497 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2498 {
2499   asection *sectp;
2500   bfd *abfd;
2501   gdb_byte *buf, *retbuf;
2502
2503   if (info->readin)
2504     return;
2505   info->buffer = NULL;
2506   info->readin = 1;
2507
2508   if (dwarf2_section_empty_p (info))
2509     return;
2510
2511   sectp = get_section_bfd_section (info);
2512
2513   /* If this is a virtual section we need to read in the real one first.  */
2514   if (info->is_virtual)
2515     {
2516       struct dwarf2_section_info *containing_section =
2517         get_containing_section (info);
2518
2519       gdb_assert (sectp != NULL);
2520       if ((sectp->flags & SEC_RELOC) != 0)
2521         {
2522           error (_("Dwarf Error: DWP format V2 with relocations is not"
2523                    " supported in section %s [in module %s]"),
2524                  get_section_name (info), get_section_file_name (info));
2525         }
2526       dwarf2_read_section (objfile, containing_section);
2527       /* Other code should have already caught virtual sections that don't
2528          fit.  */
2529       gdb_assert (info->virtual_offset + info->size
2530                   <= containing_section->size);
2531       /* If the real section is empty or there was a problem reading the
2532          section we shouldn't get here.  */
2533       gdb_assert (containing_section->buffer != NULL);
2534       info->buffer = containing_section->buffer + info->virtual_offset;
2535       return;
2536     }
2537
2538   /* If the section has relocations, we must read it ourselves.
2539      Otherwise we attach it to the BFD.  */
2540   if ((sectp->flags & SEC_RELOC) == 0)
2541     {
2542       info->buffer = gdb_bfd_map_section (sectp, &info->size);
2543       return;
2544     }
2545
2546   buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2547   info->buffer = buf;
2548
2549   /* When debugging .o files, we may need to apply relocations; see
2550      http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2551      We never compress sections in .o files, so we only need to
2552      try this when the section is not compressed.  */
2553   retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2554   if (retbuf != NULL)
2555     {
2556       info->buffer = retbuf;
2557       return;
2558     }
2559
2560   abfd = get_section_bfd_owner (info);
2561   gdb_assert (abfd != NULL);
2562
2563   if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2564       || bfd_bread (buf, info->size, abfd) != info->size)
2565     {
2566       error (_("Dwarf Error: Can't read DWARF data"
2567                " in section %s [in module %s]"),
2568              bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2569     }
2570 }
2571
2572 /* A helper function that returns the size of a section in a safe way.
2573    If you are positive that the section has been read before using the
2574    size, then it is safe to refer to the dwarf2_section_info object's
2575    "size" field directly.  In other cases, you must call this
2576    function, because for compressed sections the size field is not set
2577    correctly until the section has been read.  */
2578
2579 static bfd_size_type
2580 dwarf2_section_size (struct objfile *objfile,
2581                      struct dwarf2_section_info *info)
2582 {
2583   if (!info->readin)
2584     dwarf2_read_section (objfile, info);
2585   return info->size;
2586 }
2587
2588 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2589    SECTION_NAME.  */
2590
2591 void
2592 dwarf2_get_section_info (struct objfile *objfile,
2593                          enum dwarf2_section_enum sect,
2594                          asection **sectp, const gdb_byte **bufp,
2595                          bfd_size_type *sizep)
2596 {
2597   struct dwarf2_per_objfile *data
2598     = (struct dwarf2_per_objfile *) objfile_data (objfile,
2599                                                   dwarf2_objfile_data_key);
2600   struct dwarf2_section_info *info;
2601
2602   /* We may see an objfile without any DWARF, in which case we just
2603      return nothing.  */
2604   if (data == NULL)
2605     {
2606       *sectp = NULL;
2607       *bufp = NULL;
2608       *sizep = 0;
2609       return;
2610     }
2611   switch (sect)
2612     {
2613     case DWARF2_DEBUG_FRAME:
2614       info = &data->frame;
2615       break;
2616     case DWARF2_EH_FRAME:
2617       info = &data->eh_frame;
2618       break;
2619     default:
2620       gdb_assert_not_reached ("unexpected section");
2621     }
2622
2623   dwarf2_read_section (objfile, info);
2624
2625   *sectp = get_section_bfd_section (info);
2626   *bufp = info->buffer;
2627   *sizep = info->size;
2628 }
2629
2630 /* A helper function to find the sections for a .dwz file.  */
2631
2632 static void
2633 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2634 {
2635   struct dwz_file *dwz_file = (struct dwz_file *) arg;
2636
2637   /* Note that we only support the standard ELF names, because .dwz
2638      is ELF-only (at the time of writing).  */
2639   if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2640     {
2641       dwz_file->abbrev.s.section = sectp;
2642       dwz_file->abbrev.size = bfd_get_section_size (sectp);
2643     }
2644   else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2645     {
2646       dwz_file->info.s.section = sectp;
2647       dwz_file->info.size = bfd_get_section_size (sectp);
2648     }
2649   else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2650     {
2651       dwz_file->str.s.section = sectp;
2652       dwz_file->str.size = bfd_get_section_size (sectp);
2653     }
2654   else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2655     {
2656       dwz_file->line.s.section = sectp;
2657       dwz_file->line.size = bfd_get_section_size (sectp);
2658     }
2659   else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2660     {
2661       dwz_file->macro.s.section = sectp;
2662       dwz_file->macro.size = bfd_get_section_size (sectp);
2663     }
2664   else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2665     {
2666       dwz_file->gdb_index.s.section = sectp;
2667       dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2668     }
2669   else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2670     {
2671       dwz_file->debug_names.s.section = sectp;
2672       dwz_file->debug_names.size = bfd_get_section_size (sectp);
2673     }
2674 }
2675
2676 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
2677    there is no .gnu_debugaltlink section in the file.  Error if there
2678    is such a section but the file cannot be found.  */
2679
2680 static struct dwz_file *
2681 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2682 {
2683   const char *filename;
2684   bfd_size_type buildid_len_arg;
2685   size_t buildid_len;
2686   bfd_byte *buildid;
2687
2688   if (dwarf2_per_objfile->dwz_file != NULL)
2689     return dwarf2_per_objfile->dwz_file.get ();
2690
2691   bfd_set_error (bfd_error_no_error);
2692   gdb::unique_xmalloc_ptr<char> data
2693     (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2694                                   &buildid_len_arg, &buildid));
2695   if (data == NULL)
2696     {
2697       if (bfd_get_error () == bfd_error_no_error)
2698         return NULL;
2699       error (_("could not read '.gnu_debugaltlink' section: %s"),
2700              bfd_errmsg (bfd_get_error ()));
2701     }
2702
2703   gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2704
2705   buildid_len = (size_t) buildid_len_arg;
2706
2707   filename = data.get ();
2708
2709   std::string abs_storage;
2710   if (!IS_ABSOLUTE_PATH (filename))
2711     {
2712       gdb::unique_xmalloc_ptr<char> abs
2713         = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2714
2715       abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2716       filename = abs_storage.c_str ();
2717     }
2718
2719   /* First try the file name given in the section.  If that doesn't
2720      work, try to use the build-id instead.  */
2721   gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2722   if (dwz_bfd != NULL)
2723     {
2724       if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2725         dwz_bfd.reset (nullptr);
2726     }
2727
2728   if (dwz_bfd == NULL)
2729     dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2730
2731   if (dwz_bfd == NULL)
2732     error (_("could not find '.gnu_debugaltlink' file for %s"),
2733            objfile_name (dwarf2_per_objfile->objfile));
2734
2735   std::unique_ptr<struct dwz_file> result
2736     (new struct dwz_file (std::move (dwz_bfd)));
2737
2738   bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2739                          result.get ());
2740
2741   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2742                             result->dwz_bfd.get ());
2743   dwarf2_per_objfile->dwz_file = std::move (result);
2744   return dwarf2_per_objfile->dwz_file.get ();
2745 }
2746 \f
2747 /* DWARF quick_symbols_functions support.  */
2748
2749 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2750    unique line tables, so we maintain a separate table of all .debug_line
2751    derived entries to support the sharing.
2752    All the quick functions need is the list of file names.  We discard the
2753    line_header when we're done and don't need to record it here.  */
2754 struct quick_file_names
2755 {
2756   /* The data used to construct the hash key.  */
2757   struct stmt_list_hash hash;
2758
2759   /* The number of entries in file_names, real_names.  */
2760   unsigned int num_file_names;
2761
2762   /* The file names from the line table, after being run through
2763      file_full_name.  */
2764   const char **file_names;
2765
2766   /* The file names from the line table after being run through
2767      gdb_realpath.  These are computed lazily.  */
2768   const char **real_names;
2769 };
2770
2771 /* When using the index (and thus not using psymtabs), each CU has an
2772    object of this type.  This is used to hold information needed by
2773    the various "quick" methods.  */
2774 struct dwarf2_per_cu_quick_data
2775 {
2776   /* The file table.  This can be NULL if there was no file table
2777      or it's currently not read in.
2778      NOTE: This points into dwarf2_per_objfile->quick_file_names_table.  */
2779   struct quick_file_names *file_names;
2780
2781   /* The corresponding symbol table.  This is NULL if symbols for this
2782      CU have not yet been read.  */
2783   struct compunit_symtab *compunit_symtab;
2784
2785   /* A temporary mark bit used when iterating over all CUs in
2786      expand_symtabs_matching.  */
2787   unsigned int mark : 1;
2788
2789   /* True if we've tried to read the file table and found there isn't one.
2790      There will be no point in trying to read it again next time.  */
2791   unsigned int no_file_data : 1;
2792 };
2793
2794 /* Utility hash function for a stmt_list_hash.  */
2795
2796 static hashval_t
2797 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2798 {
2799   hashval_t v = 0;
2800
2801   if (stmt_list_hash->dwo_unit != NULL)
2802     v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2803   v += to_underlying (stmt_list_hash->line_sect_off);
2804   return v;
2805 }
2806
2807 /* Utility equality function for a stmt_list_hash.  */
2808
2809 static int
2810 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2811                     const struct stmt_list_hash *rhs)
2812 {
2813   if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2814     return 0;
2815   if (lhs->dwo_unit != NULL
2816       && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2817     return 0;
2818
2819   return lhs->line_sect_off == rhs->line_sect_off;
2820 }
2821
2822 /* Hash function for a quick_file_names.  */
2823
2824 static hashval_t
2825 hash_file_name_entry (const void *e)
2826 {
2827   const struct quick_file_names *file_data
2828     = (const struct quick_file_names *) e;
2829
2830   return hash_stmt_list_entry (&file_data->hash);
2831 }
2832
2833 /* Equality function for a quick_file_names.  */
2834
2835 static int
2836 eq_file_name_entry (const void *a, const void *b)
2837 {
2838   const struct quick_file_names *ea = (const struct quick_file_names *) a;
2839   const struct quick_file_names *eb = (const struct quick_file_names *) b;
2840
2841   return eq_stmt_list_entry (&ea->hash, &eb->hash);
2842 }
2843
2844 /* Delete function for a quick_file_names.  */
2845
2846 static void
2847 delete_file_name_entry (void *e)
2848 {
2849   struct quick_file_names *file_data = (struct quick_file_names *) e;
2850   int i;
2851
2852   for (i = 0; i < file_data->num_file_names; ++i)
2853     {
2854       xfree ((void*) file_data->file_names[i]);
2855       if (file_data->real_names)
2856         xfree ((void*) file_data->real_names[i]);
2857     }
2858
2859   /* The space for the struct itself lives on objfile_obstack,
2860      so we don't free it here.  */
2861 }
2862
2863 /* Create a quick_file_names hash table.  */
2864
2865 static htab_t
2866 create_quick_file_names_table (unsigned int nr_initial_entries)
2867 {
2868   return htab_create_alloc (nr_initial_entries,
2869                             hash_file_name_entry, eq_file_name_entry,
2870                             delete_file_name_entry, xcalloc, xfree);
2871 }
2872
2873 /* Read in PER_CU->CU.  This function is unrelated to symtabs, symtab would
2874    have to be created afterwards.  You should call age_cached_comp_units after
2875    processing PER_CU->CU.  dw2_setup must have been already called.  */
2876
2877 static void
2878 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2879 {
2880   if (per_cu->is_debug_types)
2881     load_full_type_unit (per_cu);
2882   else
2883     load_full_comp_unit (per_cu, skip_partial, language_minimal);
2884
2885   if (per_cu->cu == NULL)
2886     return;  /* Dummy CU.  */
2887
2888   dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2889 }
2890
2891 /* Read in the symbols for PER_CU.  */
2892
2893 static void
2894 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2895 {
2896   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2897
2898   /* Skip type_unit_groups, reading the type units they contain
2899      is handled elsewhere.  */
2900   if (IS_TYPE_UNIT_GROUP (per_cu))
2901     return;
2902
2903   /* The destructor of dwarf2_queue_guard frees any entries left on
2904      the queue.  After this point we're guaranteed to leave this function
2905      with the dwarf queue empty.  */
2906   dwarf2_queue_guard q_guard;
2907
2908   if (dwarf2_per_objfile->using_index
2909       ? per_cu->v.quick->compunit_symtab == NULL
2910       : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2911     {
2912       queue_comp_unit (per_cu, language_minimal);
2913       load_cu (per_cu, skip_partial);
2914
2915       /* If we just loaded a CU from a DWO, and we're working with an index
2916          that may badly handle TUs, load all the TUs in that DWO as well.
2917          http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
2918       if (!per_cu->is_debug_types
2919           && per_cu->cu != NULL
2920           && per_cu->cu->dwo_unit != NULL
2921           && dwarf2_per_objfile->index_table != NULL
2922           && dwarf2_per_objfile->index_table->version <= 7
2923           /* DWP files aren't supported yet.  */
2924           && get_dwp_file (dwarf2_per_objfile) == NULL)
2925         queue_and_load_all_dwo_tus (per_cu);
2926     }
2927
2928   process_queue (dwarf2_per_objfile);
2929
2930   /* Age the cache, releasing compilation units that have not
2931      been used recently.  */
2932   age_cached_comp_units (dwarf2_per_objfile);
2933 }
2934
2935 /* Ensure that the symbols for PER_CU have been read in.  OBJFILE is
2936    the objfile from which this CU came.  Returns the resulting symbol
2937    table.  */
2938
2939 static struct compunit_symtab *
2940 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2941 {
2942   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2943
2944   gdb_assert (dwarf2_per_objfile->using_index);
2945   if (!per_cu->v.quick->compunit_symtab)
2946     {
2947       free_cached_comp_units freer (dwarf2_per_objfile);
2948       scoped_restore decrementer = increment_reading_symtab ();
2949       dw2_do_instantiate_symtab (per_cu, skip_partial);
2950       process_cu_includes (dwarf2_per_objfile);
2951     }
2952
2953   return per_cu->v.quick->compunit_symtab;
2954 }
2955
2956 /* See declaration.  */
2957
2958 dwarf2_per_cu_data *
2959 dwarf2_per_objfile::get_cutu (int index)
2960 {
2961   if (index >= this->all_comp_units.size ())
2962     {
2963       index -= this->all_comp_units.size ();
2964       gdb_assert (index < this->all_type_units.size ());
2965       return &this->all_type_units[index]->per_cu;
2966     }
2967
2968   return this->all_comp_units[index];
2969 }
2970
2971 /* See declaration.  */
2972
2973 dwarf2_per_cu_data *
2974 dwarf2_per_objfile::get_cu (int index)
2975 {
2976   gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2977
2978   return this->all_comp_units[index];
2979 }
2980
2981 /* See declaration.  */
2982
2983 signatured_type *
2984 dwarf2_per_objfile::get_tu (int index)
2985 {
2986   gdb_assert (index >= 0 && index < this->all_type_units.size ());
2987
2988   return this->all_type_units[index];
2989 }
2990
2991 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2992    objfile_obstack, and constructed with the specified field
2993    values.  */
2994
2995 static dwarf2_per_cu_data *
2996 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2997                           struct dwarf2_section_info *section,
2998                           int is_dwz,
2999                           sect_offset sect_off, ULONGEST length)
3000 {
3001   struct objfile *objfile = dwarf2_per_objfile->objfile;
3002   dwarf2_per_cu_data *the_cu
3003     = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3004                      struct dwarf2_per_cu_data);
3005   the_cu->sect_off = sect_off;
3006   the_cu->length = length;
3007   the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
3008   the_cu->section = section;
3009   the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3010                                    struct dwarf2_per_cu_quick_data);
3011   the_cu->is_dwz = is_dwz;
3012   return the_cu;
3013 }
3014
3015 /* A helper for create_cus_from_index that handles a given list of
3016    CUs.  */
3017
3018 static void
3019 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
3020                             const gdb_byte *cu_list, offset_type n_elements,
3021                             struct dwarf2_section_info *section,
3022                             int is_dwz)
3023 {
3024   for (offset_type i = 0; i < n_elements; i += 2)
3025     {
3026       gdb_static_assert (sizeof (ULONGEST) >= 8);
3027
3028       sect_offset sect_off
3029         = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
3030       ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3031       cu_list += 2 * 8;
3032
3033       dwarf2_per_cu_data *per_cu
3034         = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3035                                      sect_off, length);
3036       dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3037     }
3038 }
3039
3040 /* Read the CU list from the mapped index, and use it to create all
3041    the CU objects for this objfile.  */
3042
3043 static void
3044 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3045                        const gdb_byte *cu_list, offset_type cu_list_elements,
3046                        const gdb_byte *dwz_list, offset_type dwz_elements)
3047 {
3048   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3049   dwarf2_per_objfile->all_comp_units.reserve
3050     ((cu_list_elements + dwz_elements) / 2);
3051
3052   create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3053                               &dwarf2_per_objfile->info, 0);
3054
3055   if (dwz_elements == 0)
3056     return;
3057
3058   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3059   create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3060                               &dwz->info, 1);
3061 }
3062
3063 /* Create the signatured type hash table from the index.  */
3064
3065 static void
3066 create_signatured_type_table_from_index
3067   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3068    struct dwarf2_section_info *section,
3069    const gdb_byte *bytes,
3070    offset_type elements)
3071 {
3072   struct objfile *objfile = dwarf2_per_objfile->objfile;
3073
3074   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3075   dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3076
3077   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3078
3079   for (offset_type i = 0; i < elements; i += 3)
3080     {
3081       struct signatured_type *sig_type;
3082       ULONGEST signature;
3083       void **slot;
3084       cu_offset type_offset_in_tu;
3085
3086       gdb_static_assert (sizeof (ULONGEST) >= 8);
3087       sect_offset sect_off
3088         = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3089       type_offset_in_tu
3090         = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3091                                                 BFD_ENDIAN_LITTLE);
3092       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3093       bytes += 3 * 8;
3094
3095       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3096                                  struct signatured_type);
3097       sig_type->signature = signature;
3098       sig_type->type_offset_in_tu = type_offset_in_tu;
3099       sig_type->per_cu.is_debug_types = 1;
3100       sig_type->per_cu.section = section;
3101       sig_type->per_cu.sect_off = sect_off;
3102       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3103       sig_type->per_cu.v.quick
3104         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3105                           struct dwarf2_per_cu_quick_data);
3106
3107       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3108       *slot = sig_type;
3109
3110       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3111     }
3112
3113   dwarf2_per_objfile->signatured_types = sig_types_hash;
3114 }
3115
3116 /* Create the signatured type hash table from .debug_names.  */
3117
3118 static void
3119 create_signatured_type_table_from_debug_names
3120   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3121    const mapped_debug_names &map,
3122    struct dwarf2_section_info *section,
3123    struct dwarf2_section_info *abbrev_section)
3124 {
3125   struct objfile *objfile = dwarf2_per_objfile->objfile;
3126
3127   dwarf2_read_section (objfile, section);
3128   dwarf2_read_section (objfile, abbrev_section);
3129
3130   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3131   dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3132
3133   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3134
3135   for (uint32_t i = 0; i < map.tu_count; ++i)
3136     {
3137       struct signatured_type *sig_type;
3138       void **slot;
3139
3140       sect_offset sect_off
3141         = (sect_offset) (extract_unsigned_integer
3142                          (map.tu_table_reordered + i * map.offset_size,
3143                           map.offset_size,
3144                           map.dwarf5_byte_order));
3145
3146       comp_unit_head cu_header;
3147       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3148                                      abbrev_section,
3149                                      section->buffer + to_underlying (sect_off),
3150                                      rcuh_kind::TYPE);
3151
3152       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3153                                  struct signatured_type);
3154       sig_type->signature = cu_header.signature;
3155       sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3156       sig_type->per_cu.is_debug_types = 1;
3157       sig_type->per_cu.section = section;
3158       sig_type->per_cu.sect_off = sect_off;
3159       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3160       sig_type->per_cu.v.quick
3161         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3162                           struct dwarf2_per_cu_quick_data);
3163
3164       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3165       *slot = sig_type;
3166
3167       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3168     }
3169
3170   dwarf2_per_objfile->signatured_types = sig_types_hash;
3171 }
3172
3173 /* Read the address map data from the mapped index, and use it to
3174    populate the objfile's psymtabs_addrmap.  */
3175
3176 static void
3177 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3178                            struct mapped_index *index)
3179 {
3180   struct objfile *objfile = dwarf2_per_objfile->objfile;
3181   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3182   const gdb_byte *iter, *end;
3183   struct addrmap *mutable_map;
3184   CORE_ADDR baseaddr;
3185
3186   auto_obstack temp_obstack;
3187
3188   mutable_map = addrmap_create_mutable (&temp_obstack);
3189
3190   iter = index->address_table.data ();
3191   end = iter + index->address_table.size ();
3192
3193   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3194
3195   while (iter < end)
3196     {
3197       ULONGEST hi, lo, cu_index;
3198       lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3199       iter += 8;
3200       hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3201       iter += 8;
3202       cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3203       iter += 4;
3204
3205       if (lo > hi)
3206         {
3207           complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3208                      hex_string (lo), hex_string (hi));
3209           continue;
3210         }
3211
3212       if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3213         {
3214           complaint (_(".gdb_index address table has invalid CU number %u"),
3215                      (unsigned) cu_index);
3216           continue;
3217         }
3218
3219       lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3220       hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3221       addrmap_set_empty (mutable_map, lo, hi - 1,
3222                          dwarf2_per_objfile->get_cu (cu_index));
3223     }
3224
3225   objfile->partial_symtabs->psymtabs_addrmap
3226     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3227 }
3228
3229 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3230    populate the objfile's psymtabs_addrmap.  */
3231
3232 static void
3233 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3234                              struct dwarf2_section_info *section)
3235 {
3236   struct objfile *objfile = dwarf2_per_objfile->objfile;
3237   bfd *abfd = objfile->obfd;
3238   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3239   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3240                                        SECT_OFF_TEXT (objfile));
3241
3242   auto_obstack temp_obstack;
3243   addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3244
3245   std::unordered_map<sect_offset,
3246                      dwarf2_per_cu_data *,
3247                      gdb::hash_enum<sect_offset>>
3248     debug_info_offset_to_per_cu;
3249   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3250     {
3251       const auto insertpair
3252         = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3253       if (!insertpair.second)
3254         {
3255           warning (_("Section .debug_aranges in %s has duplicate "
3256                      "debug_info_offset %s, ignoring .debug_aranges."),
3257                    objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3258           return;
3259         }
3260     }
3261
3262   dwarf2_read_section (objfile, section);
3263
3264   const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3265
3266   const gdb_byte *addr = section->buffer;
3267
3268   while (addr < section->buffer + section->size)
3269     {
3270       const gdb_byte *const entry_addr = addr;
3271       unsigned int bytes_read;
3272
3273       const LONGEST entry_length = read_initial_length (abfd, addr,
3274                                                         &bytes_read);
3275       addr += bytes_read;
3276
3277       const gdb_byte *const entry_end = addr + entry_length;
3278       const bool dwarf5_is_dwarf64 = bytes_read != 4;
3279       const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3280       if (addr + entry_length > section->buffer + section->size)
3281         {
3282           warning (_("Section .debug_aranges in %s entry at offset %zu "
3283                      "length %s exceeds section length %s, "
3284                      "ignoring .debug_aranges."),
3285                    objfile_name (objfile), entry_addr - section->buffer,
3286                    plongest (bytes_read + entry_length),
3287                    pulongest (section->size));
3288           return;
3289         }
3290
3291       /* The version number.  */
3292       const uint16_t version = read_2_bytes (abfd, addr);
3293       addr += 2;
3294       if (version != 2)
3295         {
3296           warning (_("Section .debug_aranges in %s entry at offset %zu "
3297                      "has unsupported version %d, ignoring .debug_aranges."),
3298                    objfile_name (objfile), entry_addr - section->buffer,
3299                    version);
3300           return;
3301         }
3302
3303       const uint64_t debug_info_offset
3304         = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3305       addr += offset_size;
3306       const auto per_cu_it
3307         = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3308       if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3309         {
3310           warning (_("Section .debug_aranges in %s entry at offset %zu "
3311                      "debug_info_offset %s does not exists, "
3312                      "ignoring .debug_aranges."),
3313                    objfile_name (objfile), entry_addr - section->buffer,
3314                    pulongest (debug_info_offset));
3315           return;
3316         }
3317       dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3318
3319       const uint8_t address_size = *addr++;
3320       if (address_size < 1 || address_size > 8)
3321         {
3322           warning (_("Section .debug_aranges in %s entry at offset %zu "
3323                      "address_size %u is invalid, ignoring .debug_aranges."),
3324                    objfile_name (objfile), entry_addr - section->buffer,
3325                    address_size);
3326           return;
3327         }
3328
3329       const uint8_t segment_selector_size = *addr++;
3330       if (segment_selector_size != 0)
3331         {
3332           warning (_("Section .debug_aranges in %s entry at offset %zu "
3333                      "segment_selector_size %u is not supported, "
3334                      "ignoring .debug_aranges."),
3335                    objfile_name (objfile), entry_addr - section->buffer,
3336                    segment_selector_size);
3337           return;
3338         }
3339
3340       /* Must pad to an alignment boundary that is twice the address
3341          size.  It is undocumented by the DWARF standard but GCC does
3342          use it.  */
3343       for (size_t padding = ((-(addr - section->buffer))
3344                              & (2 * address_size - 1));
3345            padding > 0; padding--)
3346         if (*addr++ != 0)
3347           {
3348             warning (_("Section .debug_aranges in %s entry at offset %zu "
3349                        "padding is not zero, ignoring .debug_aranges."),
3350                      objfile_name (objfile), entry_addr - section->buffer);
3351             return;
3352           }
3353
3354       for (;;)
3355         {
3356           if (addr + 2 * address_size > entry_end)
3357             {
3358               warning (_("Section .debug_aranges in %s entry at offset %zu "
3359                          "address list is not properly terminated, "
3360                          "ignoring .debug_aranges."),
3361                        objfile_name (objfile), entry_addr - section->buffer);
3362               return;
3363             }
3364           ULONGEST start = extract_unsigned_integer (addr, address_size,
3365                                                      dwarf5_byte_order);
3366           addr += address_size;
3367           ULONGEST length = extract_unsigned_integer (addr, address_size,
3368                                                       dwarf5_byte_order);
3369           addr += address_size;
3370           if (start == 0 && length == 0)
3371             break;
3372           if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3373             {
3374               /* Symbol was eliminated due to a COMDAT group.  */
3375               continue;
3376             }
3377           ULONGEST end = start + length;
3378           start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3379                    - baseaddr);
3380           end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3381                  - baseaddr);
3382           addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3383         }
3384     }
3385
3386   objfile->partial_symtabs->psymtabs_addrmap
3387     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3388 }
3389
3390 /* Find a slot in the mapped index INDEX for the object named NAME.
3391    If NAME is found, set *VEC_OUT to point to the CU vector in the
3392    constant pool and return true.  If NAME cannot be found, return
3393    false.  */
3394
3395 static bool
3396 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3397                           offset_type **vec_out)
3398 {
3399   offset_type hash;
3400   offset_type slot, step;
3401   int (*cmp) (const char *, const char *);
3402
3403   gdb::unique_xmalloc_ptr<char> without_params;
3404   if (current_language->la_language == language_cplus
3405       || current_language->la_language == language_fortran
3406       || current_language->la_language == language_d)
3407     {
3408       /* NAME is already canonical.  Drop any qualifiers as .gdb_index does
3409          not contain any.  */
3410
3411       if (strchr (name, '(') != NULL)
3412         {
3413           without_params = cp_remove_params (name);
3414
3415           if (without_params != NULL)
3416             name = without_params.get ();
3417         }
3418     }
3419
3420   /* Index version 4 did not support case insensitive searches.  But the
3421      indices for case insensitive languages are built in lowercase, therefore
3422      simulate our NAME being searched is also lowercased.  */
3423   hash = mapped_index_string_hash ((index->version == 4
3424                                     && case_sensitivity == case_sensitive_off
3425                                     ? 5 : index->version),
3426                                    name);
3427
3428   slot = hash & (index->symbol_table.size () - 1);
3429   step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3430   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3431
3432   for (;;)
3433     {
3434       const char *str;
3435
3436       const auto &bucket = index->symbol_table[slot];
3437       if (bucket.name == 0 && bucket.vec == 0)
3438         return false;
3439
3440       str = index->constant_pool + MAYBE_SWAP (bucket.name);
3441       if (!cmp (name, str))
3442         {
3443           *vec_out = (offset_type *) (index->constant_pool
3444                                       + MAYBE_SWAP (bucket.vec));
3445           return true;
3446         }
3447
3448       slot = (slot + step) & (index->symbol_table.size () - 1);
3449     }
3450 }
3451
3452 /* A helper function that reads the .gdb_index from BUFFER and fills
3453    in MAP.  FILENAME is the name of the file containing the data;
3454    it is used for error reporting.  DEPRECATED_OK is true if it is
3455    ok to use deprecated sections.
3456
3457    CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3458    out parameters that are filled in with information about the CU and
3459    TU lists in the section.
3460
3461    Returns true if all went well, false otherwise.  */
3462
3463 static bool
3464 read_gdb_index_from_buffer (struct objfile *objfile,
3465                             const char *filename,
3466                             bool deprecated_ok,
3467                             gdb::array_view<const gdb_byte> buffer,
3468                             struct mapped_index *map,
3469                             const gdb_byte **cu_list,
3470                             offset_type *cu_list_elements,
3471                             const gdb_byte **types_list,
3472                             offset_type *types_list_elements)
3473 {
3474   const gdb_byte *addr = &buffer[0];
3475
3476   /* Version check.  */
3477   offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3478   /* Versions earlier than 3 emitted every copy of a psymbol.  This
3479      causes the index to behave very poorly for certain requests.  Version 3
3480      contained incomplete addrmap.  So, it seems better to just ignore such
3481      indices.  */
3482   if (version < 4)
3483     {
3484       static int warning_printed = 0;
3485       if (!warning_printed)
3486         {
3487           warning (_("Skipping obsolete .gdb_index section in %s."),
3488                    filename);
3489           warning_printed = 1;
3490         }
3491       return 0;
3492     }
3493   /* Index version 4 uses a different hash function than index version
3494      5 and later.
3495
3496      Versions earlier than 6 did not emit psymbols for inlined
3497      functions.  Using these files will cause GDB not to be able to
3498      set breakpoints on inlined functions by name, so we ignore these
3499      indices unless the user has done
3500      "set use-deprecated-index-sections on".  */
3501   if (version < 6 && !deprecated_ok)
3502     {
3503       static int warning_printed = 0;
3504       if (!warning_printed)
3505         {
3506           warning (_("\
3507 Skipping deprecated .gdb_index section in %s.\n\
3508 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3509 to use the section anyway."),
3510                    filename);
3511           warning_printed = 1;
3512         }
3513       return 0;
3514     }
3515   /* Version 7 indices generated by gold refer to the CU for a symbol instead
3516      of the TU (for symbols coming from TUs),
3517      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3518      Plus gold-generated indices can have duplicate entries for global symbols,
3519      http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3520      These are just performance bugs, and we can't distinguish gdb-generated
3521      indices from gold-generated ones, so issue no warning here.  */
3522
3523   /* Indexes with higher version than the one supported by GDB may be no
3524      longer backward compatible.  */
3525   if (version > 8)
3526     return 0;
3527
3528   map->version = version;
3529
3530   offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3531
3532   int i = 0;
3533   *cu_list = addr + MAYBE_SWAP (metadata[i]);
3534   *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3535                        / 8);
3536   ++i;
3537
3538   *types_list = addr + MAYBE_SWAP (metadata[i]);
3539   *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3540                            - MAYBE_SWAP (metadata[i]))
3541                           / 8);
3542   ++i;
3543
3544   const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3545   const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3546   map->address_table
3547     = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3548   ++i;
3549
3550   const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3551   const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3552   map->symbol_table
3553     = gdb::array_view<mapped_index::symbol_table_slot>
3554        ((mapped_index::symbol_table_slot *) symbol_table,
3555         (mapped_index::symbol_table_slot *) symbol_table_end);
3556
3557   ++i;
3558   map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3559
3560   return 1;
3561 }
3562
3563 /* Callback types for dwarf2_read_gdb_index.  */
3564
3565 typedef gdb::function_view
3566     <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3567     get_gdb_index_contents_ftype;
3568 typedef gdb::function_view
3569     <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3570     get_gdb_index_contents_dwz_ftype;
3571
3572 /* Read .gdb_index.  If everything went ok, initialize the "quick"
3573    elements of all the CUs and return 1.  Otherwise, return 0.  */
3574
3575 static int
3576 dwarf2_read_gdb_index
3577   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3578    get_gdb_index_contents_ftype get_gdb_index_contents,
3579    get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3580 {
3581   const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3582   offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3583   struct dwz_file *dwz;
3584   struct objfile *objfile = dwarf2_per_objfile->objfile;
3585
3586   gdb::array_view<const gdb_byte> main_index_contents
3587     = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3588
3589   if (main_index_contents.empty ())
3590     return 0;
3591
3592   std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3593   if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3594                                    use_deprecated_index_sections,
3595                                    main_index_contents, map.get (), &cu_list,
3596                                    &cu_list_elements, &types_list,
3597                                    &types_list_elements))
3598     return 0;
3599
3600   /* Don't use the index if it's empty.  */
3601   if (map->symbol_table.empty ())
3602     return 0;
3603
3604   /* If there is a .dwz file, read it so we can get its CU list as
3605      well.  */
3606   dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3607   if (dwz != NULL)
3608     {
3609       struct mapped_index dwz_map;
3610       const gdb_byte *dwz_types_ignore;
3611       offset_type dwz_types_elements_ignore;
3612
3613       gdb::array_view<const gdb_byte> dwz_index_content
3614         = get_gdb_index_contents_dwz (objfile, dwz);
3615
3616       if (dwz_index_content.empty ())
3617         return 0;
3618
3619       if (!read_gdb_index_from_buffer (objfile,
3620                                        bfd_get_filename (dwz->dwz_bfd), 1,
3621                                        dwz_index_content, &dwz_map,
3622                                        &dwz_list, &dwz_list_elements,
3623                                        &dwz_types_ignore,
3624                                        &dwz_types_elements_ignore))
3625         {
3626           warning (_("could not read '.gdb_index' section from %s; skipping"),
3627                    bfd_get_filename (dwz->dwz_bfd));
3628           return 0;
3629         }
3630     }
3631
3632   create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3633                          dwz_list, dwz_list_elements);
3634
3635   if (types_list_elements)
3636     {
3637       struct dwarf2_section_info *section;
3638
3639       /* We can only handle a single .debug_types when we have an
3640          index.  */
3641       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3642         return 0;
3643
3644       section = VEC_index (dwarf2_section_info_def,
3645                            dwarf2_per_objfile->types, 0);
3646
3647       create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3648                                                types_list, types_list_elements);
3649     }
3650
3651   create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3652
3653   dwarf2_per_objfile->index_table = std::move (map);
3654   dwarf2_per_objfile->using_index = 1;
3655   dwarf2_per_objfile->quick_file_names_table =
3656     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3657
3658   return 1;
3659 }
3660
3661 /* die_reader_func for dw2_get_file_names.  */
3662
3663 static void
3664 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3665                            const gdb_byte *info_ptr,
3666                            struct die_info *comp_unit_die,
3667                            int has_children,
3668                            void *data)
3669 {
3670   struct dwarf2_cu *cu = reader->cu;
3671   struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3672   struct dwarf2_per_objfile *dwarf2_per_objfile
3673     = cu->per_cu->dwarf2_per_objfile;
3674   struct objfile *objfile = dwarf2_per_objfile->objfile;
3675   struct dwarf2_per_cu_data *lh_cu;
3676   struct attribute *attr;
3677   int i;
3678   void **slot;
3679   struct quick_file_names *qfn;
3680
3681   gdb_assert (! this_cu->is_debug_types);
3682
3683   /* Our callers never want to match partial units -- instead they
3684      will match the enclosing full CU.  */
3685   if (comp_unit_die->tag == DW_TAG_partial_unit)
3686     {
3687       this_cu->v.quick->no_file_data = 1;
3688       return;
3689     }
3690
3691   lh_cu = this_cu;
3692   slot = NULL;
3693
3694   line_header_up lh;
3695   sect_offset line_offset {};
3696
3697   attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3698   if (attr)
3699     {
3700       struct quick_file_names find_entry;
3701
3702       line_offset = (sect_offset) DW_UNSND (attr);
3703
3704       /* We may have already read in this line header (TU line header sharing).
3705          If we have we're done.  */
3706       find_entry.hash.dwo_unit = cu->dwo_unit;
3707       find_entry.hash.line_sect_off = line_offset;
3708       slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3709                              &find_entry, INSERT);
3710       if (*slot != NULL)
3711         {
3712           lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3713           return;
3714         }
3715
3716       lh = dwarf_decode_line_header (line_offset, cu);
3717     }
3718   if (lh == NULL)
3719     {
3720       lh_cu->v.quick->no_file_data = 1;
3721       return;
3722     }
3723
3724   qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3725   qfn->hash.dwo_unit = cu->dwo_unit;
3726   qfn->hash.line_sect_off = line_offset;
3727   gdb_assert (slot != NULL);
3728   *slot = qfn;
3729
3730   file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3731
3732   qfn->num_file_names = lh->file_names.size ();
3733   qfn->file_names =
3734     XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3735   for (i = 0; i < lh->file_names.size (); ++i)
3736     qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3737   qfn->real_names = NULL;
3738
3739   lh_cu->v.quick->file_names = qfn;
3740 }
3741
3742 /* A helper for the "quick" functions which attempts to read the line
3743    table for THIS_CU.  */
3744
3745 static struct quick_file_names *
3746 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3747 {
3748   /* This should never be called for TUs.  */
3749   gdb_assert (! this_cu->is_debug_types);
3750   /* Nor type unit groups.  */
3751   gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3752
3753   if (this_cu->v.quick->file_names != NULL)
3754     return this_cu->v.quick->file_names;
3755   /* If we know there is no line data, no point in looking again.  */
3756   if (this_cu->v.quick->no_file_data)
3757     return NULL;
3758
3759   init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3760
3761   if (this_cu->v.quick->no_file_data)
3762     return NULL;
3763   return this_cu->v.quick->file_names;
3764 }
3765
3766 /* A helper for the "quick" functions which computes and caches the
3767    real path for a given file name from the line table.  */
3768
3769 static const char *
3770 dw2_get_real_path (struct objfile *objfile,
3771                    struct quick_file_names *qfn, int index)
3772 {
3773   if (qfn->real_names == NULL)
3774     qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3775                                       qfn->num_file_names, const char *);
3776
3777   if (qfn->real_names[index] == NULL)
3778     qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3779
3780   return qfn->real_names[index];
3781 }
3782
3783 static struct symtab *
3784 dw2_find_last_source_symtab (struct objfile *objfile)
3785 {
3786   struct dwarf2_per_objfile *dwarf2_per_objfile
3787     = get_dwarf2_per_objfile (objfile);
3788   dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3789   compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3790
3791   if (cust == NULL)
3792     return NULL;
3793
3794   return compunit_primary_filetab (cust);
3795 }
3796
3797 /* Traversal function for dw2_forget_cached_source_info.  */
3798
3799 static int
3800 dw2_free_cached_file_names (void **slot, void *info)
3801 {
3802   struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3803
3804   if (file_data->real_names)
3805     {
3806       int i;
3807
3808       for (i = 0; i < file_data->num_file_names; ++i)
3809         {
3810           xfree ((void*) file_data->real_names[i]);
3811           file_data->real_names[i] = NULL;
3812         }
3813     }
3814
3815   return 1;
3816 }
3817
3818 static void
3819 dw2_forget_cached_source_info (struct objfile *objfile)
3820 {
3821   struct dwarf2_per_objfile *dwarf2_per_objfile
3822     = get_dwarf2_per_objfile (objfile);
3823
3824   htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3825                           dw2_free_cached_file_names, NULL);
3826 }
3827
3828 /* Helper function for dw2_map_symtabs_matching_filename that expands
3829    the symtabs and calls the iterator.  */
3830
3831 static int
3832 dw2_map_expand_apply (struct objfile *objfile,
3833                       struct dwarf2_per_cu_data *per_cu,
3834                       const char *name, const char *real_path,
3835                       gdb::function_view<bool (symtab *)> callback)
3836 {
3837   struct compunit_symtab *last_made = objfile->compunit_symtabs;
3838
3839   /* Don't visit already-expanded CUs.  */
3840   if (per_cu->v.quick->compunit_symtab)
3841     return 0;
3842
3843   /* This may expand more than one symtab, and we want to iterate over
3844      all of them.  */
3845   dw2_instantiate_symtab (per_cu, false);
3846
3847   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3848                                     last_made, callback);
3849 }
3850
3851 /* Implementation of the map_symtabs_matching_filename method.  */
3852
3853 static bool
3854 dw2_map_symtabs_matching_filename
3855   (struct objfile *objfile, const char *name, const char *real_path,
3856    gdb::function_view<bool (symtab *)> callback)
3857 {
3858   const char *name_basename = lbasename (name);
3859   struct dwarf2_per_objfile *dwarf2_per_objfile
3860     = get_dwarf2_per_objfile (objfile);
3861
3862   /* The rule is CUs specify all the files, including those used by
3863      any TU, so there's no need to scan TUs here.  */
3864
3865   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3866     {
3867       /* We only need to look at symtabs not already expanded.  */
3868       if (per_cu->v.quick->compunit_symtab)
3869         continue;
3870
3871       quick_file_names *file_data = dw2_get_file_names (per_cu);
3872       if (file_data == NULL)
3873         continue;
3874
3875       for (int j = 0; j < file_data->num_file_names; ++j)
3876         {
3877           const char *this_name = file_data->file_names[j];
3878           const char *this_real_name;
3879
3880           if (compare_filenames_for_search (this_name, name))
3881             {
3882               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3883                                         callback))
3884                 return true;
3885               continue;
3886             }
3887
3888           /* Before we invoke realpath, which can get expensive when many
3889              files are involved, do a quick comparison of the basenames.  */
3890           if (! basenames_may_differ
3891               && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3892             continue;
3893
3894           this_real_name = dw2_get_real_path (objfile, file_data, j);
3895           if (compare_filenames_for_search (this_real_name, name))
3896             {
3897               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3898                                         callback))
3899                 return true;
3900               continue;
3901             }
3902
3903           if (real_path != NULL)
3904             {
3905               gdb_assert (IS_ABSOLUTE_PATH (real_path));
3906               gdb_assert (IS_ABSOLUTE_PATH (name));
3907               if (this_real_name != NULL
3908                   && FILENAME_CMP (real_path, this_real_name) == 0)
3909                 {
3910                   if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3911                                             callback))
3912                     return true;
3913                   continue;
3914                 }
3915             }
3916         }
3917     }
3918
3919   return false;
3920 }
3921
3922 /* Struct used to manage iterating over all CUs looking for a symbol.  */
3923
3924 struct dw2_symtab_iterator
3925 {
3926   /* The dwarf2_per_objfile owning the CUs we are iterating on.  */
3927   struct dwarf2_per_objfile *dwarf2_per_objfile;
3928   /* If non-zero, only look for symbols that match BLOCK_INDEX.  */
3929   int want_specific_block;
3930   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3931      Unused if !WANT_SPECIFIC_BLOCK.  */
3932   int block_index;
3933   /* The kind of symbol we're looking for.  */
3934   domain_enum domain;
3935   /* The list of CUs from the index entry of the symbol,
3936      or NULL if not found.  */
3937   offset_type *vec;
3938   /* The next element in VEC to look at.  */
3939   int next;
3940   /* The number of elements in VEC, or zero if there is no match.  */
3941   int length;
3942   /* Have we seen a global version of the symbol?
3943      If so we can ignore all further global instances.
3944      This is to work around gold/15646, inefficient gold-generated
3945      indices.  */
3946   int global_seen;
3947 };
3948
3949 /* Initialize the index symtab iterator ITER.
3950    If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3951    in block BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
3952
3953 static void
3954 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3955                       struct dwarf2_per_objfile *dwarf2_per_objfile,
3956                       int want_specific_block,
3957                       int block_index,
3958                       domain_enum domain,
3959                       const char *name)
3960 {
3961   iter->dwarf2_per_objfile = dwarf2_per_objfile;
3962   iter->want_specific_block = want_specific_block;
3963   iter->block_index = block_index;
3964   iter->domain = domain;
3965   iter->next = 0;
3966   iter->global_seen = 0;
3967
3968   mapped_index *index = dwarf2_per_objfile->index_table.get ();
3969
3970   /* index is NULL if OBJF_READNOW.  */
3971   if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3972     iter->length = MAYBE_SWAP (*iter->vec);
3973   else
3974     {
3975       iter->vec = NULL;
3976       iter->length = 0;
3977     }
3978 }
3979
3980 /* Return the next matching CU or NULL if there are no more.  */
3981
3982 static struct dwarf2_per_cu_data *
3983 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3984 {
3985   struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3986
3987   for ( ; iter->next < iter->length; ++iter->next)
3988     {
3989       offset_type cu_index_and_attrs =
3990         MAYBE_SWAP (iter->vec[iter->next + 1]);
3991       offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3992       int want_static = iter->block_index != GLOBAL_BLOCK;
3993       /* This value is only valid for index versions >= 7.  */
3994       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3995       gdb_index_symbol_kind symbol_kind =
3996         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3997       /* Only check the symbol attributes if they're present.
3998          Indices prior to version 7 don't record them,
3999          and indices >= 7 may elide them for certain symbols
4000          (gold does this).  */
4001       int attrs_valid =
4002         (dwarf2_per_objfile->index_table->version >= 7
4003          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
4004
4005       /* Don't crash on bad data.  */
4006       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
4007                        + dwarf2_per_objfile->all_type_units.size ()))
4008         {
4009           complaint (_(".gdb_index entry has bad CU index"
4010                        " [in module %s]"),
4011                      objfile_name (dwarf2_per_objfile->objfile));
4012           continue;
4013         }
4014
4015       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
4016
4017       /* Skip if already read in.  */
4018       if (per_cu->v.quick->compunit_symtab)
4019         continue;
4020
4021       /* Check static vs global.  */
4022       if (attrs_valid)
4023         {
4024           if (iter->want_specific_block
4025               && want_static != is_static)
4026             continue;
4027           /* Work around gold/15646.  */
4028           if (!is_static && iter->global_seen)
4029             continue;
4030           if (!is_static)
4031             iter->global_seen = 1;
4032         }
4033
4034       /* Only check the symbol's kind if it has one.  */
4035       if (attrs_valid)
4036         {
4037           switch (iter->domain)
4038             {
4039             case VAR_DOMAIN:
4040               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4041                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4042                   /* Some types are also in VAR_DOMAIN.  */
4043                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4044                 continue;
4045               break;
4046             case STRUCT_DOMAIN:
4047               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4048                 continue;
4049               break;
4050             case LABEL_DOMAIN:
4051               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4052                 continue;
4053               break;
4054             default:
4055               break;
4056             }
4057         }
4058
4059       ++iter->next;
4060       return per_cu;
4061     }
4062
4063   return NULL;
4064 }
4065
4066 static struct compunit_symtab *
4067 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4068                    const char *name, domain_enum domain)
4069 {
4070   struct compunit_symtab *stab_best = NULL;
4071   struct dwarf2_per_objfile *dwarf2_per_objfile
4072     = get_dwarf2_per_objfile (objfile);
4073
4074   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4075
4076   struct dw2_symtab_iterator iter;
4077   struct dwarf2_per_cu_data *per_cu;
4078
4079   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4080
4081   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4082     {
4083       struct symbol *sym, *with_opaque = NULL;
4084       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4085       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4086       struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4087
4088       sym = block_find_symbol (block, name, domain,
4089                                block_find_non_opaque_type_preferred,
4090                                &with_opaque);
4091
4092       /* Some caution must be observed with overloaded functions
4093          and methods, since the index will not contain any overload
4094          information (but NAME might contain it).  */
4095
4096       if (sym != NULL
4097           && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4098         return stab;
4099       if (with_opaque != NULL
4100           && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4101         stab_best = stab;
4102
4103       /* Keep looking through other CUs.  */
4104     }
4105
4106   return stab_best;
4107 }
4108
4109 static void
4110 dw2_print_stats (struct objfile *objfile)
4111 {
4112   struct dwarf2_per_objfile *dwarf2_per_objfile
4113     = get_dwarf2_per_objfile (objfile);
4114   int total = (dwarf2_per_objfile->all_comp_units.size ()
4115                + dwarf2_per_objfile->all_type_units.size ());
4116   int count = 0;
4117
4118   for (int i = 0; i < total; ++i)
4119     {
4120       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4121
4122       if (!per_cu->v.quick->compunit_symtab)
4123         ++count;
4124     }
4125   printf_filtered (_("  Number of read CUs: %d\n"), total - count);
4126   printf_filtered (_("  Number of unread CUs: %d\n"), count);
4127 }
4128
4129 /* This dumps minimal information about the index.
4130    It is called via "mt print objfiles".
4131    One use is to verify .gdb_index has been loaded by the
4132    gdb.dwarf2/gdb-index.exp testcase.  */
4133
4134 static void
4135 dw2_dump (struct objfile *objfile)
4136 {
4137   struct dwarf2_per_objfile *dwarf2_per_objfile
4138     = get_dwarf2_per_objfile (objfile);
4139
4140   gdb_assert (dwarf2_per_objfile->using_index);
4141   printf_filtered (".gdb_index:");
4142   if (dwarf2_per_objfile->index_table != NULL)
4143     {
4144       printf_filtered (" version %d\n",
4145                        dwarf2_per_objfile->index_table->version);
4146     }
4147   else
4148     printf_filtered (" faked for \"readnow\"\n");
4149   printf_filtered ("\n");
4150 }
4151
4152 static void
4153 dw2_expand_symtabs_for_function (struct objfile *objfile,
4154                                  const char *func_name)
4155 {
4156   struct dwarf2_per_objfile *dwarf2_per_objfile
4157     = get_dwarf2_per_objfile (objfile);
4158
4159   struct dw2_symtab_iterator iter;
4160   struct dwarf2_per_cu_data *per_cu;
4161
4162   /* Note: It doesn't matter what we pass for block_index here.  */
4163   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4164                         func_name);
4165
4166   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4167     dw2_instantiate_symtab (per_cu, false);
4168
4169 }
4170
4171 static void
4172 dw2_expand_all_symtabs (struct objfile *objfile)
4173 {
4174   struct dwarf2_per_objfile *dwarf2_per_objfile
4175     = get_dwarf2_per_objfile (objfile);
4176   int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4177                      + dwarf2_per_objfile->all_type_units.size ());
4178
4179   for (int i = 0; i < total_units; ++i)
4180     {
4181       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4182
4183       /* We don't want to directly expand a partial CU, because if we
4184          read it with the wrong language, then assertion failures can
4185          be triggered later on.  See PR symtab/23010.  So, tell
4186          dw2_instantiate_symtab to skip partial CUs -- any important
4187          partial CU will be read via DW_TAG_imported_unit anyway.  */
4188       dw2_instantiate_symtab (per_cu, true);
4189     }
4190 }
4191
4192 static void
4193 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4194                                   const char *fullname)
4195 {
4196   struct dwarf2_per_objfile *dwarf2_per_objfile
4197     = get_dwarf2_per_objfile (objfile);
4198
4199   /* We don't need to consider type units here.
4200      This is only called for examining code, e.g. expand_line_sal.
4201      There can be an order of magnitude (or more) more type units
4202      than comp units, and we avoid them if we can.  */
4203
4204   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4205     {
4206       /* We only need to look at symtabs not already expanded.  */
4207       if (per_cu->v.quick->compunit_symtab)
4208         continue;
4209
4210       quick_file_names *file_data = dw2_get_file_names (per_cu);
4211       if (file_data == NULL)
4212         continue;
4213
4214       for (int j = 0; j < file_data->num_file_names; ++j)
4215         {
4216           const char *this_fullname = file_data->file_names[j];
4217
4218           if (filename_cmp (this_fullname, fullname) == 0)
4219             {
4220               dw2_instantiate_symtab (per_cu, false);
4221               break;
4222             }
4223         }
4224     }
4225 }
4226
4227 static void
4228 dw2_map_matching_symbols (struct objfile *objfile,
4229                           const char * name, domain_enum domain,
4230                           int global,
4231                           int (*callback) (struct block *,
4232                                            struct symbol *, void *),
4233                           void *data, symbol_name_match_type match,
4234                           symbol_compare_ftype *ordered_compare)
4235 {
4236   /* Currently unimplemented; used for Ada.  The function can be called if the
4237      current language is Ada for a non-Ada objfile using GNU index.  As Ada
4238      does not look for non-Ada symbols this function should just return.  */
4239 }
4240
4241 /* Symbol name matcher for .gdb_index names.
4242
4243    Symbol names in .gdb_index have a few particularities:
4244
4245    - There's no indication of which is the language of each symbol.
4246
4247      Since each language has its own symbol name matching algorithm,
4248      and we don't know which language is the right one, we must match
4249      each symbol against all languages.  This would be a potential
4250      performance problem if it were not mitigated by the
4251      mapped_index::name_components lookup table, which significantly
4252      reduces the number of times we need to call into this matcher,
4253      making it a non-issue.
4254
4255    - Symbol names in the index have no overload (parameter)
4256      information.  I.e., in C++, "foo(int)" and "foo(long)" both
4257      appear as "foo" in the index, for example.
4258
4259      This means that the lookup names passed to the symbol name
4260      matcher functions must have no parameter information either
4261      because (e.g.) symbol search name "foo" does not match
4262      lookup-name "foo(int)" [while swapping search name for lookup
4263      name would match].
4264 */
4265 class gdb_index_symbol_name_matcher
4266 {
4267 public:
4268   /* Prepares the vector of comparison functions for LOOKUP_NAME.  */
4269   gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4270
4271   /* Walk all the matcher routines and match SYMBOL_NAME against them.
4272      Returns true if any matcher matches.  */
4273   bool matches (const char *symbol_name);
4274
4275 private:
4276   /* A reference to the lookup name we're matching against.  */
4277   const lookup_name_info &m_lookup_name;
4278
4279   /* A vector holding all the different symbol name matchers, for all
4280      languages.  */
4281   std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4282 };
4283
4284 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4285   (const lookup_name_info &lookup_name)
4286     : m_lookup_name (lookup_name)
4287 {
4288   /* Prepare the vector of comparison functions upfront, to avoid
4289      doing the same work for each symbol.  Care is taken to avoid
4290      matching with the same matcher more than once if/when multiple
4291      languages use the same matcher function.  */
4292   auto &matchers = m_symbol_name_matcher_funcs;
4293   matchers.reserve (nr_languages);
4294
4295   matchers.push_back (default_symbol_name_matcher);
4296
4297   for (int i = 0; i < nr_languages; i++)
4298     {
4299       const language_defn *lang = language_def ((enum language) i);
4300       symbol_name_matcher_ftype *name_matcher
4301         = get_symbol_name_matcher (lang, m_lookup_name);
4302
4303       /* Don't insert the same comparison routine more than once.
4304          Note that we do this linear walk instead of a seemingly
4305          cheaper sorted insert, or use a std::set or something like
4306          that, because relative order of function addresses is not
4307          stable.  This is not a problem in practice because the number
4308          of supported languages is low, and the cost here is tiny
4309          compared to the number of searches we'll do afterwards using
4310          this object.  */
4311       if (name_matcher != default_symbol_name_matcher
4312           && (std::find (matchers.begin (), matchers.end (), name_matcher)
4313               == matchers.end ()))
4314         matchers.push_back (name_matcher);
4315     }
4316 }
4317
4318 bool
4319 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4320 {
4321   for (auto matches_name : m_symbol_name_matcher_funcs)
4322     if (matches_name (symbol_name, m_lookup_name, NULL))
4323       return true;
4324
4325   return false;
4326 }
4327
4328 /* Starting from a search name, return the string that finds the upper
4329    bound of all strings that start with SEARCH_NAME in a sorted name
4330    list.  Returns the empty string to indicate that the upper bound is
4331    the end of the list.  */
4332
4333 static std::string
4334 make_sort_after_prefix_name (const char *search_name)
4335 {
4336   /* When looking to complete "func", we find the upper bound of all
4337      symbols that start with "func" by looking for where we'd insert
4338      the closest string that would follow "func" in lexicographical
4339      order.  Usually, that's "func"-with-last-character-incremented,
4340      i.e. "fund".  Mind non-ASCII characters, though.  Usually those
4341      will be UTF-8 multi-byte sequences, but we can't be certain.
4342      Especially mind the 0xff character, which is a valid character in
4343      non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4344      rule out compilers allowing it in identifiers.  Note that
4345      conveniently, strcmp/strcasecmp are specified to compare
4346      characters interpreted as unsigned char.  So what we do is treat
4347      the whole string as a base 256 number composed of a sequence of
4348      base 256 "digits" and add 1 to it.  I.e., adding 1 to 0xff wraps
4349      to 0, and carries 1 to the following more-significant position.
4350      If the very first character in SEARCH_NAME ends up incremented
4351      and carries/overflows, then the upper bound is the end of the
4352      list.  The string after the empty string is also the empty
4353      string.
4354
4355      Some examples of this operation:
4356
4357        SEARCH_NAME  => "+1" RESULT
4358
4359        "abc"              => "abd"
4360        "ab\xff"           => "ac"
4361        "\xff" "a" "\xff"  => "\xff" "b"
4362        "\xff"             => ""
4363        "\xff\xff"         => ""
4364        ""                 => ""
4365
4366      Then, with these symbols for example:
4367
4368       func
4369       func1
4370       fund
4371
4372      completing "func" looks for symbols between "func" and
4373      "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4374      which finds "func" and "func1", but not "fund".
4375
4376      And with:
4377
4378       funcÿ     (Latin1 'ÿ' [0xff])
4379       funcÿ1
4380       fund
4381
4382      completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4383      (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4384
4385      And with:
4386
4387       ÿÿ        (Latin1 'ÿ' [0xff])
4388       ÿÿ1
4389
4390      completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4391      the end of the list.
4392   */
4393   std::string after = search_name;
4394   while (!after.empty () && (unsigned char) after.back () == 0xff)
4395     after.pop_back ();
4396   if (!after.empty ())
4397     after.back () = (unsigned char) after.back () + 1;
4398   return after;
4399 }
4400
4401 /* See declaration.  */
4402
4403 std::pair<std::vector<name_component>::const_iterator,
4404           std::vector<name_component>::const_iterator>
4405 mapped_index_base::find_name_components_bounds
4406   (const lookup_name_info &lookup_name_without_params) const
4407 {
4408   auto *name_cmp
4409     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4410
4411   const char *cplus
4412     = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4413
4414   /* Comparison function object for lower_bound that matches against a
4415      given symbol name.  */
4416   auto lookup_compare_lower = [&] (const name_component &elem,
4417                                    const char *name)
4418     {
4419       const char *elem_qualified = this->symbol_name_at (elem.idx);
4420       const char *elem_name = elem_qualified + elem.name_offset;
4421       return name_cmp (elem_name, name) < 0;
4422     };
4423
4424   /* Comparison function object for upper_bound that matches against a
4425      given symbol name.  */
4426   auto lookup_compare_upper = [&] (const char *name,
4427                                    const name_component &elem)
4428     {
4429       const char *elem_qualified = this->symbol_name_at (elem.idx);
4430       const char *elem_name = elem_qualified + elem.name_offset;
4431       return name_cmp (name, elem_name) < 0;
4432     };
4433
4434   auto begin = this->name_components.begin ();
4435   auto end = this->name_components.end ();
4436
4437   /* Find the lower bound.  */
4438   auto lower = [&] ()
4439     {
4440       if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4441         return begin;
4442       else
4443         return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4444     } ();
4445
4446   /* Find the upper bound.  */
4447   auto upper = [&] ()
4448     {
4449       if (lookup_name_without_params.completion_mode ())
4450         {
4451           /* In completion mode, we want UPPER to point past all
4452              symbols names that have the same prefix.  I.e., with
4453              these symbols, and completing "func":
4454
4455               function        << lower bound
4456               function1
4457               other_function  << upper bound
4458
4459              We find the upper bound by looking for the insertion
4460              point of "func"-with-last-character-incremented,
4461              i.e. "fund".  */
4462           std::string after = make_sort_after_prefix_name (cplus);
4463           if (after.empty ())
4464             return end;
4465           return std::lower_bound (lower, end, after.c_str (),
4466                                    lookup_compare_lower);
4467         }
4468       else
4469         return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4470     } ();
4471
4472   return {lower, upper};
4473 }
4474
4475 /* See declaration.  */
4476
4477 void
4478 mapped_index_base::build_name_components ()
4479 {
4480   if (!this->name_components.empty ())
4481     return;
4482
4483   this->name_components_casing = case_sensitivity;
4484   auto *name_cmp
4485     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4486
4487   /* The code below only knows how to break apart components of C++
4488      symbol names (and other languages that use '::' as
4489      namespace/module separator).  If we add support for wild matching
4490      to some language that uses some other operator (E.g., Ada, Go and
4491      D use '.'), then we'll need to try splitting the symbol name
4492      according to that language too.  Note that Ada does support wild
4493      matching, but doesn't currently support .gdb_index.  */
4494   auto count = this->symbol_name_count ();
4495   for (offset_type idx = 0; idx < count; idx++)
4496     {
4497       if (this->symbol_name_slot_invalid (idx))
4498         continue;
4499
4500       const char *name = this->symbol_name_at (idx);
4501
4502       /* Add each name component to the name component table.  */
4503       unsigned int previous_len = 0;
4504       for (unsigned int current_len = cp_find_first_component (name);
4505            name[current_len] != '\0';
4506            current_len += cp_find_first_component (name + current_len))
4507         {
4508           gdb_assert (name[current_len] == ':');
4509           this->name_components.push_back ({previous_len, idx});
4510           /* Skip the '::'.  */
4511           current_len += 2;
4512           previous_len = current_len;
4513         }
4514       this->name_components.push_back ({previous_len, idx});
4515     }
4516
4517   /* Sort name_components elements by name.  */
4518   auto name_comp_compare = [&] (const name_component &left,
4519                                 const name_component &right)
4520     {
4521       const char *left_qualified = this->symbol_name_at (left.idx);
4522       const char *right_qualified = this->symbol_name_at (right.idx);
4523
4524       const char *left_name = left_qualified + left.name_offset;
4525       const char *right_name = right_qualified + right.name_offset;
4526
4527       return name_cmp (left_name, right_name) < 0;
4528     };
4529
4530   std::sort (this->name_components.begin (),
4531              this->name_components.end (),
4532              name_comp_compare);
4533 }
4534
4535 /* Helper for dw2_expand_symtabs_matching that works with a
4536    mapped_index_base instead of the containing objfile.  This is split
4537    to a separate function in order to be able to unit test the
4538    name_components matching using a mock mapped_index_base.  For each
4539    symbol name that matches, calls MATCH_CALLBACK, passing it the
4540    symbol's index in the mapped_index_base symbol table.  */
4541
4542 static void
4543 dw2_expand_symtabs_matching_symbol
4544   (mapped_index_base &index,
4545    const lookup_name_info &lookup_name_in,
4546    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4547    enum search_domain kind,
4548    gdb::function_view<void (offset_type)> match_callback)
4549 {
4550   lookup_name_info lookup_name_without_params
4551     = lookup_name_in.make_ignore_params ();
4552   gdb_index_symbol_name_matcher lookup_name_matcher
4553     (lookup_name_without_params);
4554
4555   /* Build the symbol name component sorted vector, if we haven't
4556      yet.  */
4557   index.build_name_components ();
4558
4559   auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4560
4561   /* Now for each symbol name in range, check to see if we have a name
4562      match, and if so, call the MATCH_CALLBACK callback.  */
4563
4564   /* The same symbol may appear more than once in the range though.
4565      E.g., if we're looking for symbols that complete "w", and we have
4566      a symbol named "w1::w2", we'll find the two name components for
4567      that same symbol in the range.  To be sure we only call the
4568      callback once per symbol, we first collect the symbol name
4569      indexes that matched in a temporary vector and ignore
4570      duplicates.  */
4571   std::vector<offset_type> matches;
4572   matches.reserve (std::distance (bounds.first, bounds.second));
4573
4574   for (; bounds.first != bounds.second; ++bounds.first)
4575     {
4576       const char *qualified = index.symbol_name_at (bounds.first->idx);
4577
4578       if (!lookup_name_matcher.matches (qualified)
4579           || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4580         continue;
4581
4582       matches.push_back (bounds.first->idx);
4583     }
4584
4585   std::sort (matches.begin (), matches.end ());
4586
4587   /* Finally call the callback, once per match.  */
4588   ULONGEST prev = -1;
4589   for (offset_type idx : matches)
4590     {
4591       if (prev != idx)
4592         {
4593           match_callback (idx);
4594           prev = idx;
4595         }
4596     }
4597
4598   /* Above we use a type wider than idx's for 'prev', since 0 and
4599      (offset_type)-1 are both possible values.  */
4600   static_assert (sizeof (prev) > sizeof (offset_type), "");
4601 }
4602
4603 #if GDB_SELF_TEST
4604
4605 namespace selftests { namespace dw2_expand_symtabs_matching {
4606
4607 /* A mock .gdb_index/.debug_names-like name index table, enough to
4608    exercise dw2_expand_symtabs_matching_symbol, which works with the
4609    mapped_index_base interface.  Builds an index from the symbol list
4610    passed as parameter to the constructor.  */
4611 class mock_mapped_index : public mapped_index_base
4612 {
4613 public:
4614   mock_mapped_index (gdb::array_view<const char *> symbols)
4615     : m_symbol_table (symbols)
4616   {}
4617
4618   DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4619
4620   /* Return the number of names in the symbol table.  */
4621   size_t symbol_name_count () const override
4622   {
4623     return m_symbol_table.size ();
4624   }
4625
4626   /* Get the name of the symbol at IDX in the symbol table.  */
4627   const char *symbol_name_at (offset_type idx) const override
4628   {
4629     return m_symbol_table[idx];
4630   }
4631
4632 private:
4633   gdb::array_view<const char *> m_symbol_table;
4634 };
4635
4636 /* Convenience function that converts a NULL pointer to a "<null>"
4637    string, to pass to print routines.  */
4638
4639 static const char *
4640 string_or_null (const char *str)
4641 {
4642   return str != NULL ? str : "<null>";
4643 }
4644
4645 /* Check if a lookup_name_info built from
4646    NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4647    index.  EXPECTED_LIST is the list of expected matches, in expected
4648    matching order.  If no match expected, then an empty list is
4649    specified.  Returns true on success.  On failure prints a warning
4650    indicating the file:line that failed, and returns false.  */
4651
4652 static bool
4653 check_match (const char *file, int line,
4654              mock_mapped_index &mock_index,
4655              const char *name, symbol_name_match_type match_type,
4656              bool completion_mode,
4657              std::initializer_list<const char *> expected_list)
4658 {
4659   lookup_name_info lookup_name (name, match_type, completion_mode);
4660
4661   bool matched = true;
4662
4663   auto mismatch = [&] (const char *expected_str,
4664                        const char *got)
4665   {
4666     warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4667                "expected=\"%s\", got=\"%s\"\n"),
4668              file, line,
4669              (match_type == symbol_name_match_type::FULL
4670               ? "FULL" : "WILD"),
4671              name, string_or_null (expected_str), string_or_null (got));
4672     matched = false;
4673   };
4674
4675   auto expected_it = expected_list.begin ();
4676   auto expected_end = expected_list.end ();
4677
4678   dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4679                                       NULL, ALL_DOMAIN,
4680                                       [&] (offset_type idx)
4681   {
4682     const char *matched_name = mock_index.symbol_name_at (idx);
4683     const char *expected_str
4684       = expected_it == expected_end ? NULL : *expected_it++;
4685
4686     if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4687       mismatch (expected_str, matched_name);
4688   });
4689
4690   const char *expected_str
4691   = expected_it == expected_end ? NULL : *expected_it++;
4692   if (expected_str != NULL)
4693     mismatch (expected_str, NULL);
4694
4695   return matched;
4696 }
4697
4698 /* The symbols added to the mock mapped_index for testing (in
4699    canonical form).  */
4700 static const char *test_symbols[] = {
4701   "function",
4702   "std::bar",
4703   "std::zfunction",
4704   "std::zfunction2",
4705   "w1::w2",
4706   "ns::foo<char*>",
4707   "ns::foo<int>",
4708   "ns::foo<long>",
4709   "ns2::tmpl<int>::foo2",
4710   "(anonymous namespace)::A::B::C",
4711
4712   /* These are used to check that the increment-last-char in the
4713      matching algorithm for completion doesn't match "t1_fund" when
4714      completing "t1_func".  */
4715   "t1_func",
4716   "t1_func1",
4717   "t1_fund",
4718   "t1_fund1",
4719
4720   /* A UTF-8 name with multi-byte sequences to make sure that
4721      cp-name-parser understands this as a single identifier ("função"
4722      is "function" in PT).  */
4723   u8"u8função",
4724
4725   /* \377 (0xff) is Latin1 'ÿ'.  */
4726   "yfunc\377",
4727
4728   /* \377 (0xff) is Latin1 'ÿ'.  */
4729   "\377",
4730   "\377\377123",
4731
4732   /* A name with all sorts of complications.  Starts with "z" to make
4733      it easier for the completion tests below.  */
4734 #define Z_SYM_NAME \
4735   "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4736     "::tuple<(anonymous namespace)::ui*, " \
4737     "std::default_delete<(anonymous namespace)::ui>, void>"
4738
4739   Z_SYM_NAME
4740 };
4741
4742 /* Returns true if the mapped_index_base::find_name_component_bounds
4743    method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4744    in completion mode.  */
4745
4746 static bool
4747 check_find_bounds_finds (mapped_index_base &index,
4748                          const char *search_name,
4749                          gdb::array_view<const char *> expected_syms)
4750 {
4751   lookup_name_info lookup_name (search_name,
4752                                 symbol_name_match_type::FULL, true);
4753
4754   auto bounds = index.find_name_components_bounds (lookup_name);
4755
4756   size_t distance = std::distance (bounds.first, bounds.second);
4757   if (distance != expected_syms.size ())
4758     return false;
4759
4760   for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4761     {
4762       auto nc_elem = bounds.first + exp_elem;
4763       const char *qualified = index.symbol_name_at (nc_elem->idx);
4764       if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4765         return false;
4766     }
4767
4768   return true;
4769 }
4770
4771 /* Test the lower-level mapped_index::find_name_component_bounds
4772    method.  */
4773
4774 static void
4775 test_mapped_index_find_name_component_bounds ()
4776 {
4777   mock_mapped_index mock_index (test_symbols);
4778
4779   mock_index.build_name_components ();
4780
4781   /* Test the lower-level mapped_index::find_name_component_bounds
4782      method in completion mode.  */
4783   {
4784     static const char *expected_syms[] = {
4785       "t1_func",
4786       "t1_func1",
4787     };
4788
4789     SELF_CHECK (check_find_bounds_finds (mock_index,
4790                                          "t1_func", expected_syms));
4791   }
4792
4793   /* Check that the increment-last-char in the name matching algorithm
4794      for completion doesn't get confused with Ansi1 'ÿ' / 0xff.  */
4795   {
4796     static const char *expected_syms1[] = {
4797       "\377",
4798       "\377\377123",
4799     };
4800     SELF_CHECK (check_find_bounds_finds (mock_index,
4801                                          "\377", expected_syms1));
4802
4803     static const char *expected_syms2[] = {
4804       "\377\377123",
4805     };
4806     SELF_CHECK (check_find_bounds_finds (mock_index,
4807                                          "\377\377", expected_syms2));
4808   }
4809 }
4810
4811 /* Test dw2_expand_symtabs_matching_symbol.  */
4812
4813 static void
4814 test_dw2_expand_symtabs_matching_symbol ()
4815 {
4816   mock_mapped_index mock_index (test_symbols);
4817
4818   /* We let all tests run until the end even if some fails, for debug
4819      convenience.  */
4820   bool any_mismatch = false;
4821
4822   /* Create the expected symbols list (an initializer_list).  Needed
4823      because lists have commas, and we need to pass them to CHECK,
4824      which is a macro.  */
4825 #define EXPECT(...) { __VA_ARGS__ }
4826
4827   /* Wrapper for check_match that passes down the current
4828      __FILE__/__LINE__.  */
4829 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST)   \
4830   any_mismatch |= !check_match (__FILE__, __LINE__,                     \
4831                                 mock_index,                             \
4832                                 NAME, MATCH_TYPE, COMPLETION_MODE,      \
4833                                 EXPECTED_LIST)
4834
4835   /* Identity checks.  */
4836   for (const char *sym : test_symbols)
4837     {
4838       /* Should be able to match all existing symbols.  */
4839       CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4840                    EXPECT (sym));
4841
4842       /* Should be able to match all existing symbols with
4843          parameters.  */
4844       std::string with_params = std::string (sym) + "(int)";
4845       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4846                    EXPECT (sym));
4847
4848       /* Should be able to match all existing symbols with
4849          parameters and qualifiers.  */
4850       with_params = std::string (sym) + " ( int ) const";
4851       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4852                    EXPECT (sym));
4853
4854       /* This should really find sym, but cp-name-parser.y doesn't
4855          know about lvalue/rvalue qualifiers yet.  */
4856       with_params = std::string (sym) + " ( int ) &&";
4857       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4858                    {});
4859     }
4860
4861   /* Check that the name matching algorithm for completion doesn't get
4862      confused with Latin1 'ÿ' / 0xff.  */
4863   {
4864     static const char str[] = "\377";
4865     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4866                  EXPECT ("\377", "\377\377123"));
4867   }
4868
4869   /* Check that the increment-last-char in the matching algorithm for
4870      completion doesn't match "t1_fund" when completing "t1_func".  */
4871   {
4872     static const char str[] = "t1_func";
4873     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4874                  EXPECT ("t1_func", "t1_func1"));
4875   }
4876
4877   /* Check that completion mode works at each prefix of the expected
4878      symbol name.  */
4879   {
4880     static const char str[] = "function(int)";
4881     size_t len = strlen (str);
4882     std::string lookup;
4883
4884     for (size_t i = 1; i < len; i++)
4885       {
4886         lookup.assign (str, i);
4887         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4888                      EXPECT ("function"));
4889       }
4890   }
4891
4892   /* While "w" is a prefix of both components, the match function
4893      should still only be called once.  */
4894   {
4895     CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4896                  EXPECT ("w1::w2"));
4897     CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4898                  EXPECT ("w1::w2"));
4899   }
4900
4901   /* Same, with a "complicated" symbol.  */
4902   {
4903     static const char str[] = Z_SYM_NAME;
4904     size_t len = strlen (str);
4905     std::string lookup;
4906
4907     for (size_t i = 1; i < len; i++)
4908       {
4909         lookup.assign (str, i);
4910         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4911                      EXPECT (Z_SYM_NAME));
4912       }
4913   }
4914
4915   /* In FULL mode, an incomplete symbol doesn't match.  */
4916   {
4917     CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4918                  {});
4919   }
4920
4921   /* A complete symbol with parameters matches any overload, since the
4922      index has no overload info.  */
4923   {
4924     CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4925                  EXPECT ("std::zfunction", "std::zfunction2"));
4926     CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4927                  EXPECT ("std::zfunction", "std::zfunction2"));
4928     CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4929                  EXPECT ("std::zfunction", "std::zfunction2"));
4930   }
4931
4932   /* Check that whitespace is ignored appropriately.  A symbol with a
4933      template argument list. */
4934   {
4935     static const char expected[] = "ns::foo<int>";
4936     CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4937                  EXPECT (expected));
4938     CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4939                  EXPECT (expected));
4940   }
4941
4942   /* Check that whitespace is ignored appropriately.  A symbol with a
4943      template argument list that includes a pointer.  */
4944   {
4945     static const char expected[] = "ns::foo<char*>";
4946     /* Try both completion and non-completion modes.  */
4947     static const bool completion_mode[2] = {false, true};
4948     for (size_t i = 0; i < 2; i++)
4949       {
4950         CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4951                      completion_mode[i], EXPECT (expected));
4952         CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4953                      completion_mode[i], EXPECT (expected));
4954
4955         CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4956                      completion_mode[i], EXPECT (expected));
4957         CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4958                      completion_mode[i], EXPECT (expected));
4959       }
4960   }
4961
4962   {
4963     /* Check method qualifiers are ignored.  */
4964     static const char expected[] = "ns::foo<char*>";
4965     CHECK_MATCH ("ns :: foo < char * >  ( int ) const",
4966                  symbol_name_match_type::FULL, true, EXPECT (expected));
4967     CHECK_MATCH ("ns :: foo < char * >  ( int ) &&",
4968                  symbol_name_match_type::FULL, true, EXPECT (expected));
4969     CHECK_MATCH ("foo < char * >  ( int ) const",
4970                  symbol_name_match_type::WILD, true, EXPECT (expected));
4971     CHECK_MATCH ("foo < char * >  ( int ) &&",
4972                  symbol_name_match_type::WILD, true, EXPECT (expected));
4973   }
4974
4975   /* Test lookup names that don't match anything.  */
4976   {
4977     CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4978                  {});
4979
4980     CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4981                  {});
4982   }
4983
4984   /* Some wild matching tests, exercising "(anonymous namespace)",
4985      which should not be confused with a parameter list.  */
4986   {
4987     static const char *syms[] = {
4988       "A::B::C",
4989       "B::C",
4990       "C",
4991       "A :: B :: C ( int )",
4992       "B :: C ( int )",
4993       "C ( int )",
4994     };
4995
4996     for (const char *s : syms)
4997       {
4998         CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4999                      EXPECT ("(anonymous namespace)::A::B::C"));
5000       }
5001   }
5002
5003   {
5004     static const char expected[] = "ns2::tmpl<int>::foo2";
5005     CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
5006                  EXPECT (expected));
5007     CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
5008                  EXPECT (expected));
5009   }
5010
5011   SELF_CHECK (!any_mismatch);
5012
5013 #undef EXPECT
5014 #undef CHECK_MATCH
5015 }
5016
5017 static void
5018 run_test ()
5019 {
5020   test_mapped_index_find_name_component_bounds ();
5021   test_dw2_expand_symtabs_matching_symbol ();
5022 }
5023
5024 }} // namespace selftests::dw2_expand_symtabs_matching
5025
5026 #endif /* GDB_SELF_TEST */
5027
5028 /* If FILE_MATCHER is NULL or if PER_CU has
5029    dwarf2_per_cu_quick_data::MARK set (see
5030    dw_expand_symtabs_matching_file_matcher), expand the CU and call
5031    EXPANSION_NOTIFY on it.  */
5032
5033 static void
5034 dw2_expand_symtabs_matching_one
5035   (struct dwarf2_per_cu_data *per_cu,
5036    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5037    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5038 {
5039   if (file_matcher == NULL || per_cu->v.quick->mark)
5040     {
5041       bool symtab_was_null
5042         = (per_cu->v.quick->compunit_symtab == NULL);
5043
5044       dw2_instantiate_symtab (per_cu, false);
5045
5046       if (expansion_notify != NULL
5047           && symtab_was_null
5048           && per_cu->v.quick->compunit_symtab != NULL)
5049         expansion_notify (per_cu->v.quick->compunit_symtab);
5050     }
5051 }
5052
5053 /* Helper for dw2_expand_matching symtabs.  Called on each symbol
5054    matched, to expand corresponding CUs that were marked.  IDX is the
5055    index of the symbol name that matched.  */
5056
5057 static void
5058 dw2_expand_marked_cus
5059   (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5060    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5061    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5062    search_domain kind)
5063 {
5064   offset_type *vec, vec_len, vec_idx;
5065   bool global_seen = false;
5066   mapped_index &index = *dwarf2_per_objfile->index_table;
5067
5068   vec = (offset_type *) (index.constant_pool
5069                          + MAYBE_SWAP (index.symbol_table[idx].vec));
5070   vec_len = MAYBE_SWAP (vec[0]);
5071   for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5072     {
5073       offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5074       /* This value is only valid for index versions >= 7.  */
5075       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5076       gdb_index_symbol_kind symbol_kind =
5077         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5078       int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5079       /* Only check the symbol attributes if they're present.
5080          Indices prior to version 7 don't record them,
5081          and indices >= 7 may elide them for certain symbols
5082          (gold does this).  */
5083       int attrs_valid =
5084         (index.version >= 7
5085          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5086
5087       /* Work around gold/15646.  */
5088       if (attrs_valid)
5089         {
5090           if (!is_static && global_seen)
5091             continue;
5092           if (!is_static)
5093             global_seen = true;
5094         }
5095
5096       /* Only check the symbol's kind if it has one.  */
5097       if (attrs_valid)
5098         {
5099           switch (kind)
5100             {
5101             case VARIABLES_DOMAIN:
5102               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5103                 continue;
5104               break;
5105             case FUNCTIONS_DOMAIN:
5106               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5107                 continue;
5108               break;
5109             case TYPES_DOMAIN:
5110               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5111                 continue;
5112               break;
5113             default:
5114               break;
5115             }
5116         }
5117
5118       /* Don't crash on bad data.  */
5119       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5120                        + dwarf2_per_objfile->all_type_units.size ()))
5121         {
5122           complaint (_(".gdb_index entry has bad CU index"
5123                        " [in module %s]"),
5124                        objfile_name (dwarf2_per_objfile->objfile));
5125           continue;
5126         }
5127
5128       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5129       dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5130                                        expansion_notify);
5131     }
5132 }
5133
5134 /* If FILE_MATCHER is non-NULL, set all the
5135    dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5136    that match FILE_MATCHER.  */
5137
5138 static void
5139 dw_expand_symtabs_matching_file_matcher
5140   (struct dwarf2_per_objfile *dwarf2_per_objfile,
5141    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5142 {
5143   if (file_matcher == NULL)
5144     return;
5145
5146   objfile *const objfile = dwarf2_per_objfile->objfile;
5147
5148   htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5149                                             htab_eq_pointer,
5150                                             NULL, xcalloc, xfree));
5151   htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5152                                                 htab_eq_pointer,
5153                                                 NULL, xcalloc, xfree));
5154
5155   /* The rule is CUs specify all the files, including those used by
5156      any TU, so there's no need to scan TUs here.  */
5157
5158   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5159     {
5160       QUIT;
5161
5162       per_cu->v.quick->mark = 0;
5163
5164       /* We only need to look at symtabs not already expanded.  */
5165       if (per_cu->v.quick->compunit_symtab)
5166         continue;
5167
5168       quick_file_names *file_data = dw2_get_file_names (per_cu);
5169       if (file_data == NULL)
5170         continue;
5171
5172       if (htab_find (visited_not_found.get (), file_data) != NULL)
5173         continue;
5174       else if (htab_find (visited_found.get (), file_data) != NULL)
5175         {
5176           per_cu->v.quick->mark = 1;
5177           continue;
5178         }
5179
5180       for (int j = 0; j < file_data->num_file_names; ++j)
5181         {
5182           const char *this_real_name;
5183
5184           if (file_matcher (file_data->file_names[j], false))
5185             {
5186               per_cu->v.quick->mark = 1;
5187               break;
5188             }
5189
5190           /* Before we invoke realpath, which can get expensive when many
5191              files are involved, do a quick comparison of the basenames.  */
5192           if (!basenames_may_differ
5193               && !file_matcher (lbasename (file_data->file_names[j]),
5194                                 true))
5195             continue;
5196
5197           this_real_name = dw2_get_real_path (objfile, file_data, j);
5198           if (file_matcher (this_real_name, false))
5199             {
5200               per_cu->v.quick->mark = 1;
5201               break;
5202             }
5203         }
5204
5205       void **slot = htab_find_slot (per_cu->v.quick->mark
5206                                     ? visited_found.get ()
5207                                     : visited_not_found.get (),
5208                                     file_data, INSERT);
5209       *slot = file_data;
5210     }
5211 }
5212
5213 static void
5214 dw2_expand_symtabs_matching
5215   (struct objfile *objfile,
5216    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5217    const lookup_name_info &lookup_name,
5218    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5219    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5220    enum search_domain kind)
5221 {
5222   struct dwarf2_per_objfile *dwarf2_per_objfile
5223     = get_dwarf2_per_objfile (objfile);
5224
5225   /* index_table is NULL if OBJF_READNOW.  */
5226   if (!dwarf2_per_objfile->index_table)
5227     return;
5228
5229   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5230
5231   mapped_index &index = *dwarf2_per_objfile->index_table;
5232
5233   dw2_expand_symtabs_matching_symbol (index, lookup_name,
5234                                       symbol_matcher,
5235                                       kind, [&] (offset_type idx)
5236     {
5237       dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5238                              expansion_notify, kind);
5239     });
5240 }
5241
5242 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5243    symtab.  */
5244
5245 static struct compunit_symtab *
5246 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5247                                           CORE_ADDR pc)
5248 {
5249   int i;
5250
5251   if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5252       && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5253     return cust;
5254
5255   if (cust->includes == NULL)
5256     return NULL;
5257
5258   for (i = 0; cust->includes[i]; ++i)
5259     {
5260       struct compunit_symtab *s = cust->includes[i];
5261
5262       s = recursively_find_pc_sect_compunit_symtab (s, pc);
5263       if (s != NULL)
5264         return s;
5265     }
5266
5267   return NULL;
5268 }
5269
5270 static struct compunit_symtab *
5271 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5272                                   struct bound_minimal_symbol msymbol,
5273                                   CORE_ADDR pc,
5274                                   struct obj_section *section,
5275                                   int warn_if_readin)
5276 {
5277   struct dwarf2_per_cu_data *data;
5278   struct compunit_symtab *result;
5279
5280   if (!objfile->partial_symtabs->psymtabs_addrmap)
5281     return NULL;
5282
5283   CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5284                                  SECT_OFF_TEXT (objfile));
5285   data = (struct dwarf2_per_cu_data *) addrmap_find
5286     (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5287   if (!data)
5288     return NULL;
5289
5290   if (warn_if_readin && data->v.quick->compunit_symtab)
5291     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5292              paddress (get_objfile_arch (objfile), pc));
5293
5294   result
5295     = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5296                                                                         false),
5297                                                 pc);
5298   gdb_assert (result != NULL);
5299   return result;
5300 }
5301
5302 static void
5303 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5304                           void *data, int need_fullname)
5305 {
5306   struct dwarf2_per_objfile *dwarf2_per_objfile
5307     = get_dwarf2_per_objfile (objfile);
5308
5309   if (!dwarf2_per_objfile->filenames_cache)
5310     {
5311       dwarf2_per_objfile->filenames_cache.emplace ();
5312
5313       htab_up visited (htab_create_alloc (10,
5314                                           htab_hash_pointer, htab_eq_pointer,
5315                                           NULL, xcalloc, xfree));
5316
5317       /* The rule is CUs specify all the files, including those used
5318          by any TU, so there's no need to scan TUs here.  We can
5319          ignore file names coming from already-expanded CUs.  */
5320
5321       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5322         {
5323           if (per_cu->v.quick->compunit_symtab)
5324             {
5325               void **slot = htab_find_slot (visited.get (),
5326                                             per_cu->v.quick->file_names,
5327                                             INSERT);
5328
5329               *slot = per_cu->v.quick->file_names;
5330             }
5331         }
5332
5333       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5334         {
5335           /* We only need to look at symtabs not already expanded.  */
5336           if (per_cu->v.quick->compunit_symtab)
5337             continue;
5338
5339           quick_file_names *file_data = dw2_get_file_names (per_cu);
5340           if (file_data == NULL)
5341             continue;
5342
5343           void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5344           if (*slot)
5345             {
5346               /* Already visited.  */
5347               continue;
5348             }
5349           *slot = file_data;
5350
5351           for (int j = 0; j < file_data->num_file_names; ++j)
5352             {
5353               const char *filename = file_data->file_names[j];
5354               dwarf2_per_objfile->filenames_cache->seen (filename);
5355             }
5356         }
5357     }
5358
5359   dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5360     {
5361       gdb::unique_xmalloc_ptr<char> this_real_name;
5362
5363       if (need_fullname)
5364         this_real_name = gdb_realpath (filename);
5365       (*fun) (filename, this_real_name.get (), data);
5366     });
5367 }
5368
5369 static int
5370 dw2_has_symbols (struct objfile *objfile)
5371 {
5372   return 1;
5373 }
5374
5375 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5376 {
5377   dw2_has_symbols,
5378   dw2_find_last_source_symtab,
5379   dw2_forget_cached_source_info,
5380   dw2_map_symtabs_matching_filename,
5381   dw2_lookup_symbol,
5382   dw2_print_stats,
5383   dw2_dump,
5384   dw2_expand_symtabs_for_function,
5385   dw2_expand_all_symtabs,
5386   dw2_expand_symtabs_with_fullname,
5387   dw2_map_matching_symbols,
5388   dw2_expand_symtabs_matching,
5389   dw2_find_pc_sect_compunit_symtab,
5390   NULL,
5391   dw2_map_symbol_filenames
5392 };
5393
5394 /* DWARF-5 debug_names reader.  */
5395
5396 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension.  */
5397 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5398
5399 /* A helper function that reads the .debug_names section in SECTION
5400    and fills in MAP.  FILENAME is the name of the file containing the
5401    section; it is used for error reporting.
5402
5403    Returns true if all went well, false otherwise.  */
5404
5405 static bool
5406 read_debug_names_from_section (struct objfile *objfile,
5407                                const char *filename,
5408                                struct dwarf2_section_info *section,
5409                                mapped_debug_names &map)
5410 {
5411   if (dwarf2_section_empty_p (section))
5412     return false;
5413
5414   /* Older elfutils strip versions could keep the section in the main
5415      executable while splitting it for the separate debug info file.  */
5416   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5417     return false;
5418
5419   dwarf2_read_section (objfile, section);
5420
5421   map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5422
5423   const gdb_byte *addr = section->buffer;
5424
5425   bfd *const abfd = get_section_bfd_owner (section);
5426
5427   unsigned int bytes_read;
5428   LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5429   addr += bytes_read;
5430
5431   map.dwarf5_is_dwarf64 = bytes_read != 4;
5432   map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5433   if (bytes_read + length != section->size)
5434     {
5435       /* There may be multiple per-CU indices.  */
5436       warning (_("Section .debug_names in %s length %s does not match "
5437                  "section length %s, ignoring .debug_names."),
5438                filename, plongest (bytes_read + length),
5439                pulongest (section->size));
5440       return false;
5441     }
5442
5443   /* The version number.  */
5444   uint16_t version = read_2_bytes (abfd, addr);
5445   addr += 2;
5446   if (version != 5)
5447     {
5448       warning (_("Section .debug_names in %s has unsupported version %d, "
5449                  "ignoring .debug_names."),
5450                filename, version);
5451       return false;
5452     }
5453
5454   /* Padding.  */
5455   uint16_t padding = read_2_bytes (abfd, addr);
5456   addr += 2;
5457   if (padding != 0)
5458     {
5459       warning (_("Section .debug_names in %s has unsupported padding %d, "
5460                  "ignoring .debug_names."),
5461                filename, padding);
5462       return false;
5463     }
5464
5465   /* comp_unit_count - The number of CUs in the CU list.  */
5466   map.cu_count = read_4_bytes (abfd, addr);
5467   addr += 4;
5468
5469   /* local_type_unit_count - The number of TUs in the local TU
5470      list.  */
5471   map.tu_count = read_4_bytes (abfd, addr);
5472   addr += 4;
5473
5474   /* foreign_type_unit_count - The number of TUs in the foreign TU
5475      list.  */
5476   uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5477   addr += 4;
5478   if (foreign_tu_count != 0)
5479     {
5480       warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5481                  "ignoring .debug_names."),
5482                filename, static_cast<unsigned long> (foreign_tu_count));
5483       return false;
5484     }
5485
5486   /* bucket_count - The number of hash buckets in the hash lookup
5487      table.  */
5488   map.bucket_count = read_4_bytes (abfd, addr);
5489   addr += 4;
5490
5491   /* name_count - The number of unique names in the index.  */
5492   map.name_count = read_4_bytes (abfd, addr);
5493   addr += 4;
5494
5495   /* abbrev_table_size - The size in bytes of the abbreviations
5496      table.  */
5497   uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5498   addr += 4;
5499
5500   /* augmentation_string_size - The size in bytes of the augmentation
5501      string.  This value is rounded up to a multiple of 4.  */
5502   uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5503   addr += 4;
5504   map.augmentation_is_gdb = ((augmentation_string_size
5505                               == sizeof (dwarf5_augmentation))
5506                              && memcmp (addr, dwarf5_augmentation,
5507                                         sizeof (dwarf5_augmentation)) == 0);
5508   augmentation_string_size += (-augmentation_string_size) & 3;
5509   addr += augmentation_string_size;
5510
5511   /* List of CUs */
5512   map.cu_table_reordered = addr;
5513   addr += map.cu_count * map.offset_size;
5514
5515   /* List of Local TUs */
5516   map.tu_table_reordered = addr;
5517   addr += map.tu_count * map.offset_size;
5518
5519   /* Hash Lookup Table */
5520   map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5521   addr += map.bucket_count * 4;
5522   map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5523   addr += map.name_count * 4;
5524
5525   /* Name Table */
5526   map.name_table_string_offs_reordered = addr;
5527   addr += map.name_count * map.offset_size;
5528   map.name_table_entry_offs_reordered = addr;
5529   addr += map.name_count * map.offset_size;
5530
5531   const gdb_byte *abbrev_table_start = addr;
5532   for (;;)
5533     {
5534       const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5535       addr += bytes_read;
5536       if (index_num == 0)
5537         break;
5538
5539       const auto insertpair
5540         = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5541       if (!insertpair.second)
5542         {
5543           warning (_("Section .debug_names in %s has duplicate index %s, "
5544                      "ignoring .debug_names."),
5545                    filename, pulongest (index_num));
5546           return false;
5547         }
5548       mapped_debug_names::index_val &indexval = insertpair.first->second;
5549       indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5550       addr += bytes_read;
5551
5552       for (;;)
5553         {
5554           mapped_debug_names::index_val::attr attr;
5555           attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5556           addr += bytes_read;
5557           attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5558           addr += bytes_read;
5559           if (attr.form == DW_FORM_implicit_const)
5560             {
5561               attr.implicit_const = read_signed_leb128 (abfd, addr,
5562                                                         &bytes_read);
5563               addr += bytes_read;
5564             }
5565           if (attr.dw_idx == 0 && attr.form == 0)
5566             break;
5567           indexval.attr_vec.push_back (std::move (attr));
5568         }
5569     }
5570   if (addr != abbrev_table_start + abbrev_table_size)
5571     {
5572       warning (_("Section .debug_names in %s has abbreviation_table "
5573                  "of size %zu vs. written as %u, ignoring .debug_names."),
5574                filename, addr - abbrev_table_start, abbrev_table_size);
5575       return false;
5576     }
5577   map.entry_pool = addr;
5578
5579   return true;
5580 }
5581
5582 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5583    list.  */
5584
5585 static void
5586 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5587                                   const mapped_debug_names &map,
5588                                   dwarf2_section_info &section,
5589                                   bool is_dwz)
5590 {
5591   sect_offset sect_off_prev;
5592   for (uint32_t i = 0; i <= map.cu_count; ++i)
5593     {
5594       sect_offset sect_off_next;
5595       if (i < map.cu_count)
5596         {
5597           sect_off_next
5598             = (sect_offset) (extract_unsigned_integer
5599                              (map.cu_table_reordered + i * map.offset_size,
5600                               map.offset_size,
5601                               map.dwarf5_byte_order));
5602         }
5603       else
5604         sect_off_next = (sect_offset) section.size;
5605       if (i >= 1)
5606         {
5607           const ULONGEST length = sect_off_next - sect_off_prev;
5608           dwarf2_per_cu_data *per_cu
5609             = create_cu_from_index_list (dwarf2_per_objfile, &section, is_dwz,
5610                                          sect_off_prev, length);
5611           dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5612         }
5613       sect_off_prev = sect_off_next;
5614     }
5615 }
5616
5617 /* Read the CU list from the mapped index, and use it to create all
5618    the CU objects for this dwarf2_per_objfile.  */
5619
5620 static void
5621 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5622                              const mapped_debug_names &map,
5623                              const mapped_debug_names &dwz_map)
5624 {
5625   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5626   dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5627
5628   create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5629                                     dwarf2_per_objfile->info,
5630                                     false /* is_dwz */);
5631
5632   if (dwz_map.cu_count == 0)
5633     return;
5634
5635   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5636   create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5637                                     true /* is_dwz */);
5638 }
5639
5640 /* Read .debug_names.  If everything went ok, initialize the "quick"
5641    elements of all the CUs and return true.  Otherwise, return false.  */
5642
5643 static bool
5644 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5645 {
5646   std::unique_ptr<mapped_debug_names> map
5647     (new mapped_debug_names (dwarf2_per_objfile));
5648   mapped_debug_names dwz_map (dwarf2_per_objfile);
5649   struct objfile *objfile = dwarf2_per_objfile->objfile;
5650
5651   if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5652                                       &dwarf2_per_objfile->debug_names,
5653                                       *map))
5654     return false;
5655
5656   /* Don't use the index if it's empty.  */
5657   if (map->name_count == 0)
5658     return false;
5659
5660   /* If there is a .dwz file, read it so we can get its CU list as
5661      well.  */
5662   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5663   if (dwz != NULL)
5664     {
5665       if (!read_debug_names_from_section (objfile,
5666                                           bfd_get_filename (dwz->dwz_bfd),
5667                                           &dwz->debug_names, dwz_map))
5668         {
5669           warning (_("could not read '.debug_names' section from %s; skipping"),
5670                    bfd_get_filename (dwz->dwz_bfd));
5671           return false;
5672         }
5673     }
5674
5675   create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5676
5677   if (map->tu_count != 0)
5678     {
5679       /* We can only handle a single .debug_types when we have an
5680          index.  */
5681       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5682         return false;
5683
5684       dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5685                                                 dwarf2_per_objfile->types, 0);
5686
5687       create_signatured_type_table_from_debug_names
5688         (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5689     }
5690
5691   create_addrmap_from_aranges (dwarf2_per_objfile,
5692                                &dwarf2_per_objfile->debug_aranges);
5693
5694   dwarf2_per_objfile->debug_names_table = std::move (map);
5695   dwarf2_per_objfile->using_index = 1;
5696   dwarf2_per_objfile->quick_file_names_table =
5697     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5698
5699   return true;
5700 }
5701
5702 /* Type used to manage iterating over all CUs looking for a symbol for
5703    .debug_names.  */
5704
5705 class dw2_debug_names_iterator
5706 {
5707 public:
5708   /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5709      BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
5710   dw2_debug_names_iterator (const mapped_debug_names &map,
5711                             bool want_specific_block,
5712                             block_enum block_index, domain_enum domain,
5713                             const char *name)
5714     : m_map (map), m_want_specific_block (want_specific_block),
5715       m_block_index (block_index), m_domain (domain),
5716       m_addr (find_vec_in_debug_names (map, name))
5717   {}
5718
5719   dw2_debug_names_iterator (const mapped_debug_names &map,
5720                             search_domain search, uint32_t namei)
5721     : m_map (map),
5722       m_search (search),
5723       m_addr (find_vec_in_debug_names (map, namei))
5724   {}
5725
5726   /* Return the next matching CU or NULL if there are no more.  */
5727   dwarf2_per_cu_data *next ();
5728
5729 private:
5730   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5731                                                   const char *name);
5732   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5733                                                   uint32_t namei);
5734
5735   /* The internalized form of .debug_names.  */
5736   const mapped_debug_names &m_map;
5737
5738   /* If true, only look for symbols that match BLOCK_INDEX.  */
5739   const bool m_want_specific_block = false;
5740
5741   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5742      Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5743      value.  */
5744   const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5745
5746   /* The kind of symbol we're looking for.  */
5747   const domain_enum m_domain = UNDEF_DOMAIN;
5748   const search_domain m_search = ALL_DOMAIN;
5749
5750   /* The list of CUs from the index entry of the symbol, or NULL if
5751      not found.  */
5752   const gdb_byte *m_addr;
5753 };
5754
5755 const char *
5756 mapped_debug_names::namei_to_name (uint32_t namei) const
5757 {
5758   const ULONGEST namei_string_offs
5759     = extract_unsigned_integer ((name_table_string_offs_reordered
5760                                  + namei * offset_size),
5761                                 offset_size,
5762                                 dwarf5_byte_order);
5763   return read_indirect_string_at_offset
5764     (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5765 }
5766
5767 /* Find a slot in .debug_names for the object named NAME.  If NAME is
5768    found, return pointer to its pool data.  If NAME cannot be found,
5769    return NULL.  */
5770
5771 const gdb_byte *
5772 dw2_debug_names_iterator::find_vec_in_debug_names
5773   (const mapped_debug_names &map, const char *name)
5774 {
5775   int (*cmp) (const char *, const char *);
5776
5777   if (current_language->la_language == language_cplus
5778       || current_language->la_language == language_fortran
5779       || current_language->la_language == language_d)
5780     {
5781       /* NAME is already canonical.  Drop any qualifiers as
5782          .debug_names does not contain any.  */
5783
5784       if (strchr (name, '(') != NULL)
5785         {
5786           gdb::unique_xmalloc_ptr<char> without_params
5787             = cp_remove_params (name);
5788
5789           if (without_params != NULL)
5790             {
5791               name = without_params.get();
5792             }
5793         }
5794     }
5795
5796   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5797
5798   const uint32_t full_hash = dwarf5_djb_hash (name);
5799   uint32_t namei
5800     = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5801                                 (map.bucket_table_reordered
5802                                  + (full_hash % map.bucket_count)), 4,
5803                                 map.dwarf5_byte_order);
5804   if (namei == 0)
5805     return NULL;
5806   --namei;
5807   if (namei >= map.name_count)
5808     {
5809       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5810                    "[in module %s]"),
5811                  namei, map.name_count,
5812                  objfile_name (map.dwarf2_per_objfile->objfile));
5813       return NULL;
5814     }
5815
5816   for (;;)
5817     {
5818       const uint32_t namei_full_hash
5819         = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5820                                     (map.hash_table_reordered + namei), 4,
5821                                     map.dwarf5_byte_order);
5822       if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5823         return NULL;
5824
5825       if (full_hash == namei_full_hash)
5826         {
5827           const char *const namei_string = map.namei_to_name (namei);
5828
5829 #if 0 /* An expensive sanity check.  */
5830           if (namei_full_hash != dwarf5_djb_hash (namei_string))
5831             {
5832               complaint (_("Wrong .debug_names hash for string at index %u "
5833                            "[in module %s]"),
5834                          namei, objfile_name (dwarf2_per_objfile->objfile));
5835               return NULL;
5836             }
5837 #endif
5838
5839           if (cmp (namei_string, name) == 0)
5840             {
5841               const ULONGEST namei_entry_offs
5842                 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5843                                              + namei * map.offset_size),
5844                                             map.offset_size, map.dwarf5_byte_order);
5845               return map.entry_pool + namei_entry_offs;
5846             }
5847         }
5848
5849       ++namei;
5850       if (namei >= map.name_count)
5851         return NULL;
5852     }
5853 }
5854
5855 const gdb_byte *
5856 dw2_debug_names_iterator::find_vec_in_debug_names
5857   (const mapped_debug_names &map, uint32_t namei)
5858 {
5859   if (namei >= map.name_count)
5860     {
5861       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5862                    "[in module %s]"),
5863                  namei, map.name_count,
5864                  objfile_name (map.dwarf2_per_objfile->objfile));
5865       return NULL;
5866     }
5867
5868   const ULONGEST namei_entry_offs
5869     = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5870                                  + namei * map.offset_size),
5871                                 map.offset_size, map.dwarf5_byte_order);
5872   return map.entry_pool + namei_entry_offs;
5873 }
5874
5875 /* See dw2_debug_names_iterator.  */
5876
5877 dwarf2_per_cu_data *
5878 dw2_debug_names_iterator::next ()
5879 {
5880   if (m_addr == NULL)
5881     return NULL;
5882
5883   struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5884   struct objfile *objfile = dwarf2_per_objfile->objfile;
5885   bfd *const abfd = objfile->obfd;
5886
5887  again:
5888
5889   unsigned int bytes_read;
5890   const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5891   m_addr += bytes_read;
5892   if (abbrev == 0)
5893     return NULL;
5894
5895   const auto indexval_it = m_map.abbrev_map.find (abbrev);
5896   if (indexval_it == m_map.abbrev_map.cend ())
5897     {
5898       complaint (_("Wrong .debug_names undefined abbrev code %s "
5899                    "[in module %s]"),
5900                  pulongest (abbrev), objfile_name (objfile));
5901       return NULL;
5902     }
5903   const mapped_debug_names::index_val &indexval = indexval_it->second;
5904   bool have_is_static = false;
5905   bool is_static;
5906   dwarf2_per_cu_data *per_cu = NULL;
5907   for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5908     {
5909       ULONGEST ull;
5910       switch (attr.form)
5911         {
5912         case DW_FORM_implicit_const:
5913           ull = attr.implicit_const;
5914           break;
5915         case DW_FORM_flag_present:
5916           ull = 1;
5917           break;
5918         case DW_FORM_udata:
5919           ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5920           m_addr += bytes_read;
5921           break;
5922         default:
5923           complaint (_("Unsupported .debug_names form %s [in module %s]"),
5924                      dwarf_form_name (attr.form),
5925                      objfile_name (objfile));
5926           return NULL;
5927         }
5928       switch (attr.dw_idx)
5929         {
5930         case DW_IDX_compile_unit:
5931           /* Don't crash on bad data.  */
5932           if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5933             {
5934               complaint (_(".debug_names entry has bad CU index %s"
5935                            " [in module %s]"),
5936                          pulongest (ull),
5937                          objfile_name (dwarf2_per_objfile->objfile));
5938               continue;
5939             }
5940           per_cu = dwarf2_per_objfile->get_cutu (ull);
5941           break;
5942         case DW_IDX_type_unit:
5943           /* Don't crash on bad data.  */
5944           if (ull >= dwarf2_per_objfile->all_type_units.size ())
5945             {
5946               complaint (_(".debug_names entry has bad TU index %s"
5947                            " [in module %s]"),
5948                          pulongest (ull),
5949                          objfile_name (dwarf2_per_objfile->objfile));
5950               continue;
5951             }
5952           per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5953           break;
5954         case DW_IDX_GNU_internal:
5955           if (!m_map.augmentation_is_gdb)
5956             break;
5957           have_is_static = true;
5958           is_static = true;
5959           break;
5960         case DW_IDX_GNU_external:
5961           if (!m_map.augmentation_is_gdb)
5962             break;
5963           have_is_static = true;
5964           is_static = false;
5965           break;
5966         }
5967     }
5968
5969   /* Skip if already read in.  */
5970   if (per_cu->v.quick->compunit_symtab)
5971     goto again;
5972
5973   /* Check static vs global.  */
5974   if (have_is_static)
5975     {
5976       const bool want_static = m_block_index != GLOBAL_BLOCK;
5977       if (m_want_specific_block && want_static != is_static)
5978         goto again;
5979     }
5980
5981   /* Match dw2_symtab_iter_next, symbol_kind
5982      and debug_names::psymbol_tag.  */
5983   switch (m_domain)
5984     {
5985     case VAR_DOMAIN:
5986       switch (indexval.dwarf_tag)
5987         {
5988         case DW_TAG_variable:
5989         case DW_TAG_subprogram:
5990         /* Some types are also in VAR_DOMAIN.  */
5991         case DW_TAG_typedef:
5992         case DW_TAG_structure_type:
5993           break;
5994         default:
5995           goto again;
5996         }
5997       break;
5998     case STRUCT_DOMAIN:
5999       switch (indexval.dwarf_tag)
6000         {
6001         case DW_TAG_typedef:
6002         case DW_TAG_structure_type:
6003           break;
6004         default:
6005           goto again;
6006         }
6007       break;
6008     case LABEL_DOMAIN:
6009       switch (indexval.dwarf_tag)
6010         {
6011         case 0:
6012         case DW_TAG_variable:
6013           break;
6014         default:
6015           goto again;
6016         }
6017       break;
6018     default:
6019       break;
6020     }
6021
6022   /* Match dw2_expand_symtabs_matching, symbol_kind and
6023      debug_names::psymbol_tag.  */
6024   switch (m_search)
6025     {
6026     case VARIABLES_DOMAIN:
6027       switch (indexval.dwarf_tag)
6028         {
6029         case DW_TAG_variable:
6030           break;
6031         default:
6032           goto again;
6033         }
6034       break;
6035     case FUNCTIONS_DOMAIN:
6036       switch (indexval.dwarf_tag)
6037         {
6038         case DW_TAG_subprogram:
6039           break;
6040         default:
6041           goto again;
6042         }
6043       break;
6044     case TYPES_DOMAIN:
6045       switch (indexval.dwarf_tag)
6046         {
6047         case DW_TAG_typedef:
6048         case DW_TAG_structure_type:
6049           break;
6050         default:
6051           goto again;
6052         }
6053       break;
6054     default:
6055       break;
6056     }
6057
6058   return per_cu;
6059 }
6060
6061 static struct compunit_symtab *
6062 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6063                                const char *name, domain_enum domain)
6064 {
6065   const block_enum block_index = static_cast<block_enum> (block_index_int);
6066   struct dwarf2_per_objfile *dwarf2_per_objfile
6067     = get_dwarf2_per_objfile (objfile);
6068
6069   const auto &mapp = dwarf2_per_objfile->debug_names_table;
6070   if (!mapp)
6071     {
6072       /* index is NULL if OBJF_READNOW.  */
6073       return NULL;
6074     }
6075   const auto &map = *mapp;
6076
6077   dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6078                                  block_index, domain, name);
6079
6080   struct compunit_symtab *stab_best = NULL;
6081   struct dwarf2_per_cu_data *per_cu;
6082   while ((per_cu = iter.next ()) != NULL)
6083     {
6084       struct symbol *sym, *with_opaque = NULL;
6085       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6086       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6087       struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6088
6089       sym = block_find_symbol (block, name, domain,
6090                                block_find_non_opaque_type_preferred,
6091                                &with_opaque);
6092
6093       /* Some caution must be observed with overloaded functions and
6094          methods, since the index will not contain any overload
6095          information (but NAME might contain it).  */
6096
6097       if (sym != NULL
6098           && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6099         return stab;
6100       if (with_opaque != NULL
6101           && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6102         stab_best = stab;
6103
6104       /* Keep looking through other CUs.  */
6105     }
6106
6107   return stab_best;
6108 }
6109
6110 /* This dumps minimal information about .debug_names.  It is called
6111    via "mt print objfiles".  The gdb.dwarf2/gdb-index.exp testcase
6112    uses this to verify that .debug_names has been loaded.  */
6113
6114 static void
6115 dw2_debug_names_dump (struct objfile *objfile)
6116 {
6117   struct dwarf2_per_objfile *dwarf2_per_objfile
6118     = get_dwarf2_per_objfile (objfile);
6119
6120   gdb_assert (dwarf2_per_objfile->using_index);
6121   printf_filtered (".debug_names:");
6122   if (dwarf2_per_objfile->debug_names_table)
6123     printf_filtered (" exists\n");
6124   else
6125     printf_filtered (" faked for \"readnow\"\n");
6126   printf_filtered ("\n");
6127 }
6128
6129 static void
6130 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6131                                              const char *func_name)
6132 {
6133   struct dwarf2_per_objfile *dwarf2_per_objfile
6134     = get_dwarf2_per_objfile (objfile);
6135
6136   /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW.  */
6137   if (dwarf2_per_objfile->debug_names_table)
6138     {
6139       const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6140
6141       /* Note: It doesn't matter what we pass for block_index here.  */
6142       dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6143                                      GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6144
6145       struct dwarf2_per_cu_data *per_cu;
6146       while ((per_cu = iter.next ()) != NULL)
6147         dw2_instantiate_symtab (per_cu, false);
6148     }
6149 }
6150
6151 static void
6152 dw2_debug_names_expand_symtabs_matching
6153   (struct objfile *objfile,
6154    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6155    const lookup_name_info &lookup_name,
6156    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6157    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6158    enum search_domain kind)
6159 {
6160   struct dwarf2_per_objfile *dwarf2_per_objfile
6161     = get_dwarf2_per_objfile (objfile);
6162
6163   /* debug_names_table is NULL if OBJF_READNOW.  */
6164   if (!dwarf2_per_objfile->debug_names_table)
6165     return;
6166
6167   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6168
6169   mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6170
6171   dw2_expand_symtabs_matching_symbol (map, lookup_name,
6172                                       symbol_matcher,
6173                                       kind, [&] (offset_type namei)
6174     {
6175       /* The name was matched, now expand corresponding CUs that were
6176          marked.  */
6177       dw2_debug_names_iterator iter (map, kind, namei);
6178
6179       struct dwarf2_per_cu_data *per_cu;
6180       while ((per_cu = iter.next ()) != NULL)
6181         dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6182                                          expansion_notify);
6183     });
6184 }
6185
6186 const struct quick_symbol_functions dwarf2_debug_names_functions =
6187 {
6188   dw2_has_symbols,
6189   dw2_find_last_source_symtab,
6190   dw2_forget_cached_source_info,
6191   dw2_map_symtabs_matching_filename,
6192   dw2_debug_names_lookup_symbol,
6193   dw2_print_stats,
6194   dw2_debug_names_dump,
6195   dw2_debug_names_expand_symtabs_for_function,
6196   dw2_expand_all_symtabs,
6197   dw2_expand_symtabs_with_fullname,
6198   dw2_map_matching_symbols,
6199   dw2_debug_names_expand_symtabs_matching,
6200   dw2_find_pc_sect_compunit_symtab,
6201   NULL,
6202   dw2_map_symbol_filenames
6203 };
6204
6205 /* Get the content of the .gdb_index section of OBJ.  SECTION_OWNER should point
6206    to either a dwarf2_per_objfile or dwz_file object.  */
6207
6208 template <typename T>
6209 static gdb::array_view<const gdb_byte>
6210 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6211 {
6212   dwarf2_section_info *section = &section_owner->gdb_index;
6213
6214   if (dwarf2_section_empty_p (section))
6215     return {};
6216
6217   /* Older elfutils strip versions could keep the section in the main
6218      executable while splitting it for the separate debug info file.  */
6219   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6220     return {};
6221
6222   dwarf2_read_section (obj, section);
6223
6224   /* dwarf2_section_info::size is a bfd_size_type, while
6225      gdb::array_view works with size_t.  On 32-bit hosts, with
6226      --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6227      is 32-bit.  So we need an explicit narrowing conversion here.
6228      This is fine, because it's impossible to allocate or mmap an
6229      array/buffer larger than what size_t can represent.  */
6230   return gdb::make_array_view (section->buffer, section->size);
6231 }
6232
6233 /* Lookup the index cache for the contents of the index associated to
6234    DWARF2_OBJ.  */
6235
6236 static gdb::array_view<const gdb_byte>
6237 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6238 {
6239   const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6240   if (build_id == nullptr)
6241     return {};
6242
6243   return global_index_cache.lookup_gdb_index (build_id,
6244                                               &dwarf2_obj->index_cache_res);
6245 }
6246
6247 /* Same as the above, but for DWZ.  */
6248
6249 static gdb::array_view<const gdb_byte>
6250 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6251 {
6252   const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6253   if (build_id == nullptr)
6254     return {};
6255
6256   return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6257 }
6258
6259 /* See symfile.h.  */
6260
6261 bool
6262 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6263 {
6264   struct dwarf2_per_objfile *dwarf2_per_objfile
6265     = get_dwarf2_per_objfile (objfile);
6266
6267   /* If we're about to read full symbols, don't bother with the
6268      indices.  In this case we also don't care if some other debug
6269      format is making psymtabs, because they are all about to be
6270      expanded anyway.  */
6271   if ((objfile->flags & OBJF_READNOW))
6272     {
6273       dwarf2_per_objfile->using_index = 1;
6274       create_all_comp_units (dwarf2_per_objfile);
6275       create_all_type_units (dwarf2_per_objfile);
6276       dwarf2_per_objfile->quick_file_names_table
6277         = create_quick_file_names_table
6278             (dwarf2_per_objfile->all_comp_units.size ());
6279
6280       for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6281                            + dwarf2_per_objfile->all_type_units.size ()); ++i)
6282         {
6283           dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6284
6285           per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6286                                             struct dwarf2_per_cu_quick_data);
6287         }
6288
6289       /* Return 1 so that gdb sees the "quick" functions.  However,
6290          these functions will be no-ops because we will have expanded
6291          all symtabs.  */
6292       *index_kind = dw_index_kind::GDB_INDEX;
6293       return true;
6294     }
6295
6296   if (dwarf2_read_debug_names (dwarf2_per_objfile))
6297     {
6298       *index_kind = dw_index_kind::DEBUG_NAMES;
6299       return true;
6300     }
6301
6302   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6303                              get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6304                              get_gdb_index_contents_from_section<dwz_file>))
6305     {
6306       *index_kind = dw_index_kind::GDB_INDEX;
6307       return true;
6308     }
6309
6310   /* ... otherwise, try to find the index in the index cache.  */
6311   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6312                              get_gdb_index_contents_from_cache,
6313                              get_gdb_index_contents_from_cache_dwz))
6314     {
6315       global_index_cache.hit ();
6316       *index_kind = dw_index_kind::GDB_INDEX;
6317       return true;
6318     }
6319
6320   global_index_cache.miss ();
6321   return false;
6322 }
6323
6324 \f
6325
6326 /* Build a partial symbol table.  */
6327
6328 void
6329 dwarf2_build_psymtabs (struct objfile *objfile)
6330 {
6331   struct dwarf2_per_objfile *dwarf2_per_objfile
6332     = get_dwarf2_per_objfile (objfile);
6333
6334   init_psymbol_list (objfile, 1024);
6335
6336   TRY
6337     {
6338       /* This isn't really ideal: all the data we allocate on the
6339          objfile's obstack is still uselessly kept around.  However,
6340          freeing it seems unsafe.  */
6341       psymtab_discarder psymtabs (objfile);
6342       dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6343       psymtabs.keep ();
6344
6345       /* (maybe) store an index in the cache.  */
6346       global_index_cache.store (dwarf2_per_objfile);
6347     }
6348   CATCH (except, RETURN_MASK_ERROR)
6349     {
6350       exception_print (gdb_stderr, except);
6351     }
6352   END_CATCH
6353 }
6354
6355 /* Return the total length of the CU described by HEADER.  */
6356
6357 static unsigned int
6358 get_cu_length (const struct comp_unit_head *header)
6359 {
6360   return header->initial_length_size + header->length;
6361 }
6362
6363 /* Return TRUE if SECT_OFF is within CU_HEADER.  */
6364
6365 static inline bool
6366 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6367 {
6368   sect_offset bottom = cu_header->sect_off;
6369   sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6370
6371   return sect_off >= bottom && sect_off < top;
6372 }
6373
6374 /* Find the base address of the compilation unit for range lists and
6375    location lists.  It will normally be specified by DW_AT_low_pc.
6376    In DWARF-3 draft 4, the base address could be overridden by
6377    DW_AT_entry_pc.  It's been removed, but GCC still uses this for
6378    compilation units with discontinuous ranges.  */
6379
6380 static void
6381 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6382 {
6383   struct attribute *attr;
6384
6385   cu->base_known = 0;
6386   cu->base_address = 0;
6387
6388   attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6389   if (attr)
6390     {
6391       cu->base_address = attr_value_as_address (attr);
6392       cu->base_known = 1;
6393     }
6394   else
6395     {
6396       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6397       if (attr)
6398         {
6399           cu->base_address = attr_value_as_address (attr);
6400           cu->base_known = 1;
6401         }
6402     }
6403 }
6404
6405 /* Read in the comp unit header information from the debug_info at info_ptr.
6406    Use rcuh_kind::COMPILE as the default type if not known by the caller.
6407    NOTE: This leaves members offset, first_die_offset to be filled in
6408    by the caller.  */
6409
6410 static const gdb_byte *
6411 read_comp_unit_head (struct comp_unit_head *cu_header,
6412                      const gdb_byte *info_ptr,
6413                      struct dwarf2_section_info *section,
6414                      rcuh_kind section_kind)
6415 {
6416   int signed_addr;
6417   unsigned int bytes_read;
6418   const char *filename = get_section_file_name (section);
6419   bfd *abfd = get_section_bfd_owner (section);
6420
6421   cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6422   cu_header->initial_length_size = bytes_read;
6423   cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6424   info_ptr += bytes_read;
6425   cu_header->version = read_2_bytes (abfd, info_ptr);
6426   if (cu_header->version < 2 || cu_header->version > 5)
6427     error (_("Dwarf Error: wrong version in compilation unit header "
6428            "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6429            cu_header->version, filename);
6430   info_ptr += 2;
6431   if (cu_header->version < 5)
6432     switch (section_kind)
6433       {
6434       case rcuh_kind::COMPILE:
6435         cu_header->unit_type = DW_UT_compile;
6436         break;
6437       case rcuh_kind::TYPE:
6438         cu_header->unit_type = DW_UT_type;
6439         break;
6440       default:
6441         internal_error (__FILE__, __LINE__,
6442                         _("read_comp_unit_head: invalid section_kind"));
6443       }
6444   else
6445     {
6446       cu_header->unit_type = static_cast<enum dwarf_unit_type>
6447                                                  (read_1_byte (abfd, info_ptr));
6448       info_ptr += 1;
6449       switch (cu_header->unit_type)
6450         {
6451         case DW_UT_compile:
6452           if (section_kind != rcuh_kind::COMPILE)
6453             error (_("Dwarf Error: wrong unit_type in compilation unit header "
6454                    "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6455                    filename);
6456           break;
6457         case DW_UT_type:
6458           section_kind = rcuh_kind::TYPE;
6459           break;
6460         default:
6461           error (_("Dwarf Error: wrong unit_type in compilation unit header "
6462                  "(is %d, should be %d or %d) [in module %s]"),
6463                  cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6464         }
6465
6466       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6467       info_ptr += 1;
6468     }
6469   cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6470                                                           cu_header,
6471                                                           &bytes_read);
6472   info_ptr += bytes_read;
6473   if (cu_header->version < 5)
6474     {
6475       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6476       info_ptr += 1;
6477     }
6478   signed_addr = bfd_get_sign_extend_vma (abfd);
6479   if (signed_addr < 0)
6480     internal_error (__FILE__, __LINE__,
6481                     _("read_comp_unit_head: dwarf from non elf file"));
6482   cu_header->signed_addr_p = signed_addr;
6483
6484   if (section_kind == rcuh_kind::TYPE)
6485     {
6486       LONGEST type_offset;
6487
6488       cu_header->signature = read_8_bytes (abfd, info_ptr);
6489       info_ptr += 8;
6490
6491       type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6492       info_ptr += bytes_read;
6493       cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6494       if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6495         error (_("Dwarf Error: Too big type_offset in compilation unit "
6496                "header (is %s) [in module %s]"), plongest (type_offset),
6497                filename);
6498     }
6499
6500   return info_ptr;
6501 }
6502
6503 /* Helper function that returns the proper abbrev section for
6504    THIS_CU.  */
6505
6506 static struct dwarf2_section_info *
6507 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6508 {
6509   struct dwarf2_section_info *abbrev;
6510   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6511
6512   if (this_cu->is_dwz)
6513     abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6514   else
6515     abbrev = &dwarf2_per_objfile->abbrev;
6516
6517   return abbrev;
6518 }
6519
6520 /* Subroutine of read_and_check_comp_unit_head and
6521    read_and_check_type_unit_head to simplify them.
6522    Perform various error checking on the header.  */
6523
6524 static void
6525 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6526                             struct comp_unit_head *header,
6527                             struct dwarf2_section_info *section,
6528                             struct dwarf2_section_info *abbrev_section)
6529 {
6530   const char *filename = get_section_file_name (section);
6531
6532   if (to_underlying (header->abbrev_sect_off)
6533       >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6534     error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6535            "(offset %s + 6) [in module %s]"),
6536            sect_offset_str (header->abbrev_sect_off),
6537            sect_offset_str (header->sect_off),
6538            filename);
6539
6540   /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6541      avoid potential 32-bit overflow.  */
6542   if (((ULONGEST) header->sect_off + get_cu_length (header))
6543       > section->size)
6544     error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6545            "(offset %s + 0) [in module %s]"),
6546            header->length, sect_offset_str (header->sect_off),
6547            filename);
6548 }
6549
6550 /* Read in a CU/TU header and perform some basic error checking.
6551    The contents of the header are stored in HEADER.
6552    The result is a pointer to the start of the first DIE.  */
6553
6554 static const gdb_byte *
6555 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6556                                struct comp_unit_head *header,
6557                                struct dwarf2_section_info *section,
6558                                struct dwarf2_section_info *abbrev_section,
6559                                const gdb_byte *info_ptr,
6560                                rcuh_kind section_kind)
6561 {
6562   const gdb_byte *beg_of_comp_unit = info_ptr;
6563
6564   header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6565
6566   info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6567
6568   header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6569
6570   error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6571                               abbrev_section);
6572
6573   return info_ptr;
6574 }
6575
6576 /* Fetch the abbreviation table offset from a comp or type unit header.  */
6577
6578 static sect_offset
6579 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6580                     struct dwarf2_section_info *section,
6581                     sect_offset sect_off)
6582 {
6583   bfd *abfd = get_section_bfd_owner (section);
6584   const gdb_byte *info_ptr;
6585   unsigned int initial_length_size, offset_size;
6586   uint16_t version;
6587
6588   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6589   info_ptr = section->buffer + to_underlying (sect_off);
6590   read_initial_length (abfd, info_ptr, &initial_length_size);
6591   offset_size = initial_length_size == 4 ? 4 : 8;
6592   info_ptr += initial_length_size;
6593
6594   version = read_2_bytes (abfd, info_ptr);
6595   info_ptr += 2;
6596   if (version >= 5)
6597     {
6598       /* Skip unit type and address size.  */
6599       info_ptr += 2;
6600     }
6601
6602   return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6603 }
6604
6605 /* Allocate a new partial symtab for file named NAME and mark this new
6606    partial symtab as being an include of PST.  */
6607
6608 static void
6609 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6610                                struct objfile *objfile)
6611 {
6612   struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6613
6614   if (!IS_ABSOLUTE_PATH (subpst->filename))
6615     {
6616       /* It shares objfile->objfile_obstack.  */
6617       subpst->dirname = pst->dirname;
6618     }
6619
6620   subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6621   subpst->dependencies[0] = pst;
6622   subpst->number_of_dependencies = 1;
6623
6624   subpst->read_symtab = pst->read_symtab;
6625
6626   /* No private part is necessary for include psymtabs.  This property
6627      can be used to differentiate between such include psymtabs and
6628      the regular ones.  */
6629   subpst->read_symtab_private = NULL;
6630 }
6631
6632 /* Read the Line Number Program data and extract the list of files
6633    included by the source file represented by PST.  Build an include
6634    partial symtab for each of these included files.  */
6635
6636 static void
6637 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6638                                struct die_info *die,
6639                                struct partial_symtab *pst)
6640 {
6641   line_header_up lh;
6642   struct attribute *attr;
6643
6644   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6645   if (attr)
6646     lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6647   if (lh == NULL)
6648     return;  /* No linetable, so no includes.  */
6649
6650   /* NOTE: pst->dirname is DW_AT_comp_dir (if present).  Also note
6651      that we pass in the raw text_low here; that is ok because we're
6652      only decoding the line table to make include partial symtabs, and
6653      so the addresses aren't really used.  */
6654   dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6655                       pst->raw_text_low (), 1);
6656 }
6657
6658 static hashval_t
6659 hash_signatured_type (const void *item)
6660 {
6661   const struct signatured_type *sig_type
6662     = (const struct signatured_type *) item;
6663
6664   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
6665   return sig_type->signature;
6666 }
6667
6668 static int
6669 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6670 {
6671   const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6672   const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6673
6674   return lhs->signature == rhs->signature;
6675 }
6676
6677 /* Allocate a hash table for signatured types.  */
6678
6679 static htab_t
6680 allocate_signatured_type_table (struct objfile *objfile)
6681 {
6682   return htab_create_alloc_ex (41,
6683                                hash_signatured_type,
6684                                eq_signatured_type,
6685                                NULL,
6686                                &objfile->objfile_obstack,
6687                                hashtab_obstack_allocate,
6688                                dummy_obstack_deallocate);
6689 }
6690
6691 /* A helper function to add a signatured type CU to a table.  */
6692
6693 static int
6694 add_signatured_type_cu_to_table (void **slot, void *datum)
6695 {
6696   struct signatured_type *sigt = (struct signatured_type *) *slot;
6697   std::vector<signatured_type *> *all_type_units
6698     = (std::vector<signatured_type *> *) datum;
6699
6700   all_type_units->push_back (sigt);
6701
6702   return 1;
6703 }
6704
6705 /* A helper for create_debug_types_hash_table.  Read types from SECTION
6706    and fill them into TYPES_HTAB.  It will process only type units,
6707    therefore DW_UT_type.  */
6708
6709 static void
6710 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6711                               struct dwo_file *dwo_file,
6712                               dwarf2_section_info *section, htab_t &types_htab,
6713                               rcuh_kind section_kind)
6714 {
6715   struct objfile *objfile = dwarf2_per_objfile->objfile;
6716   struct dwarf2_section_info *abbrev_section;
6717   bfd *abfd;
6718   const gdb_byte *info_ptr, *end_ptr;
6719
6720   abbrev_section = (dwo_file != NULL
6721                     ? &dwo_file->sections.abbrev
6722                     : &dwarf2_per_objfile->abbrev);
6723
6724   if (dwarf_read_debug)
6725     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6726                         get_section_name (section),
6727                         get_section_file_name (abbrev_section));
6728
6729   dwarf2_read_section (objfile, section);
6730   info_ptr = section->buffer;
6731
6732   if (info_ptr == NULL)
6733     return;
6734
6735   /* We can't set abfd until now because the section may be empty or
6736      not present, in which case the bfd is unknown.  */
6737   abfd = get_section_bfd_owner (section);
6738
6739   /* We don't use init_cutu_and_read_dies_simple, or some such, here
6740      because we don't need to read any dies: the signature is in the
6741      header.  */
6742
6743   end_ptr = info_ptr + section->size;
6744   while (info_ptr < end_ptr)
6745     {
6746       struct signatured_type *sig_type;
6747       struct dwo_unit *dwo_tu;
6748       void **slot;
6749       const gdb_byte *ptr = info_ptr;
6750       struct comp_unit_head header;
6751       unsigned int length;
6752
6753       sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6754
6755       /* Initialize it due to a false compiler warning.  */
6756       header.signature = -1;
6757       header.type_cu_offset_in_tu = (cu_offset) -1;
6758
6759       /* We need to read the type's signature in order to build the hash
6760          table, but we don't need anything else just yet.  */
6761
6762       ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6763                                            abbrev_section, ptr, section_kind);
6764
6765       length = get_cu_length (&header);
6766
6767       /* Skip dummy type units.  */
6768       if (ptr >= info_ptr + length
6769           || peek_abbrev_code (abfd, ptr) == 0
6770           || header.unit_type != DW_UT_type)
6771         {
6772           info_ptr += length;
6773           continue;
6774         }
6775
6776       if (types_htab == NULL)
6777         {
6778           if (dwo_file)
6779             types_htab = allocate_dwo_unit_table (objfile);
6780           else
6781             types_htab = allocate_signatured_type_table (objfile);
6782         }
6783
6784       if (dwo_file)
6785         {
6786           sig_type = NULL;
6787           dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6788                                    struct dwo_unit);
6789           dwo_tu->dwo_file = dwo_file;
6790           dwo_tu->signature = header.signature;
6791           dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6792           dwo_tu->section = section;
6793           dwo_tu->sect_off = sect_off;
6794           dwo_tu->length = length;
6795         }
6796       else
6797         {
6798           /* N.B.: type_offset is not usable if this type uses a DWO file.
6799              The real type_offset is in the DWO file.  */
6800           dwo_tu = NULL;
6801           sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6802                                      struct signatured_type);
6803           sig_type->signature = header.signature;
6804           sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6805           sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6806           sig_type->per_cu.is_debug_types = 1;
6807           sig_type->per_cu.section = section;
6808           sig_type->per_cu.sect_off = sect_off;
6809           sig_type->per_cu.length = length;
6810         }
6811
6812       slot = htab_find_slot (types_htab,
6813                              dwo_file ? (void*) dwo_tu : (void *) sig_type,
6814                              INSERT);
6815       gdb_assert (slot != NULL);
6816       if (*slot != NULL)
6817         {
6818           sect_offset dup_sect_off;
6819
6820           if (dwo_file)
6821             {
6822               const struct dwo_unit *dup_tu
6823                 = (const struct dwo_unit *) *slot;
6824
6825               dup_sect_off = dup_tu->sect_off;
6826             }
6827           else
6828             {
6829               const struct signatured_type *dup_tu
6830                 = (const struct signatured_type *) *slot;
6831
6832               dup_sect_off = dup_tu->per_cu.sect_off;
6833             }
6834
6835           complaint (_("debug type entry at offset %s is duplicate to"
6836                        " the entry at offset %s, signature %s"),
6837                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6838                      hex_string (header.signature));
6839         }
6840       *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6841
6842       if (dwarf_read_debug > 1)
6843         fprintf_unfiltered (gdb_stdlog, "  offset %s, signature %s\n",
6844                             sect_offset_str (sect_off),
6845                             hex_string (header.signature));
6846
6847       info_ptr += length;
6848     }
6849 }
6850
6851 /* Create the hash table of all entries in the .debug_types
6852    (or .debug_types.dwo) section(s).
6853    If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6854    otherwise it is NULL.
6855
6856    The result is a pointer to the hash table or NULL if there are no types.
6857
6858    Note: This function processes DWO files only, not DWP files.  */
6859
6860 static void
6861 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6862                                struct dwo_file *dwo_file,
6863                                VEC (dwarf2_section_info_def) *types,
6864                                htab_t &types_htab)
6865 {
6866   int ix;
6867   struct dwarf2_section_info *section;
6868
6869   if (VEC_empty (dwarf2_section_info_def, types))
6870     return;
6871
6872   for (ix = 0;
6873        VEC_iterate (dwarf2_section_info_def, types, ix, section);
6874        ++ix)
6875     create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6876                                   types_htab, rcuh_kind::TYPE);
6877 }
6878
6879 /* Create the hash table of all entries in the .debug_types section,
6880    and initialize all_type_units.
6881    The result is zero if there is an error (e.g. missing .debug_types section),
6882    otherwise non-zero.  */
6883
6884 static int
6885 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6886 {
6887   htab_t types_htab = NULL;
6888
6889   create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6890                                 &dwarf2_per_objfile->info, types_htab,
6891                                 rcuh_kind::COMPILE);
6892   create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6893                                  dwarf2_per_objfile->types, types_htab);
6894   if (types_htab == NULL)
6895     {
6896       dwarf2_per_objfile->signatured_types = NULL;
6897       return 0;
6898     }
6899
6900   dwarf2_per_objfile->signatured_types = types_htab;
6901
6902   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6903   dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6904
6905   htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6906                           &dwarf2_per_objfile->all_type_units);
6907
6908   return 1;
6909 }
6910
6911 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6912    If SLOT is non-NULL, it is the entry to use in the hash table.
6913    Otherwise we find one.  */
6914
6915 static struct signatured_type *
6916 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6917                void **slot)
6918 {
6919   struct objfile *objfile = dwarf2_per_objfile->objfile;
6920
6921   if (dwarf2_per_objfile->all_type_units.size ()
6922       == dwarf2_per_objfile->all_type_units.capacity ())
6923     ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6924
6925   signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6926                                               struct signatured_type);
6927
6928   dwarf2_per_objfile->all_type_units.push_back (sig_type);
6929   sig_type->signature = sig;
6930   sig_type->per_cu.is_debug_types = 1;
6931   if (dwarf2_per_objfile->using_index)
6932     {
6933       sig_type->per_cu.v.quick =
6934         OBSTACK_ZALLOC (&objfile->objfile_obstack,
6935                         struct dwarf2_per_cu_quick_data);
6936     }
6937
6938   if (slot == NULL)
6939     {
6940       slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6941                              sig_type, INSERT);
6942     }
6943   gdb_assert (*slot == NULL);
6944   *slot = sig_type;
6945   /* The rest of sig_type must be filled in by the caller.  */
6946   return sig_type;
6947 }
6948
6949 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6950    Fill in SIG_ENTRY with DWO_ENTRY.  */
6951
6952 static void
6953 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6954                                   struct signatured_type *sig_entry,
6955                                   struct dwo_unit *dwo_entry)
6956 {
6957   /* Make sure we're not clobbering something we don't expect to.  */
6958   gdb_assert (! sig_entry->per_cu.queued);
6959   gdb_assert (sig_entry->per_cu.cu == NULL);
6960   if (dwarf2_per_objfile->using_index)
6961     {
6962       gdb_assert (sig_entry->per_cu.v.quick != NULL);
6963       gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6964     }
6965   else
6966       gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6967   gdb_assert (sig_entry->signature == dwo_entry->signature);
6968   gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6969   gdb_assert (sig_entry->type_unit_group == NULL);
6970   gdb_assert (sig_entry->dwo_unit == NULL);
6971
6972   sig_entry->per_cu.section = dwo_entry->section;
6973   sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6974   sig_entry->per_cu.length = dwo_entry->length;
6975   sig_entry->per_cu.reading_dwo_directly = 1;
6976   sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6977   sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6978   sig_entry->dwo_unit = dwo_entry;
6979 }
6980
6981 /* Subroutine of lookup_signatured_type.
6982    If we haven't read the TU yet, create the signatured_type data structure
6983    for a TU to be read in directly from a DWO file, bypassing the stub.
6984    This is the "Stay in DWO Optimization": When there is no DWP file and we're
6985    using .gdb_index, then when reading a CU we want to stay in the DWO file
6986    containing that CU.  Otherwise we could end up reading several other DWO
6987    files (due to comdat folding) to process the transitive closure of all the
6988    mentioned TUs, and that can be slow.  The current DWO file will have every
6989    type signature that it needs.
6990    We only do this for .gdb_index because in the psymtab case we already have
6991    to read all the DWOs to build the type unit groups.  */
6992
6993 static struct signatured_type *
6994 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6995 {
6996   struct dwarf2_per_objfile *dwarf2_per_objfile
6997     = cu->per_cu->dwarf2_per_objfile;
6998   struct objfile *objfile = dwarf2_per_objfile->objfile;
6999   struct dwo_file *dwo_file;
7000   struct dwo_unit find_dwo_entry, *dwo_entry;
7001   struct signatured_type find_sig_entry, *sig_entry;
7002   void **slot;
7003
7004   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7005
7006   /* If TU skeletons have been removed then we may not have read in any
7007      TUs yet.  */
7008   if (dwarf2_per_objfile->signatured_types == NULL)
7009     {
7010       dwarf2_per_objfile->signatured_types
7011         = allocate_signatured_type_table (objfile);
7012     }
7013
7014   /* We only ever need to read in one copy of a signatured type.
7015      Use the global signatured_types array to do our own comdat-folding
7016      of types.  If this is the first time we're reading this TU, and
7017      the TU has an entry in .gdb_index, replace the recorded data from
7018      .gdb_index with this TU.  */
7019
7020   find_sig_entry.signature = sig;
7021   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7022                          &find_sig_entry, INSERT);
7023   sig_entry = (struct signatured_type *) *slot;
7024
7025   /* We can get here with the TU already read, *or* in the process of being
7026      read.  Don't reassign the global entry to point to this DWO if that's
7027      the case.  Also note that if the TU is already being read, it may not
7028      have come from a DWO, the program may be a mix of Fission-compiled
7029      code and non-Fission-compiled code.  */
7030
7031   /* Have we already tried to read this TU?
7032      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7033      needn't exist in the global table yet).  */
7034   if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7035     return sig_entry;
7036
7037   /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7038      dwo_unit of the TU itself.  */
7039   dwo_file = cu->dwo_unit->dwo_file;
7040
7041   /* Ok, this is the first time we're reading this TU.  */
7042   if (dwo_file->tus == NULL)
7043     return NULL;
7044   find_dwo_entry.signature = sig;
7045   dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7046   if (dwo_entry == NULL)
7047     return NULL;
7048
7049   /* If the global table doesn't have an entry for this TU, add one.  */
7050   if (sig_entry == NULL)
7051     sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7052
7053   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7054   sig_entry->per_cu.tu_read = 1;
7055   return sig_entry;
7056 }
7057
7058 /* Subroutine of lookup_signatured_type.
7059    Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7060    then try the DWP file.  If the TU stub (skeleton) has been removed then
7061    it won't be in .gdb_index.  */
7062
7063 static struct signatured_type *
7064 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7065 {
7066   struct dwarf2_per_objfile *dwarf2_per_objfile
7067     = cu->per_cu->dwarf2_per_objfile;
7068   struct objfile *objfile = dwarf2_per_objfile->objfile;
7069   struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7070   struct dwo_unit *dwo_entry;
7071   struct signatured_type find_sig_entry, *sig_entry;
7072   void **slot;
7073
7074   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7075   gdb_assert (dwp_file != NULL);
7076
7077   /* If TU skeletons have been removed then we may not have read in any
7078      TUs yet.  */
7079   if (dwarf2_per_objfile->signatured_types == NULL)
7080     {
7081       dwarf2_per_objfile->signatured_types
7082         = allocate_signatured_type_table (objfile);
7083     }
7084
7085   find_sig_entry.signature = sig;
7086   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7087                          &find_sig_entry, INSERT);
7088   sig_entry = (struct signatured_type *) *slot;
7089
7090   /* Have we already tried to read this TU?
7091      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7092      needn't exist in the global table yet).  */
7093   if (sig_entry != NULL)
7094     return sig_entry;
7095
7096   if (dwp_file->tus == NULL)
7097     return NULL;
7098   dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7099                                       sig, 1 /* is_debug_types */);
7100   if (dwo_entry == NULL)
7101     return NULL;
7102
7103   sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7104   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7105
7106   return sig_entry;
7107 }
7108
7109 /* Lookup a signature based type for DW_FORM_ref_sig8.
7110    Returns NULL if signature SIG is not present in the table.
7111    It is up to the caller to complain about this.  */
7112
7113 static struct signatured_type *
7114 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7115 {
7116   struct dwarf2_per_objfile *dwarf2_per_objfile
7117     = cu->per_cu->dwarf2_per_objfile;
7118
7119   if (cu->dwo_unit
7120       && dwarf2_per_objfile->using_index)
7121     {
7122       /* We're in a DWO/DWP file, and we're using .gdb_index.
7123          These cases require special processing.  */
7124       if (get_dwp_file (dwarf2_per_objfile) == NULL)
7125         return lookup_dwo_signatured_type (cu, sig);
7126       else
7127         return lookup_dwp_signatured_type (cu, sig);
7128     }
7129   else
7130     {
7131       struct signatured_type find_entry, *entry;
7132
7133       if (dwarf2_per_objfile->signatured_types == NULL)
7134         return NULL;
7135       find_entry.signature = sig;
7136       entry = ((struct signatured_type *)
7137                htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7138       return entry;
7139     }
7140 }
7141 \f
7142 /* Low level DIE reading support.  */
7143
7144 /* Initialize a die_reader_specs struct from a dwarf2_cu struct.  */
7145
7146 static void
7147 init_cu_die_reader (struct die_reader_specs *reader,
7148                     struct dwarf2_cu *cu,
7149                     struct dwarf2_section_info *section,
7150                     struct dwo_file *dwo_file,
7151                     struct abbrev_table *abbrev_table)
7152 {
7153   gdb_assert (section->readin && section->buffer != NULL);
7154   reader->abfd = get_section_bfd_owner (section);
7155   reader->cu = cu;
7156   reader->dwo_file = dwo_file;
7157   reader->die_section = section;
7158   reader->buffer = section->buffer;
7159   reader->buffer_end = section->buffer + section->size;
7160   reader->comp_dir = NULL;
7161   reader->abbrev_table = abbrev_table;
7162 }
7163
7164 /* Subroutine of init_cutu_and_read_dies to simplify it.
7165    Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7166    There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7167    already.
7168
7169    STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7170    from it to the DIE in the DWO.  If NULL we are skipping the stub.
7171    STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7172    from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7173    attribute of the referencing CU.  At most one of STUB_COMP_UNIT_DIE and
7174    STUB_COMP_DIR may be non-NULL.
7175    *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7176    are filled in with the info of the DIE from the DWO file.
7177    *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7178    from the dwo.  Since *RESULT_READER references this abbrev table, it must be
7179    kept around for at least as long as *RESULT_READER.
7180
7181    The result is non-zero if a valid (non-dummy) DIE was found.  */
7182
7183 static int
7184 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7185                         struct dwo_unit *dwo_unit,
7186                         struct die_info *stub_comp_unit_die,
7187                         const char *stub_comp_dir,
7188                         struct die_reader_specs *result_reader,
7189                         const gdb_byte **result_info_ptr,
7190                         struct die_info **result_comp_unit_die,
7191                         int *result_has_children,
7192                         abbrev_table_up *result_dwo_abbrev_table)
7193 {
7194   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7195   struct objfile *objfile = dwarf2_per_objfile->objfile;
7196   struct dwarf2_cu *cu = this_cu->cu;
7197   bfd *abfd;
7198   const gdb_byte *begin_info_ptr, *info_ptr;
7199   struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7200   int i,num_extra_attrs;
7201   struct dwarf2_section_info *dwo_abbrev_section;
7202   struct attribute *attr;
7203   struct die_info *comp_unit_die;
7204
7205   /* At most one of these may be provided.  */
7206   gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7207
7208   /* These attributes aren't processed until later:
7209      DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7210      DW_AT_comp_dir is used now, to find the DWO file, but it is also
7211      referenced later.  However, these attributes are found in the stub
7212      which we won't have later.  In order to not impose this complication
7213      on the rest of the code, we read them here and copy them to the
7214      DWO CU/TU die.  */
7215
7216   stmt_list = NULL;
7217   low_pc = NULL;
7218   high_pc = NULL;
7219   ranges = NULL;
7220   comp_dir = NULL;
7221
7222   if (stub_comp_unit_die != NULL)
7223     {
7224       /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7225          DWO file.  */
7226       if (! this_cu->is_debug_types)
7227         stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7228       low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7229       high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7230       ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7231       comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7232
7233       /* There should be a DW_AT_addr_base attribute here (if needed).
7234          We need the value before we can process DW_FORM_GNU_addr_index.  */
7235       cu->addr_base = 0;
7236       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7237       if (attr)
7238         cu->addr_base = DW_UNSND (attr);
7239
7240       /* There should be a DW_AT_ranges_base attribute here (if needed).
7241          We need the value before we can process DW_AT_ranges.  */
7242       cu->ranges_base = 0;
7243       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7244       if (attr)
7245         cu->ranges_base = DW_UNSND (attr);
7246     }
7247   else if (stub_comp_dir != NULL)
7248     {
7249       /* Reconstruct the comp_dir attribute to simplify the code below.  */
7250       comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7251       comp_dir->name = DW_AT_comp_dir;
7252       comp_dir->form = DW_FORM_string;
7253       DW_STRING_IS_CANONICAL (comp_dir) = 0;
7254       DW_STRING (comp_dir) = stub_comp_dir;
7255     }
7256
7257   /* Set up for reading the DWO CU/TU.  */
7258   cu->dwo_unit = dwo_unit;
7259   dwarf2_section_info *section = dwo_unit->section;
7260   dwarf2_read_section (objfile, section);
7261   abfd = get_section_bfd_owner (section);
7262   begin_info_ptr = info_ptr = (section->buffer
7263                                + to_underlying (dwo_unit->sect_off));
7264   dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7265
7266   if (this_cu->is_debug_types)
7267     {
7268       struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7269
7270       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7271                                                 &cu->header, section,
7272                                                 dwo_abbrev_section,
7273                                                 info_ptr, rcuh_kind::TYPE);
7274       /* This is not an assert because it can be caused by bad debug info.  */
7275       if (sig_type->signature != cu->header.signature)
7276         {
7277           error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7278                    " TU at offset %s [in module %s]"),
7279                  hex_string (sig_type->signature),
7280                  hex_string (cu->header.signature),
7281                  sect_offset_str (dwo_unit->sect_off),
7282                  bfd_get_filename (abfd));
7283         }
7284       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7285       /* For DWOs coming from DWP files, we don't know the CU length
7286          nor the type's offset in the TU until now.  */
7287       dwo_unit->length = get_cu_length (&cu->header);
7288       dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7289
7290       /* Establish the type offset that can be used to lookup the type.
7291          For DWO files, we don't know it until now.  */
7292       sig_type->type_offset_in_section
7293         = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7294     }
7295   else
7296     {
7297       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7298                                                 &cu->header, section,
7299                                                 dwo_abbrev_section,
7300                                                 info_ptr, rcuh_kind::COMPILE);
7301       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7302       /* For DWOs coming from DWP files, we don't know the CU length
7303          until now.  */
7304       dwo_unit->length = get_cu_length (&cu->header);
7305     }
7306
7307   *result_dwo_abbrev_table
7308     = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7309                                cu->header.abbrev_sect_off);
7310   init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7311                       result_dwo_abbrev_table->get ());
7312
7313   /* Read in the die, but leave space to copy over the attributes
7314      from the stub.  This has the benefit of simplifying the rest of
7315      the code - all the work to maintain the illusion of a single
7316      DW_TAG_{compile,type}_unit DIE is done here.  */
7317   num_extra_attrs = ((stmt_list != NULL)
7318                      + (low_pc != NULL)
7319                      + (high_pc != NULL)
7320                      + (ranges != NULL)
7321                      + (comp_dir != NULL));
7322   info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7323                               result_has_children, num_extra_attrs);
7324
7325   /* Copy over the attributes from the stub to the DIE we just read in.  */
7326   comp_unit_die = *result_comp_unit_die;
7327   i = comp_unit_die->num_attrs;
7328   if (stmt_list != NULL)
7329     comp_unit_die->attrs[i++] = *stmt_list;
7330   if (low_pc != NULL)
7331     comp_unit_die->attrs[i++] = *low_pc;
7332   if (high_pc != NULL)
7333     comp_unit_die->attrs[i++] = *high_pc;
7334   if (ranges != NULL)
7335     comp_unit_die->attrs[i++] = *ranges;
7336   if (comp_dir != NULL)
7337     comp_unit_die->attrs[i++] = *comp_dir;
7338   comp_unit_die->num_attrs += num_extra_attrs;
7339
7340   if (dwarf_die_debug)
7341     {
7342       fprintf_unfiltered (gdb_stdlog,
7343                           "Read die from %s@0x%x of %s:\n",
7344                           get_section_name (section),
7345                           (unsigned) (begin_info_ptr - section->buffer),
7346                           bfd_get_filename (abfd));
7347       dump_die (comp_unit_die, dwarf_die_debug);
7348     }
7349
7350   /* Save the comp_dir attribute.  If there is no DWP file then we'll read
7351      TUs by skipping the stub and going directly to the entry in the DWO file.
7352      However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7353      to get it via circuitous means.  Blech.  */
7354   if (comp_dir != NULL)
7355     result_reader->comp_dir = DW_STRING (comp_dir);
7356
7357   /* Skip dummy compilation units.  */
7358   if (info_ptr >= begin_info_ptr + dwo_unit->length
7359       || peek_abbrev_code (abfd, info_ptr) == 0)
7360     return 0;
7361
7362   *result_info_ptr = info_ptr;
7363   return 1;
7364 }
7365
7366 /* Subroutine of init_cutu_and_read_dies to simplify it.
7367    Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7368    Returns NULL if the specified DWO unit cannot be found.  */
7369
7370 static struct dwo_unit *
7371 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7372                  struct die_info *comp_unit_die)
7373 {
7374   struct dwarf2_cu *cu = this_cu->cu;
7375   ULONGEST signature;
7376   struct dwo_unit *dwo_unit;
7377   const char *comp_dir, *dwo_name;
7378
7379   gdb_assert (cu != NULL);
7380
7381   /* Yeah, we look dwo_name up again, but it simplifies the code.  */
7382   dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7383   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7384
7385   if (this_cu->is_debug_types)
7386     {
7387       struct signatured_type *sig_type;
7388
7389       /* Since this_cu is the first member of struct signatured_type,
7390          we can go from a pointer to one to a pointer to the other.  */
7391       sig_type = (struct signatured_type *) this_cu;
7392       signature = sig_type->signature;
7393       dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7394     }
7395   else
7396     {
7397       struct attribute *attr;
7398
7399       attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7400       if (! attr)
7401         error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7402                  " [in module %s]"),
7403                dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7404       signature = DW_UNSND (attr);
7405       dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7406                                        signature);
7407     }
7408
7409   return dwo_unit;
7410 }
7411
7412 /* Subroutine of init_cutu_and_read_dies to simplify it.
7413    See it for a description of the parameters.
7414    Read a TU directly from a DWO file, bypassing the stub.  */
7415
7416 static void
7417 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7418                            int use_existing_cu, int keep,
7419                            die_reader_func_ftype *die_reader_func,
7420                            void *data)
7421 {
7422   std::unique_ptr<dwarf2_cu> new_cu;
7423   struct signatured_type *sig_type;
7424   struct die_reader_specs reader;
7425   const gdb_byte *info_ptr;
7426   struct die_info *comp_unit_die;
7427   int has_children;
7428   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7429
7430   /* Verify we can do the following downcast, and that we have the
7431      data we need.  */
7432   gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7433   sig_type = (struct signatured_type *) this_cu;
7434   gdb_assert (sig_type->dwo_unit != NULL);
7435
7436   if (use_existing_cu && this_cu->cu != NULL)
7437     {
7438       gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7439       /* There's no need to do the rereading_dwo_cu handling that
7440          init_cutu_and_read_dies does since we don't read the stub.  */
7441     }
7442   else
7443     {
7444       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7445       gdb_assert (this_cu->cu == NULL);
7446       new_cu.reset (new dwarf2_cu (this_cu));
7447     }
7448
7449   /* A future optimization, if needed, would be to use an existing
7450      abbrev table.  When reading DWOs with skeletonless TUs, all the TUs
7451      could share abbrev tables.  */
7452
7453   /* The abbreviation table used by READER, this must live at least as long as
7454      READER.  */
7455   abbrev_table_up dwo_abbrev_table;
7456
7457   if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7458                               NULL /* stub_comp_unit_die */,
7459                               sig_type->dwo_unit->dwo_file->comp_dir,
7460                               &reader, &info_ptr,
7461                               &comp_unit_die, &has_children,
7462                               &dwo_abbrev_table) == 0)
7463     {
7464       /* Dummy die.  */
7465       return;
7466     }
7467
7468   /* All the "real" work is done here.  */
7469   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7470
7471   /* This duplicates the code in init_cutu_and_read_dies,
7472      but the alternative is making the latter more complex.
7473      This function is only for the special case of using DWO files directly:
7474      no point in overly complicating the general case just to handle this.  */
7475   if (new_cu != NULL && keep)
7476     {
7477       /* Link this CU into read_in_chain.  */
7478       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7479       dwarf2_per_objfile->read_in_chain = this_cu;
7480       /* The chain owns it now.  */
7481       new_cu.release ();
7482     }
7483 }
7484
7485 /* Initialize a CU (or TU) and read its DIEs.
7486    If the CU defers to a DWO file, read the DWO file as well.
7487
7488    ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7489    Otherwise the table specified in the comp unit header is read in and used.
7490    This is an optimization for when we already have the abbrev table.
7491
7492    If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7493    Otherwise, a new CU is allocated with xmalloc.
7494
7495    If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7496    read_in_chain.  Otherwise the dwarf2_cu data is freed at the end.
7497
7498    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7499    linker) then DIE_READER_FUNC will not get called.  */
7500
7501 static void
7502 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7503                          struct abbrev_table *abbrev_table,
7504                          int use_existing_cu, int keep,
7505                          bool skip_partial,
7506                          die_reader_func_ftype *die_reader_func,
7507                          void *data)
7508 {
7509   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7510   struct objfile *objfile = dwarf2_per_objfile->objfile;
7511   struct dwarf2_section_info *section = this_cu->section;
7512   bfd *abfd = get_section_bfd_owner (section);
7513   struct dwarf2_cu *cu;
7514   const gdb_byte *begin_info_ptr, *info_ptr;
7515   struct die_reader_specs reader;
7516   struct die_info *comp_unit_die;
7517   int has_children;
7518   struct attribute *attr;
7519   struct signatured_type *sig_type = NULL;
7520   struct dwarf2_section_info *abbrev_section;
7521   /* Non-zero if CU currently points to a DWO file and we need to
7522      reread it.  When this happens we need to reread the skeleton die
7523      before we can reread the DWO file (this only applies to CUs, not TUs).  */
7524   int rereading_dwo_cu = 0;
7525
7526   if (dwarf_die_debug)
7527     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7528                         this_cu->is_debug_types ? "type" : "comp",
7529                         sect_offset_str (this_cu->sect_off));
7530
7531   if (use_existing_cu)
7532     gdb_assert (keep);
7533
7534   /* If we're reading a TU directly from a DWO file, including a virtual DWO
7535      file (instead of going through the stub), short-circuit all of this.  */
7536   if (this_cu->reading_dwo_directly)
7537     {
7538       /* Narrow down the scope of possibilities to have to understand.  */
7539       gdb_assert (this_cu->is_debug_types);
7540       gdb_assert (abbrev_table == NULL);
7541       init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7542                                  die_reader_func, data);
7543       return;
7544     }
7545
7546   /* This is cheap if the section is already read in.  */
7547   dwarf2_read_section (objfile, section);
7548
7549   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7550
7551   abbrev_section = get_abbrev_section_for_cu (this_cu);
7552
7553   std::unique_ptr<dwarf2_cu> new_cu;
7554   if (use_existing_cu && this_cu->cu != NULL)
7555     {
7556       cu = this_cu->cu;
7557       /* If this CU is from a DWO file we need to start over, we need to
7558          refetch the attributes from the skeleton CU.
7559          This could be optimized by retrieving those attributes from when we
7560          were here the first time: the previous comp_unit_die was stored in
7561          comp_unit_obstack.  But there's no data yet that we need this
7562          optimization.  */
7563       if (cu->dwo_unit != NULL)
7564         rereading_dwo_cu = 1;
7565     }
7566   else
7567     {
7568       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7569       gdb_assert (this_cu->cu == NULL);
7570       new_cu.reset (new dwarf2_cu (this_cu));
7571       cu = new_cu.get ();
7572     }
7573
7574   /* Get the header.  */
7575   if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7576     {
7577       /* We already have the header, there's no need to read it in again.  */
7578       info_ptr += to_underlying (cu->header.first_die_cu_offset);
7579     }
7580   else
7581     {
7582       if (this_cu->is_debug_types)
7583         {
7584           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7585                                                     &cu->header, section,
7586                                                     abbrev_section, info_ptr,
7587                                                     rcuh_kind::TYPE);
7588
7589           /* Since per_cu is the first member of struct signatured_type,
7590              we can go from a pointer to one to a pointer to the other.  */
7591           sig_type = (struct signatured_type *) this_cu;
7592           gdb_assert (sig_type->signature == cu->header.signature);
7593           gdb_assert (sig_type->type_offset_in_tu
7594                       == cu->header.type_cu_offset_in_tu);
7595           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7596
7597           /* LENGTH has not been set yet for type units if we're
7598              using .gdb_index.  */
7599           this_cu->length = get_cu_length (&cu->header);
7600
7601           /* Establish the type offset that can be used to lookup the type.  */
7602           sig_type->type_offset_in_section =
7603             this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7604
7605           this_cu->dwarf_version = cu->header.version;
7606         }
7607       else
7608         {
7609           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7610                                                     &cu->header, section,
7611                                                     abbrev_section,
7612                                                     info_ptr,
7613                                                     rcuh_kind::COMPILE);
7614
7615           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7616           gdb_assert (this_cu->length == get_cu_length (&cu->header));
7617           this_cu->dwarf_version = cu->header.version;
7618         }
7619     }
7620
7621   /* Skip dummy compilation units.  */
7622   if (info_ptr >= begin_info_ptr + this_cu->length
7623       || peek_abbrev_code (abfd, info_ptr) == 0)
7624     return;
7625
7626   /* If we don't have them yet, read the abbrevs for this compilation unit.
7627      And if we need to read them now, make sure they're freed when we're
7628      done (own the table through ABBREV_TABLE_HOLDER).  */
7629   abbrev_table_up abbrev_table_holder;
7630   if (abbrev_table != NULL)
7631     gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7632   else
7633     {
7634       abbrev_table_holder
7635         = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7636                                    cu->header.abbrev_sect_off);
7637       abbrev_table = abbrev_table_holder.get ();
7638     }
7639
7640   /* Read the top level CU/TU die.  */
7641   init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7642   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7643
7644   if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7645     return;
7646
7647   /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7648      from the DWO file.  read_cutu_die_from_dwo will allocate the abbreviation
7649      table from the DWO file and pass the ownership over to us.  It will be
7650      referenced from READER, so we must make sure to free it after we're done
7651      with READER.
7652
7653      Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7654      DWO CU, that this test will fail (the attribute will not be present).  */
7655   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7656   abbrev_table_up dwo_abbrev_table;
7657   if (attr)
7658     {
7659       struct dwo_unit *dwo_unit;
7660       struct die_info *dwo_comp_unit_die;
7661
7662       if (has_children)
7663         {
7664           complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7665                        " has children (offset %s) [in module %s]"),
7666                      sect_offset_str (this_cu->sect_off),
7667                      bfd_get_filename (abfd));
7668         }
7669       dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7670       if (dwo_unit != NULL)
7671         {
7672           if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7673                                       comp_unit_die, NULL,
7674                                       &reader, &info_ptr,
7675                                       &dwo_comp_unit_die, &has_children,
7676                                       &dwo_abbrev_table) == 0)
7677             {
7678               /* Dummy die.  */
7679               return;
7680             }
7681           comp_unit_die = dwo_comp_unit_die;
7682         }
7683       else
7684         {
7685           /* Yikes, we couldn't find the rest of the DIE, we only have
7686              the stub.  A complaint has already been logged.  There's
7687              not much more we can do except pass on the stub DIE to
7688              die_reader_func.  We don't want to throw an error on bad
7689              debug info.  */
7690         }
7691     }
7692
7693   /* All of the above is setup for this call.  Yikes.  */
7694   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7695
7696   /* Done, clean up.  */
7697   if (new_cu != NULL && keep)
7698     {
7699       /* Link this CU into read_in_chain.  */
7700       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7701       dwarf2_per_objfile->read_in_chain = this_cu;
7702       /* The chain owns it now.  */
7703       new_cu.release ();
7704     }
7705 }
7706
7707 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7708    DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7709    to have already done the lookup to find the DWO file).
7710
7711    The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7712    THIS_CU->is_debug_types, but nothing else.
7713
7714    We fill in THIS_CU->length.
7715
7716    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7717    linker) then DIE_READER_FUNC will not get called.
7718
7719    THIS_CU->cu is always freed when done.
7720    This is done in order to not leave THIS_CU->cu in a state where we have
7721    to care whether it refers to the "main" CU or the DWO CU.  */
7722
7723 static void
7724 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7725                                    struct dwo_file *dwo_file,
7726                                    die_reader_func_ftype *die_reader_func,
7727                                    void *data)
7728 {
7729   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7730   struct objfile *objfile = dwarf2_per_objfile->objfile;
7731   struct dwarf2_section_info *section = this_cu->section;
7732   bfd *abfd = get_section_bfd_owner (section);
7733   struct dwarf2_section_info *abbrev_section;
7734   const gdb_byte *begin_info_ptr, *info_ptr;
7735   struct die_reader_specs reader;
7736   struct die_info *comp_unit_die;
7737   int has_children;
7738
7739   if (dwarf_die_debug)
7740     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7741                         this_cu->is_debug_types ? "type" : "comp",
7742                         sect_offset_str (this_cu->sect_off));
7743
7744   gdb_assert (this_cu->cu == NULL);
7745
7746   abbrev_section = (dwo_file != NULL
7747                     ? &dwo_file->sections.abbrev
7748                     : get_abbrev_section_for_cu (this_cu));
7749
7750   /* This is cheap if the section is already read in.  */
7751   dwarf2_read_section (objfile, section);
7752
7753   struct dwarf2_cu cu (this_cu);
7754
7755   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7756   info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7757                                             &cu.header, section,
7758                                             abbrev_section, info_ptr,
7759                                             (this_cu->is_debug_types
7760                                              ? rcuh_kind::TYPE
7761                                              : rcuh_kind::COMPILE));
7762
7763   this_cu->length = get_cu_length (&cu.header);
7764
7765   /* Skip dummy compilation units.  */
7766   if (info_ptr >= begin_info_ptr + this_cu->length
7767       || peek_abbrev_code (abfd, info_ptr) == 0)
7768     return;
7769
7770   abbrev_table_up abbrev_table
7771     = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7772                                cu.header.abbrev_sect_off);
7773
7774   init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7775   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7776
7777   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7778 }
7779
7780 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7781    does not lookup the specified DWO file.
7782    This cannot be used to read DWO files.
7783
7784    THIS_CU->cu is always freed when done.
7785    This is done in order to not leave THIS_CU->cu in a state where we have
7786    to care whether it refers to the "main" CU or the DWO CU.
7787    We can revisit this if the data shows there's a performance issue.  */
7788
7789 static void
7790 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7791                                 die_reader_func_ftype *die_reader_func,
7792                                 void *data)
7793 {
7794   init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7795 }
7796 \f
7797 /* Type Unit Groups.
7798
7799    Type Unit Groups are a way to collapse the set of all TUs (type units) into
7800    a more manageable set.  The grouping is done by DW_AT_stmt_list entry
7801    so that all types coming from the same compilation (.o file) are grouped
7802    together.  A future step could be to put the types in the same symtab as
7803    the CU the types ultimately came from.  */
7804
7805 static hashval_t
7806 hash_type_unit_group (const void *item)
7807 {
7808   const struct type_unit_group *tu_group
7809     = (const struct type_unit_group *) item;
7810
7811   return hash_stmt_list_entry (&tu_group->hash);
7812 }
7813
7814 static int
7815 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7816 {
7817   const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7818   const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7819
7820   return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7821 }
7822
7823 /* Allocate a hash table for type unit groups.  */
7824
7825 static htab_t
7826 allocate_type_unit_groups_table (struct objfile *objfile)
7827 {
7828   return htab_create_alloc_ex (3,
7829                                hash_type_unit_group,
7830                                eq_type_unit_group,
7831                                NULL,
7832                                &objfile->objfile_obstack,
7833                                hashtab_obstack_allocate,
7834                                dummy_obstack_deallocate);
7835 }
7836
7837 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7838    partial symtabs.  We combine several TUs per psymtab to not let the size
7839    of any one psymtab grow too big.  */
7840 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7841 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7842
7843 /* Helper routine for get_type_unit_group.
7844    Create the type_unit_group object used to hold one or more TUs.  */
7845
7846 static struct type_unit_group *
7847 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7848 {
7849   struct dwarf2_per_objfile *dwarf2_per_objfile
7850     = cu->per_cu->dwarf2_per_objfile;
7851   struct objfile *objfile = dwarf2_per_objfile->objfile;
7852   struct dwarf2_per_cu_data *per_cu;
7853   struct type_unit_group *tu_group;
7854
7855   tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7856                              struct type_unit_group);
7857   per_cu = &tu_group->per_cu;
7858   per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7859
7860   if (dwarf2_per_objfile->using_index)
7861     {
7862       per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7863                                         struct dwarf2_per_cu_quick_data);
7864     }
7865   else
7866     {
7867       unsigned int line_offset = to_underlying (line_offset_struct);
7868       struct partial_symtab *pst;
7869       std::string name;
7870
7871       /* Give the symtab a useful name for debug purposes.  */
7872       if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7873         name = string_printf ("<type_units_%d>",
7874                               (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7875       else
7876         name = string_printf ("<type_units_at_0x%x>", line_offset);
7877
7878       pst = create_partial_symtab (per_cu, name.c_str ());
7879       pst->anonymous = 1;
7880     }
7881
7882   tu_group->hash.dwo_unit = cu->dwo_unit;
7883   tu_group->hash.line_sect_off = line_offset_struct;
7884
7885   return tu_group;
7886 }
7887
7888 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7889    STMT_LIST is a DW_AT_stmt_list attribute.  */
7890
7891 static struct type_unit_group *
7892 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7893 {
7894   struct dwarf2_per_objfile *dwarf2_per_objfile
7895     = cu->per_cu->dwarf2_per_objfile;
7896   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7897   struct type_unit_group *tu_group;
7898   void **slot;
7899   unsigned int line_offset;
7900   struct type_unit_group type_unit_group_for_lookup;
7901
7902   if (dwarf2_per_objfile->type_unit_groups == NULL)
7903     {
7904       dwarf2_per_objfile->type_unit_groups =
7905         allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7906     }
7907
7908   /* Do we need to create a new group, or can we use an existing one?  */
7909
7910   if (stmt_list)
7911     {
7912       line_offset = DW_UNSND (stmt_list);
7913       ++tu_stats->nr_symtab_sharers;
7914     }
7915   else
7916     {
7917       /* Ugh, no stmt_list.  Rare, but we have to handle it.
7918          We can do various things here like create one group per TU or
7919          spread them over multiple groups to split up the expansion work.
7920          To avoid worst case scenarios (too many groups or too large groups)
7921          we, umm, group them in bunches.  */
7922       line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7923                      | (tu_stats->nr_stmt_less_type_units
7924                         / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7925       ++tu_stats->nr_stmt_less_type_units;
7926     }
7927
7928   type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7929   type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7930   slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7931                          &type_unit_group_for_lookup, INSERT);
7932   if (*slot != NULL)
7933     {
7934       tu_group = (struct type_unit_group *) *slot;
7935       gdb_assert (tu_group != NULL);
7936     }
7937   else
7938     {
7939       sect_offset line_offset_struct = (sect_offset) line_offset;
7940       tu_group = create_type_unit_group (cu, line_offset_struct);
7941       *slot = tu_group;
7942       ++tu_stats->nr_symtabs;
7943     }
7944
7945   return tu_group;
7946 }
7947 \f
7948 /* Partial symbol tables.  */
7949
7950 /* Create a psymtab named NAME and assign it to PER_CU.
7951
7952    The caller must fill in the following details:
7953    dirname, textlow, texthigh.  */
7954
7955 static struct partial_symtab *
7956 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7957 {
7958   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7959   struct partial_symtab *pst;
7960
7961   pst = start_psymtab_common (objfile, name, 0);
7962
7963   pst->psymtabs_addrmap_supported = 1;
7964
7965   /* This is the glue that links PST into GDB's symbol API.  */
7966   pst->read_symtab_private = per_cu;
7967   pst->read_symtab = dwarf2_read_symtab;
7968   per_cu->v.psymtab = pst;
7969
7970   return pst;
7971 }
7972
7973 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7974    type.  */
7975
7976 struct process_psymtab_comp_unit_data
7977 {
7978   /* True if we are reading a DW_TAG_partial_unit.  */
7979
7980   int want_partial_unit;
7981
7982   /* The "pretend" language that is used if the CU doesn't declare a
7983      language.  */
7984
7985   enum language pretend_language;
7986 };
7987
7988 /* die_reader_func for process_psymtab_comp_unit.  */
7989
7990 static void
7991 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7992                                   const gdb_byte *info_ptr,
7993                                   struct die_info *comp_unit_die,
7994                                   int has_children,
7995                                   void *data)
7996 {
7997   struct dwarf2_cu *cu = reader->cu;
7998   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7999   struct gdbarch *gdbarch = get_objfile_arch (objfile);
8000   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8001   CORE_ADDR baseaddr;
8002   CORE_ADDR best_lowpc = 0, best_highpc = 0;
8003   struct partial_symtab *pst;
8004   enum pc_bounds_kind cu_bounds_kind;
8005   const char *filename;
8006   struct process_psymtab_comp_unit_data *info
8007     = (struct process_psymtab_comp_unit_data *) data;
8008
8009   if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
8010     return;
8011
8012   gdb_assert (! per_cu->is_debug_types);
8013
8014   prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
8015
8016   /* Allocate a new partial symbol table structure.  */
8017   filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
8018   if (filename == NULL)
8019     filename = "";
8020
8021   pst = create_partial_symtab (per_cu, filename);
8022
8023   /* This must be done before calling dwarf2_build_include_psymtabs.  */
8024   pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
8025
8026   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8027
8028   dwarf2_find_base_address (comp_unit_die, cu);
8029
8030   /* Possibly set the default values of LOWPC and HIGHPC from
8031      `DW_AT_ranges'.  */
8032   cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8033                                          &best_highpc, cu, pst);
8034   if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8035     {
8036       CORE_ADDR low
8037         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8038            - baseaddr);
8039       CORE_ADDR high
8040         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8041            - baseaddr - 1);
8042       /* Store the contiguous range if it is not empty; it can be
8043          empty for CUs with no code.  */
8044       addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
8045                          low, high, pst);
8046     }
8047
8048   /* Check if comp unit has_children.
8049      If so, read the rest of the partial symbols from this comp unit.
8050      If not, there's no more debug_info for this comp unit.  */
8051   if (has_children)
8052     {
8053       struct partial_die_info *first_die;
8054       CORE_ADDR lowpc, highpc;
8055
8056       lowpc = ((CORE_ADDR) -1);
8057       highpc = ((CORE_ADDR) 0);
8058
8059       first_die = load_partial_dies (reader, info_ptr, 1);
8060
8061       scan_partial_symbols (first_die, &lowpc, &highpc,
8062                             cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8063
8064       /* If we didn't find a lowpc, set it to highpc to avoid
8065          complaints from `maint check'.  */
8066       if (lowpc == ((CORE_ADDR) -1))
8067         lowpc = highpc;
8068
8069       /* If the compilation unit didn't have an explicit address range,
8070          then use the information extracted from its child dies.  */
8071       if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8072         {
8073           best_lowpc = lowpc;
8074           best_highpc = highpc;
8075         }
8076     }
8077   pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8078                                                  best_lowpc + baseaddr)
8079                      - baseaddr);
8080   pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8081                                                   best_highpc + baseaddr)
8082                       - baseaddr);
8083
8084   end_psymtab_common (objfile, pst);
8085
8086   if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8087     {
8088       int i;
8089       int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8090       struct dwarf2_per_cu_data *iter;
8091
8092       /* Fill in 'dependencies' here; we fill in 'users' in a
8093          post-pass.  */
8094       pst->number_of_dependencies = len;
8095       pst->dependencies
8096         = objfile->partial_symtabs->allocate_dependencies (len);
8097       for (i = 0;
8098            VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8099                         i, iter);
8100            ++i)
8101         pst->dependencies[i] = iter->v.psymtab;
8102
8103       VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8104     }
8105
8106   /* Get the list of files included in the current compilation unit,
8107      and build a psymtab for each of them.  */
8108   dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8109
8110   if (dwarf_read_debug)
8111     fprintf_unfiltered (gdb_stdlog,
8112                         "Psymtab for %s unit @%s: %s - %s"
8113                         ", %d global, %d static syms\n",
8114                         per_cu->is_debug_types ? "type" : "comp",
8115                         sect_offset_str (per_cu->sect_off),
8116                         paddress (gdbarch, pst->text_low (objfile)),
8117                         paddress (gdbarch, pst->text_high (objfile)),
8118                         pst->n_global_syms, pst->n_static_syms);
8119 }
8120
8121 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8122    Process compilation unit THIS_CU for a psymtab.  */
8123
8124 static void
8125 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8126                            int want_partial_unit,
8127                            enum language pretend_language)
8128 {
8129   /* If this compilation unit was already read in, free the
8130      cached copy in order to read it in again.  This is
8131      necessary because we skipped some symbols when we first
8132      read in the compilation unit (see load_partial_dies).
8133      This problem could be avoided, but the benefit is unclear.  */
8134   if (this_cu->cu != NULL)
8135     free_one_cached_comp_unit (this_cu);
8136
8137   if (this_cu->is_debug_types)
8138     init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8139                              build_type_psymtabs_reader, NULL);
8140   else
8141     {
8142       process_psymtab_comp_unit_data info;
8143       info.want_partial_unit = want_partial_unit;
8144       info.pretend_language = pretend_language;
8145       init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8146                                process_psymtab_comp_unit_reader, &info);
8147     }
8148
8149   /* Age out any secondary CUs.  */
8150   age_cached_comp_units (this_cu->dwarf2_per_objfile);
8151 }
8152
8153 /* Reader function for build_type_psymtabs.  */
8154
8155 static void
8156 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8157                             const gdb_byte *info_ptr,
8158                             struct die_info *type_unit_die,
8159                             int has_children,
8160                             void *data)
8161 {
8162   struct dwarf2_per_objfile *dwarf2_per_objfile
8163     = reader->cu->per_cu->dwarf2_per_objfile;
8164   struct objfile *objfile = dwarf2_per_objfile->objfile;
8165   struct dwarf2_cu *cu = reader->cu;
8166   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8167   struct signatured_type *sig_type;
8168   struct type_unit_group *tu_group;
8169   struct attribute *attr;
8170   struct partial_die_info *first_die;
8171   CORE_ADDR lowpc, highpc;
8172   struct partial_symtab *pst;
8173
8174   gdb_assert (data == NULL);
8175   gdb_assert (per_cu->is_debug_types);
8176   sig_type = (struct signatured_type *) per_cu;
8177
8178   if (! has_children)
8179     return;
8180
8181   attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8182   tu_group = get_type_unit_group (cu, attr);
8183
8184   VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8185
8186   prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8187   pst = create_partial_symtab (per_cu, "");
8188   pst->anonymous = 1;
8189
8190   first_die = load_partial_dies (reader, info_ptr, 1);
8191
8192   lowpc = (CORE_ADDR) -1;
8193   highpc = (CORE_ADDR) 0;
8194   scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8195
8196   end_psymtab_common (objfile, pst);
8197 }
8198
8199 /* Struct used to sort TUs by their abbreviation table offset.  */
8200
8201 struct tu_abbrev_offset
8202 {
8203   tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8204   : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8205   {}
8206
8207   signatured_type *sig_type;
8208   sect_offset abbrev_offset;
8209 };
8210
8211 /* Helper routine for build_type_psymtabs_1, passed to std::sort.  */
8212
8213 static bool
8214 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8215                           const struct tu_abbrev_offset &b)
8216 {
8217   return a.abbrev_offset < b.abbrev_offset;
8218 }
8219
8220 /* Efficiently read all the type units.
8221    This does the bulk of the work for build_type_psymtabs.
8222
8223    The efficiency is because we sort TUs by the abbrev table they use and
8224    only read each abbrev table once.  In one program there are 200K TUs
8225    sharing 8K abbrev tables.
8226
8227    The main purpose of this function is to support building the
8228    dwarf2_per_objfile->type_unit_groups table.
8229    TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8230    can collapse the search space by grouping them by stmt_list.
8231    The savings can be significant, in the same program from above the 200K TUs
8232    share 8K stmt_list tables.
8233
8234    FUNC is expected to call get_type_unit_group, which will create the
8235    struct type_unit_group if necessary and add it to
8236    dwarf2_per_objfile->type_unit_groups.  */
8237
8238 static void
8239 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8240 {
8241   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8242   abbrev_table_up abbrev_table;
8243   sect_offset abbrev_offset;
8244
8245   /* It's up to the caller to not call us multiple times.  */
8246   gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8247
8248   if (dwarf2_per_objfile->all_type_units.empty ())
8249     return;
8250
8251   /* TUs typically share abbrev tables, and there can be way more TUs than
8252      abbrev tables.  Sort by abbrev table to reduce the number of times we
8253      read each abbrev table in.
8254      Alternatives are to punt or to maintain a cache of abbrev tables.
8255      This is simpler and efficient enough for now.
8256
8257      Later we group TUs by their DW_AT_stmt_list value (as this defines the
8258      symtab to use).  Typically TUs with the same abbrev offset have the same
8259      stmt_list value too so in practice this should work well.
8260
8261      The basic algorithm here is:
8262
8263       sort TUs by abbrev table
8264       for each TU with same abbrev table:
8265         read abbrev table if first user
8266         read TU top level DIE
8267           [IWBN if DWO skeletons had DW_AT_stmt_list]
8268         call FUNC  */
8269
8270   if (dwarf_read_debug)
8271     fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8272
8273   /* Sort in a separate table to maintain the order of all_type_units
8274      for .gdb_index: TU indices directly index all_type_units.  */
8275   std::vector<tu_abbrev_offset> sorted_by_abbrev;
8276   sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8277
8278   for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8279     sorted_by_abbrev.emplace_back
8280       (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8281                                      sig_type->per_cu.section,
8282                                      sig_type->per_cu.sect_off));
8283
8284   std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8285              sort_tu_by_abbrev_offset);
8286
8287   abbrev_offset = (sect_offset) ~(unsigned) 0;
8288
8289   for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8290     {
8291       /* Switch to the next abbrev table if necessary.  */
8292       if (abbrev_table == NULL
8293           || tu.abbrev_offset != abbrev_offset)
8294         {
8295           abbrev_offset = tu.abbrev_offset;
8296           abbrev_table =
8297             abbrev_table_read_table (dwarf2_per_objfile,
8298                                      &dwarf2_per_objfile->abbrev,
8299                                      abbrev_offset);
8300           ++tu_stats->nr_uniq_abbrev_tables;
8301         }
8302
8303       init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8304                                0, 0, false, build_type_psymtabs_reader, NULL);
8305     }
8306 }
8307
8308 /* Print collected type unit statistics.  */
8309
8310 static void
8311 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8312 {
8313   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8314
8315   fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8316   fprintf_unfiltered (gdb_stdlog, "  %zu TUs\n",
8317                       dwarf2_per_objfile->all_type_units.size ());
8318   fprintf_unfiltered (gdb_stdlog, "  %d uniq abbrev tables\n",
8319                       tu_stats->nr_uniq_abbrev_tables);
8320   fprintf_unfiltered (gdb_stdlog, "  %d symtabs from stmt_list entries\n",
8321                       tu_stats->nr_symtabs);
8322   fprintf_unfiltered (gdb_stdlog, "  %d symtab sharers\n",
8323                       tu_stats->nr_symtab_sharers);
8324   fprintf_unfiltered (gdb_stdlog, "  %d type units without a stmt_list\n",
8325                       tu_stats->nr_stmt_less_type_units);
8326   fprintf_unfiltered (gdb_stdlog, "  %d all_type_units reallocs\n",
8327                       tu_stats->nr_all_type_units_reallocs);
8328 }
8329
8330 /* Traversal function for build_type_psymtabs.  */
8331
8332 static int
8333 build_type_psymtab_dependencies (void **slot, void *info)
8334 {
8335   struct dwarf2_per_objfile *dwarf2_per_objfile
8336     = (struct dwarf2_per_objfile *) info;
8337   struct objfile *objfile = dwarf2_per_objfile->objfile;
8338   struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8339   struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8340   struct partial_symtab *pst = per_cu->v.psymtab;
8341   int len = VEC_length (sig_type_ptr, tu_group->tus);
8342   struct signatured_type *iter;
8343   int i;
8344
8345   gdb_assert (len > 0);
8346   gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8347
8348   pst->number_of_dependencies = len;
8349   pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8350   for (i = 0;
8351        VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8352        ++i)
8353     {
8354       gdb_assert (iter->per_cu.is_debug_types);
8355       pst->dependencies[i] = iter->per_cu.v.psymtab;
8356       iter->type_unit_group = tu_group;
8357     }
8358
8359   VEC_free (sig_type_ptr, tu_group->tus);
8360
8361   return 1;
8362 }
8363
8364 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8365    Build partial symbol tables for the .debug_types comp-units.  */
8366
8367 static void
8368 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8369 {
8370   if (! create_all_type_units (dwarf2_per_objfile))
8371     return;
8372
8373   build_type_psymtabs_1 (dwarf2_per_objfile);
8374 }
8375
8376 /* Traversal function for process_skeletonless_type_unit.
8377    Read a TU in a DWO file and build partial symbols for it.  */
8378
8379 static int
8380 process_skeletonless_type_unit (void **slot, void *info)
8381 {
8382   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8383   struct dwarf2_per_objfile *dwarf2_per_objfile
8384     = (struct dwarf2_per_objfile *) info;
8385   struct signatured_type find_entry, *entry;
8386
8387   /* If this TU doesn't exist in the global table, add it and read it in.  */
8388
8389   if (dwarf2_per_objfile->signatured_types == NULL)
8390     {
8391       dwarf2_per_objfile->signatured_types
8392         = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8393     }
8394
8395   find_entry.signature = dwo_unit->signature;
8396   slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8397                          INSERT);
8398   /* If we've already seen this type there's nothing to do.  What's happening
8399      is we're doing our own version of comdat-folding here.  */
8400   if (*slot != NULL)
8401     return 1;
8402
8403   /* This does the job that create_all_type_units would have done for
8404      this TU.  */
8405   entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8406   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8407   *slot = entry;
8408
8409   /* This does the job that build_type_psymtabs_1 would have done.  */
8410   init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8411                            build_type_psymtabs_reader, NULL);
8412
8413   return 1;
8414 }
8415
8416 /* Traversal function for process_skeletonless_type_units.  */
8417
8418 static int
8419 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8420 {
8421   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8422
8423   if (dwo_file->tus != NULL)
8424     {
8425       htab_traverse_noresize (dwo_file->tus,
8426                               process_skeletonless_type_unit, info);
8427     }
8428
8429   return 1;
8430 }
8431
8432 /* Scan all TUs of DWO files, verifying we've processed them.
8433    This is needed in case a TU was emitted without its skeleton.
8434    Note: This can't be done until we know what all the DWO files are.  */
8435
8436 static void
8437 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8438 {
8439   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
8440   if (get_dwp_file (dwarf2_per_objfile) == NULL
8441       && dwarf2_per_objfile->dwo_files != NULL)
8442     {
8443       htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8444                               process_dwo_file_for_skeletonless_type_units,
8445                               dwarf2_per_objfile);
8446     }
8447 }
8448
8449 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE.  */
8450
8451 static void
8452 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8453 {
8454   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8455     {
8456       struct partial_symtab *pst = per_cu->v.psymtab;
8457
8458       if (pst == NULL)
8459         continue;
8460
8461       for (int j = 0; j < pst->number_of_dependencies; ++j)
8462         {
8463           /* Set the 'user' field only if it is not already set.  */
8464           if (pst->dependencies[j]->user == NULL)
8465             pst->dependencies[j]->user = pst;
8466         }
8467     }
8468 }
8469
8470 /* Build the partial symbol table by doing a quick pass through the
8471    .debug_info and .debug_abbrev sections.  */
8472
8473 static void
8474 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8475 {
8476   struct objfile *objfile = dwarf2_per_objfile->objfile;
8477
8478   if (dwarf_read_debug)
8479     {
8480       fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8481                           objfile_name (objfile));
8482     }
8483
8484   dwarf2_per_objfile->reading_partial_symbols = 1;
8485
8486   dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8487
8488   /* Any cached compilation units will be linked by the per-objfile
8489      read_in_chain.  Make sure to free them when we're done.  */
8490   free_cached_comp_units freer (dwarf2_per_objfile);
8491
8492   build_type_psymtabs (dwarf2_per_objfile);
8493
8494   create_all_comp_units (dwarf2_per_objfile);
8495
8496   /* Create a temporary address map on a temporary obstack.  We later
8497      copy this to the final obstack.  */
8498   auto_obstack temp_obstack;
8499
8500   scoped_restore save_psymtabs_addrmap
8501     = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8502                            addrmap_create_mutable (&temp_obstack));
8503
8504   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8505     process_psymtab_comp_unit (per_cu, 0, language_minimal);
8506
8507   /* This has to wait until we read the CUs, we need the list of DWOs.  */
8508   process_skeletonless_type_units (dwarf2_per_objfile);
8509
8510   /* Now that all TUs have been processed we can fill in the dependencies.  */
8511   if (dwarf2_per_objfile->type_unit_groups != NULL)
8512     {
8513       htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8514                               build_type_psymtab_dependencies, dwarf2_per_objfile);
8515     }
8516
8517   if (dwarf_read_debug)
8518     print_tu_stats (dwarf2_per_objfile);
8519
8520   set_partial_user (dwarf2_per_objfile);
8521
8522   objfile->partial_symtabs->psymtabs_addrmap
8523     = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8524                             objfile->partial_symtabs->obstack ());
8525   /* At this point we want to keep the address map.  */
8526   save_psymtabs_addrmap.release ();
8527
8528   if (dwarf_read_debug)
8529     fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8530                         objfile_name (objfile));
8531 }
8532
8533 /* die_reader_func for load_partial_comp_unit.  */
8534
8535 static void
8536 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8537                                const gdb_byte *info_ptr,
8538                                struct die_info *comp_unit_die,
8539                                int has_children,
8540                                void *data)
8541 {
8542   struct dwarf2_cu *cu = reader->cu;
8543
8544   prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8545
8546   /* Check if comp unit has_children.
8547      If so, read the rest of the partial symbols from this comp unit.
8548      If not, there's no more debug_info for this comp unit.  */
8549   if (has_children)
8550     load_partial_dies (reader, info_ptr, 0);
8551 }
8552
8553 /* Load the partial DIEs for a secondary CU into memory.
8554    This is also used when rereading a primary CU with load_all_dies.  */
8555
8556 static void
8557 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8558 {
8559   init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8560                            load_partial_comp_unit_reader, NULL);
8561 }
8562
8563 static void
8564 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8565                               struct dwarf2_section_info *section,
8566                               struct dwarf2_section_info *abbrev_section,
8567                               unsigned int is_dwz)
8568 {
8569   const gdb_byte *info_ptr;
8570   struct objfile *objfile = dwarf2_per_objfile->objfile;
8571
8572   if (dwarf_read_debug)
8573     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8574                         get_section_name (section),
8575                         get_section_file_name (section));
8576
8577   dwarf2_read_section (objfile, section);
8578
8579   info_ptr = section->buffer;
8580
8581   while (info_ptr < section->buffer + section->size)
8582     {
8583       struct dwarf2_per_cu_data *this_cu;
8584
8585       sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8586
8587       comp_unit_head cu_header;
8588       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8589                                      abbrev_section, info_ptr,
8590                                      rcuh_kind::COMPILE);
8591
8592       /* Save the compilation unit for later lookup.  */
8593       if (cu_header.unit_type != DW_UT_type)
8594         {
8595           this_cu = XOBNEW (&objfile->objfile_obstack,
8596                             struct dwarf2_per_cu_data);
8597           memset (this_cu, 0, sizeof (*this_cu));
8598         }
8599       else
8600         {
8601           auto sig_type = XOBNEW (&objfile->objfile_obstack,
8602                                   struct signatured_type);
8603           memset (sig_type, 0, sizeof (*sig_type));
8604           sig_type->signature = cu_header.signature;
8605           sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8606           this_cu = &sig_type->per_cu;
8607         }
8608       this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8609       this_cu->sect_off = sect_off;
8610       this_cu->length = cu_header.length + cu_header.initial_length_size;
8611       this_cu->is_dwz = is_dwz;
8612       this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8613       this_cu->section = section;
8614
8615       dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8616
8617       info_ptr = info_ptr + this_cu->length;
8618     }
8619 }
8620
8621 /* Create a list of all compilation units in OBJFILE.
8622    This is only done for -readnow and building partial symtabs.  */
8623
8624 static void
8625 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8626 {
8627   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8628   read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8629                                 &dwarf2_per_objfile->abbrev, 0);
8630
8631   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8632   if (dwz != NULL)
8633     read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8634                                   1);
8635 }
8636
8637 /* Process all loaded DIEs for compilation unit CU, starting at
8638    FIRST_DIE.  The caller should pass SET_ADDRMAP == 1 if the compilation
8639    unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8640    DW_AT_ranges).  See the comments of add_partial_subprogram on how
8641    SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated.  */
8642
8643 static void
8644 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8645                       CORE_ADDR *highpc, int set_addrmap,
8646                       struct dwarf2_cu *cu)
8647 {
8648   struct partial_die_info *pdi;
8649
8650   /* Now, march along the PDI's, descending into ones which have
8651      interesting children but skipping the children of the other ones,
8652      until we reach the end of the compilation unit.  */
8653
8654   pdi = first_die;
8655
8656   while (pdi != NULL)
8657     {
8658       pdi->fixup (cu);
8659
8660       /* Anonymous namespaces or modules have no name but have interesting
8661          children, so we need to look at them.  Ditto for anonymous
8662          enums.  */
8663
8664       if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8665           || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8666           || pdi->tag == DW_TAG_imported_unit
8667           || pdi->tag == DW_TAG_inlined_subroutine)
8668         {
8669           switch (pdi->tag)
8670             {
8671             case DW_TAG_subprogram:
8672             case DW_TAG_inlined_subroutine:
8673               add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8674               break;
8675             case DW_TAG_constant:
8676             case DW_TAG_variable:
8677             case DW_TAG_typedef:
8678             case DW_TAG_union_type:
8679               if (!pdi->is_declaration)
8680                 {
8681                   add_partial_symbol (pdi, cu);
8682                 }
8683               break;
8684             case DW_TAG_class_type:
8685             case DW_TAG_interface_type:
8686             case DW_TAG_structure_type:
8687               if (!pdi->is_declaration)
8688                 {
8689                   add_partial_symbol (pdi, cu);
8690                 }
8691               if ((cu->language == language_rust
8692                    || cu->language == language_cplus) && pdi->has_children)
8693                 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8694                                       set_addrmap, cu);
8695               break;
8696             case DW_TAG_enumeration_type:
8697               if (!pdi->is_declaration)
8698                 add_partial_enumeration (pdi, cu);
8699               break;
8700             case DW_TAG_base_type:
8701             case DW_TAG_subrange_type:
8702               /* File scope base type definitions are added to the partial
8703                  symbol table.  */
8704               add_partial_symbol (pdi, cu);
8705               break;
8706             case DW_TAG_namespace:
8707               add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8708               break;
8709             case DW_TAG_module:
8710               add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8711               break;
8712             case DW_TAG_imported_unit:
8713               {
8714                 struct dwarf2_per_cu_data *per_cu;
8715
8716                 /* For now we don't handle imported units in type units.  */
8717                 if (cu->per_cu->is_debug_types)
8718                   {
8719                     error (_("Dwarf Error: DW_TAG_imported_unit is not"
8720                              " supported in type units [in module %s]"),
8721                            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8722                   }
8723
8724                 per_cu = dwarf2_find_containing_comp_unit
8725                            (pdi->d.sect_off, pdi->is_dwz,
8726                             cu->per_cu->dwarf2_per_objfile);
8727
8728                 /* Go read the partial unit, if needed.  */
8729                 if (per_cu->v.psymtab == NULL)
8730                   process_psymtab_comp_unit (per_cu, 1, cu->language);
8731
8732                 VEC_safe_push (dwarf2_per_cu_ptr,
8733                                cu->per_cu->imported_symtabs, per_cu);
8734               }
8735               break;
8736             case DW_TAG_imported_declaration:
8737               add_partial_symbol (pdi, cu);
8738               break;
8739             default:
8740               break;
8741             }
8742         }
8743
8744       /* If the die has a sibling, skip to the sibling.  */
8745
8746       pdi = pdi->die_sibling;
8747     }
8748 }
8749
8750 /* Functions used to compute the fully scoped name of a partial DIE.
8751
8752    Normally, this is simple.  For C++, the parent DIE's fully scoped
8753    name is concatenated with "::" and the partial DIE's name.
8754    Enumerators are an exception; they use the scope of their parent
8755    enumeration type, i.e. the name of the enumeration type is not
8756    prepended to the enumerator.
8757
8758    There are two complexities.  One is DW_AT_specification; in this
8759    case "parent" means the parent of the target of the specification,
8760    instead of the direct parent of the DIE.  The other is compilers
8761    which do not emit DW_TAG_namespace; in this case we try to guess
8762    the fully qualified name of structure types from their members'
8763    linkage names.  This must be done using the DIE's children rather
8764    than the children of any DW_AT_specification target.  We only need
8765    to do this for structures at the top level, i.e. if the target of
8766    any DW_AT_specification (if any; otherwise the DIE itself) does not
8767    have a parent.  */
8768
8769 /* Compute the scope prefix associated with PDI's parent, in
8770    compilation unit CU.  The result will be allocated on CU's
8771    comp_unit_obstack, or a copy of the already allocated PDI->NAME
8772    field.  NULL is returned if no prefix is necessary.  */
8773 static const char *
8774 partial_die_parent_scope (struct partial_die_info *pdi,
8775                           struct dwarf2_cu *cu)
8776 {
8777   const char *grandparent_scope;
8778   struct partial_die_info *parent, *real_pdi;
8779
8780   /* We need to look at our parent DIE; if we have a DW_AT_specification,
8781      then this means the parent of the specification DIE.  */
8782
8783   real_pdi = pdi;
8784   while (real_pdi->has_specification)
8785     real_pdi = find_partial_die (real_pdi->spec_offset,
8786                                  real_pdi->spec_is_dwz, cu);
8787
8788   parent = real_pdi->die_parent;
8789   if (parent == NULL)
8790     return NULL;
8791
8792   if (parent->scope_set)
8793     return parent->scope;
8794
8795   parent->fixup (cu);
8796
8797   grandparent_scope = partial_die_parent_scope (parent, cu);
8798
8799   /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8800      DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8801      Work around this problem here.  */
8802   if (cu->language == language_cplus
8803       && parent->tag == DW_TAG_namespace
8804       && strcmp (parent->name, "::") == 0
8805       && grandparent_scope == NULL)
8806     {
8807       parent->scope = NULL;
8808       parent->scope_set = 1;
8809       return NULL;
8810     }
8811
8812   if (pdi->tag == DW_TAG_enumerator)
8813     /* Enumerators should not get the name of the enumeration as a prefix.  */
8814     parent->scope = grandparent_scope;
8815   else if (parent->tag == DW_TAG_namespace
8816       || parent->tag == DW_TAG_module
8817       || parent->tag == DW_TAG_structure_type
8818       || parent->tag == DW_TAG_class_type
8819       || parent->tag == DW_TAG_interface_type
8820       || parent->tag == DW_TAG_union_type
8821       || parent->tag == DW_TAG_enumeration_type)
8822     {
8823       if (grandparent_scope == NULL)
8824         parent->scope = parent->name;
8825       else
8826         parent->scope = typename_concat (&cu->comp_unit_obstack,
8827                                          grandparent_scope,
8828                                          parent->name, 0, cu);
8829     }
8830   else
8831     {
8832       /* FIXME drow/2004-04-01: What should we be doing with
8833          function-local names?  For partial symbols, we should probably be
8834          ignoring them.  */
8835       complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8836                  parent->tag, sect_offset_str (pdi->sect_off));
8837       parent->scope = grandparent_scope;
8838     }
8839
8840   parent->scope_set = 1;
8841   return parent->scope;
8842 }
8843
8844 /* Return the fully scoped name associated with PDI, from compilation unit
8845    CU.  The result will be allocated with malloc.  */
8846
8847 static char *
8848 partial_die_full_name (struct partial_die_info *pdi,
8849                        struct dwarf2_cu *cu)
8850 {
8851   const char *parent_scope;
8852
8853   /* If this is a template instantiation, we can not work out the
8854      template arguments from partial DIEs.  So, unfortunately, we have
8855      to go through the full DIEs.  At least any work we do building
8856      types here will be reused if full symbols are loaded later.  */
8857   if (pdi->has_template_arguments)
8858     {
8859       pdi->fixup (cu);
8860
8861       if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8862         {
8863           struct die_info *die;
8864           struct attribute attr;
8865           struct dwarf2_cu *ref_cu = cu;
8866
8867           /* DW_FORM_ref_addr is using section offset.  */
8868           attr.name = (enum dwarf_attribute) 0;
8869           attr.form = DW_FORM_ref_addr;
8870           attr.u.unsnd = to_underlying (pdi->sect_off);
8871           die = follow_die_ref (NULL, &attr, &ref_cu);
8872
8873           return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8874         }
8875     }
8876
8877   parent_scope = partial_die_parent_scope (pdi, cu);
8878   if (parent_scope == NULL)
8879     return NULL;
8880   else
8881     return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8882 }
8883
8884 static void
8885 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8886 {
8887   struct dwarf2_per_objfile *dwarf2_per_objfile
8888     = cu->per_cu->dwarf2_per_objfile;
8889   struct objfile *objfile = dwarf2_per_objfile->objfile;
8890   struct gdbarch *gdbarch = get_objfile_arch (objfile);
8891   CORE_ADDR addr = 0;
8892   const char *actual_name = NULL;
8893   CORE_ADDR baseaddr;
8894   char *built_actual_name;
8895
8896   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8897
8898   built_actual_name = partial_die_full_name (pdi, cu);
8899   if (built_actual_name != NULL)
8900     actual_name = built_actual_name;
8901
8902   if (actual_name == NULL)
8903     actual_name = pdi->name;
8904
8905   switch (pdi->tag)
8906     {
8907     case DW_TAG_inlined_subroutine:
8908     case DW_TAG_subprogram:
8909       addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8910               - baseaddr);
8911       if (pdi->is_external || cu->language == language_ada)
8912         {
8913           /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8914              of the global scope.  But in Ada, we want to be able to access
8915              nested procedures globally.  So all Ada subprograms are stored
8916              in the global scope.  */
8917           add_psymbol_to_list (actual_name, strlen (actual_name),
8918                                built_actual_name != NULL,
8919                                VAR_DOMAIN, LOC_BLOCK,
8920                                SECT_OFF_TEXT (objfile),
8921                                psymbol_placement::GLOBAL,
8922                                addr,
8923                                cu->language, objfile);
8924         }
8925       else
8926         {
8927           add_psymbol_to_list (actual_name, strlen (actual_name),
8928                                built_actual_name != NULL,
8929                                VAR_DOMAIN, LOC_BLOCK,
8930                                SECT_OFF_TEXT (objfile),
8931                                psymbol_placement::STATIC,
8932                                addr, cu->language, objfile);
8933         }
8934
8935       if (pdi->main_subprogram && actual_name != NULL)
8936         set_objfile_main_name (objfile, actual_name, cu->language);
8937       break;
8938     case DW_TAG_constant:
8939       add_psymbol_to_list (actual_name, strlen (actual_name),
8940                            built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8941                            -1, (pdi->is_external
8942                                 ? psymbol_placement::GLOBAL
8943                                 : psymbol_placement::STATIC),
8944                            0, cu->language, objfile);
8945       break;
8946     case DW_TAG_variable:
8947       if (pdi->d.locdesc)
8948         addr = decode_locdesc (pdi->d.locdesc, cu);
8949
8950       if (pdi->d.locdesc
8951           && addr == 0
8952           && !dwarf2_per_objfile->has_section_at_zero)
8953         {
8954           /* A global or static variable may also have been stripped
8955              out by the linker if unused, in which case its address
8956              will be nullified; do not add such variables into partial
8957              symbol table then.  */
8958         }
8959       else if (pdi->is_external)
8960         {
8961           /* Global Variable.
8962              Don't enter into the minimal symbol tables as there is
8963              a minimal symbol table entry from the ELF symbols already.
8964              Enter into partial symbol table if it has a location
8965              descriptor or a type.
8966              If the location descriptor is missing, new_symbol will create
8967              a LOC_UNRESOLVED symbol, the address of the variable will then
8968              be determined from the minimal symbol table whenever the variable
8969              is referenced.
8970              The address for the partial symbol table entry is not
8971              used by GDB, but it comes in handy for debugging partial symbol
8972              table building.  */
8973
8974           if (pdi->d.locdesc || pdi->has_type)
8975             add_psymbol_to_list (actual_name, strlen (actual_name),
8976                                  built_actual_name != NULL,
8977                                  VAR_DOMAIN, LOC_STATIC,
8978                                  SECT_OFF_TEXT (objfile),
8979                                  psymbol_placement::GLOBAL,
8980                                  addr, cu->language, objfile);
8981         }
8982       else
8983         {
8984           int has_loc = pdi->d.locdesc != NULL;
8985
8986           /* Static Variable.  Skip symbols whose value we cannot know (those
8987              without location descriptors or constant values).  */
8988           if (!has_loc && !pdi->has_const_value)
8989             {
8990               xfree (built_actual_name);
8991               return;
8992             }
8993
8994           add_psymbol_to_list (actual_name, strlen (actual_name),
8995                                built_actual_name != NULL,
8996                                VAR_DOMAIN, LOC_STATIC,
8997                                SECT_OFF_TEXT (objfile),
8998                                psymbol_placement::STATIC,
8999                                has_loc ? addr : 0,
9000                                cu->language, objfile);
9001         }
9002       break;
9003     case DW_TAG_typedef:
9004     case DW_TAG_base_type:
9005     case DW_TAG_subrange_type:
9006       add_psymbol_to_list (actual_name, strlen (actual_name),
9007                            built_actual_name != NULL,
9008                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9009                            psymbol_placement::STATIC,
9010                            0, cu->language, objfile);
9011       break;
9012     case DW_TAG_imported_declaration:
9013     case DW_TAG_namespace:
9014       add_psymbol_to_list (actual_name, strlen (actual_name),
9015                            built_actual_name != NULL,
9016                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9017                            psymbol_placement::GLOBAL,
9018                            0, cu->language, objfile);
9019       break;
9020     case DW_TAG_module:
9021       add_psymbol_to_list (actual_name, strlen (actual_name),
9022                            built_actual_name != NULL,
9023                            MODULE_DOMAIN, LOC_TYPEDEF, -1,
9024                            psymbol_placement::GLOBAL,
9025                            0, cu->language, objfile);
9026       break;
9027     case DW_TAG_class_type:
9028     case DW_TAG_interface_type:
9029     case DW_TAG_structure_type:
9030     case DW_TAG_union_type:
9031     case DW_TAG_enumeration_type:
9032       /* Skip external references.  The DWARF standard says in the section
9033          about "Structure, Union, and Class Type Entries": "An incomplete
9034          structure, union or class type is represented by a structure,
9035          union or class entry that does not have a byte size attribute
9036          and that has a DW_AT_declaration attribute."  */
9037       if (!pdi->has_byte_size && pdi->is_declaration)
9038         {
9039           xfree (built_actual_name);
9040           return;
9041         }
9042
9043       /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9044          static vs. global.  */
9045       add_psymbol_to_list (actual_name, strlen (actual_name),
9046                            built_actual_name != NULL,
9047                            STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9048                            cu->language == language_cplus
9049                            ? psymbol_placement::GLOBAL
9050                            : psymbol_placement::STATIC,
9051                            0, cu->language, objfile);
9052
9053       break;
9054     case DW_TAG_enumerator:
9055       add_psymbol_to_list (actual_name, strlen (actual_name),
9056                            built_actual_name != NULL,
9057                            VAR_DOMAIN, LOC_CONST, -1,
9058                            cu->language == language_cplus
9059                            ? psymbol_placement::GLOBAL
9060                            : psymbol_placement::STATIC,
9061                            0, cu->language, objfile);
9062       break;
9063     default:
9064       break;
9065     }
9066
9067   xfree (built_actual_name);
9068 }
9069
9070 /* Read a partial die corresponding to a namespace; also, add a symbol
9071    corresponding to that namespace to the symbol table.  NAMESPACE is
9072    the name of the enclosing namespace.  */
9073
9074 static void
9075 add_partial_namespace (struct partial_die_info *pdi,
9076                        CORE_ADDR *lowpc, CORE_ADDR *highpc,
9077                        int set_addrmap, struct dwarf2_cu *cu)
9078 {
9079   /* Add a symbol for the namespace.  */
9080
9081   add_partial_symbol (pdi, cu);
9082
9083   /* Now scan partial symbols in that namespace.  */
9084
9085   if (pdi->has_children)
9086     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9087 }
9088
9089 /* Read a partial die corresponding to a Fortran module.  */
9090
9091 static void
9092 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9093                     CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9094 {
9095   /* Add a symbol for the namespace.  */
9096
9097   add_partial_symbol (pdi, cu);
9098
9099   /* Now scan partial symbols in that module.  */
9100
9101   if (pdi->has_children)
9102     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9103 }
9104
9105 /* Read a partial die corresponding to a subprogram or an inlined
9106    subprogram and create a partial symbol for that subprogram.
9107    When the CU language allows it, this routine also defines a partial
9108    symbol for each nested subprogram that this subprogram contains.
9109    If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9110    Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9111
9112    PDI may also be a lexical block, in which case we simply search
9113    recursively for subprograms defined inside that lexical block.
9114    Again, this is only performed when the CU language allows this
9115    type of definitions.  */
9116
9117 static void
9118 add_partial_subprogram (struct partial_die_info *pdi,
9119                         CORE_ADDR *lowpc, CORE_ADDR *highpc,
9120                         int set_addrmap, struct dwarf2_cu *cu)
9121 {
9122   if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9123     {
9124       if (pdi->has_pc_info)
9125         {
9126           if (pdi->lowpc < *lowpc)
9127             *lowpc = pdi->lowpc;
9128           if (pdi->highpc > *highpc)
9129             *highpc = pdi->highpc;
9130           if (set_addrmap)
9131             {
9132               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9133               struct gdbarch *gdbarch = get_objfile_arch (objfile);
9134               CORE_ADDR baseaddr;
9135               CORE_ADDR this_highpc;
9136               CORE_ADDR this_lowpc;
9137
9138               baseaddr = ANOFFSET (objfile->section_offsets,
9139                                    SECT_OFF_TEXT (objfile));
9140               this_lowpc
9141                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9142                                                pdi->lowpc + baseaddr)
9143                    - baseaddr);
9144               this_highpc
9145                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9146                                                pdi->highpc + baseaddr)
9147                    - baseaddr);
9148               addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9149                                  this_lowpc, this_highpc - 1,
9150                                  cu->per_cu->v.psymtab);
9151             }
9152         }
9153
9154       if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9155         {
9156           if (!pdi->is_declaration)
9157             /* Ignore subprogram DIEs that do not have a name, they are
9158                illegal.  Do not emit a complaint at this point, we will
9159                do so when we convert this psymtab into a symtab.  */
9160             if (pdi->name)
9161               add_partial_symbol (pdi, cu);
9162         }
9163     }
9164
9165   if (! pdi->has_children)
9166     return;
9167
9168   if (cu->language == language_ada)
9169     {
9170       pdi = pdi->die_child;
9171       while (pdi != NULL)
9172         {
9173           pdi->fixup (cu);
9174           if (pdi->tag == DW_TAG_subprogram
9175               || pdi->tag == DW_TAG_inlined_subroutine
9176               || pdi->tag == DW_TAG_lexical_block)
9177             add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9178           pdi = pdi->die_sibling;
9179         }
9180     }
9181 }
9182
9183 /* Read a partial die corresponding to an enumeration type.  */
9184
9185 static void
9186 add_partial_enumeration (struct partial_die_info *enum_pdi,
9187                          struct dwarf2_cu *cu)
9188 {
9189   struct partial_die_info *pdi;
9190
9191   if (enum_pdi->name != NULL)
9192     add_partial_symbol (enum_pdi, cu);
9193
9194   pdi = enum_pdi->die_child;
9195   while (pdi)
9196     {
9197       if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9198         complaint (_("malformed enumerator DIE ignored"));
9199       else
9200         add_partial_symbol (pdi, cu);
9201       pdi = pdi->die_sibling;
9202     }
9203 }
9204
9205 /* Return the initial uleb128 in the die at INFO_PTR.  */
9206
9207 static unsigned int
9208 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9209 {
9210   unsigned int bytes_read;
9211
9212   return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9213 }
9214
9215 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9216    READER::CU.  Use READER::ABBREV_TABLE to lookup any abbreviation.
9217
9218    Return the corresponding abbrev, or NULL if the number is zero (indicating
9219    an empty DIE).  In either case *BYTES_READ will be set to the length of
9220    the initial number.  */
9221
9222 static struct abbrev_info *
9223 peek_die_abbrev (const die_reader_specs &reader,
9224                  const gdb_byte *info_ptr, unsigned int *bytes_read)
9225 {
9226   dwarf2_cu *cu = reader.cu;
9227   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9228   unsigned int abbrev_number
9229     = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9230
9231   if (abbrev_number == 0)
9232     return NULL;
9233
9234   abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9235   if (!abbrev)
9236     {
9237       error (_("Dwarf Error: Could not find abbrev number %d in %s"
9238                " at offset %s [in module %s]"),
9239              abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9240              sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9241     }
9242
9243   return abbrev;
9244 }
9245
9246 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9247    Returns a pointer to the end of a series of DIEs, terminated by an empty
9248    DIE.  Any children of the skipped DIEs will also be skipped.  */
9249
9250 static const gdb_byte *
9251 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9252 {
9253   while (1)
9254     {
9255       unsigned int bytes_read;
9256       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9257
9258       if (abbrev == NULL)
9259         return info_ptr + bytes_read;
9260       else
9261         info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9262     }
9263 }
9264
9265 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9266    INFO_PTR should point just after the initial uleb128 of a DIE, and the
9267    abbrev corresponding to that skipped uleb128 should be passed in
9268    ABBREV.  Returns a pointer to this DIE's sibling, skipping any
9269    children.  */
9270
9271 static const gdb_byte *
9272 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9273               struct abbrev_info *abbrev)
9274 {
9275   unsigned int bytes_read;
9276   struct attribute attr;
9277   bfd *abfd = reader->abfd;
9278   struct dwarf2_cu *cu = reader->cu;
9279   const gdb_byte *buffer = reader->buffer;
9280   const gdb_byte *buffer_end = reader->buffer_end;
9281   unsigned int form, i;
9282
9283   for (i = 0; i < abbrev->num_attrs; i++)
9284     {
9285       /* The only abbrev we care about is DW_AT_sibling.  */
9286       if (abbrev->attrs[i].name == DW_AT_sibling)
9287         {
9288           read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9289           if (attr.form == DW_FORM_ref_addr)
9290             complaint (_("ignoring absolute DW_AT_sibling"));
9291           else
9292             {
9293               sect_offset off = dwarf2_get_ref_die_offset (&attr);
9294               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9295
9296               if (sibling_ptr < info_ptr)
9297                 complaint (_("DW_AT_sibling points backwards"));
9298               else if (sibling_ptr > reader->buffer_end)
9299                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9300               else
9301                 return sibling_ptr;
9302             }
9303         }
9304
9305       /* If it isn't DW_AT_sibling, skip this attribute.  */
9306       form = abbrev->attrs[i].form;
9307     skip_attribute:
9308       switch (form)
9309         {
9310         case DW_FORM_ref_addr:
9311           /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9312              and later it is offset sized.  */
9313           if (cu->header.version == 2)
9314             info_ptr += cu->header.addr_size;
9315           else
9316             info_ptr += cu->header.offset_size;
9317           break;
9318         case DW_FORM_GNU_ref_alt:
9319           info_ptr += cu->header.offset_size;
9320           break;
9321         case DW_FORM_addr:
9322           info_ptr += cu->header.addr_size;
9323           break;
9324         case DW_FORM_data1:
9325         case DW_FORM_ref1:
9326         case DW_FORM_flag:
9327           info_ptr += 1;
9328           break;
9329         case DW_FORM_flag_present:
9330         case DW_FORM_implicit_const:
9331           break;
9332         case DW_FORM_data2:
9333         case DW_FORM_ref2:
9334           info_ptr += 2;
9335           break;
9336         case DW_FORM_data4:
9337         case DW_FORM_ref4:
9338           info_ptr += 4;
9339           break;
9340         case DW_FORM_data8:
9341         case DW_FORM_ref8:
9342         case DW_FORM_ref_sig8:
9343           info_ptr += 8;
9344           break;
9345         case DW_FORM_data16:
9346           info_ptr += 16;
9347           break;
9348         case DW_FORM_string:
9349           read_direct_string (abfd, info_ptr, &bytes_read);
9350           info_ptr += bytes_read;
9351           break;
9352         case DW_FORM_sec_offset:
9353         case DW_FORM_strp:
9354         case DW_FORM_GNU_strp_alt:
9355           info_ptr += cu->header.offset_size;
9356           break;
9357         case DW_FORM_exprloc:
9358         case DW_FORM_block:
9359           info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9360           info_ptr += bytes_read;
9361           break;
9362         case DW_FORM_block1:
9363           info_ptr += 1 + read_1_byte (abfd, info_ptr);
9364           break;
9365         case DW_FORM_block2:
9366           info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9367           break;
9368         case DW_FORM_block4:
9369           info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9370           break;
9371         case DW_FORM_sdata:
9372         case DW_FORM_udata:
9373         case DW_FORM_ref_udata:
9374         case DW_FORM_GNU_addr_index:
9375         case DW_FORM_GNU_str_index:
9376           info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9377           break;
9378         case DW_FORM_indirect:
9379           form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9380           info_ptr += bytes_read;
9381           /* We need to continue parsing from here, so just go back to
9382              the top.  */
9383           goto skip_attribute;
9384
9385         default:
9386           error (_("Dwarf Error: Cannot handle %s "
9387                    "in DWARF reader [in module %s]"),
9388                  dwarf_form_name (form),
9389                  bfd_get_filename (abfd));
9390         }
9391     }
9392
9393   if (abbrev->has_children)
9394     return skip_children (reader, info_ptr);
9395   else
9396     return info_ptr;
9397 }
9398
9399 /* Locate ORIG_PDI's sibling.
9400    INFO_PTR should point to the start of the next DIE after ORIG_PDI.  */
9401
9402 static const gdb_byte *
9403 locate_pdi_sibling (const struct die_reader_specs *reader,
9404                     struct partial_die_info *orig_pdi,
9405                     const gdb_byte *info_ptr)
9406 {
9407   /* Do we know the sibling already?  */
9408
9409   if (orig_pdi->sibling)
9410     return orig_pdi->sibling;
9411
9412   /* Are there any children to deal with?  */
9413
9414   if (!orig_pdi->has_children)
9415     return info_ptr;
9416
9417   /* Skip the children the long way.  */
9418
9419   return skip_children (reader, info_ptr);
9420 }
9421
9422 /* Expand this partial symbol table into a full symbol table.  SELF is
9423    not NULL.  */
9424
9425 static void
9426 dwarf2_read_symtab (struct partial_symtab *self,
9427                     struct objfile *objfile)
9428 {
9429   struct dwarf2_per_objfile *dwarf2_per_objfile
9430     = get_dwarf2_per_objfile (objfile);
9431
9432   if (self->readin)
9433     {
9434       warning (_("bug: psymtab for %s is already read in."),
9435                self->filename);
9436     }
9437   else
9438     {
9439       if (info_verbose)
9440         {
9441           printf_filtered (_("Reading in symbols for %s..."),
9442                            self->filename);
9443           gdb_flush (gdb_stdout);
9444         }
9445
9446       /* If this psymtab is constructed from a debug-only objfile, the
9447          has_section_at_zero flag will not necessarily be correct.  We
9448          can get the correct value for this flag by looking at the data
9449          associated with the (presumably stripped) associated objfile.  */
9450       if (objfile->separate_debug_objfile_backlink)
9451         {
9452           struct dwarf2_per_objfile *dpo_backlink
9453             = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9454
9455           dwarf2_per_objfile->has_section_at_zero
9456             = dpo_backlink->has_section_at_zero;
9457         }
9458
9459       dwarf2_per_objfile->reading_partial_symbols = 0;
9460
9461       psymtab_to_symtab_1 (self);
9462
9463       /* Finish up the debug error message.  */
9464       if (info_verbose)
9465         printf_filtered (_("done.\n"));
9466     }
9467
9468   process_cu_includes (dwarf2_per_objfile);
9469 }
9470 \f
9471 /* Reading in full CUs.  */
9472
9473 /* Add PER_CU to the queue.  */
9474
9475 static void
9476 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9477                  enum language pretend_language)
9478 {
9479   struct dwarf2_queue_item *item;
9480
9481   per_cu->queued = 1;
9482   item = XNEW (struct dwarf2_queue_item);
9483   item->per_cu = per_cu;
9484   item->pretend_language = pretend_language;
9485   item->next = NULL;
9486
9487   if (dwarf2_queue == NULL)
9488     dwarf2_queue = item;
9489   else
9490     dwarf2_queue_tail->next = item;
9491
9492   dwarf2_queue_tail = item;
9493 }
9494
9495 /* If PER_CU is not yet queued, add it to the queue.
9496    If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9497    dependency.
9498    The result is non-zero if PER_CU was queued, otherwise the result is zero
9499    meaning either PER_CU is already queued or it is already loaded.
9500
9501    N.B. There is an invariant here that if a CU is queued then it is loaded.
9502    The caller is required to load PER_CU if we return non-zero.  */
9503
9504 static int
9505 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9506                        struct dwarf2_per_cu_data *per_cu,
9507                        enum language pretend_language)
9508 {
9509   /* We may arrive here during partial symbol reading, if we need full
9510      DIEs to process an unusual case (e.g. template arguments).  Do
9511      not queue PER_CU, just tell our caller to load its DIEs.  */
9512   if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9513     {
9514       if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9515         return 1;
9516       return 0;
9517     }
9518
9519   /* Mark the dependence relation so that we don't flush PER_CU
9520      too early.  */
9521   if (dependent_cu != NULL)
9522     dwarf2_add_dependence (dependent_cu, per_cu);
9523
9524   /* If it's already on the queue, we have nothing to do.  */
9525   if (per_cu->queued)
9526     return 0;
9527
9528   /* If the compilation unit is already loaded, just mark it as
9529      used.  */
9530   if (per_cu->cu != NULL)
9531     {
9532       per_cu->cu->last_used = 0;
9533       return 0;
9534     }
9535
9536   /* Add it to the queue.  */
9537   queue_comp_unit (per_cu, pretend_language);
9538
9539   return 1;
9540 }
9541
9542 /* Process the queue.  */
9543
9544 static void
9545 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9546 {
9547   struct dwarf2_queue_item *item, *next_item;
9548
9549   if (dwarf_read_debug)
9550     {
9551       fprintf_unfiltered (gdb_stdlog,
9552                           "Expanding one or more symtabs of objfile %s ...\n",
9553                           objfile_name (dwarf2_per_objfile->objfile));
9554     }
9555
9556   /* The queue starts out with one item, but following a DIE reference
9557      may load a new CU, adding it to the end of the queue.  */
9558   for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9559     {
9560       if ((dwarf2_per_objfile->using_index
9561            ? !item->per_cu->v.quick->compunit_symtab
9562            : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9563           /* Skip dummy CUs.  */
9564           && item->per_cu->cu != NULL)
9565         {
9566           struct dwarf2_per_cu_data *per_cu = item->per_cu;
9567           unsigned int debug_print_threshold;
9568           char buf[100];
9569
9570           if (per_cu->is_debug_types)
9571             {
9572               struct signatured_type *sig_type =
9573                 (struct signatured_type *) per_cu;
9574
9575               sprintf (buf, "TU %s at offset %s",
9576                        hex_string (sig_type->signature),
9577                        sect_offset_str (per_cu->sect_off));
9578               /* There can be 100s of TUs.
9579                  Only print them in verbose mode.  */
9580               debug_print_threshold = 2;
9581             }
9582           else
9583             {
9584               sprintf (buf, "CU at offset %s",
9585                        sect_offset_str (per_cu->sect_off));
9586               debug_print_threshold = 1;
9587             }
9588
9589           if (dwarf_read_debug >= debug_print_threshold)
9590             fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9591
9592           if (per_cu->is_debug_types)
9593             process_full_type_unit (per_cu, item->pretend_language);
9594           else
9595             process_full_comp_unit (per_cu, item->pretend_language);
9596
9597           if (dwarf_read_debug >= debug_print_threshold)
9598             fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9599         }
9600
9601       item->per_cu->queued = 0;
9602       next_item = item->next;
9603       xfree (item);
9604     }
9605
9606   dwarf2_queue_tail = NULL;
9607
9608   if (dwarf_read_debug)
9609     {
9610       fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9611                           objfile_name (dwarf2_per_objfile->objfile));
9612     }
9613 }
9614
9615 /* Read in full symbols for PST, and anything it depends on.  */
9616
9617 static void
9618 psymtab_to_symtab_1 (struct partial_symtab *pst)
9619 {
9620   struct dwarf2_per_cu_data *per_cu;
9621   int i;
9622
9623   if (pst->readin)
9624     return;
9625
9626   for (i = 0; i < pst->number_of_dependencies; i++)
9627     if (!pst->dependencies[i]->readin
9628         && pst->dependencies[i]->user == NULL)
9629       {
9630         /* Inform about additional files that need to be read in.  */
9631         if (info_verbose)
9632           {
9633             /* FIXME: i18n: Need to make this a single string.  */
9634             fputs_filtered (" ", gdb_stdout);
9635             wrap_here ("");
9636             fputs_filtered ("and ", gdb_stdout);
9637             wrap_here ("");
9638             printf_filtered ("%s...", pst->dependencies[i]->filename);
9639             wrap_here ("");     /* Flush output.  */
9640             gdb_flush (gdb_stdout);
9641           }
9642         psymtab_to_symtab_1 (pst->dependencies[i]);
9643       }
9644
9645   per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9646
9647   if (per_cu == NULL)
9648     {
9649       /* It's an include file, no symbols to read for it.
9650          Everything is in the parent symtab.  */
9651       pst->readin = 1;
9652       return;
9653     }
9654
9655   dw2_do_instantiate_symtab (per_cu, false);
9656 }
9657
9658 /* Trivial hash function for die_info: the hash value of a DIE
9659    is its offset in .debug_info for this objfile.  */
9660
9661 static hashval_t
9662 die_hash (const void *item)
9663 {
9664   const struct die_info *die = (const struct die_info *) item;
9665
9666   return to_underlying (die->sect_off);
9667 }
9668
9669 /* Trivial comparison function for die_info structures: two DIEs
9670    are equal if they have the same offset.  */
9671
9672 static int
9673 die_eq (const void *item_lhs, const void *item_rhs)
9674 {
9675   const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9676   const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9677
9678   return die_lhs->sect_off == die_rhs->sect_off;
9679 }
9680
9681 /* die_reader_func for load_full_comp_unit.
9682    This is identical to read_signatured_type_reader,
9683    but is kept separate for now.  */
9684
9685 static void
9686 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9687                             const gdb_byte *info_ptr,
9688                             struct die_info *comp_unit_die,
9689                             int has_children,
9690                             void *data)
9691 {
9692   struct dwarf2_cu *cu = reader->cu;
9693   enum language *language_ptr = (enum language *) data;
9694
9695   gdb_assert (cu->die_hash == NULL);
9696   cu->die_hash =
9697     htab_create_alloc_ex (cu->header.length / 12,
9698                           die_hash,
9699                           die_eq,
9700                           NULL,
9701                           &cu->comp_unit_obstack,
9702                           hashtab_obstack_allocate,
9703                           dummy_obstack_deallocate);
9704
9705   if (has_children)
9706     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9707                                                   &info_ptr, comp_unit_die);
9708   cu->dies = comp_unit_die;
9709   /* comp_unit_die is not stored in die_hash, no need.  */
9710
9711   /* We try not to read any attributes in this function, because not
9712      all CUs needed for references have been loaded yet, and symbol
9713      table processing isn't initialized.  But we have to set the CU language,
9714      or we won't be able to build types correctly.
9715      Similarly, if we do not read the producer, we can not apply
9716      producer-specific interpretation.  */
9717   prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9718 }
9719
9720 /* Load the DIEs associated with PER_CU into memory.  */
9721
9722 static void
9723 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9724                      bool skip_partial,
9725                      enum language pretend_language)
9726 {
9727   gdb_assert (! this_cu->is_debug_types);
9728
9729   init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9730                            load_full_comp_unit_reader, &pretend_language);
9731 }
9732
9733 /* Add a DIE to the delayed physname list.  */
9734
9735 static void
9736 add_to_method_list (struct type *type, int fnfield_index, int index,
9737                     const char *name, struct die_info *die,
9738                     struct dwarf2_cu *cu)
9739 {
9740   struct delayed_method_info mi;
9741   mi.type = type;
9742   mi.fnfield_index = fnfield_index;
9743   mi.index = index;
9744   mi.name = name;
9745   mi.die = die;
9746   cu->method_list.push_back (mi);
9747 }
9748
9749 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9750    "const" / "volatile".  If so, decrements LEN by the length of the
9751    modifier and return true.  Otherwise return false.  */
9752
9753 template<size_t N>
9754 static bool
9755 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9756 {
9757   size_t mod_len = sizeof (mod) - 1;
9758   if (len > mod_len && startswith (physname + (len - mod_len), mod))
9759     {
9760       len -= mod_len;
9761       return true;
9762     }
9763   return false;
9764 }
9765
9766 /* Compute the physnames of any methods on the CU's method list.
9767
9768    The computation of method physnames is delayed in order to avoid the
9769    (bad) condition that one of the method's formal parameters is of an as yet
9770    incomplete type.  */
9771
9772 static void
9773 compute_delayed_physnames (struct dwarf2_cu *cu)
9774 {
9775   /* Only C++ delays computing physnames.  */
9776   if (cu->method_list.empty ())
9777     return;
9778   gdb_assert (cu->language == language_cplus);
9779
9780   for (const delayed_method_info &mi : cu->method_list)
9781     {
9782       const char *physname;
9783       struct fn_fieldlist *fn_flp
9784         = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9785       physname = dwarf2_physname (mi.name, mi.die, cu);
9786       TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9787         = physname ? physname : "";
9788
9789       /* Since there's no tag to indicate whether a method is a
9790          const/volatile overload, extract that information out of the
9791          demangled name.  */
9792       if (physname != NULL)
9793         {
9794           size_t len = strlen (physname);
9795
9796           while (1)
9797             {
9798               if (physname[len] == ')') /* shortcut */
9799                 break;
9800               else if (check_modifier (physname, len, " const"))
9801                 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9802               else if (check_modifier (physname, len, " volatile"))
9803                 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9804               else
9805                 break;
9806             }
9807         }
9808     }
9809
9810   /* The list is no longer needed.  */
9811   cu->method_list.clear ();
9812 }
9813
9814 /* Go objects should be embedded in a DW_TAG_module DIE,
9815    and it's not clear if/how imported objects will appear.
9816    To keep Go support simple until that's worked out,
9817    go back through what we've read and create something usable.
9818    We could do this while processing each DIE, and feels kinda cleaner,
9819    but that way is more invasive.
9820    This is to, for example, allow the user to type "p var" or "b main"
9821    without having to specify the package name, and allow lookups
9822    of module.object to work in contexts that use the expression
9823    parser.  */
9824
9825 static void
9826 fixup_go_packaging (struct dwarf2_cu *cu)
9827 {
9828   char *package_name = NULL;
9829   struct pending *list;
9830   int i;
9831
9832   for (list = *cu->get_builder ()->get_global_symbols ();
9833        list != NULL;
9834        list = list->next)
9835     {
9836       for (i = 0; i < list->nsyms; ++i)
9837         {
9838           struct symbol *sym = list->symbol[i];
9839
9840           if (SYMBOL_LANGUAGE (sym) == language_go
9841               && SYMBOL_CLASS (sym) == LOC_BLOCK)
9842             {
9843               char *this_package_name = go_symbol_package_name (sym);
9844
9845               if (this_package_name == NULL)
9846                 continue;
9847               if (package_name == NULL)
9848                 package_name = this_package_name;
9849               else
9850                 {
9851                   struct objfile *objfile
9852                     = cu->per_cu->dwarf2_per_objfile->objfile;
9853                   if (strcmp (package_name, this_package_name) != 0)
9854                     complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9855                                (symbol_symtab (sym) != NULL
9856                                 ? symtab_to_filename_for_display
9857                                     (symbol_symtab (sym))
9858                                 : objfile_name (objfile)),
9859                                this_package_name, package_name);
9860                   xfree (this_package_name);
9861                 }
9862             }
9863         }
9864     }
9865
9866   if (package_name != NULL)
9867     {
9868       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9869       const char *saved_package_name
9870         = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9871                                         package_name,
9872                                         strlen (package_name));
9873       struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9874                                      saved_package_name);
9875       struct symbol *sym;
9876
9877       sym = allocate_symbol (objfile);
9878       SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9879       SYMBOL_SET_NAMES (sym, saved_package_name,
9880                         strlen (saved_package_name), 0, objfile);
9881       /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9882          e.g., "main" finds the "main" module and not C's main().  */
9883       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9884       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9885       SYMBOL_TYPE (sym) = type;
9886
9887       add_symbol_to_list (sym, cu->get_builder ()->get_global_symbols ());
9888
9889       xfree (package_name);
9890     }
9891 }
9892
9893 /* Allocate a fully-qualified name consisting of the two parts on the
9894    obstack.  */
9895
9896 static const char *
9897 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9898 {
9899   return obconcat (obstack, p1, "::", p2, (char *) NULL);
9900 }
9901
9902 /* A helper that allocates a struct discriminant_info to attach to a
9903    union type.  */
9904
9905 static struct discriminant_info *
9906 alloc_discriminant_info (struct type *type, int discriminant_index,
9907                          int default_index)
9908 {
9909   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9910   gdb_assert (discriminant_index == -1
9911               || (discriminant_index >= 0
9912                   && discriminant_index < TYPE_NFIELDS (type)));
9913   gdb_assert (default_index == -1
9914               || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9915
9916   TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9917
9918   struct discriminant_info *disc
9919     = ((struct discriminant_info *)
9920        TYPE_ZALLOC (type,
9921                     offsetof (struct discriminant_info, discriminants)
9922                     + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9923   disc->default_index = default_index;
9924   disc->discriminant_index = discriminant_index;
9925
9926   struct dynamic_prop prop;
9927   prop.kind = PROP_UNDEFINED;
9928   prop.data.baton = disc;
9929
9930   add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9931
9932   return disc;
9933 }
9934
9935 /* Some versions of rustc emitted enums in an unusual way.
9936
9937    Ordinary enums were emitted as unions.  The first element of each
9938    structure in the union was named "RUST$ENUM$DISR".  This element
9939    held the discriminant.
9940
9941    These versions of Rust also implemented the "non-zero"
9942    optimization.  When the enum had two values, and one is empty and
9943    the other holds a pointer that cannot be zero, the pointer is used
9944    as the discriminant, with a zero value meaning the empty variant.
9945    Here, the union's first member is of the form
9946    RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9947    where the fieldnos are the indices of the fields that should be
9948    traversed in order to find the field (which may be several fields deep)
9949    and the variantname is the name of the variant of the case when the
9950    field is zero.
9951
9952    This function recognizes whether TYPE is of one of these forms,
9953    and, if so, smashes it to be a variant type.  */
9954
9955 static void
9956 quirk_rust_enum (struct type *type, struct objfile *objfile)
9957 {
9958   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9959
9960   /* We don't need to deal with empty enums.  */
9961   if (TYPE_NFIELDS (type) == 0)
9962     return;
9963
9964 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9965   if (TYPE_NFIELDS (type) == 1
9966       && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9967     {
9968       const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9969
9970       /* Decode the field name to find the offset of the
9971          discriminant.  */
9972       ULONGEST bit_offset = 0;
9973       struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9974       while (name[0] >= '0' && name[0] <= '9')
9975         {
9976           char *tail;
9977           unsigned long index = strtoul (name, &tail, 10);
9978           name = tail;
9979           if (*name != '$'
9980               || index >= TYPE_NFIELDS (field_type)
9981               || (TYPE_FIELD_LOC_KIND (field_type, index)
9982                   != FIELD_LOC_KIND_BITPOS))
9983             {
9984               complaint (_("Could not parse Rust enum encoding string \"%s\""
9985                            "[in module %s]"),
9986                          TYPE_FIELD_NAME (type, 0),
9987                          objfile_name (objfile));
9988               return;
9989             }
9990           ++name;
9991
9992           bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9993           field_type = TYPE_FIELD_TYPE (field_type, index);
9994         }
9995
9996       /* Make a union to hold the variants.  */
9997       struct type *union_type = alloc_type (objfile);
9998       TYPE_CODE (union_type) = TYPE_CODE_UNION;
9999       TYPE_NFIELDS (union_type) = 3;
10000       TYPE_FIELDS (union_type)
10001         = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
10002       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10003       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10004
10005       /* Put the discriminant must at index 0.  */
10006       TYPE_FIELD_TYPE (union_type, 0) = field_type;
10007       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10008       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10009       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
10010
10011       /* The order of fields doesn't really matter, so put the real
10012          field at index 1 and the data-less field at index 2.  */
10013       struct discriminant_info *disc
10014         = alloc_discriminant_info (union_type, 0, 1);
10015       TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10016       TYPE_FIELD_NAME (union_type, 1)
10017         = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10018       TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10019         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10020                               TYPE_FIELD_NAME (union_type, 1));
10021
10022       const char *dataless_name
10023         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10024                               name);
10025       struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10026                                               dataless_name);
10027       TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10028       /* NAME points into the original discriminant name, which
10029          already has the correct lifetime.  */
10030       TYPE_FIELD_NAME (union_type, 2) = name;
10031       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10032       disc->discriminants[2] = 0;
10033
10034       /* Smash this type to be a structure type.  We have to do this
10035          because the type has already been recorded.  */
10036       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10037       TYPE_NFIELDS (type) = 1;
10038       TYPE_FIELDS (type)
10039         = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10040
10041       /* Install the variant part.  */
10042       TYPE_FIELD_TYPE (type, 0) = union_type;
10043       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10044       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10045     }
10046   else if (TYPE_NFIELDS (type) == 1)
10047     {
10048       /* We assume that a union with a single field is a univariant
10049          enum.  */
10050       /* Smash this type to be a structure type.  We have to do this
10051          because the type has already been recorded.  */
10052       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10053
10054       /* Make a union to hold the variants.  */
10055       struct type *union_type = alloc_type (objfile);
10056       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10057       TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10058       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10059       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10060       TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10061
10062       struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10063       const char *variant_name
10064         = rust_last_path_segment (TYPE_NAME (field_type));
10065       TYPE_FIELD_NAME (union_type, 0) = variant_name;
10066       TYPE_NAME (field_type)
10067         = rust_fully_qualify (&objfile->objfile_obstack,
10068                               TYPE_NAME (type), variant_name);
10069
10070       /* Install the union in the outer struct type.  */
10071       TYPE_NFIELDS (type) = 1;
10072       TYPE_FIELDS (type)
10073         = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10074       TYPE_FIELD_TYPE (type, 0) = union_type;
10075       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10076       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10077
10078       alloc_discriminant_info (union_type, -1, 0);
10079     }
10080   else
10081     {
10082       struct type *disr_type = nullptr;
10083       for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10084         {
10085           disr_type = TYPE_FIELD_TYPE (type, i);
10086
10087           if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10088             {
10089               /* All fields of a true enum will be structs.  */
10090               return;
10091             }
10092           else if (TYPE_NFIELDS (disr_type) == 0)
10093             {
10094               /* Could be data-less variant, so keep going.  */
10095               disr_type = nullptr;
10096             }
10097           else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10098                            "RUST$ENUM$DISR") != 0)
10099             {
10100               /* Not a Rust enum.  */
10101               return;
10102             }
10103           else
10104             {
10105               /* Found one.  */
10106               break;
10107             }
10108         }
10109
10110       /* If we got here without a discriminant, then it's probably
10111          just a union.  */
10112       if (disr_type == nullptr)
10113         return;
10114
10115       /* Smash this type to be a structure type.  We have to do this
10116          because the type has already been recorded.  */
10117       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10118
10119       /* Make a union to hold the variants.  */
10120       struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10121       struct type *union_type = alloc_type (objfile);
10122       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10123       TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10124       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10125       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10126       TYPE_FIELDS (union_type)
10127         = (struct field *) TYPE_ZALLOC (union_type,
10128                                         (TYPE_NFIELDS (union_type)
10129                                          * sizeof (struct field)));
10130
10131       memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10132               TYPE_NFIELDS (type) * sizeof (struct field));
10133
10134       /* Install the discriminant at index 0 in the union.  */
10135       TYPE_FIELD (union_type, 0) = *disr_field;
10136       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10137       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10138
10139       /* Install the union in the outer struct type.  */
10140       TYPE_FIELD_TYPE (type, 0) = union_type;
10141       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10142       TYPE_NFIELDS (type) = 1;
10143
10144       /* Set the size and offset of the union type.  */
10145       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10146
10147       /* We need a way to find the correct discriminant given a
10148          variant name.  For convenience we build a map here.  */
10149       struct type *enum_type = FIELD_TYPE (*disr_field);
10150       std::unordered_map<std::string, ULONGEST> discriminant_map;
10151       for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10152         {
10153           if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10154             {
10155               const char *name
10156                 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10157               discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10158             }
10159         }
10160
10161       int n_fields = TYPE_NFIELDS (union_type);
10162       struct discriminant_info *disc
10163         = alloc_discriminant_info (union_type, 0, -1);
10164       /* Skip the discriminant here.  */
10165       for (int i = 1; i < n_fields; ++i)
10166         {
10167           /* Find the final word in the name of this variant's type.
10168              That name can be used to look up the correct
10169              discriminant.  */
10170           const char *variant_name
10171             = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10172                                                                   i)));
10173
10174           auto iter = discriminant_map.find (variant_name);
10175           if (iter != discriminant_map.end ())
10176             disc->discriminants[i] = iter->second;
10177
10178           /* Remove the discriminant field, if it exists.  */
10179           struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10180           if (TYPE_NFIELDS (sub_type) > 0)
10181             {
10182               --TYPE_NFIELDS (sub_type);
10183               ++TYPE_FIELDS (sub_type);
10184             }
10185           TYPE_FIELD_NAME (union_type, i) = variant_name;
10186           TYPE_NAME (sub_type)
10187             = rust_fully_qualify (&objfile->objfile_obstack,
10188                                   TYPE_NAME (type), variant_name);
10189         }
10190     }
10191 }
10192
10193 /* Rewrite some Rust unions to be structures with variants parts.  */
10194
10195 static void
10196 rust_union_quirks (struct dwarf2_cu *cu)
10197 {
10198   gdb_assert (cu->language == language_rust);
10199   for (type *type_ : cu->rust_unions)
10200     quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10201   /* We don't need this any more.  */
10202   cu->rust_unions.clear ();
10203 }
10204
10205 /* Return the symtab for PER_CU.  This works properly regardless of
10206    whether we're using the index or psymtabs.  */
10207
10208 static struct compunit_symtab *
10209 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10210 {
10211   return (per_cu->dwarf2_per_objfile->using_index
10212           ? per_cu->v.quick->compunit_symtab
10213           : per_cu->v.psymtab->compunit_symtab);
10214 }
10215
10216 /* A helper function for computing the list of all symbol tables
10217    included by PER_CU.  */
10218
10219 static void
10220 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10221                                 htab_t all_children, htab_t all_type_symtabs,
10222                                 struct dwarf2_per_cu_data *per_cu,
10223                                 struct compunit_symtab *immediate_parent)
10224 {
10225   void **slot;
10226   int ix;
10227   struct compunit_symtab *cust;
10228   struct dwarf2_per_cu_data *iter;
10229
10230   slot = htab_find_slot (all_children, per_cu, INSERT);
10231   if (*slot != NULL)
10232     {
10233       /* This inclusion and its children have been processed.  */
10234       return;
10235     }
10236
10237   *slot = per_cu;
10238   /* Only add a CU if it has a symbol table.  */
10239   cust = get_compunit_symtab (per_cu);
10240   if (cust != NULL)
10241     {
10242       /* If this is a type unit only add its symbol table if we haven't
10243          seen it yet (type unit per_cu's can share symtabs).  */
10244       if (per_cu->is_debug_types)
10245         {
10246           slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10247           if (*slot == NULL)
10248             {
10249               *slot = cust;
10250               result->push_back (cust);
10251               if (cust->user == NULL)
10252                 cust->user = immediate_parent;
10253             }
10254         }
10255       else
10256         {
10257           result->push_back (cust);
10258           if (cust->user == NULL)
10259             cust->user = immediate_parent;
10260         }
10261     }
10262
10263   for (ix = 0;
10264        VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10265        ++ix)
10266     {
10267       recursively_compute_inclusions (result, all_children,
10268                                       all_type_symtabs, iter, cust);
10269     }
10270 }
10271
10272 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10273    PER_CU.  */
10274
10275 static void
10276 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10277 {
10278   gdb_assert (! per_cu->is_debug_types);
10279
10280   if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10281     {
10282       int ix, len;
10283       struct dwarf2_per_cu_data *per_cu_iter;
10284       std::vector<compunit_symtab *> result_symtabs;
10285       htab_t all_children, all_type_symtabs;
10286       struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10287
10288       /* If we don't have a symtab, we can just skip this case.  */
10289       if (cust == NULL)
10290         return;
10291
10292       all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10293                                         NULL, xcalloc, xfree);
10294       all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10295                                             NULL, xcalloc, xfree);
10296
10297       for (ix = 0;
10298            VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10299                         ix, per_cu_iter);
10300            ++ix)
10301         {
10302           recursively_compute_inclusions (&result_symtabs, all_children,
10303                                           all_type_symtabs, per_cu_iter,
10304                                           cust);
10305         }
10306
10307       /* Now we have a transitive closure of all the included symtabs.  */
10308       len = result_symtabs.size ();
10309       cust->includes
10310         = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10311                      struct compunit_symtab *, len + 1);
10312       memcpy (cust->includes, result_symtabs.data (),
10313               len * sizeof (compunit_symtab *));
10314       cust->includes[len] = NULL;
10315
10316       htab_delete (all_children);
10317       htab_delete (all_type_symtabs);
10318     }
10319 }
10320
10321 /* Compute the 'includes' field for the symtabs of all the CUs we just
10322    read.  */
10323
10324 static void
10325 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10326 {
10327   for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10328     {
10329       if (! iter->is_debug_types)
10330         compute_compunit_symtab_includes (iter);
10331     }
10332
10333   dwarf2_per_objfile->just_read_cus.clear ();
10334 }
10335
10336 /* Generate full symbol information for PER_CU, whose DIEs have
10337    already been loaded into memory.  */
10338
10339 static void
10340 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10341                         enum language pretend_language)
10342 {
10343   struct dwarf2_cu *cu = per_cu->cu;
10344   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10345   struct objfile *objfile = dwarf2_per_objfile->objfile;
10346   struct gdbarch *gdbarch = get_objfile_arch (objfile);
10347   CORE_ADDR lowpc, highpc;
10348   struct compunit_symtab *cust;
10349   CORE_ADDR baseaddr;
10350   struct block *static_block;
10351   CORE_ADDR addr;
10352
10353   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10354
10355   /* Clear the list here in case something was left over.  */
10356   cu->method_list.clear ();
10357
10358   cu->language = pretend_language;
10359   cu->language_defn = language_def (cu->language);
10360
10361   /* Do line number decoding in read_file_scope () */
10362   process_die (cu->dies, cu);
10363
10364   /* For now fudge the Go package.  */
10365   if (cu->language == language_go)
10366     fixup_go_packaging (cu);
10367
10368   /* Now that we have processed all the DIEs in the CU, all the types 
10369      should be complete, and it should now be safe to compute all of the
10370      physnames.  */
10371   compute_delayed_physnames (cu);
10372
10373   if (cu->language == language_rust)
10374     rust_union_quirks (cu);
10375
10376   /* Some compilers don't define a DW_AT_high_pc attribute for the
10377      compilation unit.  If the DW_AT_high_pc is missing, synthesize
10378      it, by scanning the DIE's below the compilation unit.  */
10379   get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10380
10381   addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10382   static_block = cu->get_builder ()->end_symtab_get_static_block (addr, 0, 1);
10383
10384   /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10385      Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10386      (such as virtual method tables).  Record the ranges in STATIC_BLOCK's
10387      addrmap to help ensure it has an accurate map of pc values belonging to
10388      this comp unit.  */
10389   dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10390
10391   cust = cu->get_builder ()->end_symtab_from_static_block (static_block,
10392                                                     SECT_OFF_TEXT (objfile),
10393                                                     0);
10394
10395   if (cust != NULL)
10396     {
10397       int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10398
10399       /* Set symtab language to language from DW_AT_language.  If the
10400          compilation is from a C file generated by language preprocessors, do
10401          not set the language if it was already deduced by start_subfile.  */
10402       if (!(cu->language == language_c
10403             && COMPUNIT_FILETABS (cust)->language != language_unknown))
10404         COMPUNIT_FILETABS (cust)->language = cu->language;
10405
10406       /* GCC-4.0 has started to support -fvar-tracking.  GCC-3.x still can
10407          produce DW_AT_location with location lists but it can be possibly
10408          invalid without -fvar-tracking.  Still up to GCC-4.4.x incl. 4.4.0
10409          there were bugs in prologue debug info, fixed later in GCC-4.5
10410          by "unwind info for epilogues" patch (which is not directly related).
10411
10412          For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10413          needed, it would be wrong due to missing DW_AT_producer there.
10414
10415          Still one can confuse GDB by using non-standard GCC compilation
10416          options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10417          */ 
10418       if (cu->has_loclist && gcc_4_minor >= 5)
10419         cust->locations_valid = 1;
10420
10421       if (gcc_4_minor >= 5)
10422         cust->epilogue_unwind_valid = 1;
10423
10424       cust->call_site_htab = cu->call_site_htab;
10425     }
10426
10427   if (dwarf2_per_objfile->using_index)
10428     per_cu->v.quick->compunit_symtab = cust;
10429   else
10430     {
10431       struct partial_symtab *pst = per_cu->v.psymtab;
10432       pst->compunit_symtab = cust;
10433       pst->readin = 1;
10434     }
10435
10436   /* Push it for inclusion processing later.  */
10437   dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10438
10439   /* Not needed any more.  */
10440   cu->reset_builder ();
10441 }
10442
10443 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10444    already been loaded into memory.  */
10445
10446 static void
10447 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10448                         enum language pretend_language)
10449 {
10450   struct dwarf2_cu *cu = per_cu->cu;
10451   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10452   struct objfile *objfile = dwarf2_per_objfile->objfile;
10453   struct compunit_symtab *cust;
10454   struct signatured_type *sig_type;
10455
10456   gdb_assert (per_cu->is_debug_types);
10457   sig_type = (struct signatured_type *) per_cu;
10458
10459   /* Clear the list here in case something was left over.  */
10460   cu->method_list.clear ();
10461
10462   cu->language = pretend_language;
10463   cu->language_defn = language_def (cu->language);
10464
10465   /* The symbol tables are set up in read_type_unit_scope.  */
10466   process_die (cu->dies, cu);
10467
10468   /* For now fudge the Go package.  */
10469   if (cu->language == language_go)
10470     fixup_go_packaging (cu);
10471
10472   /* Now that we have processed all the DIEs in the CU, all the types 
10473      should be complete, and it should now be safe to compute all of the
10474      physnames.  */
10475   compute_delayed_physnames (cu);
10476
10477   if (cu->language == language_rust)
10478     rust_union_quirks (cu);
10479
10480   /* TUs share symbol tables.
10481      If this is the first TU to use this symtab, complete the construction
10482      of it with end_expandable_symtab.  Otherwise, complete the addition of
10483      this TU's symbols to the existing symtab.  */
10484   if (sig_type->type_unit_group->compunit_symtab == NULL)
10485     {
10486       buildsym_compunit *builder = cu->get_builder ();
10487       cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10488       sig_type->type_unit_group->compunit_symtab = cust;
10489
10490       if (cust != NULL)
10491         {
10492           /* Set symtab language to language from DW_AT_language.  If the
10493              compilation is from a C file generated by language preprocessors,
10494              do not set the language if it was already deduced by
10495              start_subfile.  */
10496           if (!(cu->language == language_c
10497                 && COMPUNIT_FILETABS (cust)->language != language_c))
10498             COMPUNIT_FILETABS (cust)->language = cu->language;
10499         }
10500     }
10501   else
10502     {
10503       cu->get_builder ()->augment_type_symtab ();
10504       cust = sig_type->type_unit_group->compunit_symtab;
10505     }
10506
10507   if (dwarf2_per_objfile->using_index)
10508     per_cu->v.quick->compunit_symtab = cust;
10509   else
10510     {
10511       struct partial_symtab *pst = per_cu->v.psymtab;
10512       pst->compunit_symtab = cust;
10513       pst->readin = 1;
10514     }
10515
10516   /* Not needed any more.  */
10517   cu->reset_builder ();
10518 }
10519
10520 /* Process an imported unit DIE.  */
10521
10522 static void
10523 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10524 {
10525   struct attribute *attr;
10526
10527   /* For now we don't handle imported units in type units.  */
10528   if (cu->per_cu->is_debug_types)
10529     {
10530       error (_("Dwarf Error: DW_TAG_imported_unit is not"
10531                " supported in type units [in module %s]"),
10532              objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10533     }
10534
10535   attr = dwarf2_attr (die, DW_AT_import, cu);
10536   if (attr != NULL)
10537     {
10538       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10539       bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10540       dwarf2_per_cu_data *per_cu
10541         = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10542                                             cu->per_cu->dwarf2_per_objfile);
10543
10544       /* If necessary, add it to the queue and load its DIEs.  */
10545       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10546         load_full_comp_unit (per_cu, false, cu->language);
10547
10548       VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10549                      per_cu);
10550     }
10551 }
10552
10553 /* RAII object that represents a process_die scope: i.e.,
10554    starts/finishes processing a DIE.  */
10555 class process_die_scope
10556 {
10557 public:
10558   process_die_scope (die_info *die, dwarf2_cu *cu)
10559     : m_die (die), m_cu (cu)
10560   {
10561     /* We should only be processing DIEs not already in process.  */
10562     gdb_assert (!m_die->in_process);
10563     m_die->in_process = true;
10564   }
10565
10566   ~process_die_scope ()
10567   {
10568     m_die->in_process = false;
10569
10570     /* If we're done processing the DIE for the CU that owns the line
10571        header, we don't need the line header anymore.  */
10572     if (m_cu->line_header_die_owner == m_die)
10573       {
10574         delete m_cu->line_header;
10575         m_cu->line_header = NULL;
10576         m_cu->line_header_die_owner = NULL;
10577       }
10578   }
10579
10580 private:
10581   die_info *m_die;
10582   dwarf2_cu *m_cu;
10583 };
10584
10585 /* Process a die and its children.  */
10586
10587 static void
10588 process_die (struct die_info *die, struct dwarf2_cu *cu)
10589 {
10590   process_die_scope scope (die, cu);
10591
10592   switch (die->tag)
10593     {
10594     case DW_TAG_padding:
10595       break;
10596     case DW_TAG_compile_unit:
10597     case DW_TAG_partial_unit:
10598       read_file_scope (die, cu);
10599       break;
10600     case DW_TAG_type_unit:
10601       read_type_unit_scope (die, cu);
10602       break;
10603     case DW_TAG_subprogram:
10604     case DW_TAG_inlined_subroutine:
10605       read_func_scope (die, cu);
10606       break;
10607     case DW_TAG_lexical_block:
10608     case DW_TAG_try_block:
10609     case DW_TAG_catch_block:
10610       read_lexical_block_scope (die, cu);
10611       break;
10612     case DW_TAG_call_site:
10613     case DW_TAG_GNU_call_site:
10614       read_call_site_scope (die, cu);
10615       break;
10616     case DW_TAG_class_type:
10617     case DW_TAG_interface_type:
10618     case DW_TAG_structure_type:
10619     case DW_TAG_union_type:
10620       process_structure_scope (die, cu);
10621       break;
10622     case DW_TAG_enumeration_type:
10623       process_enumeration_scope (die, cu);
10624       break;
10625
10626     /* These dies have a type, but processing them does not create
10627        a symbol or recurse to process the children.  Therefore we can
10628        read them on-demand through read_type_die.  */
10629     case DW_TAG_subroutine_type:
10630     case DW_TAG_set_type:
10631     case DW_TAG_array_type:
10632     case DW_TAG_pointer_type:
10633     case DW_TAG_ptr_to_member_type:
10634     case DW_TAG_reference_type:
10635     case DW_TAG_rvalue_reference_type:
10636     case DW_TAG_string_type:
10637       break;
10638
10639     case DW_TAG_base_type:
10640     case DW_TAG_subrange_type:
10641     case DW_TAG_typedef:
10642       /* Add a typedef symbol for the type definition, if it has a
10643          DW_AT_name.  */
10644       new_symbol (die, read_type_die (die, cu), cu);
10645       break;
10646     case DW_TAG_common_block:
10647       read_common_block (die, cu);
10648       break;
10649     case DW_TAG_common_inclusion:
10650       break;
10651     case DW_TAG_namespace:
10652       cu->processing_has_namespace_info = true;
10653       read_namespace (die, cu);
10654       break;
10655     case DW_TAG_module:
10656       cu->processing_has_namespace_info = true;
10657       read_module (die, cu);
10658       break;
10659     case DW_TAG_imported_declaration:
10660       cu->processing_has_namespace_info = true;
10661       if (read_namespace_alias (die, cu))
10662         break;
10663       /* The declaration is not a global namespace alias.  */
10664       /* Fall through.  */
10665     case DW_TAG_imported_module:
10666       cu->processing_has_namespace_info = true;
10667       if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10668                                  || cu->language != language_fortran))
10669         complaint (_("Tag '%s' has unexpected children"),
10670                    dwarf_tag_name (die->tag));
10671       read_import_statement (die, cu);
10672       break;
10673
10674     case DW_TAG_imported_unit:
10675       process_imported_unit_die (die, cu);
10676       break;
10677
10678     case DW_TAG_variable:
10679       read_variable (die, cu);
10680       break;
10681
10682     default:
10683       new_symbol (die, NULL, cu);
10684       break;
10685     }
10686 }
10687 \f
10688 /* DWARF name computation.  */
10689
10690 /* A helper function for dwarf2_compute_name which determines whether DIE
10691    needs to have the name of the scope prepended to the name listed in the
10692    die.  */
10693
10694 static int
10695 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10696 {
10697   struct attribute *attr;
10698
10699   switch (die->tag)
10700     {
10701     case DW_TAG_namespace:
10702     case DW_TAG_typedef:
10703     case DW_TAG_class_type:
10704     case DW_TAG_interface_type:
10705     case DW_TAG_structure_type:
10706     case DW_TAG_union_type:
10707     case DW_TAG_enumeration_type:
10708     case DW_TAG_enumerator:
10709     case DW_TAG_subprogram:
10710     case DW_TAG_inlined_subroutine:
10711     case DW_TAG_member:
10712     case DW_TAG_imported_declaration:
10713       return 1;
10714
10715     case DW_TAG_variable:
10716     case DW_TAG_constant:
10717       /* We only need to prefix "globally" visible variables.  These include
10718          any variable marked with DW_AT_external or any variable that
10719          lives in a namespace.  [Variables in anonymous namespaces
10720          require prefixing, but they are not DW_AT_external.]  */
10721
10722       if (dwarf2_attr (die, DW_AT_specification, cu))
10723         {
10724           struct dwarf2_cu *spec_cu = cu;
10725
10726           return die_needs_namespace (die_specification (die, &spec_cu),
10727                                       spec_cu);
10728         }
10729
10730       attr = dwarf2_attr (die, DW_AT_external, cu);
10731       if (attr == NULL && die->parent->tag != DW_TAG_namespace
10732           && die->parent->tag != DW_TAG_module)
10733         return 0;
10734       /* A variable in a lexical block of some kind does not need a
10735          namespace, even though in C++ such variables may be external
10736          and have a mangled name.  */
10737       if (die->parent->tag ==  DW_TAG_lexical_block
10738           || die->parent->tag ==  DW_TAG_try_block
10739           || die->parent->tag ==  DW_TAG_catch_block
10740           || die->parent->tag == DW_TAG_subprogram)
10741         return 0;
10742       return 1;
10743
10744     default:
10745       return 0;
10746     }
10747 }
10748
10749 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10750    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10751    defined for the given DIE.  */
10752
10753 static struct attribute *
10754 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10755 {
10756   struct attribute *attr;
10757
10758   attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10759   if (attr == NULL)
10760     attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10761
10762   return attr;
10763 }
10764
10765 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10766    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10767    defined for the given DIE.  */
10768
10769 static const char *
10770 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10771 {
10772   const char *linkage_name;
10773
10774   linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10775   if (linkage_name == NULL)
10776     linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10777
10778   return linkage_name;
10779 }
10780
10781 /* Compute the fully qualified name of DIE in CU.  If PHYSNAME is nonzero,
10782    compute the physname for the object, which include a method's:
10783    - formal parameters (C++),
10784    - receiver type (Go),
10785
10786    The term "physname" is a bit confusing.
10787    For C++, for example, it is the demangled name.
10788    For Go, for example, it's the mangled name.
10789
10790    For Ada, return the DIE's linkage name rather than the fully qualified
10791    name.  PHYSNAME is ignored..
10792
10793    The result is allocated on the objfile_obstack and canonicalized.  */
10794
10795 static const char *
10796 dwarf2_compute_name (const char *name,
10797                      struct die_info *die, struct dwarf2_cu *cu,
10798                      int physname)
10799 {
10800   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10801
10802   if (name == NULL)
10803     name = dwarf2_name (die, cu);
10804
10805   /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10806      but otherwise compute it by typename_concat inside GDB.
10807      FIXME: Actually this is not really true, or at least not always true.
10808      It's all very confusing.  SYMBOL_SET_NAMES doesn't try to demangle
10809      Fortran names because there is no mangling standard.  So new_symbol
10810      will set the demangled name to the result of dwarf2_full_name, and it is
10811      the demangled name that GDB uses if it exists.  */
10812   if (cu->language == language_ada
10813       || (cu->language == language_fortran && physname))
10814     {
10815       /* For Ada unit, we prefer the linkage name over the name, as
10816          the former contains the exported name, which the user expects
10817          to be able to reference.  Ideally, we want the user to be able
10818          to reference this entity using either natural or linkage name,
10819          but we haven't started looking at this enhancement yet.  */
10820       const char *linkage_name = dw2_linkage_name (die, cu);
10821
10822       if (linkage_name != NULL)
10823         return linkage_name;
10824     }
10825
10826   /* These are the only languages we know how to qualify names in.  */
10827   if (name != NULL
10828       && (cu->language == language_cplus
10829           || cu->language == language_fortran || cu->language == language_d
10830           || cu->language == language_rust))
10831     {
10832       if (die_needs_namespace (die, cu))
10833         {
10834           const char *prefix;
10835           const char *canonical_name = NULL;
10836
10837           string_file buf;
10838
10839           prefix = determine_prefix (die, cu);
10840           if (*prefix != '\0')
10841             {
10842               char *prefixed_name = typename_concat (NULL, prefix, name,
10843                                                      physname, cu);
10844
10845               buf.puts (prefixed_name);
10846               xfree (prefixed_name);
10847             }
10848           else
10849             buf.puts (name);
10850
10851           /* Template parameters may be specified in the DIE's DW_AT_name, or
10852              as children with DW_TAG_template_type_param or
10853              DW_TAG_value_type_param.  If the latter, add them to the name
10854              here.  If the name already has template parameters, then
10855              skip this step; some versions of GCC emit both, and
10856              it is more efficient to use the pre-computed name.
10857
10858              Something to keep in mind about this process: it is very
10859              unlikely, or in some cases downright impossible, to produce
10860              something that will match the mangled name of a function.
10861              If the definition of the function has the same debug info,
10862              we should be able to match up with it anyway.  But fallbacks
10863              using the minimal symbol, for instance to find a method
10864              implemented in a stripped copy of libstdc++, will not work.
10865              If we do not have debug info for the definition, we will have to
10866              match them up some other way.
10867
10868              When we do name matching there is a related problem with function
10869              templates; two instantiated function templates are allowed to
10870              differ only by their return types, which we do not add here.  */
10871
10872           if (cu->language == language_cplus && strchr (name, '<') == NULL)
10873             {
10874               struct attribute *attr;
10875               struct die_info *child;
10876               int first = 1;
10877
10878               die->building_fullname = 1;
10879
10880               for (child = die->child; child != NULL; child = child->sibling)
10881                 {
10882                   struct type *type;
10883                   LONGEST value;
10884                   const gdb_byte *bytes;
10885                   struct dwarf2_locexpr_baton *baton;
10886                   struct value *v;
10887
10888                   if (child->tag != DW_TAG_template_type_param
10889                       && child->tag != DW_TAG_template_value_param)
10890                     continue;
10891
10892                   if (first)
10893                     {
10894                       buf.puts ("<");
10895                       first = 0;
10896                     }
10897                   else
10898                     buf.puts (", ");
10899
10900                   attr = dwarf2_attr (child, DW_AT_type, cu);
10901                   if (attr == NULL)
10902                     {
10903                       complaint (_("template parameter missing DW_AT_type"));
10904                       buf.puts ("UNKNOWN_TYPE");
10905                       continue;
10906                     }
10907                   type = die_type (child, cu);
10908
10909                   if (child->tag == DW_TAG_template_type_param)
10910                     {
10911                       c_print_type (type, "", &buf, -1, 0, cu->language,
10912                                     &type_print_raw_options);
10913                       continue;
10914                     }
10915
10916                   attr = dwarf2_attr (child, DW_AT_const_value, cu);
10917                   if (attr == NULL)
10918                     {
10919                       complaint (_("template parameter missing "
10920                                    "DW_AT_const_value"));
10921                       buf.puts ("UNKNOWN_VALUE");
10922                       continue;
10923                     }
10924
10925                   dwarf2_const_value_attr (attr, type, name,
10926                                            &cu->comp_unit_obstack, cu,
10927                                            &value, &bytes, &baton);
10928
10929                   if (TYPE_NOSIGN (type))
10930                     /* GDB prints characters as NUMBER 'CHAR'.  If that's
10931                        changed, this can use value_print instead.  */
10932                     c_printchar (value, type, &buf);
10933                   else
10934                     {
10935                       struct value_print_options opts;
10936
10937                       if (baton != NULL)
10938                         v = dwarf2_evaluate_loc_desc (type, NULL,
10939                                                       baton->data,
10940                                                       baton->size,
10941                                                       baton->per_cu);
10942                       else if (bytes != NULL)
10943                         {
10944                           v = allocate_value (type);
10945                           memcpy (value_contents_writeable (v), bytes,
10946                                   TYPE_LENGTH (type));
10947                         }
10948                       else
10949                         v = value_from_longest (type, value);
10950
10951                       /* Specify decimal so that we do not depend on
10952                          the radix.  */
10953                       get_formatted_print_options (&opts, 'd');
10954                       opts.raw = 1;
10955                       value_print (v, &buf, &opts);
10956                       release_value (v);
10957                     }
10958                 }
10959
10960               die->building_fullname = 0;
10961
10962               if (!first)
10963                 {
10964                   /* Close the argument list, with a space if necessary
10965                      (nested templates).  */
10966                   if (!buf.empty () && buf.string ().back () == '>')
10967                     buf.puts (" >");
10968                   else
10969                     buf.puts (">");
10970                 }
10971             }
10972
10973           /* For C++ methods, append formal parameter type
10974              information, if PHYSNAME.  */
10975
10976           if (physname && die->tag == DW_TAG_subprogram
10977               && cu->language == language_cplus)
10978             {
10979               struct type *type = read_type_die (die, cu);
10980
10981               c_type_print_args (type, &buf, 1, cu->language,
10982                                  &type_print_raw_options);
10983
10984               if (cu->language == language_cplus)
10985                 {
10986                   /* Assume that an artificial first parameter is
10987                      "this", but do not crash if it is not.  RealView
10988                      marks unnamed (and thus unused) parameters as
10989                      artificial; there is no way to differentiate
10990                      the two cases.  */
10991                   if (TYPE_NFIELDS (type) > 0
10992                       && TYPE_FIELD_ARTIFICIAL (type, 0)
10993                       && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10994                       && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10995                                                                         0))))
10996                     buf.puts (" const");
10997                 }
10998             }
10999
11000           const std::string &intermediate_name = buf.string ();
11001
11002           if (cu->language == language_cplus)
11003             canonical_name
11004               = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
11005                                           &objfile->per_bfd->storage_obstack);
11006
11007           /* If we only computed INTERMEDIATE_NAME, or if
11008              INTERMEDIATE_NAME is already canonical, then we need to
11009              copy it to the appropriate obstack.  */
11010           if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11011             name = ((const char *)
11012                     obstack_copy0 (&objfile->per_bfd->storage_obstack,
11013                                    intermediate_name.c_str (),
11014                                    intermediate_name.length ()));
11015           else
11016             name = canonical_name;
11017         }
11018     }
11019
11020   return name;
11021 }
11022
11023 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11024    If scope qualifiers are appropriate they will be added.  The result
11025    will be allocated on the storage_obstack, or NULL if the DIE does
11026    not have a name.  NAME may either be from a previous call to
11027    dwarf2_name or NULL.
11028
11029    The output string will be canonicalized (if C++).  */
11030
11031 static const char *
11032 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11033 {
11034   return dwarf2_compute_name (name, die, cu, 0);
11035 }
11036
11037 /* Construct a physname for the given DIE in CU.  NAME may either be
11038    from a previous call to dwarf2_name or NULL.  The result will be
11039    allocated on the objfile_objstack or NULL if the DIE does not have a
11040    name.
11041
11042    The output string will be canonicalized (if C++).  */
11043
11044 static const char *
11045 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11046 {
11047   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11048   const char *retval, *mangled = NULL, *canon = NULL;
11049   int need_copy = 1;
11050
11051   /* In this case dwarf2_compute_name is just a shortcut not building anything
11052      on its own.  */
11053   if (!die_needs_namespace (die, cu))
11054     return dwarf2_compute_name (name, die, cu, 1);
11055
11056   mangled = dw2_linkage_name (die, cu);
11057
11058   /* rustc emits invalid values for DW_AT_linkage_name.  Ignore these.
11059      See https://github.com/rust-lang/rust/issues/32925.  */
11060   if (cu->language == language_rust && mangled != NULL
11061       && strchr (mangled, '{') != NULL)
11062     mangled = NULL;
11063
11064   /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11065      has computed.  */
11066   gdb::unique_xmalloc_ptr<char> demangled;
11067   if (mangled != NULL)
11068     {
11069
11070       if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11071         {
11072           /* Do nothing (do not demangle the symbol name).  */
11073         }
11074       else if (cu->language == language_go)
11075         {
11076           /* This is a lie, but we already lie to the caller new_symbol.
11077              new_symbol assumes we return the mangled name.
11078              This just undoes that lie until things are cleaned up.  */
11079         }
11080       else
11081         {
11082           /* Use DMGL_RET_DROP for C++ template functions to suppress
11083              their return type.  It is easier for GDB users to search
11084              for such functions as `name(params)' than `long name(params)'.
11085              In such case the minimal symbol names do not match the full
11086              symbol names but for template functions there is never a need
11087              to look up their definition from their declaration so
11088              the only disadvantage remains the minimal symbol variant
11089              `long name(params)' does not have the proper inferior type.  */
11090           demangled.reset (gdb_demangle (mangled,
11091                                          (DMGL_PARAMS | DMGL_ANSI
11092                                           | DMGL_RET_DROP)));
11093         }
11094       if (demangled)
11095         canon = demangled.get ();
11096       else
11097         {
11098           canon = mangled;
11099           need_copy = 0;
11100         }
11101     }
11102
11103   if (canon == NULL || check_physname)
11104     {
11105       const char *physname = dwarf2_compute_name (name, die, cu, 1);
11106
11107       if (canon != NULL && strcmp (physname, canon) != 0)
11108         {
11109           /* It may not mean a bug in GDB.  The compiler could also
11110              compute DW_AT_linkage_name incorrectly.  But in such case
11111              GDB would need to be bug-to-bug compatible.  */
11112
11113           complaint (_("Computed physname <%s> does not match demangled <%s> "
11114                        "(from linkage <%s>) - DIE at %s [in module %s]"),
11115                      physname, canon, mangled, sect_offset_str (die->sect_off),
11116                      objfile_name (objfile));
11117
11118           /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11119              is available here - over computed PHYSNAME.  It is safer
11120              against both buggy GDB and buggy compilers.  */
11121
11122           retval = canon;
11123         }
11124       else
11125         {
11126           retval = physname;
11127           need_copy = 0;
11128         }
11129     }
11130   else
11131     retval = canon;
11132
11133   if (need_copy)
11134     retval = ((const char *)
11135               obstack_copy0 (&objfile->per_bfd->storage_obstack,
11136                              retval, strlen (retval)));
11137
11138   return retval;
11139 }
11140
11141 /* Inspect DIE in CU for a namespace alias.  If one exists, record
11142    a new symbol for it.
11143
11144    Returns 1 if a namespace alias was recorded, 0 otherwise.  */
11145
11146 static int
11147 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11148 {
11149   struct attribute *attr;
11150
11151   /* If the die does not have a name, this is not a namespace
11152      alias.  */
11153   attr = dwarf2_attr (die, DW_AT_name, cu);
11154   if (attr != NULL)
11155     {
11156       int num;
11157       struct die_info *d = die;
11158       struct dwarf2_cu *imported_cu = cu;
11159
11160       /* If the compiler has nested DW_AT_imported_declaration DIEs,
11161          keep inspecting DIEs until we hit the underlying import.  */
11162 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11163       for (num = 0; num  < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11164         {
11165           attr = dwarf2_attr (d, DW_AT_import, cu);
11166           if (attr == NULL)
11167             break;
11168
11169           d = follow_die_ref (d, attr, &imported_cu);
11170           if (d->tag != DW_TAG_imported_declaration)
11171             break;
11172         }
11173
11174       if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11175         {
11176           complaint (_("DIE at %s has too many recursively imported "
11177                        "declarations"), sect_offset_str (d->sect_off));
11178           return 0;
11179         }
11180
11181       if (attr != NULL)
11182         {
11183           struct type *type;
11184           sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11185
11186           type = get_die_type_at_offset (sect_off, cu->per_cu);
11187           if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11188             {
11189               /* This declaration is a global namespace alias.  Add
11190                  a symbol for it whose type is the aliased namespace.  */
11191               new_symbol (die, type, cu);
11192               return 1;
11193             }
11194         }
11195     }
11196
11197   return 0;
11198 }
11199
11200 /* Return the using directives repository (global or local?) to use in the
11201    current context for CU.
11202
11203    For Ada, imported declarations can materialize renamings, which *may* be
11204    global.  However it is impossible (for now?) in DWARF to distinguish
11205    "external" imported declarations and "static" ones.  As all imported
11206    declarations seem to be static in all other languages, make them all CU-wide
11207    global only in Ada.  */
11208
11209 static struct using_direct **
11210 using_directives (struct dwarf2_cu *cu)
11211 {
11212   if (cu->language == language_ada
11213       && cu->get_builder ()->outermost_context_p ())
11214     return cu->get_builder ()->get_global_using_directives ();
11215   else
11216     return cu->get_builder ()->get_local_using_directives ();
11217 }
11218
11219 /* Read the import statement specified by the given die and record it.  */
11220
11221 static void
11222 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11223 {
11224   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11225   struct attribute *import_attr;
11226   struct die_info *imported_die, *child_die;
11227   struct dwarf2_cu *imported_cu;
11228   const char *imported_name;
11229   const char *imported_name_prefix;
11230   const char *canonical_name;
11231   const char *import_alias;
11232   const char *imported_declaration = NULL;
11233   const char *import_prefix;
11234   std::vector<const char *> excludes;
11235
11236   import_attr = dwarf2_attr (die, DW_AT_import, cu);
11237   if (import_attr == NULL)
11238     {
11239       complaint (_("Tag '%s' has no DW_AT_import"),
11240                  dwarf_tag_name (die->tag));
11241       return;
11242     }
11243
11244   imported_cu = cu;
11245   imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11246   imported_name = dwarf2_name (imported_die, imported_cu);
11247   if (imported_name == NULL)
11248     {
11249       /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11250
11251         The import in the following code:
11252         namespace A
11253           {
11254             typedef int B;
11255           }
11256
11257         int main ()
11258           {
11259             using A::B;
11260             B b;
11261             return b;
11262           }
11263
11264         ...
11265          <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11266             <52>   DW_AT_decl_file   : 1
11267             <53>   DW_AT_decl_line   : 6
11268             <54>   DW_AT_import      : <0x75>
11269          <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11270             <59>   DW_AT_name        : B
11271             <5b>   DW_AT_decl_file   : 1
11272             <5c>   DW_AT_decl_line   : 2
11273             <5d>   DW_AT_type        : <0x6e>
11274         ...
11275          <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11276             <76>   DW_AT_byte_size   : 4
11277             <77>   DW_AT_encoding    : 5        (signed)
11278
11279         imports the wrong die ( 0x75 instead of 0x58 ).
11280         This case will be ignored until the gcc bug is fixed.  */
11281       return;
11282     }
11283
11284   /* Figure out the local name after import.  */
11285   import_alias = dwarf2_name (die, cu);
11286
11287   /* Figure out where the statement is being imported to.  */
11288   import_prefix = determine_prefix (die, cu);
11289
11290   /* Figure out what the scope of the imported die is and prepend it
11291      to the name of the imported die.  */
11292   imported_name_prefix = determine_prefix (imported_die, imported_cu);
11293
11294   if (imported_die->tag != DW_TAG_namespace
11295       && imported_die->tag != DW_TAG_module)
11296     {
11297       imported_declaration = imported_name;
11298       canonical_name = imported_name_prefix;
11299     }
11300   else if (strlen (imported_name_prefix) > 0)
11301     canonical_name = obconcat (&objfile->objfile_obstack,
11302                                imported_name_prefix,
11303                                (cu->language == language_d ? "." : "::"),
11304                                imported_name, (char *) NULL);
11305   else
11306     canonical_name = imported_name;
11307
11308   if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11309     for (child_die = die->child; child_die && child_die->tag;
11310          child_die = sibling_die (child_die))
11311       {
11312         /* DWARF-4: A Fortran use statement with a “rename list” may be
11313            represented by an imported module entry with an import attribute
11314            referring to the module and owned entries corresponding to those
11315            entities that are renamed as part of being imported.  */
11316
11317         if (child_die->tag != DW_TAG_imported_declaration)
11318           {
11319             complaint (_("child DW_TAG_imported_declaration expected "
11320                          "- DIE at %s [in module %s]"),
11321                        sect_offset_str (child_die->sect_off),
11322                        objfile_name (objfile));
11323             continue;
11324           }
11325
11326         import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11327         if (import_attr == NULL)
11328           {
11329             complaint (_("Tag '%s' has no DW_AT_import"),
11330                        dwarf_tag_name (child_die->tag));
11331             continue;
11332           }
11333
11334         imported_cu = cu;
11335         imported_die = follow_die_ref_or_sig (child_die, import_attr,
11336                                               &imported_cu);
11337         imported_name = dwarf2_name (imported_die, imported_cu);
11338         if (imported_name == NULL)
11339           {
11340             complaint (_("child DW_TAG_imported_declaration has unknown "
11341                          "imported name - DIE at %s [in module %s]"),
11342                        sect_offset_str (child_die->sect_off),
11343                        objfile_name (objfile));
11344             continue;
11345           }
11346
11347         excludes.push_back (imported_name);
11348
11349         process_die (child_die, cu);
11350       }
11351
11352   add_using_directive (using_directives (cu),
11353                        import_prefix,
11354                        canonical_name,
11355                        import_alias,
11356                        imported_declaration,
11357                        excludes,
11358                        0,
11359                        &objfile->objfile_obstack);
11360 }
11361
11362 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11363    types, but gives them a size of zero.  Starting with version 14,
11364    ICC is compatible with GCC.  */
11365
11366 static bool
11367 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11368 {
11369   if (!cu->checked_producer)
11370     check_producer (cu);
11371
11372   return cu->producer_is_icc_lt_14;
11373 }
11374
11375 /* ICC generates a DW_AT_type for C void functions.  This was observed on
11376    ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11377    which says that void functions should not have a DW_AT_type.  */
11378
11379 static bool
11380 producer_is_icc (struct dwarf2_cu *cu)
11381 {
11382   if (!cu->checked_producer)
11383     check_producer (cu);
11384
11385   return cu->producer_is_icc;
11386 }
11387
11388 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11389    directory paths.  GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11390    this, it was first present in GCC release 4.3.0.  */
11391
11392 static bool
11393 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11394 {
11395   if (!cu->checked_producer)
11396     check_producer (cu);
11397
11398   return cu->producer_is_gcc_lt_4_3;
11399 }
11400
11401 static file_and_directory
11402 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11403 {
11404   file_and_directory res;
11405
11406   /* Find the filename.  Do not use dwarf2_name here, since the filename
11407      is not a source language identifier.  */
11408   res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11409   res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11410
11411   if (res.comp_dir == NULL
11412       && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11413       && IS_ABSOLUTE_PATH (res.name))
11414     {
11415       res.comp_dir_storage = ldirname (res.name);
11416       if (!res.comp_dir_storage.empty ())
11417         res.comp_dir = res.comp_dir_storage.c_str ();
11418     }
11419   if (res.comp_dir != NULL)
11420     {
11421       /* Irix 6.2 native cc prepends <machine>.: to the compilation
11422          directory, get rid of it.  */
11423       const char *cp = strchr (res.comp_dir, ':');
11424
11425       if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11426         res.comp_dir = cp + 1;
11427     }
11428
11429   if (res.name == NULL)
11430     res.name = "<unknown>";
11431
11432   return res;
11433 }
11434
11435 /* Handle DW_AT_stmt_list for a compilation unit.
11436    DIE is the DW_TAG_compile_unit die for CU.
11437    COMP_DIR is the compilation directory.  LOWPC is passed to
11438    dwarf_decode_lines.  See dwarf_decode_lines comments about it.  */
11439
11440 static void
11441 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11442                         const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11443 {
11444   struct dwarf2_per_objfile *dwarf2_per_objfile
11445     = cu->per_cu->dwarf2_per_objfile;
11446   struct objfile *objfile = dwarf2_per_objfile->objfile;
11447   struct attribute *attr;
11448   struct line_header line_header_local;
11449   hashval_t line_header_local_hash;
11450   void **slot;
11451   int decode_mapping;
11452
11453   gdb_assert (! cu->per_cu->is_debug_types);
11454
11455   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11456   if (attr == NULL)
11457     return;
11458
11459   sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11460
11461   /* The line header hash table is only created if needed (it exists to
11462      prevent redundant reading of the line table for partial_units).
11463      If we're given a partial_unit, we'll need it.  If we're given a
11464      compile_unit, then use the line header hash table if it's already
11465      created, but don't create one just yet.  */
11466
11467   if (dwarf2_per_objfile->line_header_hash == NULL
11468       && die->tag == DW_TAG_partial_unit)
11469     {
11470       dwarf2_per_objfile->line_header_hash
11471         = htab_create_alloc_ex (127, line_header_hash_voidp,
11472                                 line_header_eq_voidp,
11473                                 free_line_header_voidp,
11474                                 &objfile->objfile_obstack,
11475                                 hashtab_obstack_allocate,
11476                                 dummy_obstack_deallocate);
11477     }
11478
11479   line_header_local.sect_off = line_offset;
11480   line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11481   line_header_local_hash = line_header_hash (&line_header_local);
11482   if (dwarf2_per_objfile->line_header_hash != NULL)
11483     {
11484       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11485                                        &line_header_local,
11486                                        line_header_local_hash, NO_INSERT);
11487
11488       /* For DW_TAG_compile_unit we need info like symtab::linetable which
11489          is not present in *SLOT (since if there is something in *SLOT then
11490          it will be for a partial_unit).  */
11491       if (die->tag == DW_TAG_partial_unit && slot != NULL)
11492         {
11493           gdb_assert (*slot != NULL);
11494           cu->line_header = (struct line_header *) *slot;
11495           return;
11496         }
11497     }
11498
11499   /* dwarf_decode_line_header does not yet provide sufficient information.
11500      We always have to call also dwarf_decode_lines for it.  */
11501   line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11502   if (lh == NULL)
11503     return;
11504
11505   cu->line_header = lh.release ();
11506   cu->line_header_die_owner = die;
11507
11508   if (dwarf2_per_objfile->line_header_hash == NULL)
11509     slot = NULL;
11510   else
11511     {
11512       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11513                                        &line_header_local,
11514                                        line_header_local_hash, INSERT);
11515       gdb_assert (slot != NULL);
11516     }
11517   if (slot != NULL && *slot == NULL)
11518     {
11519       /* This newly decoded line number information unit will be owned
11520          by line_header_hash hash table.  */
11521       *slot = cu->line_header;
11522       cu->line_header_die_owner = NULL;
11523     }
11524   else
11525     {
11526       /* We cannot free any current entry in (*slot) as that struct line_header
11527          may be already used by multiple CUs.  Create only temporary decoded
11528          line_header for this CU - it may happen at most once for each line
11529          number information unit.  And if we're not using line_header_hash
11530          then this is what we want as well.  */
11531       gdb_assert (die->tag != DW_TAG_partial_unit);
11532     }
11533   decode_mapping = (die->tag != DW_TAG_partial_unit);
11534   dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11535                       decode_mapping);
11536
11537 }
11538
11539 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit.  */
11540
11541 static void
11542 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11543 {
11544   struct dwarf2_per_objfile *dwarf2_per_objfile
11545     = cu->per_cu->dwarf2_per_objfile;
11546   struct objfile *objfile = dwarf2_per_objfile->objfile;
11547   struct gdbarch *gdbarch = get_objfile_arch (objfile);
11548   CORE_ADDR lowpc = ((CORE_ADDR) -1);
11549   CORE_ADDR highpc = ((CORE_ADDR) 0);
11550   struct attribute *attr;
11551   struct die_info *child_die;
11552   CORE_ADDR baseaddr;
11553
11554   prepare_one_comp_unit (cu, die, cu->language);
11555   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11556
11557   get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11558
11559   /* If we didn't find a lowpc, set it to highpc to avoid complaints
11560      from finish_block.  */
11561   if (lowpc == ((CORE_ADDR) -1))
11562     lowpc = highpc;
11563   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11564
11565   file_and_directory fnd = find_file_and_directory (die, cu);
11566
11567   /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11568      standardised yet.  As a workaround for the language detection we fall
11569      back to the DW_AT_producer string.  */
11570   if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11571     cu->language = language_opencl;
11572
11573   /* Similar hack for Go.  */
11574   if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11575     set_cu_language (DW_LANG_Go, cu);
11576
11577   cu->start_symtab (fnd.name, fnd.comp_dir, lowpc);
11578
11579   /* Decode line number information if present.  We do this before
11580      processing child DIEs, so that the line header table is available
11581      for DW_AT_decl_file.  */
11582   handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11583
11584   /* Process all dies in compilation unit.  */
11585   if (die->child != NULL)
11586     {
11587       child_die = die->child;
11588       while (child_die && child_die->tag)
11589         {
11590           process_die (child_die, cu);
11591           child_die = sibling_die (child_die);
11592         }
11593     }
11594
11595   /* Decode macro information, if present.  Dwarf 2 macro information
11596      refers to information in the line number info statement program
11597      header, so we can only read it if we've read the header
11598      successfully.  */
11599   attr = dwarf2_attr (die, DW_AT_macros, cu);
11600   if (attr == NULL)
11601     attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11602   if (attr && cu->line_header)
11603     {
11604       if (dwarf2_attr (die, DW_AT_macro_info, cu))
11605         complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11606
11607       dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11608     }
11609   else
11610     {
11611       attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11612       if (attr && cu->line_header)
11613         {
11614           unsigned int macro_offset = DW_UNSND (attr);
11615
11616           dwarf_decode_macros (cu, macro_offset, 0);
11617         }
11618     }
11619 }
11620
11621 void
11622 dwarf2_cu::setup_type_unit_groups (struct die_info *die)
11623 {
11624   struct type_unit_group *tu_group;
11625   int first_time;
11626   struct attribute *attr;
11627   unsigned int i;
11628   struct signatured_type *sig_type;
11629
11630   gdb_assert (per_cu->is_debug_types);
11631   sig_type = (struct signatured_type *) per_cu;
11632
11633   attr = dwarf2_attr (die, DW_AT_stmt_list, this);
11634
11635   /* If we're using .gdb_index (includes -readnow) then
11636      per_cu->type_unit_group may not have been set up yet.  */
11637   if (sig_type->type_unit_group == NULL)
11638     sig_type->type_unit_group = get_type_unit_group (this, attr);
11639   tu_group = sig_type->type_unit_group;
11640
11641   /* If we've already processed this stmt_list there's no real need to
11642      do it again, we could fake it and just recreate the part we need
11643      (file name,index -> symtab mapping).  If data shows this optimization
11644      is useful we can do it then.  */
11645   first_time = tu_group->compunit_symtab == NULL;
11646
11647   /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11648      debug info.  */
11649   line_header_up lh;
11650   if (attr != NULL)
11651     {
11652       sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11653       lh = dwarf_decode_line_header (line_offset, this);
11654     }
11655   if (lh == NULL)
11656     {
11657       if (first_time)
11658         start_symtab ("", NULL, 0);
11659       else
11660         {
11661           gdb_assert (tu_group->symtabs == NULL);
11662           gdb_assert (m_builder == nullptr);
11663           struct compunit_symtab *cust = tu_group->compunit_symtab;
11664           m_builder.reset (new struct buildsym_compunit
11665                            (COMPUNIT_OBJFILE (cust), "",
11666                             COMPUNIT_DIRNAME (cust),
11667                             compunit_language (cust),
11668                             0, cust));
11669         }
11670       return;
11671     }
11672
11673   line_header = lh.release ();
11674   line_header_die_owner = die;
11675
11676   if (first_time)
11677     {
11678       struct compunit_symtab *cust = start_symtab ("", NULL, 0);
11679
11680       /* Note: We don't assign tu_group->compunit_symtab yet because we're
11681          still initializing it, and our caller (a few levels up)
11682          process_full_type_unit still needs to know if this is the first
11683          time.  */
11684
11685       tu_group->num_symtabs = line_header->file_names.size ();
11686       tu_group->symtabs = XNEWVEC (struct symtab *,
11687                                    line_header->file_names.size ());
11688
11689       for (i = 0; i < line_header->file_names.size (); ++i)
11690         {
11691           file_entry &fe = line_header->file_names[i];
11692
11693           dwarf2_start_subfile (this, fe.name,
11694                                 fe.include_dir (line_header));
11695           buildsym_compunit *b = get_builder ();
11696           if (b->get_current_subfile ()->symtab == NULL)
11697             {
11698               /* NOTE: start_subfile will recognize when it's been
11699                  passed a file it has already seen.  So we can't
11700                  assume there's a simple mapping from
11701                  cu->line_header->file_names to subfiles, plus
11702                  cu->line_header->file_names may contain dups.  */
11703               b->get_current_subfile ()->symtab
11704                 = allocate_symtab (cust, b->get_current_subfile ()->name);
11705             }
11706
11707           fe.symtab = b->get_current_subfile ()->symtab;
11708           tu_group->symtabs[i] = fe.symtab;
11709         }
11710     }
11711   else
11712     {
11713       gdb_assert (m_builder == nullptr);
11714       struct compunit_symtab *cust = tu_group->compunit_symtab;
11715       m_builder.reset (new struct buildsym_compunit
11716                        (COMPUNIT_OBJFILE (cust), "",
11717                         COMPUNIT_DIRNAME (cust),
11718                         compunit_language (cust),
11719                         0, cust));
11720
11721       for (i = 0; i < line_header->file_names.size (); ++i)
11722         {
11723           file_entry &fe = line_header->file_names[i];
11724
11725           fe.symtab = tu_group->symtabs[i];
11726         }
11727     }
11728
11729   /* The main symtab is allocated last.  Type units don't have DW_AT_name
11730      so they don't have a "real" (so to speak) symtab anyway.
11731      There is later code that will assign the main symtab to all symbols
11732      that don't have one.  We need to handle the case of a symbol with a
11733      missing symtab (DW_AT_decl_file) anyway.  */
11734 }
11735
11736 /* Process DW_TAG_type_unit.
11737    For TUs we want to skip the first top level sibling if it's not the
11738    actual type being defined by this TU.  In this case the first top
11739    level sibling is there to provide context only.  */
11740
11741 static void
11742 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11743 {
11744   struct die_info *child_die;
11745
11746   prepare_one_comp_unit (cu, die, language_minimal);
11747
11748   /* Initialize (or reinitialize) the machinery for building symtabs.
11749      We do this before processing child DIEs, so that the line header table
11750      is available for DW_AT_decl_file.  */
11751   cu->setup_type_unit_groups (die);
11752
11753   if (die->child != NULL)
11754     {
11755       child_die = die->child;
11756       while (child_die && child_die->tag)
11757         {
11758           process_die (child_die, cu);
11759           child_die = sibling_die (child_die);
11760         }
11761     }
11762 }
11763 \f
11764 /* DWO/DWP files.
11765
11766    http://gcc.gnu.org/wiki/DebugFission
11767    http://gcc.gnu.org/wiki/DebugFissionDWP
11768
11769    To simplify handling of both DWO files ("object" files with the DWARF info)
11770    and DWP files (a file with the DWOs packaged up into one file), we treat
11771    DWP files as having a collection of virtual DWO files.  */
11772
11773 static hashval_t
11774 hash_dwo_file (const void *item)
11775 {
11776   const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11777   hashval_t hash;
11778
11779   hash = htab_hash_string (dwo_file->dwo_name);
11780   if (dwo_file->comp_dir != NULL)
11781     hash += htab_hash_string (dwo_file->comp_dir);
11782   return hash;
11783 }
11784
11785 static int
11786 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11787 {
11788   const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11789   const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11790
11791   if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11792     return 0;
11793   if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11794     return lhs->comp_dir == rhs->comp_dir;
11795   return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11796 }
11797
11798 /* Allocate a hash table for DWO files.  */
11799
11800 static htab_t
11801 allocate_dwo_file_hash_table (struct objfile *objfile)
11802 {
11803   return htab_create_alloc_ex (41,
11804                                hash_dwo_file,
11805                                eq_dwo_file,
11806                                NULL,
11807                                &objfile->objfile_obstack,
11808                                hashtab_obstack_allocate,
11809                                dummy_obstack_deallocate);
11810 }
11811
11812 /* Lookup DWO file DWO_NAME.  */
11813
11814 static void **
11815 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11816                       const char *dwo_name,
11817                       const char *comp_dir)
11818 {
11819   struct dwo_file find_entry;
11820   void **slot;
11821
11822   if (dwarf2_per_objfile->dwo_files == NULL)
11823     dwarf2_per_objfile->dwo_files
11824       = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11825
11826   memset (&find_entry, 0, sizeof (find_entry));
11827   find_entry.dwo_name = dwo_name;
11828   find_entry.comp_dir = comp_dir;
11829   slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11830
11831   return slot;
11832 }
11833
11834 static hashval_t
11835 hash_dwo_unit (const void *item)
11836 {
11837   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11838
11839   /* This drops the top 32 bits of the id, but is ok for a hash.  */
11840   return dwo_unit->signature;
11841 }
11842
11843 static int
11844 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11845 {
11846   const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11847   const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11848
11849   /* The signature is assumed to be unique within the DWO file.
11850      So while object file CU dwo_id's always have the value zero,
11851      that's OK, assuming each object file DWO file has only one CU,
11852      and that's the rule for now.  */
11853   return lhs->signature == rhs->signature;
11854 }
11855
11856 /* Allocate a hash table for DWO CUs,TUs.
11857    There is one of these tables for each of CUs,TUs for each DWO file.  */
11858
11859 static htab_t
11860 allocate_dwo_unit_table (struct objfile *objfile)
11861 {
11862   /* Start out with a pretty small number.
11863      Generally DWO files contain only one CU and maybe some TUs.  */
11864   return htab_create_alloc_ex (3,
11865                                hash_dwo_unit,
11866                                eq_dwo_unit,
11867                                NULL,
11868                                &objfile->objfile_obstack,
11869                                hashtab_obstack_allocate,
11870                                dummy_obstack_deallocate);
11871 }
11872
11873 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader.  */
11874
11875 struct create_dwo_cu_data
11876 {
11877   struct dwo_file *dwo_file;
11878   struct dwo_unit dwo_unit;
11879 };
11880
11881 /* die_reader_func for create_dwo_cu.  */
11882
11883 static void
11884 create_dwo_cu_reader (const struct die_reader_specs *reader,
11885                       const gdb_byte *info_ptr,
11886                       struct die_info *comp_unit_die,
11887                       int has_children,
11888                       void *datap)
11889 {
11890   struct dwarf2_cu *cu = reader->cu;
11891   sect_offset sect_off = cu->per_cu->sect_off;
11892   struct dwarf2_section_info *section = cu->per_cu->section;
11893   struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11894   struct dwo_file *dwo_file = data->dwo_file;
11895   struct dwo_unit *dwo_unit = &data->dwo_unit;
11896   struct attribute *attr;
11897
11898   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11899   if (attr == NULL)
11900     {
11901       complaint (_("Dwarf Error: debug entry at offset %s is missing"
11902                    " its dwo_id [in module %s]"),
11903                  sect_offset_str (sect_off), dwo_file->dwo_name);
11904       return;
11905     }
11906
11907   dwo_unit->dwo_file = dwo_file;
11908   dwo_unit->signature = DW_UNSND (attr);
11909   dwo_unit->section = section;
11910   dwo_unit->sect_off = sect_off;
11911   dwo_unit->length = cu->per_cu->length;
11912
11913   if (dwarf_read_debug)
11914     fprintf_unfiltered (gdb_stdlog, "  offset %s, dwo_id %s\n",
11915                         sect_offset_str (sect_off),
11916                         hex_string (dwo_unit->signature));
11917 }
11918
11919 /* Create the dwo_units for the CUs in a DWO_FILE.
11920    Note: This function processes DWO files only, not DWP files.  */
11921
11922 static void
11923 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11924                        struct dwo_file &dwo_file, dwarf2_section_info &section,
11925                        htab_t &cus_htab)
11926 {
11927   struct objfile *objfile = dwarf2_per_objfile->objfile;
11928   const gdb_byte *info_ptr, *end_ptr;
11929
11930   dwarf2_read_section (objfile, &section);
11931   info_ptr = section.buffer;
11932
11933   if (info_ptr == NULL)
11934     return;
11935
11936   if (dwarf_read_debug)
11937     {
11938       fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11939                           get_section_name (&section),
11940                           get_section_file_name (&section));
11941     }
11942
11943   end_ptr = info_ptr + section.size;
11944   while (info_ptr < end_ptr)
11945     {
11946       struct dwarf2_per_cu_data per_cu;
11947       struct create_dwo_cu_data create_dwo_cu_data;
11948       struct dwo_unit *dwo_unit;
11949       void **slot;
11950       sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11951
11952       memset (&create_dwo_cu_data.dwo_unit, 0,
11953               sizeof (create_dwo_cu_data.dwo_unit));
11954       memset (&per_cu, 0, sizeof (per_cu));
11955       per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11956       per_cu.is_debug_types = 0;
11957       per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11958       per_cu.section = &section;
11959       create_dwo_cu_data.dwo_file = &dwo_file;
11960
11961       init_cutu_and_read_dies_no_follow (
11962           &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11963       info_ptr += per_cu.length;
11964
11965       // If the unit could not be parsed, skip it.
11966       if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11967         continue;
11968
11969       if (cus_htab == NULL)
11970         cus_htab = allocate_dwo_unit_table (objfile);
11971
11972       dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11973       *dwo_unit = create_dwo_cu_data.dwo_unit;
11974       slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11975       gdb_assert (slot != NULL);
11976       if (*slot != NULL)
11977         {
11978           const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11979           sect_offset dup_sect_off = dup_cu->sect_off;
11980
11981           complaint (_("debug cu entry at offset %s is duplicate to"
11982                        " the entry at offset %s, signature %s"),
11983                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11984                      hex_string (dwo_unit->signature));
11985         }
11986       *slot = (void *)dwo_unit;
11987     }
11988 }
11989
11990 /* DWP file .debug_{cu,tu}_index section format:
11991    [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11992
11993    DWP Version 1:
11994
11995    Both index sections have the same format, and serve to map a 64-bit
11996    signature to a set of section numbers.  Each section begins with a header,
11997    followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11998    indexes, and a pool of 32-bit section numbers.  The index sections will be
11999    aligned at 8-byte boundaries in the file.
12000
12001    The index section header consists of:
12002
12003     V, 32 bit version number
12004     -, 32 bits unused
12005     N, 32 bit number of compilation units or type units in the index
12006     M, 32 bit number of slots in the hash table
12007
12008    Numbers are recorded using the byte order of the application binary.
12009
12010    The hash table begins at offset 16 in the section, and consists of an array
12011    of M 64-bit slots.  Each slot contains a 64-bit signature (using the byte
12012    order of the application binary).  Unused slots in the hash table are 0.
12013    (We rely on the extreme unlikeliness of a signature being exactly 0.)
12014
12015    The parallel table begins immediately after the hash table
12016    (at offset 16 + 8 * M from the beginning of the section), and consists of an
12017    array of 32-bit indexes (using the byte order of the application binary),
12018    corresponding 1-1 with slots in the hash table.  Each entry in the parallel
12019    table contains a 32-bit index into the pool of section numbers.  For unused
12020    hash table slots, the corresponding entry in the parallel table will be 0.
12021
12022    The pool of section numbers begins immediately following the hash table
12023    (at offset 16 + 12 * M from the beginning of the section).  The pool of
12024    section numbers consists of an array of 32-bit words (using the byte order
12025    of the application binary).  Each item in the array is indexed starting
12026    from 0.  The hash table entry provides the index of the first section
12027    number in the set.  Additional section numbers in the set follow, and the
12028    set is terminated by a 0 entry (section number 0 is not used in ELF).
12029
12030    In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12031    section must be the first entry in the set, and the .debug_abbrev.dwo must
12032    be the second entry. Other members of the set may follow in any order.
12033
12034    ---
12035
12036    DWP Version 2:
12037
12038    DWP Version 2 combines all the .debug_info, etc. sections into one,
12039    and the entries in the index tables are now offsets into these sections.
12040    CU offsets begin at 0.  TU offsets begin at the size of the .debug_info
12041    section.
12042
12043    Index Section Contents:
12044     Header
12045     Hash Table of Signatures   dwp_hash_table.hash_table
12046     Parallel Table of Indices  dwp_hash_table.unit_table
12047     Table of Section Offsets   dwp_hash_table.v2.{section_ids,offsets}
12048     Table of Section Sizes     dwp_hash_table.v2.sizes
12049
12050    The index section header consists of:
12051
12052     V, 32 bit version number
12053     L, 32 bit number of columns in the table of section offsets
12054     N, 32 bit number of compilation units or type units in the index
12055     M, 32 bit number of slots in the hash table
12056
12057    Numbers are recorded using the byte order of the application binary.
12058
12059    The hash table has the same format as version 1.
12060    The parallel table of indices has the same format as version 1,
12061    except that the entries are origin-1 indices into the table of sections
12062    offsets and the table of section sizes.
12063
12064    The table of offsets begins immediately following the parallel table
12065    (at offset 16 + 12 * M from the beginning of the section).  The table is
12066    a two-dimensional array of 32-bit words (using the byte order of the
12067    application binary), with L columns and N+1 rows, in row-major order.
12068    Each row in the array is indexed starting from 0.  The first row provides
12069    a key to the remaining rows: each column in this row provides an identifier
12070    for a debug section, and the offsets in the same column of subsequent rows
12071    refer to that section.  The section identifiers are:
12072
12073     DW_SECT_INFO         1  .debug_info.dwo
12074     DW_SECT_TYPES        2  .debug_types.dwo
12075     DW_SECT_ABBREV       3  .debug_abbrev.dwo
12076     DW_SECT_LINE         4  .debug_line.dwo
12077     DW_SECT_LOC          5  .debug_loc.dwo
12078     DW_SECT_STR_OFFSETS  6  .debug_str_offsets.dwo
12079     DW_SECT_MACINFO      7  .debug_macinfo.dwo
12080     DW_SECT_MACRO        8  .debug_macro.dwo
12081
12082    The offsets provided by the CU and TU index sections are the base offsets
12083    for the contributions made by each CU or TU to the corresponding section
12084    in the package file.  Each CU and TU header contains an abbrev_offset
12085    field, used to find the abbreviations table for that CU or TU within the
12086    contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12087    be interpreted as relative to the base offset given in the index section.
12088    Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12089    should be interpreted as relative to the base offset for .debug_line.dwo,
12090    and offsets into other debug sections obtained from DWARF attributes should
12091    also be interpreted as relative to the corresponding base offset.
12092
12093    The table of sizes begins immediately following the table of offsets.
12094    Like the table of offsets, it is a two-dimensional array of 32-bit words,
12095    with L columns and N rows, in row-major order.  Each row in the array is
12096    indexed starting from 1 (row 0 is shared by the two tables).
12097
12098    ---
12099
12100    Hash table lookup is handled the same in version 1 and 2:
12101
12102    We assume that N and M will not exceed 2^32 - 1.
12103    The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12104
12105    Given a 64-bit compilation unit signature or a type signature S, an entry
12106    in the hash table is located as follows:
12107
12108    1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12109       the low-order k bits all set to 1.
12110
12111    2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12112
12113    3) If the hash table entry at index H matches the signature, use that
12114       entry.  If the hash table entry at index H is unused (all zeroes),
12115       terminate the search: the signature is not present in the table.
12116
12117    4) Let H = (H + H') modulo M. Repeat at Step 3.
12118
12119    Because M > N and H' and M are relatively prime, the search is guaranteed
12120    to stop at an unused slot or find the match.  */
12121
12122 /* Create a hash table to map DWO IDs to their CU/TU entry in
12123    .debug_{info,types}.dwo in DWP_FILE.
12124    Returns NULL if there isn't one.
12125    Note: This function processes DWP files only, not DWO files.  */
12126
12127 static struct dwp_hash_table *
12128 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12129                        struct dwp_file *dwp_file, int is_debug_types)
12130 {
12131   struct objfile *objfile = dwarf2_per_objfile->objfile;
12132   bfd *dbfd = dwp_file->dbfd.get ();
12133   const gdb_byte *index_ptr, *index_end;
12134   struct dwarf2_section_info *index;
12135   uint32_t version, nr_columns, nr_units, nr_slots;
12136   struct dwp_hash_table *htab;
12137
12138   if (is_debug_types)
12139     index = &dwp_file->sections.tu_index;
12140   else
12141     index = &dwp_file->sections.cu_index;
12142
12143   if (dwarf2_section_empty_p (index))
12144     return NULL;
12145   dwarf2_read_section (objfile, index);
12146
12147   index_ptr = index->buffer;
12148   index_end = index_ptr + index->size;
12149
12150   version = read_4_bytes (dbfd, index_ptr);
12151   index_ptr += 4;
12152   if (version == 2)
12153     nr_columns = read_4_bytes (dbfd, index_ptr);
12154   else
12155     nr_columns = 0;
12156   index_ptr += 4;
12157   nr_units = read_4_bytes (dbfd, index_ptr);
12158   index_ptr += 4;
12159   nr_slots = read_4_bytes (dbfd, index_ptr);
12160   index_ptr += 4;
12161
12162   if (version != 1 && version != 2)
12163     {
12164       error (_("Dwarf Error: unsupported DWP file version (%s)"
12165                " [in module %s]"),
12166              pulongest (version), dwp_file->name);
12167     }
12168   if (nr_slots != (nr_slots & -nr_slots))
12169     {
12170       error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12171                " is not power of 2 [in module %s]"),
12172              pulongest (nr_slots), dwp_file->name);
12173     }
12174
12175   htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12176   htab->version = version;
12177   htab->nr_columns = nr_columns;
12178   htab->nr_units = nr_units;
12179   htab->nr_slots = nr_slots;
12180   htab->hash_table = index_ptr;
12181   htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12182
12183   /* Exit early if the table is empty.  */
12184   if (nr_slots == 0 || nr_units == 0
12185       || (version == 2 && nr_columns == 0))
12186     {
12187       /* All must be zero.  */
12188       if (nr_slots != 0 || nr_units != 0
12189           || (version == 2 && nr_columns != 0))
12190         {
12191           complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12192                        " all zero [in modules %s]"),
12193                      dwp_file->name);
12194         }
12195       return htab;
12196     }
12197
12198   if (version == 1)
12199     {
12200       htab->section_pool.v1.indices =
12201         htab->unit_table + sizeof (uint32_t) * nr_slots;
12202       /* It's harder to decide whether the section is too small in v1.
12203          V1 is deprecated anyway so we punt.  */
12204     }
12205   else
12206     {
12207       const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12208       int *ids = htab->section_pool.v2.section_ids;
12209       size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12210       /* Reverse map for error checking.  */
12211       int ids_seen[DW_SECT_MAX + 1];
12212       int i;
12213
12214       if (nr_columns < 2)
12215         {
12216           error (_("Dwarf Error: bad DWP hash table, too few columns"
12217                    " in section table [in module %s]"),
12218                  dwp_file->name);
12219         }
12220       if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12221         {
12222           error (_("Dwarf Error: bad DWP hash table, too many columns"
12223                    " in section table [in module %s]"),
12224                  dwp_file->name);
12225         }
12226       memset (ids, 255, sizeof_ids);
12227       memset (ids_seen, 255, sizeof (ids_seen));
12228       for (i = 0; i < nr_columns; ++i)
12229         {
12230           int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12231
12232           if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12233             {
12234               error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12235                        " in section table [in module %s]"),
12236                      id, dwp_file->name);
12237             }
12238           if (ids_seen[id] != -1)
12239             {
12240               error (_("Dwarf Error: bad DWP hash table, duplicate section"
12241                        " id %d in section table [in module %s]"),
12242                      id, dwp_file->name);
12243             }
12244           ids_seen[id] = i;
12245           ids[i] = id;
12246         }
12247       /* Must have exactly one info or types section.  */
12248       if (((ids_seen[DW_SECT_INFO] != -1)
12249            + (ids_seen[DW_SECT_TYPES] != -1))
12250           != 1)
12251         {
12252           error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12253                    " DWO info/types section [in module %s]"),
12254                  dwp_file->name);
12255         }
12256       /* Must have an abbrev section.  */
12257       if (ids_seen[DW_SECT_ABBREV] == -1)
12258         {
12259           error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12260                    " section [in module %s]"),
12261                  dwp_file->name);
12262         }
12263       htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12264       htab->section_pool.v2.sizes =
12265         htab->section_pool.v2.offsets + (sizeof (uint32_t)
12266                                          * nr_units * nr_columns);
12267       if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12268                                           * nr_units * nr_columns))
12269           > index_end)
12270         {
12271           error (_("Dwarf Error: DWP index section is corrupt (too small)"
12272                    " [in module %s]"),
12273                  dwp_file->name);
12274         }
12275     }
12276
12277   return htab;
12278 }
12279
12280 /* Update SECTIONS with the data from SECTP.
12281
12282    This function is like the other "locate" section routines that are
12283    passed to bfd_map_over_sections, but in this context the sections to
12284    read comes from the DWP V1 hash table, not the full ELF section table.
12285
12286    The result is non-zero for success, or zero if an error was found.  */
12287
12288 static int
12289 locate_v1_virtual_dwo_sections (asection *sectp,
12290                                 struct virtual_v1_dwo_sections *sections)
12291 {
12292   const struct dwop_section_names *names = &dwop_section_names;
12293
12294   if (section_is_p (sectp->name, &names->abbrev_dwo))
12295     {
12296       /* There can be only one.  */
12297       if (sections->abbrev.s.section != NULL)
12298         return 0;
12299       sections->abbrev.s.section = sectp;
12300       sections->abbrev.size = bfd_get_section_size (sectp);
12301     }
12302   else if (section_is_p (sectp->name, &names->info_dwo)
12303            || section_is_p (sectp->name, &names->types_dwo))
12304     {
12305       /* There can be only one.  */
12306       if (sections->info_or_types.s.section != NULL)
12307         return 0;
12308       sections->info_or_types.s.section = sectp;
12309       sections->info_or_types.size = bfd_get_section_size (sectp);
12310     }
12311   else if (section_is_p (sectp->name, &names->line_dwo))
12312     {
12313       /* There can be only one.  */
12314       if (sections->line.s.section != NULL)
12315         return 0;
12316       sections->line.s.section = sectp;
12317       sections->line.size = bfd_get_section_size (sectp);
12318     }
12319   else if (section_is_p (sectp->name, &names->loc_dwo))
12320     {
12321       /* There can be only one.  */
12322       if (sections->loc.s.section != NULL)
12323         return 0;
12324       sections->loc.s.section = sectp;
12325       sections->loc.size = bfd_get_section_size (sectp);
12326     }
12327   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12328     {
12329       /* There can be only one.  */
12330       if (sections->macinfo.s.section != NULL)
12331         return 0;
12332       sections->macinfo.s.section = sectp;
12333       sections->macinfo.size = bfd_get_section_size (sectp);
12334     }
12335   else if (section_is_p (sectp->name, &names->macro_dwo))
12336     {
12337       /* There can be only one.  */
12338       if (sections->macro.s.section != NULL)
12339         return 0;
12340       sections->macro.s.section = sectp;
12341       sections->macro.size = bfd_get_section_size (sectp);
12342     }
12343   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12344     {
12345       /* There can be only one.  */
12346       if (sections->str_offsets.s.section != NULL)
12347         return 0;
12348       sections->str_offsets.s.section = sectp;
12349       sections->str_offsets.size = bfd_get_section_size (sectp);
12350     }
12351   else
12352     {
12353       /* No other kind of section is valid.  */
12354       return 0;
12355     }
12356
12357   return 1;
12358 }
12359
12360 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12361    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12362    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12363    This is for DWP version 1 files.  */
12364
12365 static struct dwo_unit *
12366 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12367                            struct dwp_file *dwp_file,
12368                            uint32_t unit_index,
12369                            const char *comp_dir,
12370                            ULONGEST signature, int is_debug_types)
12371 {
12372   struct objfile *objfile = dwarf2_per_objfile->objfile;
12373   const struct dwp_hash_table *dwp_htab =
12374     is_debug_types ? dwp_file->tus : dwp_file->cus;
12375   bfd *dbfd = dwp_file->dbfd.get ();
12376   const char *kind = is_debug_types ? "TU" : "CU";
12377   struct dwo_file *dwo_file;
12378   struct dwo_unit *dwo_unit;
12379   struct virtual_v1_dwo_sections sections;
12380   void **dwo_file_slot;
12381   int i;
12382
12383   gdb_assert (dwp_file->version == 1);
12384
12385   if (dwarf_read_debug)
12386     {
12387       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12388                           kind,
12389                           pulongest (unit_index), hex_string (signature),
12390                           dwp_file->name);
12391     }
12392
12393   /* Fetch the sections of this DWO unit.
12394      Put a limit on the number of sections we look for so that bad data
12395      doesn't cause us to loop forever.  */
12396
12397 #define MAX_NR_V1_DWO_SECTIONS \
12398   (1 /* .debug_info or .debug_types */ \
12399    + 1 /* .debug_abbrev */ \
12400    + 1 /* .debug_line */ \
12401    + 1 /* .debug_loc */ \
12402    + 1 /* .debug_str_offsets */ \
12403    + 1 /* .debug_macro or .debug_macinfo */ \
12404    + 1 /* trailing zero */)
12405
12406   memset (&sections, 0, sizeof (sections));
12407
12408   for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12409     {
12410       asection *sectp;
12411       uint32_t section_nr =
12412         read_4_bytes (dbfd,
12413                       dwp_htab->section_pool.v1.indices
12414                       + (unit_index + i) * sizeof (uint32_t));
12415
12416       if (section_nr == 0)
12417         break;
12418       if (section_nr >= dwp_file->num_sections)
12419         {
12420           error (_("Dwarf Error: bad DWP hash table, section number too large"
12421                    " [in module %s]"),
12422                  dwp_file->name);
12423         }
12424
12425       sectp = dwp_file->elf_sections[section_nr];
12426       if (! locate_v1_virtual_dwo_sections (sectp, &sections))
12427         {
12428           error (_("Dwarf Error: bad DWP hash table, invalid section found"
12429                    " [in module %s]"),
12430                  dwp_file->name);
12431         }
12432     }
12433
12434   if (i < 2
12435       || dwarf2_section_empty_p (&sections.info_or_types)
12436       || dwarf2_section_empty_p (&sections.abbrev))
12437     {
12438       error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12439                " [in module %s]"),
12440              dwp_file->name);
12441     }
12442   if (i == MAX_NR_V1_DWO_SECTIONS)
12443     {
12444       error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12445                " [in module %s]"),
12446              dwp_file->name);
12447     }
12448
12449   /* It's easier for the rest of the code if we fake a struct dwo_file and
12450      have dwo_unit "live" in that.  At least for now.
12451
12452      The DWP file can be made up of a random collection of CUs and TUs.
12453      However, for each CU + set of TUs that came from the same original DWO
12454      file, we can combine them back into a virtual DWO file to save space
12455      (fewer struct dwo_file objects to allocate).  Remember that for really
12456      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12457
12458   std::string virtual_dwo_name =
12459     string_printf ("virtual-dwo/%d-%d-%d-%d",
12460                    get_section_id (&sections.abbrev),
12461                    get_section_id (&sections.line),
12462                    get_section_id (&sections.loc),
12463                    get_section_id (&sections.str_offsets));
12464   /* Can we use an existing virtual DWO file?  */
12465   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12466                                         virtual_dwo_name.c_str (),
12467                                         comp_dir);
12468   /* Create one if necessary.  */
12469   if (*dwo_file_slot == NULL)
12470     {
12471       if (dwarf_read_debug)
12472         {
12473           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12474                               virtual_dwo_name.c_str ());
12475         }
12476       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12477       dwo_file->dwo_name
12478         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12479                                         virtual_dwo_name.c_str (),
12480                                         virtual_dwo_name.size ());
12481       dwo_file->comp_dir = comp_dir;
12482       dwo_file->sections.abbrev = sections.abbrev;
12483       dwo_file->sections.line = sections.line;
12484       dwo_file->sections.loc = sections.loc;
12485       dwo_file->sections.macinfo = sections.macinfo;
12486       dwo_file->sections.macro = sections.macro;
12487       dwo_file->sections.str_offsets = sections.str_offsets;
12488       /* The "str" section is global to the entire DWP file.  */
12489       dwo_file->sections.str = dwp_file->sections.str;
12490       /* The info or types section is assigned below to dwo_unit,
12491          there's no need to record it in dwo_file.
12492          Also, we can't simply record type sections in dwo_file because
12493          we record a pointer into the vector in dwo_unit.  As we collect more
12494          types we'll grow the vector and eventually have to reallocate space
12495          for it, invalidating all copies of pointers into the previous
12496          contents.  */
12497       *dwo_file_slot = dwo_file;
12498     }
12499   else
12500     {
12501       if (dwarf_read_debug)
12502         {
12503           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12504                               virtual_dwo_name.c_str ());
12505         }
12506       dwo_file = (struct dwo_file *) *dwo_file_slot;
12507     }
12508
12509   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12510   dwo_unit->dwo_file = dwo_file;
12511   dwo_unit->signature = signature;
12512   dwo_unit->section =
12513     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12514   *dwo_unit->section = sections.info_or_types;
12515   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12516
12517   return dwo_unit;
12518 }
12519
12520 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12521    Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12522    piece within that section used by a TU/CU, return a virtual section
12523    of just that piece.  */
12524
12525 static struct dwarf2_section_info
12526 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12527                        struct dwarf2_section_info *section,
12528                        bfd_size_type offset, bfd_size_type size)
12529 {
12530   struct dwarf2_section_info result;
12531   asection *sectp;
12532
12533   gdb_assert (section != NULL);
12534   gdb_assert (!section->is_virtual);
12535
12536   memset (&result, 0, sizeof (result));
12537   result.s.containing_section = section;
12538   result.is_virtual = 1;
12539
12540   if (size == 0)
12541     return result;
12542
12543   sectp = get_section_bfd_section (section);
12544
12545   /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12546      bounds of the real section.  This is a pretty-rare event, so just
12547      flag an error (easier) instead of a warning and trying to cope.  */
12548   if (sectp == NULL
12549       || offset + size > bfd_get_section_size (sectp))
12550     {
12551       error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12552                " in section %s [in module %s]"),
12553              sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12554              objfile_name (dwarf2_per_objfile->objfile));
12555     }
12556
12557   result.virtual_offset = offset;
12558   result.size = size;
12559   return result;
12560 }
12561
12562 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12563    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12564    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12565    This is for DWP version 2 files.  */
12566
12567 static struct dwo_unit *
12568 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12569                            struct dwp_file *dwp_file,
12570                            uint32_t unit_index,
12571                            const char *comp_dir,
12572                            ULONGEST signature, int is_debug_types)
12573 {
12574   struct objfile *objfile = dwarf2_per_objfile->objfile;
12575   const struct dwp_hash_table *dwp_htab =
12576     is_debug_types ? dwp_file->tus : dwp_file->cus;
12577   bfd *dbfd = dwp_file->dbfd.get ();
12578   const char *kind = is_debug_types ? "TU" : "CU";
12579   struct dwo_file *dwo_file;
12580   struct dwo_unit *dwo_unit;
12581   struct virtual_v2_dwo_sections sections;
12582   void **dwo_file_slot;
12583   int i;
12584
12585   gdb_assert (dwp_file->version == 2);
12586
12587   if (dwarf_read_debug)
12588     {
12589       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12590                           kind,
12591                           pulongest (unit_index), hex_string (signature),
12592                           dwp_file->name);
12593     }
12594
12595   /* Fetch the section offsets of this DWO unit.  */
12596
12597   memset (&sections, 0, sizeof (sections));
12598
12599   for (i = 0; i < dwp_htab->nr_columns; ++i)
12600     {
12601       uint32_t offset = read_4_bytes (dbfd,
12602                                       dwp_htab->section_pool.v2.offsets
12603                                       + (((unit_index - 1) * dwp_htab->nr_columns
12604                                           + i)
12605                                          * sizeof (uint32_t)));
12606       uint32_t size = read_4_bytes (dbfd,
12607                                     dwp_htab->section_pool.v2.sizes
12608                                     + (((unit_index - 1) * dwp_htab->nr_columns
12609                                         + i)
12610                                        * sizeof (uint32_t)));
12611
12612       switch (dwp_htab->section_pool.v2.section_ids[i])
12613         {
12614         case DW_SECT_INFO:
12615         case DW_SECT_TYPES:
12616           sections.info_or_types_offset = offset;
12617           sections.info_or_types_size = size;
12618           break;
12619         case DW_SECT_ABBREV:
12620           sections.abbrev_offset = offset;
12621           sections.abbrev_size = size;
12622           break;
12623         case DW_SECT_LINE:
12624           sections.line_offset = offset;
12625           sections.line_size = size;
12626           break;
12627         case DW_SECT_LOC:
12628           sections.loc_offset = offset;
12629           sections.loc_size = size;
12630           break;
12631         case DW_SECT_STR_OFFSETS:
12632           sections.str_offsets_offset = offset;
12633           sections.str_offsets_size = size;
12634           break;
12635         case DW_SECT_MACINFO:
12636           sections.macinfo_offset = offset;
12637           sections.macinfo_size = size;
12638           break;
12639         case DW_SECT_MACRO:
12640           sections.macro_offset = offset;
12641           sections.macro_size = size;
12642           break;
12643         }
12644     }
12645
12646   /* It's easier for the rest of the code if we fake a struct dwo_file and
12647      have dwo_unit "live" in that.  At least for now.
12648
12649      The DWP file can be made up of a random collection of CUs and TUs.
12650      However, for each CU + set of TUs that came from the same original DWO
12651      file, we can combine them back into a virtual DWO file to save space
12652      (fewer struct dwo_file objects to allocate).  Remember that for really
12653      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12654
12655   std::string virtual_dwo_name =
12656     string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12657                    (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12658                    (long) (sections.line_size ? sections.line_offset : 0),
12659                    (long) (sections.loc_size ? sections.loc_offset : 0),
12660                    (long) (sections.str_offsets_size
12661                            ? sections.str_offsets_offset : 0));
12662   /* Can we use an existing virtual DWO file?  */
12663   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12664                                         virtual_dwo_name.c_str (),
12665                                         comp_dir);
12666   /* Create one if necessary.  */
12667   if (*dwo_file_slot == NULL)
12668     {
12669       if (dwarf_read_debug)
12670         {
12671           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12672                               virtual_dwo_name.c_str ());
12673         }
12674       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12675       dwo_file->dwo_name
12676         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12677                                         virtual_dwo_name.c_str (),
12678                                         virtual_dwo_name.size ());
12679       dwo_file->comp_dir = comp_dir;
12680       dwo_file->sections.abbrev =
12681         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12682                                sections.abbrev_offset, sections.abbrev_size);
12683       dwo_file->sections.line =
12684         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12685                                sections.line_offset, sections.line_size);
12686       dwo_file->sections.loc =
12687         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12688                                sections.loc_offset, sections.loc_size);
12689       dwo_file->sections.macinfo =
12690         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12691                                sections.macinfo_offset, sections.macinfo_size);
12692       dwo_file->sections.macro =
12693         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12694                                sections.macro_offset, sections.macro_size);
12695       dwo_file->sections.str_offsets =
12696         create_dwp_v2_section (dwarf2_per_objfile,
12697                                &dwp_file->sections.str_offsets,
12698                                sections.str_offsets_offset,
12699                                sections.str_offsets_size);
12700       /* The "str" section is global to the entire DWP file.  */
12701       dwo_file->sections.str = dwp_file->sections.str;
12702       /* The info or types section is assigned below to dwo_unit,
12703          there's no need to record it in dwo_file.
12704          Also, we can't simply record type sections in dwo_file because
12705          we record a pointer into the vector in dwo_unit.  As we collect more
12706          types we'll grow the vector and eventually have to reallocate space
12707          for it, invalidating all copies of pointers into the previous
12708          contents.  */
12709       *dwo_file_slot = dwo_file;
12710     }
12711   else
12712     {
12713       if (dwarf_read_debug)
12714         {
12715           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12716                               virtual_dwo_name.c_str ());
12717         }
12718       dwo_file = (struct dwo_file *) *dwo_file_slot;
12719     }
12720
12721   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12722   dwo_unit->dwo_file = dwo_file;
12723   dwo_unit->signature = signature;
12724   dwo_unit->section =
12725     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12726   *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12727                                               is_debug_types
12728                                               ? &dwp_file->sections.types
12729                                               : &dwp_file->sections.info,
12730                                               sections.info_or_types_offset,
12731                                               sections.info_or_types_size);
12732   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12733
12734   return dwo_unit;
12735 }
12736
12737 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12738    Returns NULL if the signature isn't found.  */
12739
12740 static struct dwo_unit *
12741 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12742                         struct dwp_file *dwp_file, const char *comp_dir,
12743                         ULONGEST signature, int is_debug_types)
12744 {
12745   const struct dwp_hash_table *dwp_htab =
12746     is_debug_types ? dwp_file->tus : dwp_file->cus;
12747   bfd *dbfd = dwp_file->dbfd.get ();
12748   uint32_t mask = dwp_htab->nr_slots - 1;
12749   uint32_t hash = signature & mask;
12750   uint32_t hash2 = ((signature >> 32) & mask) | 1;
12751   unsigned int i;
12752   void **slot;
12753   struct dwo_unit find_dwo_cu;
12754
12755   memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12756   find_dwo_cu.signature = signature;
12757   slot = htab_find_slot (is_debug_types
12758                          ? dwp_file->loaded_tus
12759                          : dwp_file->loaded_cus,
12760                          &find_dwo_cu, INSERT);
12761
12762   if (*slot != NULL)
12763     return (struct dwo_unit *) *slot;
12764
12765   /* Use a for loop so that we don't loop forever on bad debug info.  */
12766   for (i = 0; i < dwp_htab->nr_slots; ++i)
12767     {
12768       ULONGEST signature_in_table;
12769
12770       signature_in_table =
12771         read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12772       if (signature_in_table == signature)
12773         {
12774           uint32_t unit_index =
12775             read_4_bytes (dbfd,
12776                           dwp_htab->unit_table + hash * sizeof (uint32_t));
12777
12778           if (dwp_file->version == 1)
12779             {
12780               *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12781                                                  dwp_file, unit_index,
12782                                                  comp_dir, signature,
12783                                                  is_debug_types);
12784             }
12785           else
12786             {
12787               *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12788                                                  dwp_file, unit_index,
12789                                                  comp_dir, signature,
12790                                                  is_debug_types);
12791             }
12792           return (struct dwo_unit *) *slot;
12793         }
12794       if (signature_in_table == 0)
12795         return NULL;
12796       hash = (hash + hash2) & mask;
12797     }
12798
12799   error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12800            " [in module %s]"),
12801          dwp_file->name);
12802 }
12803
12804 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12805    Open the file specified by FILE_NAME and hand it off to BFD for
12806    preliminary analysis.  Return a newly initialized bfd *, which
12807    includes a canonicalized copy of FILE_NAME.
12808    If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12809    SEARCH_CWD is true if the current directory is to be searched.
12810    It will be searched before debug-file-directory.
12811    If successful, the file is added to the bfd include table of the
12812    objfile's bfd (see gdb_bfd_record_inclusion).
12813    If unable to find/open the file, return NULL.
12814    NOTE: This function is derived from symfile_bfd_open.  */
12815
12816 static gdb_bfd_ref_ptr
12817 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12818                     const char *file_name, int is_dwp, int search_cwd)
12819 {
12820   int desc;
12821   /* Blech.  OPF_TRY_CWD_FIRST also disables searching the path list if
12822      FILE_NAME contains a '/'.  So we can't use it.  Instead prepend "."
12823      to debug_file_directory.  */
12824   const char *search_path;
12825   static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12826
12827   gdb::unique_xmalloc_ptr<char> search_path_holder;
12828   if (search_cwd)
12829     {
12830       if (*debug_file_directory != '\0')
12831         {
12832           search_path_holder.reset (concat (".", dirname_separator_string,
12833                                             debug_file_directory,
12834                                             (char *) NULL));
12835           search_path = search_path_holder.get ();
12836         }
12837       else
12838         search_path = ".";
12839     }
12840   else
12841     search_path = debug_file_directory;
12842
12843   openp_flags flags = OPF_RETURN_REALPATH;
12844   if (is_dwp)
12845     flags |= OPF_SEARCH_IN_PATH;
12846
12847   gdb::unique_xmalloc_ptr<char> absolute_name;
12848   desc = openp (search_path, flags, file_name,
12849                 O_RDONLY | O_BINARY, &absolute_name);
12850   if (desc < 0)
12851     return NULL;
12852
12853   gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12854                                          gnutarget, desc));
12855   if (sym_bfd == NULL)
12856     return NULL;
12857   bfd_set_cacheable (sym_bfd.get (), 1);
12858
12859   if (!bfd_check_format (sym_bfd.get (), bfd_object))
12860     return NULL;
12861
12862   /* Success.  Record the bfd as having been included by the objfile's bfd.
12863      This is important because things like demangled_names_hash lives in the
12864      objfile's per_bfd space and may have references to things like symbol
12865      names that live in the DWO/DWP file's per_bfd space.  PR 16426.  */
12866   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12867
12868   return sym_bfd;
12869 }
12870
12871 /* Try to open DWO file FILE_NAME.
12872    COMP_DIR is the DW_AT_comp_dir attribute.
12873    The result is the bfd handle of the file.
12874    If there is a problem finding or opening the file, return NULL.
12875    Upon success, the canonicalized path of the file is stored in the bfd,
12876    same as symfile_bfd_open.  */
12877
12878 static gdb_bfd_ref_ptr
12879 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12880                const char *file_name, const char *comp_dir)
12881 {
12882   if (IS_ABSOLUTE_PATH (file_name))
12883     return try_open_dwop_file (dwarf2_per_objfile, file_name,
12884                                0 /*is_dwp*/, 0 /*search_cwd*/);
12885
12886   /* Before trying the search path, try DWO_NAME in COMP_DIR.  */
12887
12888   if (comp_dir != NULL)
12889     {
12890       char *path_to_try = concat (comp_dir, SLASH_STRING,
12891                                   file_name, (char *) NULL);
12892
12893       /* NOTE: If comp_dir is a relative path, this will also try the
12894          search path, which seems useful.  */
12895       gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12896                                                 path_to_try,
12897                                                 0 /*is_dwp*/,
12898                                                 1 /*search_cwd*/));
12899       xfree (path_to_try);
12900       if (abfd != NULL)
12901         return abfd;
12902     }
12903
12904   /* That didn't work, try debug-file-directory, which, despite its name,
12905      is a list of paths.  */
12906
12907   if (*debug_file_directory == '\0')
12908     return NULL;
12909
12910   return try_open_dwop_file (dwarf2_per_objfile, file_name,
12911                              0 /*is_dwp*/, 1 /*search_cwd*/);
12912 }
12913
12914 /* This function is mapped across the sections and remembers the offset and
12915    size of each of the DWO debugging sections we are interested in.  */
12916
12917 static void
12918 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12919 {
12920   struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12921   const struct dwop_section_names *names = &dwop_section_names;
12922
12923   if (section_is_p (sectp->name, &names->abbrev_dwo))
12924     {
12925       dwo_sections->abbrev.s.section = sectp;
12926       dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12927     }
12928   else if (section_is_p (sectp->name, &names->info_dwo))
12929     {
12930       dwo_sections->info.s.section = sectp;
12931       dwo_sections->info.size = bfd_get_section_size (sectp);
12932     }
12933   else if (section_is_p (sectp->name, &names->line_dwo))
12934     {
12935       dwo_sections->line.s.section = sectp;
12936       dwo_sections->line.size = bfd_get_section_size (sectp);
12937     }
12938   else if (section_is_p (sectp->name, &names->loc_dwo))
12939     {
12940       dwo_sections->loc.s.section = sectp;
12941       dwo_sections->loc.size = bfd_get_section_size (sectp);
12942     }
12943   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12944     {
12945       dwo_sections->macinfo.s.section = sectp;
12946       dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12947     }
12948   else if (section_is_p (sectp->name, &names->macro_dwo))
12949     {
12950       dwo_sections->macro.s.section = sectp;
12951       dwo_sections->macro.size = bfd_get_section_size (sectp);
12952     }
12953   else if (section_is_p (sectp->name, &names->str_dwo))
12954     {
12955       dwo_sections->str.s.section = sectp;
12956       dwo_sections->str.size = bfd_get_section_size (sectp);
12957     }
12958   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12959     {
12960       dwo_sections->str_offsets.s.section = sectp;
12961       dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12962     }
12963   else if (section_is_p (sectp->name, &names->types_dwo))
12964     {
12965       struct dwarf2_section_info type_section;
12966
12967       memset (&type_section, 0, sizeof (type_section));
12968       type_section.s.section = sectp;
12969       type_section.size = bfd_get_section_size (sectp);
12970       VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12971                      &type_section);
12972     }
12973 }
12974
12975 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12976    by PER_CU.  This is for the non-DWP case.
12977    The result is NULL if DWO_NAME can't be found.  */
12978
12979 static struct dwo_file *
12980 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12981                         const char *dwo_name, const char *comp_dir)
12982 {
12983   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12984   struct objfile *objfile = dwarf2_per_objfile->objfile;
12985
12986   gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12987   if (dbfd == NULL)
12988     {
12989       if (dwarf_read_debug)
12990         fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12991       return NULL;
12992     }
12993
12994   /* We use a unique pointer here, despite the obstack allocation,
12995      because a dwo_file needs some cleanup if it is abandoned.  */
12996   dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12997                                         struct dwo_file));
12998   dwo_file->dwo_name = dwo_name;
12999   dwo_file->comp_dir = comp_dir;
13000   dwo_file->dbfd = dbfd.release ();
13001
13002   bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
13003                          &dwo_file->sections);
13004
13005   create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13006                          dwo_file->cus);
13007
13008   create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
13009                                  dwo_file->sections.types, dwo_file->tus);
13010
13011   if (dwarf_read_debug)
13012     fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13013
13014   return dwo_file.release ();
13015 }
13016
13017 /* This function is mapped across the sections and remembers the offset and
13018    size of each of the DWP debugging sections common to version 1 and 2 that
13019    we are interested in.  */
13020
13021 static void
13022 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13023                                    void *dwp_file_ptr)
13024 {
13025   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13026   const struct dwop_section_names *names = &dwop_section_names;
13027   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13028
13029   /* Record the ELF section number for later lookup: this is what the
13030      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13031   gdb_assert (elf_section_nr < dwp_file->num_sections);
13032   dwp_file->elf_sections[elf_section_nr] = sectp;
13033
13034   /* Look for specific sections that we need.  */
13035   if (section_is_p (sectp->name, &names->str_dwo))
13036     {
13037       dwp_file->sections.str.s.section = sectp;
13038       dwp_file->sections.str.size = bfd_get_section_size (sectp);
13039     }
13040   else if (section_is_p (sectp->name, &names->cu_index))
13041     {
13042       dwp_file->sections.cu_index.s.section = sectp;
13043       dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13044     }
13045   else if (section_is_p (sectp->name, &names->tu_index))
13046     {
13047       dwp_file->sections.tu_index.s.section = sectp;
13048       dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13049     }
13050 }
13051
13052 /* This function is mapped across the sections and remembers the offset and
13053    size of each of the DWP version 2 debugging sections that we are interested
13054    in.  This is split into a separate function because we don't know if we
13055    have version 1 or 2 until we parse the cu_index/tu_index sections.  */
13056
13057 static void
13058 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13059 {
13060   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13061   const struct dwop_section_names *names = &dwop_section_names;
13062   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13063
13064   /* Record the ELF section number for later lookup: this is what the
13065      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13066   gdb_assert (elf_section_nr < dwp_file->num_sections);
13067   dwp_file->elf_sections[elf_section_nr] = sectp;
13068
13069   /* Look for specific sections that we need.  */
13070   if (section_is_p (sectp->name, &names->abbrev_dwo))
13071     {
13072       dwp_file->sections.abbrev.s.section = sectp;
13073       dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13074     }
13075   else if (section_is_p (sectp->name, &names->info_dwo))
13076     {
13077       dwp_file->sections.info.s.section = sectp;
13078       dwp_file->sections.info.size = bfd_get_section_size (sectp);
13079     }
13080   else if (section_is_p (sectp->name, &names->line_dwo))
13081     {
13082       dwp_file->sections.line.s.section = sectp;
13083       dwp_file->sections.line.size = bfd_get_section_size (sectp);
13084     }
13085   else if (section_is_p (sectp->name, &names->loc_dwo))
13086     {
13087       dwp_file->sections.loc.s.section = sectp;
13088       dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13089     }
13090   else if (section_is_p (sectp->name, &names->macinfo_dwo))
13091     {
13092       dwp_file->sections.macinfo.s.section = sectp;
13093       dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13094     }
13095   else if (section_is_p (sectp->name, &names->macro_dwo))
13096     {
13097       dwp_file->sections.macro.s.section = sectp;
13098       dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13099     }
13100   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13101     {
13102       dwp_file->sections.str_offsets.s.section = sectp;
13103       dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13104     }
13105   else if (section_is_p (sectp->name, &names->types_dwo))
13106     {
13107       dwp_file->sections.types.s.section = sectp;
13108       dwp_file->sections.types.size = bfd_get_section_size (sectp);
13109     }
13110 }
13111
13112 /* Hash function for dwp_file loaded CUs/TUs.  */
13113
13114 static hashval_t
13115 hash_dwp_loaded_cutus (const void *item)
13116 {
13117   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13118
13119   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
13120   return dwo_unit->signature;
13121 }
13122
13123 /* Equality function for dwp_file loaded CUs/TUs.  */
13124
13125 static int
13126 eq_dwp_loaded_cutus (const void *a, const void *b)
13127 {
13128   const struct dwo_unit *dua = (const struct dwo_unit *) a;
13129   const struct dwo_unit *dub = (const struct dwo_unit *) b;
13130
13131   return dua->signature == dub->signature;
13132 }
13133
13134 /* Allocate a hash table for dwp_file loaded CUs/TUs.  */
13135
13136 static htab_t
13137 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13138 {
13139   return htab_create_alloc_ex (3,
13140                                hash_dwp_loaded_cutus,
13141                                eq_dwp_loaded_cutus,
13142                                NULL,
13143                                &objfile->objfile_obstack,
13144                                hashtab_obstack_allocate,
13145                                dummy_obstack_deallocate);
13146 }
13147
13148 /* Try to open DWP file FILE_NAME.
13149    The result is the bfd handle of the file.
13150    If there is a problem finding or opening the file, return NULL.
13151    Upon success, the canonicalized path of the file is stored in the bfd,
13152    same as symfile_bfd_open.  */
13153
13154 static gdb_bfd_ref_ptr
13155 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13156                const char *file_name)
13157 {
13158   gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13159                                             1 /*is_dwp*/,
13160                                             1 /*search_cwd*/));
13161   if (abfd != NULL)
13162     return abfd;
13163
13164   /* Work around upstream bug 15652.
13165      http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13166      [Whether that's a "bug" is debatable, but it is getting in our way.]
13167      We have no real idea where the dwp file is, because gdb's realpath-ing
13168      of the executable's path may have discarded the needed info.
13169      [IWBN if the dwp file name was recorded in the executable, akin to
13170      .gnu_debuglink, but that doesn't exist yet.]
13171      Strip the directory from FILE_NAME and search again.  */
13172   if (*debug_file_directory != '\0')
13173     {
13174       /* Don't implicitly search the current directory here.
13175          If the user wants to search "." to handle this case,
13176          it must be added to debug-file-directory.  */
13177       return try_open_dwop_file (dwarf2_per_objfile,
13178                                  lbasename (file_name), 1 /*is_dwp*/,
13179                                  0 /*search_cwd*/);
13180     }
13181
13182   return NULL;
13183 }
13184
13185 /* Initialize the use of the DWP file for the current objfile.
13186    By convention the name of the DWP file is ${objfile}.dwp.
13187    The result is NULL if it can't be found.  */
13188
13189 static std::unique_ptr<struct dwp_file>
13190 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13191 {
13192   struct objfile *objfile = dwarf2_per_objfile->objfile;
13193
13194   /* Try to find first .dwp for the binary file before any symbolic links
13195      resolving.  */
13196
13197   /* If the objfile is a debug file, find the name of the real binary
13198      file and get the name of dwp file from there.  */
13199   std::string dwp_name;
13200   if (objfile->separate_debug_objfile_backlink != NULL)
13201     {
13202       struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13203       const char *backlink_basename = lbasename (backlink->original_name);
13204
13205       dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13206     }
13207   else
13208     dwp_name = objfile->original_name;
13209
13210   dwp_name += ".dwp";
13211
13212   gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13213   if (dbfd == NULL
13214       && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13215     {
13216       /* Try to find .dwp for the binary file after gdb_realpath resolving.  */
13217       dwp_name = objfile_name (objfile);
13218       dwp_name += ".dwp";
13219       dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13220     }
13221
13222   if (dbfd == NULL)
13223     {
13224       if (dwarf_read_debug)
13225         fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13226       return std::unique_ptr<dwp_file> ();
13227     }
13228
13229   const char *name = bfd_get_filename (dbfd.get ());
13230   std::unique_ptr<struct dwp_file> dwp_file
13231     (new struct dwp_file (name, std::move (dbfd)));
13232
13233   dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
13234   dwp_file->elf_sections =
13235     OBSTACK_CALLOC (&objfile->objfile_obstack,
13236                     dwp_file->num_sections, asection *);
13237
13238   bfd_map_over_sections (dwp_file->dbfd.get (),
13239                          dwarf2_locate_common_dwp_sections,
13240                          dwp_file.get ());
13241
13242   dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13243                                          0);
13244
13245   dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13246                                          1);
13247
13248   /* The DWP file version is stored in the hash table.  Oh well.  */
13249   if (dwp_file->cus && dwp_file->tus
13250       && dwp_file->cus->version != dwp_file->tus->version)
13251     {
13252       /* Technically speaking, we should try to limp along, but this is
13253          pretty bizarre.  We use pulongest here because that's the established
13254          portability solution (e.g, we cannot use %u for uint32_t).  */
13255       error (_("Dwarf Error: DWP file CU version %s doesn't match"
13256                " TU version %s [in DWP file %s]"),
13257              pulongest (dwp_file->cus->version),
13258              pulongest (dwp_file->tus->version), dwp_name.c_str ());
13259     }
13260
13261   if (dwp_file->cus)
13262     dwp_file->version = dwp_file->cus->version;
13263   else if (dwp_file->tus)
13264     dwp_file->version = dwp_file->tus->version;
13265   else
13266     dwp_file->version = 2;
13267
13268   if (dwp_file->version == 2)
13269     bfd_map_over_sections (dwp_file->dbfd.get (),
13270                            dwarf2_locate_v2_dwp_sections,
13271                            dwp_file.get ());
13272
13273   dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13274   dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13275
13276   if (dwarf_read_debug)
13277     {
13278       fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13279       fprintf_unfiltered (gdb_stdlog,
13280                           "    %s CUs, %s TUs\n",
13281                           pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13282                           pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13283     }
13284
13285   return dwp_file;
13286 }
13287
13288 /* Wrapper around open_and_init_dwp_file, only open it once.  */
13289
13290 static struct dwp_file *
13291 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13292 {
13293   if (! dwarf2_per_objfile->dwp_checked)
13294     {
13295       dwarf2_per_objfile->dwp_file
13296         = open_and_init_dwp_file (dwarf2_per_objfile);
13297       dwarf2_per_objfile->dwp_checked = 1;
13298     }
13299   return dwarf2_per_objfile->dwp_file.get ();
13300 }
13301
13302 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13303    Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13304    or in the DWP file for the objfile, referenced by THIS_UNIT.
13305    If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13306    IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13307
13308    This is called, for example, when wanting to read a variable with a
13309    complex location.  Therefore we don't want to do file i/o for every call.
13310    Therefore we don't want to look for a DWO file on every call.
13311    Therefore we first see if we've already seen SIGNATURE in a DWP file,
13312    then we check if we've already seen DWO_NAME, and only THEN do we check
13313    for a DWO file.
13314
13315    The result is a pointer to the dwo_unit object or NULL if we didn't find it
13316    (dwo_id mismatch or couldn't find the DWO/DWP file).  */
13317
13318 static struct dwo_unit *
13319 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13320                  const char *dwo_name, const char *comp_dir,
13321                  ULONGEST signature, int is_debug_types)
13322 {
13323   struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13324   struct objfile *objfile = dwarf2_per_objfile->objfile;
13325   const char *kind = is_debug_types ? "TU" : "CU";
13326   void **dwo_file_slot;
13327   struct dwo_file *dwo_file;
13328   struct dwp_file *dwp_file;
13329
13330   /* First see if there's a DWP file.
13331      If we have a DWP file but didn't find the DWO inside it, don't
13332      look for the original DWO file.  It makes gdb behave differently
13333      depending on whether one is debugging in the build tree.  */
13334
13335   dwp_file = get_dwp_file (dwarf2_per_objfile);
13336   if (dwp_file != NULL)
13337     {
13338       const struct dwp_hash_table *dwp_htab =
13339         is_debug_types ? dwp_file->tus : dwp_file->cus;
13340
13341       if (dwp_htab != NULL)
13342         {
13343           struct dwo_unit *dwo_cutu =
13344             lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13345                                     signature, is_debug_types);
13346
13347           if (dwo_cutu != NULL)
13348             {
13349               if (dwarf_read_debug)
13350                 {
13351                   fprintf_unfiltered (gdb_stdlog,
13352                                       "Virtual DWO %s %s found: @%s\n",
13353                                       kind, hex_string (signature),
13354                                       host_address_to_string (dwo_cutu));
13355                 }
13356               return dwo_cutu;
13357             }
13358         }
13359     }
13360   else
13361     {
13362       /* No DWP file, look for the DWO file.  */
13363
13364       dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13365                                             dwo_name, comp_dir);
13366       if (*dwo_file_slot == NULL)
13367         {
13368           /* Read in the file and build a table of the CUs/TUs it contains.  */
13369           *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13370         }
13371       /* NOTE: This will be NULL if unable to open the file.  */
13372       dwo_file = (struct dwo_file *) *dwo_file_slot;
13373
13374       if (dwo_file != NULL)
13375         {
13376           struct dwo_unit *dwo_cutu = NULL;
13377
13378           if (is_debug_types && dwo_file->tus)
13379             {
13380               struct dwo_unit find_dwo_cutu;
13381
13382               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13383               find_dwo_cutu.signature = signature;
13384               dwo_cutu
13385                 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13386             }
13387           else if (!is_debug_types && dwo_file->cus)
13388             {
13389               struct dwo_unit find_dwo_cutu;
13390
13391               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13392               find_dwo_cutu.signature = signature;
13393               dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13394                                                        &find_dwo_cutu);
13395             }
13396
13397           if (dwo_cutu != NULL)
13398             {
13399               if (dwarf_read_debug)
13400                 {
13401                   fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13402                                       kind, dwo_name, hex_string (signature),
13403                                       host_address_to_string (dwo_cutu));
13404                 }
13405               return dwo_cutu;
13406             }
13407         }
13408     }
13409
13410   /* We didn't find it.  This could mean a dwo_id mismatch, or
13411      someone deleted the DWO/DWP file, or the search path isn't set up
13412      correctly to find the file.  */
13413
13414   if (dwarf_read_debug)
13415     {
13416       fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13417                           kind, dwo_name, hex_string (signature));
13418     }
13419
13420   /* This is a warning and not a complaint because it can be caused by
13421      pilot error (e.g., user accidentally deleting the DWO).  */
13422   {
13423     /* Print the name of the DWP file if we looked there, helps the user
13424        better diagnose the problem.  */
13425     std::string dwp_text;
13426
13427     if (dwp_file != NULL)
13428       dwp_text = string_printf (" [in DWP file %s]",
13429                                 lbasename (dwp_file->name));
13430
13431     warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13432                " [in module %s]"),
13433              kind, dwo_name, hex_string (signature),
13434              dwp_text.c_str (),
13435              this_unit->is_debug_types ? "TU" : "CU",
13436              sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13437   }
13438   return NULL;
13439 }
13440
13441 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13442    See lookup_dwo_cutu_unit for details.  */
13443
13444 static struct dwo_unit *
13445 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13446                       const char *dwo_name, const char *comp_dir,
13447                       ULONGEST signature)
13448 {
13449   return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13450 }
13451
13452 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13453    See lookup_dwo_cutu_unit for details.  */
13454
13455 static struct dwo_unit *
13456 lookup_dwo_type_unit (struct signatured_type *this_tu,
13457                       const char *dwo_name, const char *comp_dir)
13458 {
13459   return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13460 }
13461
13462 /* Traversal function for queue_and_load_all_dwo_tus.  */
13463
13464 static int
13465 queue_and_load_dwo_tu (void **slot, void *info)
13466 {
13467   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13468   struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13469   ULONGEST signature = dwo_unit->signature;
13470   struct signatured_type *sig_type =
13471     lookup_dwo_signatured_type (per_cu->cu, signature);
13472
13473   if (sig_type != NULL)
13474     {
13475       struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13476
13477       /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13478          a real dependency of PER_CU on SIG_TYPE.  That is detected later
13479          while processing PER_CU.  */
13480       if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13481         load_full_type_unit (sig_cu);
13482       VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13483     }
13484
13485   return 1;
13486 }
13487
13488 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13489    The DWO may have the only definition of the type, though it may not be
13490    referenced anywhere in PER_CU.  Thus we have to load *all* its TUs.
13491    http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
13492
13493 static void
13494 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13495 {
13496   struct dwo_unit *dwo_unit;
13497   struct dwo_file *dwo_file;
13498
13499   gdb_assert (!per_cu->is_debug_types);
13500   gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13501   gdb_assert (per_cu->cu != NULL);
13502
13503   dwo_unit = per_cu->cu->dwo_unit;
13504   gdb_assert (dwo_unit != NULL);
13505
13506   dwo_file = dwo_unit->dwo_file;
13507   if (dwo_file->tus != NULL)
13508     htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13509 }
13510
13511 /* Free all resources associated with DWO_FILE.
13512    Close the DWO file and munmap the sections.  */
13513
13514 static void
13515 free_dwo_file (struct dwo_file *dwo_file)
13516 {
13517   /* Note: dbfd is NULL for virtual DWO files.  */
13518   gdb_bfd_unref (dwo_file->dbfd);
13519
13520   VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13521 }
13522
13523 /* Traversal function for free_dwo_files.  */
13524
13525 static int
13526 free_dwo_file_from_slot (void **slot, void *info)
13527 {
13528   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13529
13530   free_dwo_file (dwo_file);
13531
13532   return 1;
13533 }
13534
13535 /* Free all resources associated with DWO_FILES.  */
13536
13537 static void
13538 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13539 {
13540   htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13541 }
13542 \f
13543 /* Read in various DIEs.  */
13544
13545 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13546    Inherit only the children of the DW_AT_abstract_origin DIE not being
13547    already referenced by DW_AT_abstract_origin from the children of the
13548    current DIE.  */
13549
13550 static void
13551 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13552 {
13553   struct die_info *child_die;
13554   sect_offset *offsetp;
13555   /* Parent of DIE - referenced by DW_AT_abstract_origin.  */
13556   struct die_info *origin_die;
13557   /* Iterator of the ORIGIN_DIE children.  */
13558   struct die_info *origin_child_die;
13559   struct attribute *attr;
13560   struct dwarf2_cu *origin_cu;
13561   struct pending **origin_previous_list_in_scope;
13562
13563   attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13564   if (!attr)
13565     return;
13566
13567   /* Note that following die references may follow to a die in a
13568      different cu.  */
13569
13570   origin_cu = cu;
13571   origin_die = follow_die_ref (die, attr, &origin_cu);
13572
13573   /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13574      symbols in.  */
13575   origin_previous_list_in_scope = origin_cu->list_in_scope;
13576   origin_cu->list_in_scope = cu->list_in_scope;
13577
13578   if (die->tag != origin_die->tag
13579       && !(die->tag == DW_TAG_inlined_subroutine
13580            && origin_die->tag == DW_TAG_subprogram))
13581     complaint (_("DIE %s and its abstract origin %s have different tags"),
13582                sect_offset_str (die->sect_off),
13583                sect_offset_str (origin_die->sect_off));
13584
13585   std::vector<sect_offset> offsets;
13586
13587   for (child_die = die->child;
13588        child_die && child_die->tag;
13589        child_die = sibling_die (child_die))
13590     {
13591       struct die_info *child_origin_die;
13592       struct dwarf2_cu *child_origin_cu;
13593
13594       /* We are trying to process concrete instance entries:
13595          DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13596          it's not relevant to our analysis here. i.e. detecting DIEs that are
13597          present in the abstract instance but not referenced in the concrete
13598          one.  */
13599       if (child_die->tag == DW_TAG_call_site
13600           || child_die->tag == DW_TAG_GNU_call_site)
13601         continue;
13602
13603       /* For each CHILD_DIE, find the corresponding child of
13604          ORIGIN_DIE.  If there is more than one layer of
13605          DW_AT_abstract_origin, follow them all; there shouldn't be,
13606          but GCC versions at least through 4.4 generate this (GCC PR
13607          40573).  */
13608       child_origin_die = child_die;
13609       child_origin_cu = cu;
13610       while (1)
13611         {
13612           attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13613                               child_origin_cu);
13614           if (attr == NULL)
13615             break;
13616           child_origin_die = follow_die_ref (child_origin_die, attr,
13617                                              &child_origin_cu);
13618         }
13619
13620       /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13621          counterpart may exist.  */
13622       if (child_origin_die != child_die)
13623         {
13624           if (child_die->tag != child_origin_die->tag
13625               && !(child_die->tag == DW_TAG_inlined_subroutine
13626                    && child_origin_die->tag == DW_TAG_subprogram))
13627             complaint (_("Child DIE %s and its abstract origin %s have "
13628                          "different tags"),
13629                        sect_offset_str (child_die->sect_off),
13630                        sect_offset_str (child_origin_die->sect_off));
13631           if (child_origin_die->parent != origin_die)
13632             complaint (_("Child DIE %s and its abstract origin %s have "
13633                          "different parents"),
13634                        sect_offset_str (child_die->sect_off),
13635                        sect_offset_str (child_origin_die->sect_off));
13636           else
13637             offsets.push_back (child_origin_die->sect_off);
13638         }
13639     }
13640   std::sort (offsets.begin (), offsets.end ());
13641   sect_offset *offsets_end = offsets.data () + offsets.size ();
13642   for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13643     if (offsetp[-1] == *offsetp)
13644       complaint (_("Multiple children of DIE %s refer "
13645                    "to DIE %s as their abstract origin"),
13646                  sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13647
13648   offsetp = offsets.data ();
13649   origin_child_die = origin_die->child;
13650   while (origin_child_die && origin_child_die->tag)
13651     {
13652       /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children?  */
13653       while (offsetp < offsets_end
13654              && *offsetp < origin_child_die->sect_off)
13655         offsetp++;
13656       if (offsetp >= offsets_end
13657           || *offsetp > origin_child_die->sect_off)
13658         {
13659           /* Found that ORIGIN_CHILD_DIE is really not referenced.
13660              Check whether we're already processing ORIGIN_CHILD_DIE.
13661              This can happen with mutually referenced abstract_origins.
13662              PR 16581.  */
13663           if (!origin_child_die->in_process)
13664             process_die (origin_child_die, origin_cu);
13665         }
13666       origin_child_die = sibling_die (origin_child_die);
13667     }
13668   origin_cu->list_in_scope = origin_previous_list_in_scope;
13669 }
13670
13671 static void
13672 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13673 {
13674   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13675   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13676   struct context_stack *newobj;
13677   CORE_ADDR lowpc;
13678   CORE_ADDR highpc;
13679   struct die_info *child_die;
13680   struct attribute *attr, *call_line, *call_file;
13681   const char *name;
13682   CORE_ADDR baseaddr;
13683   struct block *block;
13684   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13685   std::vector<struct symbol *> template_args;
13686   struct template_symbol *templ_func = NULL;
13687
13688   if (inlined_func)
13689     {
13690       /* If we do not have call site information, we can't show the
13691          caller of this inlined function.  That's too confusing, so
13692          only use the scope for local variables.  */
13693       call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13694       call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13695       if (call_line == NULL || call_file == NULL)
13696         {
13697           read_lexical_block_scope (die, cu);
13698           return;
13699         }
13700     }
13701
13702   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13703
13704   name = dwarf2_name (die, cu);
13705
13706   /* Ignore functions with missing or empty names.  These are actually
13707      illegal according to the DWARF standard.  */
13708   if (name == NULL)
13709     {
13710       complaint (_("missing name for subprogram DIE at %s"),
13711                  sect_offset_str (die->sect_off));
13712       return;
13713     }
13714
13715   /* Ignore functions with missing or invalid low and high pc attributes.  */
13716   if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13717       <= PC_BOUNDS_INVALID)
13718     {
13719       attr = dwarf2_attr (die, DW_AT_external, cu);
13720       if (!attr || !DW_UNSND (attr))
13721         complaint (_("cannot get low and high bounds "
13722                      "for subprogram DIE at %s"),
13723                    sect_offset_str (die->sect_off));
13724       return;
13725     }
13726
13727   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13728   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13729
13730   /* If we have any template arguments, then we must allocate a
13731      different sort of symbol.  */
13732   for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13733     {
13734       if (child_die->tag == DW_TAG_template_type_param
13735           || child_die->tag == DW_TAG_template_value_param)
13736         {
13737           templ_func = allocate_template_symbol (objfile);
13738           templ_func->subclass = SYMBOL_TEMPLATE;
13739           break;
13740         }
13741     }
13742
13743   newobj = cu->get_builder ()->push_context (0, lowpc);
13744   newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13745                              (struct symbol *) templ_func);
13746
13747   /* If there is a location expression for DW_AT_frame_base, record
13748      it.  */
13749   attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13750   if (attr)
13751     dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13752
13753   /* If there is a location for the static link, record it.  */
13754   newobj->static_link = NULL;
13755   attr = dwarf2_attr (die, DW_AT_static_link, cu);
13756   if (attr)
13757     {
13758       newobj->static_link
13759         = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13760       attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13761     }
13762
13763   cu->list_in_scope = cu->get_builder ()->get_local_symbols ();
13764
13765   if (die->child != NULL)
13766     {
13767       child_die = die->child;
13768       while (child_die && child_die->tag)
13769         {
13770           if (child_die->tag == DW_TAG_template_type_param
13771               || child_die->tag == DW_TAG_template_value_param)
13772             {
13773               struct symbol *arg = new_symbol (child_die, NULL, cu);
13774
13775               if (arg != NULL)
13776                 template_args.push_back (arg);
13777             }
13778           else
13779             process_die (child_die, cu);
13780           child_die = sibling_die (child_die);
13781         }
13782     }
13783
13784   inherit_abstract_dies (die, cu);
13785
13786   /* If we have a DW_AT_specification, we might need to import using
13787      directives from the context of the specification DIE.  See the
13788      comment in determine_prefix.  */
13789   if (cu->language == language_cplus
13790       && dwarf2_attr (die, DW_AT_specification, cu))
13791     {
13792       struct dwarf2_cu *spec_cu = cu;
13793       struct die_info *spec_die = die_specification (die, &spec_cu);
13794
13795       while (spec_die)
13796         {
13797           child_die = spec_die->child;
13798           while (child_die && child_die->tag)
13799             {
13800               if (child_die->tag == DW_TAG_imported_module)
13801                 process_die (child_die, spec_cu);
13802               child_die = sibling_die (child_die);
13803             }
13804
13805           /* In some cases, GCC generates specification DIEs that
13806              themselves contain DW_AT_specification attributes.  */
13807           spec_die = die_specification (spec_die, &spec_cu);
13808         }
13809     }
13810
13811   struct context_stack cstk = cu->get_builder ()->pop_context ();
13812   /* Make a block for the local symbols within.  */
13813   block = cu->get_builder ()->finish_block (cstk.name, cstk.old_blocks,
13814                                      cstk.static_link, lowpc, highpc);
13815
13816   /* For C++, set the block's scope.  */
13817   if ((cu->language == language_cplus
13818        || cu->language == language_fortran
13819        || cu->language == language_d
13820        || cu->language == language_rust)
13821       && cu->processing_has_namespace_info)
13822     block_set_scope (block, determine_prefix (die, cu),
13823                      &objfile->objfile_obstack);
13824
13825   /* If we have address ranges, record them.  */
13826   dwarf2_record_block_ranges (die, block, baseaddr, cu);
13827
13828   gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13829
13830   /* Attach template arguments to function.  */
13831   if (!template_args.empty ())
13832     {
13833       gdb_assert (templ_func != NULL);
13834
13835       templ_func->n_template_arguments = template_args.size ();
13836       templ_func->template_arguments
13837         = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13838                      templ_func->n_template_arguments);
13839       memcpy (templ_func->template_arguments,
13840               template_args.data (),
13841               (templ_func->n_template_arguments * sizeof (struct symbol *)));
13842
13843       /* Make sure that the symtab is set on the new symbols.  Even
13844          though they don't appear in this symtab directly, other parts
13845          of gdb assume that symbols do, and this is reasonably
13846          true.  */
13847       for (symbol *sym : template_args)
13848         symbol_set_symtab (sym, symbol_symtab (templ_func));
13849     }
13850
13851   /* In C++, we can have functions nested inside functions (e.g., when
13852      a function declares a class that has methods).  This means that
13853      when we finish processing a function scope, we may need to go
13854      back to building a containing block's symbol lists.  */
13855   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13856   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13857
13858   /* If we've finished processing a top-level function, subsequent
13859      symbols go in the file symbol list.  */
13860   if (cu->get_builder ()->outermost_context_p ())
13861     cu->list_in_scope = cu->get_builder ()->get_file_symbols ();
13862 }
13863
13864 /* Process all the DIES contained within a lexical block scope.  Start
13865    a new scope, process the dies, and then close the scope.  */
13866
13867 static void
13868 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13869 {
13870   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13871   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13872   CORE_ADDR lowpc, highpc;
13873   struct die_info *child_die;
13874   CORE_ADDR baseaddr;
13875
13876   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13877
13878   /* Ignore blocks with missing or invalid low and high pc attributes.  */
13879   /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13880      as multiple lexical blocks?  Handling children in a sane way would
13881      be nasty.  Might be easier to properly extend generic blocks to
13882      describe ranges.  */
13883   switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13884     {
13885     case PC_BOUNDS_NOT_PRESENT:
13886       /* DW_TAG_lexical_block has no attributes, process its children as if
13887          there was no wrapping by that DW_TAG_lexical_block.
13888          GCC does no longer produces such DWARF since GCC r224161.  */
13889       for (child_die = die->child;
13890            child_die != NULL && child_die->tag;
13891            child_die = sibling_die (child_die))
13892         process_die (child_die, cu);
13893       return;
13894     case PC_BOUNDS_INVALID:
13895       return;
13896     }
13897   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13898   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13899
13900   cu->get_builder ()->push_context (0, lowpc);
13901   if (die->child != NULL)
13902     {
13903       child_die = die->child;
13904       while (child_die && child_die->tag)
13905         {
13906           process_die (child_die, cu);
13907           child_die = sibling_die (child_die);
13908         }
13909     }
13910   inherit_abstract_dies (die, cu);
13911   struct context_stack cstk = cu->get_builder ()->pop_context ();
13912
13913   if (*cu->get_builder ()->get_local_symbols () != NULL
13914       || (*cu->get_builder ()->get_local_using_directives ()) != NULL)
13915     {
13916       struct block *block
13917         = cu->get_builder ()->finish_block (0, cstk.old_blocks, NULL,
13918                                      cstk.start_addr, highpc);
13919
13920       /* Note that recording ranges after traversing children, as we
13921          do here, means that recording a parent's ranges entails
13922          walking across all its children's ranges as they appear in
13923          the address map, which is quadratic behavior.
13924
13925          It would be nicer to record the parent's ranges before
13926          traversing its children, simply overriding whatever you find
13927          there.  But since we don't even decide whether to create a
13928          block until after we've traversed its children, that's hard
13929          to do.  */
13930       dwarf2_record_block_ranges (die, block, baseaddr, cu);
13931     }
13932   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13933   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13934 }
13935
13936 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab.  */
13937
13938 static void
13939 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13940 {
13941   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13942   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13943   CORE_ADDR pc, baseaddr;
13944   struct attribute *attr;
13945   struct call_site *call_site, call_site_local;
13946   void **slot;
13947   int nparams;
13948   struct die_info *child_die;
13949
13950   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13951
13952   attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13953   if (attr == NULL)
13954     {
13955       /* This was a pre-DWARF-5 GNU extension alias
13956          for DW_AT_call_return_pc.  */
13957       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13958     }
13959   if (!attr)
13960     {
13961       complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13962                    "DIE %s [in module %s]"),
13963                  sect_offset_str (die->sect_off), objfile_name (objfile));
13964       return;
13965     }
13966   pc = attr_value_as_address (attr) + baseaddr;
13967   pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13968
13969   if (cu->call_site_htab == NULL)
13970     cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13971                                                NULL, &objfile->objfile_obstack,
13972                                                hashtab_obstack_allocate, NULL);
13973   call_site_local.pc = pc;
13974   slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13975   if (*slot != NULL)
13976     {
13977       complaint (_("Duplicate PC %s for DW_TAG_call_site "
13978                    "DIE %s [in module %s]"),
13979                  paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13980                  objfile_name (objfile));
13981       return;
13982     }
13983
13984   /* Count parameters at the caller.  */
13985
13986   nparams = 0;
13987   for (child_die = die->child; child_die && child_die->tag;
13988        child_die = sibling_die (child_die))
13989     {
13990       if (child_die->tag != DW_TAG_call_site_parameter
13991           && child_die->tag != DW_TAG_GNU_call_site_parameter)
13992         {
13993           complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13994                        "DW_TAG_call_site child DIE %s [in module %s]"),
13995                      child_die->tag, sect_offset_str (child_die->sect_off),
13996                      objfile_name (objfile));
13997           continue;
13998         }
13999
14000       nparams++;
14001     }
14002
14003   call_site
14004     = ((struct call_site *)
14005        obstack_alloc (&objfile->objfile_obstack,
14006                       sizeof (*call_site)
14007                       + (sizeof (*call_site->parameter) * (nparams - 1))));
14008   *slot = call_site;
14009   memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14010   call_site->pc = pc;
14011
14012   if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14013       || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14014     {
14015       struct die_info *func_die;
14016
14017       /* Skip also over DW_TAG_inlined_subroutine.  */
14018       for (func_die = die->parent;
14019            func_die && func_die->tag != DW_TAG_subprogram
14020            && func_die->tag != DW_TAG_subroutine_type;
14021            func_die = func_die->parent);
14022
14023       /* DW_AT_call_all_calls is a superset
14024          of DW_AT_call_all_tail_calls.  */
14025       if (func_die
14026           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14027           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14028           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14029           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14030         {
14031           /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14032              not complete.  But keep CALL_SITE for look ups via call_site_htab,
14033              both the initial caller containing the real return address PC and
14034              the final callee containing the current PC of a chain of tail
14035              calls do not need to have the tail call list complete.  But any
14036              function candidate for a virtual tail call frame searched via
14037              TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14038              determined unambiguously.  */
14039         }
14040       else
14041         {
14042           struct type *func_type = NULL;
14043
14044           if (func_die)
14045             func_type = get_die_type (func_die, cu);
14046           if (func_type != NULL)
14047             {
14048               gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14049
14050               /* Enlist this call site to the function.  */
14051               call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14052               TYPE_TAIL_CALL_LIST (func_type) = call_site;
14053             }
14054           else
14055             complaint (_("Cannot find function owning DW_TAG_call_site "
14056                          "DIE %s [in module %s]"),
14057                        sect_offset_str (die->sect_off), objfile_name (objfile));
14058         }
14059     }
14060
14061   attr = dwarf2_attr (die, DW_AT_call_target, cu);
14062   if (attr == NULL)
14063     attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14064   if (attr == NULL)
14065     attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14066   if (attr == NULL)
14067     {
14068       /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin.  */
14069       attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14070     }
14071   SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14072   if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14073     /* Keep NULL DWARF_BLOCK.  */;
14074   else if (attr_form_is_block (attr))
14075     {
14076       struct dwarf2_locexpr_baton *dlbaton;
14077
14078       dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14079       dlbaton->data = DW_BLOCK (attr)->data;
14080       dlbaton->size = DW_BLOCK (attr)->size;
14081       dlbaton->per_cu = cu->per_cu;
14082
14083       SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14084     }
14085   else if (attr_form_is_ref (attr))
14086     {
14087       struct dwarf2_cu *target_cu = cu;
14088       struct die_info *target_die;
14089
14090       target_die = follow_die_ref (die, attr, &target_cu);
14091       gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14092       if (die_is_declaration (target_die, target_cu))
14093         {
14094           const char *target_physname;
14095
14096           /* Prefer the mangled name; otherwise compute the demangled one.  */
14097           target_physname = dw2_linkage_name (target_die, target_cu);
14098           if (target_physname == NULL)
14099             target_physname = dwarf2_physname (NULL, target_die, target_cu);
14100           if (target_physname == NULL)
14101             complaint (_("DW_AT_call_target target DIE has invalid "
14102                          "physname, for referencing DIE %s [in module %s]"),
14103                        sect_offset_str (die->sect_off), objfile_name (objfile));
14104           else
14105             SET_FIELD_PHYSNAME (call_site->target, target_physname);
14106         }
14107       else
14108         {
14109           CORE_ADDR lowpc;
14110
14111           /* DW_AT_entry_pc should be preferred.  */
14112           if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14113               <= PC_BOUNDS_INVALID)
14114             complaint (_("DW_AT_call_target target DIE has invalid "
14115                          "low pc, for referencing DIE %s [in module %s]"),
14116                        sect_offset_str (die->sect_off), objfile_name (objfile));
14117           else
14118             {
14119               lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14120               SET_FIELD_PHYSADDR (call_site->target, lowpc);
14121             }
14122         }
14123     }
14124   else
14125     complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14126                  "block nor reference, for DIE %s [in module %s]"),
14127                sect_offset_str (die->sect_off), objfile_name (objfile));
14128
14129   call_site->per_cu = cu->per_cu;
14130
14131   for (child_die = die->child;
14132        child_die && child_die->tag;
14133        child_die = sibling_die (child_die))
14134     {
14135       struct call_site_parameter *parameter;
14136       struct attribute *loc, *origin;
14137
14138       if (child_die->tag != DW_TAG_call_site_parameter
14139           && child_die->tag != DW_TAG_GNU_call_site_parameter)
14140         {
14141           /* Already printed the complaint above.  */
14142           continue;
14143         }
14144
14145       gdb_assert (call_site->parameter_count < nparams);
14146       parameter = &call_site->parameter[call_site->parameter_count];
14147
14148       /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14149          specifies DW_TAG_formal_parameter.  Value of the data assumed for the
14150          register is contained in DW_AT_call_value.  */
14151
14152       loc = dwarf2_attr (child_die, DW_AT_location, cu);
14153       origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14154       if (origin == NULL)
14155         {
14156           /* This was a pre-DWARF-5 GNU extension alias
14157              for DW_AT_call_parameter.  */
14158           origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14159         }
14160       if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14161         {
14162           parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14163
14164           sect_offset sect_off
14165             = (sect_offset) dwarf2_get_ref_die_offset (origin);
14166           if (!offset_in_cu_p (&cu->header, sect_off))
14167             {
14168               /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14169                  binding can be done only inside one CU.  Such referenced DIE
14170                  therefore cannot be even moved to DW_TAG_partial_unit.  */
14171               complaint (_("DW_AT_call_parameter offset is not in CU for "
14172                            "DW_TAG_call_site child DIE %s [in module %s]"),
14173                          sect_offset_str (child_die->sect_off),
14174                          objfile_name (objfile));
14175               continue;
14176             }
14177           parameter->u.param_cu_off
14178             = (cu_offset) (sect_off - cu->header.sect_off);
14179         }
14180       else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14181         {
14182           complaint (_("No DW_FORM_block* DW_AT_location for "
14183                        "DW_TAG_call_site child DIE %s [in module %s]"),
14184                      sect_offset_str (child_die->sect_off), objfile_name (objfile));
14185           continue;
14186         }
14187       else
14188         {
14189           parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14190             (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14191           if (parameter->u.dwarf_reg != -1)
14192             parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14193           else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14194                                     &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14195                                              &parameter->u.fb_offset))
14196             parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14197           else
14198             {
14199               complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14200                            "for DW_FORM_block* DW_AT_location is supported for "
14201                            "DW_TAG_call_site child DIE %s "
14202                            "[in module %s]"),
14203                          sect_offset_str (child_die->sect_off),
14204                          objfile_name (objfile));
14205               continue;
14206             }
14207         }
14208
14209       attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14210       if (attr == NULL)
14211         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14212       if (!attr_form_is_block (attr))
14213         {
14214           complaint (_("No DW_FORM_block* DW_AT_call_value for "
14215                        "DW_TAG_call_site child DIE %s [in module %s]"),
14216                      sect_offset_str (child_die->sect_off),
14217                      objfile_name (objfile));
14218           continue;
14219         }
14220       parameter->value = DW_BLOCK (attr)->data;
14221       parameter->value_size = DW_BLOCK (attr)->size;
14222
14223       /* Parameters are not pre-cleared by memset above.  */
14224       parameter->data_value = NULL;
14225       parameter->data_value_size = 0;
14226       call_site->parameter_count++;
14227
14228       attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14229       if (attr == NULL)
14230         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14231       if (attr)
14232         {
14233           if (!attr_form_is_block (attr))
14234             complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14235                          "DW_TAG_call_site child DIE %s [in module %s]"),
14236                        sect_offset_str (child_die->sect_off),
14237                        objfile_name (objfile));
14238           else
14239             {
14240               parameter->data_value = DW_BLOCK (attr)->data;
14241               parameter->data_value_size = DW_BLOCK (attr)->size;
14242             }
14243         }
14244     }
14245 }
14246
14247 /* Helper function for read_variable.  If DIE represents a virtual
14248    table, then return the type of the concrete object that is
14249    associated with the virtual table.  Otherwise, return NULL.  */
14250
14251 static struct type *
14252 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14253 {
14254   struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14255   if (attr == NULL)
14256     return NULL;
14257
14258   /* Find the type DIE.  */
14259   struct die_info *type_die = NULL;
14260   struct dwarf2_cu *type_cu = cu;
14261
14262   if (attr_form_is_ref (attr))
14263     type_die = follow_die_ref (die, attr, &type_cu);
14264   if (type_die == NULL)
14265     return NULL;
14266
14267   if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14268     return NULL;
14269   return die_containing_type (type_die, type_cu);
14270 }
14271
14272 /* Read a variable (DW_TAG_variable) DIE and create a new symbol.  */
14273
14274 static void
14275 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14276 {
14277   struct rust_vtable_symbol *storage = NULL;
14278
14279   if (cu->language == language_rust)
14280     {
14281       struct type *containing_type = rust_containing_type (die, cu);
14282
14283       if (containing_type != NULL)
14284         {
14285           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14286
14287           storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14288                                     struct rust_vtable_symbol);
14289           initialize_objfile_symbol (storage);
14290           storage->concrete_type = containing_type;
14291           storage->subclass = SYMBOL_RUST_VTABLE;
14292         }
14293     }
14294
14295   struct symbol *res = new_symbol (die, NULL, cu, storage);
14296   struct attribute *abstract_origin
14297     = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14298   struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14299   if (res == NULL && loc && abstract_origin)
14300     {
14301       /* We have a variable without a name, but with a location and an abstract
14302          origin.  This may be a concrete instance of an abstract variable
14303          referenced from an DW_OP_GNU_variable_value, so save it to find it back
14304          later.  */
14305       struct dwarf2_cu *origin_cu = cu;
14306       struct die_info *origin_die
14307         = follow_die_ref (die, abstract_origin, &origin_cu);
14308       dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14309       dpo->abstract_to_concrete[origin_die].push_back (die);
14310     }
14311 }
14312
14313 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14314    reading .debug_rnglists.
14315    Callback's type should be:
14316     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14317    Return true if the attributes are present and valid, otherwise,
14318    return false.  */
14319
14320 template <typename Callback>
14321 static bool
14322 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14323                          Callback &&callback)
14324 {
14325   struct dwarf2_per_objfile *dwarf2_per_objfile
14326     = cu->per_cu->dwarf2_per_objfile;
14327   struct objfile *objfile = dwarf2_per_objfile->objfile;
14328   bfd *obfd = objfile->obfd;
14329   /* Base address selection entry.  */
14330   CORE_ADDR base;
14331   int found_base;
14332   const gdb_byte *buffer;
14333   CORE_ADDR baseaddr;
14334   bool overflow = false;
14335
14336   found_base = cu->base_known;
14337   base = cu->base_address;
14338
14339   dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14340   if (offset >= dwarf2_per_objfile->rnglists.size)
14341     {
14342       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14343                  offset);
14344       return false;
14345     }
14346   buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14347
14348   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14349
14350   while (1)
14351     {
14352       /* Initialize it due to a false compiler warning.  */
14353       CORE_ADDR range_beginning = 0, range_end = 0;
14354       const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14355                                  + dwarf2_per_objfile->rnglists.size);
14356       unsigned int bytes_read;
14357
14358       if (buffer == buf_end)
14359         {
14360           overflow = true;
14361           break;
14362         }
14363       const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14364       switch (rlet)
14365         {
14366         case DW_RLE_end_of_list:
14367           break;
14368         case DW_RLE_base_address:
14369           if (buffer + cu->header.addr_size > buf_end)
14370             {
14371               overflow = true;
14372               break;
14373             }
14374           base = read_address (obfd, buffer, cu, &bytes_read);
14375           found_base = 1;
14376           buffer += bytes_read;
14377           break;
14378         case DW_RLE_start_length:
14379           if (buffer + cu->header.addr_size > buf_end)
14380             {
14381               overflow = true;
14382               break;
14383             }
14384           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14385           buffer += bytes_read;
14386           range_end = (range_beginning
14387                        + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14388           buffer += bytes_read;
14389           if (buffer > buf_end)
14390             {
14391               overflow = true;
14392               break;
14393             }
14394           break;
14395         case DW_RLE_offset_pair:
14396           range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14397           buffer += bytes_read;
14398           if (buffer > buf_end)
14399             {
14400               overflow = true;
14401               break;
14402             }
14403           range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14404           buffer += bytes_read;
14405           if (buffer > buf_end)
14406             {
14407               overflow = true;
14408               break;
14409             }
14410           break;
14411         case DW_RLE_start_end:
14412           if (buffer + 2 * cu->header.addr_size > buf_end)
14413             {
14414               overflow = true;
14415               break;
14416             }
14417           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14418           buffer += bytes_read;
14419           range_end = read_address (obfd, buffer, cu, &bytes_read);
14420           buffer += bytes_read;
14421           break;
14422         default:
14423           complaint (_("Invalid .debug_rnglists data (no base address)"));
14424           return false;
14425         }
14426       if (rlet == DW_RLE_end_of_list || overflow)
14427         break;
14428       if (rlet == DW_RLE_base_address)
14429         continue;
14430
14431       if (!found_base)
14432         {
14433           /* We have no valid base address for the ranges
14434              data.  */
14435           complaint (_("Invalid .debug_rnglists data (no base address)"));
14436           return false;
14437         }
14438
14439       if (range_beginning > range_end)
14440         {
14441           /* Inverted range entries are invalid.  */
14442           complaint (_("Invalid .debug_rnglists data (inverted range)"));
14443           return false;
14444         }
14445
14446       /* Empty range entries have no effect.  */
14447       if (range_beginning == range_end)
14448         continue;
14449
14450       range_beginning += base;
14451       range_end += base;
14452
14453       /* A not-uncommon case of bad debug info.
14454          Don't pollute the addrmap with bad data.  */
14455       if (range_beginning + baseaddr == 0
14456           && !dwarf2_per_objfile->has_section_at_zero)
14457         {
14458           complaint (_(".debug_rnglists entry has start address of zero"
14459                        " [in module %s]"), objfile_name (objfile));
14460           continue;
14461         }
14462
14463       callback (range_beginning, range_end);
14464     }
14465
14466   if (overflow)
14467     {
14468       complaint (_("Offset %d is not terminated "
14469                    "for DW_AT_ranges attribute"),
14470                  offset);
14471       return false;
14472     }
14473
14474   return true;
14475 }
14476
14477 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14478    Callback's type should be:
14479     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14480    Return 1 if the attributes are present and valid, otherwise, return 0.  */
14481
14482 template <typename Callback>
14483 static int
14484 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14485                        Callback &&callback)
14486 {
14487   struct dwarf2_per_objfile *dwarf2_per_objfile
14488       = cu->per_cu->dwarf2_per_objfile;
14489   struct objfile *objfile = dwarf2_per_objfile->objfile;
14490   struct comp_unit_head *cu_header = &cu->header;
14491   bfd *obfd = objfile->obfd;
14492   unsigned int addr_size = cu_header->addr_size;
14493   CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14494   /* Base address selection entry.  */
14495   CORE_ADDR base;
14496   int found_base;
14497   unsigned int dummy;
14498   const gdb_byte *buffer;
14499   CORE_ADDR baseaddr;
14500
14501   if (cu_header->version >= 5)
14502     return dwarf2_rnglists_process (offset, cu, callback);
14503
14504   found_base = cu->base_known;
14505   base = cu->base_address;
14506
14507   dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14508   if (offset >= dwarf2_per_objfile->ranges.size)
14509     {
14510       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14511                  offset);
14512       return 0;
14513     }
14514   buffer = dwarf2_per_objfile->ranges.buffer + offset;
14515
14516   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14517
14518   while (1)
14519     {
14520       CORE_ADDR range_beginning, range_end;
14521
14522       range_beginning = read_address (obfd, buffer, cu, &dummy);
14523       buffer += addr_size;
14524       range_end = read_address (obfd, buffer, cu, &dummy);
14525       buffer += addr_size;
14526       offset += 2 * addr_size;
14527
14528       /* An end of list marker is a pair of zero addresses.  */
14529       if (range_beginning == 0 && range_end == 0)
14530         /* Found the end of list entry.  */
14531         break;
14532
14533       /* Each base address selection entry is a pair of 2 values.
14534          The first is the largest possible address, the second is
14535          the base address.  Check for a base address here.  */
14536       if ((range_beginning & mask) == mask)
14537         {
14538           /* If we found the largest possible address, then we already
14539              have the base address in range_end.  */
14540           base = range_end;
14541           found_base = 1;
14542           continue;
14543         }
14544
14545       if (!found_base)
14546         {
14547           /* We have no valid base address for the ranges
14548              data.  */
14549           complaint (_("Invalid .debug_ranges data (no base address)"));
14550           return 0;
14551         }
14552
14553       if (range_beginning > range_end)
14554         {
14555           /* Inverted range entries are invalid.  */
14556           complaint (_("Invalid .debug_ranges data (inverted range)"));
14557           return 0;
14558         }
14559
14560       /* Empty range entries have no effect.  */
14561       if (range_beginning == range_end)
14562         continue;
14563
14564       range_beginning += base;
14565       range_end += base;
14566
14567       /* A not-uncommon case of bad debug info.
14568          Don't pollute the addrmap with bad data.  */
14569       if (range_beginning + baseaddr == 0
14570           && !dwarf2_per_objfile->has_section_at_zero)
14571         {
14572           complaint (_(".debug_ranges entry has start address of zero"
14573                        " [in module %s]"), objfile_name (objfile));
14574           continue;
14575         }
14576
14577       callback (range_beginning, range_end);
14578     }
14579
14580   return 1;
14581 }
14582
14583 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14584    Return 1 if the attributes are present and valid, otherwise, return 0.
14585    If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'.  */
14586
14587 static int
14588 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14589                     CORE_ADDR *high_return, struct dwarf2_cu *cu,
14590                     struct partial_symtab *ranges_pst)
14591 {
14592   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14593   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14594   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14595                                        SECT_OFF_TEXT (objfile));
14596   int low_set = 0;
14597   CORE_ADDR low = 0;
14598   CORE_ADDR high = 0;
14599   int retval;
14600
14601   retval = dwarf2_ranges_process (offset, cu,
14602     [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14603     {
14604       if (ranges_pst != NULL)
14605         {
14606           CORE_ADDR lowpc;
14607           CORE_ADDR highpc;
14608
14609           lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14610                                                range_beginning + baseaddr)
14611                    - baseaddr);
14612           highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14613                                                 range_end + baseaddr)
14614                     - baseaddr);
14615           addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14616                              lowpc, highpc - 1, ranges_pst);
14617         }
14618
14619       /* FIXME: This is recording everything as a low-high
14620          segment of consecutive addresses.  We should have a
14621          data structure for discontiguous block ranges
14622          instead.  */
14623       if (! low_set)
14624         {
14625           low = range_beginning;
14626           high = range_end;
14627           low_set = 1;
14628         }
14629       else
14630         {
14631           if (range_beginning < low)
14632             low = range_beginning;
14633           if (range_end > high)
14634             high = range_end;
14635         }
14636     });
14637   if (!retval)
14638     return 0;
14639
14640   if (! low_set)
14641     /* If the first entry is an end-of-list marker, the range
14642        describes an empty scope, i.e. no instructions.  */
14643     return 0;
14644
14645   if (low_return)
14646     *low_return = low;
14647   if (high_return)
14648     *high_return = high;
14649   return 1;
14650 }
14651
14652 /* Get low and high pc attributes from a die.  See enum pc_bounds_kind
14653    definition for the return value.  *LOWPC and *HIGHPC are set iff
14654    neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned.  */
14655
14656 static enum pc_bounds_kind
14657 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14658                       CORE_ADDR *highpc, struct dwarf2_cu *cu,
14659                       struct partial_symtab *pst)
14660 {
14661   struct dwarf2_per_objfile *dwarf2_per_objfile
14662     = cu->per_cu->dwarf2_per_objfile;
14663   struct attribute *attr;
14664   struct attribute *attr_high;
14665   CORE_ADDR low = 0;
14666   CORE_ADDR high = 0;
14667   enum pc_bounds_kind ret;
14668
14669   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14670   if (attr_high)
14671     {
14672       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14673       if (attr)
14674         {
14675           low = attr_value_as_address (attr);
14676           high = attr_value_as_address (attr_high);
14677           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14678             high += low;
14679         }
14680       else
14681         /* Found high w/o low attribute.  */
14682         return PC_BOUNDS_INVALID;
14683
14684       /* Found consecutive range of addresses.  */
14685       ret = PC_BOUNDS_HIGH_LOW;
14686     }
14687   else
14688     {
14689       attr = dwarf2_attr (die, DW_AT_ranges, cu);
14690       if (attr != NULL)
14691         {
14692           /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14693              We take advantage of the fact that DW_AT_ranges does not appear
14694              in DW_TAG_compile_unit of DWO files.  */
14695           int need_ranges_base = die->tag != DW_TAG_compile_unit;
14696           unsigned int ranges_offset = (DW_UNSND (attr)
14697                                         + (need_ranges_base
14698                                            ? cu->ranges_base
14699                                            : 0));
14700
14701           /* Value of the DW_AT_ranges attribute is the offset in the
14702              .debug_ranges section.  */
14703           if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14704             return PC_BOUNDS_INVALID;
14705           /* Found discontinuous range of addresses.  */
14706           ret = PC_BOUNDS_RANGES;
14707         }
14708       else
14709         return PC_BOUNDS_NOT_PRESENT;
14710     }
14711
14712   /* partial_die_info::read has also the strict LOW < HIGH requirement.  */
14713   if (high <= low)
14714     return PC_BOUNDS_INVALID;
14715
14716   /* When using the GNU linker, .gnu.linkonce. sections are used to
14717      eliminate duplicate copies of functions and vtables and such.
14718      The linker will arbitrarily choose one and discard the others.
14719      The AT_*_pc values for such functions refer to local labels in
14720      these sections.  If the section from that file was discarded, the
14721      labels are not in the output, so the relocs get a value of 0.
14722      If this is a discarded function, mark the pc bounds as invalid,
14723      so that GDB will ignore it.  */
14724   if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14725     return PC_BOUNDS_INVALID;
14726
14727   *lowpc = low;
14728   if (highpc)
14729     *highpc = high;
14730   return ret;
14731 }
14732
14733 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14734    its low and high PC addresses.  Do nothing if these addresses could not
14735    be determined.  Otherwise, set LOWPC to the low address if it is smaller,
14736    and HIGHPC to the high address if greater than HIGHPC.  */
14737
14738 static void
14739 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14740                                  CORE_ADDR *lowpc, CORE_ADDR *highpc,
14741                                  struct dwarf2_cu *cu)
14742 {
14743   CORE_ADDR low, high;
14744   struct die_info *child = die->child;
14745
14746   if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14747     {
14748       *lowpc = std::min (*lowpc, low);
14749       *highpc = std::max (*highpc, high);
14750     }
14751
14752   /* If the language does not allow nested subprograms (either inside
14753      subprograms or lexical blocks), we're done.  */
14754   if (cu->language != language_ada)
14755     return;
14756
14757   /* Check all the children of the given DIE.  If it contains nested
14758      subprograms, then check their pc bounds.  Likewise, we need to
14759      check lexical blocks as well, as they may also contain subprogram
14760      definitions.  */
14761   while (child && child->tag)
14762     {
14763       if (child->tag == DW_TAG_subprogram
14764           || child->tag == DW_TAG_lexical_block)
14765         dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14766       child = sibling_die (child);
14767     }
14768 }
14769
14770 /* Get the low and high pc's represented by the scope DIE, and store
14771    them in *LOWPC and *HIGHPC.  If the correct values can't be
14772    determined, set *LOWPC to -1 and *HIGHPC to 0.  */
14773
14774 static void
14775 get_scope_pc_bounds (struct die_info *die,
14776                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
14777                      struct dwarf2_cu *cu)
14778 {
14779   CORE_ADDR best_low = (CORE_ADDR) -1;
14780   CORE_ADDR best_high = (CORE_ADDR) 0;
14781   CORE_ADDR current_low, current_high;
14782
14783   if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL)
14784       >= PC_BOUNDS_RANGES)
14785     {
14786       best_low = current_low;
14787       best_high = current_high;
14788     }
14789   else
14790     {
14791       struct die_info *child = die->child;
14792
14793       while (child && child->tag)
14794         {
14795           switch (child->tag) {
14796           case DW_TAG_subprogram:
14797             dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14798             break;
14799           case DW_TAG_namespace:
14800           case DW_TAG_module:
14801             /* FIXME: carlton/2004-01-16: Should we do this for
14802                DW_TAG_class_type/DW_TAG_structure_type, too?  I think
14803                that current GCC's always emit the DIEs corresponding
14804                to definitions of methods of classes as children of a
14805                DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14806                the DIEs giving the declarations, which could be
14807                anywhere).  But I don't see any reason why the
14808                standards says that they have to be there.  */
14809             get_scope_pc_bounds (child, &current_low, &current_high, cu);
14810
14811             if (current_low != ((CORE_ADDR) -1))
14812               {
14813                 best_low = std::min (best_low, current_low);
14814                 best_high = std::max (best_high, current_high);
14815               }
14816             break;
14817           default:
14818             /* Ignore.  */
14819             break;
14820           }
14821
14822           child = sibling_die (child);
14823         }
14824     }
14825
14826   *lowpc = best_low;
14827   *highpc = best_high;
14828 }
14829
14830 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14831    in DIE.  */
14832
14833 static void
14834 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14835                             CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14836 {
14837   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14838   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14839   struct attribute *attr;
14840   struct attribute *attr_high;
14841
14842   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14843   if (attr_high)
14844     {
14845       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14846       if (attr)
14847         {
14848           CORE_ADDR low = attr_value_as_address (attr);
14849           CORE_ADDR high = attr_value_as_address (attr_high);
14850
14851           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14852             high += low;
14853
14854           low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14855           high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14856           cu->get_builder ()->record_block_range (block, low, high - 1);
14857         }
14858     }
14859
14860   attr = dwarf2_attr (die, DW_AT_ranges, cu);
14861   if (attr)
14862     {
14863       /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14864          We take advantage of the fact that DW_AT_ranges does not appear
14865          in DW_TAG_compile_unit of DWO files.  */
14866       int need_ranges_base = die->tag != DW_TAG_compile_unit;
14867
14868       /* The value of the DW_AT_ranges attribute is the offset of the
14869          address range list in the .debug_ranges section.  */
14870       unsigned long offset = (DW_UNSND (attr)
14871                               + (need_ranges_base ? cu->ranges_base : 0));
14872
14873       std::vector<blockrange> blockvec;
14874       dwarf2_ranges_process (offset, cu,
14875         [&] (CORE_ADDR start, CORE_ADDR end)
14876         {
14877           start += baseaddr;
14878           end += baseaddr;
14879           start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14880           end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14881           cu->get_builder ()->record_block_range (block, start, end - 1);
14882           blockvec.emplace_back (start, end);
14883         });
14884
14885       BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14886     }
14887 }
14888
14889 /* Check whether the producer field indicates either of GCC < 4.6, or the
14890    Intel C/C++ compiler, and cache the result in CU.  */
14891
14892 static void
14893 check_producer (struct dwarf2_cu *cu)
14894 {
14895   int major, minor;
14896
14897   if (cu->producer == NULL)
14898     {
14899       /* For unknown compilers expect their behavior is DWARF version
14900          compliant.
14901
14902          GCC started to support .debug_types sections by -gdwarf-4 since
14903          gcc-4.5.x.  As the .debug_types sections are missing DW_AT_producer
14904          for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14905          combination.  gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14906          interpreted incorrectly by GDB now - GCC PR debug/48229.  */
14907     }
14908   else if (producer_is_gcc (cu->producer, &major, &minor))
14909     {
14910       cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14911       cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14912     }
14913   else if (producer_is_icc (cu->producer, &major, &minor))
14914     {
14915       cu->producer_is_icc = true;
14916       cu->producer_is_icc_lt_14 = major < 14;
14917     }
14918   else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14919     cu->producer_is_codewarrior = true;
14920   else
14921     {
14922       /* For other non-GCC compilers, expect their behavior is DWARF version
14923          compliant.  */
14924     }
14925
14926   cu->checked_producer = true;
14927 }
14928
14929 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14930    to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14931    during 4.6.0 experimental.  */
14932
14933 static bool
14934 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14935 {
14936   if (!cu->checked_producer)
14937     check_producer (cu);
14938
14939   return cu->producer_is_gxx_lt_4_6;
14940 }
14941
14942
14943 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14944    with incorrect is_stmt attributes.  */
14945
14946 static bool
14947 producer_is_codewarrior (struct dwarf2_cu *cu)
14948 {
14949   if (!cu->checked_producer)
14950     check_producer (cu);
14951
14952   return cu->producer_is_codewarrior;
14953 }
14954
14955 /* Return the default accessibility type if it is not overriden by
14956    DW_AT_accessibility.  */
14957
14958 static enum dwarf_access_attribute
14959 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14960 {
14961   if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14962     {
14963       /* The default DWARF 2 accessibility for members is public, the default
14964          accessibility for inheritance is private.  */
14965
14966       if (die->tag != DW_TAG_inheritance)
14967         return DW_ACCESS_public;
14968       else
14969         return DW_ACCESS_private;
14970     }
14971   else
14972     {
14973       /* DWARF 3+ defines the default accessibility a different way.  The same
14974          rules apply now for DW_TAG_inheritance as for the members and it only
14975          depends on the container kind.  */
14976
14977       if (die->parent->tag == DW_TAG_class_type)
14978         return DW_ACCESS_private;
14979       else
14980         return DW_ACCESS_public;
14981     }
14982 }
14983
14984 /* Look for DW_AT_data_member_location.  Set *OFFSET to the byte
14985    offset.  If the attribute was not found return 0, otherwise return
14986    1.  If it was found but could not properly be handled, set *OFFSET
14987    to 0.  */
14988
14989 static int
14990 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14991                              LONGEST *offset)
14992 {
14993   struct attribute *attr;
14994
14995   attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14996   if (attr != NULL)
14997     {
14998       *offset = 0;
14999
15000       /* Note that we do not check for a section offset first here.
15001          This is because DW_AT_data_member_location is new in DWARF 4,
15002          so if we see it, we can assume that a constant form is really
15003          a constant and not a section offset.  */
15004       if (attr_form_is_constant (attr))
15005         *offset = dwarf2_get_attr_constant_value (attr, 0);
15006       else if (attr_form_is_section_offset (attr))
15007         dwarf2_complex_location_expr_complaint ();
15008       else if (attr_form_is_block (attr))
15009         *offset = decode_locdesc (DW_BLOCK (attr), cu);
15010       else
15011         dwarf2_complex_location_expr_complaint ();
15012
15013       return 1;
15014     }
15015
15016   return 0;
15017 }
15018
15019 /* Add an aggregate field to the field list.  */
15020
15021 static void
15022 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15023                   struct dwarf2_cu *cu)
15024 {
15025   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15026   struct gdbarch *gdbarch = get_objfile_arch (objfile);
15027   struct nextfield *new_field;
15028   struct attribute *attr;
15029   struct field *fp;
15030   const char *fieldname = "";
15031
15032   if (die->tag == DW_TAG_inheritance)
15033     {
15034       fip->baseclasses.emplace_back ();
15035       new_field = &fip->baseclasses.back ();
15036     }
15037   else
15038     {
15039       fip->fields.emplace_back ();
15040       new_field = &fip->fields.back ();
15041     }
15042
15043   fip->nfields++;
15044
15045   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15046   if (attr)
15047     new_field->accessibility = DW_UNSND (attr);
15048   else
15049     new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15050   if (new_field->accessibility != DW_ACCESS_public)
15051     fip->non_public_fields = 1;
15052
15053   attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15054   if (attr)
15055     new_field->virtuality = DW_UNSND (attr);
15056   else
15057     new_field->virtuality = DW_VIRTUALITY_none;
15058
15059   fp = &new_field->field;
15060
15061   if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15062     {
15063       LONGEST offset;
15064
15065       /* Data member other than a C++ static data member.  */
15066
15067       /* Get type of field.  */
15068       fp->type = die_type (die, cu);
15069
15070       SET_FIELD_BITPOS (*fp, 0);
15071
15072       /* Get bit size of field (zero if none).  */
15073       attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15074       if (attr)
15075         {
15076           FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15077         }
15078       else
15079         {
15080           FIELD_BITSIZE (*fp) = 0;
15081         }
15082
15083       /* Get bit offset of field.  */
15084       if (handle_data_member_location (die, cu, &offset))
15085         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15086       attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15087       if (attr)
15088         {
15089           if (gdbarch_bits_big_endian (gdbarch))
15090             {
15091               /* For big endian bits, the DW_AT_bit_offset gives the
15092                  additional bit offset from the MSB of the containing
15093                  anonymous object to the MSB of the field.  We don't
15094                  have to do anything special since we don't need to
15095                  know the size of the anonymous object.  */
15096               SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15097             }
15098           else
15099             {
15100               /* For little endian bits, compute the bit offset to the
15101                  MSB of the anonymous object, subtract off the number of
15102                  bits from the MSB of the field to the MSB of the
15103                  object, and then subtract off the number of bits of
15104                  the field itself.  The result is the bit offset of
15105                  the LSB of the field.  */
15106               int anonymous_size;
15107               int bit_offset = DW_UNSND (attr);
15108
15109               attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15110               if (attr)
15111                 {
15112                   /* The size of the anonymous object containing
15113                      the bit field is explicit, so use the
15114                      indicated size (in bytes).  */
15115                   anonymous_size = DW_UNSND (attr);
15116                 }
15117               else
15118                 {
15119                   /* The size of the anonymous object containing
15120                      the bit field must be inferred from the type
15121                      attribute of the data member containing the
15122                      bit field.  */
15123                   anonymous_size = TYPE_LENGTH (fp->type);
15124                 }
15125               SET_FIELD_BITPOS (*fp,
15126                                 (FIELD_BITPOS (*fp)
15127                                  + anonymous_size * bits_per_byte
15128                                  - bit_offset - FIELD_BITSIZE (*fp)));
15129             }
15130         }
15131       attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15132       if (attr != NULL)
15133         SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15134                                 + dwarf2_get_attr_constant_value (attr, 0)));
15135
15136       /* Get name of field.  */
15137       fieldname = dwarf2_name (die, cu);
15138       if (fieldname == NULL)
15139         fieldname = "";
15140
15141       /* The name is already allocated along with this objfile, so we don't
15142          need to duplicate it for the type.  */
15143       fp->name = fieldname;
15144
15145       /* Change accessibility for artificial fields (e.g. virtual table
15146          pointer or virtual base class pointer) to private.  */
15147       if (dwarf2_attr (die, DW_AT_artificial, cu))
15148         {
15149           FIELD_ARTIFICIAL (*fp) = 1;
15150           new_field->accessibility = DW_ACCESS_private;
15151           fip->non_public_fields = 1;
15152         }
15153     }
15154   else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15155     {
15156       /* C++ static member.  */
15157
15158       /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15159          is a declaration, but all versions of G++ as of this writing
15160          (so through at least 3.2.1) incorrectly generate
15161          DW_TAG_variable tags.  */
15162
15163       const char *physname;
15164
15165       /* Get name of field.  */
15166       fieldname = dwarf2_name (die, cu);
15167       if (fieldname == NULL)
15168         return;
15169
15170       attr = dwarf2_attr (die, DW_AT_const_value, cu);
15171       if (attr
15172           /* Only create a symbol if this is an external value.
15173              new_symbol checks this and puts the value in the global symbol
15174              table, which we want.  If it is not external, new_symbol
15175              will try to put the value in cu->list_in_scope which is wrong.  */
15176           && dwarf2_flag_true_p (die, DW_AT_external, cu))
15177         {
15178           /* A static const member, not much different than an enum as far as
15179              we're concerned, except that we can support more types.  */
15180           new_symbol (die, NULL, cu);
15181         }
15182
15183       /* Get physical name.  */
15184       physname = dwarf2_physname (fieldname, die, cu);
15185
15186       /* The name is already allocated along with this objfile, so we don't
15187          need to duplicate it for the type.  */
15188       SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15189       FIELD_TYPE (*fp) = die_type (die, cu);
15190       FIELD_NAME (*fp) = fieldname;
15191     }
15192   else if (die->tag == DW_TAG_inheritance)
15193     {
15194       LONGEST offset;
15195
15196       /* C++ base class field.  */
15197       if (handle_data_member_location (die, cu, &offset))
15198         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15199       FIELD_BITSIZE (*fp) = 0;
15200       FIELD_TYPE (*fp) = die_type (die, cu);
15201       FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15202     }
15203   else if (die->tag == DW_TAG_variant_part)
15204     {
15205       /* process_structure_scope will treat this DIE as a union.  */
15206       process_structure_scope (die, cu);
15207
15208       /* The variant part is relative to the start of the enclosing
15209          structure.  */
15210       SET_FIELD_BITPOS (*fp, 0);
15211       fp->type = get_die_type (die, cu);
15212       fp->artificial = 1;
15213       fp->name = "<<variant>>";
15214
15215       /* Normally a DW_TAG_variant_part won't have a size, but our
15216          representation requires one, so set it to the maximum of the
15217          child sizes.  */
15218       if (TYPE_LENGTH (fp->type) == 0)
15219         {
15220           unsigned max = 0;
15221           for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15222             if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15223               max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15224           TYPE_LENGTH (fp->type) = max;
15225         }
15226     }
15227   else
15228     gdb_assert_not_reached ("missing case in dwarf2_add_field");
15229 }
15230
15231 /* Can the type given by DIE define another type?  */
15232
15233 static bool
15234 type_can_define_types (const struct die_info *die)
15235 {
15236   switch (die->tag)
15237     {
15238     case DW_TAG_typedef:
15239     case DW_TAG_class_type:
15240     case DW_TAG_structure_type:
15241     case DW_TAG_union_type:
15242     case DW_TAG_enumeration_type:
15243       return true;
15244
15245     default:
15246       return false;
15247     }
15248 }
15249
15250 /* Add a type definition defined in the scope of the FIP's class.  */
15251
15252 static void
15253 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15254                       struct dwarf2_cu *cu)
15255 {
15256   struct decl_field fp;
15257   memset (&fp, 0, sizeof (fp));
15258
15259   gdb_assert (type_can_define_types (die));
15260
15261   /* Get name of field.  NULL is okay here, meaning an anonymous type.  */
15262   fp.name = dwarf2_name (die, cu);
15263   fp.type = read_type_die (die, cu);
15264
15265   /* Save accessibility.  */
15266   enum dwarf_access_attribute accessibility;
15267   struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15268   if (attr != NULL)
15269     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15270   else
15271     accessibility = dwarf2_default_access_attribute (die, cu);
15272   switch (accessibility)
15273     {
15274     case DW_ACCESS_public:
15275       /* The assumed value if neither private nor protected.  */
15276       break;
15277     case DW_ACCESS_private:
15278       fp.is_private = 1;
15279       break;
15280     case DW_ACCESS_protected:
15281       fp.is_protected = 1;
15282       break;
15283     default:
15284       complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15285     }
15286
15287   if (die->tag == DW_TAG_typedef)
15288     fip->typedef_field_list.push_back (fp);
15289   else
15290     fip->nested_types_list.push_back (fp);
15291 }
15292
15293 /* Create the vector of fields, and attach it to the type.  */
15294
15295 static void
15296 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15297                               struct dwarf2_cu *cu)
15298 {
15299   int nfields = fip->nfields;
15300
15301   /* Record the field count, allocate space for the array of fields,
15302      and create blank accessibility bitfields if necessary.  */
15303   TYPE_NFIELDS (type) = nfields;
15304   TYPE_FIELDS (type) = (struct field *)
15305     TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15306
15307   if (fip->non_public_fields && cu->language != language_ada)
15308     {
15309       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15310
15311       TYPE_FIELD_PRIVATE_BITS (type) =
15312         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15313       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15314
15315       TYPE_FIELD_PROTECTED_BITS (type) =
15316         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15317       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15318
15319       TYPE_FIELD_IGNORE_BITS (type) =
15320         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15321       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15322     }
15323
15324   /* If the type has baseclasses, allocate and clear a bit vector for
15325      TYPE_FIELD_VIRTUAL_BITS.  */
15326   if (!fip->baseclasses.empty () && cu->language != language_ada)
15327     {
15328       int num_bytes = B_BYTES (fip->baseclasses.size ());
15329       unsigned char *pointer;
15330
15331       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15332       pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15333       TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15334       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15335       TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15336     }
15337
15338   if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15339     {
15340       struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15341
15342       for (int index = 0; index < nfields; ++index)
15343         {
15344           struct nextfield &field = fip->fields[index];
15345
15346           if (field.variant.is_discriminant)
15347             di->discriminant_index = index;
15348           else if (field.variant.default_branch)
15349             di->default_index = index;
15350           else
15351             di->discriminants[index] = field.variant.discriminant_value;
15352         }
15353     }
15354
15355   /* Copy the saved-up fields into the field vector.  */
15356   for (int i = 0; i < nfields; ++i)
15357     {
15358       struct nextfield &field
15359         = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15360            : fip->fields[i - fip->baseclasses.size ()]);
15361
15362       TYPE_FIELD (type, i) = field.field;
15363       switch (field.accessibility)
15364         {
15365         case DW_ACCESS_private:
15366           if (cu->language != language_ada)
15367             SET_TYPE_FIELD_PRIVATE (type, i);
15368           break;
15369
15370         case DW_ACCESS_protected:
15371           if (cu->language != language_ada)
15372             SET_TYPE_FIELD_PROTECTED (type, i);
15373           break;
15374
15375         case DW_ACCESS_public:
15376           break;
15377
15378         default:
15379           /* Unknown accessibility.  Complain and treat it as public.  */
15380           {
15381             complaint (_("unsupported accessibility %d"),
15382                        field.accessibility);
15383           }
15384           break;
15385         }
15386       if (i < fip->baseclasses.size ())
15387         {
15388           switch (field.virtuality)
15389             {
15390             case DW_VIRTUALITY_virtual:
15391             case DW_VIRTUALITY_pure_virtual:
15392               if (cu->language == language_ada)
15393                 error (_("unexpected virtuality in component of Ada type"));
15394               SET_TYPE_FIELD_VIRTUAL (type, i);
15395               break;
15396             }
15397         }
15398     }
15399 }
15400
15401 /* Return true if this member function is a constructor, false
15402    otherwise.  */
15403
15404 static int
15405 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15406 {
15407   const char *fieldname;
15408   const char *type_name;
15409   int len;
15410
15411   if (die->parent == NULL)
15412     return 0;
15413
15414   if (die->parent->tag != DW_TAG_structure_type
15415       && die->parent->tag != DW_TAG_union_type
15416       && die->parent->tag != DW_TAG_class_type)
15417     return 0;
15418
15419   fieldname = dwarf2_name (die, cu);
15420   type_name = dwarf2_name (die->parent, cu);
15421   if (fieldname == NULL || type_name == NULL)
15422     return 0;
15423
15424   len = strlen (fieldname);
15425   return (strncmp (fieldname, type_name, len) == 0
15426           && (type_name[len] == '\0' || type_name[len] == '<'));
15427 }
15428
15429 /* Add a member function to the proper fieldlist.  */
15430
15431 static void
15432 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15433                       struct type *type, struct dwarf2_cu *cu)
15434 {
15435   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15436   struct attribute *attr;
15437   int i;
15438   struct fnfieldlist *flp = nullptr;
15439   struct fn_field *fnp;
15440   const char *fieldname;
15441   struct type *this_type;
15442   enum dwarf_access_attribute accessibility;
15443
15444   if (cu->language == language_ada)
15445     error (_("unexpected member function in Ada type"));
15446
15447   /* Get name of member function.  */
15448   fieldname = dwarf2_name (die, cu);
15449   if (fieldname == NULL)
15450     return;
15451
15452   /* Look up member function name in fieldlist.  */
15453   for (i = 0; i < fip->fnfieldlists.size (); i++)
15454     {
15455       if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15456         {
15457           flp = &fip->fnfieldlists[i];
15458           break;
15459         }
15460     }
15461
15462   /* Create a new fnfieldlist if necessary.  */
15463   if (flp == nullptr)
15464     {
15465       fip->fnfieldlists.emplace_back ();
15466       flp = &fip->fnfieldlists.back ();
15467       flp->name = fieldname;
15468       i = fip->fnfieldlists.size () - 1;
15469     }
15470
15471   /* Create a new member function field and add it to the vector of
15472      fnfieldlists.  */
15473   flp->fnfields.emplace_back ();
15474   fnp = &flp->fnfields.back ();
15475
15476   /* Delay processing of the physname until later.  */
15477   if (cu->language == language_cplus)
15478     add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15479                         die, cu);
15480   else
15481     {
15482       const char *physname = dwarf2_physname (fieldname, die, cu);
15483       fnp->physname = physname ? physname : "";
15484     }
15485
15486   fnp->type = alloc_type (objfile);
15487   this_type = read_type_die (die, cu);
15488   if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15489     {
15490       int nparams = TYPE_NFIELDS (this_type);
15491
15492       /* TYPE is the domain of this method, and THIS_TYPE is the type
15493            of the method itself (TYPE_CODE_METHOD).  */
15494       smash_to_method_type (fnp->type, type,
15495                             TYPE_TARGET_TYPE (this_type),
15496                             TYPE_FIELDS (this_type),
15497                             TYPE_NFIELDS (this_type),
15498                             TYPE_VARARGS (this_type));
15499
15500       /* Handle static member functions.
15501          Dwarf2 has no clean way to discern C++ static and non-static
15502          member functions.  G++ helps GDB by marking the first
15503          parameter for non-static member functions (which is the this
15504          pointer) as artificial.  We obtain this information from
15505          read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
15506       if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15507         fnp->voffset = VOFFSET_STATIC;
15508     }
15509   else
15510     complaint (_("member function type missing for '%s'"),
15511                dwarf2_full_name (fieldname, die, cu));
15512
15513   /* Get fcontext from DW_AT_containing_type if present.  */
15514   if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15515     fnp->fcontext = die_containing_type (die, cu);
15516
15517   /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15518      is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
15519
15520   /* Get accessibility.  */
15521   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15522   if (attr)
15523     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15524   else
15525     accessibility = dwarf2_default_access_attribute (die, cu);
15526   switch (accessibility)
15527     {
15528     case DW_ACCESS_private:
15529       fnp->is_private = 1;
15530       break;
15531     case DW_ACCESS_protected:
15532       fnp->is_protected = 1;
15533       break;
15534     }
15535
15536   /* Check for artificial methods.  */
15537   attr = dwarf2_attr (die, DW_AT_artificial, cu);
15538   if (attr && DW_UNSND (attr) != 0)
15539     fnp->is_artificial = 1;
15540
15541   fnp->is_constructor = dwarf2_is_constructor (die, cu);
15542
15543   /* Get index in virtual function table if it is a virtual member
15544      function.  For older versions of GCC, this is an offset in the
15545      appropriate virtual table, as specified by DW_AT_containing_type.
15546      For everyone else, it is an expression to be evaluated relative
15547      to the object address.  */
15548
15549   attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15550   if (attr)
15551     {
15552       if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15553         {
15554           if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15555             {
15556               /* Old-style GCC.  */
15557               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15558             }
15559           else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15560                    || (DW_BLOCK (attr)->size > 1
15561                        && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15562                        && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15563             {
15564               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15565               if ((fnp->voffset % cu->header.addr_size) != 0)
15566                 dwarf2_complex_location_expr_complaint ();
15567               else
15568                 fnp->voffset /= cu->header.addr_size;
15569               fnp->voffset += 2;
15570             }
15571           else
15572             dwarf2_complex_location_expr_complaint ();
15573
15574           if (!fnp->fcontext)
15575             {
15576               /* If there is no `this' field and no DW_AT_containing_type,
15577                  we cannot actually find a base class context for the
15578                  vtable!  */
15579               if (TYPE_NFIELDS (this_type) == 0
15580                   || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15581                 {
15582                   complaint (_("cannot determine context for virtual member "
15583                                "function \"%s\" (offset %s)"),
15584                              fieldname, sect_offset_str (die->sect_off));
15585                 }
15586               else
15587                 {
15588                   fnp->fcontext
15589                     = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15590                 }
15591             }
15592         }
15593       else if (attr_form_is_section_offset (attr))
15594         {
15595           dwarf2_complex_location_expr_complaint ();
15596         }
15597       else
15598         {
15599           dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15600                                                  fieldname);
15601         }
15602     }
15603   else
15604     {
15605       attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15606       if (attr && DW_UNSND (attr))
15607         {
15608           /* GCC does this, as of 2008-08-25; PR debug/37237.  */
15609           complaint (_("Member function \"%s\" (offset %s) is virtual "
15610                        "but the vtable offset is not specified"),
15611                      fieldname, sect_offset_str (die->sect_off));
15612           ALLOCATE_CPLUS_STRUCT_TYPE (type);
15613           TYPE_CPLUS_DYNAMIC (type) = 1;
15614         }
15615     }
15616 }
15617
15618 /* Create the vector of member function fields, and attach it to the type.  */
15619
15620 static void
15621 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15622                                  struct dwarf2_cu *cu)
15623 {
15624   if (cu->language == language_ada)
15625     error (_("unexpected member functions in Ada type"));
15626
15627   ALLOCATE_CPLUS_STRUCT_TYPE (type);
15628   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15629     TYPE_ALLOC (type,
15630                 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15631
15632   for (int i = 0; i < fip->fnfieldlists.size (); i++)
15633     {
15634       struct fnfieldlist &nf = fip->fnfieldlists[i];
15635       struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15636
15637       TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15638       TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15639       fn_flp->fn_fields = (struct fn_field *)
15640         TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15641
15642       for (int k = 0; k < nf.fnfields.size (); ++k)
15643         fn_flp->fn_fields[k] = nf.fnfields[k];
15644     }
15645
15646   TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15647 }
15648
15649 /* Returns non-zero if NAME is the name of a vtable member in CU's
15650    language, zero otherwise.  */
15651 static int
15652 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15653 {
15654   static const char vptr[] = "_vptr";
15655
15656   /* Look for the C++ form of the vtable.  */
15657   if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15658     return 1;
15659
15660   return 0;
15661 }
15662
15663 /* GCC outputs unnamed structures that are really pointers to member
15664    functions, with the ABI-specified layout.  If TYPE describes
15665    such a structure, smash it into a member function type.
15666
15667    GCC shouldn't do this; it should just output pointer to member DIEs.
15668    This is GCC PR debug/28767.  */
15669
15670 static void
15671 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15672 {
15673   struct type *pfn_type, *self_type, *new_type;
15674
15675   /* Check for a structure with no name and two children.  */
15676   if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15677     return;
15678
15679   /* Check for __pfn and __delta members.  */
15680   if (TYPE_FIELD_NAME (type, 0) == NULL
15681       || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15682       || TYPE_FIELD_NAME (type, 1) == NULL
15683       || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15684     return;
15685
15686   /* Find the type of the method.  */
15687   pfn_type = TYPE_FIELD_TYPE (type, 0);
15688   if (pfn_type == NULL
15689       || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15690       || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15691     return;
15692
15693   /* Look for the "this" argument.  */
15694   pfn_type = TYPE_TARGET_TYPE (pfn_type);
15695   if (TYPE_NFIELDS (pfn_type) == 0
15696       /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15697       || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15698     return;
15699
15700   self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15701   new_type = alloc_type (objfile);
15702   smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15703                         TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15704                         TYPE_VARARGS (pfn_type));
15705   smash_to_methodptr_type (type, new_type);
15706 }
15707
15708 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15709    appropriate error checking and issuing complaints if there is a
15710    problem.  */
15711
15712 static ULONGEST
15713 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15714 {
15715   struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15716
15717   if (attr == nullptr)
15718     return 0;
15719
15720   if (!attr_form_is_constant (attr))
15721     {
15722       complaint (_("DW_AT_alignment must have constant form"
15723                    " - DIE at %s [in module %s]"),
15724                  sect_offset_str (die->sect_off),
15725                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15726       return 0;
15727     }
15728
15729   ULONGEST align;
15730   if (attr->form == DW_FORM_sdata)
15731     {
15732       LONGEST val = DW_SND (attr);
15733       if (val < 0)
15734         {
15735           complaint (_("DW_AT_alignment value must not be negative"
15736                        " - DIE at %s [in module %s]"),
15737                      sect_offset_str (die->sect_off),
15738                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15739           return 0;
15740         }
15741       align = val;
15742     }
15743   else
15744     align = DW_UNSND (attr);
15745
15746   if (align == 0)
15747     {
15748       complaint (_("DW_AT_alignment value must not be zero"
15749                    " - DIE at %s [in module %s]"),
15750                  sect_offset_str (die->sect_off),
15751                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15752       return 0;
15753     }
15754   if ((align & (align - 1)) != 0)
15755     {
15756       complaint (_("DW_AT_alignment value must be a power of 2"
15757                    " - DIE at %s [in module %s]"),
15758                  sect_offset_str (die->sect_off),
15759                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15760       return 0;
15761     }
15762
15763   return align;
15764 }
15765
15766 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15767    the alignment for TYPE.  */
15768
15769 static void
15770 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15771                      struct type *type)
15772 {
15773   if (!set_type_align (type, get_alignment (cu, die)))
15774     complaint (_("DW_AT_alignment value too large"
15775                  " - DIE at %s [in module %s]"),
15776                sect_offset_str (die->sect_off),
15777                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15778 }
15779
15780 /* Called when we find the DIE that starts a structure or union scope
15781    (definition) to create a type for the structure or union.  Fill in
15782    the type's name and general properties; the members will not be
15783    processed until process_structure_scope.  A symbol table entry for
15784    the type will also not be done until process_structure_scope (assuming
15785    the type has a name).
15786
15787    NOTE: we need to call these functions regardless of whether or not the
15788    DIE has a DW_AT_name attribute, since it might be an anonymous
15789    structure or union.  This gets the type entered into our set of
15790    user defined types.  */
15791
15792 static struct type *
15793 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15794 {
15795   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15796   struct type *type;
15797   struct attribute *attr;
15798   const char *name;
15799
15800   /* If the definition of this type lives in .debug_types, read that type.
15801      Don't follow DW_AT_specification though, that will take us back up
15802      the chain and we want to go down.  */
15803   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15804   if (attr)
15805     {
15806       type = get_DW_AT_signature_type (die, attr, cu);
15807
15808       /* The type's CU may not be the same as CU.
15809          Ensure TYPE is recorded with CU in die_type_hash.  */
15810       return set_die_type (die, type, cu);
15811     }
15812
15813   type = alloc_type (objfile);
15814   INIT_CPLUS_SPECIFIC (type);
15815
15816   name = dwarf2_name (die, cu);
15817   if (name != NULL)
15818     {
15819       if (cu->language == language_cplus
15820           || cu->language == language_d
15821           || cu->language == language_rust)
15822         {
15823           const char *full_name = dwarf2_full_name (name, die, cu);
15824
15825           /* dwarf2_full_name might have already finished building the DIE's
15826              type.  If so, there is no need to continue.  */
15827           if (get_die_type (die, cu) != NULL)
15828             return get_die_type (die, cu);
15829
15830           TYPE_NAME (type) = full_name;
15831         }
15832       else
15833         {
15834           /* The name is already allocated along with this objfile, so
15835              we don't need to duplicate it for the type.  */
15836           TYPE_NAME (type) = name;
15837         }
15838     }
15839
15840   if (die->tag == DW_TAG_structure_type)
15841     {
15842       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15843     }
15844   else if (die->tag == DW_TAG_union_type)
15845     {
15846       TYPE_CODE (type) = TYPE_CODE_UNION;
15847     }
15848   else if (die->tag == DW_TAG_variant_part)
15849     {
15850       TYPE_CODE (type) = TYPE_CODE_UNION;
15851       TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15852     }
15853   else
15854     {
15855       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15856     }
15857
15858   if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15859     TYPE_DECLARED_CLASS (type) = 1;
15860
15861   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15862   if (attr)
15863     {
15864       if (attr_form_is_constant (attr))
15865         TYPE_LENGTH (type) = DW_UNSND (attr);
15866       else
15867         {
15868           /* For the moment, dynamic type sizes are not supported
15869              by GDB's struct type.  The actual size is determined
15870              on-demand when resolving the type of a given object,
15871              so set the type's length to zero for now.  Otherwise,
15872              we record an expression as the length, and that expression
15873              could lead to a very large value, which could eventually
15874              lead to us trying to allocate that much memory when creating
15875              a value of that type.  */
15876           TYPE_LENGTH (type) = 0;
15877         }
15878     }
15879   else
15880     {
15881       TYPE_LENGTH (type) = 0;
15882     }
15883
15884   maybe_set_alignment (cu, die, type);
15885
15886   if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15887     {
15888       /* ICC<14 does not output the required DW_AT_declaration on
15889          incomplete types, but gives them a size of zero.  */
15890       TYPE_STUB (type) = 1;
15891     }
15892   else
15893     TYPE_STUB_SUPPORTED (type) = 1;
15894
15895   if (die_is_declaration (die, cu))
15896     TYPE_STUB (type) = 1;
15897   else if (attr == NULL && die->child == NULL
15898            && producer_is_realview (cu->producer))
15899     /* RealView does not output the required DW_AT_declaration
15900        on incomplete types.  */
15901     TYPE_STUB (type) = 1;
15902
15903   /* We need to add the type field to the die immediately so we don't
15904      infinitely recurse when dealing with pointers to the structure
15905      type within the structure itself.  */
15906   set_die_type (die, type, cu);
15907
15908   /* set_die_type should be already done.  */
15909   set_descriptive_type (type, die, cu);
15910
15911   return type;
15912 }
15913
15914 /* A helper for process_structure_scope that handles a single member
15915    DIE.  */
15916
15917 static void
15918 handle_struct_member_die (struct die_info *child_die, struct type *type,
15919                           struct field_info *fi,
15920                           std::vector<struct symbol *> *template_args,
15921                           struct dwarf2_cu *cu)
15922 {
15923   if (child_die->tag == DW_TAG_member
15924       || child_die->tag == DW_TAG_variable
15925       || child_die->tag == DW_TAG_variant_part)
15926     {
15927       /* NOTE: carlton/2002-11-05: A C++ static data member
15928          should be a DW_TAG_member that is a declaration, but
15929          all versions of G++ as of this writing (so through at
15930          least 3.2.1) incorrectly generate DW_TAG_variable
15931          tags for them instead.  */
15932       dwarf2_add_field (fi, child_die, cu);
15933     }
15934   else if (child_die->tag == DW_TAG_subprogram)
15935     {
15936       /* Rust doesn't have member functions in the C++ sense.
15937          However, it does emit ordinary functions as children
15938          of a struct DIE.  */
15939       if (cu->language == language_rust)
15940         read_func_scope (child_die, cu);
15941       else
15942         {
15943           /* C++ member function.  */
15944           dwarf2_add_member_fn (fi, child_die, type, cu);
15945         }
15946     }
15947   else if (child_die->tag == DW_TAG_inheritance)
15948     {
15949       /* C++ base class field.  */
15950       dwarf2_add_field (fi, child_die, cu);
15951     }
15952   else if (type_can_define_types (child_die))
15953     dwarf2_add_type_defn (fi, child_die, cu);
15954   else if (child_die->tag == DW_TAG_template_type_param
15955            || child_die->tag == DW_TAG_template_value_param)
15956     {
15957       struct symbol *arg = new_symbol (child_die, NULL, cu);
15958
15959       if (arg != NULL)
15960         template_args->push_back (arg);
15961     }
15962   else if (child_die->tag == DW_TAG_variant)
15963     {
15964       /* In a variant we want to get the discriminant and also add a
15965          field for our sole member child.  */
15966       struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15967
15968       for (struct die_info *variant_child = child_die->child;
15969            variant_child != NULL;
15970            variant_child = sibling_die (variant_child))
15971         {
15972           if (variant_child->tag == DW_TAG_member)
15973             {
15974               handle_struct_member_die (variant_child, type, fi,
15975                                         template_args, cu);
15976               /* Only handle the one.  */
15977               break;
15978             }
15979         }
15980
15981       /* We don't handle this but we might as well report it if we see
15982          it.  */
15983       if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15984           complaint (_("DW_AT_discr_list is not supported yet"
15985                        " - DIE at %s [in module %s]"),
15986                      sect_offset_str (child_die->sect_off),
15987                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15988
15989       /* The first field was just added, so we can stash the
15990          discriminant there.  */
15991       gdb_assert (!fi->fields.empty ());
15992       if (discr == NULL)
15993         fi->fields.back ().variant.default_branch = true;
15994       else
15995         fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15996     }
15997 }
15998
15999 /* Finish creating a structure or union type, including filling in
16000    its members and creating a symbol for it.  */
16001
16002 static void
16003 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
16004 {
16005   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16006   struct die_info *child_die;
16007   struct type *type;
16008
16009   type = get_die_type (die, cu);
16010   if (type == NULL)
16011     type = read_structure_type (die, cu);
16012
16013   /* When reading a DW_TAG_variant_part, we need to notice when we
16014      read the discriminant member, so we can record it later in the
16015      discriminant_info.  */
16016   bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16017   sect_offset discr_offset;
16018   bool has_template_parameters = false;
16019
16020   if (is_variant_part)
16021     {
16022       struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16023       if (discr == NULL)
16024         {
16025           /* Maybe it's a univariant form, an extension we support.
16026              In this case arrange not to check the offset.  */
16027           is_variant_part = false;
16028         }
16029       else if (attr_form_is_ref (discr))
16030         {
16031           struct dwarf2_cu *target_cu = cu;
16032           struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16033
16034           discr_offset = target_die->sect_off;
16035         }
16036       else
16037         {
16038           complaint (_("DW_AT_discr does not have DIE reference form"
16039                        " - DIE at %s [in module %s]"),
16040                      sect_offset_str (die->sect_off),
16041                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16042           is_variant_part = false;
16043         }
16044     }
16045
16046   if (die->child != NULL && ! die_is_declaration (die, cu))
16047     {
16048       struct field_info fi;
16049       std::vector<struct symbol *> template_args;
16050
16051       child_die = die->child;
16052
16053       while (child_die && child_die->tag)
16054         {
16055           handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16056
16057           if (is_variant_part && discr_offset == child_die->sect_off)
16058             fi.fields.back ().variant.is_discriminant = true;
16059
16060           child_die = sibling_die (child_die);
16061         }
16062
16063       /* Attach template arguments to type.  */
16064       if (!template_args.empty ())
16065         {
16066           has_template_parameters = true;
16067           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16068           TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16069           TYPE_TEMPLATE_ARGUMENTS (type)
16070             = XOBNEWVEC (&objfile->objfile_obstack,
16071                          struct symbol *,
16072                          TYPE_N_TEMPLATE_ARGUMENTS (type));
16073           memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16074                   template_args.data (),
16075                   (TYPE_N_TEMPLATE_ARGUMENTS (type)
16076                    * sizeof (struct symbol *)));
16077         }
16078
16079       /* Attach fields and member functions to the type.  */
16080       if (fi.nfields)
16081         dwarf2_attach_fields_to_type (&fi, type, cu);
16082       if (!fi.fnfieldlists.empty ())
16083         {
16084           dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16085
16086           /* Get the type which refers to the base class (possibly this
16087              class itself) which contains the vtable pointer for the current
16088              class from the DW_AT_containing_type attribute.  This use of
16089              DW_AT_containing_type is a GNU extension.  */
16090
16091           if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16092             {
16093               struct type *t = die_containing_type (die, cu);
16094
16095               set_type_vptr_basetype (type, t);
16096               if (type == t)
16097                 {
16098                   int i;
16099
16100                   /* Our own class provides vtbl ptr.  */
16101                   for (i = TYPE_NFIELDS (t) - 1;
16102                        i >= TYPE_N_BASECLASSES (t);
16103                        --i)
16104                     {
16105                       const char *fieldname = TYPE_FIELD_NAME (t, i);
16106
16107                       if (is_vtable_name (fieldname, cu))
16108                         {
16109                           set_type_vptr_fieldno (type, i);
16110                           break;
16111                         }
16112                     }
16113
16114                   /* Complain if virtual function table field not found.  */
16115                   if (i < TYPE_N_BASECLASSES (t))
16116                     complaint (_("virtual function table pointer "
16117                                  "not found when defining class '%s'"),
16118                                TYPE_NAME (type) ? TYPE_NAME (type) : "");
16119                 }
16120               else
16121                 {
16122                   set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16123                 }
16124             }
16125           else if (cu->producer
16126                    && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16127             {
16128               /* The IBM XLC compiler does not provide direct indication
16129                  of the containing type, but the vtable pointer is
16130                  always named __vfp.  */
16131
16132               int i;
16133
16134               for (i = TYPE_NFIELDS (type) - 1;
16135                    i >= TYPE_N_BASECLASSES (type);
16136                    --i)
16137                 {
16138                   if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16139                     {
16140                       set_type_vptr_fieldno (type, i);
16141                       set_type_vptr_basetype (type, type);
16142                       break;
16143                     }
16144                 }
16145             }
16146         }
16147
16148       /* Copy fi.typedef_field_list linked list elements content into the
16149          allocated array TYPE_TYPEDEF_FIELD_ARRAY (type).  */
16150       if (!fi.typedef_field_list.empty ())
16151         {
16152           int count = fi.typedef_field_list.size ();
16153
16154           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16155           TYPE_TYPEDEF_FIELD_ARRAY (type)
16156             = ((struct decl_field *)
16157                TYPE_ALLOC (type,
16158                            sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16159           TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16160
16161           for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16162             TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16163         }
16164
16165       /* Copy fi.nested_types_list linked list elements content into the
16166          allocated array TYPE_NESTED_TYPES_ARRAY (type).  */
16167       if (!fi.nested_types_list.empty () && cu->language != language_ada)
16168         {
16169           int count = fi.nested_types_list.size ();
16170
16171           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16172           TYPE_NESTED_TYPES_ARRAY (type)
16173             = ((struct decl_field *)
16174                TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16175           TYPE_NESTED_TYPES_COUNT (type) = count;
16176
16177           for (int i = 0; i < fi.nested_types_list.size (); ++i)
16178             TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16179         }
16180     }
16181
16182   quirk_gcc_member_function_pointer (type, objfile);
16183   if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16184     cu->rust_unions.push_back (type);
16185
16186   /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16187      snapshots) has been known to create a die giving a declaration
16188      for a class that has, as a child, a die giving a definition for a
16189      nested class.  So we have to process our children even if the
16190      current die is a declaration.  Normally, of course, a declaration
16191      won't have any children at all.  */
16192
16193   child_die = die->child;
16194
16195   while (child_die != NULL && child_die->tag)
16196     {
16197       if (child_die->tag == DW_TAG_member
16198           || child_die->tag == DW_TAG_variable
16199           || child_die->tag == DW_TAG_inheritance
16200           || child_die->tag == DW_TAG_template_value_param
16201           || child_die->tag == DW_TAG_template_type_param)
16202         {
16203           /* Do nothing.  */
16204         }
16205       else
16206         process_die (child_die, cu);
16207
16208       child_die = sibling_die (child_die);
16209     }
16210
16211   /* Do not consider external references.  According to the DWARF standard,
16212      these DIEs are identified by the fact that they have no byte_size
16213      attribute, and a declaration attribute.  */
16214   if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16215       || !die_is_declaration (die, cu))
16216     {
16217       struct symbol *sym = new_symbol (die, type, cu);
16218
16219       if (has_template_parameters)
16220         {
16221           struct symtab *symtab;
16222           if (sym != nullptr)
16223             symtab = symbol_symtab (sym);
16224           else if (cu->line_header != nullptr)
16225             {
16226               /* Any related symtab will do.  */
16227               symtab
16228                 = cu->line_header->file_name_at (file_name_index (1))->symtab;
16229             }
16230           else
16231             {
16232               symtab = nullptr;
16233               complaint (_("could not find suitable "
16234                            "symtab for template parameter"
16235                            " - DIE at %s [in module %s]"),
16236                          sect_offset_str (die->sect_off),
16237                          objfile_name (objfile));
16238             }
16239
16240           if (symtab != nullptr)
16241             {
16242               /* Make sure that the symtab is set on the new symbols.
16243                  Even though they don't appear in this symtab directly,
16244                  other parts of gdb assume that symbols do, and this is
16245                  reasonably true.  */
16246               for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16247                 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i), symtab);
16248             }
16249         }
16250     }
16251 }
16252
16253 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16254    update TYPE using some information only available in DIE's children.  */
16255
16256 static void
16257 update_enumeration_type_from_children (struct die_info *die,
16258                                        struct type *type,
16259                                        struct dwarf2_cu *cu)
16260 {
16261   struct die_info *child_die;
16262   int unsigned_enum = 1;
16263   int flag_enum = 1;
16264   ULONGEST mask = 0;
16265
16266   auto_obstack obstack;
16267
16268   for (child_die = die->child;
16269        child_die != NULL && child_die->tag;
16270        child_die = sibling_die (child_die))
16271     {
16272       struct attribute *attr;
16273       LONGEST value;
16274       const gdb_byte *bytes;
16275       struct dwarf2_locexpr_baton *baton;
16276       const char *name;
16277
16278       if (child_die->tag != DW_TAG_enumerator)
16279         continue;
16280
16281       attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16282       if (attr == NULL)
16283         continue;
16284
16285       name = dwarf2_name (child_die, cu);
16286       if (name == NULL)
16287         name = "<anonymous enumerator>";
16288
16289       dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16290                                &value, &bytes, &baton);
16291       if (value < 0)
16292         {
16293           unsigned_enum = 0;
16294           flag_enum = 0;
16295         }
16296       else if ((mask & value) != 0)
16297         flag_enum = 0;
16298       else
16299         mask |= value;
16300
16301       /* If we already know that the enum type is neither unsigned, nor
16302          a flag type, no need to look at the rest of the enumerates.  */
16303       if (!unsigned_enum && !flag_enum)
16304         break;
16305     }
16306
16307   if (unsigned_enum)
16308     TYPE_UNSIGNED (type) = 1;
16309   if (flag_enum)
16310     TYPE_FLAG_ENUM (type) = 1;
16311 }
16312
16313 /* Given a DW_AT_enumeration_type die, set its type.  We do not
16314    complete the type's fields yet, or create any symbols.  */
16315
16316 static struct type *
16317 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16318 {
16319   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16320   struct type *type;
16321   struct attribute *attr;
16322   const char *name;
16323
16324   /* If the definition of this type lives in .debug_types, read that type.
16325      Don't follow DW_AT_specification though, that will take us back up
16326      the chain and we want to go down.  */
16327   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16328   if (attr)
16329     {
16330       type = get_DW_AT_signature_type (die, attr, cu);
16331
16332       /* The type's CU may not be the same as CU.
16333          Ensure TYPE is recorded with CU in die_type_hash.  */
16334       return set_die_type (die, type, cu);
16335     }
16336
16337   type = alloc_type (objfile);
16338
16339   TYPE_CODE (type) = TYPE_CODE_ENUM;
16340   name = dwarf2_full_name (NULL, die, cu);
16341   if (name != NULL)
16342     TYPE_NAME (type) = name;
16343
16344   attr = dwarf2_attr (die, DW_AT_type, cu);
16345   if (attr != NULL)
16346     {
16347       struct type *underlying_type = die_type (die, cu);
16348
16349       TYPE_TARGET_TYPE (type) = underlying_type;
16350     }
16351
16352   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16353   if (attr)
16354     {
16355       TYPE_LENGTH (type) = DW_UNSND (attr);
16356     }
16357   else
16358     {
16359       TYPE_LENGTH (type) = 0;
16360     }
16361
16362   maybe_set_alignment (cu, die, type);
16363
16364   /* The enumeration DIE can be incomplete.  In Ada, any type can be
16365      declared as private in the package spec, and then defined only
16366      inside the package body.  Such types are known as Taft Amendment
16367      Types.  When another package uses such a type, an incomplete DIE
16368      may be generated by the compiler.  */
16369   if (die_is_declaration (die, cu))
16370     TYPE_STUB (type) = 1;
16371
16372   /* Finish the creation of this type by using the enum's children.
16373      We must call this even when the underlying type has been provided
16374      so that we can determine if we're looking at a "flag" enum.  */
16375   update_enumeration_type_from_children (die, type, cu);
16376
16377   /* If this type has an underlying type that is not a stub, then we
16378      may use its attributes.  We always use the "unsigned" attribute
16379      in this situation, because ordinarily we guess whether the type
16380      is unsigned -- but the guess can be wrong and the underlying type
16381      can tell us the reality.  However, we defer to a local size
16382      attribute if one exists, because this lets the compiler override
16383      the underlying type if needed.  */
16384   if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16385     {
16386       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16387       if (TYPE_LENGTH (type) == 0)
16388         TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16389       if (TYPE_RAW_ALIGN (type) == 0
16390           && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16391         set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16392     }
16393
16394   TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16395
16396   return set_die_type (die, type, cu);
16397 }
16398
16399 /* Given a pointer to a die which begins an enumeration, process all
16400    the dies that define the members of the enumeration, and create the
16401    symbol for the enumeration type.
16402
16403    NOTE: We reverse the order of the element list.  */
16404
16405 static void
16406 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16407 {
16408   struct type *this_type;
16409
16410   this_type = get_die_type (die, cu);
16411   if (this_type == NULL)
16412     this_type = read_enumeration_type (die, cu);
16413
16414   if (die->child != NULL)
16415     {
16416       struct die_info *child_die;
16417       struct symbol *sym;
16418       struct field *fields = NULL;
16419       int num_fields = 0;
16420       const char *name;
16421
16422       child_die = die->child;
16423       while (child_die && child_die->tag)
16424         {
16425           if (child_die->tag != DW_TAG_enumerator)
16426             {
16427               process_die (child_die, cu);
16428             }
16429           else
16430             {
16431               name = dwarf2_name (child_die, cu);
16432               if (name)
16433                 {
16434                   sym = new_symbol (child_die, this_type, cu);
16435
16436                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16437                     {
16438                       fields = (struct field *)
16439                         xrealloc (fields,
16440                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
16441                                   * sizeof (struct field));
16442                     }
16443
16444                   FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16445                   FIELD_TYPE (fields[num_fields]) = NULL;
16446                   SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16447                   FIELD_BITSIZE (fields[num_fields]) = 0;
16448
16449                   num_fields++;
16450                 }
16451             }
16452
16453           child_die = sibling_die (child_die);
16454         }
16455
16456       if (num_fields)
16457         {
16458           TYPE_NFIELDS (this_type) = num_fields;
16459           TYPE_FIELDS (this_type) = (struct field *)
16460             TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16461           memcpy (TYPE_FIELDS (this_type), fields,
16462                   sizeof (struct field) * num_fields);
16463           xfree (fields);
16464         }
16465     }
16466
16467   /* If we are reading an enum from a .debug_types unit, and the enum
16468      is a declaration, and the enum is not the signatured type in the
16469      unit, then we do not want to add a symbol for it.  Adding a
16470      symbol would in some cases obscure the true definition of the
16471      enum, giving users an incomplete type when the definition is
16472      actually available.  Note that we do not want to do this for all
16473      enums which are just declarations, because C++0x allows forward
16474      enum declarations.  */
16475   if (cu->per_cu->is_debug_types
16476       && die_is_declaration (die, cu))
16477     {
16478       struct signatured_type *sig_type;
16479
16480       sig_type = (struct signatured_type *) cu->per_cu;
16481       gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16482       if (sig_type->type_offset_in_section != die->sect_off)
16483         return;
16484     }
16485
16486   new_symbol (die, this_type, cu);
16487 }
16488
16489 /* Extract all information from a DW_TAG_array_type DIE and put it in
16490    the DIE's type field.  For now, this only handles one dimensional
16491    arrays.  */
16492
16493 static struct type *
16494 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16495 {
16496   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16497   struct die_info *child_die;
16498   struct type *type;
16499   struct type *element_type, *range_type, *index_type;
16500   struct attribute *attr;
16501   const char *name;
16502   struct dynamic_prop *byte_stride_prop = NULL;
16503   unsigned int bit_stride = 0;
16504
16505   element_type = die_type (die, cu);
16506
16507   /* The die_type call above may have already set the type for this DIE.  */
16508   type = get_die_type (die, cu);
16509   if (type)
16510     return type;
16511
16512   attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16513   if (attr != NULL)
16514     {
16515       int stride_ok;
16516
16517       byte_stride_prop
16518         = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16519       stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16520       if (!stride_ok)
16521         {
16522           complaint (_("unable to read array DW_AT_byte_stride "
16523                        " - DIE at %s [in module %s]"),
16524                      sect_offset_str (die->sect_off),
16525                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16526           /* Ignore this attribute.  We will likely not be able to print
16527              arrays of this type correctly, but there is little we can do
16528              to help if we cannot read the attribute's value.  */
16529           byte_stride_prop = NULL;
16530         }
16531     }
16532
16533   attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16534   if (attr != NULL)
16535     bit_stride = DW_UNSND (attr);
16536
16537   /* Irix 6.2 native cc creates array types without children for
16538      arrays with unspecified length.  */
16539   if (die->child == NULL)
16540     {
16541       index_type = objfile_type (objfile)->builtin_int;
16542       range_type = create_static_range_type (NULL, index_type, 0, -1);
16543       type = create_array_type_with_stride (NULL, element_type, range_type,
16544                                             byte_stride_prop, bit_stride);
16545       return set_die_type (die, type, cu);
16546     }
16547
16548   std::vector<struct type *> range_types;
16549   child_die = die->child;
16550   while (child_die && child_die->tag)
16551     {
16552       if (child_die->tag == DW_TAG_subrange_type)
16553         {
16554           struct type *child_type = read_type_die (child_die, cu);
16555
16556           if (child_type != NULL)
16557             {
16558               /* The range type was succesfully read.  Save it for the
16559                  array type creation.  */
16560               range_types.push_back (child_type);
16561             }
16562         }
16563       child_die = sibling_die (child_die);
16564     }
16565
16566   /* Dwarf2 dimensions are output from left to right, create the
16567      necessary array types in backwards order.  */
16568
16569   type = element_type;
16570
16571   if (read_array_order (die, cu) == DW_ORD_col_major)
16572     {
16573       int i = 0;
16574
16575       while (i < range_types.size ())
16576         type = create_array_type_with_stride (NULL, type, range_types[i++],
16577                                               byte_stride_prop, bit_stride);
16578     }
16579   else
16580     {
16581       size_t ndim = range_types.size ();
16582       while (ndim-- > 0)
16583         type = create_array_type_with_stride (NULL, type, range_types[ndim],
16584                                               byte_stride_prop, bit_stride);
16585     }
16586
16587   /* Understand Dwarf2 support for vector types (like they occur on
16588      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
16589      array type.  This is not part of the Dwarf2/3 standard yet, but a
16590      custom vendor extension.  The main difference between a regular
16591      array and the vector variant is that vectors are passed by value
16592      to functions.  */
16593   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16594   if (attr)
16595     make_vector_type (type);
16596
16597   /* The DIE may have DW_AT_byte_size set.  For example an OpenCL
16598      implementation may choose to implement triple vectors using this
16599      attribute.  */
16600   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16601   if (attr)
16602     {
16603       if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16604         TYPE_LENGTH (type) = DW_UNSND (attr);
16605       else
16606         complaint (_("DW_AT_byte_size for array type smaller "
16607                      "than the total size of elements"));
16608     }
16609
16610   name = dwarf2_name (die, cu);
16611   if (name)
16612     TYPE_NAME (type) = name;
16613
16614   maybe_set_alignment (cu, die, type);
16615
16616   /* Install the type in the die.  */
16617   set_die_type (die, type, cu);
16618
16619   /* set_die_type should be already done.  */
16620   set_descriptive_type (type, die, cu);
16621
16622   return type;
16623 }
16624
16625 static enum dwarf_array_dim_ordering
16626 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16627 {
16628   struct attribute *attr;
16629
16630   attr = dwarf2_attr (die, DW_AT_ordering, cu);
16631
16632   if (attr)
16633     return (enum dwarf_array_dim_ordering) DW_SND (attr);
16634
16635   /* GNU F77 is a special case, as at 08/2004 array type info is the
16636      opposite order to the dwarf2 specification, but data is still
16637      laid out as per normal fortran.
16638
16639      FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16640      version checking.  */
16641
16642   if (cu->language == language_fortran
16643       && cu->producer && strstr (cu->producer, "GNU F77"))
16644     {
16645       return DW_ORD_row_major;
16646     }
16647
16648   switch (cu->language_defn->la_array_ordering)
16649     {
16650     case array_column_major:
16651       return DW_ORD_col_major;
16652     case array_row_major:
16653     default:
16654       return DW_ORD_row_major;
16655     };
16656 }
16657
16658 /* Extract all information from a DW_TAG_set_type DIE and put it in
16659    the DIE's type field.  */
16660
16661 static struct type *
16662 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16663 {
16664   struct type *domain_type, *set_type;
16665   struct attribute *attr;
16666
16667   domain_type = die_type (die, cu);
16668
16669   /* The die_type call above may have already set the type for this DIE.  */
16670   set_type = get_die_type (die, cu);
16671   if (set_type)
16672     return set_type;
16673
16674   set_type = create_set_type (NULL, domain_type);
16675
16676   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16677   if (attr)
16678     TYPE_LENGTH (set_type) = DW_UNSND (attr);
16679
16680   maybe_set_alignment (cu, die, set_type);
16681
16682   return set_die_type (die, set_type, cu);
16683 }
16684
16685 /* A helper for read_common_block that creates a locexpr baton.
16686    SYM is the symbol which we are marking as computed.
16687    COMMON_DIE is the DIE for the common block.
16688    COMMON_LOC is the location expression attribute for the common
16689    block itself.
16690    MEMBER_LOC is the location expression attribute for the particular
16691    member of the common block that we are processing.
16692    CU is the CU from which the above come.  */
16693
16694 static void
16695 mark_common_block_symbol_computed (struct symbol *sym,
16696                                    struct die_info *common_die,
16697                                    struct attribute *common_loc,
16698                                    struct attribute *member_loc,
16699                                    struct dwarf2_cu *cu)
16700 {
16701   struct dwarf2_per_objfile *dwarf2_per_objfile
16702     = cu->per_cu->dwarf2_per_objfile;
16703   struct objfile *objfile = dwarf2_per_objfile->objfile;
16704   struct dwarf2_locexpr_baton *baton;
16705   gdb_byte *ptr;
16706   unsigned int cu_off;
16707   enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16708   LONGEST offset = 0;
16709
16710   gdb_assert (common_loc && member_loc);
16711   gdb_assert (attr_form_is_block (common_loc));
16712   gdb_assert (attr_form_is_block (member_loc)
16713               || attr_form_is_constant (member_loc));
16714
16715   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16716   baton->per_cu = cu->per_cu;
16717   gdb_assert (baton->per_cu);
16718
16719   baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16720
16721   if (attr_form_is_constant (member_loc))
16722     {
16723       offset = dwarf2_get_attr_constant_value (member_loc, 0);
16724       baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16725     }
16726   else
16727     baton->size += DW_BLOCK (member_loc)->size;
16728
16729   ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16730   baton->data = ptr;
16731
16732   *ptr++ = DW_OP_call4;
16733   cu_off = common_die->sect_off - cu->per_cu->sect_off;
16734   store_unsigned_integer (ptr, 4, byte_order, cu_off);
16735   ptr += 4;
16736
16737   if (attr_form_is_constant (member_loc))
16738     {
16739       *ptr++ = DW_OP_addr;
16740       store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16741       ptr += cu->header.addr_size;
16742     }
16743   else
16744     {
16745       /* We have to copy the data here, because DW_OP_call4 will only
16746          use a DW_AT_location attribute.  */
16747       memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16748       ptr += DW_BLOCK (member_loc)->size;
16749     }
16750
16751   *ptr++ = DW_OP_plus;
16752   gdb_assert (ptr - baton->data == baton->size);
16753
16754   SYMBOL_LOCATION_BATON (sym) = baton;
16755   SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16756 }
16757
16758 /* Create appropriate locally-scoped variables for all the
16759    DW_TAG_common_block entries.  Also create a struct common_block
16760    listing all such variables for `info common'.  COMMON_BLOCK_DOMAIN
16761    is used to sepate the common blocks name namespace from regular
16762    variable names.  */
16763
16764 static void
16765 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16766 {
16767   struct attribute *attr;
16768
16769   attr = dwarf2_attr (die, DW_AT_location, cu);
16770   if (attr)
16771     {
16772       /* Support the .debug_loc offsets.  */
16773       if (attr_form_is_block (attr))
16774         {
16775           /* Ok.  */
16776         }
16777       else if (attr_form_is_section_offset (attr))
16778         {
16779           dwarf2_complex_location_expr_complaint ();
16780           attr = NULL;
16781         }
16782       else
16783         {
16784           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16785                                                  "common block member");
16786           attr = NULL;
16787         }
16788     }
16789
16790   if (die->child != NULL)
16791     {
16792       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16793       struct die_info *child_die;
16794       size_t n_entries = 0, size;
16795       struct common_block *common_block;
16796       struct symbol *sym;
16797
16798       for (child_die = die->child;
16799            child_die && child_die->tag;
16800            child_die = sibling_die (child_die))
16801         ++n_entries;
16802
16803       size = (sizeof (struct common_block)
16804               + (n_entries - 1) * sizeof (struct symbol *));
16805       common_block
16806         = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16807                                                  size);
16808       memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16809       common_block->n_entries = 0;
16810
16811       for (child_die = die->child;
16812            child_die && child_die->tag;
16813            child_die = sibling_die (child_die))
16814         {
16815           /* Create the symbol in the DW_TAG_common_block block in the current
16816              symbol scope.  */
16817           sym = new_symbol (child_die, NULL, cu);
16818           if (sym != NULL)
16819             {
16820               struct attribute *member_loc;
16821
16822               common_block->contents[common_block->n_entries++] = sym;
16823
16824               member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16825                                         cu);
16826               if (member_loc)
16827                 {
16828                   /* GDB has handled this for a long time, but it is
16829                      not specified by DWARF.  It seems to have been
16830                      emitted by gfortran at least as recently as:
16831                      http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057.  */
16832                   complaint (_("Variable in common block has "
16833                                "DW_AT_data_member_location "
16834                                "- DIE at %s [in module %s]"),
16835                                sect_offset_str (child_die->sect_off),
16836                              objfile_name (objfile));
16837
16838                   if (attr_form_is_section_offset (member_loc))
16839                     dwarf2_complex_location_expr_complaint ();
16840                   else if (attr_form_is_constant (member_loc)
16841                            || attr_form_is_block (member_loc))
16842                     {
16843                       if (attr)
16844                         mark_common_block_symbol_computed (sym, die, attr,
16845                                                            member_loc, cu);
16846                     }
16847                   else
16848                     dwarf2_complex_location_expr_complaint ();
16849                 }
16850             }
16851         }
16852
16853       sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16854       SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16855     }
16856 }
16857
16858 /* Create a type for a C++ namespace.  */
16859
16860 static struct type *
16861 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16862 {
16863   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16864   const char *previous_prefix, *name;
16865   int is_anonymous;
16866   struct type *type;
16867
16868   /* For extensions, reuse the type of the original namespace.  */
16869   if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16870     {
16871       struct die_info *ext_die;
16872       struct dwarf2_cu *ext_cu = cu;
16873
16874       ext_die = dwarf2_extension (die, &ext_cu);
16875       type = read_type_die (ext_die, ext_cu);
16876
16877       /* EXT_CU may not be the same as CU.
16878          Ensure TYPE is recorded with CU in die_type_hash.  */
16879       return set_die_type (die, type, cu);
16880     }
16881
16882   name = namespace_name (die, &is_anonymous, cu);
16883
16884   /* Now build the name of the current namespace.  */
16885
16886   previous_prefix = determine_prefix (die, cu);
16887   if (previous_prefix[0] != '\0')
16888     name = typename_concat (&objfile->objfile_obstack,
16889                             previous_prefix, name, 0, cu);
16890
16891   /* Create the type.  */
16892   type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16893
16894   return set_die_type (die, type, cu);
16895 }
16896
16897 /* Read a namespace scope.  */
16898
16899 static void
16900 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16901 {
16902   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16903   int is_anonymous;
16904
16905   /* Add a symbol associated to this if we haven't seen the namespace
16906      before.  Also, add a using directive if it's an anonymous
16907      namespace.  */
16908
16909   if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16910     {
16911       struct type *type;
16912
16913       type = read_type_die (die, cu);
16914       new_symbol (die, type, cu);
16915
16916       namespace_name (die, &is_anonymous, cu);
16917       if (is_anonymous)
16918         {
16919           const char *previous_prefix = determine_prefix (die, cu);
16920
16921           std::vector<const char *> excludes;
16922           add_using_directive (using_directives (cu),
16923                                previous_prefix, TYPE_NAME (type), NULL,
16924                                NULL, excludes, 0, &objfile->objfile_obstack);
16925         }
16926     }
16927
16928   if (die->child != NULL)
16929     {
16930       struct die_info *child_die = die->child;
16931
16932       while (child_die && child_die->tag)
16933         {
16934           process_die (child_die, cu);
16935           child_die = sibling_die (child_die);
16936         }
16937     }
16938 }
16939
16940 /* Read a Fortran module as type.  This DIE can be only a declaration used for
16941    imported module.  Still we need that type as local Fortran "use ... only"
16942    declaration imports depend on the created type in determine_prefix.  */
16943
16944 static struct type *
16945 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16946 {
16947   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16948   const char *module_name;
16949   struct type *type;
16950
16951   module_name = dwarf2_name (die, cu);
16952   if (!module_name)
16953     complaint (_("DW_TAG_module has no name, offset %s"),
16954                sect_offset_str (die->sect_off));
16955   type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16956
16957   return set_die_type (die, type, cu);
16958 }
16959
16960 /* Read a Fortran module.  */
16961
16962 static void
16963 read_module (struct die_info *die, struct dwarf2_cu *cu)
16964 {
16965   struct die_info *child_die = die->child;
16966   struct type *type;
16967
16968   type = read_type_die (die, cu);
16969   new_symbol (die, type, cu);
16970
16971   while (child_die && child_die->tag)
16972     {
16973       process_die (child_die, cu);
16974       child_die = sibling_die (child_die);
16975     }
16976 }
16977
16978 /* Return the name of the namespace represented by DIE.  Set
16979    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16980    namespace.  */
16981
16982 static const char *
16983 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16984 {
16985   struct die_info *current_die;
16986   const char *name = NULL;
16987
16988   /* Loop through the extensions until we find a name.  */
16989
16990   for (current_die = die;
16991        current_die != NULL;
16992        current_die = dwarf2_extension (die, &cu))
16993     {
16994       /* We don't use dwarf2_name here so that we can detect the absence
16995          of a name -> anonymous namespace.  */
16996       name = dwarf2_string_attr (die, DW_AT_name, cu);
16997
16998       if (name != NULL)
16999         break;
17000     }
17001
17002   /* Is it an anonymous namespace?  */
17003
17004   *is_anonymous = (name == NULL);
17005   if (*is_anonymous)
17006     name = CP_ANONYMOUS_NAMESPACE_STR;
17007
17008   return name;
17009 }
17010
17011 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17012    the user defined type vector.  */
17013
17014 static struct type *
17015 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
17016 {
17017   struct gdbarch *gdbarch
17018     = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
17019   struct comp_unit_head *cu_header = &cu->header;
17020   struct type *type;
17021   struct attribute *attr_byte_size;
17022   struct attribute *attr_address_class;
17023   int byte_size, addr_class;
17024   struct type *target_type;
17025
17026   target_type = die_type (die, cu);
17027
17028   /* The die_type call above may have already set the type for this DIE.  */
17029   type = get_die_type (die, cu);
17030   if (type)
17031     return type;
17032
17033   type = lookup_pointer_type (target_type);
17034
17035   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17036   if (attr_byte_size)
17037     byte_size = DW_UNSND (attr_byte_size);
17038   else
17039     byte_size = cu_header->addr_size;
17040
17041   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17042   if (attr_address_class)
17043     addr_class = DW_UNSND (attr_address_class);
17044   else
17045     addr_class = DW_ADDR_none;
17046
17047   ULONGEST alignment = get_alignment (cu, die);
17048
17049   /* If the pointer size, alignment, or address class is different
17050      than the default, create a type variant marked as such and set
17051      the length accordingly.  */
17052   if (TYPE_LENGTH (type) != byte_size
17053       || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17054           && alignment != TYPE_RAW_ALIGN (type))
17055       || addr_class != DW_ADDR_none)
17056     {
17057       if (gdbarch_address_class_type_flags_p (gdbarch))
17058         {
17059           int type_flags;
17060
17061           type_flags = gdbarch_address_class_type_flags
17062                          (gdbarch, byte_size, addr_class);
17063           gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17064                       == 0);
17065           type = make_type_with_address_space (type, type_flags);
17066         }
17067       else if (TYPE_LENGTH (type) != byte_size)
17068         {
17069           complaint (_("invalid pointer size %d"), byte_size);
17070         }
17071       else if (TYPE_RAW_ALIGN (type) != alignment)
17072         {
17073           complaint (_("Invalid DW_AT_alignment"
17074                        " - DIE at %s [in module %s]"),
17075                      sect_offset_str (die->sect_off),
17076                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17077         }
17078       else
17079         {
17080           /* Should we also complain about unhandled address classes?  */
17081         }
17082     }
17083
17084   TYPE_LENGTH (type) = byte_size;
17085   set_type_align (type, alignment);
17086   return set_die_type (die, type, cu);
17087 }
17088
17089 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17090    the user defined type vector.  */
17091
17092 static struct type *
17093 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17094 {
17095   struct type *type;
17096   struct type *to_type;
17097   struct type *domain;
17098
17099   to_type = die_type (die, cu);
17100   domain = die_containing_type (die, cu);
17101
17102   /* The calls above may have already set the type for this DIE.  */
17103   type = get_die_type (die, cu);
17104   if (type)
17105     return type;
17106
17107   if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17108     type = lookup_methodptr_type (to_type);
17109   else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17110     {
17111       struct type *new_type
17112         = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17113
17114       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17115                             TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17116                             TYPE_VARARGS (to_type));
17117       type = lookup_methodptr_type (new_type);
17118     }
17119   else
17120     type = lookup_memberptr_type (to_type, domain);
17121
17122   return set_die_type (die, type, cu);
17123 }
17124
17125 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17126    the user defined type vector.  */
17127
17128 static struct type *
17129 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17130                           enum type_code refcode)
17131 {
17132   struct comp_unit_head *cu_header = &cu->header;
17133   struct type *type, *target_type;
17134   struct attribute *attr;
17135
17136   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17137
17138   target_type = die_type (die, cu);
17139
17140   /* The die_type call above may have already set the type for this DIE.  */
17141   type = get_die_type (die, cu);
17142   if (type)
17143     return type;
17144
17145   type = lookup_reference_type (target_type, refcode);
17146   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17147   if (attr)
17148     {
17149       TYPE_LENGTH (type) = DW_UNSND (attr);
17150     }
17151   else
17152     {
17153       TYPE_LENGTH (type) = cu_header->addr_size;
17154     }
17155   maybe_set_alignment (cu, die, type);
17156   return set_die_type (die, type, cu);
17157 }
17158
17159 /* Add the given cv-qualifiers to the element type of the array.  GCC
17160    outputs DWARF type qualifiers that apply to an array, not the
17161    element type.  But GDB relies on the array element type to carry
17162    the cv-qualifiers.  This mimics section 6.7.3 of the C99
17163    specification.  */
17164
17165 static struct type *
17166 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17167                    struct type *base_type, int cnst, int voltl)
17168 {
17169   struct type *el_type, *inner_array;
17170
17171   base_type = copy_type (base_type);
17172   inner_array = base_type;
17173
17174   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17175     {
17176       TYPE_TARGET_TYPE (inner_array) =
17177         copy_type (TYPE_TARGET_TYPE (inner_array));
17178       inner_array = TYPE_TARGET_TYPE (inner_array);
17179     }
17180
17181   el_type = TYPE_TARGET_TYPE (inner_array);
17182   cnst |= TYPE_CONST (el_type);
17183   voltl |= TYPE_VOLATILE (el_type);
17184   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17185
17186   return set_die_type (die, base_type, cu);
17187 }
17188
17189 static struct type *
17190 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17191 {
17192   struct type *base_type, *cv_type;
17193
17194   base_type = die_type (die, cu);
17195
17196   /* The die_type call above may have already set the type for this DIE.  */
17197   cv_type = get_die_type (die, cu);
17198   if (cv_type)
17199     return cv_type;
17200
17201   /* In case the const qualifier is applied to an array type, the element type
17202      is so qualified, not the array type (section 6.7.3 of C99).  */
17203   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17204     return add_array_cv_type (die, cu, base_type, 1, 0);
17205
17206   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17207   return set_die_type (die, cv_type, cu);
17208 }
17209
17210 static struct type *
17211 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17212 {
17213   struct type *base_type, *cv_type;
17214
17215   base_type = die_type (die, cu);
17216
17217   /* The die_type call above may have already set the type for this DIE.  */
17218   cv_type = get_die_type (die, cu);
17219   if (cv_type)
17220     return cv_type;
17221
17222   /* In case the volatile qualifier is applied to an array type, the
17223      element type is so qualified, not the array type (section 6.7.3
17224      of C99).  */
17225   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17226     return add_array_cv_type (die, cu, base_type, 0, 1);
17227
17228   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17229   return set_die_type (die, cv_type, cu);
17230 }
17231
17232 /* Handle DW_TAG_restrict_type.  */
17233
17234 static struct type *
17235 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17236 {
17237   struct type *base_type, *cv_type;
17238
17239   base_type = die_type (die, cu);
17240
17241   /* The die_type call above may have already set the type for this DIE.  */
17242   cv_type = get_die_type (die, cu);
17243   if (cv_type)
17244     return cv_type;
17245
17246   cv_type = make_restrict_type (base_type);
17247   return set_die_type (die, cv_type, cu);
17248 }
17249
17250 /* Handle DW_TAG_atomic_type.  */
17251
17252 static struct type *
17253 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17254 {
17255   struct type *base_type, *cv_type;
17256
17257   base_type = die_type (die, cu);
17258
17259   /* The die_type call above may have already set the type for this DIE.  */
17260   cv_type = get_die_type (die, cu);
17261   if (cv_type)
17262     return cv_type;
17263
17264   cv_type = make_atomic_type (base_type);
17265   return set_die_type (die, cv_type, cu);
17266 }
17267
17268 /* Extract all information from a DW_TAG_string_type DIE and add to
17269    the user defined type vector.  It isn't really a user defined type,
17270    but it behaves like one, with other DIE's using an AT_user_def_type
17271    attribute to reference it.  */
17272
17273 static struct type *
17274 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17275 {
17276   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17277   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17278   struct type *type, *range_type, *index_type, *char_type;
17279   struct attribute *attr;
17280   unsigned int length;
17281
17282   attr = dwarf2_attr (die, DW_AT_string_length, cu);
17283   if (attr)
17284     {
17285       length = DW_UNSND (attr);
17286     }
17287   else
17288     {
17289       /* Check for the DW_AT_byte_size attribute.  */
17290       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17291       if (attr)
17292         {
17293           length = DW_UNSND (attr);
17294         }
17295       else
17296         {
17297           length = 1;
17298         }
17299     }
17300
17301   index_type = objfile_type (objfile)->builtin_int;
17302   range_type = create_static_range_type (NULL, index_type, 1, length);
17303   char_type = language_string_char_type (cu->language_defn, gdbarch);
17304   type = create_string_type (NULL, char_type, range_type);
17305
17306   return set_die_type (die, type, cu);
17307 }
17308
17309 /* Assuming that DIE corresponds to a function, returns nonzero
17310    if the function is prototyped.  */
17311
17312 static int
17313 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17314 {
17315   struct attribute *attr;
17316
17317   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17318   if (attr && (DW_UNSND (attr) != 0))
17319     return 1;
17320
17321   /* The DWARF standard implies that the DW_AT_prototyped attribute
17322      is only meaninful for C, but the concept also extends to other
17323      languages that allow unprototyped functions (Eg: Objective C).
17324      For all other languages, assume that functions are always
17325      prototyped.  */
17326   if (cu->language != language_c
17327       && cu->language != language_objc
17328       && cu->language != language_opencl)
17329     return 1;
17330
17331   /* RealView does not emit DW_AT_prototyped.  We can not distinguish
17332      prototyped and unprototyped functions; default to prototyped,
17333      since that is more common in modern code (and RealView warns
17334      about unprototyped functions).  */
17335   if (producer_is_realview (cu->producer))
17336     return 1;
17337
17338   return 0;
17339 }
17340
17341 /* Handle DIES due to C code like:
17342
17343    struct foo
17344    {
17345    int (*funcp)(int a, long l);
17346    int b;
17347    };
17348
17349    ('funcp' generates a DW_TAG_subroutine_type DIE).  */
17350
17351 static struct type *
17352 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17353 {
17354   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17355   struct type *type;            /* Type that this function returns.  */
17356   struct type *ftype;           /* Function that returns above type.  */
17357   struct attribute *attr;
17358
17359   type = die_type (die, cu);
17360
17361   /* The die_type call above may have already set the type for this DIE.  */
17362   ftype = get_die_type (die, cu);
17363   if (ftype)
17364     return ftype;
17365
17366   ftype = lookup_function_type (type);
17367
17368   if (prototyped_function_p (die, cu))
17369     TYPE_PROTOTYPED (ftype) = 1;
17370
17371   /* Store the calling convention in the type if it's available in
17372      the subroutine die.  Otherwise set the calling convention to
17373      the default value DW_CC_normal.  */
17374   attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17375   if (attr)
17376     TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17377   else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17378     TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17379   else
17380     TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17381
17382   /* Record whether the function returns normally to its caller or not
17383      if the DWARF producer set that information.  */
17384   attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17385   if (attr && (DW_UNSND (attr) != 0))
17386     TYPE_NO_RETURN (ftype) = 1;
17387
17388   /* We need to add the subroutine type to the die immediately so
17389      we don't infinitely recurse when dealing with parameters
17390      declared as the same subroutine type.  */
17391   set_die_type (die, ftype, cu);
17392
17393   if (die->child != NULL)
17394     {
17395       struct type *void_type = objfile_type (objfile)->builtin_void;
17396       struct die_info *child_die;
17397       int nparams, iparams;
17398
17399       /* Count the number of parameters.
17400          FIXME: GDB currently ignores vararg functions, but knows about
17401          vararg member functions.  */
17402       nparams = 0;
17403       child_die = die->child;
17404       while (child_die && child_die->tag)
17405         {
17406           if (child_die->tag == DW_TAG_formal_parameter)
17407             nparams++;
17408           else if (child_die->tag == DW_TAG_unspecified_parameters)
17409             TYPE_VARARGS (ftype) = 1;
17410           child_die = sibling_die (child_die);
17411         }
17412
17413       /* Allocate storage for parameters and fill them in.  */
17414       TYPE_NFIELDS (ftype) = nparams;
17415       TYPE_FIELDS (ftype) = (struct field *)
17416         TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17417
17418       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
17419          even if we error out during the parameters reading below.  */
17420       for (iparams = 0; iparams < nparams; iparams++)
17421         TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17422
17423       iparams = 0;
17424       child_die = die->child;
17425       while (child_die && child_die->tag)
17426         {
17427           if (child_die->tag == DW_TAG_formal_parameter)
17428             {
17429               struct type *arg_type;
17430
17431               /* DWARF version 2 has no clean way to discern C++
17432                  static and non-static member functions.  G++ helps
17433                  GDB by marking the first parameter for non-static
17434                  member functions (which is the this pointer) as
17435                  artificial.  We pass this information to
17436                  dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17437
17438                  DWARF version 3 added DW_AT_object_pointer, which GCC
17439                  4.5 does not yet generate.  */
17440               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17441               if (attr)
17442                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17443               else
17444                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17445               arg_type = die_type (child_die, cu);
17446
17447               /* RealView does not mark THIS as const, which the testsuite
17448                  expects.  GCC marks THIS as const in method definitions,
17449                  but not in the class specifications (GCC PR 43053).  */
17450               if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17451                   && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17452                 {
17453                   int is_this = 0;
17454                   struct dwarf2_cu *arg_cu = cu;
17455                   const char *name = dwarf2_name (child_die, cu);
17456
17457                   attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17458                   if (attr)
17459                     {
17460                       /* If the compiler emits this, use it.  */
17461                       if (follow_die_ref (die, attr, &arg_cu) == child_die)
17462                         is_this = 1;
17463                     }
17464                   else if (name && strcmp (name, "this") == 0)
17465                     /* Function definitions will have the argument names.  */
17466                     is_this = 1;
17467                   else if (name == NULL && iparams == 0)
17468                     /* Declarations may not have the names, so like
17469                        elsewhere in GDB, assume an artificial first
17470                        argument is "this".  */
17471                     is_this = 1;
17472
17473                   if (is_this)
17474                     arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17475                                              arg_type, 0);
17476                 }
17477
17478               TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17479               iparams++;
17480             }
17481           child_die = sibling_die (child_die);
17482         }
17483     }
17484
17485   return ftype;
17486 }
17487
17488 static struct type *
17489 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17490 {
17491   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17492   const char *name = NULL;
17493   struct type *this_type, *target_type;
17494
17495   name = dwarf2_full_name (NULL, die, cu);
17496   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17497   TYPE_TARGET_STUB (this_type) = 1;
17498   set_die_type (die, this_type, cu);
17499   target_type = die_type (die, cu);
17500   if (target_type != this_type)
17501     TYPE_TARGET_TYPE (this_type) = target_type;
17502   else
17503     {
17504       /* Self-referential typedefs are, it seems, not allowed by the DWARF
17505          spec and cause infinite loops in GDB.  */
17506       complaint (_("Self-referential DW_TAG_typedef "
17507                    "- DIE at %s [in module %s]"),
17508                  sect_offset_str (die->sect_off), objfile_name (objfile));
17509       TYPE_TARGET_TYPE (this_type) = NULL;
17510     }
17511   return this_type;
17512 }
17513
17514 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
17515    (which may be different from NAME) to the architecture back-end to allow
17516    it to guess the correct format if necessary.  */
17517
17518 static struct type *
17519 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17520                         const char *name_hint)
17521 {
17522   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17523   const struct floatformat **format;
17524   struct type *type;
17525
17526   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17527   if (format)
17528     type = init_float_type (objfile, bits, name, format);
17529   else
17530     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17531
17532   return type;
17533 }
17534
17535 /* Allocate an integer type of size BITS and name NAME.  */
17536
17537 static struct type *
17538 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17539                           int bits, int unsigned_p, const char *name)
17540 {
17541   struct type *type;
17542
17543   /* Versions of Intel's C Compiler generate an integer type called "void"
17544      instead of using DW_TAG_unspecified_type.  This has been seen on
17545      at least versions 14, 17, and 18.  */
17546   if (bits == 0 && producer_is_icc (cu) && name != nullptr
17547       && strcmp (name, "void") == 0)
17548     type = objfile_type (objfile)->builtin_void;
17549   else
17550     type = init_integer_type (objfile, bits, unsigned_p, name);
17551
17552   return type;
17553 }
17554
17555 /* Find a representation of a given base type and install
17556    it in the TYPE field of the die.  */
17557
17558 static struct type *
17559 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17560 {
17561   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17562   struct type *type;
17563   struct attribute *attr;
17564   int encoding = 0, bits = 0;
17565   const char *name;
17566
17567   attr = dwarf2_attr (die, DW_AT_encoding, cu);
17568   if (attr)
17569     {
17570       encoding = DW_UNSND (attr);
17571     }
17572   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17573   if (attr)
17574     {
17575       bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17576     }
17577   name = dwarf2_name (die, cu);
17578   if (!name)
17579     {
17580       complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17581     }
17582
17583   switch (encoding)
17584     {
17585       case DW_ATE_address:
17586         /* Turn DW_ATE_address into a void * pointer.  */
17587         type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17588         type = init_pointer_type (objfile, bits, name, type);
17589         break;
17590       case DW_ATE_boolean:
17591         type = init_boolean_type (objfile, bits, 1, name);
17592         break;
17593       case DW_ATE_complex_float:
17594         type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17595         type = init_complex_type (objfile, name, type);
17596         break;
17597       case DW_ATE_decimal_float:
17598         type = init_decfloat_type (objfile, bits, name);
17599         break;
17600       case DW_ATE_float:
17601         type = dwarf2_init_float_type (objfile, bits, name, name);
17602         break;
17603       case DW_ATE_signed:
17604         type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17605         break;
17606       case DW_ATE_unsigned:
17607         if (cu->language == language_fortran
17608             && name
17609             && startswith (name, "character("))
17610           type = init_character_type (objfile, bits, 1, name);
17611         else
17612           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17613         break;
17614       case DW_ATE_signed_char:
17615         if (cu->language == language_ada || cu->language == language_m2
17616             || cu->language == language_pascal
17617             || cu->language == language_fortran)
17618           type = init_character_type (objfile, bits, 0, name);
17619         else
17620           type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17621         break;
17622       case DW_ATE_unsigned_char:
17623         if (cu->language == language_ada || cu->language == language_m2
17624             || cu->language == language_pascal
17625             || cu->language == language_fortran
17626             || cu->language == language_rust)
17627           type = init_character_type (objfile, bits, 1, name);
17628         else
17629           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17630         break;
17631       case DW_ATE_UTF:
17632         {
17633           gdbarch *arch = get_objfile_arch (objfile);
17634
17635           if (bits == 16)
17636             type = builtin_type (arch)->builtin_char16;
17637           else if (bits == 32)
17638             type = builtin_type (arch)->builtin_char32;
17639           else
17640             {
17641               complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17642                          bits);
17643               type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17644             }
17645           return set_die_type (die, type, cu);
17646         }
17647         break;
17648
17649       default:
17650         complaint (_("unsupported DW_AT_encoding: '%s'"),
17651                    dwarf_type_encoding_name (encoding));
17652         type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17653         break;
17654     }
17655
17656   if (name && strcmp (name, "char") == 0)
17657     TYPE_NOSIGN (type) = 1;
17658
17659   maybe_set_alignment (cu, die, type);
17660
17661   return set_die_type (die, type, cu);
17662 }
17663
17664 /* Parse dwarf attribute if it's a block, reference or constant and put the
17665    resulting value of the attribute into struct bound_prop.
17666    Returns 1 if ATTR could be resolved into PROP, 0 otherwise.  */
17667
17668 static int
17669 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17670                       struct dwarf2_cu *cu, struct dynamic_prop *prop)
17671 {
17672   struct dwarf2_property_baton *baton;
17673   struct obstack *obstack
17674     = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17675
17676   if (attr == NULL || prop == NULL)
17677     return 0;
17678
17679   if (attr_form_is_block (attr))
17680     {
17681       baton = XOBNEW (obstack, struct dwarf2_property_baton);
17682       baton->referenced_type = NULL;
17683       baton->locexpr.per_cu = cu->per_cu;
17684       baton->locexpr.size = DW_BLOCK (attr)->size;
17685       baton->locexpr.data = DW_BLOCK (attr)->data;
17686       prop->data.baton = baton;
17687       prop->kind = PROP_LOCEXPR;
17688       gdb_assert (prop->data.baton != NULL);
17689     }
17690   else if (attr_form_is_ref (attr))
17691     {
17692       struct dwarf2_cu *target_cu = cu;
17693       struct die_info *target_die;
17694       struct attribute *target_attr;
17695
17696       target_die = follow_die_ref (die, attr, &target_cu);
17697       target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17698       if (target_attr == NULL)
17699         target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17700                                    target_cu);
17701       if (target_attr == NULL)
17702         return 0;
17703
17704       switch (target_attr->name)
17705         {
17706           case DW_AT_location:
17707             if (attr_form_is_section_offset (target_attr))
17708               {
17709                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17710                 baton->referenced_type = die_type (target_die, target_cu);
17711                 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17712                 prop->data.baton = baton;
17713                 prop->kind = PROP_LOCLIST;
17714                 gdb_assert (prop->data.baton != NULL);
17715               }
17716             else if (attr_form_is_block (target_attr))
17717               {
17718                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17719                 baton->referenced_type = die_type (target_die, target_cu);
17720                 baton->locexpr.per_cu = cu->per_cu;
17721                 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17722                 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17723                 prop->data.baton = baton;
17724                 prop->kind = PROP_LOCEXPR;
17725                 gdb_assert (prop->data.baton != NULL);
17726               }
17727             else
17728               {
17729                 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17730                                                        "dynamic property");
17731                 return 0;
17732               }
17733             break;
17734           case DW_AT_data_member_location:
17735             {
17736               LONGEST offset;
17737
17738               if (!handle_data_member_location (target_die, target_cu,
17739                                                 &offset))
17740                 return 0;
17741
17742               baton = XOBNEW (obstack, struct dwarf2_property_baton);
17743               baton->referenced_type = read_type_die (target_die->parent,
17744                                                       target_cu);
17745               baton->offset_info.offset = offset;
17746               baton->offset_info.type = die_type (target_die, target_cu);
17747               prop->data.baton = baton;
17748               prop->kind = PROP_ADDR_OFFSET;
17749               break;
17750             }
17751         }
17752     }
17753   else if (attr_form_is_constant (attr))
17754     {
17755       prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17756       prop->kind = PROP_CONST;
17757     }
17758   else
17759     {
17760       dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17761                                              dwarf2_name (die, cu));
17762       return 0;
17763     }
17764
17765   return 1;
17766 }
17767
17768 /* Read the given DW_AT_subrange DIE.  */
17769
17770 static struct type *
17771 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17772 {
17773   struct type *base_type, *orig_base_type;
17774   struct type *range_type;
17775   struct attribute *attr;
17776   struct dynamic_prop low, high;
17777   int low_default_is_valid;
17778   int high_bound_is_count = 0;
17779   const char *name;
17780   ULONGEST negative_mask;
17781
17782   orig_base_type = die_type (die, cu);
17783   /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17784      whereas the real type might be.  So, we use ORIG_BASE_TYPE when
17785      creating the range type, but we use the result of check_typedef
17786      when examining properties of the type.  */
17787   base_type = check_typedef (orig_base_type);
17788
17789   /* The die_type call above may have already set the type for this DIE.  */
17790   range_type = get_die_type (die, cu);
17791   if (range_type)
17792     return range_type;
17793
17794   low.kind = PROP_CONST;
17795   high.kind = PROP_CONST;
17796   high.data.const_val = 0;
17797
17798   /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17799      omitting DW_AT_lower_bound.  */
17800   switch (cu->language)
17801     {
17802     case language_c:
17803     case language_cplus:
17804       low.data.const_val = 0;
17805       low_default_is_valid = 1;
17806       break;
17807     case language_fortran:
17808       low.data.const_val = 1;
17809       low_default_is_valid = 1;
17810       break;
17811     case language_d:
17812     case language_objc:
17813     case language_rust:
17814       low.data.const_val = 0;
17815       low_default_is_valid = (cu->header.version >= 4);
17816       break;
17817     case language_ada:
17818     case language_m2:
17819     case language_pascal:
17820       low.data.const_val = 1;
17821       low_default_is_valid = (cu->header.version >= 4);
17822       break;
17823     default:
17824       low.data.const_val = 0;
17825       low_default_is_valid = 0;
17826       break;
17827     }
17828
17829   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17830   if (attr)
17831     attr_to_dynamic_prop (attr, die, cu, &low);
17832   else if (!low_default_is_valid)
17833     complaint (_("Missing DW_AT_lower_bound "
17834                                       "- DIE at %s [in module %s]"),
17835                sect_offset_str (die->sect_off),
17836                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17837
17838   struct attribute *attr_ub, *attr_count;
17839   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17840   if (!attr_to_dynamic_prop (attr, die, cu, &high))
17841     {
17842       attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17843       if (attr_to_dynamic_prop (attr, die, cu, &high))
17844         {
17845           /* If bounds are constant do the final calculation here.  */
17846           if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17847             high.data.const_val = low.data.const_val + high.data.const_val - 1;
17848           else
17849             high_bound_is_count = 1;
17850         }
17851       else
17852         {
17853           if (attr_ub != NULL)
17854             complaint (_("Unresolved DW_AT_upper_bound "
17855                          "- DIE at %s [in module %s]"),
17856                        sect_offset_str (die->sect_off),
17857                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17858           if (attr_count != NULL)
17859             complaint (_("Unresolved DW_AT_count "
17860                          "- DIE at %s [in module %s]"),
17861                        sect_offset_str (die->sect_off),
17862                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17863         }
17864         
17865     }
17866
17867   /* Dwarf-2 specifications explicitly allows to create subrange types
17868      without specifying a base type.
17869      In that case, the base type must be set to the type of
17870      the lower bound, upper bound or count, in that order, if any of these
17871      three attributes references an object that has a type.
17872      If no base type is found, the Dwarf-2 specifications say that
17873      a signed integer type of size equal to the size of an address should
17874      be used.
17875      For the following C code: `extern char gdb_int [];'
17876      GCC produces an empty range DIE.
17877      FIXME: muller/2010-05-28: Possible references to object for low bound,
17878      high bound or count are not yet handled by this code.  */
17879   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17880     {
17881       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17882       struct gdbarch *gdbarch = get_objfile_arch (objfile);
17883       int addr_size = gdbarch_addr_bit (gdbarch) /8;
17884       struct type *int_type = objfile_type (objfile)->builtin_int;
17885
17886       /* Test "int", "long int", and "long long int" objfile types,
17887          and select the first one having a size above or equal to the
17888          architecture address size.  */
17889       if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17890         base_type = int_type;
17891       else
17892         {
17893           int_type = objfile_type (objfile)->builtin_long;
17894           if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17895             base_type = int_type;
17896           else
17897             {
17898               int_type = objfile_type (objfile)->builtin_long_long;
17899               if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17900                 base_type = int_type;
17901             }
17902         }
17903     }
17904
17905   /* Normally, the DWARF producers are expected to use a signed
17906      constant form (Eg. DW_FORM_sdata) to express negative bounds.
17907      But this is unfortunately not always the case, as witnessed
17908      with GCC, for instance, where the ambiguous DW_FORM_dataN form
17909      is used instead.  To work around that ambiguity, we treat
17910      the bounds as signed, and thus sign-extend their values, when
17911      the base type is signed.  */
17912   negative_mask =
17913     -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17914   if (low.kind == PROP_CONST
17915       && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17916     low.data.const_val |= negative_mask;
17917   if (high.kind == PROP_CONST
17918       && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17919     high.data.const_val |= negative_mask;
17920
17921   range_type = create_range_type (NULL, orig_base_type, &low, &high);
17922
17923   if (high_bound_is_count)
17924     TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17925
17926   /* Ada expects an empty array on no boundary attributes.  */
17927   if (attr == NULL && cu->language != language_ada)
17928     TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17929
17930   name = dwarf2_name (die, cu);
17931   if (name)
17932     TYPE_NAME (range_type) = name;
17933
17934   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17935   if (attr)
17936     TYPE_LENGTH (range_type) = DW_UNSND (attr);
17937
17938   maybe_set_alignment (cu, die, range_type);
17939
17940   set_die_type (die, range_type, cu);
17941
17942   /* set_die_type should be already done.  */
17943   set_descriptive_type (range_type, die, cu);
17944
17945   return range_type;
17946 }
17947
17948 static struct type *
17949 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17950 {
17951   struct type *type;
17952
17953   type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17954                     NULL);
17955   TYPE_NAME (type) = dwarf2_name (die, cu);
17956
17957   /* In Ada, an unspecified type is typically used when the description
17958      of the type is defered to a different unit.  When encountering
17959      such a type, we treat it as a stub, and try to resolve it later on,
17960      when needed.  */
17961   if (cu->language == language_ada)
17962     TYPE_STUB (type) = 1;
17963
17964   return set_die_type (die, type, cu);
17965 }
17966
17967 /* Read a single die and all its descendents.  Set the die's sibling
17968    field to NULL; set other fields in the die correctly, and set all
17969    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
17970    location of the info_ptr after reading all of those dies.  PARENT
17971    is the parent of the die in question.  */
17972
17973 static struct die_info *
17974 read_die_and_children (const struct die_reader_specs *reader,
17975                        const gdb_byte *info_ptr,
17976                        const gdb_byte **new_info_ptr,
17977                        struct die_info *parent)
17978 {
17979   struct die_info *die;
17980   const gdb_byte *cur_ptr;
17981   int has_children;
17982
17983   cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17984   if (die == NULL)
17985     {
17986       *new_info_ptr = cur_ptr;
17987       return NULL;
17988     }
17989   store_in_ref_table (die, reader->cu);
17990
17991   if (has_children)
17992     die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17993   else
17994     {
17995       die->child = NULL;
17996       *new_info_ptr = cur_ptr;
17997     }
17998
17999   die->sibling = NULL;
18000   die->parent = parent;
18001   return die;
18002 }
18003
18004 /* Read a die, all of its descendents, and all of its siblings; set
18005    all of the fields of all of the dies correctly.  Arguments are as
18006    in read_die_and_children.  */
18007
18008 static struct die_info *
18009 read_die_and_siblings_1 (const struct die_reader_specs *reader,
18010                          const gdb_byte *info_ptr,
18011                          const gdb_byte **new_info_ptr,
18012                          struct die_info *parent)
18013 {
18014   struct die_info *first_die, *last_sibling;
18015   const gdb_byte *cur_ptr;
18016
18017   cur_ptr = info_ptr;
18018   first_die = last_sibling = NULL;
18019
18020   while (1)
18021     {
18022       struct die_info *die
18023         = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18024
18025       if (die == NULL)
18026         {
18027           *new_info_ptr = cur_ptr;
18028           return first_die;
18029         }
18030
18031       if (!first_die)
18032         first_die = die;
18033       else
18034         last_sibling->sibling = die;
18035
18036       last_sibling = die;
18037     }
18038 }
18039
18040 /* Read a die, all of its descendents, and all of its siblings; set
18041    all of the fields of all of the dies correctly.  Arguments are as
18042    in read_die_and_children.
18043    This the main entry point for reading a DIE and all its children.  */
18044
18045 static struct die_info *
18046 read_die_and_siblings (const struct die_reader_specs *reader,
18047                        const gdb_byte *info_ptr,
18048                        const gdb_byte **new_info_ptr,
18049                        struct die_info *parent)
18050 {
18051   struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18052                                                   new_info_ptr, parent);
18053
18054   if (dwarf_die_debug)
18055     {
18056       fprintf_unfiltered (gdb_stdlog,
18057                           "Read die from %s@0x%x of %s:\n",
18058                           get_section_name (reader->die_section),
18059                           (unsigned) (info_ptr - reader->die_section->buffer),
18060                           bfd_get_filename (reader->abfd));
18061       dump_die (die, dwarf_die_debug);
18062     }
18063
18064   return die;
18065 }
18066
18067 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18068    attributes.
18069    The caller is responsible for filling in the extra attributes
18070    and updating (*DIEP)->num_attrs.
18071    Set DIEP to point to a newly allocated die with its information,
18072    except for its child, sibling, and parent fields.
18073    Set HAS_CHILDREN to tell whether the die has children or not.  */
18074
18075 static const gdb_byte *
18076 read_full_die_1 (const struct die_reader_specs *reader,
18077                  struct die_info **diep, const gdb_byte *info_ptr,
18078                  int *has_children, int num_extra_attrs)
18079 {
18080   unsigned int abbrev_number, bytes_read, i;
18081   struct abbrev_info *abbrev;
18082   struct die_info *die;
18083   struct dwarf2_cu *cu = reader->cu;
18084   bfd *abfd = reader->abfd;
18085
18086   sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18087   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18088   info_ptr += bytes_read;
18089   if (!abbrev_number)
18090     {
18091       *diep = NULL;
18092       *has_children = 0;
18093       return info_ptr;
18094     }
18095
18096   abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18097   if (!abbrev)
18098     error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18099            abbrev_number,
18100            bfd_get_filename (abfd));
18101
18102   die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18103   die->sect_off = sect_off;
18104   die->tag = abbrev->tag;
18105   die->abbrev = abbrev_number;
18106
18107   /* Make the result usable.
18108      The caller needs to update num_attrs after adding the extra
18109      attributes.  */
18110   die->num_attrs = abbrev->num_attrs;
18111
18112   for (i = 0; i < abbrev->num_attrs; ++i)
18113     info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18114                                info_ptr);
18115
18116   *diep = die;
18117   *has_children = abbrev->has_children;
18118   return info_ptr;
18119 }
18120
18121 /* Read a die and all its attributes.
18122    Set DIEP to point to a newly allocated die with its information,
18123    except for its child, sibling, and parent fields.
18124    Set HAS_CHILDREN to tell whether the die has children or not.  */
18125
18126 static const gdb_byte *
18127 read_full_die (const struct die_reader_specs *reader,
18128                struct die_info **diep, const gdb_byte *info_ptr,
18129                int *has_children)
18130 {
18131   const gdb_byte *result;
18132
18133   result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18134
18135   if (dwarf_die_debug)
18136     {
18137       fprintf_unfiltered (gdb_stdlog,
18138                           "Read die from %s@0x%x of %s:\n",
18139                           get_section_name (reader->die_section),
18140                           (unsigned) (info_ptr - reader->die_section->buffer),
18141                           bfd_get_filename (reader->abfd));
18142       dump_die (*diep, dwarf_die_debug);
18143     }
18144
18145   return result;
18146 }
18147 \f
18148 /* Abbreviation tables.
18149
18150    In DWARF version 2, the description of the debugging information is
18151    stored in a separate .debug_abbrev section.  Before we read any
18152    dies from a section we read in all abbreviations and install them
18153    in a hash table.  */
18154
18155 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE.  */
18156
18157 struct abbrev_info *
18158 abbrev_table::alloc_abbrev ()
18159 {
18160   struct abbrev_info *abbrev;
18161
18162   abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18163   memset (abbrev, 0, sizeof (struct abbrev_info));
18164
18165   return abbrev;
18166 }
18167
18168 /* Add an abbreviation to the table.  */
18169
18170 void
18171 abbrev_table::add_abbrev (unsigned int abbrev_number,
18172                           struct abbrev_info *abbrev)
18173 {
18174   unsigned int hash_number;
18175
18176   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18177   abbrev->next = m_abbrevs[hash_number];
18178   m_abbrevs[hash_number] = abbrev;
18179 }
18180
18181 /* Look up an abbrev in the table.
18182    Returns NULL if the abbrev is not found.  */
18183
18184 struct abbrev_info *
18185 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18186 {
18187   unsigned int hash_number;
18188   struct abbrev_info *abbrev;
18189
18190   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18191   abbrev = m_abbrevs[hash_number];
18192
18193   while (abbrev)
18194     {
18195       if (abbrev->number == abbrev_number)
18196         return abbrev;
18197       abbrev = abbrev->next;
18198     }
18199   return NULL;
18200 }
18201
18202 /* Read in an abbrev table.  */
18203
18204 static abbrev_table_up
18205 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18206                          struct dwarf2_section_info *section,
18207                          sect_offset sect_off)
18208 {
18209   struct objfile *objfile = dwarf2_per_objfile->objfile;
18210   bfd *abfd = get_section_bfd_owner (section);
18211   const gdb_byte *abbrev_ptr;
18212   struct abbrev_info *cur_abbrev;
18213   unsigned int abbrev_number, bytes_read, abbrev_name;
18214   unsigned int abbrev_form;
18215   struct attr_abbrev *cur_attrs;
18216   unsigned int allocated_attrs;
18217
18218   abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18219
18220   dwarf2_read_section (objfile, section);
18221   abbrev_ptr = section->buffer + to_underlying (sect_off);
18222   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18223   abbrev_ptr += bytes_read;
18224
18225   allocated_attrs = ATTR_ALLOC_CHUNK;
18226   cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18227
18228   /* Loop until we reach an abbrev number of 0.  */
18229   while (abbrev_number)
18230     {
18231       cur_abbrev = abbrev_table->alloc_abbrev ();
18232
18233       /* read in abbrev header */
18234       cur_abbrev->number = abbrev_number;
18235       cur_abbrev->tag
18236         = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18237       abbrev_ptr += bytes_read;
18238       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18239       abbrev_ptr += 1;
18240
18241       /* now read in declarations */
18242       for (;;)
18243         {
18244           LONGEST implicit_const;
18245
18246           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18247           abbrev_ptr += bytes_read;
18248           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18249           abbrev_ptr += bytes_read;
18250           if (abbrev_form == DW_FORM_implicit_const)
18251             {
18252               implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18253                                                    &bytes_read);
18254               abbrev_ptr += bytes_read;
18255             }
18256           else
18257             {
18258               /* Initialize it due to a false compiler warning.  */
18259               implicit_const = -1;
18260             }
18261
18262           if (abbrev_name == 0)
18263             break;
18264
18265           if (cur_abbrev->num_attrs == allocated_attrs)
18266             {
18267               allocated_attrs += ATTR_ALLOC_CHUNK;
18268               cur_attrs
18269                 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18270             }
18271
18272           cur_attrs[cur_abbrev->num_attrs].name
18273             = (enum dwarf_attribute) abbrev_name;
18274           cur_attrs[cur_abbrev->num_attrs].form
18275             = (enum dwarf_form) abbrev_form;
18276           cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18277           ++cur_abbrev->num_attrs;
18278         }
18279
18280       cur_abbrev->attrs =
18281         XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18282                    cur_abbrev->num_attrs);
18283       memcpy (cur_abbrev->attrs, cur_attrs,
18284               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18285
18286       abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18287
18288       /* Get next abbreviation.
18289          Under Irix6 the abbreviations for a compilation unit are not
18290          always properly terminated with an abbrev number of 0.
18291          Exit loop if we encounter an abbreviation which we have
18292          already read (which means we are about to read the abbreviations
18293          for the next compile unit) or if the end of the abbreviation
18294          table is reached.  */
18295       if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18296         break;
18297       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18298       abbrev_ptr += bytes_read;
18299       if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18300         break;
18301     }
18302
18303   xfree (cur_attrs);
18304   return abbrev_table;
18305 }
18306
18307 /* Returns nonzero if TAG represents a type that we might generate a partial
18308    symbol for.  */
18309
18310 static int
18311 is_type_tag_for_partial (int tag)
18312 {
18313   switch (tag)
18314     {
18315 #if 0
18316     /* Some types that would be reasonable to generate partial symbols for,
18317        that we don't at present.  */
18318     case DW_TAG_array_type:
18319     case DW_TAG_file_type:
18320     case DW_TAG_ptr_to_member_type:
18321     case DW_TAG_set_type:
18322     case DW_TAG_string_type:
18323     case DW_TAG_subroutine_type:
18324 #endif
18325     case DW_TAG_base_type:
18326     case DW_TAG_class_type:
18327     case DW_TAG_interface_type:
18328     case DW_TAG_enumeration_type:
18329     case DW_TAG_structure_type:
18330     case DW_TAG_subrange_type:
18331     case DW_TAG_typedef:
18332     case DW_TAG_union_type:
18333       return 1;
18334     default:
18335       return 0;
18336     }
18337 }
18338
18339 /* Load all DIEs that are interesting for partial symbols into memory.  */
18340
18341 static struct partial_die_info *
18342 load_partial_dies (const struct die_reader_specs *reader,
18343                    const gdb_byte *info_ptr, int building_psymtab)
18344 {
18345   struct dwarf2_cu *cu = reader->cu;
18346   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18347   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18348   unsigned int bytes_read;
18349   unsigned int load_all = 0;
18350   int nesting_level = 1;
18351
18352   parent_die = NULL;
18353   last_die = NULL;
18354
18355   gdb_assert (cu->per_cu != NULL);
18356   if (cu->per_cu->load_all_dies)
18357     load_all = 1;
18358
18359   cu->partial_dies
18360     = htab_create_alloc_ex (cu->header.length / 12,
18361                             partial_die_hash,
18362                             partial_die_eq,
18363                             NULL,
18364                             &cu->comp_unit_obstack,
18365                             hashtab_obstack_allocate,
18366                             dummy_obstack_deallocate);
18367
18368   while (1)
18369     {
18370       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18371
18372       /* A NULL abbrev means the end of a series of children.  */
18373       if (abbrev == NULL)
18374         {
18375           if (--nesting_level == 0)
18376             return first_die;
18377
18378           info_ptr += bytes_read;
18379           last_die = parent_die;
18380           parent_die = parent_die->die_parent;
18381           continue;
18382         }
18383
18384       /* Check for template arguments.  We never save these; if
18385          they're seen, we just mark the parent, and go on our way.  */
18386       if (parent_die != NULL
18387           && cu->language == language_cplus
18388           && (abbrev->tag == DW_TAG_template_type_param
18389               || abbrev->tag == DW_TAG_template_value_param))
18390         {
18391           parent_die->has_template_arguments = 1;
18392
18393           if (!load_all)
18394             {
18395               /* We don't need a partial DIE for the template argument.  */
18396               info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18397               continue;
18398             }
18399         }
18400
18401       /* We only recurse into c++ subprograms looking for template arguments.
18402          Skip their other children.  */
18403       if (!load_all
18404           && cu->language == language_cplus
18405           && parent_die != NULL
18406           && parent_die->tag == DW_TAG_subprogram)
18407         {
18408           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18409           continue;
18410         }
18411
18412       /* Check whether this DIE is interesting enough to save.  Normally
18413          we would not be interested in members here, but there may be
18414          later variables referencing them via DW_AT_specification (for
18415          static members).  */
18416       if (!load_all
18417           && !is_type_tag_for_partial (abbrev->tag)
18418           && abbrev->tag != DW_TAG_constant
18419           && abbrev->tag != DW_TAG_enumerator
18420           && abbrev->tag != DW_TAG_subprogram
18421           && abbrev->tag != DW_TAG_inlined_subroutine
18422           && abbrev->tag != DW_TAG_lexical_block
18423           && abbrev->tag != DW_TAG_variable
18424           && abbrev->tag != DW_TAG_namespace
18425           && abbrev->tag != DW_TAG_module
18426           && abbrev->tag != DW_TAG_member
18427           && abbrev->tag != DW_TAG_imported_unit
18428           && abbrev->tag != DW_TAG_imported_declaration)
18429         {
18430           /* Otherwise we skip to the next sibling, if any.  */
18431           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18432           continue;
18433         }
18434
18435       struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18436                                    abbrev);
18437
18438       info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18439
18440       /* This two-pass algorithm for processing partial symbols has a
18441          high cost in cache pressure.  Thus, handle some simple cases
18442          here which cover the majority of C partial symbols.  DIEs
18443          which neither have specification tags in them, nor could have
18444          specification tags elsewhere pointing at them, can simply be
18445          processed and discarded.
18446
18447          This segment is also optional; scan_partial_symbols and
18448          add_partial_symbol will handle these DIEs if we chain
18449          them in normally.  When compilers which do not emit large
18450          quantities of duplicate debug information are more common,
18451          this code can probably be removed.  */
18452
18453       /* Any complete simple types at the top level (pretty much all
18454          of them, for a language without namespaces), can be processed
18455          directly.  */
18456       if (parent_die == NULL
18457           && pdi.has_specification == 0
18458           && pdi.is_declaration == 0
18459           && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18460               || pdi.tag == DW_TAG_base_type
18461               || pdi.tag == DW_TAG_subrange_type))
18462         {
18463           if (building_psymtab && pdi.name != NULL)
18464             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18465                                  VAR_DOMAIN, LOC_TYPEDEF, -1,
18466                                  psymbol_placement::STATIC,
18467                                  0, cu->language, objfile);
18468           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18469           continue;
18470         }
18471
18472       /* The exception for DW_TAG_typedef with has_children above is
18473          a workaround of GCC PR debug/47510.  In the case of this complaint
18474          type_name_or_error will error on such types later.
18475
18476          GDB skipped children of DW_TAG_typedef by the shortcut above and then
18477          it could not find the child DIEs referenced later, this is checked
18478          above.  In correct DWARF DW_TAG_typedef should have no children.  */
18479
18480       if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18481         complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18482                      "- DIE at %s [in module %s]"),
18483                    sect_offset_str (pdi.sect_off), objfile_name (objfile));
18484
18485       /* If we're at the second level, and we're an enumerator, and
18486          our parent has no specification (meaning possibly lives in a
18487          namespace elsewhere), then we can add the partial symbol now
18488          instead of queueing it.  */
18489       if (pdi.tag == DW_TAG_enumerator
18490           && parent_die != NULL
18491           && parent_die->die_parent == NULL
18492           && parent_die->tag == DW_TAG_enumeration_type
18493           && parent_die->has_specification == 0)
18494         {
18495           if (pdi.name == NULL)
18496             complaint (_("malformed enumerator DIE ignored"));
18497           else if (building_psymtab)
18498             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18499                                  VAR_DOMAIN, LOC_CONST, -1,
18500                                  cu->language == language_cplus
18501                                  ? psymbol_placement::GLOBAL
18502                                  : psymbol_placement::STATIC,
18503                                  0, cu->language, objfile);
18504
18505           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18506           continue;
18507         }
18508
18509       struct partial_die_info *part_die
18510         = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18511
18512       /* We'll save this DIE so link it in.  */
18513       part_die->die_parent = parent_die;
18514       part_die->die_sibling = NULL;
18515       part_die->die_child = NULL;
18516
18517       if (last_die && last_die == parent_die)
18518         last_die->die_child = part_die;
18519       else if (last_die)
18520         last_die->die_sibling = part_die;
18521
18522       last_die = part_die;
18523
18524       if (first_die == NULL)
18525         first_die = part_die;
18526
18527       /* Maybe add the DIE to the hash table.  Not all DIEs that we
18528          find interesting need to be in the hash table, because we
18529          also have the parent/sibling/child chains; only those that we
18530          might refer to by offset later during partial symbol reading.
18531
18532          For now this means things that might have be the target of a
18533          DW_AT_specification, DW_AT_abstract_origin, or
18534          DW_AT_extension.  DW_AT_extension will refer only to
18535          namespaces; DW_AT_abstract_origin refers to functions (and
18536          many things under the function DIE, but we do not recurse
18537          into function DIEs during partial symbol reading) and
18538          possibly variables as well; DW_AT_specification refers to
18539          declarations.  Declarations ought to have the DW_AT_declaration
18540          flag.  It happens that GCC forgets to put it in sometimes, but
18541          only for functions, not for types.
18542
18543          Adding more things than necessary to the hash table is harmless
18544          except for the performance cost.  Adding too few will result in
18545          wasted time in find_partial_die, when we reread the compilation
18546          unit with load_all_dies set.  */
18547
18548       if (load_all
18549           || abbrev->tag == DW_TAG_constant
18550           || abbrev->tag == DW_TAG_subprogram
18551           || abbrev->tag == DW_TAG_variable
18552           || abbrev->tag == DW_TAG_namespace
18553           || part_die->is_declaration)
18554         {
18555           void **slot;
18556
18557           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18558                                            to_underlying (part_die->sect_off),
18559                                            INSERT);
18560           *slot = part_die;
18561         }
18562
18563       /* For some DIEs we want to follow their children (if any).  For C
18564          we have no reason to follow the children of structures; for other
18565          languages we have to, so that we can get at method physnames
18566          to infer fully qualified class names, for DW_AT_specification,
18567          and for C++ template arguments.  For C++, we also look one level
18568          inside functions to find template arguments (if the name of the
18569          function does not already contain the template arguments).
18570
18571          For Ada, we need to scan the children of subprograms and lexical
18572          blocks as well because Ada allows the definition of nested
18573          entities that could be interesting for the debugger, such as
18574          nested subprograms for instance.  */
18575       if (last_die->has_children
18576           && (load_all
18577               || last_die->tag == DW_TAG_namespace
18578               || last_die->tag == DW_TAG_module
18579               || last_die->tag == DW_TAG_enumeration_type
18580               || (cu->language == language_cplus
18581                   && last_die->tag == DW_TAG_subprogram
18582                   && (last_die->name == NULL
18583                       || strchr (last_die->name, '<') == NULL))
18584               || (cu->language != language_c
18585                   && (last_die->tag == DW_TAG_class_type
18586                       || last_die->tag == DW_TAG_interface_type
18587                       || last_die->tag == DW_TAG_structure_type
18588                       || last_die->tag == DW_TAG_union_type))
18589               || (cu->language == language_ada
18590                   && (last_die->tag == DW_TAG_subprogram
18591                       || last_die->tag == DW_TAG_lexical_block))))
18592         {
18593           nesting_level++;
18594           parent_die = last_die;
18595           continue;
18596         }
18597
18598       /* Otherwise we skip to the next sibling, if any.  */
18599       info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18600
18601       /* Back to the top, do it again.  */
18602     }
18603 }
18604
18605 partial_die_info::partial_die_info (sect_offset sect_off_,
18606                                     struct abbrev_info *abbrev)
18607   : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18608 {
18609 }
18610
18611 /* Read a minimal amount of information into the minimal die structure.
18612    INFO_PTR should point just after the initial uleb128 of a DIE.  */
18613
18614 const gdb_byte *
18615 partial_die_info::read (const struct die_reader_specs *reader,
18616                         const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18617 {
18618   struct dwarf2_cu *cu = reader->cu;
18619   struct dwarf2_per_objfile *dwarf2_per_objfile
18620     = cu->per_cu->dwarf2_per_objfile;
18621   unsigned int i;
18622   int has_low_pc_attr = 0;
18623   int has_high_pc_attr = 0;
18624   int high_pc_relative = 0;
18625
18626   for (i = 0; i < abbrev.num_attrs; ++i)
18627     {
18628       struct attribute attr;
18629
18630       info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18631
18632       /* Store the data if it is of an attribute we want to keep in a
18633          partial symbol table.  */
18634       switch (attr.name)
18635         {
18636         case DW_AT_name:
18637           switch (tag)
18638             {
18639             case DW_TAG_compile_unit:
18640             case DW_TAG_partial_unit:
18641             case DW_TAG_type_unit:
18642               /* Compilation units have a DW_AT_name that is a filename, not
18643                  a source language identifier.  */
18644             case DW_TAG_enumeration_type:
18645             case DW_TAG_enumerator:
18646               /* These tags always have simple identifiers already; no need
18647                  to canonicalize them.  */
18648               name = DW_STRING (&attr);
18649               break;
18650             default:
18651               {
18652                 struct objfile *objfile = dwarf2_per_objfile->objfile;
18653
18654                 name
18655                   = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18656                                               &objfile->per_bfd->storage_obstack);
18657               }
18658               break;
18659             }
18660           break;
18661         case DW_AT_linkage_name:
18662         case DW_AT_MIPS_linkage_name:
18663           /* Note that both forms of linkage name might appear.  We
18664              assume they will be the same, and we only store the last
18665              one we see.  */
18666           if (cu->language == language_ada)
18667             name = DW_STRING (&attr);
18668           linkage_name = DW_STRING (&attr);
18669           break;
18670         case DW_AT_low_pc:
18671           has_low_pc_attr = 1;
18672           lowpc = attr_value_as_address (&attr);
18673           break;
18674         case DW_AT_high_pc:
18675           has_high_pc_attr = 1;
18676           highpc = attr_value_as_address (&attr);
18677           if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18678                 high_pc_relative = 1;
18679           break;
18680         case DW_AT_location:
18681           /* Support the .debug_loc offsets.  */
18682           if (attr_form_is_block (&attr))
18683             {
18684                d.locdesc = DW_BLOCK (&attr);
18685             }
18686           else if (attr_form_is_section_offset (&attr))
18687             {
18688               dwarf2_complex_location_expr_complaint ();
18689             }
18690           else
18691             {
18692               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18693                                                      "partial symbol information");
18694             }
18695           break;
18696         case DW_AT_external:
18697           is_external = DW_UNSND (&attr);
18698           break;
18699         case DW_AT_declaration:
18700           is_declaration = DW_UNSND (&attr);
18701           break;
18702         case DW_AT_type:
18703           has_type = 1;
18704           break;
18705         case DW_AT_abstract_origin:
18706         case DW_AT_specification:
18707         case DW_AT_extension:
18708           has_specification = 1;
18709           spec_offset = dwarf2_get_ref_die_offset (&attr);
18710           spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18711                                    || cu->per_cu->is_dwz);
18712           break;
18713         case DW_AT_sibling:
18714           /* Ignore absolute siblings, they might point outside of
18715              the current compile unit.  */
18716           if (attr.form == DW_FORM_ref_addr)
18717             complaint (_("ignoring absolute DW_AT_sibling"));
18718           else
18719             {
18720               const gdb_byte *buffer = reader->buffer;
18721               sect_offset off = dwarf2_get_ref_die_offset (&attr);
18722               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18723
18724               if (sibling_ptr < info_ptr)
18725                 complaint (_("DW_AT_sibling points backwards"));
18726               else if (sibling_ptr > reader->buffer_end)
18727                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18728               else
18729                 sibling = sibling_ptr;
18730             }
18731           break;
18732         case DW_AT_byte_size:
18733           has_byte_size = 1;
18734           break;
18735         case DW_AT_const_value:
18736           has_const_value = 1;
18737           break;
18738         case DW_AT_calling_convention:
18739           /* DWARF doesn't provide a way to identify a program's source-level
18740              entry point.  DW_AT_calling_convention attributes are only meant
18741              to describe functions' calling conventions.
18742
18743              However, because it's a necessary piece of information in
18744              Fortran, and before DWARF 4 DW_CC_program was the only
18745              piece of debugging information whose definition refers to
18746              a 'main program' at all, several compilers marked Fortran
18747              main programs with DW_CC_program --- even when those
18748              functions use the standard calling conventions.
18749
18750              Although DWARF now specifies a way to provide this
18751              information, we support this practice for backward
18752              compatibility.  */
18753           if (DW_UNSND (&attr) == DW_CC_program
18754               && cu->language == language_fortran)
18755             main_subprogram = 1;
18756           break;
18757         case DW_AT_inline:
18758           if (DW_UNSND (&attr) == DW_INL_inlined
18759               || DW_UNSND (&attr) == DW_INL_declared_inlined)
18760             may_be_inlined = 1;
18761           break;
18762
18763         case DW_AT_import:
18764           if (tag == DW_TAG_imported_unit)
18765             {
18766               d.sect_off = dwarf2_get_ref_die_offset (&attr);
18767               is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18768                                   || cu->per_cu->is_dwz);
18769             }
18770           break;
18771
18772         case DW_AT_main_subprogram:
18773           main_subprogram = DW_UNSND (&attr);
18774           break;
18775
18776         default:
18777           break;
18778         }
18779     }
18780
18781   if (high_pc_relative)
18782     highpc += lowpc;
18783
18784   if (has_low_pc_attr && has_high_pc_attr)
18785     {
18786       /* When using the GNU linker, .gnu.linkonce. sections are used to
18787          eliminate duplicate copies of functions and vtables and such.
18788          The linker will arbitrarily choose one and discard the others.
18789          The AT_*_pc values for such functions refer to local labels in
18790          these sections.  If the section from that file was discarded, the
18791          labels are not in the output, so the relocs get a value of 0.
18792          If this is a discarded function, mark the pc bounds as invalid,
18793          so that GDB will ignore it.  */
18794       if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18795         {
18796           struct objfile *objfile = dwarf2_per_objfile->objfile;
18797           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18798
18799           complaint (_("DW_AT_low_pc %s is zero "
18800                        "for DIE at %s [in module %s]"),
18801                      paddress (gdbarch, lowpc),
18802                      sect_offset_str (sect_off),
18803                      objfile_name (objfile));
18804         }
18805       /* dwarf2_get_pc_bounds has also the strict low < high requirement.  */
18806       else if (lowpc >= highpc)
18807         {
18808           struct objfile *objfile = dwarf2_per_objfile->objfile;
18809           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18810
18811           complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18812                        "for DIE at %s [in module %s]"),
18813                      paddress (gdbarch, lowpc),
18814                      paddress (gdbarch, highpc),
18815                      sect_offset_str (sect_off),
18816                      objfile_name (objfile));
18817         }
18818       else
18819         has_pc_info = 1;
18820     }
18821
18822   return info_ptr;
18823 }
18824
18825 /* Find a cached partial DIE at OFFSET in CU.  */
18826
18827 struct partial_die_info *
18828 dwarf2_cu::find_partial_die (sect_offset sect_off)
18829 {
18830   struct partial_die_info *lookup_die = NULL;
18831   struct partial_die_info part_die (sect_off);
18832
18833   lookup_die = ((struct partial_die_info *)
18834                 htab_find_with_hash (partial_dies, &part_die,
18835                                      to_underlying (sect_off)));
18836
18837   return lookup_die;
18838 }
18839
18840 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18841    except in the case of .debug_types DIEs which do not reference
18842    outside their CU (they do however referencing other types via
18843    DW_FORM_ref_sig8).  */
18844
18845 static struct partial_die_info *
18846 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18847 {
18848   struct dwarf2_per_objfile *dwarf2_per_objfile
18849     = cu->per_cu->dwarf2_per_objfile;
18850   struct objfile *objfile = dwarf2_per_objfile->objfile;
18851   struct dwarf2_per_cu_data *per_cu = NULL;
18852   struct partial_die_info *pd = NULL;
18853
18854   if (offset_in_dwz == cu->per_cu->is_dwz
18855       && offset_in_cu_p (&cu->header, sect_off))
18856     {
18857       pd = cu->find_partial_die (sect_off);
18858       if (pd != NULL)
18859         return pd;
18860       /* We missed recording what we needed.
18861          Load all dies and try again.  */
18862       per_cu = cu->per_cu;
18863     }
18864   else
18865     {
18866       /* TUs don't reference other CUs/TUs (except via type signatures).  */
18867       if (cu->per_cu->is_debug_types)
18868         {
18869           error (_("Dwarf Error: Type Unit at offset %s contains"
18870                    " external reference to offset %s [in module %s].\n"),
18871                  sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18872                  bfd_get_filename (objfile->obfd));
18873         }
18874       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18875                                                  dwarf2_per_objfile);
18876
18877       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18878         load_partial_comp_unit (per_cu);
18879
18880       per_cu->cu->last_used = 0;
18881       pd = per_cu->cu->find_partial_die (sect_off);
18882     }
18883
18884   /* If we didn't find it, and not all dies have been loaded,
18885      load them all and try again.  */
18886
18887   if (pd == NULL && per_cu->load_all_dies == 0)
18888     {
18889       per_cu->load_all_dies = 1;
18890
18891       /* This is nasty.  When we reread the DIEs, somewhere up the call chain
18892          THIS_CU->cu may already be in use.  So we can't just free it and
18893          replace its DIEs with the ones we read in.  Instead, we leave those
18894          DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18895          and clobber THIS_CU->cu->partial_dies with the hash table for the new
18896          set.  */
18897       load_partial_comp_unit (per_cu);
18898
18899       pd = per_cu->cu->find_partial_die (sect_off);
18900     }
18901
18902   if (pd == NULL)
18903     internal_error (__FILE__, __LINE__,
18904                     _("could not find partial DIE %s "
18905                       "in cache [from module %s]\n"),
18906                     sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18907   return pd;
18908 }
18909
18910 /* See if we can figure out if the class lives in a namespace.  We do
18911    this by looking for a member function; its demangled name will
18912    contain namespace info, if there is any.  */
18913
18914 static void
18915 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18916                                   struct dwarf2_cu *cu)
18917 {
18918   /* NOTE: carlton/2003-10-07: Getting the info this way changes
18919      what template types look like, because the demangler
18920      frequently doesn't give the same name as the debug info.  We
18921      could fix this by only using the demangled name to get the
18922      prefix (but see comment in read_structure_type).  */
18923
18924   struct partial_die_info *real_pdi;
18925   struct partial_die_info *child_pdi;
18926
18927   /* If this DIE (this DIE's specification, if any) has a parent, then
18928      we should not do this.  We'll prepend the parent's fully qualified
18929      name when we create the partial symbol.  */
18930
18931   real_pdi = struct_pdi;
18932   while (real_pdi->has_specification)
18933     real_pdi = find_partial_die (real_pdi->spec_offset,
18934                                  real_pdi->spec_is_dwz, cu);
18935
18936   if (real_pdi->die_parent != NULL)
18937     return;
18938
18939   for (child_pdi = struct_pdi->die_child;
18940        child_pdi != NULL;
18941        child_pdi = child_pdi->die_sibling)
18942     {
18943       if (child_pdi->tag == DW_TAG_subprogram
18944           && child_pdi->linkage_name != NULL)
18945         {
18946           char *actual_class_name
18947             = language_class_name_from_physname (cu->language_defn,
18948                                                  child_pdi->linkage_name);
18949           if (actual_class_name != NULL)
18950             {
18951               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18952               struct_pdi->name
18953                 = ((const char *)
18954                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
18955                                   actual_class_name,
18956                                   strlen (actual_class_name)));
18957               xfree (actual_class_name);
18958             }
18959           break;
18960         }
18961     }
18962 }
18963
18964 void
18965 partial_die_info::fixup (struct dwarf2_cu *cu)
18966 {
18967   /* Once we've fixed up a die, there's no point in doing so again.
18968      This also avoids a memory leak if we were to call
18969      guess_partial_die_structure_name multiple times.  */
18970   if (fixup_called)
18971     return;
18972
18973   /* If we found a reference attribute and the DIE has no name, try
18974      to find a name in the referred to DIE.  */
18975
18976   if (name == NULL && has_specification)
18977     {
18978       struct partial_die_info *spec_die;
18979
18980       spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18981
18982       spec_die->fixup (cu);
18983
18984       if (spec_die->name)
18985         {
18986           name = spec_die->name;
18987
18988           /* Copy DW_AT_external attribute if it is set.  */
18989           if (spec_die->is_external)
18990             is_external = spec_die->is_external;
18991         }
18992     }
18993
18994   /* Set default names for some unnamed DIEs.  */
18995
18996   if (name == NULL && tag == DW_TAG_namespace)
18997     name = CP_ANONYMOUS_NAMESPACE_STR;
18998
18999   /* If there is no parent die to provide a namespace, and there are
19000      children, see if we can determine the namespace from their linkage
19001      name.  */
19002   if (cu->language == language_cplus
19003       && !VEC_empty (dwarf2_section_info_def,
19004                      cu->per_cu->dwarf2_per_objfile->types)
19005       && die_parent == NULL
19006       && has_children
19007       && (tag == DW_TAG_class_type
19008           || tag == DW_TAG_structure_type
19009           || tag == DW_TAG_union_type))
19010     guess_partial_die_structure_name (this, cu);
19011
19012   /* GCC might emit a nameless struct or union that has a linkage
19013      name.  See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
19014   if (name == NULL
19015       && (tag == DW_TAG_class_type
19016           || tag == DW_TAG_interface_type
19017           || tag == DW_TAG_structure_type
19018           || tag == DW_TAG_union_type)
19019       && linkage_name != NULL)
19020     {
19021       char *demangled;
19022
19023       demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19024       if (demangled)
19025         {
19026           const char *base;
19027
19028           /* Strip any leading namespaces/classes, keep only the base name.
19029              DW_AT_name for named DIEs does not contain the prefixes.  */
19030           base = strrchr (demangled, ':');
19031           if (base && base > demangled && base[-1] == ':')
19032             base++;
19033           else
19034             base = demangled;
19035
19036           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19037           name
19038             = ((const char *)
19039                obstack_copy0 (&objfile->per_bfd->storage_obstack,
19040                               base, strlen (base)));
19041           xfree (demangled);
19042         }
19043     }
19044
19045   fixup_called = 1;
19046 }
19047
19048 /* Read an attribute value described by an attribute form.  */
19049
19050 static const gdb_byte *
19051 read_attribute_value (const struct die_reader_specs *reader,
19052                       struct attribute *attr, unsigned form,
19053                       LONGEST implicit_const, const gdb_byte *info_ptr)
19054 {
19055   struct dwarf2_cu *cu = reader->cu;
19056   struct dwarf2_per_objfile *dwarf2_per_objfile
19057     = cu->per_cu->dwarf2_per_objfile;
19058   struct objfile *objfile = dwarf2_per_objfile->objfile;
19059   struct gdbarch *gdbarch = get_objfile_arch (objfile);
19060   bfd *abfd = reader->abfd;
19061   struct comp_unit_head *cu_header = &cu->header;
19062   unsigned int bytes_read;
19063   struct dwarf_block *blk;
19064
19065   attr->form = (enum dwarf_form) form;
19066   switch (form)
19067     {
19068     case DW_FORM_ref_addr:
19069       if (cu->header.version == 2)
19070         DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19071       else
19072         DW_UNSND (attr) = read_offset (abfd, info_ptr,
19073                                        &cu->header, &bytes_read);
19074       info_ptr += bytes_read;
19075       break;
19076     case DW_FORM_GNU_ref_alt:
19077       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19078       info_ptr += bytes_read;
19079       break;
19080     case DW_FORM_addr:
19081       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19082       DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19083       info_ptr += bytes_read;
19084       break;
19085     case DW_FORM_block2:
19086       blk = dwarf_alloc_block (cu);
19087       blk->size = read_2_bytes (abfd, info_ptr);
19088       info_ptr += 2;
19089       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19090       info_ptr += blk->size;
19091       DW_BLOCK (attr) = blk;
19092       break;
19093     case DW_FORM_block4:
19094       blk = dwarf_alloc_block (cu);
19095       blk->size = read_4_bytes (abfd, info_ptr);
19096       info_ptr += 4;
19097       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19098       info_ptr += blk->size;
19099       DW_BLOCK (attr) = blk;
19100       break;
19101     case DW_FORM_data2:
19102       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19103       info_ptr += 2;
19104       break;
19105     case DW_FORM_data4:
19106       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19107       info_ptr += 4;
19108       break;
19109     case DW_FORM_data8:
19110       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19111       info_ptr += 8;
19112       break;
19113     case DW_FORM_data16:
19114       blk = dwarf_alloc_block (cu);
19115       blk->size = 16;
19116       blk->data = read_n_bytes (abfd, info_ptr, 16);
19117       info_ptr += 16;
19118       DW_BLOCK (attr) = blk;
19119       break;
19120     case DW_FORM_sec_offset:
19121       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19122       info_ptr += bytes_read;
19123       break;
19124     case DW_FORM_string:
19125       DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19126       DW_STRING_IS_CANONICAL (attr) = 0;
19127       info_ptr += bytes_read;
19128       break;
19129     case DW_FORM_strp:
19130       if (!cu->per_cu->is_dwz)
19131         {
19132           DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19133                                                    abfd, info_ptr, cu_header,
19134                                                    &bytes_read);
19135           DW_STRING_IS_CANONICAL (attr) = 0;
19136           info_ptr += bytes_read;
19137           break;
19138         }
19139       /* FALLTHROUGH */
19140     case DW_FORM_line_strp:
19141       if (!cu->per_cu->is_dwz)
19142         {
19143           DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19144                                                         abfd, info_ptr,
19145                                                         cu_header, &bytes_read);
19146           DW_STRING_IS_CANONICAL (attr) = 0;
19147           info_ptr += bytes_read;
19148           break;
19149         }
19150       /* FALLTHROUGH */
19151     case DW_FORM_GNU_strp_alt:
19152       {
19153         struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19154         LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19155                                           &bytes_read);
19156
19157         DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19158                                                           dwz, str_offset);
19159         DW_STRING_IS_CANONICAL (attr) = 0;
19160         info_ptr += bytes_read;
19161       }
19162       break;
19163     case DW_FORM_exprloc:
19164     case DW_FORM_block:
19165       blk = dwarf_alloc_block (cu);
19166       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19167       info_ptr += bytes_read;
19168       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19169       info_ptr += blk->size;
19170       DW_BLOCK (attr) = blk;
19171       break;
19172     case DW_FORM_block1:
19173       blk = dwarf_alloc_block (cu);
19174       blk->size = read_1_byte (abfd, info_ptr);
19175       info_ptr += 1;
19176       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19177       info_ptr += blk->size;
19178       DW_BLOCK (attr) = blk;
19179       break;
19180     case DW_FORM_data1:
19181       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19182       info_ptr += 1;
19183       break;
19184     case DW_FORM_flag:
19185       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19186       info_ptr += 1;
19187       break;
19188     case DW_FORM_flag_present:
19189       DW_UNSND (attr) = 1;
19190       break;
19191     case DW_FORM_sdata:
19192       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19193       info_ptr += bytes_read;
19194       break;
19195     case DW_FORM_udata:
19196       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19197       info_ptr += bytes_read;
19198       break;
19199     case DW_FORM_ref1:
19200       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19201                          + read_1_byte (abfd, info_ptr));
19202       info_ptr += 1;
19203       break;
19204     case DW_FORM_ref2:
19205       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19206                          + read_2_bytes (abfd, info_ptr));
19207       info_ptr += 2;
19208       break;
19209     case DW_FORM_ref4:
19210       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19211                          + read_4_bytes (abfd, info_ptr));
19212       info_ptr += 4;
19213       break;
19214     case DW_FORM_ref8:
19215       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19216                          + read_8_bytes (abfd, info_ptr));
19217       info_ptr += 8;
19218       break;
19219     case DW_FORM_ref_sig8:
19220       DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19221       info_ptr += 8;
19222       break;
19223     case DW_FORM_ref_udata:
19224       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19225                          + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19226       info_ptr += bytes_read;
19227       break;
19228     case DW_FORM_indirect:
19229       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19230       info_ptr += bytes_read;
19231       if (form == DW_FORM_implicit_const)
19232         {
19233           implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19234           info_ptr += bytes_read;
19235         }
19236       info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19237                                        info_ptr);
19238       break;
19239     case DW_FORM_implicit_const:
19240       DW_SND (attr) = implicit_const;
19241       break;
19242     case DW_FORM_GNU_addr_index:
19243       if (reader->dwo_file == NULL)
19244         {
19245           /* For now flag a hard error.
19246              Later we can turn this into a complaint.  */
19247           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19248                  dwarf_form_name (form),
19249                  bfd_get_filename (abfd));
19250         }
19251       DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19252       info_ptr += bytes_read;
19253       break;
19254     case DW_FORM_GNU_str_index:
19255       if (reader->dwo_file == NULL)
19256         {
19257           /* For now flag a hard error.
19258              Later we can turn this into a complaint if warranted.  */
19259           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19260                  dwarf_form_name (form),
19261                  bfd_get_filename (abfd));
19262         }
19263       {
19264         ULONGEST str_index =
19265           read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19266
19267         DW_STRING (attr) = read_str_index (reader, str_index);
19268         DW_STRING_IS_CANONICAL (attr) = 0;
19269         info_ptr += bytes_read;
19270       }
19271       break;
19272     default:
19273       error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19274              dwarf_form_name (form),
19275              bfd_get_filename (abfd));
19276     }
19277
19278   /* Super hack.  */
19279   if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19280     attr->form = DW_FORM_GNU_ref_alt;
19281
19282   /* We have seen instances where the compiler tried to emit a byte
19283      size attribute of -1 which ended up being encoded as an unsigned
19284      0xffffffff.  Although 0xffffffff is technically a valid size value,
19285      an object of this size seems pretty unlikely so we can relatively
19286      safely treat these cases as if the size attribute was invalid and
19287      treat them as zero by default.  */
19288   if (attr->name == DW_AT_byte_size
19289       && form == DW_FORM_data4
19290       && DW_UNSND (attr) >= 0xffffffff)
19291     {
19292       complaint
19293         (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19294          hex_string (DW_UNSND (attr)));
19295       DW_UNSND (attr) = 0;
19296     }
19297
19298   return info_ptr;
19299 }
19300
19301 /* Read an attribute described by an abbreviated attribute.  */
19302
19303 static const gdb_byte *
19304 read_attribute (const struct die_reader_specs *reader,
19305                 struct attribute *attr, struct attr_abbrev *abbrev,
19306                 const gdb_byte *info_ptr)
19307 {
19308   attr->name = abbrev->name;
19309   return read_attribute_value (reader, attr, abbrev->form,
19310                                abbrev->implicit_const, info_ptr);
19311 }
19312
19313 /* Read dwarf information from a buffer.  */
19314
19315 static unsigned int
19316 read_1_byte (bfd *abfd, const gdb_byte *buf)
19317 {
19318   return bfd_get_8 (abfd, buf);
19319 }
19320
19321 static int
19322 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19323 {
19324   return bfd_get_signed_8 (abfd, buf);
19325 }
19326
19327 static unsigned int
19328 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19329 {
19330   return bfd_get_16 (abfd, buf);
19331 }
19332
19333 static int
19334 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19335 {
19336   return bfd_get_signed_16 (abfd, buf);
19337 }
19338
19339 static unsigned int
19340 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19341 {
19342   return bfd_get_32 (abfd, buf);
19343 }
19344
19345 static int
19346 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19347 {
19348   return bfd_get_signed_32 (abfd, buf);
19349 }
19350
19351 static ULONGEST
19352 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19353 {
19354   return bfd_get_64 (abfd, buf);
19355 }
19356
19357 static CORE_ADDR
19358 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19359               unsigned int *bytes_read)
19360 {
19361   struct comp_unit_head *cu_header = &cu->header;
19362   CORE_ADDR retval = 0;
19363
19364   if (cu_header->signed_addr_p)
19365     {
19366       switch (cu_header->addr_size)
19367         {
19368         case 2:
19369           retval = bfd_get_signed_16 (abfd, buf);
19370           break;
19371         case 4:
19372           retval = bfd_get_signed_32 (abfd, buf);
19373           break;
19374         case 8:
19375           retval = bfd_get_signed_64 (abfd, buf);
19376           break;
19377         default:
19378           internal_error (__FILE__, __LINE__,
19379                           _("read_address: bad switch, signed [in module %s]"),
19380                           bfd_get_filename (abfd));
19381         }
19382     }
19383   else
19384     {
19385       switch (cu_header->addr_size)
19386         {
19387         case 2:
19388           retval = bfd_get_16 (abfd, buf);
19389           break;
19390         case 4:
19391           retval = bfd_get_32 (abfd, buf);
19392           break;
19393         case 8:
19394           retval = bfd_get_64 (abfd, buf);
19395           break;
19396         default:
19397           internal_error (__FILE__, __LINE__,
19398                           _("read_address: bad switch, "
19399                             "unsigned [in module %s]"),
19400                           bfd_get_filename (abfd));
19401         }
19402     }
19403
19404   *bytes_read = cu_header->addr_size;
19405   return retval;
19406 }
19407
19408 /* Read the initial length from a section.  The (draft) DWARF 3
19409    specification allows the initial length to take up either 4 bytes
19410    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
19411    bytes describe the length and all offsets will be 8 bytes in length
19412    instead of 4.
19413
19414    An older, non-standard 64-bit format is also handled by this
19415    function.  The older format in question stores the initial length
19416    as an 8-byte quantity without an escape value.  Lengths greater
19417    than 2^32 aren't very common which means that the initial 4 bytes
19418    is almost always zero.  Since a length value of zero doesn't make
19419    sense for the 32-bit format, this initial zero can be considered to
19420    be an escape value which indicates the presence of the older 64-bit
19421    format.  As written, the code can't detect (old format) lengths
19422    greater than 4GB.  If it becomes necessary to handle lengths
19423    somewhat larger than 4GB, we could allow other small values (such
19424    as the non-sensical values of 1, 2, and 3) to also be used as
19425    escape values indicating the presence of the old format.
19426
19427    The value returned via bytes_read should be used to increment the
19428    relevant pointer after calling read_initial_length().
19429
19430    [ Note:  read_initial_length() and read_offset() are based on the
19431      document entitled "DWARF Debugging Information Format", revision
19432      3, draft 8, dated November 19, 2001.  This document was obtained
19433      from:
19434
19435         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19436
19437      This document is only a draft and is subject to change.  (So beware.)
19438
19439      Details regarding the older, non-standard 64-bit format were
19440      determined empirically by examining 64-bit ELF files produced by
19441      the SGI toolchain on an IRIX 6.5 machine.
19442
19443      - Kevin, July 16, 2002
19444    ] */
19445
19446 static LONGEST
19447 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19448 {
19449   LONGEST length = bfd_get_32 (abfd, buf);
19450
19451   if (length == 0xffffffff)
19452     {
19453       length = bfd_get_64 (abfd, buf + 4);
19454       *bytes_read = 12;
19455     }
19456   else if (length == 0)
19457     {
19458       /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX.  */
19459       length = bfd_get_64 (abfd, buf);
19460       *bytes_read = 8;
19461     }
19462   else
19463     {
19464       *bytes_read = 4;
19465     }
19466
19467   return length;
19468 }
19469
19470 /* Cover function for read_initial_length.
19471    Returns the length of the object at BUF, and stores the size of the
19472    initial length in *BYTES_READ and stores the size that offsets will be in
19473    *OFFSET_SIZE.
19474    If the initial length size is not equivalent to that specified in
19475    CU_HEADER then issue a complaint.
19476    This is useful when reading non-comp-unit headers.  */
19477
19478 static LONGEST
19479 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19480                                         const struct comp_unit_head *cu_header,
19481                                         unsigned int *bytes_read,
19482                                         unsigned int *offset_size)
19483 {
19484   LONGEST length = read_initial_length (abfd, buf, bytes_read);
19485
19486   gdb_assert (cu_header->initial_length_size == 4
19487               || cu_header->initial_length_size == 8
19488               || cu_header->initial_length_size == 12);
19489
19490   if (cu_header->initial_length_size != *bytes_read)
19491     complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19492
19493   *offset_size = (*bytes_read == 4) ? 4 : 8;
19494   return length;
19495 }
19496
19497 /* Read an offset from the data stream.  The size of the offset is
19498    given by cu_header->offset_size.  */
19499
19500 static LONGEST
19501 read_offset (bfd *abfd, const gdb_byte *buf,
19502              const struct comp_unit_head *cu_header,
19503              unsigned int *bytes_read)
19504 {
19505   LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19506
19507   *bytes_read = cu_header->offset_size;
19508   return offset;
19509 }
19510
19511 /* Read an offset from the data stream.  */
19512
19513 static LONGEST
19514 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19515 {
19516   LONGEST retval = 0;
19517
19518   switch (offset_size)
19519     {
19520     case 4:
19521       retval = bfd_get_32 (abfd, buf);
19522       break;
19523     case 8:
19524       retval = bfd_get_64 (abfd, buf);
19525       break;
19526     default:
19527       internal_error (__FILE__, __LINE__,
19528                       _("read_offset_1: bad switch [in module %s]"),
19529                       bfd_get_filename (abfd));
19530     }
19531
19532   return retval;
19533 }
19534
19535 static const gdb_byte *
19536 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19537 {
19538   /* If the size of a host char is 8 bits, we can return a pointer
19539      to the buffer, otherwise we have to copy the data to a buffer
19540      allocated on the temporary obstack.  */
19541   gdb_assert (HOST_CHAR_BIT == 8);
19542   return buf;
19543 }
19544
19545 static const char *
19546 read_direct_string (bfd *abfd, const gdb_byte *buf,
19547                     unsigned int *bytes_read_ptr)
19548 {
19549   /* If the size of a host char is 8 bits, we can return a pointer
19550      to the string, otherwise we have to copy the string to a buffer
19551      allocated on the temporary obstack.  */
19552   gdb_assert (HOST_CHAR_BIT == 8);
19553   if (*buf == '\0')
19554     {
19555       *bytes_read_ptr = 1;
19556       return NULL;
19557     }
19558   *bytes_read_ptr = strlen ((const char *) buf) + 1;
19559   return (const char *) buf;
19560 }
19561
19562 /* Return pointer to string at section SECT offset STR_OFFSET with error
19563    reporting strings FORM_NAME and SECT_NAME.  */
19564
19565 static const char *
19566 read_indirect_string_at_offset_from (struct objfile *objfile,
19567                                      bfd *abfd, LONGEST str_offset,
19568                                      struct dwarf2_section_info *sect,
19569                                      const char *form_name,
19570                                      const char *sect_name)
19571 {
19572   dwarf2_read_section (objfile, sect);
19573   if (sect->buffer == NULL)
19574     error (_("%s used without %s section [in module %s]"),
19575            form_name, sect_name, bfd_get_filename (abfd));
19576   if (str_offset >= sect->size)
19577     error (_("%s pointing outside of %s section [in module %s]"),
19578            form_name, sect_name, bfd_get_filename (abfd));
19579   gdb_assert (HOST_CHAR_BIT == 8);
19580   if (sect->buffer[str_offset] == '\0')
19581     return NULL;
19582   return (const char *) (sect->buffer + str_offset);
19583 }
19584
19585 /* Return pointer to string at .debug_str offset STR_OFFSET.  */
19586
19587 static const char *
19588 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19589                                 bfd *abfd, LONGEST str_offset)
19590 {
19591   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19592                                               abfd, str_offset,
19593                                               &dwarf2_per_objfile->str,
19594                                               "DW_FORM_strp", ".debug_str");
19595 }
19596
19597 /* Return pointer to string at .debug_line_str offset STR_OFFSET.  */
19598
19599 static const char *
19600 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19601                                      bfd *abfd, LONGEST str_offset)
19602 {
19603   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19604                                               abfd, str_offset,
19605                                               &dwarf2_per_objfile->line_str,
19606                                               "DW_FORM_line_strp",
19607                                               ".debug_line_str");
19608 }
19609
19610 /* Read a string at offset STR_OFFSET in the .debug_str section from
19611    the .dwz file DWZ.  Throw an error if the offset is too large.  If
19612    the string consists of a single NUL byte, return NULL; otherwise
19613    return a pointer to the string.  */
19614
19615 static const char *
19616 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19617                                LONGEST str_offset)
19618 {
19619   dwarf2_read_section (objfile, &dwz->str);
19620
19621   if (dwz->str.buffer == NULL)
19622     error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19623              "section [in module %s]"),
19624            bfd_get_filename (dwz->dwz_bfd));
19625   if (str_offset >= dwz->str.size)
19626     error (_("DW_FORM_GNU_strp_alt pointing outside of "
19627              ".debug_str section [in module %s]"),
19628            bfd_get_filename (dwz->dwz_bfd));
19629   gdb_assert (HOST_CHAR_BIT == 8);
19630   if (dwz->str.buffer[str_offset] == '\0')
19631     return NULL;
19632   return (const char *) (dwz->str.buffer + str_offset);
19633 }
19634
19635 /* Return pointer to string at .debug_str offset as read from BUF.
19636    BUF is assumed to be in a compilation unit described by CU_HEADER.
19637    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19638
19639 static const char *
19640 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19641                       const gdb_byte *buf,
19642                       const struct comp_unit_head *cu_header,
19643                       unsigned int *bytes_read_ptr)
19644 {
19645   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19646
19647   return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19648 }
19649
19650 /* Return pointer to string at .debug_line_str offset as read from BUF.
19651    BUF is assumed to be in a compilation unit described by CU_HEADER.
19652    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19653
19654 static const char *
19655 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19656                            bfd *abfd, const gdb_byte *buf,
19657                            const struct comp_unit_head *cu_header,
19658                            unsigned int *bytes_read_ptr)
19659 {
19660   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19661
19662   return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19663                                               str_offset);
19664 }
19665
19666 ULONGEST
19667 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19668                           unsigned int *bytes_read_ptr)
19669 {
19670   ULONGEST result;
19671   unsigned int num_read;
19672   int shift;
19673   unsigned char byte;
19674
19675   result = 0;
19676   shift = 0;
19677   num_read = 0;
19678   while (1)
19679     {
19680       byte = bfd_get_8 (abfd, buf);
19681       buf++;
19682       num_read++;
19683       result |= ((ULONGEST) (byte & 127) << shift);
19684       if ((byte & 128) == 0)
19685         {
19686           break;
19687         }
19688       shift += 7;
19689     }
19690   *bytes_read_ptr = num_read;
19691   return result;
19692 }
19693
19694 static LONGEST
19695 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19696                     unsigned int *bytes_read_ptr)
19697 {
19698   ULONGEST result;
19699   int shift, num_read;
19700   unsigned char byte;
19701
19702   result = 0;
19703   shift = 0;
19704   num_read = 0;
19705   while (1)
19706     {
19707       byte = bfd_get_8 (abfd, buf);
19708       buf++;
19709       num_read++;
19710       result |= ((ULONGEST) (byte & 127) << shift);
19711       shift += 7;
19712       if ((byte & 128) == 0)
19713         {
19714           break;
19715         }
19716     }
19717   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19718     result |= -(((ULONGEST) 1) << shift);
19719   *bytes_read_ptr = num_read;
19720   return result;
19721 }
19722
19723 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19724    ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19725    ADDR_SIZE is the size of addresses from the CU header.  */
19726
19727 static CORE_ADDR
19728 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19729                    unsigned int addr_index, ULONGEST addr_base, int addr_size)
19730 {
19731   struct objfile *objfile = dwarf2_per_objfile->objfile;
19732   bfd *abfd = objfile->obfd;
19733   const gdb_byte *info_ptr;
19734
19735   dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19736   if (dwarf2_per_objfile->addr.buffer == NULL)
19737     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19738            objfile_name (objfile));
19739   if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19740     error (_("DW_FORM_addr_index pointing outside of "
19741              ".debug_addr section [in module %s]"),
19742            objfile_name (objfile));
19743   info_ptr = (dwarf2_per_objfile->addr.buffer
19744               + addr_base + addr_index * addr_size);
19745   if (addr_size == 4)
19746     return bfd_get_32 (abfd, info_ptr);
19747   else
19748     return bfd_get_64 (abfd, info_ptr);
19749 }
19750
19751 /* Given index ADDR_INDEX in .debug_addr, fetch the value.  */
19752
19753 static CORE_ADDR
19754 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19755 {
19756   return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19757                             cu->addr_base, cu->header.addr_size);
19758 }
19759
19760 /* Given a pointer to an leb128 value, fetch the value from .debug_addr.  */
19761
19762 static CORE_ADDR
19763 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19764                              unsigned int *bytes_read)
19765 {
19766   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19767   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19768
19769   return read_addr_index (cu, addr_index);
19770 }
19771
19772 /* Data structure to pass results from dwarf2_read_addr_index_reader
19773    back to dwarf2_read_addr_index.  */
19774
19775 struct dwarf2_read_addr_index_data
19776 {
19777   ULONGEST addr_base;
19778   int addr_size;
19779 };
19780
19781 /* die_reader_func for dwarf2_read_addr_index.  */
19782
19783 static void
19784 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19785                                const gdb_byte *info_ptr,
19786                                struct die_info *comp_unit_die,
19787                                int has_children,
19788                                void *data)
19789 {
19790   struct dwarf2_cu *cu = reader->cu;
19791   struct dwarf2_read_addr_index_data *aidata =
19792     (struct dwarf2_read_addr_index_data *) data;
19793
19794   aidata->addr_base = cu->addr_base;
19795   aidata->addr_size = cu->header.addr_size;
19796 }
19797
19798 /* Given an index in .debug_addr, fetch the value.
19799    NOTE: This can be called during dwarf expression evaluation,
19800    long after the debug information has been read, and thus per_cu->cu
19801    may no longer exist.  */
19802
19803 CORE_ADDR
19804 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19805                         unsigned int addr_index)
19806 {
19807   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19808   struct dwarf2_cu *cu = per_cu->cu;
19809   ULONGEST addr_base;
19810   int addr_size;
19811
19812   /* We need addr_base and addr_size.
19813      If we don't have PER_CU->cu, we have to get it.
19814      Nasty, but the alternative is storing the needed info in PER_CU,
19815      which at this point doesn't seem justified: it's not clear how frequently
19816      it would get used and it would increase the size of every PER_CU.
19817      Entry points like dwarf2_per_cu_addr_size do a similar thing
19818      so we're not in uncharted territory here.
19819      Alas we need to be a bit more complicated as addr_base is contained
19820      in the DIE.
19821
19822      We don't need to read the entire CU(/TU).
19823      We just need the header and top level die.
19824
19825      IWBN to use the aging mechanism to let us lazily later discard the CU.
19826      For now we skip this optimization.  */
19827
19828   if (cu != NULL)
19829     {
19830       addr_base = cu->addr_base;
19831       addr_size = cu->header.addr_size;
19832     }
19833   else
19834     {
19835       struct dwarf2_read_addr_index_data aidata;
19836
19837       /* Note: We can't use init_cutu_and_read_dies_simple here,
19838          we need addr_base.  */
19839       init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19840                                dwarf2_read_addr_index_reader, &aidata);
19841       addr_base = aidata.addr_base;
19842       addr_size = aidata.addr_size;
19843     }
19844
19845   return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19846                             addr_size);
19847 }
19848
19849 /* Given a DW_FORM_GNU_str_index, fetch the string.
19850    This is only used by the Fission support.  */
19851
19852 static const char *
19853 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19854 {
19855   struct dwarf2_cu *cu = reader->cu;
19856   struct dwarf2_per_objfile *dwarf2_per_objfile
19857     = cu->per_cu->dwarf2_per_objfile;
19858   struct objfile *objfile = dwarf2_per_objfile->objfile;
19859   const char *objf_name = objfile_name (objfile);
19860   bfd *abfd = objfile->obfd;
19861   struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19862   struct dwarf2_section_info *str_offsets_section =
19863     &reader->dwo_file->sections.str_offsets;
19864   const gdb_byte *info_ptr;
19865   ULONGEST str_offset;
19866   static const char form_name[] = "DW_FORM_GNU_str_index";
19867
19868   dwarf2_read_section (objfile, str_section);
19869   dwarf2_read_section (objfile, str_offsets_section);
19870   if (str_section->buffer == NULL)
19871     error (_("%s used without .debug_str.dwo section"
19872              " in CU at offset %s [in module %s]"),
19873            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19874   if (str_offsets_section->buffer == NULL)
19875     error (_("%s used without .debug_str_offsets.dwo section"
19876              " in CU at offset %s [in module %s]"),
19877            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19878   if (str_index * cu->header.offset_size >= str_offsets_section->size)
19879     error (_("%s pointing outside of .debug_str_offsets.dwo"
19880              " section in CU at offset %s [in module %s]"),
19881            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19882   info_ptr = (str_offsets_section->buffer
19883               + str_index * cu->header.offset_size);
19884   if (cu->header.offset_size == 4)
19885     str_offset = bfd_get_32 (abfd, info_ptr);
19886   else
19887     str_offset = bfd_get_64 (abfd, info_ptr);
19888   if (str_offset >= str_section->size)
19889     error (_("Offset from %s pointing outside of"
19890              " .debug_str.dwo section in CU at offset %s [in module %s]"),
19891            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19892   return (const char *) (str_section->buffer + str_offset);
19893 }
19894
19895 /* Return the length of an LEB128 number in BUF.  */
19896
19897 static int
19898 leb128_size (const gdb_byte *buf)
19899 {
19900   const gdb_byte *begin = buf;
19901   gdb_byte byte;
19902
19903   while (1)
19904     {
19905       byte = *buf++;
19906       if ((byte & 128) == 0)
19907         return buf - begin;
19908     }
19909 }
19910
19911 static void
19912 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19913 {
19914   switch (lang)
19915     {
19916     case DW_LANG_C89:
19917     case DW_LANG_C99:
19918     case DW_LANG_C11:
19919     case DW_LANG_C:
19920     case DW_LANG_UPC:
19921       cu->language = language_c;
19922       break;
19923     case DW_LANG_Java:
19924     case DW_LANG_C_plus_plus:
19925     case DW_LANG_C_plus_plus_11:
19926     case DW_LANG_C_plus_plus_14:
19927       cu->language = language_cplus;
19928       break;
19929     case DW_LANG_D:
19930       cu->language = language_d;
19931       break;
19932     case DW_LANG_Fortran77:
19933     case DW_LANG_Fortran90:
19934     case DW_LANG_Fortran95:
19935     case DW_LANG_Fortran03:
19936     case DW_LANG_Fortran08:
19937       cu->language = language_fortran;
19938       break;
19939     case DW_LANG_Go:
19940       cu->language = language_go;
19941       break;
19942     case DW_LANG_Mips_Assembler:
19943       cu->language = language_asm;
19944       break;
19945     case DW_LANG_Ada83:
19946     case DW_LANG_Ada95:
19947       cu->language = language_ada;
19948       break;
19949     case DW_LANG_Modula2:
19950       cu->language = language_m2;
19951       break;
19952     case DW_LANG_Pascal83:
19953       cu->language = language_pascal;
19954       break;
19955     case DW_LANG_ObjC:
19956       cu->language = language_objc;
19957       break;
19958     case DW_LANG_Rust:
19959     case DW_LANG_Rust_old:
19960       cu->language = language_rust;
19961       break;
19962     case DW_LANG_Cobol74:
19963     case DW_LANG_Cobol85:
19964     default:
19965       cu->language = language_minimal;
19966       break;
19967     }
19968   cu->language_defn = language_def (cu->language);
19969 }
19970
19971 /* Return the named attribute or NULL if not there.  */
19972
19973 static struct attribute *
19974 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19975 {
19976   for (;;)
19977     {
19978       unsigned int i;
19979       struct attribute *spec = NULL;
19980
19981       for (i = 0; i < die->num_attrs; ++i)
19982         {
19983           if (die->attrs[i].name == name)
19984             return &die->attrs[i];
19985           if (die->attrs[i].name == DW_AT_specification
19986               || die->attrs[i].name == DW_AT_abstract_origin)
19987             spec = &die->attrs[i];
19988         }
19989
19990       if (!spec)
19991         break;
19992
19993       die = follow_die_ref (die, spec, &cu);
19994     }
19995
19996   return NULL;
19997 }
19998
19999 /* Return the named attribute or NULL if not there,
20000    but do not follow DW_AT_specification, etc.
20001    This is for use in contexts where we're reading .debug_types dies.
20002    Following DW_AT_specification, DW_AT_abstract_origin will take us
20003    back up the chain, and we want to go down.  */
20004
20005 static struct attribute *
20006 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
20007 {
20008   unsigned int i;
20009
20010   for (i = 0; i < die->num_attrs; ++i)
20011     if (die->attrs[i].name == name)
20012       return &die->attrs[i];
20013
20014   return NULL;
20015 }
20016
20017 /* Return the string associated with a string-typed attribute, or NULL if it
20018    is either not found or is of an incorrect type.  */
20019
20020 static const char *
20021 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20022 {
20023   struct attribute *attr;
20024   const char *str = NULL;
20025
20026   attr = dwarf2_attr (die, name, cu);
20027
20028   if (attr != NULL)
20029     {
20030       if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20031           || attr->form == DW_FORM_string
20032           || attr->form == DW_FORM_GNU_str_index
20033           || attr->form == DW_FORM_GNU_strp_alt)
20034         str = DW_STRING (attr);
20035       else
20036         complaint (_("string type expected for attribute %s for "
20037                      "DIE at %s in module %s"),
20038                    dwarf_attr_name (name), sect_offset_str (die->sect_off),
20039                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20040     }
20041
20042   return str;
20043 }
20044
20045 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20046    and holds a non-zero value.  This function should only be used for
20047    DW_FORM_flag or DW_FORM_flag_present attributes.  */
20048
20049 static int
20050 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20051 {
20052   struct attribute *attr = dwarf2_attr (die, name, cu);
20053
20054   return (attr && DW_UNSND (attr));
20055 }
20056
20057 static int
20058 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20059 {
20060   /* A DIE is a declaration if it has a DW_AT_declaration attribute
20061      which value is non-zero.  However, we have to be careful with
20062      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20063      (via dwarf2_flag_true_p) follows this attribute.  So we may
20064      end up accidently finding a declaration attribute that belongs
20065      to a different DIE referenced by the specification attribute,
20066      even though the given DIE does not have a declaration attribute.  */
20067   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20068           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20069 }
20070
20071 /* Return the die giving the specification for DIE, if there is
20072    one.  *SPEC_CU is the CU containing DIE on input, and the CU
20073    containing the return value on output.  If there is no
20074    specification, but there is an abstract origin, that is
20075    returned.  */
20076
20077 static struct die_info *
20078 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20079 {
20080   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20081                                              *spec_cu);
20082
20083   if (spec_attr == NULL)
20084     spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20085
20086   if (spec_attr == NULL)
20087     return NULL;
20088   else
20089     return follow_die_ref (die, spec_attr, spec_cu);
20090 }
20091
20092 /* Stub for free_line_header to match void * callback types.  */
20093
20094 static void
20095 free_line_header_voidp (void *arg)
20096 {
20097   struct line_header *lh = (struct line_header *) arg;
20098
20099   delete lh;
20100 }
20101
20102 void
20103 line_header::add_include_dir (const char *include_dir)
20104 {
20105   if (dwarf_line_debug >= 2)
20106     fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20107                         include_dirs.size () + 1, include_dir);
20108
20109   include_dirs.push_back (include_dir);
20110 }
20111
20112 void
20113 line_header::add_file_name (const char *name,
20114                             dir_index d_index,
20115                             unsigned int mod_time,
20116                             unsigned int length)
20117 {
20118   if (dwarf_line_debug >= 2)
20119     fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20120                         (unsigned) file_names.size () + 1, name);
20121
20122   file_names.emplace_back (name, d_index, mod_time, length);
20123 }
20124
20125 /* A convenience function to find the proper .debug_line section for a CU.  */
20126
20127 static struct dwarf2_section_info *
20128 get_debug_line_section (struct dwarf2_cu *cu)
20129 {
20130   struct dwarf2_section_info *section;
20131   struct dwarf2_per_objfile *dwarf2_per_objfile
20132     = cu->per_cu->dwarf2_per_objfile;
20133
20134   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20135      DWO file.  */
20136   if (cu->dwo_unit && cu->per_cu->is_debug_types)
20137     section = &cu->dwo_unit->dwo_file->sections.line;
20138   else if (cu->per_cu->is_dwz)
20139     {
20140       struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20141
20142       section = &dwz->line;
20143     }
20144   else
20145     section = &dwarf2_per_objfile->line;
20146
20147   return section;
20148 }
20149
20150 /* Read directory or file name entry format, starting with byte of
20151    format count entries, ULEB128 pairs of entry formats, ULEB128 of
20152    entries count and the entries themselves in the described entry
20153    format.  */
20154
20155 static void
20156 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20157                         bfd *abfd, const gdb_byte **bufp,
20158                         struct line_header *lh,
20159                         const struct comp_unit_head *cu_header,
20160                         void (*callback) (struct line_header *lh,
20161                                           const char *name,
20162                                           dir_index d_index,
20163                                           unsigned int mod_time,
20164                                           unsigned int length))
20165 {
20166   gdb_byte format_count, formati;
20167   ULONGEST data_count, datai;
20168   const gdb_byte *buf = *bufp;
20169   const gdb_byte *format_header_data;
20170   unsigned int bytes_read;
20171
20172   format_count = read_1_byte (abfd, buf);
20173   buf += 1;
20174   format_header_data = buf;
20175   for (formati = 0; formati < format_count; formati++)
20176     {
20177       read_unsigned_leb128 (abfd, buf, &bytes_read);
20178       buf += bytes_read;
20179       read_unsigned_leb128 (abfd, buf, &bytes_read);
20180       buf += bytes_read;
20181     }
20182
20183   data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20184   buf += bytes_read;
20185   for (datai = 0; datai < data_count; datai++)
20186     {
20187       const gdb_byte *format = format_header_data;
20188       struct file_entry fe;
20189
20190       for (formati = 0; formati < format_count; formati++)
20191         {
20192           ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20193           format += bytes_read;
20194
20195           ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
20196           format += bytes_read;
20197
20198           gdb::optional<const char *> string;
20199           gdb::optional<unsigned int> uint;
20200
20201           switch (form)
20202             {
20203             case DW_FORM_string:
20204               string.emplace (read_direct_string (abfd, buf, &bytes_read));
20205               buf += bytes_read;
20206               break;
20207
20208             case DW_FORM_line_strp:
20209               string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20210                                                          abfd, buf,
20211                                                          cu_header,
20212                                                          &bytes_read));
20213               buf += bytes_read;
20214               break;
20215
20216             case DW_FORM_data1:
20217               uint.emplace (read_1_byte (abfd, buf));
20218               buf += 1;
20219               break;
20220
20221             case DW_FORM_data2:
20222               uint.emplace (read_2_bytes (abfd, buf));
20223               buf += 2;
20224               break;
20225
20226             case DW_FORM_data4:
20227               uint.emplace (read_4_bytes (abfd, buf));
20228               buf += 4;
20229               break;
20230
20231             case DW_FORM_data8:
20232               uint.emplace (read_8_bytes (abfd, buf));
20233               buf += 8;
20234               break;
20235
20236             case DW_FORM_udata:
20237               uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20238               buf += bytes_read;
20239               break;
20240
20241             case DW_FORM_block:
20242               /* It is valid only for DW_LNCT_timestamp which is ignored by
20243                  current GDB.  */
20244               break;
20245             }
20246
20247           switch (content_type)
20248             {
20249             case DW_LNCT_path:
20250               if (string.has_value ())
20251                 fe.name = *string;
20252               break;
20253             case DW_LNCT_directory_index:
20254               if (uint.has_value ())
20255                 fe.d_index = (dir_index) *uint;
20256               break;
20257             case DW_LNCT_timestamp:
20258               if (uint.has_value ())
20259                 fe.mod_time = *uint;
20260               break;
20261             case DW_LNCT_size:
20262               if (uint.has_value ())
20263                 fe.length = *uint;
20264               break;
20265             case DW_LNCT_MD5:
20266               break;
20267             default:
20268               complaint (_("Unknown format content type %s"),
20269                          pulongest (content_type));
20270             }
20271         }
20272
20273       callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20274     }
20275
20276   *bufp = buf;
20277 }
20278
20279 /* Read the statement program header starting at OFFSET in
20280    .debug_line, or .debug_line.dwo.  Return a pointer
20281    to a struct line_header, allocated using xmalloc.
20282    Returns NULL if there is a problem reading the header, e.g., if it
20283    has a version we don't understand.
20284
20285    NOTE: the strings in the include directory and file name tables of
20286    the returned object point into the dwarf line section buffer,
20287    and must not be freed.  */
20288
20289 static line_header_up
20290 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20291 {
20292   const gdb_byte *line_ptr;
20293   unsigned int bytes_read, offset_size;
20294   int i;
20295   const char *cur_dir, *cur_file;
20296   struct dwarf2_section_info *section;
20297   bfd *abfd;
20298   struct dwarf2_per_objfile *dwarf2_per_objfile
20299     = cu->per_cu->dwarf2_per_objfile;
20300
20301   section = get_debug_line_section (cu);
20302   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20303   if (section->buffer == NULL)
20304     {
20305       if (cu->dwo_unit && cu->per_cu->is_debug_types)
20306         complaint (_("missing .debug_line.dwo section"));
20307       else
20308         complaint (_("missing .debug_line section"));
20309       return 0;
20310     }
20311
20312   /* We can't do this until we know the section is non-empty.
20313      Only then do we know we have such a section.  */
20314   abfd = get_section_bfd_owner (section);
20315
20316   /* Make sure that at least there's room for the total_length field.
20317      That could be 12 bytes long, but we're just going to fudge that.  */
20318   if (to_underlying (sect_off) + 4 >= section->size)
20319     {
20320       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20321       return 0;
20322     }
20323
20324   line_header_up lh (new line_header ());
20325
20326   lh->sect_off = sect_off;
20327   lh->offset_in_dwz = cu->per_cu->is_dwz;
20328
20329   line_ptr = section->buffer + to_underlying (sect_off);
20330
20331   /* Read in the header.  */
20332   lh->total_length =
20333     read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20334                                             &bytes_read, &offset_size);
20335   line_ptr += bytes_read;
20336   if (line_ptr + lh->total_length > (section->buffer + section->size))
20337     {
20338       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20339       return 0;
20340     }
20341   lh->statement_program_end = line_ptr + lh->total_length;
20342   lh->version = read_2_bytes (abfd, line_ptr);
20343   line_ptr += 2;
20344   if (lh->version > 5)
20345     {
20346       /* This is a version we don't understand.  The format could have
20347          changed in ways we don't handle properly so just punt.  */
20348       complaint (_("unsupported version in .debug_line section"));
20349       return NULL;
20350     }
20351   if (lh->version >= 5)
20352     {
20353       gdb_byte segment_selector_size;
20354
20355       /* Skip address size.  */
20356       read_1_byte (abfd, line_ptr);
20357       line_ptr += 1;
20358
20359       segment_selector_size = read_1_byte (abfd, line_ptr);
20360       line_ptr += 1;
20361       if (segment_selector_size != 0)
20362         {
20363           complaint (_("unsupported segment selector size %u "
20364                        "in .debug_line section"),
20365                      segment_selector_size);
20366           return NULL;
20367         }
20368     }
20369   lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20370   line_ptr += offset_size;
20371   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20372   line_ptr += 1;
20373   if (lh->version >= 4)
20374     {
20375       lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20376       line_ptr += 1;
20377     }
20378   else
20379     lh->maximum_ops_per_instruction = 1;
20380
20381   if (lh->maximum_ops_per_instruction == 0)
20382     {
20383       lh->maximum_ops_per_instruction = 1;
20384       complaint (_("invalid maximum_ops_per_instruction "
20385                    "in `.debug_line' section"));
20386     }
20387
20388   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20389   line_ptr += 1;
20390   lh->line_base = read_1_signed_byte (abfd, line_ptr);
20391   line_ptr += 1;
20392   lh->line_range = read_1_byte (abfd, line_ptr);
20393   line_ptr += 1;
20394   lh->opcode_base = read_1_byte (abfd, line_ptr);
20395   line_ptr += 1;
20396   lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20397
20398   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
20399   for (i = 1; i < lh->opcode_base; ++i)
20400     {
20401       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20402       line_ptr += 1;
20403     }
20404
20405   if (lh->version >= 5)
20406     {
20407       /* Read directory table.  */
20408       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20409                               &cu->header,
20410                               [] (struct line_header *header, const char *name,
20411                                   dir_index d_index, unsigned int mod_time,
20412                                   unsigned int length)
20413         {
20414           header->add_include_dir (name);
20415         });
20416
20417       /* Read file name table.  */
20418       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20419                               &cu->header,
20420                               [] (struct line_header *header, const char *name,
20421                                   dir_index d_index, unsigned int mod_time,
20422                                   unsigned int length)
20423         {
20424           header->add_file_name (name, d_index, mod_time, length);
20425         });
20426     }
20427   else
20428     {
20429       /* Read directory table.  */
20430       while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20431         {
20432           line_ptr += bytes_read;
20433           lh->add_include_dir (cur_dir);
20434         }
20435       line_ptr += bytes_read;
20436
20437       /* Read file name table.  */
20438       while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20439         {
20440           unsigned int mod_time, length;
20441           dir_index d_index;
20442
20443           line_ptr += bytes_read;
20444           d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20445           line_ptr += bytes_read;
20446           mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20447           line_ptr += bytes_read;
20448           length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20449           line_ptr += bytes_read;
20450
20451           lh->add_file_name (cur_file, d_index, mod_time, length);
20452         }
20453       line_ptr += bytes_read;
20454     }
20455   lh->statement_program_start = line_ptr;
20456
20457   if (line_ptr > (section->buffer + section->size))
20458     complaint (_("line number info header doesn't "
20459                  "fit in `.debug_line' section"));
20460
20461   return lh;
20462 }
20463
20464 /* Subroutine of dwarf_decode_lines to simplify it.
20465    Return the file name of the psymtab for included file FILE_INDEX
20466    in line header LH of PST.
20467    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20468    If space for the result is malloc'd, *NAME_HOLDER will be set.
20469    Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.  */
20470
20471 static const char *
20472 psymtab_include_file_name (const struct line_header *lh, int file_index,
20473                            const struct partial_symtab *pst,
20474                            const char *comp_dir,
20475                            gdb::unique_xmalloc_ptr<char> *name_holder)
20476 {
20477   const file_entry &fe = lh->file_names[file_index];
20478   const char *include_name = fe.name;
20479   const char *include_name_to_compare = include_name;
20480   const char *pst_filename;
20481   int file_is_pst;
20482
20483   const char *dir_name = fe.include_dir (lh);
20484
20485   gdb::unique_xmalloc_ptr<char> hold_compare;
20486   if (!IS_ABSOLUTE_PATH (include_name)
20487       && (dir_name != NULL || comp_dir != NULL))
20488     {
20489       /* Avoid creating a duplicate psymtab for PST.
20490          We do this by comparing INCLUDE_NAME and PST_FILENAME.
20491          Before we do the comparison, however, we need to account
20492          for DIR_NAME and COMP_DIR.
20493          First prepend dir_name (if non-NULL).  If we still don't
20494          have an absolute path prepend comp_dir (if non-NULL).
20495          However, the directory we record in the include-file's
20496          psymtab does not contain COMP_DIR (to match the
20497          corresponding symtab(s)).
20498
20499          Example:
20500
20501          bash$ cd /tmp
20502          bash$ gcc -g ./hello.c
20503          include_name = "hello.c"
20504          dir_name = "."
20505          DW_AT_comp_dir = comp_dir = "/tmp"
20506          DW_AT_name = "./hello.c"
20507
20508       */
20509
20510       if (dir_name != NULL)
20511         {
20512           name_holder->reset (concat (dir_name, SLASH_STRING,
20513                                       include_name, (char *) NULL));
20514           include_name = name_holder->get ();
20515           include_name_to_compare = include_name;
20516         }
20517       if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20518         {
20519           hold_compare.reset (concat (comp_dir, SLASH_STRING,
20520                                       include_name, (char *) NULL));
20521           include_name_to_compare = hold_compare.get ();
20522         }
20523     }
20524
20525   pst_filename = pst->filename;
20526   gdb::unique_xmalloc_ptr<char> copied_name;
20527   if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20528     {
20529       copied_name.reset (concat (pst->dirname, SLASH_STRING,
20530                                  pst_filename, (char *) NULL));
20531       pst_filename = copied_name.get ();
20532     }
20533
20534   file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20535
20536   if (file_is_pst)
20537     return NULL;
20538   return include_name;
20539 }
20540
20541 /* State machine to track the state of the line number program.  */
20542
20543 class lnp_state_machine
20544 {
20545 public:
20546   /* Initialize a machine state for the start of a line number
20547      program.  */
20548   lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20549                      bool record_lines_p);
20550
20551   file_entry *current_file ()
20552   {
20553     /* lh->file_names is 0-based, but the file name numbers in the
20554        statement program are 1-based.  */
20555     return m_line_header->file_name_at (m_file);
20556   }
20557
20558   /* Record the line in the state machine.  END_SEQUENCE is true if
20559      we're processing the end of a sequence.  */
20560   void record_line (bool end_sequence);
20561
20562   /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20563      nop-out rest of the lines in this sequence.  */
20564   void check_line_address (struct dwarf2_cu *cu,
20565                            const gdb_byte *line_ptr,
20566                            CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20567
20568   void handle_set_discriminator (unsigned int discriminator)
20569   {
20570     m_discriminator = discriminator;
20571     m_line_has_non_zero_discriminator |= discriminator != 0;
20572   }
20573
20574   /* Handle DW_LNE_set_address.  */
20575   void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20576   {
20577     m_op_index = 0;
20578     address += baseaddr;
20579     m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20580   }
20581
20582   /* Handle DW_LNS_advance_pc.  */
20583   void handle_advance_pc (CORE_ADDR adjust);
20584
20585   /* Handle a special opcode.  */
20586   void handle_special_opcode (unsigned char op_code);
20587
20588   /* Handle DW_LNS_advance_line.  */
20589   void handle_advance_line (int line_delta)
20590   {
20591     advance_line (line_delta);
20592   }
20593
20594   /* Handle DW_LNS_set_file.  */
20595   void handle_set_file (file_name_index file);
20596
20597   /* Handle DW_LNS_negate_stmt.  */
20598   void handle_negate_stmt ()
20599   {
20600     m_is_stmt = !m_is_stmt;
20601   }
20602
20603   /* Handle DW_LNS_const_add_pc.  */
20604   void handle_const_add_pc ();
20605
20606   /* Handle DW_LNS_fixed_advance_pc.  */
20607   void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20608   {
20609     m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20610     m_op_index = 0;
20611   }
20612
20613   /* Handle DW_LNS_copy.  */
20614   void handle_copy ()
20615   {
20616     record_line (false);
20617     m_discriminator = 0;
20618   }
20619
20620   /* Handle DW_LNE_end_sequence.  */
20621   void handle_end_sequence ()
20622   {
20623     m_currently_recording_lines = true;
20624   }
20625
20626 private:
20627   /* Advance the line by LINE_DELTA.  */
20628   void advance_line (int line_delta)
20629   {
20630     m_line += line_delta;
20631
20632     if (line_delta != 0)
20633       m_line_has_non_zero_discriminator = m_discriminator != 0;
20634   }
20635
20636   struct dwarf2_cu *m_cu;
20637
20638   gdbarch *m_gdbarch;
20639
20640   /* True if we're recording lines.
20641      Otherwise we're building partial symtabs and are just interested in
20642      finding include files mentioned by the line number program.  */
20643   bool m_record_lines_p;
20644
20645   /* The line number header.  */
20646   line_header *m_line_header;
20647
20648   /* These are part of the standard DWARF line number state machine,
20649      and initialized according to the DWARF spec.  */
20650
20651   unsigned char m_op_index = 0;
20652   /* The line table index (1-based) of the current file.  */
20653   file_name_index m_file = (file_name_index) 1;
20654   unsigned int m_line = 1;
20655
20656   /* These are initialized in the constructor.  */
20657
20658   CORE_ADDR m_address;
20659   bool m_is_stmt;
20660   unsigned int m_discriminator;
20661
20662   /* Additional bits of state we need to track.  */
20663
20664   /* The last file that we called dwarf2_start_subfile for.
20665      This is only used for TLLs.  */
20666   unsigned int m_last_file = 0;
20667   /* The last file a line number was recorded for.  */
20668   struct subfile *m_last_subfile = NULL;
20669
20670   /* When true, record the lines we decode.  */
20671   bool m_currently_recording_lines = false;
20672
20673   /* The last line number that was recorded, used to coalesce
20674      consecutive entries for the same line.  This can happen, for
20675      example, when discriminators are present.  PR 17276.  */
20676   unsigned int m_last_line = 0;
20677   bool m_line_has_non_zero_discriminator = false;
20678 };
20679
20680 void
20681 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20682 {
20683   CORE_ADDR addr_adj = (((m_op_index + adjust)
20684                          / m_line_header->maximum_ops_per_instruction)
20685                         * m_line_header->minimum_instruction_length);
20686   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20687   m_op_index = ((m_op_index + adjust)
20688                 % m_line_header->maximum_ops_per_instruction);
20689 }
20690
20691 void
20692 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20693 {
20694   unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20695   CORE_ADDR addr_adj = (((m_op_index
20696                           + (adj_opcode / m_line_header->line_range))
20697                          / m_line_header->maximum_ops_per_instruction)
20698                         * m_line_header->minimum_instruction_length);
20699   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20700   m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20701                 % m_line_header->maximum_ops_per_instruction);
20702
20703   int line_delta = (m_line_header->line_base
20704                     + (adj_opcode % m_line_header->line_range));
20705   advance_line (line_delta);
20706   record_line (false);
20707   m_discriminator = 0;
20708 }
20709
20710 void
20711 lnp_state_machine::handle_set_file (file_name_index file)
20712 {
20713   m_file = file;
20714
20715   const file_entry *fe = current_file ();
20716   if (fe == NULL)
20717     dwarf2_debug_line_missing_file_complaint ();
20718   else if (m_record_lines_p)
20719     {
20720       const char *dir = fe->include_dir (m_line_header);
20721
20722       m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20723       m_line_has_non_zero_discriminator = m_discriminator != 0;
20724       dwarf2_start_subfile (m_cu, fe->name, dir);
20725     }
20726 }
20727
20728 void
20729 lnp_state_machine::handle_const_add_pc ()
20730 {
20731   CORE_ADDR adjust
20732     = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20733
20734   CORE_ADDR addr_adj
20735     = (((m_op_index + adjust)
20736         / m_line_header->maximum_ops_per_instruction)
20737        * m_line_header->minimum_instruction_length);
20738
20739   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20740   m_op_index = ((m_op_index + adjust)
20741                 % m_line_header->maximum_ops_per_instruction);
20742 }
20743
20744 /* Return non-zero if we should add LINE to the line number table.
20745    LINE is the line to add, LAST_LINE is the last line that was added,
20746    LAST_SUBFILE is the subfile for LAST_LINE.
20747    LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20748    had a non-zero discriminator.
20749
20750    We have to be careful in the presence of discriminators.
20751    E.g., for this line:
20752
20753      for (i = 0; i < 100000; i++);
20754
20755    clang can emit four line number entries for that one line,
20756    each with a different discriminator.
20757    See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20758
20759    However, we want gdb to coalesce all four entries into one.
20760    Otherwise the user could stepi into the middle of the line and
20761    gdb would get confused about whether the pc really was in the
20762    middle of the line.
20763
20764    Things are further complicated by the fact that two consecutive
20765    line number entries for the same line is a heuristic used by gcc
20766    to denote the end of the prologue.  So we can't just discard duplicate
20767    entries, we have to be selective about it.  The heuristic we use is
20768    that we only collapse consecutive entries for the same line if at least
20769    one of those entries has a non-zero discriminator.  PR 17276.
20770
20771    Note: Addresses in the line number state machine can never go backwards
20772    within one sequence, thus this coalescing is ok.  */
20773
20774 static int
20775 dwarf_record_line_p (struct dwarf2_cu *cu,
20776                      unsigned int line, unsigned int last_line,
20777                      int line_has_non_zero_discriminator,
20778                      struct subfile *last_subfile)
20779 {
20780   if (cu->get_builder ()->get_current_subfile () != last_subfile)
20781     return 1;
20782   if (line != last_line)
20783     return 1;
20784   /* Same line for the same file that we've seen already.
20785      As a last check, for pr 17276, only record the line if the line
20786      has never had a non-zero discriminator.  */
20787   if (!line_has_non_zero_discriminator)
20788     return 1;
20789   return 0;
20790 }
20791
20792 /* Use the CU's builder to record line number LINE beginning at
20793    address ADDRESS in the line table of subfile SUBFILE.  */
20794
20795 static void
20796 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20797                      unsigned int line, CORE_ADDR address,
20798                      struct dwarf2_cu *cu)
20799 {
20800   CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20801
20802   if (dwarf_line_debug)
20803     {
20804       fprintf_unfiltered (gdb_stdlog,
20805                           "Recording line %u, file %s, address %s\n",
20806                           line, lbasename (subfile->name),
20807                           paddress (gdbarch, address));
20808     }
20809
20810   if (cu != nullptr)
20811     cu->get_builder ()->record_line (subfile, line, addr);
20812 }
20813
20814 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20815    Mark the end of a set of line number records.
20816    The arguments are the same as for dwarf_record_line_1.
20817    If SUBFILE is NULL the request is ignored.  */
20818
20819 static void
20820 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20821                    CORE_ADDR address, struct dwarf2_cu *cu)
20822 {
20823   if (subfile == NULL)
20824     return;
20825
20826   if (dwarf_line_debug)
20827     {
20828       fprintf_unfiltered (gdb_stdlog,
20829                           "Finishing current line, file %s, address %s\n",
20830                           lbasename (subfile->name),
20831                           paddress (gdbarch, address));
20832     }
20833
20834   dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20835 }
20836
20837 void
20838 lnp_state_machine::record_line (bool end_sequence)
20839 {
20840   if (dwarf_line_debug)
20841     {
20842       fprintf_unfiltered (gdb_stdlog,
20843                           "Processing actual line %u: file %u,"
20844                           " address %s, is_stmt %u, discrim %u\n",
20845                           m_line, to_underlying (m_file),
20846                           paddress (m_gdbarch, m_address),
20847                           m_is_stmt, m_discriminator);
20848     }
20849
20850   file_entry *fe = current_file ();
20851
20852   if (fe == NULL)
20853     dwarf2_debug_line_missing_file_complaint ();
20854   /* For now we ignore lines not starting on an instruction boundary.
20855      But not when processing end_sequence for compatibility with the
20856      previous version of the code.  */
20857   else if (m_op_index == 0 || end_sequence)
20858     {
20859       fe->included_p = 1;
20860       if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20861         {
20862           if (m_last_subfile != m_cu->get_builder ()->get_current_subfile ()
20863               || end_sequence)
20864             {
20865               dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20866                                  m_currently_recording_lines ? m_cu : nullptr);
20867             }
20868
20869           if (!end_sequence)
20870             {
20871               if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20872                                        m_line_has_non_zero_discriminator,
20873                                        m_last_subfile))
20874                 {
20875                   buildsym_compunit *builder = m_cu->get_builder ();
20876                   dwarf_record_line_1 (m_gdbarch,
20877                                        builder->get_current_subfile (),
20878                                        m_line, m_address,
20879                                        m_currently_recording_lines ? m_cu : nullptr);
20880                 }
20881               m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20882               m_last_line = m_line;
20883             }
20884         }
20885     }
20886 }
20887
20888 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20889                                       line_header *lh, bool record_lines_p)
20890 {
20891   m_cu = cu;
20892   m_gdbarch = arch;
20893   m_record_lines_p = record_lines_p;
20894   m_line_header = lh;
20895
20896   m_currently_recording_lines = true;
20897
20898   /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20899      was a line entry for it so that the backend has a chance to adjust it
20900      and also record it in case it needs it.  This is currently used by MIPS
20901      code, cf. `mips_adjust_dwarf2_line'.  */
20902   m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20903   m_is_stmt = lh->default_is_stmt;
20904   m_discriminator = 0;
20905 }
20906
20907 void
20908 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20909                                        const gdb_byte *line_ptr,
20910                                        CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20911 {
20912   /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20913      the pc range of the CU.  However, we restrict the test to only ADDRESS
20914      values of zero to preserve GDB's previous behaviour which is to handle
20915      the specific case of a function being GC'd by the linker.  */
20916
20917   if (address == 0 && address < unrelocated_lowpc)
20918     {
20919       /* This line table is for a function which has been
20920          GCd by the linker.  Ignore it.  PR gdb/12528 */
20921
20922       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20923       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20924
20925       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20926                  line_offset, objfile_name (objfile));
20927       m_currently_recording_lines = false;
20928       /* Note: m_currently_recording_lines is left as false until we see
20929          DW_LNE_end_sequence.  */
20930     }
20931 }
20932
20933 /* Subroutine of dwarf_decode_lines to simplify it.
20934    Process the line number information in LH.
20935    If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20936    program in order to set included_p for every referenced header.  */
20937
20938 static void
20939 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20940                       const int decode_for_pst_p, CORE_ADDR lowpc)
20941 {
20942   const gdb_byte *line_ptr, *extended_end;
20943   const gdb_byte *line_end;
20944   unsigned int bytes_read, extended_len;
20945   unsigned char op_code, extended_op;
20946   CORE_ADDR baseaddr;
20947   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20948   bfd *abfd = objfile->obfd;
20949   struct gdbarch *gdbarch = get_objfile_arch (objfile);
20950   /* True if we're recording line info (as opposed to building partial
20951      symtabs and just interested in finding include files mentioned by
20952      the line number program).  */
20953   bool record_lines_p = !decode_for_pst_p;
20954
20955   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20956
20957   line_ptr = lh->statement_program_start;
20958   line_end = lh->statement_program_end;
20959
20960   /* Read the statement sequences until there's nothing left.  */
20961   while (line_ptr < line_end)
20962     {
20963       /* The DWARF line number program state machine.  Reset the state
20964          machine at the start of each sequence.  */
20965       lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20966       bool end_sequence = false;
20967
20968       if (record_lines_p)
20969         {
20970           /* Start a subfile for the current file of the state
20971              machine.  */
20972           const file_entry *fe = state_machine.current_file ();
20973
20974           if (fe != NULL)
20975             dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20976         }
20977
20978       /* Decode the table.  */
20979       while (line_ptr < line_end && !end_sequence)
20980         {
20981           op_code = read_1_byte (abfd, line_ptr);
20982           line_ptr += 1;
20983
20984           if (op_code >= lh->opcode_base)
20985             {
20986               /* Special opcode.  */
20987               state_machine.handle_special_opcode (op_code);
20988             }
20989           else switch (op_code)
20990             {
20991             case DW_LNS_extended_op:
20992               extended_len = read_unsigned_leb128 (abfd, line_ptr,
20993                                                    &bytes_read);
20994               line_ptr += bytes_read;
20995               extended_end = line_ptr + extended_len;
20996               extended_op = read_1_byte (abfd, line_ptr);
20997               line_ptr += 1;
20998               switch (extended_op)
20999                 {
21000                 case DW_LNE_end_sequence:
21001                   state_machine.handle_end_sequence ();
21002                   end_sequence = true;
21003                   break;
21004                 case DW_LNE_set_address:
21005                   {
21006                     CORE_ADDR address
21007                       = read_address (abfd, line_ptr, cu, &bytes_read);
21008                     line_ptr += bytes_read;
21009
21010                     state_machine.check_line_address (cu, line_ptr,
21011                                                       lowpc - baseaddr, address);
21012                     state_machine.handle_set_address (baseaddr, address);
21013                   }
21014                   break;
21015                 case DW_LNE_define_file:
21016                   {
21017                     const char *cur_file;
21018                     unsigned int mod_time, length;
21019                     dir_index dindex;
21020
21021                     cur_file = read_direct_string (abfd, line_ptr,
21022                                                    &bytes_read);
21023                     line_ptr += bytes_read;
21024                     dindex = (dir_index)
21025                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21026                     line_ptr += bytes_read;
21027                     mod_time =
21028                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21029                     line_ptr += bytes_read;
21030                     length =
21031                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21032                     line_ptr += bytes_read;
21033                     lh->add_file_name (cur_file, dindex, mod_time, length);
21034                   }
21035                   break;
21036                 case DW_LNE_set_discriminator:
21037                   {
21038                     /* The discriminator is not interesting to the
21039                        debugger; just ignore it.  We still need to
21040                        check its value though:
21041                        if there are consecutive entries for the same
21042                        (non-prologue) line we want to coalesce them.
21043                        PR 17276.  */
21044                     unsigned int discr
21045                       = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21046                     line_ptr += bytes_read;
21047
21048                     state_machine.handle_set_discriminator (discr);
21049                   }
21050                   break;
21051                 default:
21052                   complaint (_("mangled .debug_line section"));
21053                   return;
21054                 }
21055               /* Make sure that we parsed the extended op correctly.  If e.g.
21056                  we expected a different address size than the producer used,
21057                  we may have read the wrong number of bytes.  */
21058               if (line_ptr != extended_end)
21059                 {
21060                   complaint (_("mangled .debug_line section"));
21061                   return;
21062                 }
21063               break;
21064             case DW_LNS_copy:
21065               state_machine.handle_copy ();
21066               break;
21067             case DW_LNS_advance_pc:
21068               {
21069                 CORE_ADDR adjust
21070                   = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21071                 line_ptr += bytes_read;
21072
21073                 state_machine.handle_advance_pc (adjust);
21074               }
21075               break;
21076             case DW_LNS_advance_line:
21077               {
21078                 int line_delta
21079                   = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21080                 line_ptr += bytes_read;
21081
21082                 state_machine.handle_advance_line (line_delta);
21083               }
21084               break;
21085             case DW_LNS_set_file:
21086               {
21087                 file_name_index file
21088                   = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21089                                                             &bytes_read);
21090                 line_ptr += bytes_read;
21091
21092                 state_machine.handle_set_file (file);
21093               }
21094               break;
21095             case DW_LNS_set_column:
21096               (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21097               line_ptr += bytes_read;
21098               break;
21099             case DW_LNS_negate_stmt:
21100               state_machine.handle_negate_stmt ();
21101               break;
21102             case DW_LNS_set_basic_block:
21103               break;
21104             /* Add to the address register of the state machine the
21105                address increment value corresponding to special opcode
21106                255.  I.e., this value is scaled by the minimum
21107                instruction length since special opcode 255 would have
21108                scaled the increment.  */
21109             case DW_LNS_const_add_pc:
21110               state_machine.handle_const_add_pc ();
21111               break;
21112             case DW_LNS_fixed_advance_pc:
21113               {
21114                 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21115                 line_ptr += 2;
21116
21117                 state_machine.handle_fixed_advance_pc (addr_adj);
21118               }
21119               break;
21120             default:
21121               {
21122                 /* Unknown standard opcode, ignore it.  */
21123                 int i;
21124
21125                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21126                   {
21127                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21128                     line_ptr += bytes_read;
21129                   }
21130               }
21131             }
21132         }
21133
21134       if (!end_sequence)
21135         dwarf2_debug_line_missing_end_sequence_complaint ();
21136
21137       /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21138          in which case we still finish recording the last line).  */
21139       state_machine.record_line (true);
21140     }
21141 }
21142
21143 /* Decode the Line Number Program (LNP) for the given line_header
21144    structure and CU.  The actual information extracted and the type
21145    of structures created from the LNP depends on the value of PST.
21146
21147    1. If PST is NULL, then this procedure uses the data from the program
21148       to create all necessary symbol tables, and their linetables.
21149
21150    2. If PST is not NULL, this procedure reads the program to determine
21151       the list of files included by the unit represented by PST, and
21152       builds all the associated partial symbol tables.
21153
21154    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21155    It is used for relative paths in the line table.
21156    NOTE: When processing partial symtabs (pst != NULL),
21157    comp_dir == pst->dirname.
21158
21159    NOTE: It is important that psymtabs have the same file name (via strcmp)
21160    as the corresponding symtab.  Since COMP_DIR is not used in the name of the
21161    symtab we don't use it in the name of the psymtabs we create.
21162    E.g. expand_line_sal requires this when finding psymtabs to expand.
21163    A good testcase for this is mb-inline.exp.
21164
21165    LOWPC is the lowest address in CU (or 0 if not known).
21166
21167    Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21168    for its PC<->lines mapping information.  Otherwise only the filename
21169    table is read in.  */
21170
21171 static void
21172 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21173                     struct dwarf2_cu *cu, struct partial_symtab *pst,
21174                     CORE_ADDR lowpc, int decode_mapping)
21175 {
21176   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21177   const int decode_for_pst_p = (pst != NULL);
21178
21179   if (decode_mapping)
21180     dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21181
21182   if (decode_for_pst_p)
21183     {
21184       int file_index;
21185
21186       /* Now that we're done scanning the Line Header Program, we can
21187          create the psymtab of each included file.  */
21188       for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21189         if (lh->file_names[file_index].included_p == 1)
21190           {
21191             gdb::unique_xmalloc_ptr<char> name_holder;
21192             const char *include_name =
21193               psymtab_include_file_name (lh, file_index, pst, comp_dir,
21194                                          &name_holder);
21195             if (include_name != NULL)
21196               dwarf2_create_include_psymtab (include_name, pst, objfile);
21197           }
21198     }
21199   else
21200     {
21201       /* Make sure a symtab is created for every file, even files
21202          which contain only variables (i.e. no code with associated
21203          line numbers).  */
21204       buildsym_compunit *builder = cu->get_builder ();
21205       struct compunit_symtab *cust = builder->get_compunit_symtab ();
21206       int i;
21207
21208       for (i = 0; i < lh->file_names.size (); i++)
21209         {
21210           file_entry &fe = lh->file_names[i];
21211
21212           dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21213
21214           if (builder->get_current_subfile ()->symtab == NULL)
21215             {
21216               builder->get_current_subfile ()->symtab
21217                 = allocate_symtab (cust,
21218                                    builder->get_current_subfile ()->name);
21219             }
21220           fe.symtab = builder->get_current_subfile ()->symtab;
21221         }
21222     }
21223 }
21224
21225 /* Start a subfile for DWARF.  FILENAME is the name of the file and
21226    DIRNAME the name of the source directory which contains FILENAME
21227    or NULL if not known.
21228    This routine tries to keep line numbers from identical absolute and
21229    relative file names in a common subfile.
21230
21231    Using the `list' example from the GDB testsuite, which resides in
21232    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21233    of /srcdir/list0.c yields the following debugging information for list0.c:
21234
21235    DW_AT_name:          /srcdir/list0.c
21236    DW_AT_comp_dir:      /compdir
21237    files.files[0].name: list0.h
21238    files.files[0].dir:  /srcdir
21239    files.files[1].name: list0.c
21240    files.files[1].dir:  /srcdir
21241
21242    The line number information for list0.c has to end up in a single
21243    subfile, so that `break /srcdir/list0.c:1' works as expected.
21244    start_subfile will ensure that this happens provided that we pass the
21245    concatenation of files.files[1].dir and files.files[1].name as the
21246    subfile's name.  */
21247
21248 static void
21249 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21250                       const char *dirname)
21251 {
21252   char *copy = NULL;
21253
21254   /* In order not to lose the line information directory,
21255      we concatenate it to the filename when it makes sense.
21256      Note that the Dwarf3 standard says (speaking of filenames in line
21257      information): ``The directory index is ignored for file names
21258      that represent full path names''.  Thus ignoring dirname in the
21259      `else' branch below isn't an issue.  */
21260
21261   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21262     {
21263       copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21264       filename = copy;
21265     }
21266
21267   cu->get_builder ()->start_subfile (filename);
21268
21269   if (copy != NULL)
21270     xfree (copy);
21271 }
21272
21273 /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
21274    buildsym_compunit constructor.  */
21275
21276 struct compunit_symtab *
21277 dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
21278                          CORE_ADDR low_pc)
21279 {
21280   gdb_assert (m_builder == nullptr);
21281
21282   m_builder.reset (new struct buildsym_compunit
21283                    (per_cu->dwarf2_per_objfile->objfile,
21284                     name, comp_dir, language, low_pc));
21285
21286   list_in_scope = get_builder ()->get_file_symbols ();
21287
21288   get_builder ()->record_debugformat ("DWARF 2");
21289   get_builder ()->record_producer (producer);
21290
21291   processing_has_namespace_info = false;
21292
21293   return get_builder ()->get_compunit_symtab ();
21294 }
21295
21296 static void
21297 var_decode_location (struct attribute *attr, struct symbol *sym,
21298                      struct dwarf2_cu *cu)
21299 {
21300   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21301   struct comp_unit_head *cu_header = &cu->header;
21302
21303   /* NOTE drow/2003-01-30: There used to be a comment and some special
21304      code here to turn a symbol with DW_AT_external and a
21305      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
21306      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21307      with some versions of binutils) where shared libraries could have
21308      relocations against symbols in their debug information - the
21309      minimal symbol would have the right address, but the debug info
21310      would not.  It's no longer necessary, because we will explicitly
21311      apply relocations when we read in the debug information now.  */
21312
21313   /* A DW_AT_location attribute with no contents indicates that a
21314      variable has been optimized away.  */
21315   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21316     {
21317       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21318       return;
21319     }
21320
21321   /* Handle one degenerate form of location expression specially, to
21322      preserve GDB's previous behavior when section offsets are
21323      specified.  If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21324      then mark this symbol as LOC_STATIC.  */
21325
21326   if (attr_form_is_block (attr)
21327       && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21328            && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21329           || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21330               && (DW_BLOCK (attr)->size
21331                   == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21332     {
21333       unsigned int dummy;
21334
21335       if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21336         SYMBOL_VALUE_ADDRESS (sym) =
21337           read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21338       else
21339         SYMBOL_VALUE_ADDRESS (sym) =
21340           read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21341       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21342       fixup_symbol_section (sym, objfile);
21343       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21344                                               SYMBOL_SECTION (sym));
21345       return;
21346     }
21347
21348   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21349      expression evaluator, and use LOC_COMPUTED only when necessary
21350      (i.e. when the value of a register or memory location is
21351      referenced, or a thread-local block, etc.).  Then again, it might
21352      not be worthwhile.  I'm assuming that it isn't unless performance
21353      or memory numbers show me otherwise.  */
21354
21355   dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21356
21357   if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21358     cu->has_loclist = true;
21359 }
21360
21361 /* Given a pointer to a DWARF information entry, figure out if we need
21362    to make a symbol table entry for it, and if so, create a new entry
21363    and return a pointer to it.
21364    If TYPE is NULL, determine symbol type from the die, otherwise
21365    used the passed type.
21366    If SPACE is not NULL, use it to hold the new symbol.  If it is
21367    NULL, allocate a new symbol on the objfile's obstack.  */
21368
21369 static struct symbol *
21370 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21371             struct symbol *space)
21372 {
21373   struct dwarf2_per_objfile *dwarf2_per_objfile
21374     = cu->per_cu->dwarf2_per_objfile;
21375   struct objfile *objfile = dwarf2_per_objfile->objfile;
21376   struct gdbarch *gdbarch = get_objfile_arch (objfile);
21377   struct symbol *sym = NULL;
21378   const char *name;
21379   struct attribute *attr = NULL;
21380   struct attribute *attr2 = NULL;
21381   CORE_ADDR baseaddr;
21382   struct pending **list_to_add = NULL;
21383
21384   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21385
21386   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21387
21388   name = dwarf2_name (die, cu);
21389   if (name)
21390     {
21391       const char *linkagename;
21392       int suppress_add = 0;
21393
21394       if (space)
21395         sym = space;
21396       else
21397         sym = allocate_symbol (objfile);
21398       OBJSTAT (objfile, n_syms++);
21399
21400       /* Cache this symbol's name and the name's demangled form (if any).  */
21401       SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21402       linkagename = dwarf2_physname (name, die, cu);
21403       SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21404
21405       /* Fortran does not have mangling standard and the mangling does differ
21406          between gfortran, iFort etc.  */
21407       if (cu->language == language_fortran
21408           && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21409         symbol_set_demangled_name (&(sym->ginfo),
21410                                    dwarf2_full_name (name, die, cu),
21411                                    NULL);
21412
21413       /* Default assumptions.
21414          Use the passed type or decode it from the die.  */
21415       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21416       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21417       if (type != NULL)
21418         SYMBOL_TYPE (sym) = type;
21419       else
21420         SYMBOL_TYPE (sym) = die_type (die, cu);
21421       attr = dwarf2_attr (die,
21422                           inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21423                           cu);
21424       if (attr)
21425         {
21426           SYMBOL_LINE (sym) = DW_UNSND (attr);
21427         }
21428
21429       attr = dwarf2_attr (die,
21430                           inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21431                           cu);
21432       if (attr)
21433         {
21434           file_name_index file_index = (file_name_index) DW_UNSND (attr);
21435           struct file_entry *fe;
21436
21437           if (cu->line_header != NULL)
21438             fe = cu->line_header->file_name_at (file_index);
21439           else
21440             fe = NULL;
21441
21442           if (fe == NULL)
21443             complaint (_("file index out of range"));
21444           else
21445             symbol_set_symtab (sym, fe->symtab);
21446         }
21447
21448       switch (die->tag)
21449         {
21450         case DW_TAG_label:
21451           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21452           if (attr)
21453             {
21454               CORE_ADDR addr;
21455
21456               addr = attr_value_as_address (attr);
21457               addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21458               SYMBOL_VALUE_ADDRESS (sym) = addr;
21459             }
21460           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21461           SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21462           SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21463           add_symbol_to_list (sym, cu->list_in_scope);
21464           break;
21465         case DW_TAG_subprogram:
21466           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21467              finish_block.  */
21468           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21469           attr2 = dwarf2_attr (die, DW_AT_external, cu);
21470           if ((attr2 && (DW_UNSND (attr2) != 0))
21471               || cu->language == language_ada)
21472             {
21473               /* Subprograms marked external are stored as a global symbol.
21474                  Ada subprograms, whether marked external or not, are always
21475                  stored as a global symbol, because we want to be able to
21476                  access them globally.  For instance, we want to be able
21477                  to break on a nested subprogram without having to
21478                  specify the context.  */
21479               list_to_add = cu->get_builder ()->get_global_symbols ();
21480             }
21481           else
21482             {
21483               list_to_add = cu->list_in_scope;
21484             }
21485           break;
21486         case DW_TAG_inlined_subroutine:
21487           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21488              finish_block.  */
21489           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21490           SYMBOL_INLINED (sym) = 1;
21491           list_to_add = cu->list_in_scope;
21492           break;
21493         case DW_TAG_template_value_param:
21494           suppress_add = 1;
21495           /* Fall through.  */
21496         case DW_TAG_constant:
21497         case DW_TAG_variable:
21498         case DW_TAG_member:
21499           /* Compilation with minimal debug info may result in
21500              variables with missing type entries.  Change the
21501              misleading `void' type to something sensible.  */
21502           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21503             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21504
21505           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21506           /* In the case of DW_TAG_member, we should only be called for
21507              static const members.  */
21508           if (die->tag == DW_TAG_member)
21509             {
21510               /* dwarf2_add_field uses die_is_declaration,
21511                  so we do the same.  */
21512               gdb_assert (die_is_declaration (die, cu));
21513               gdb_assert (attr);
21514             }
21515           if (attr)
21516             {
21517               dwarf2_const_value (attr, sym, cu);
21518               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21519               if (!suppress_add)
21520                 {
21521                   if (attr2 && (DW_UNSND (attr2) != 0))
21522                     list_to_add = cu->get_builder ()->get_global_symbols ();
21523                   else
21524                     list_to_add = cu->list_in_scope;
21525                 }
21526               break;
21527             }
21528           attr = dwarf2_attr (die, DW_AT_location, cu);
21529           if (attr)
21530             {
21531               var_decode_location (attr, sym, cu);
21532               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21533
21534               /* Fortran explicitly imports any global symbols to the local
21535                  scope by DW_TAG_common_block.  */
21536               if (cu->language == language_fortran && die->parent
21537                   && die->parent->tag == DW_TAG_common_block)
21538                 attr2 = NULL;
21539
21540               if (SYMBOL_CLASS (sym) == LOC_STATIC
21541                   && SYMBOL_VALUE_ADDRESS (sym) == 0
21542                   && !dwarf2_per_objfile->has_section_at_zero)
21543                 {
21544                   /* When a static variable is eliminated by the linker,
21545                      the corresponding debug information is not stripped
21546                      out, but the variable address is set to null;
21547                      do not add such variables into symbol table.  */
21548                 }
21549               else if (attr2 && (DW_UNSND (attr2) != 0))
21550                 {
21551                   /* Workaround gfortran PR debug/40040 - it uses
21552                      DW_AT_location for variables in -fPIC libraries which may
21553                      get overriden by other libraries/executable and get
21554                      a different address.  Resolve it by the minimal symbol
21555                      which may come from inferior's executable using copy
21556                      relocation.  Make this workaround only for gfortran as for
21557                      other compilers GDB cannot guess the minimal symbol
21558                      Fortran mangling kind.  */
21559                   if (cu->language == language_fortran && die->parent
21560                       && die->parent->tag == DW_TAG_module
21561                       && cu->producer
21562                       && startswith (cu->producer, "GNU Fortran"))
21563                     SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21564
21565                   /* A variable with DW_AT_external is never static,
21566                      but it may be block-scoped.  */
21567                   list_to_add
21568                     = ((cu->list_in_scope
21569                         == cu->get_builder ()->get_file_symbols ())
21570                        ? cu->get_builder ()->get_global_symbols ()
21571                        : cu->list_in_scope);
21572                 }
21573               else
21574                 list_to_add = cu->list_in_scope;
21575             }
21576           else
21577             {
21578               /* We do not know the address of this symbol.
21579                  If it is an external symbol and we have type information
21580                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
21581                  The address of the variable will then be determined from
21582                  the minimal symbol table whenever the variable is
21583                  referenced.  */
21584               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21585
21586               /* Fortran explicitly imports any global symbols to the local
21587                  scope by DW_TAG_common_block.  */
21588               if (cu->language == language_fortran && die->parent
21589                   && die->parent->tag == DW_TAG_common_block)
21590                 {
21591                   /* SYMBOL_CLASS doesn't matter here because
21592                      read_common_block is going to reset it.  */
21593                   if (!suppress_add)
21594                     list_to_add = cu->list_in_scope;
21595                 }
21596               else if (attr2 && (DW_UNSND (attr2) != 0)
21597                        && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21598                 {
21599                   /* A variable with DW_AT_external is never static, but it
21600                      may be block-scoped.  */
21601                   list_to_add
21602                     = ((cu->list_in_scope
21603                         == cu->get_builder ()->get_file_symbols ())
21604                        ? cu->get_builder ()->get_global_symbols ()
21605                        : cu->list_in_scope);
21606
21607                   SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21608                 }
21609               else if (!die_is_declaration (die, cu))
21610                 {
21611                   /* Use the default LOC_OPTIMIZED_OUT class.  */
21612                   gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21613                   if (!suppress_add)
21614                     list_to_add = cu->list_in_scope;
21615                 }
21616             }
21617           break;
21618         case DW_TAG_formal_parameter:
21619           {
21620             /* If we are inside a function, mark this as an argument.  If
21621                not, we might be looking at an argument to an inlined function
21622                when we do not have enough information to show inlined frames;
21623                pretend it's a local variable in that case so that the user can
21624                still see it.  */
21625             struct context_stack *curr
21626               = cu->get_builder ()->get_current_context_stack ();
21627             if (curr != nullptr && curr->name != nullptr)
21628               SYMBOL_IS_ARGUMENT (sym) = 1;
21629             attr = dwarf2_attr (die, DW_AT_location, cu);
21630             if (attr)
21631               {
21632                 var_decode_location (attr, sym, cu);
21633               }
21634             attr = dwarf2_attr (die, DW_AT_const_value, cu);
21635             if (attr)
21636               {
21637                 dwarf2_const_value (attr, sym, cu);
21638               }
21639
21640             list_to_add = cu->list_in_scope;
21641           }
21642           break;
21643         case DW_TAG_unspecified_parameters:
21644           /* From varargs functions; gdb doesn't seem to have any
21645              interest in this information, so just ignore it for now.
21646              (FIXME?) */
21647           break;
21648         case DW_TAG_template_type_param:
21649           suppress_add = 1;
21650           /* Fall through.  */
21651         case DW_TAG_class_type:
21652         case DW_TAG_interface_type:
21653         case DW_TAG_structure_type:
21654         case DW_TAG_union_type:
21655         case DW_TAG_set_type:
21656         case DW_TAG_enumeration_type:
21657           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21658           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21659
21660           {
21661             /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21662                really ever be static objects: otherwise, if you try
21663                to, say, break of a class's method and you're in a file
21664                which doesn't mention that class, it won't work unless
21665                the check for all static symbols in lookup_symbol_aux
21666                saves you.  See the OtherFileClass tests in
21667                gdb.c++/namespace.exp.  */
21668
21669             if (!suppress_add)
21670               {
21671                 buildsym_compunit *builder = cu->get_builder ();
21672                 list_to_add
21673                   = (cu->list_in_scope == builder->get_file_symbols ()
21674                      && cu->language == language_cplus
21675                      ? builder->get_global_symbols ()
21676                      : cu->list_in_scope);
21677
21678                 /* The semantics of C++ state that "struct foo {
21679                    ... }" also defines a typedef for "foo".  */
21680                 if (cu->language == language_cplus
21681                     || cu->language == language_ada
21682                     || cu->language == language_d
21683                     || cu->language == language_rust)
21684                   {
21685                     /* The symbol's name is already allocated along
21686                        with this objfile, so we don't need to
21687                        duplicate it for the type.  */
21688                     if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21689                       TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21690                   }
21691               }
21692           }
21693           break;
21694         case DW_TAG_typedef:
21695           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21696           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21697           list_to_add = cu->list_in_scope;
21698           break;
21699         case DW_TAG_base_type:
21700         case DW_TAG_subrange_type:
21701           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21702           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21703           list_to_add = cu->list_in_scope;
21704           break;
21705         case DW_TAG_enumerator:
21706           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21707           if (attr)
21708             {
21709               dwarf2_const_value (attr, sym, cu);
21710             }
21711           {
21712             /* NOTE: carlton/2003-11-10: See comment above in the
21713                DW_TAG_class_type, etc. block.  */
21714
21715             list_to_add
21716               = (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
21717                  && cu->language == language_cplus
21718                  ? cu->get_builder ()->get_global_symbols ()
21719                  : cu->list_in_scope);
21720           }
21721           break;
21722         case DW_TAG_imported_declaration:
21723         case DW_TAG_namespace:
21724           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21725           list_to_add = cu->get_builder ()->get_global_symbols ();
21726           break;
21727         case DW_TAG_module:
21728           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21729           SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21730           list_to_add = cu->get_builder ()->get_global_symbols ();
21731           break;
21732         case DW_TAG_common_block:
21733           SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21734           SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21735           add_symbol_to_list (sym, cu->list_in_scope);
21736           break;
21737         default:
21738           /* Not a tag we recognize.  Hopefully we aren't processing
21739              trash data, but since we must specifically ignore things
21740              we don't recognize, there is nothing else we should do at
21741              this point.  */
21742           complaint (_("unsupported tag: '%s'"),
21743                      dwarf_tag_name (die->tag));
21744           break;
21745         }
21746
21747       if (suppress_add)
21748         {
21749           sym->hash_next = objfile->template_symbols;
21750           objfile->template_symbols = sym;
21751           list_to_add = NULL;
21752         }
21753
21754       if (list_to_add != NULL)
21755         add_symbol_to_list (sym, list_to_add);
21756
21757       /* For the benefit of old versions of GCC, check for anonymous
21758          namespaces based on the demangled name.  */
21759       if (!cu->processing_has_namespace_info
21760           && cu->language == language_cplus)
21761         cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
21762     }
21763   return (sym);
21764 }
21765
21766 /* Given an attr with a DW_FORM_dataN value in host byte order,
21767    zero-extend it as appropriate for the symbol's type.  The DWARF
21768    standard (v4) is not entirely clear about the meaning of using
21769    DW_FORM_dataN for a constant with a signed type, where the type is
21770    wider than the data.  The conclusion of a discussion on the DWARF
21771    list was that this is unspecified.  We choose to always zero-extend
21772    because that is the interpretation long in use by GCC.  */
21773
21774 static gdb_byte *
21775 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21776                          struct dwarf2_cu *cu, LONGEST *value, int bits)
21777 {
21778   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21779   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21780                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21781   LONGEST l = DW_UNSND (attr);
21782
21783   if (bits < sizeof (*value) * 8)
21784     {
21785       l &= ((LONGEST) 1 << bits) - 1;
21786       *value = l;
21787     }
21788   else if (bits == sizeof (*value) * 8)
21789     *value = l;
21790   else
21791     {
21792       gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21793       store_unsigned_integer (bytes, bits / 8, byte_order, l);
21794       return bytes;
21795     }
21796
21797   return NULL;
21798 }
21799
21800 /* Read a constant value from an attribute.  Either set *VALUE, or if
21801    the value does not fit in *VALUE, set *BYTES - either already
21802    allocated on the objfile obstack, or newly allocated on OBSTACK,
21803    or, set *BATON, if we translated the constant to a location
21804    expression.  */
21805
21806 static void
21807 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21808                          const char *name, struct obstack *obstack,
21809                          struct dwarf2_cu *cu,
21810                          LONGEST *value, const gdb_byte **bytes,
21811                          struct dwarf2_locexpr_baton **baton)
21812 {
21813   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21814   struct comp_unit_head *cu_header = &cu->header;
21815   struct dwarf_block *blk;
21816   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21817                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21818
21819   *value = 0;
21820   *bytes = NULL;
21821   *baton = NULL;
21822
21823   switch (attr->form)
21824     {
21825     case DW_FORM_addr:
21826     case DW_FORM_GNU_addr_index:
21827       {
21828         gdb_byte *data;
21829
21830         if (TYPE_LENGTH (type) != cu_header->addr_size)
21831           dwarf2_const_value_length_mismatch_complaint (name,
21832                                                         cu_header->addr_size,
21833                                                         TYPE_LENGTH (type));
21834         /* Symbols of this form are reasonably rare, so we just
21835            piggyback on the existing location code rather than writing
21836            a new implementation of symbol_computed_ops.  */
21837         *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21838         (*baton)->per_cu = cu->per_cu;
21839         gdb_assert ((*baton)->per_cu);
21840
21841         (*baton)->size = 2 + cu_header->addr_size;
21842         data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21843         (*baton)->data = data;
21844
21845         data[0] = DW_OP_addr;
21846         store_unsigned_integer (&data[1], cu_header->addr_size,
21847                                 byte_order, DW_ADDR (attr));
21848         data[cu_header->addr_size + 1] = DW_OP_stack_value;
21849       }
21850       break;
21851     case DW_FORM_string:
21852     case DW_FORM_strp:
21853     case DW_FORM_GNU_str_index:
21854     case DW_FORM_GNU_strp_alt:
21855       /* DW_STRING is already allocated on the objfile obstack, point
21856          directly to it.  */
21857       *bytes = (const gdb_byte *) DW_STRING (attr);
21858       break;
21859     case DW_FORM_block1:
21860     case DW_FORM_block2:
21861     case DW_FORM_block4:
21862     case DW_FORM_block:
21863     case DW_FORM_exprloc:
21864     case DW_FORM_data16:
21865       blk = DW_BLOCK (attr);
21866       if (TYPE_LENGTH (type) != blk->size)
21867         dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21868                                                       TYPE_LENGTH (type));
21869       *bytes = blk->data;
21870       break;
21871
21872       /* The DW_AT_const_value attributes are supposed to carry the
21873          symbol's value "represented as it would be on the target
21874          architecture."  By the time we get here, it's already been
21875          converted to host endianness, so we just need to sign- or
21876          zero-extend it as appropriate.  */
21877     case DW_FORM_data1:
21878       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21879       break;
21880     case DW_FORM_data2:
21881       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21882       break;
21883     case DW_FORM_data4:
21884       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21885       break;
21886     case DW_FORM_data8:
21887       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21888       break;
21889
21890     case DW_FORM_sdata:
21891     case DW_FORM_implicit_const:
21892       *value = DW_SND (attr);
21893       break;
21894
21895     case DW_FORM_udata:
21896       *value = DW_UNSND (attr);
21897       break;
21898
21899     default:
21900       complaint (_("unsupported const value attribute form: '%s'"),
21901                  dwarf_form_name (attr->form));
21902       *value = 0;
21903       break;
21904     }
21905 }
21906
21907
21908 /* Copy constant value from an attribute to a symbol.  */
21909
21910 static void
21911 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21912                     struct dwarf2_cu *cu)
21913 {
21914   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21915   LONGEST value;
21916   const gdb_byte *bytes;
21917   struct dwarf2_locexpr_baton *baton;
21918
21919   dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21920                            SYMBOL_PRINT_NAME (sym),
21921                            &objfile->objfile_obstack, cu,
21922                            &value, &bytes, &baton);
21923
21924   if (baton != NULL)
21925     {
21926       SYMBOL_LOCATION_BATON (sym) = baton;
21927       SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21928     }
21929   else if (bytes != NULL)
21930      {
21931       SYMBOL_VALUE_BYTES (sym) = bytes;
21932       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21933     }
21934   else
21935     {
21936       SYMBOL_VALUE (sym) = value;
21937       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21938     }
21939 }
21940
21941 /* Return the type of the die in question using its DW_AT_type attribute.  */
21942
21943 static struct type *
21944 die_type (struct die_info *die, struct dwarf2_cu *cu)
21945 {
21946   struct attribute *type_attr;
21947
21948   type_attr = dwarf2_attr (die, DW_AT_type, cu);
21949   if (!type_attr)
21950     {
21951       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21952       /* A missing DW_AT_type represents a void type.  */
21953       return objfile_type (objfile)->builtin_void;
21954     }
21955
21956   return lookup_die_type (die, type_attr, cu);
21957 }
21958
21959 /* True iff CU's producer generates GNAT Ada auxiliary information
21960    that allows to find parallel types through that information instead
21961    of having to do expensive parallel lookups by type name.  */
21962
21963 static int
21964 need_gnat_info (struct dwarf2_cu *cu)
21965 {
21966   /* Assume that the Ada compiler was GNAT, which always produces
21967      the auxiliary information.  */
21968   return (cu->language == language_ada);
21969 }
21970
21971 /* Return the auxiliary type of the die in question using its
21972    DW_AT_GNAT_descriptive_type attribute.  Returns NULL if the
21973    attribute is not present.  */
21974
21975 static struct type *
21976 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21977 {
21978   struct attribute *type_attr;
21979
21980   type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21981   if (!type_attr)
21982     return NULL;
21983
21984   return lookup_die_type (die, type_attr, cu);
21985 }
21986
21987 /* If DIE has a descriptive_type attribute, then set the TYPE's
21988    descriptive type accordingly.  */
21989
21990 static void
21991 set_descriptive_type (struct type *type, struct die_info *die,
21992                       struct dwarf2_cu *cu)
21993 {
21994   struct type *descriptive_type = die_descriptive_type (die, cu);
21995
21996   if (descriptive_type)
21997     {
21998       ALLOCATE_GNAT_AUX_TYPE (type);
21999       TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
22000     }
22001 }
22002
22003 /* Return the containing type of the die in question using its
22004    DW_AT_containing_type attribute.  */
22005
22006 static struct type *
22007 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
22008 {
22009   struct attribute *type_attr;
22010   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22011
22012   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
22013   if (!type_attr)
22014     error (_("Dwarf Error: Problem turning containing type into gdb type "
22015              "[in module %s]"), objfile_name (objfile));
22016
22017   return lookup_die_type (die, type_attr, cu);
22018 }
22019
22020 /* Return an error marker type to use for the ill formed type in DIE/CU.  */
22021
22022 static struct type *
22023 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22024 {
22025   struct dwarf2_per_objfile *dwarf2_per_objfile
22026     = cu->per_cu->dwarf2_per_objfile;
22027   struct objfile *objfile = dwarf2_per_objfile->objfile;
22028   char *saved;
22029
22030   std::string message
22031     = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22032                      objfile_name (objfile),
22033                      sect_offset_str (cu->header.sect_off),
22034                      sect_offset_str (die->sect_off));
22035   saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22036                                   message.c_str (), message.length ());
22037
22038   return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22039 }
22040
22041 /* Look up the type of DIE in CU using its type attribute ATTR.
22042    ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22043    DW_AT_containing_type.
22044    If there is no type substitute an error marker.  */
22045
22046 static struct type *
22047 lookup_die_type (struct die_info *die, const struct attribute *attr,
22048                  struct dwarf2_cu *cu)
22049 {
22050   struct dwarf2_per_objfile *dwarf2_per_objfile
22051     = cu->per_cu->dwarf2_per_objfile;
22052   struct objfile *objfile = dwarf2_per_objfile->objfile;
22053   struct type *this_type;
22054
22055   gdb_assert (attr->name == DW_AT_type
22056               || attr->name == DW_AT_GNAT_descriptive_type
22057               || attr->name == DW_AT_containing_type);
22058
22059   /* First see if we have it cached.  */
22060
22061   if (attr->form == DW_FORM_GNU_ref_alt)
22062     {
22063       struct dwarf2_per_cu_data *per_cu;
22064       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22065
22066       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22067                                                  dwarf2_per_objfile);
22068       this_type = get_die_type_at_offset (sect_off, per_cu);
22069     }
22070   else if (attr_form_is_ref (attr))
22071     {
22072       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22073
22074       this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22075     }
22076   else if (attr->form == DW_FORM_ref_sig8)
22077     {
22078       ULONGEST signature = DW_SIGNATURE (attr);
22079
22080       return get_signatured_type (die, signature, cu);
22081     }
22082   else
22083     {
22084       complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22085                    " at %s [in module %s]"),
22086                  dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22087                  objfile_name (objfile));
22088       return build_error_marker_type (cu, die);
22089     }
22090
22091   /* If not cached we need to read it in.  */
22092
22093   if (this_type == NULL)
22094     {
22095       struct die_info *type_die = NULL;
22096       struct dwarf2_cu *type_cu = cu;
22097
22098       if (attr_form_is_ref (attr))
22099         type_die = follow_die_ref (die, attr, &type_cu);
22100       if (type_die == NULL)
22101         return build_error_marker_type (cu, die);
22102       /* If we find the type now, it's probably because the type came
22103          from an inter-CU reference and the type's CU got expanded before
22104          ours.  */
22105       this_type = read_type_die (type_die, type_cu);
22106     }
22107
22108   /* If we still don't have a type use an error marker.  */
22109
22110   if (this_type == NULL)
22111     return build_error_marker_type (cu, die);
22112
22113   return this_type;
22114 }
22115
22116 /* Return the type in DIE, CU.
22117    Returns NULL for invalid types.
22118
22119    This first does a lookup in die_type_hash,
22120    and only reads the die in if necessary.
22121
22122    NOTE: This can be called when reading in partial or full symbols.  */
22123
22124 static struct type *
22125 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22126 {
22127   struct type *this_type;
22128
22129   this_type = get_die_type (die, cu);
22130   if (this_type)
22131     return this_type;
22132
22133   return read_type_die_1 (die, cu);
22134 }
22135
22136 /* Read the type in DIE, CU.
22137    Returns NULL for invalid types.  */
22138
22139 static struct type *
22140 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22141 {
22142   struct type *this_type = NULL;
22143
22144   switch (die->tag)
22145     {
22146     case DW_TAG_class_type:
22147     case DW_TAG_interface_type:
22148     case DW_TAG_structure_type:
22149     case DW_TAG_union_type:
22150       this_type = read_structure_type (die, cu);
22151       break;
22152     case DW_TAG_enumeration_type:
22153       this_type = read_enumeration_type (die, cu);
22154       break;
22155     case DW_TAG_subprogram:
22156     case DW_TAG_subroutine_type:
22157     case DW_TAG_inlined_subroutine:
22158       this_type = read_subroutine_type (die, cu);
22159       break;
22160     case DW_TAG_array_type:
22161       this_type = read_array_type (die, cu);
22162       break;
22163     case DW_TAG_set_type:
22164       this_type = read_set_type (die, cu);
22165       break;
22166     case DW_TAG_pointer_type:
22167       this_type = read_tag_pointer_type (die, cu);
22168       break;
22169     case DW_TAG_ptr_to_member_type:
22170       this_type = read_tag_ptr_to_member_type (die, cu);
22171       break;
22172     case DW_TAG_reference_type:
22173       this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22174       break;
22175     case DW_TAG_rvalue_reference_type:
22176       this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22177       break;
22178     case DW_TAG_const_type:
22179       this_type = read_tag_const_type (die, cu);
22180       break;
22181     case DW_TAG_volatile_type:
22182       this_type = read_tag_volatile_type (die, cu);
22183       break;
22184     case DW_TAG_restrict_type:
22185       this_type = read_tag_restrict_type (die, cu);
22186       break;
22187     case DW_TAG_string_type:
22188       this_type = read_tag_string_type (die, cu);
22189       break;
22190     case DW_TAG_typedef:
22191       this_type = read_typedef (die, cu);
22192       break;
22193     case DW_TAG_subrange_type:
22194       this_type = read_subrange_type (die, cu);
22195       break;
22196     case DW_TAG_base_type:
22197       this_type = read_base_type (die, cu);
22198       break;
22199     case DW_TAG_unspecified_type:
22200       this_type = read_unspecified_type (die, cu);
22201       break;
22202     case DW_TAG_namespace:
22203       this_type = read_namespace_type (die, cu);
22204       break;
22205     case DW_TAG_module:
22206       this_type = read_module_type (die, cu);
22207       break;
22208     case DW_TAG_atomic_type:
22209       this_type = read_tag_atomic_type (die, cu);
22210       break;
22211     default:
22212       complaint (_("unexpected tag in read_type_die: '%s'"),
22213                  dwarf_tag_name (die->tag));
22214       break;
22215     }
22216
22217   return this_type;
22218 }
22219
22220 /* See if we can figure out if the class lives in a namespace.  We do
22221    this by looking for a member function; its demangled name will
22222    contain namespace info, if there is any.
22223    Return the computed name or NULL.
22224    Space for the result is allocated on the objfile's obstack.
22225    This is the full-die version of guess_partial_die_structure_name.
22226    In this case we know DIE has no useful parent.  */
22227
22228 static char *
22229 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22230 {
22231   struct die_info *spec_die;
22232   struct dwarf2_cu *spec_cu;
22233   struct die_info *child;
22234   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22235
22236   spec_cu = cu;
22237   spec_die = die_specification (die, &spec_cu);
22238   if (spec_die != NULL)
22239     {
22240       die = spec_die;
22241       cu = spec_cu;
22242     }
22243
22244   for (child = die->child;
22245        child != NULL;
22246        child = child->sibling)
22247     {
22248       if (child->tag == DW_TAG_subprogram)
22249         {
22250           const char *linkage_name = dw2_linkage_name (child, cu);
22251
22252           if (linkage_name != NULL)
22253             {
22254               char *actual_name
22255                 = language_class_name_from_physname (cu->language_defn,
22256                                                      linkage_name);
22257               char *name = NULL;
22258
22259               if (actual_name != NULL)
22260                 {
22261                   const char *die_name = dwarf2_name (die, cu);
22262
22263                   if (die_name != NULL
22264                       && strcmp (die_name, actual_name) != 0)
22265                     {
22266                       /* Strip off the class name from the full name.
22267                          We want the prefix.  */
22268                       int die_name_len = strlen (die_name);
22269                       int actual_name_len = strlen (actual_name);
22270
22271                       /* Test for '::' as a sanity check.  */
22272                       if (actual_name_len > die_name_len + 2
22273                           && actual_name[actual_name_len
22274                                          - die_name_len - 1] == ':')
22275                         name = (char *) obstack_copy0 (
22276                           &objfile->per_bfd->storage_obstack,
22277                           actual_name, actual_name_len - die_name_len - 2);
22278                     }
22279                 }
22280               xfree (actual_name);
22281               return name;
22282             }
22283         }
22284     }
22285
22286   return NULL;
22287 }
22288
22289 /* GCC might emit a nameless typedef that has a linkage name.  Determine the
22290    prefix part in such case.  See
22291    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22292
22293 static const char *
22294 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22295 {
22296   struct attribute *attr;
22297   const char *base;
22298
22299   if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22300       && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22301     return NULL;
22302
22303   if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22304     return NULL;
22305
22306   attr = dw2_linkage_name_attr (die, cu);
22307   if (attr == NULL || DW_STRING (attr) == NULL)
22308     return NULL;
22309
22310   /* dwarf2_name had to be already called.  */
22311   gdb_assert (DW_STRING_IS_CANONICAL (attr));
22312
22313   /* Strip the base name, keep any leading namespaces/classes.  */
22314   base = strrchr (DW_STRING (attr), ':');
22315   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22316     return "";
22317
22318   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22319   return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22320                                  DW_STRING (attr),
22321                                  &base[-1] - DW_STRING (attr));
22322 }
22323
22324 /* Return the name of the namespace/class that DIE is defined within,
22325    or "" if we can't tell.  The caller should not xfree the result.
22326
22327    For example, if we're within the method foo() in the following
22328    code:
22329
22330    namespace N {
22331      class C {
22332        void foo () {
22333        }
22334      };
22335    }
22336
22337    then determine_prefix on foo's die will return "N::C".  */
22338
22339 static const char *
22340 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22341 {
22342   struct dwarf2_per_objfile *dwarf2_per_objfile
22343     = cu->per_cu->dwarf2_per_objfile;
22344   struct die_info *parent, *spec_die;
22345   struct dwarf2_cu *spec_cu;
22346   struct type *parent_type;
22347   const char *retval;
22348
22349   if (cu->language != language_cplus
22350       && cu->language != language_fortran && cu->language != language_d
22351       && cu->language != language_rust)
22352     return "";
22353
22354   retval = anonymous_struct_prefix (die, cu);
22355   if (retval)
22356     return retval;
22357
22358   /* We have to be careful in the presence of DW_AT_specification.
22359      For example, with GCC 3.4, given the code
22360
22361      namespace N {
22362        void foo() {
22363          // Definition of N::foo.
22364        }
22365      }
22366
22367      then we'll have a tree of DIEs like this:
22368
22369      1: DW_TAG_compile_unit
22370        2: DW_TAG_namespace        // N
22371          3: DW_TAG_subprogram     // declaration of N::foo
22372        4: DW_TAG_subprogram       // definition of N::foo
22373             DW_AT_specification   // refers to die #3
22374
22375      Thus, when processing die #4, we have to pretend that we're in
22376      the context of its DW_AT_specification, namely the contex of die
22377      #3.  */
22378   spec_cu = cu;
22379   spec_die = die_specification (die, &spec_cu);
22380   if (spec_die == NULL)
22381     parent = die->parent;
22382   else
22383     {
22384       parent = spec_die->parent;
22385       cu = spec_cu;
22386     }
22387
22388   if (parent == NULL)
22389     return "";
22390   else if (parent->building_fullname)
22391     {
22392       const char *name;
22393       const char *parent_name;
22394
22395       /* It has been seen on RealView 2.2 built binaries,
22396          DW_TAG_template_type_param types actually _defined_ as
22397          children of the parent class:
22398
22399          enum E {};
22400          template class <class Enum> Class{};
22401          Class<enum E> class_e;
22402
22403          1: DW_TAG_class_type (Class)
22404            2: DW_TAG_enumeration_type (E)
22405              3: DW_TAG_enumerator (enum1:0)
22406              3: DW_TAG_enumerator (enum2:1)
22407              ...
22408            2: DW_TAG_template_type_param
22409               DW_AT_type  DW_FORM_ref_udata (E)
22410
22411          Besides being broken debug info, it can put GDB into an
22412          infinite loop.  Consider:
22413
22414          When we're building the full name for Class<E>, we'll start
22415          at Class, and go look over its template type parameters,
22416          finding E.  We'll then try to build the full name of E, and
22417          reach here.  We're now trying to build the full name of E,
22418          and look over the parent DIE for containing scope.  In the
22419          broken case, if we followed the parent DIE of E, we'd again
22420          find Class, and once again go look at its template type
22421          arguments, etc., etc.  Simply don't consider such parent die
22422          as source-level parent of this die (it can't be, the language
22423          doesn't allow it), and break the loop here.  */
22424       name = dwarf2_name (die, cu);
22425       parent_name = dwarf2_name (parent, cu);
22426       complaint (_("template param type '%s' defined within parent '%s'"),
22427                  name ? name : "<unknown>",
22428                  parent_name ? parent_name : "<unknown>");
22429       return "";
22430     }
22431   else
22432     switch (parent->tag)
22433       {
22434       case DW_TAG_namespace:
22435         parent_type = read_type_die (parent, cu);
22436         /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22437            DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22438            Work around this problem here.  */
22439         if (cu->language == language_cplus
22440             && strcmp (TYPE_NAME (parent_type), "::") == 0)
22441           return "";
22442         /* We give a name to even anonymous namespaces.  */
22443         return TYPE_NAME (parent_type);
22444       case DW_TAG_class_type:
22445       case DW_TAG_interface_type:
22446       case DW_TAG_structure_type:
22447       case DW_TAG_union_type:
22448       case DW_TAG_module:
22449         parent_type = read_type_die (parent, cu);
22450         if (TYPE_NAME (parent_type) != NULL)
22451           return TYPE_NAME (parent_type);
22452         else
22453           /* An anonymous structure is only allowed non-static data
22454              members; no typedefs, no member functions, et cetera.
22455              So it does not need a prefix.  */
22456           return "";
22457       case DW_TAG_compile_unit:
22458       case DW_TAG_partial_unit:
22459         /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
22460         if (cu->language == language_cplus
22461             && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22462             && die->child != NULL
22463             && (die->tag == DW_TAG_class_type
22464                 || die->tag == DW_TAG_structure_type
22465                 || die->tag == DW_TAG_union_type))
22466           {
22467             char *name = guess_full_die_structure_name (die, cu);
22468             if (name != NULL)
22469               return name;
22470           }
22471         return "";
22472       case DW_TAG_enumeration_type:
22473         parent_type = read_type_die (parent, cu);
22474         if (TYPE_DECLARED_CLASS (parent_type))
22475           {
22476             if (TYPE_NAME (parent_type) != NULL)
22477               return TYPE_NAME (parent_type);
22478             return "";
22479           }
22480         /* Fall through.  */
22481       default:
22482         return determine_prefix (parent, cu);
22483       }
22484 }
22485
22486 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22487    with appropriate separator.  If PREFIX or SUFFIX is NULL or empty, then
22488    simply copy the SUFFIX or PREFIX, respectively.  If OBS is non-null, perform
22489    an obconcat, otherwise allocate storage for the result.  The CU argument is
22490    used to determine the language and hence, the appropriate separator.  */
22491
22492 #define MAX_SEP_LEN 7  /* strlen ("__") + strlen ("_MOD_")  */
22493
22494 static char *
22495 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22496                  int physname, struct dwarf2_cu *cu)
22497 {
22498   const char *lead = "";
22499   const char *sep;
22500
22501   if (suffix == NULL || suffix[0] == '\0'
22502       || prefix == NULL || prefix[0] == '\0')
22503     sep = "";
22504   else if (cu->language == language_d)
22505     {
22506       /* For D, the 'main' function could be defined in any module, but it
22507          should never be prefixed.  */
22508       if (strcmp (suffix, "D main") == 0)
22509         {
22510           prefix = "";
22511           sep = "";
22512         }
22513       else
22514         sep = ".";
22515     }
22516   else if (cu->language == language_fortran && physname)
22517     {
22518       /* This is gfortran specific mangling.  Normally DW_AT_linkage_name or
22519          DW_AT_MIPS_linkage_name is preferred and used instead.  */
22520
22521       lead = "__";
22522       sep = "_MOD_";
22523     }
22524   else
22525     sep = "::";
22526
22527   if (prefix == NULL)
22528     prefix = "";
22529   if (suffix == NULL)
22530     suffix = "";
22531
22532   if (obs == NULL)
22533     {
22534       char *retval
22535         = ((char *)
22536            xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22537
22538       strcpy (retval, lead);
22539       strcat (retval, prefix);
22540       strcat (retval, sep);
22541       strcat (retval, suffix);
22542       return retval;
22543     }
22544   else
22545     {
22546       /* We have an obstack.  */
22547       return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22548     }
22549 }
22550
22551 /* Return sibling of die, NULL if no sibling.  */
22552
22553 static struct die_info *
22554 sibling_die (struct die_info *die)
22555 {
22556   return die->sibling;
22557 }
22558
22559 /* Get name of a die, return NULL if not found.  */
22560
22561 static const char *
22562 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22563                           struct obstack *obstack)
22564 {
22565   if (name && cu->language == language_cplus)
22566     {
22567       std::string canon_name = cp_canonicalize_string (name);
22568
22569       if (!canon_name.empty ())
22570         {
22571           if (canon_name != name)
22572             name = (const char *) obstack_copy0 (obstack,
22573                                                  canon_name.c_str (),
22574                                                  canon_name.length ());
22575         }
22576     }
22577
22578   return name;
22579 }
22580
22581 /* Get name of a die, return NULL if not found.
22582    Anonymous namespaces are converted to their magic string.  */
22583
22584 static const char *
22585 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22586 {
22587   struct attribute *attr;
22588   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22589
22590   attr = dwarf2_attr (die, DW_AT_name, cu);
22591   if ((!attr || !DW_STRING (attr))
22592       && die->tag != DW_TAG_namespace
22593       && die->tag != DW_TAG_class_type
22594       && die->tag != DW_TAG_interface_type
22595       && die->tag != DW_TAG_structure_type
22596       && die->tag != DW_TAG_union_type)
22597     return NULL;
22598
22599   switch (die->tag)
22600     {
22601     case DW_TAG_compile_unit:
22602     case DW_TAG_partial_unit:
22603       /* Compilation units have a DW_AT_name that is a filename, not
22604          a source language identifier.  */
22605     case DW_TAG_enumeration_type:
22606     case DW_TAG_enumerator:
22607       /* These tags always have simple identifiers already; no need
22608          to canonicalize them.  */
22609       return DW_STRING (attr);
22610
22611     case DW_TAG_namespace:
22612       if (attr != NULL && DW_STRING (attr) != NULL)
22613         return DW_STRING (attr);
22614       return CP_ANONYMOUS_NAMESPACE_STR;
22615
22616     case DW_TAG_class_type:
22617     case DW_TAG_interface_type:
22618     case DW_TAG_structure_type:
22619     case DW_TAG_union_type:
22620       /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22621          structures or unions.  These were of the form "._%d" in GCC 4.1,
22622          or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22623          and GCC 4.4.  We work around this problem by ignoring these.  */
22624       if (attr && DW_STRING (attr)
22625           && (startswith (DW_STRING (attr), "._")
22626               || startswith (DW_STRING (attr), "<anonymous")))
22627         return NULL;
22628
22629       /* GCC might emit a nameless typedef that has a linkage name.  See
22630          http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22631       if (!attr || DW_STRING (attr) == NULL)
22632         {
22633           char *demangled = NULL;
22634
22635           attr = dw2_linkage_name_attr (die, cu);
22636           if (attr == NULL || DW_STRING (attr) == NULL)
22637             return NULL;
22638
22639           /* Avoid demangling DW_STRING (attr) the second time on a second
22640              call for the same DIE.  */
22641           if (!DW_STRING_IS_CANONICAL (attr))
22642             demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22643
22644           if (demangled)
22645             {
22646               const char *base;
22647
22648               /* FIXME: we already did this for the partial symbol... */
22649               DW_STRING (attr)
22650                 = ((const char *)
22651                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
22652                                   demangled, strlen (demangled)));
22653               DW_STRING_IS_CANONICAL (attr) = 1;
22654               xfree (demangled);
22655
22656               /* Strip any leading namespaces/classes, keep only the base name.
22657                  DW_AT_name for named DIEs does not contain the prefixes.  */
22658               base = strrchr (DW_STRING (attr), ':');
22659               if (base && base > DW_STRING (attr) && base[-1] == ':')
22660                 return &base[1];
22661               else
22662                 return DW_STRING (attr);
22663             }
22664         }
22665       break;
22666
22667     default:
22668       break;
22669     }
22670
22671   if (!DW_STRING_IS_CANONICAL (attr))
22672     {
22673       DW_STRING (attr)
22674         = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22675                                     &objfile->per_bfd->storage_obstack);
22676       DW_STRING_IS_CANONICAL (attr) = 1;
22677     }
22678   return DW_STRING (attr);
22679 }
22680
22681 /* Return the die that this die in an extension of, or NULL if there
22682    is none.  *EXT_CU is the CU containing DIE on input, and the CU
22683    containing the return value on output.  */
22684
22685 static struct die_info *
22686 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22687 {
22688   struct attribute *attr;
22689
22690   attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22691   if (attr == NULL)
22692     return NULL;
22693
22694   return follow_die_ref (die, attr, ext_cu);
22695 }
22696
22697 /* Convert a DIE tag into its string name.  */
22698
22699 static const char *
22700 dwarf_tag_name (unsigned tag)
22701 {
22702   const char *name = get_DW_TAG_name (tag);
22703
22704   if (name == NULL)
22705     return "DW_TAG_<unknown>";
22706
22707   return name;
22708 }
22709
22710 /* Convert a DWARF attribute code into its string name.  */
22711
22712 static const char *
22713 dwarf_attr_name (unsigned attr)
22714 {
22715   const char *name;
22716
22717 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22718   if (attr == DW_AT_MIPS_fde)
22719     return "DW_AT_MIPS_fde";
22720 #else
22721   if (attr == DW_AT_HP_block_index)
22722     return "DW_AT_HP_block_index";
22723 #endif
22724
22725   name = get_DW_AT_name (attr);
22726
22727   if (name == NULL)
22728     return "DW_AT_<unknown>";
22729
22730   return name;
22731 }
22732
22733 /* Convert a DWARF value form code into its string name.  */
22734
22735 static const char *
22736 dwarf_form_name (unsigned form)
22737 {
22738   const char *name = get_DW_FORM_name (form);
22739
22740   if (name == NULL)
22741     return "DW_FORM_<unknown>";
22742
22743   return name;
22744 }
22745
22746 static const char *
22747 dwarf_bool_name (unsigned mybool)
22748 {
22749   if (mybool)
22750     return "TRUE";
22751   else
22752     return "FALSE";
22753 }
22754
22755 /* Convert a DWARF type code into its string name.  */
22756
22757 static const char *
22758 dwarf_type_encoding_name (unsigned enc)
22759 {
22760   const char *name = get_DW_ATE_name (enc);
22761
22762   if (name == NULL)
22763     return "DW_ATE_<unknown>";
22764
22765   return name;
22766 }
22767
22768 static void
22769 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22770 {
22771   unsigned int i;
22772
22773   print_spaces (indent, f);
22774   fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22775                       dwarf_tag_name (die->tag), die->abbrev,
22776                       sect_offset_str (die->sect_off));
22777
22778   if (die->parent != NULL)
22779     {
22780       print_spaces (indent, f);
22781       fprintf_unfiltered (f, "  parent at offset: %s\n",
22782                           sect_offset_str (die->parent->sect_off));
22783     }
22784
22785   print_spaces (indent, f);
22786   fprintf_unfiltered (f, "  has children: %s\n",
22787            dwarf_bool_name (die->child != NULL));
22788
22789   print_spaces (indent, f);
22790   fprintf_unfiltered (f, "  attributes:\n");
22791
22792   for (i = 0; i < die->num_attrs; ++i)
22793     {
22794       print_spaces (indent, f);
22795       fprintf_unfiltered (f, "    %s (%s) ",
22796                dwarf_attr_name (die->attrs[i].name),
22797                dwarf_form_name (die->attrs[i].form));
22798
22799       switch (die->attrs[i].form)
22800         {
22801         case DW_FORM_addr:
22802         case DW_FORM_GNU_addr_index:
22803           fprintf_unfiltered (f, "address: ");
22804           fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22805           break;
22806         case DW_FORM_block2:
22807         case DW_FORM_block4:
22808         case DW_FORM_block:
22809         case DW_FORM_block1:
22810           fprintf_unfiltered (f, "block: size %s",
22811                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22812           break;
22813         case DW_FORM_exprloc:
22814           fprintf_unfiltered (f, "expression: size %s",
22815                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22816           break;
22817         case DW_FORM_data16:
22818           fprintf_unfiltered (f, "constant of 16 bytes");
22819           break;
22820         case DW_FORM_ref_addr:
22821           fprintf_unfiltered (f, "ref address: ");
22822           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22823           break;
22824         case DW_FORM_GNU_ref_alt:
22825           fprintf_unfiltered (f, "alt ref address: ");
22826           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22827           break;
22828         case DW_FORM_ref1:
22829         case DW_FORM_ref2:
22830         case DW_FORM_ref4:
22831         case DW_FORM_ref8:
22832         case DW_FORM_ref_udata:
22833           fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22834                               (long) (DW_UNSND (&die->attrs[i])));
22835           break;
22836         case DW_FORM_data1:
22837         case DW_FORM_data2:
22838         case DW_FORM_data4:
22839         case DW_FORM_data8:
22840         case DW_FORM_udata:
22841         case DW_FORM_sdata:
22842           fprintf_unfiltered (f, "constant: %s",
22843                               pulongest (DW_UNSND (&die->attrs[i])));
22844           break;
22845         case DW_FORM_sec_offset:
22846           fprintf_unfiltered (f, "section offset: %s",
22847                               pulongest (DW_UNSND (&die->attrs[i])));
22848           break;
22849         case DW_FORM_ref_sig8:
22850           fprintf_unfiltered (f, "signature: %s",
22851                               hex_string (DW_SIGNATURE (&die->attrs[i])));
22852           break;
22853         case DW_FORM_string:
22854         case DW_FORM_strp:
22855         case DW_FORM_line_strp:
22856         case DW_FORM_GNU_str_index:
22857         case DW_FORM_GNU_strp_alt:
22858           fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22859                    DW_STRING (&die->attrs[i])
22860                    ? DW_STRING (&die->attrs[i]) : "",
22861                    DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22862           break;
22863         case DW_FORM_flag:
22864           if (DW_UNSND (&die->attrs[i]))
22865             fprintf_unfiltered (f, "flag: TRUE");
22866           else
22867             fprintf_unfiltered (f, "flag: FALSE");
22868           break;
22869         case DW_FORM_flag_present:
22870           fprintf_unfiltered (f, "flag: TRUE");
22871           break;
22872         case DW_FORM_indirect:
22873           /* The reader will have reduced the indirect form to
22874              the "base form" so this form should not occur.  */
22875           fprintf_unfiltered (f, 
22876                               "unexpected attribute form: DW_FORM_indirect");
22877           break;
22878         case DW_FORM_implicit_const:
22879           fprintf_unfiltered (f, "constant: %s",
22880                               plongest (DW_SND (&die->attrs[i])));
22881           break;
22882         default:
22883           fprintf_unfiltered (f, "unsupported attribute form: %d.",
22884                    die->attrs[i].form);
22885           break;
22886         }
22887       fprintf_unfiltered (f, "\n");
22888     }
22889 }
22890
22891 static void
22892 dump_die_for_error (struct die_info *die)
22893 {
22894   dump_die_shallow (gdb_stderr, 0, die);
22895 }
22896
22897 static void
22898 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22899 {
22900   int indent = level * 4;
22901
22902   gdb_assert (die != NULL);
22903
22904   if (level >= max_level)
22905     return;
22906
22907   dump_die_shallow (f, indent, die);
22908
22909   if (die->child != NULL)
22910     {
22911       print_spaces (indent, f);
22912       fprintf_unfiltered (f, "  Children:");
22913       if (level + 1 < max_level)
22914         {
22915           fprintf_unfiltered (f, "\n");
22916           dump_die_1 (f, level + 1, max_level, die->child);
22917         }
22918       else
22919         {
22920           fprintf_unfiltered (f,
22921                               " [not printed, max nesting level reached]\n");
22922         }
22923     }
22924
22925   if (die->sibling != NULL && level > 0)
22926     {
22927       dump_die_1 (f, level, max_level, die->sibling);
22928     }
22929 }
22930
22931 /* This is called from the pdie macro in gdbinit.in.
22932    It's not static so gcc will keep a copy callable from gdb.  */
22933
22934 void
22935 dump_die (struct die_info *die, int max_level)
22936 {
22937   dump_die_1 (gdb_stdlog, 0, max_level, die);
22938 }
22939
22940 static void
22941 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22942 {
22943   void **slot;
22944
22945   slot = htab_find_slot_with_hash (cu->die_hash, die,
22946                                    to_underlying (die->sect_off),
22947                                    INSERT);
22948
22949   *slot = die;
22950 }
22951
22952 /* Return DIE offset of ATTR.  Return 0 with complaint if ATTR is not of the
22953    required kind.  */
22954
22955 static sect_offset
22956 dwarf2_get_ref_die_offset (const struct attribute *attr)
22957 {
22958   if (attr_form_is_ref (attr))
22959     return (sect_offset) DW_UNSND (attr);
22960
22961   complaint (_("unsupported die ref attribute form: '%s'"),
22962              dwarf_form_name (attr->form));
22963   return {};
22964 }
22965
22966 /* Return the constant value held by ATTR.  Return DEFAULT_VALUE if
22967  * the value held by the attribute is not constant.  */
22968
22969 static LONGEST
22970 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22971 {
22972   if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22973     return DW_SND (attr);
22974   else if (attr->form == DW_FORM_udata
22975            || attr->form == DW_FORM_data1
22976            || attr->form == DW_FORM_data2
22977            || attr->form == DW_FORM_data4
22978            || attr->form == DW_FORM_data8)
22979     return DW_UNSND (attr);
22980   else
22981     {
22982       /* For DW_FORM_data16 see attr_form_is_constant.  */
22983       complaint (_("Attribute value is not a constant (%s)"),
22984                  dwarf_form_name (attr->form));
22985       return default_value;
22986     }
22987 }
22988
22989 /* Follow reference or signature attribute ATTR of SRC_DIE.
22990    On entry *REF_CU is the CU of SRC_DIE.
22991    On exit *REF_CU is the CU of the result.  */
22992
22993 static struct die_info *
22994 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22995                        struct dwarf2_cu **ref_cu)
22996 {
22997   struct die_info *die;
22998
22999   if (attr_form_is_ref (attr))
23000     die = follow_die_ref (src_die, attr, ref_cu);
23001   else if (attr->form == DW_FORM_ref_sig8)
23002     die = follow_die_sig (src_die, attr, ref_cu);
23003   else
23004     {
23005       dump_die_for_error (src_die);
23006       error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23007              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23008     }
23009
23010   return die;
23011 }
23012
23013 /* Follow reference OFFSET.
23014    On entry *REF_CU is the CU of the source die referencing OFFSET.
23015    On exit *REF_CU is the CU of the result.
23016    Returns NULL if OFFSET is invalid.  */
23017
23018 static struct die_info *
23019 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23020                    struct dwarf2_cu **ref_cu)
23021 {
23022   struct die_info temp_die;
23023   struct dwarf2_cu *target_cu, *cu = *ref_cu;
23024   struct dwarf2_per_objfile *dwarf2_per_objfile
23025     = cu->per_cu->dwarf2_per_objfile;
23026
23027   gdb_assert (cu->per_cu != NULL);
23028
23029   target_cu = cu;
23030
23031   if (cu->per_cu->is_debug_types)
23032     {
23033       /* .debug_types CUs cannot reference anything outside their CU.
23034          If they need to, they have to reference a signatured type via
23035          DW_FORM_ref_sig8.  */
23036       if (!offset_in_cu_p (&cu->header, sect_off))
23037         return NULL;
23038     }
23039   else if (offset_in_dwz != cu->per_cu->is_dwz
23040            || !offset_in_cu_p (&cu->header, sect_off))
23041     {
23042       struct dwarf2_per_cu_data *per_cu;
23043
23044       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23045                                                  dwarf2_per_objfile);
23046
23047       /* If necessary, add it to the queue and load its DIEs.  */
23048       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23049         load_full_comp_unit (per_cu, false, cu->language);
23050
23051       target_cu = per_cu->cu;
23052     }
23053   else if (cu->dies == NULL)
23054     {
23055       /* We're loading full DIEs during partial symbol reading.  */
23056       gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23057       load_full_comp_unit (cu->per_cu, false, language_minimal);
23058     }
23059
23060   *ref_cu = target_cu;
23061   temp_die.sect_off = sect_off;
23062
23063   if (target_cu != cu)
23064     target_cu->ancestor = cu;
23065
23066   return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23067                                                   &temp_die,
23068                                                   to_underlying (sect_off));
23069 }
23070
23071 /* Follow reference attribute ATTR of SRC_DIE.
23072    On entry *REF_CU is the CU of SRC_DIE.
23073    On exit *REF_CU is the CU of the result.  */
23074
23075 static struct die_info *
23076 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23077                 struct dwarf2_cu **ref_cu)
23078 {
23079   sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23080   struct dwarf2_cu *cu = *ref_cu;
23081   struct die_info *die;
23082
23083   die = follow_die_offset (sect_off,
23084                            (attr->form == DW_FORM_GNU_ref_alt
23085                             || cu->per_cu->is_dwz),
23086                            ref_cu);
23087   if (!die)
23088     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23089            "at %s [in module %s]"),
23090            sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23091            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23092
23093   return die;
23094 }
23095
23096 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23097    Returned value is intended for DW_OP_call*.  Returned
23098    dwarf2_locexpr_baton->data has lifetime of
23099    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
23100
23101 struct dwarf2_locexpr_baton
23102 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23103                                struct dwarf2_per_cu_data *per_cu,
23104                                CORE_ADDR (*get_frame_pc) (void *baton),
23105                                void *baton, bool resolve_abstract_p)
23106 {
23107   struct dwarf2_cu *cu;
23108   struct die_info *die;
23109   struct attribute *attr;
23110   struct dwarf2_locexpr_baton retval;
23111   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23112   struct objfile *objfile = dwarf2_per_objfile->objfile;
23113
23114   if (per_cu->cu == NULL)
23115     load_cu (per_cu, false);
23116   cu = per_cu->cu;
23117   if (cu == NULL)
23118     {
23119       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23120          Instead just throw an error, not much else we can do.  */
23121       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23122              sect_offset_str (sect_off), objfile_name (objfile));
23123     }
23124
23125   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23126   if (!die)
23127     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23128            sect_offset_str (sect_off), objfile_name (objfile));
23129
23130   attr = dwarf2_attr (die, DW_AT_location, cu);
23131   if (!attr && resolve_abstract_p
23132       && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23133           != dwarf2_per_objfile->abstract_to_concrete.end ()))
23134     {
23135       CORE_ADDR pc = (*get_frame_pc) (baton);
23136
23137       for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23138         {
23139           if (!cand->parent
23140               || cand->parent->tag != DW_TAG_subprogram)
23141             continue;
23142
23143           CORE_ADDR pc_low, pc_high;
23144           get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23145           if (pc_low == ((CORE_ADDR) -1)
23146               || !(pc_low <= pc && pc < pc_high))
23147             continue;
23148
23149           die = cand;
23150           attr = dwarf2_attr (die, DW_AT_location, cu);
23151           break;
23152         }
23153     }
23154
23155   if (!attr)
23156     {
23157       /* DWARF: "If there is no such attribute, then there is no effect.".
23158          DATA is ignored if SIZE is 0.  */
23159
23160       retval.data = NULL;
23161       retval.size = 0;
23162     }
23163   else if (attr_form_is_section_offset (attr))
23164     {
23165       struct dwarf2_loclist_baton loclist_baton;
23166       CORE_ADDR pc = (*get_frame_pc) (baton);
23167       size_t size;
23168
23169       fill_in_loclist_baton (cu, &loclist_baton, attr);
23170
23171       retval.data = dwarf2_find_location_expression (&loclist_baton,
23172                                                      &size, pc);
23173       retval.size = size;
23174     }
23175   else
23176     {
23177       if (!attr_form_is_block (attr))
23178         error (_("Dwarf Error: DIE at %s referenced in module %s "
23179                  "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23180                sect_offset_str (sect_off), objfile_name (objfile));
23181
23182       retval.data = DW_BLOCK (attr)->data;
23183       retval.size = DW_BLOCK (attr)->size;
23184     }
23185   retval.per_cu = cu->per_cu;
23186
23187   age_cached_comp_units (dwarf2_per_objfile);
23188
23189   return retval;
23190 }
23191
23192 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23193    offset.  */
23194
23195 struct dwarf2_locexpr_baton
23196 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23197                              struct dwarf2_per_cu_data *per_cu,
23198                              CORE_ADDR (*get_frame_pc) (void *baton),
23199                              void *baton)
23200 {
23201   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23202
23203   return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23204 }
23205
23206 /* Write a constant of a given type as target-ordered bytes into
23207    OBSTACK.  */
23208
23209 static const gdb_byte *
23210 write_constant_as_bytes (struct obstack *obstack,
23211                          enum bfd_endian byte_order,
23212                          struct type *type,
23213                          ULONGEST value,
23214                          LONGEST *len)
23215 {
23216   gdb_byte *result;
23217
23218   *len = TYPE_LENGTH (type);
23219   result = (gdb_byte *) obstack_alloc (obstack, *len);
23220   store_unsigned_integer (result, *len, byte_order, value);
23221
23222   return result;
23223 }
23224
23225 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23226    pointer to the constant bytes and set LEN to the length of the
23227    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
23228    does not have a DW_AT_const_value, return NULL.  */
23229
23230 const gdb_byte *
23231 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23232                              struct dwarf2_per_cu_data *per_cu,
23233                              struct obstack *obstack,
23234                              LONGEST *len)
23235 {
23236   struct dwarf2_cu *cu;
23237   struct die_info *die;
23238   struct attribute *attr;
23239   const gdb_byte *result = NULL;
23240   struct type *type;
23241   LONGEST value;
23242   enum bfd_endian byte_order;
23243   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23244
23245   if (per_cu->cu == NULL)
23246     load_cu (per_cu, false);
23247   cu = per_cu->cu;
23248   if (cu == NULL)
23249     {
23250       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23251          Instead just throw an error, not much else we can do.  */
23252       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23253              sect_offset_str (sect_off), objfile_name (objfile));
23254     }
23255
23256   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23257   if (!die)
23258     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23259            sect_offset_str (sect_off), objfile_name (objfile));
23260
23261   attr = dwarf2_attr (die, DW_AT_const_value, cu);
23262   if (attr == NULL)
23263     return NULL;
23264
23265   byte_order = (bfd_big_endian (objfile->obfd)
23266                 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23267
23268   switch (attr->form)
23269     {
23270     case DW_FORM_addr:
23271     case DW_FORM_GNU_addr_index:
23272       {
23273         gdb_byte *tem;
23274
23275         *len = cu->header.addr_size;
23276         tem = (gdb_byte *) obstack_alloc (obstack, *len);
23277         store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23278         result = tem;
23279       }
23280       break;
23281     case DW_FORM_string:
23282     case DW_FORM_strp:
23283     case DW_FORM_GNU_str_index:
23284     case DW_FORM_GNU_strp_alt:
23285       /* DW_STRING is already allocated on the objfile obstack, point
23286          directly to it.  */
23287       result = (const gdb_byte *) DW_STRING (attr);
23288       *len = strlen (DW_STRING (attr));
23289       break;
23290     case DW_FORM_block1:
23291     case DW_FORM_block2:
23292     case DW_FORM_block4:
23293     case DW_FORM_block:
23294     case DW_FORM_exprloc:
23295     case DW_FORM_data16:
23296       result = DW_BLOCK (attr)->data;
23297       *len = DW_BLOCK (attr)->size;
23298       break;
23299
23300       /* The DW_AT_const_value attributes are supposed to carry the
23301          symbol's value "represented as it would be on the target
23302          architecture."  By the time we get here, it's already been
23303          converted to host endianness, so we just need to sign- or
23304          zero-extend it as appropriate.  */
23305     case DW_FORM_data1:
23306       type = die_type (die, cu);
23307       result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23308       if (result == NULL)
23309         result = write_constant_as_bytes (obstack, byte_order,
23310                                           type, value, len);
23311       break;
23312     case DW_FORM_data2:
23313       type = die_type (die, cu);
23314       result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23315       if (result == NULL)
23316         result = write_constant_as_bytes (obstack, byte_order,
23317                                           type, value, len);
23318       break;
23319     case DW_FORM_data4:
23320       type = die_type (die, cu);
23321       result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23322       if (result == NULL)
23323         result = write_constant_as_bytes (obstack, byte_order,
23324                                           type, value, len);
23325       break;
23326     case DW_FORM_data8:
23327       type = die_type (die, cu);
23328       result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23329       if (result == NULL)
23330         result = write_constant_as_bytes (obstack, byte_order,
23331                                           type, value, len);
23332       break;
23333
23334     case DW_FORM_sdata:
23335     case DW_FORM_implicit_const:
23336       type = die_type (die, cu);
23337       result = write_constant_as_bytes (obstack, byte_order,
23338                                         type, DW_SND (attr), len);
23339       break;
23340
23341     case DW_FORM_udata:
23342       type = die_type (die, cu);
23343       result = write_constant_as_bytes (obstack, byte_order,
23344                                         type, DW_UNSND (attr), len);
23345       break;
23346
23347     default:
23348       complaint (_("unsupported const value attribute form: '%s'"),
23349                  dwarf_form_name (attr->form));
23350       break;
23351     }
23352
23353   return result;
23354 }
23355
23356 /* Return the type of the die at OFFSET in PER_CU.  Return NULL if no
23357    valid type for this die is found.  */
23358
23359 struct type *
23360 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23361                                 struct dwarf2_per_cu_data *per_cu)
23362 {
23363   struct dwarf2_cu *cu;
23364   struct die_info *die;
23365
23366   if (per_cu->cu == NULL)
23367     load_cu (per_cu, false);
23368   cu = per_cu->cu;
23369   if (!cu)
23370     return NULL;
23371
23372   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23373   if (!die)
23374     return NULL;
23375
23376   return die_type (die, cu);
23377 }
23378
23379 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23380    PER_CU.  */
23381
23382 struct type *
23383 dwarf2_get_die_type (cu_offset die_offset,
23384                      struct dwarf2_per_cu_data *per_cu)
23385 {
23386   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23387   return get_die_type_at_offset (die_offset_sect, per_cu);
23388 }
23389
23390 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23391    On entry *REF_CU is the CU of SRC_DIE.
23392    On exit *REF_CU is the CU of the result.
23393    Returns NULL if the referenced DIE isn't found.  */
23394
23395 static struct die_info *
23396 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23397                   struct dwarf2_cu **ref_cu)
23398 {
23399   struct die_info temp_die;
23400   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
23401   struct die_info *die;
23402
23403   /* While it might be nice to assert sig_type->type == NULL here,
23404      we can get here for DW_AT_imported_declaration where we need
23405      the DIE not the type.  */
23406
23407   /* If necessary, add it to the queue and load its DIEs.  */
23408
23409   if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23410     read_signatured_type (sig_type);
23411
23412   sig_cu = sig_type->per_cu.cu;
23413   gdb_assert (sig_cu != NULL);
23414   gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23415   temp_die.sect_off = sig_type->type_offset_in_section;
23416   die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23417                                                  to_underlying (temp_die.sect_off));
23418   if (die)
23419     {
23420       struct dwarf2_per_objfile *dwarf2_per_objfile
23421         = (*ref_cu)->per_cu->dwarf2_per_objfile;
23422
23423       /* For .gdb_index version 7 keep track of included TUs.
23424          http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */
23425       if (dwarf2_per_objfile->index_table != NULL
23426           && dwarf2_per_objfile->index_table->version <= 7)
23427         {
23428           VEC_safe_push (dwarf2_per_cu_ptr,
23429                          (*ref_cu)->per_cu->imported_symtabs,
23430                          sig_cu->per_cu);
23431         }
23432
23433       *ref_cu = sig_cu;
23434       if (sig_cu != cu)
23435         sig_cu->ancestor = cu;
23436
23437       return die;
23438     }
23439
23440   return NULL;
23441 }
23442
23443 /* Follow signatured type referenced by ATTR in SRC_DIE.
23444    On entry *REF_CU is the CU of SRC_DIE.
23445    On exit *REF_CU is the CU of the result.
23446    The result is the DIE of the type.
23447    If the referenced type cannot be found an error is thrown.  */
23448
23449 static struct die_info *
23450 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23451                 struct dwarf2_cu **ref_cu)
23452 {
23453   ULONGEST signature = DW_SIGNATURE (attr);
23454   struct signatured_type *sig_type;
23455   struct die_info *die;
23456
23457   gdb_assert (attr->form == DW_FORM_ref_sig8);
23458
23459   sig_type = lookup_signatured_type (*ref_cu, signature);
23460   /* sig_type will be NULL if the signatured type is missing from
23461      the debug info.  */
23462   if (sig_type == NULL)
23463     {
23464       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23465                " from DIE at %s [in module %s]"),
23466              hex_string (signature), sect_offset_str (src_die->sect_off),
23467              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23468     }
23469
23470   die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23471   if (die == NULL)
23472     {
23473       dump_die_for_error (src_die);
23474       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23475                " from DIE at %s [in module %s]"),
23476              hex_string (signature), sect_offset_str (src_die->sect_off),
23477              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23478     }
23479
23480   return die;
23481 }
23482
23483 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23484    reading in and processing the type unit if necessary.  */
23485
23486 static struct type *
23487 get_signatured_type (struct die_info *die, ULONGEST signature,
23488                      struct dwarf2_cu *cu)
23489 {
23490   struct dwarf2_per_objfile *dwarf2_per_objfile
23491     = cu->per_cu->dwarf2_per_objfile;
23492   struct signatured_type *sig_type;
23493   struct dwarf2_cu *type_cu;
23494   struct die_info *type_die;
23495   struct type *type;
23496
23497   sig_type = lookup_signatured_type (cu, signature);
23498   /* sig_type will be NULL if the signatured type is missing from
23499      the debug info.  */
23500   if (sig_type == NULL)
23501     {
23502       complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23503                    " from DIE at %s [in module %s]"),
23504                  hex_string (signature), sect_offset_str (die->sect_off),
23505                  objfile_name (dwarf2_per_objfile->objfile));
23506       return build_error_marker_type (cu, die);
23507     }
23508
23509   /* If we already know the type we're done.  */
23510   if (sig_type->type != NULL)
23511     return sig_type->type;
23512
23513   type_cu = cu;
23514   type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23515   if (type_die != NULL)
23516     {
23517       /* N.B. We need to call get_die_type to ensure only one type for this DIE
23518          is created.  This is important, for example, because for c++ classes
23519          we need TYPE_NAME set which is only done by new_symbol.  Blech.  */
23520       type = read_type_die (type_die, type_cu);
23521       if (type == NULL)
23522         {
23523           complaint (_("Dwarf Error: Cannot build signatured type %s"
23524                        " referenced from DIE at %s [in module %s]"),
23525                      hex_string (signature), sect_offset_str (die->sect_off),
23526                      objfile_name (dwarf2_per_objfile->objfile));
23527           type = build_error_marker_type (cu, die);
23528         }
23529     }
23530   else
23531     {
23532       complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23533                    " from DIE at %s [in module %s]"),
23534                  hex_string (signature), sect_offset_str (die->sect_off),
23535                  objfile_name (dwarf2_per_objfile->objfile));
23536       type = build_error_marker_type (cu, die);
23537     }
23538   sig_type->type = type;
23539
23540   return type;
23541 }
23542
23543 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23544    reading in and processing the type unit if necessary.  */
23545
23546 static struct type *
23547 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23548                           struct dwarf2_cu *cu) /* ARI: editCase function */
23549 {
23550   /* Yes, DW_AT_signature can use a non-ref_sig8 reference.  */
23551   if (attr_form_is_ref (attr))
23552     {
23553       struct dwarf2_cu *type_cu = cu;
23554       struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23555
23556       return read_type_die (type_die, type_cu);
23557     }
23558   else if (attr->form == DW_FORM_ref_sig8)
23559     {
23560       return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23561     }
23562   else
23563     {
23564       struct dwarf2_per_objfile *dwarf2_per_objfile
23565         = cu->per_cu->dwarf2_per_objfile;
23566
23567       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23568                    " at %s [in module %s]"),
23569                  dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23570                  objfile_name (dwarf2_per_objfile->objfile));
23571       return build_error_marker_type (cu, die);
23572     }
23573 }
23574
23575 /* Load the DIEs associated with type unit PER_CU into memory.  */
23576
23577 static void
23578 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23579 {
23580   struct signatured_type *sig_type;
23581
23582   /* Caller is responsible for ensuring type_unit_groups don't get here.  */
23583   gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23584
23585   /* We have the per_cu, but we need the signatured_type.
23586      Fortunately this is an easy translation.  */
23587   gdb_assert (per_cu->is_debug_types);
23588   sig_type = (struct signatured_type *) per_cu;
23589
23590   gdb_assert (per_cu->cu == NULL);
23591
23592   read_signatured_type (sig_type);
23593
23594   gdb_assert (per_cu->cu != NULL);
23595 }
23596
23597 /* die_reader_func for read_signatured_type.
23598    This is identical to load_full_comp_unit_reader,
23599    but is kept separate for now.  */
23600
23601 static void
23602 read_signatured_type_reader (const struct die_reader_specs *reader,
23603                              const gdb_byte *info_ptr,
23604                              struct die_info *comp_unit_die,
23605                              int has_children,
23606                              void *data)
23607 {
23608   struct dwarf2_cu *cu = reader->cu;
23609
23610   gdb_assert (cu->die_hash == NULL);
23611   cu->die_hash =
23612     htab_create_alloc_ex (cu->header.length / 12,
23613                           die_hash,
23614                           die_eq,
23615                           NULL,
23616                           &cu->comp_unit_obstack,
23617                           hashtab_obstack_allocate,
23618                           dummy_obstack_deallocate);
23619
23620   if (has_children)
23621     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23622                                                   &info_ptr, comp_unit_die);
23623   cu->dies = comp_unit_die;
23624   /* comp_unit_die is not stored in die_hash, no need.  */
23625
23626   /* We try not to read any attributes in this function, because not
23627      all CUs needed for references have been loaded yet, and symbol
23628      table processing isn't initialized.  But we have to set the CU language,
23629      or we won't be able to build types correctly.
23630      Similarly, if we do not read the producer, we can not apply
23631      producer-specific interpretation.  */
23632   prepare_one_comp_unit (cu, cu->dies, language_minimal);
23633 }
23634
23635 /* Read in a signatured type and build its CU and DIEs.
23636    If the type is a stub for the real type in a DWO file,
23637    read in the real type from the DWO file as well.  */
23638
23639 static void
23640 read_signatured_type (struct signatured_type *sig_type)
23641 {
23642   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23643
23644   gdb_assert (per_cu->is_debug_types);
23645   gdb_assert (per_cu->cu == NULL);
23646
23647   init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23648                            read_signatured_type_reader, NULL);
23649   sig_type->per_cu.tu_read = 1;
23650 }
23651
23652 /* Decode simple location descriptions.
23653    Given a pointer to a dwarf block that defines a location, compute
23654    the location and return the value.
23655
23656    NOTE drow/2003-11-18: This function is called in two situations
23657    now: for the address of static or global variables (partial symbols
23658    only) and for offsets into structures which are expected to be
23659    (more or less) constant.  The partial symbol case should go away,
23660    and only the constant case should remain.  That will let this
23661    function complain more accurately.  A few special modes are allowed
23662    without complaint for global variables (for instance, global
23663    register values and thread-local values).
23664
23665    A location description containing no operations indicates that the
23666    object is optimized out.  The return value is 0 for that case.
23667    FIXME drow/2003-11-16: No callers check for this case any more; soon all
23668    callers will only want a very basic result and this can become a
23669    complaint.
23670
23671    Note that stack[0] is unused except as a default error return.  */
23672
23673 static CORE_ADDR
23674 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23675 {
23676   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23677   size_t i;
23678   size_t size = blk->size;
23679   const gdb_byte *data = blk->data;
23680   CORE_ADDR stack[64];
23681   int stacki;
23682   unsigned int bytes_read, unsnd;
23683   gdb_byte op;
23684
23685   i = 0;
23686   stacki = 0;
23687   stack[stacki] = 0;
23688   stack[++stacki] = 0;
23689
23690   while (i < size)
23691     {
23692       op = data[i++];
23693       switch (op)
23694         {
23695         case DW_OP_lit0:
23696         case DW_OP_lit1:
23697         case DW_OP_lit2:
23698         case DW_OP_lit3:
23699         case DW_OP_lit4:
23700         case DW_OP_lit5:
23701         case DW_OP_lit6:
23702         case DW_OP_lit7:
23703         case DW_OP_lit8:
23704         case DW_OP_lit9:
23705         case DW_OP_lit10:
23706         case DW_OP_lit11:
23707         case DW_OP_lit12:
23708         case DW_OP_lit13:
23709         case DW_OP_lit14:
23710         case DW_OP_lit15:
23711         case DW_OP_lit16:
23712         case DW_OP_lit17:
23713         case DW_OP_lit18:
23714         case DW_OP_lit19:
23715         case DW_OP_lit20:
23716         case DW_OP_lit21:
23717         case DW_OP_lit22:
23718         case DW_OP_lit23:
23719         case DW_OP_lit24:
23720         case DW_OP_lit25:
23721         case DW_OP_lit26:
23722         case DW_OP_lit27:
23723         case DW_OP_lit28:
23724         case DW_OP_lit29:
23725         case DW_OP_lit30:
23726         case DW_OP_lit31:
23727           stack[++stacki] = op - DW_OP_lit0;
23728           break;
23729
23730         case DW_OP_reg0:
23731         case DW_OP_reg1:
23732         case DW_OP_reg2:
23733         case DW_OP_reg3:
23734         case DW_OP_reg4:
23735         case DW_OP_reg5:
23736         case DW_OP_reg6:
23737         case DW_OP_reg7:
23738         case DW_OP_reg8:
23739         case DW_OP_reg9:
23740         case DW_OP_reg10:
23741         case DW_OP_reg11:
23742         case DW_OP_reg12:
23743         case DW_OP_reg13:
23744         case DW_OP_reg14:
23745         case DW_OP_reg15:
23746         case DW_OP_reg16:
23747         case DW_OP_reg17:
23748         case DW_OP_reg18:
23749         case DW_OP_reg19:
23750         case DW_OP_reg20:
23751         case DW_OP_reg21:
23752         case DW_OP_reg22:
23753         case DW_OP_reg23:
23754         case DW_OP_reg24:
23755         case DW_OP_reg25:
23756         case DW_OP_reg26:
23757         case DW_OP_reg27:
23758         case DW_OP_reg28:
23759         case DW_OP_reg29:
23760         case DW_OP_reg30:
23761         case DW_OP_reg31:
23762           stack[++stacki] = op - DW_OP_reg0;
23763           if (i < size)
23764             dwarf2_complex_location_expr_complaint ();
23765           break;
23766
23767         case DW_OP_regx:
23768           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23769           i += bytes_read;
23770           stack[++stacki] = unsnd;
23771           if (i < size)
23772             dwarf2_complex_location_expr_complaint ();
23773           break;
23774
23775         case DW_OP_addr:
23776           stack[++stacki] = read_address (objfile->obfd, &data[i],
23777                                           cu, &bytes_read);
23778           i += bytes_read;
23779           break;
23780
23781         case DW_OP_const1u:
23782           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23783           i += 1;
23784           break;
23785
23786         case DW_OP_const1s:
23787           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23788           i += 1;
23789           break;
23790
23791         case DW_OP_const2u:
23792           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23793           i += 2;
23794           break;
23795
23796         case DW_OP_const2s:
23797           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23798           i += 2;
23799           break;
23800
23801         case DW_OP_const4u:
23802           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23803           i += 4;
23804           break;
23805
23806         case DW_OP_const4s:
23807           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23808           i += 4;
23809           break;
23810
23811         case DW_OP_const8u:
23812           stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23813           i += 8;
23814           break;
23815
23816         case DW_OP_constu:
23817           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23818                                                   &bytes_read);
23819           i += bytes_read;
23820           break;
23821
23822         case DW_OP_consts:
23823           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23824           i += bytes_read;
23825           break;
23826
23827         case DW_OP_dup:
23828           stack[stacki + 1] = stack[stacki];
23829           stacki++;
23830           break;
23831
23832         case DW_OP_plus:
23833           stack[stacki - 1] += stack[stacki];
23834           stacki--;
23835           break;
23836
23837         case DW_OP_plus_uconst:
23838           stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23839                                                  &bytes_read);
23840           i += bytes_read;
23841           break;
23842
23843         case DW_OP_minus:
23844           stack[stacki - 1] -= stack[stacki];
23845           stacki--;
23846           break;
23847
23848         case DW_OP_deref:
23849           /* If we're not the last op, then we definitely can't encode
23850              this using GDB's address_class enum.  This is valid for partial
23851              global symbols, although the variable's address will be bogus
23852              in the psymtab.  */
23853           if (i < size)
23854             dwarf2_complex_location_expr_complaint ();
23855           break;
23856
23857         case DW_OP_GNU_push_tls_address:
23858         case DW_OP_form_tls_address:
23859           /* The top of the stack has the offset from the beginning
23860              of the thread control block at which the variable is located.  */
23861           /* Nothing should follow this operator, so the top of stack would
23862              be returned.  */
23863           /* This is valid for partial global symbols, but the variable's
23864              address will be bogus in the psymtab.  Make it always at least
23865              non-zero to not look as a variable garbage collected by linker
23866              which have DW_OP_addr 0.  */
23867           if (i < size)
23868             dwarf2_complex_location_expr_complaint ();
23869           stack[stacki]++;
23870           break;
23871
23872         case DW_OP_GNU_uninit:
23873           break;
23874
23875         case DW_OP_GNU_addr_index:
23876         case DW_OP_GNU_const_index:
23877           stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23878                                                          &bytes_read);
23879           i += bytes_read;
23880           break;
23881
23882         default:
23883           {
23884             const char *name = get_DW_OP_name (op);
23885
23886             if (name)
23887               complaint (_("unsupported stack op: '%s'"),
23888                          name);
23889             else
23890               complaint (_("unsupported stack op: '%02x'"),
23891                          op);
23892           }
23893
23894           return (stack[stacki]);
23895         }
23896
23897       /* Enforce maximum stack depth of SIZE-1 to avoid writing
23898          outside of the allocated space.  Also enforce minimum>0.  */
23899       if (stacki >= ARRAY_SIZE (stack) - 1)
23900         {
23901           complaint (_("location description stack overflow"));
23902           return 0;
23903         }
23904
23905       if (stacki <= 0)
23906         {
23907           complaint (_("location description stack underflow"));
23908           return 0;
23909         }
23910     }
23911   return (stack[stacki]);
23912 }
23913
23914 /* memory allocation interface */
23915
23916 static struct dwarf_block *
23917 dwarf_alloc_block (struct dwarf2_cu *cu)
23918 {
23919   return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23920 }
23921
23922 static struct die_info *
23923 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23924 {
23925   struct die_info *die;
23926   size_t size = sizeof (struct die_info);
23927
23928   if (num_attrs > 1)
23929     size += (num_attrs - 1) * sizeof (struct attribute);
23930
23931   die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23932   memset (die, 0, sizeof (struct die_info));
23933   return (die);
23934 }
23935
23936 \f
23937 /* Macro support.  */
23938
23939 /* Return file name relative to the compilation directory of file number I in
23940    *LH's file name table.  The result is allocated using xmalloc; the caller is
23941    responsible for freeing it.  */
23942
23943 static char *
23944 file_file_name (int file, struct line_header *lh)
23945 {
23946   /* Is the file number a valid index into the line header's file name
23947      table?  Remember that file numbers start with one, not zero.  */
23948   if (1 <= file && file <= lh->file_names.size ())
23949     {
23950       const file_entry &fe = lh->file_names[file - 1];
23951
23952       if (!IS_ABSOLUTE_PATH (fe.name))
23953         {
23954           const char *dir = fe.include_dir (lh);
23955           if (dir != NULL)
23956             return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23957         }
23958       return xstrdup (fe.name);
23959     }
23960   else
23961     {
23962       /* The compiler produced a bogus file number.  We can at least
23963          record the macro definitions made in the file, even if we
23964          won't be able to find the file by name.  */
23965       char fake_name[80];
23966
23967       xsnprintf (fake_name, sizeof (fake_name),
23968                  "<bad macro file number %d>", file);
23969
23970       complaint (_("bad file number in macro information (%d)"),
23971                  file);
23972
23973       return xstrdup (fake_name);
23974     }
23975 }
23976
23977 /* Return the full name of file number I in *LH's file name table.
23978    Use COMP_DIR as the name of the current directory of the
23979    compilation.  The result is allocated using xmalloc; the caller is
23980    responsible for freeing it.  */
23981 static char *
23982 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23983 {
23984   /* Is the file number a valid index into the line header's file name
23985      table?  Remember that file numbers start with one, not zero.  */
23986   if (1 <= file && file <= lh->file_names.size ())
23987     {
23988       char *relative = file_file_name (file, lh);
23989
23990       if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23991         return relative;
23992       return reconcat (relative, comp_dir, SLASH_STRING,
23993                        relative, (char *) NULL);
23994     }
23995   else
23996     return file_file_name (file, lh);
23997 }
23998
23999
24000 static struct macro_source_file *
24001 macro_start_file (struct dwarf2_cu *cu,
24002                   int file, int line,
24003                   struct macro_source_file *current_file,
24004                   struct line_header *lh)
24005 {
24006   /* File name relative to the compilation directory of this source file.  */
24007   char *file_name = file_file_name (file, lh);
24008
24009   if (! current_file)
24010     {
24011       /* Note: We don't create a macro table for this compilation unit
24012          at all until we actually get a filename.  */
24013       struct macro_table *macro_table = cu->get_builder ()->get_macro_table ();
24014
24015       /* If we have no current file, then this must be the start_file
24016          directive for the compilation unit's main source file.  */
24017       current_file = macro_set_main (macro_table, file_name);
24018       macro_define_special (macro_table);
24019     }
24020   else
24021     current_file = macro_include (current_file, line, file_name);
24022
24023   xfree (file_name);
24024
24025   return current_file;
24026 }
24027
24028 static const char *
24029 consume_improper_spaces (const char *p, const char *body)
24030 {
24031   if (*p == ' ')
24032     {
24033       complaint (_("macro definition contains spaces "
24034                    "in formal argument list:\n`%s'"),
24035                  body);
24036
24037       while (*p == ' ')
24038         p++;
24039     }
24040
24041   return p;
24042 }
24043
24044
24045 static void
24046 parse_macro_definition (struct macro_source_file *file, int line,
24047                         const char *body)
24048 {
24049   const char *p;
24050
24051   /* The body string takes one of two forms.  For object-like macro
24052      definitions, it should be:
24053
24054         <macro name> " " <definition>
24055
24056      For function-like macro definitions, it should be:
24057
24058         <macro name> "() " <definition>
24059      or
24060         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24061
24062      Spaces may appear only where explicitly indicated, and in the
24063      <definition>.
24064
24065      The Dwarf 2 spec says that an object-like macro's name is always
24066      followed by a space, but versions of GCC around March 2002 omit
24067      the space when the macro's definition is the empty string.
24068
24069      The Dwarf 2 spec says that there should be no spaces between the
24070      formal arguments in a function-like macro's formal argument list,
24071      but versions of GCC around March 2002 include spaces after the
24072      commas.  */
24073
24074
24075   /* Find the extent of the macro name.  The macro name is terminated
24076      by either a space or null character (for an object-like macro) or
24077      an opening paren (for a function-like macro).  */
24078   for (p = body; *p; p++)
24079     if (*p == ' ' || *p == '(')
24080       break;
24081
24082   if (*p == ' ' || *p == '\0')
24083     {
24084       /* It's an object-like macro.  */
24085       int name_len = p - body;
24086       char *name = savestring (body, name_len);
24087       const char *replacement;
24088
24089       if (*p == ' ')
24090         replacement = body + name_len + 1;
24091       else
24092         {
24093           dwarf2_macro_malformed_definition_complaint (body);
24094           replacement = body + name_len;
24095         }
24096
24097       macro_define_object (file, line, name, replacement);
24098
24099       xfree (name);
24100     }
24101   else if (*p == '(')
24102     {
24103       /* It's a function-like macro.  */
24104       char *name = savestring (body, p - body);
24105       int argc = 0;
24106       int argv_size = 1;
24107       char **argv = XNEWVEC (char *, argv_size);
24108
24109       p++;
24110
24111       p = consume_improper_spaces (p, body);
24112
24113       /* Parse the formal argument list.  */
24114       while (*p && *p != ')')
24115         {
24116           /* Find the extent of the current argument name.  */
24117           const char *arg_start = p;
24118
24119           while (*p && *p != ',' && *p != ')' && *p != ' ')
24120             p++;
24121
24122           if (! *p || p == arg_start)
24123             dwarf2_macro_malformed_definition_complaint (body);
24124           else
24125             {
24126               /* Make sure argv has room for the new argument.  */
24127               if (argc >= argv_size)
24128                 {
24129                   argv_size *= 2;
24130                   argv = XRESIZEVEC (char *, argv, argv_size);
24131                 }
24132
24133               argv[argc++] = savestring (arg_start, p - arg_start);
24134             }
24135
24136           p = consume_improper_spaces (p, body);
24137
24138           /* Consume the comma, if present.  */
24139           if (*p == ',')
24140             {
24141               p++;
24142
24143               p = consume_improper_spaces (p, body);
24144             }
24145         }
24146
24147       if (*p == ')')
24148         {
24149           p++;
24150
24151           if (*p == ' ')
24152             /* Perfectly formed definition, no complaints.  */
24153             macro_define_function (file, line, name,
24154                                    argc, (const char **) argv,
24155                                    p + 1);
24156           else if (*p == '\0')
24157             {
24158               /* Complain, but do define it.  */
24159               dwarf2_macro_malformed_definition_complaint (body);
24160               macro_define_function (file, line, name,
24161                                      argc, (const char **) argv,
24162                                      p);
24163             }
24164           else
24165             /* Just complain.  */
24166             dwarf2_macro_malformed_definition_complaint (body);
24167         }
24168       else
24169         /* Just complain.  */
24170         dwarf2_macro_malformed_definition_complaint (body);
24171
24172       xfree (name);
24173       {
24174         int i;
24175
24176         for (i = 0; i < argc; i++)
24177           xfree (argv[i]);
24178       }
24179       xfree (argv);
24180     }
24181   else
24182     dwarf2_macro_malformed_definition_complaint (body);
24183 }
24184
24185 /* Skip some bytes from BYTES according to the form given in FORM.
24186    Returns the new pointer.  */
24187
24188 static const gdb_byte *
24189 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24190                  enum dwarf_form form,
24191                  unsigned int offset_size,
24192                  struct dwarf2_section_info *section)
24193 {
24194   unsigned int bytes_read;
24195
24196   switch (form)
24197     {
24198     case DW_FORM_data1:
24199     case DW_FORM_flag:
24200       ++bytes;
24201       break;
24202
24203     case DW_FORM_data2:
24204       bytes += 2;
24205       break;
24206
24207     case DW_FORM_data4:
24208       bytes += 4;
24209       break;
24210
24211     case DW_FORM_data8:
24212       bytes += 8;
24213       break;
24214
24215     case DW_FORM_data16:
24216       bytes += 16;
24217       break;
24218
24219     case DW_FORM_string:
24220       read_direct_string (abfd, bytes, &bytes_read);
24221       bytes += bytes_read;
24222       break;
24223
24224     case DW_FORM_sec_offset:
24225     case DW_FORM_strp:
24226     case DW_FORM_GNU_strp_alt:
24227       bytes += offset_size;
24228       break;
24229
24230     case DW_FORM_block:
24231       bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24232       bytes += bytes_read;
24233       break;
24234
24235     case DW_FORM_block1:
24236       bytes += 1 + read_1_byte (abfd, bytes);
24237       break;
24238     case DW_FORM_block2:
24239       bytes += 2 + read_2_bytes (abfd, bytes);
24240       break;
24241     case DW_FORM_block4:
24242       bytes += 4 + read_4_bytes (abfd, bytes);
24243       break;
24244
24245     case DW_FORM_sdata:
24246     case DW_FORM_udata:
24247     case DW_FORM_GNU_addr_index:
24248     case DW_FORM_GNU_str_index:
24249       bytes = gdb_skip_leb128 (bytes, buffer_end);
24250       if (bytes == NULL)
24251         {
24252           dwarf2_section_buffer_overflow_complaint (section);
24253           return NULL;
24254         }
24255       break;
24256
24257     case DW_FORM_implicit_const:
24258       break;
24259
24260     default:
24261       {
24262         complaint (_("invalid form 0x%x in `%s'"),
24263                    form, get_section_name (section));
24264         return NULL;
24265       }
24266     }
24267
24268   return bytes;
24269 }
24270
24271 /* A helper for dwarf_decode_macros that handles skipping an unknown
24272    opcode.  Returns an updated pointer to the macro data buffer; or,
24273    on error, issues a complaint and returns NULL.  */
24274
24275 static const gdb_byte *
24276 skip_unknown_opcode (unsigned int opcode,
24277                      const gdb_byte **opcode_definitions,
24278                      const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24279                      bfd *abfd,
24280                      unsigned int offset_size,
24281                      struct dwarf2_section_info *section)
24282 {
24283   unsigned int bytes_read, i;
24284   unsigned long arg;
24285   const gdb_byte *defn;
24286
24287   if (opcode_definitions[opcode] == NULL)
24288     {
24289       complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24290                  opcode);
24291       return NULL;
24292     }
24293
24294   defn = opcode_definitions[opcode];
24295   arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24296   defn += bytes_read;
24297
24298   for (i = 0; i < arg; ++i)
24299     {
24300       mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24301                                  (enum dwarf_form) defn[i], offset_size,
24302                                  section);
24303       if (mac_ptr == NULL)
24304         {
24305           /* skip_form_bytes already issued the complaint.  */
24306           return NULL;
24307         }
24308     }
24309
24310   return mac_ptr;
24311 }
24312
24313 /* A helper function which parses the header of a macro section.
24314    If the macro section is the extended (for now called "GNU") type,
24315    then this updates *OFFSET_SIZE.  Returns a pointer to just after
24316    the header, or issues a complaint and returns NULL on error.  */
24317
24318 static const gdb_byte *
24319 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24320                           bfd *abfd,
24321                           const gdb_byte *mac_ptr,
24322                           unsigned int *offset_size,
24323                           int section_is_gnu)
24324 {
24325   memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24326
24327   if (section_is_gnu)
24328     {
24329       unsigned int version, flags;
24330
24331       version = read_2_bytes (abfd, mac_ptr);
24332       if (version != 4 && version != 5)
24333         {
24334           complaint (_("unrecognized version `%d' in .debug_macro section"),
24335                      version);
24336           return NULL;
24337         }
24338       mac_ptr += 2;
24339
24340       flags = read_1_byte (abfd, mac_ptr);
24341       ++mac_ptr;
24342       *offset_size = (flags & 1) ? 8 : 4;
24343
24344       if ((flags & 2) != 0)
24345         /* We don't need the line table offset.  */
24346         mac_ptr += *offset_size;
24347
24348       /* Vendor opcode descriptions.  */
24349       if ((flags & 4) != 0)
24350         {
24351           unsigned int i, count;
24352
24353           count = read_1_byte (abfd, mac_ptr);
24354           ++mac_ptr;
24355           for (i = 0; i < count; ++i)
24356             {
24357               unsigned int opcode, bytes_read;
24358               unsigned long arg;
24359
24360               opcode = read_1_byte (abfd, mac_ptr);
24361               ++mac_ptr;
24362               opcode_definitions[opcode] = mac_ptr;
24363               arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24364               mac_ptr += bytes_read;
24365               mac_ptr += arg;
24366             }
24367         }
24368     }
24369
24370   return mac_ptr;
24371 }
24372
24373 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24374    including DW_MACRO_import.  */
24375
24376 static void
24377 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24378                           bfd *abfd,
24379                           const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24380                           struct macro_source_file *current_file,
24381                           struct line_header *lh,
24382                           struct dwarf2_section_info *section,
24383                           int section_is_gnu, int section_is_dwz,
24384                           unsigned int offset_size,
24385                           htab_t include_hash)
24386 {
24387   struct dwarf2_per_objfile *dwarf2_per_objfile
24388     = cu->per_cu->dwarf2_per_objfile;
24389   struct objfile *objfile = dwarf2_per_objfile->objfile;
24390   enum dwarf_macro_record_type macinfo_type;
24391   int at_commandline;
24392   const gdb_byte *opcode_definitions[256];
24393
24394   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24395                                       &offset_size, section_is_gnu);
24396   if (mac_ptr == NULL)
24397     {
24398       /* We already issued a complaint.  */
24399       return;
24400     }
24401
24402   /* Determines if GDB is still before first DW_MACINFO_start_file.  If true
24403      GDB is still reading the definitions from command line.  First
24404      DW_MACINFO_start_file will need to be ignored as it was already executed
24405      to create CURRENT_FILE for the main source holding also the command line
24406      definitions.  On first met DW_MACINFO_start_file this flag is reset to
24407      normally execute all the remaining DW_MACINFO_start_file macinfos.  */
24408
24409   at_commandline = 1;
24410
24411   do
24412     {
24413       /* Do we at least have room for a macinfo type byte?  */
24414       if (mac_ptr >= mac_end)
24415         {
24416           dwarf2_section_buffer_overflow_complaint (section);
24417           break;
24418         }
24419
24420       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24421       mac_ptr++;
24422
24423       /* Note that we rely on the fact that the corresponding GNU and
24424          DWARF constants are the same.  */
24425       DIAGNOSTIC_PUSH
24426       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24427       switch (macinfo_type)
24428         {
24429           /* A zero macinfo type indicates the end of the macro
24430              information.  */
24431         case 0:
24432           break;
24433
24434         case DW_MACRO_define:
24435         case DW_MACRO_undef:
24436         case DW_MACRO_define_strp:
24437         case DW_MACRO_undef_strp:
24438         case DW_MACRO_define_sup:
24439         case DW_MACRO_undef_sup:
24440           {
24441             unsigned int bytes_read;
24442             int line;
24443             const char *body;
24444             int is_define;
24445
24446             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24447             mac_ptr += bytes_read;
24448
24449             if (macinfo_type == DW_MACRO_define
24450                 || macinfo_type == DW_MACRO_undef)
24451               {
24452                 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24453                 mac_ptr += bytes_read;
24454               }
24455             else
24456               {
24457                 LONGEST str_offset;
24458
24459                 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24460                 mac_ptr += offset_size;
24461
24462                 if (macinfo_type == DW_MACRO_define_sup
24463                     || macinfo_type == DW_MACRO_undef_sup
24464                     || section_is_dwz)
24465                   {
24466                     struct dwz_file *dwz
24467                       = dwarf2_get_dwz_file (dwarf2_per_objfile);
24468
24469                     body = read_indirect_string_from_dwz (objfile,
24470                                                           dwz, str_offset);
24471                   }
24472                 else
24473                   body = read_indirect_string_at_offset (dwarf2_per_objfile,
24474                                                          abfd, str_offset);
24475               }
24476
24477             is_define = (macinfo_type == DW_MACRO_define
24478                          || macinfo_type == DW_MACRO_define_strp
24479                          || macinfo_type == DW_MACRO_define_sup);
24480             if (! current_file)
24481               {
24482                 /* DWARF violation as no main source is present.  */
24483                 complaint (_("debug info with no main source gives macro %s "
24484                              "on line %d: %s"),
24485                            is_define ? _("definition") : _("undefinition"),
24486                            line, body);
24487                 break;
24488               }
24489             if ((line == 0 && !at_commandline)
24490                 || (line != 0 && at_commandline))
24491               complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24492                          at_commandline ? _("command-line") : _("in-file"),
24493                          is_define ? _("definition") : _("undefinition"),
24494                          line == 0 ? _("zero") : _("non-zero"), line, body);
24495
24496             if (is_define)
24497               parse_macro_definition (current_file, line, body);
24498             else
24499               {
24500                 gdb_assert (macinfo_type == DW_MACRO_undef
24501                             || macinfo_type == DW_MACRO_undef_strp
24502                             || macinfo_type == DW_MACRO_undef_sup);
24503                 macro_undef (current_file, line, body);
24504               }
24505           }
24506           break;
24507
24508         case DW_MACRO_start_file:
24509           {
24510             unsigned int bytes_read;
24511             int line, file;
24512
24513             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24514             mac_ptr += bytes_read;
24515             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24516             mac_ptr += bytes_read;
24517
24518             if ((line == 0 && !at_commandline)
24519                 || (line != 0 && at_commandline))
24520               complaint (_("debug info gives source %d included "
24521                            "from %s at %s line %d"),
24522                          file, at_commandline ? _("command-line") : _("file"),
24523                          line == 0 ? _("zero") : _("non-zero"), line);
24524
24525             if (at_commandline)
24526               {
24527                 /* This DW_MACRO_start_file was executed in the
24528                    pass one.  */
24529                 at_commandline = 0;
24530               }
24531             else
24532               current_file = macro_start_file (cu, file, line, current_file,
24533                                                lh);
24534           }
24535           break;
24536
24537         case DW_MACRO_end_file:
24538           if (! current_file)
24539             complaint (_("macro debug info has an unmatched "
24540                          "`close_file' directive"));
24541           else
24542             {
24543               current_file = current_file->included_by;
24544               if (! current_file)
24545                 {
24546                   enum dwarf_macro_record_type next_type;
24547
24548                   /* GCC circa March 2002 doesn't produce the zero
24549                      type byte marking the end of the compilation
24550                      unit.  Complain if it's not there, but exit no
24551                      matter what.  */
24552
24553                   /* Do we at least have room for a macinfo type byte?  */
24554                   if (mac_ptr >= mac_end)
24555                     {
24556                       dwarf2_section_buffer_overflow_complaint (section);
24557                       return;
24558                     }
24559
24560                   /* We don't increment mac_ptr here, so this is just
24561                      a look-ahead.  */
24562                   next_type
24563                     = (enum dwarf_macro_record_type) read_1_byte (abfd,
24564                                                                   mac_ptr);
24565                   if (next_type != 0)
24566                     complaint (_("no terminating 0-type entry for "
24567                                  "macros in `.debug_macinfo' section"));
24568
24569                   return;
24570                 }
24571             }
24572           break;
24573
24574         case DW_MACRO_import:
24575         case DW_MACRO_import_sup:
24576           {
24577             LONGEST offset;
24578             void **slot;
24579             bfd *include_bfd = abfd;
24580             struct dwarf2_section_info *include_section = section;
24581             const gdb_byte *include_mac_end = mac_end;
24582             int is_dwz = section_is_dwz;
24583             const gdb_byte *new_mac_ptr;
24584
24585             offset = read_offset_1 (abfd, mac_ptr, offset_size);
24586             mac_ptr += offset_size;
24587
24588             if (macinfo_type == DW_MACRO_import_sup)
24589               {
24590                 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24591
24592                 dwarf2_read_section (objfile, &dwz->macro);
24593
24594                 include_section = &dwz->macro;
24595                 include_bfd = get_section_bfd_owner (include_section);
24596                 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24597                 is_dwz = 1;
24598               }
24599
24600             new_mac_ptr = include_section->buffer + offset;
24601             slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24602
24603             if (*slot != NULL)
24604               {
24605                 /* This has actually happened; see
24606                    http://sourceware.org/bugzilla/show_bug.cgi?id=13568.  */
24607                 complaint (_("recursive DW_MACRO_import in "
24608                              ".debug_macro section"));
24609               }
24610             else
24611               {
24612                 *slot = (void *) new_mac_ptr;
24613
24614                 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24615                                           include_mac_end, current_file, lh,
24616                                           section, section_is_gnu, is_dwz,
24617                                           offset_size, include_hash);
24618
24619                 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24620               }
24621           }
24622           break;
24623
24624         case DW_MACINFO_vendor_ext:
24625           if (!section_is_gnu)
24626             {
24627               unsigned int bytes_read;
24628
24629               /* This reads the constant, but since we don't recognize
24630                  any vendor extensions, we ignore it.  */
24631               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24632               mac_ptr += bytes_read;
24633               read_direct_string (abfd, mac_ptr, &bytes_read);
24634               mac_ptr += bytes_read;
24635
24636               /* We don't recognize any vendor extensions.  */
24637               break;
24638             }
24639           /* FALLTHROUGH */
24640
24641         default:
24642           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24643                                          mac_ptr, mac_end, abfd, offset_size,
24644                                          section);
24645           if (mac_ptr == NULL)
24646             return;
24647           break;
24648         }
24649       DIAGNOSTIC_POP
24650     } while (macinfo_type != 0);
24651 }
24652
24653 static void
24654 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24655                      int section_is_gnu)
24656 {
24657   struct dwarf2_per_objfile *dwarf2_per_objfile
24658     = cu->per_cu->dwarf2_per_objfile;
24659   struct objfile *objfile = dwarf2_per_objfile->objfile;
24660   struct line_header *lh = cu->line_header;
24661   bfd *abfd;
24662   const gdb_byte *mac_ptr, *mac_end;
24663   struct macro_source_file *current_file = 0;
24664   enum dwarf_macro_record_type macinfo_type;
24665   unsigned int offset_size = cu->header.offset_size;
24666   const gdb_byte *opcode_definitions[256];
24667   void **slot;
24668   struct dwarf2_section_info *section;
24669   const char *section_name;
24670
24671   if (cu->dwo_unit != NULL)
24672     {
24673       if (section_is_gnu)
24674         {
24675           section = &cu->dwo_unit->dwo_file->sections.macro;
24676           section_name = ".debug_macro.dwo";
24677         }
24678       else
24679         {
24680           section = &cu->dwo_unit->dwo_file->sections.macinfo;
24681           section_name = ".debug_macinfo.dwo";
24682         }
24683     }
24684   else
24685     {
24686       if (section_is_gnu)
24687         {
24688           section = &dwarf2_per_objfile->macro;
24689           section_name = ".debug_macro";
24690         }
24691       else
24692         {
24693           section = &dwarf2_per_objfile->macinfo;
24694           section_name = ".debug_macinfo";
24695         }
24696     }
24697
24698   dwarf2_read_section (objfile, section);
24699   if (section->buffer == NULL)
24700     {
24701       complaint (_("missing %s section"), section_name);
24702       return;
24703     }
24704   abfd = get_section_bfd_owner (section);
24705
24706   /* First pass: Find the name of the base filename.
24707      This filename is needed in order to process all macros whose definition
24708      (or undefinition) comes from the command line.  These macros are defined
24709      before the first DW_MACINFO_start_file entry, and yet still need to be
24710      associated to the base file.
24711
24712      To determine the base file name, we scan the macro definitions until we
24713      reach the first DW_MACINFO_start_file entry.  We then initialize
24714      CURRENT_FILE accordingly so that any macro definition found before the
24715      first DW_MACINFO_start_file can still be associated to the base file.  */
24716
24717   mac_ptr = section->buffer + offset;
24718   mac_end = section->buffer + section->size;
24719
24720   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24721                                       &offset_size, section_is_gnu);
24722   if (mac_ptr == NULL)
24723     {
24724       /* We already issued a complaint.  */
24725       return;
24726     }
24727
24728   do
24729     {
24730       /* Do we at least have room for a macinfo type byte?  */
24731       if (mac_ptr >= mac_end)
24732         {
24733           /* Complaint is printed during the second pass as GDB will probably
24734              stop the first pass earlier upon finding
24735              DW_MACINFO_start_file.  */
24736           break;
24737         }
24738
24739       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24740       mac_ptr++;
24741
24742       /* Note that we rely on the fact that the corresponding GNU and
24743          DWARF constants are the same.  */
24744       DIAGNOSTIC_PUSH
24745       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24746       switch (macinfo_type)
24747         {
24748           /* A zero macinfo type indicates the end of the macro
24749              information.  */
24750         case 0:
24751           break;
24752
24753         case DW_MACRO_define:
24754         case DW_MACRO_undef:
24755           /* Only skip the data by MAC_PTR.  */
24756           {
24757             unsigned int bytes_read;
24758
24759             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24760             mac_ptr += bytes_read;
24761             read_direct_string (abfd, mac_ptr, &bytes_read);
24762             mac_ptr += bytes_read;
24763           }
24764           break;
24765
24766         case DW_MACRO_start_file:
24767           {
24768             unsigned int bytes_read;
24769             int line, file;
24770
24771             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24772             mac_ptr += bytes_read;
24773             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24774             mac_ptr += bytes_read;
24775
24776             current_file = macro_start_file (cu, file, line, current_file, lh);
24777           }
24778           break;
24779
24780         case DW_MACRO_end_file:
24781           /* No data to skip by MAC_PTR.  */
24782           break;
24783
24784         case DW_MACRO_define_strp:
24785         case DW_MACRO_undef_strp:
24786         case DW_MACRO_define_sup:
24787         case DW_MACRO_undef_sup:
24788           {
24789             unsigned int bytes_read;
24790
24791             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24792             mac_ptr += bytes_read;
24793             mac_ptr += offset_size;
24794           }
24795           break;
24796
24797         case DW_MACRO_import:
24798         case DW_MACRO_import_sup:
24799           /* Note that, according to the spec, a transparent include
24800              chain cannot call DW_MACRO_start_file.  So, we can just
24801              skip this opcode.  */
24802           mac_ptr += offset_size;
24803           break;
24804
24805         case DW_MACINFO_vendor_ext:
24806           /* Only skip the data by MAC_PTR.  */
24807           if (!section_is_gnu)
24808             {
24809               unsigned int bytes_read;
24810
24811               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24812               mac_ptr += bytes_read;
24813               read_direct_string (abfd, mac_ptr, &bytes_read);
24814               mac_ptr += bytes_read;
24815             }
24816           /* FALLTHROUGH */
24817
24818         default:
24819           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24820                                          mac_ptr, mac_end, abfd, offset_size,
24821                                          section);
24822           if (mac_ptr == NULL)
24823             return;
24824           break;
24825         }
24826       DIAGNOSTIC_POP
24827     } while (macinfo_type != 0 && current_file == NULL);
24828
24829   /* Second pass: Process all entries.
24830
24831      Use the AT_COMMAND_LINE flag to determine whether we are still processing
24832      command-line macro definitions/undefinitions.  This flag is unset when we
24833      reach the first DW_MACINFO_start_file entry.  */
24834
24835   htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24836                                            htab_eq_pointer,
24837                                            NULL, xcalloc, xfree));
24838   mac_ptr = section->buffer + offset;
24839   slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24840   *slot = (void *) mac_ptr;
24841   dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24842                             current_file, lh, section,
24843                             section_is_gnu, 0, offset_size,
24844                             include_hash.get ());
24845 }
24846
24847 /* Check if the attribute's form is a DW_FORM_block*
24848    if so return true else false.  */
24849
24850 static int
24851 attr_form_is_block (const struct attribute *attr)
24852 {
24853   return (attr == NULL ? 0 :
24854       attr->form == DW_FORM_block1
24855       || attr->form == DW_FORM_block2
24856       || attr->form == DW_FORM_block4
24857       || attr->form == DW_FORM_block
24858       || attr->form == DW_FORM_exprloc);
24859 }
24860
24861 /* Return non-zero if ATTR's value is a section offset --- classes
24862    lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24863    You may use DW_UNSND (attr) to retrieve such offsets.
24864
24865    Section 7.5.4, "Attribute Encodings", explains that no attribute
24866    may have a value that belongs to more than one of these classes; it
24867    would be ambiguous if we did, because we use the same forms for all
24868    of them.  */
24869
24870 static int
24871 attr_form_is_section_offset (const struct attribute *attr)
24872 {
24873   return (attr->form == DW_FORM_data4
24874           || attr->form == DW_FORM_data8
24875           || attr->form == DW_FORM_sec_offset);
24876 }
24877
24878 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24879    zero otherwise.  When this function returns true, you can apply
24880    dwarf2_get_attr_constant_value to it.
24881
24882    However, note that for some attributes you must check
24883    attr_form_is_section_offset before using this test.  DW_FORM_data4
24884    and DW_FORM_data8 are members of both the constant class, and of
24885    the classes that contain offsets into other debug sections
24886    (lineptr, loclistptr, macptr or rangelistptr).  The DWARF spec says
24887    that, if an attribute's can be either a constant or one of the
24888    section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24889    taken as section offsets, not constants.
24890
24891    DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24892    cannot handle that.  */
24893
24894 static int
24895 attr_form_is_constant (const struct attribute *attr)
24896 {
24897   switch (attr->form)
24898     {
24899     case DW_FORM_sdata:
24900     case DW_FORM_udata:
24901     case DW_FORM_data1:
24902     case DW_FORM_data2:
24903     case DW_FORM_data4:
24904     case DW_FORM_data8:
24905     case DW_FORM_implicit_const:
24906       return 1;
24907     default:
24908       return 0;
24909     }
24910 }
24911
24912
24913 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24914    besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file.  */
24915
24916 static int
24917 attr_form_is_ref (const struct attribute *attr)
24918 {
24919   switch (attr->form)
24920     {
24921     case DW_FORM_ref_addr:
24922     case DW_FORM_ref1:
24923     case DW_FORM_ref2:
24924     case DW_FORM_ref4:
24925     case DW_FORM_ref8:
24926     case DW_FORM_ref_udata:
24927     case DW_FORM_GNU_ref_alt:
24928       return 1;
24929     default:
24930       return 0;
24931     }
24932 }
24933
24934 /* Return the .debug_loc section to use for CU.
24935    For DWO files use .debug_loc.dwo.  */
24936
24937 static struct dwarf2_section_info *
24938 cu_debug_loc_section (struct dwarf2_cu *cu)
24939 {
24940   struct dwarf2_per_objfile *dwarf2_per_objfile
24941     = cu->per_cu->dwarf2_per_objfile;
24942
24943   if (cu->dwo_unit)
24944     {
24945       struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24946       
24947       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
24948     }
24949   return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24950                                   : &dwarf2_per_objfile->loc);
24951 }
24952
24953 /* A helper function that fills in a dwarf2_loclist_baton.  */
24954
24955 static void
24956 fill_in_loclist_baton (struct dwarf2_cu *cu,
24957                        struct dwarf2_loclist_baton *baton,
24958                        const struct attribute *attr)
24959 {
24960   struct dwarf2_per_objfile *dwarf2_per_objfile
24961     = cu->per_cu->dwarf2_per_objfile;
24962   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24963
24964   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24965
24966   baton->per_cu = cu->per_cu;
24967   gdb_assert (baton->per_cu);
24968   /* We don't know how long the location list is, but make sure we
24969      don't run off the edge of the section.  */
24970   baton->size = section->size - DW_UNSND (attr);
24971   baton->data = section->buffer + DW_UNSND (attr);
24972   baton->base_address = cu->base_address;
24973   baton->from_dwo = cu->dwo_unit != NULL;
24974 }
24975
24976 static void
24977 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24978                              struct dwarf2_cu *cu, int is_block)
24979 {
24980   struct dwarf2_per_objfile *dwarf2_per_objfile
24981     = cu->per_cu->dwarf2_per_objfile;
24982   struct objfile *objfile = dwarf2_per_objfile->objfile;
24983   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24984
24985   if (attr_form_is_section_offset (attr)
24986       /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24987          the section.  If so, fall through to the complaint in the
24988          other branch.  */
24989       && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24990     {
24991       struct dwarf2_loclist_baton *baton;
24992
24993       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24994
24995       fill_in_loclist_baton (cu, baton, attr);
24996
24997       if (cu->base_known == 0)
24998         complaint (_("Location list used without "
24999                      "specifying the CU base address."));
25000
25001       SYMBOL_ACLASS_INDEX (sym) = (is_block
25002                                    ? dwarf2_loclist_block_index
25003                                    : dwarf2_loclist_index);
25004       SYMBOL_LOCATION_BATON (sym) = baton;
25005     }
25006   else
25007     {
25008       struct dwarf2_locexpr_baton *baton;
25009
25010       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
25011       baton->per_cu = cu->per_cu;
25012       gdb_assert (baton->per_cu);
25013
25014       if (attr_form_is_block (attr))
25015         {
25016           /* Note that we're just copying the block's data pointer
25017              here, not the actual data.  We're still pointing into the
25018              info_buffer for SYM's objfile; right now we never release
25019              that buffer, but when we do clean up properly this may
25020              need to change.  */
25021           baton->size = DW_BLOCK (attr)->size;
25022           baton->data = DW_BLOCK (attr)->data;
25023         }
25024       else
25025         {
25026           dwarf2_invalid_attrib_class_complaint ("location description",
25027                                                  SYMBOL_NATURAL_NAME (sym));
25028           baton->size = 0;
25029         }
25030
25031       SYMBOL_ACLASS_INDEX (sym) = (is_block
25032                                    ? dwarf2_locexpr_block_index
25033                                    : dwarf2_locexpr_index);
25034       SYMBOL_LOCATION_BATON (sym) = baton;
25035     }
25036 }
25037
25038 /* Return the OBJFILE associated with the compilation unit CU.  If CU
25039    came from a separate debuginfo file, then the master objfile is
25040    returned.  */
25041
25042 struct objfile *
25043 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25044 {
25045   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25046
25047   /* Return the master objfile, so that we can report and look up the
25048      correct file containing this variable.  */
25049   if (objfile->separate_debug_objfile_backlink)
25050     objfile = objfile->separate_debug_objfile_backlink;
25051
25052   return objfile;
25053 }
25054
25055 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25056    (CU_HEADERP is unused in such case) or prepare a temporary copy at
25057    CU_HEADERP first.  */
25058
25059 static const struct comp_unit_head *
25060 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25061                        struct dwarf2_per_cu_data *per_cu)
25062 {
25063   const gdb_byte *info_ptr;
25064
25065   if (per_cu->cu)
25066     return &per_cu->cu->header;
25067
25068   info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25069
25070   memset (cu_headerp, 0, sizeof (*cu_headerp));
25071   read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25072                        rcuh_kind::COMPILE);
25073
25074   return cu_headerp;
25075 }
25076
25077 /* Return the address size given in the compilation unit header for CU.  */
25078
25079 int
25080 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25081 {
25082   struct comp_unit_head cu_header_local;
25083   const struct comp_unit_head *cu_headerp;
25084
25085   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25086
25087   return cu_headerp->addr_size;
25088 }
25089
25090 /* Return the offset size given in the compilation unit header for CU.  */
25091
25092 int
25093 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25094 {
25095   struct comp_unit_head cu_header_local;
25096   const struct comp_unit_head *cu_headerp;
25097
25098   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25099
25100   return cu_headerp->offset_size;
25101 }
25102
25103 /* See its dwarf2loc.h declaration.  */
25104
25105 int
25106 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25107 {
25108   struct comp_unit_head cu_header_local;
25109   const struct comp_unit_head *cu_headerp;
25110
25111   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25112
25113   if (cu_headerp->version == 2)
25114     return cu_headerp->addr_size;
25115   else
25116     return cu_headerp->offset_size;
25117 }
25118
25119 /* Return the text offset of the CU.  The returned offset comes from
25120    this CU's objfile.  If this objfile came from a separate debuginfo
25121    file, then the offset may be different from the corresponding
25122    offset in the parent objfile.  */
25123
25124 CORE_ADDR
25125 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25126 {
25127   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25128
25129   return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25130 }
25131
25132 /* Return DWARF version number of PER_CU.  */
25133
25134 short
25135 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25136 {
25137   return per_cu->dwarf_version;
25138 }
25139
25140 /* Locate the .debug_info compilation unit from CU's objfile which contains
25141    the DIE at OFFSET.  Raises an error on failure.  */
25142
25143 static struct dwarf2_per_cu_data *
25144 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25145                                   unsigned int offset_in_dwz,
25146                                   struct dwarf2_per_objfile *dwarf2_per_objfile)
25147 {
25148   struct dwarf2_per_cu_data *this_cu;
25149   int low, high;
25150
25151   low = 0;
25152   high = dwarf2_per_objfile->all_comp_units.size () - 1;
25153   while (high > low)
25154     {
25155       struct dwarf2_per_cu_data *mid_cu;
25156       int mid = low + (high - low) / 2;
25157
25158       mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25159       if (mid_cu->is_dwz > offset_in_dwz
25160           || (mid_cu->is_dwz == offset_in_dwz
25161               && mid_cu->sect_off + mid_cu->length >= sect_off))
25162         high = mid;
25163       else
25164         low = mid + 1;
25165     }
25166   gdb_assert (low == high);
25167   this_cu = dwarf2_per_objfile->all_comp_units[low];
25168   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25169     {
25170       if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25171         error (_("Dwarf Error: could not find partial DIE containing "
25172                "offset %s [in module %s]"),
25173                sect_offset_str (sect_off),
25174                bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25175
25176       gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25177                   <= sect_off);
25178       return dwarf2_per_objfile->all_comp_units[low-1];
25179     }
25180   else
25181     {
25182       this_cu = dwarf2_per_objfile->all_comp_units[low];
25183       if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25184           && sect_off >= this_cu->sect_off + this_cu->length)
25185         error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25186       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25187       return this_cu;
25188     }
25189 }
25190
25191 /* Initialize dwarf2_cu CU, owned by PER_CU.  */
25192
25193 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25194   : per_cu (per_cu_),
25195     mark (false),
25196     has_loclist (false),
25197     checked_producer (false),
25198     producer_is_gxx_lt_4_6 (false),
25199     producer_is_gcc_lt_4_3 (false),
25200     producer_is_icc (false),
25201     producer_is_icc_lt_14 (false),
25202     producer_is_codewarrior (false),
25203     processing_has_namespace_info (false)
25204 {
25205   per_cu->cu = this;
25206 }
25207
25208 /* Destroy a dwarf2_cu.  */
25209
25210 dwarf2_cu::~dwarf2_cu ()
25211 {
25212   per_cu->cu = NULL;
25213 }
25214
25215 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE.  */
25216
25217 static void
25218 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25219                        enum language pretend_language)
25220 {
25221   struct attribute *attr;
25222
25223   /* Set the language we're debugging.  */
25224   attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25225   if (attr)
25226     set_cu_language (DW_UNSND (attr), cu);
25227   else
25228     {
25229       cu->language = pretend_language;
25230       cu->language_defn = language_def (cu->language);
25231     }
25232
25233   cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25234 }
25235
25236 /* Increase the age counter on each cached compilation unit, and free
25237    any that are too old.  */
25238
25239 static void
25240 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25241 {
25242   struct dwarf2_per_cu_data *per_cu, **last_chain;
25243
25244   dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25245   per_cu = dwarf2_per_objfile->read_in_chain;
25246   while (per_cu != NULL)
25247     {
25248       per_cu->cu->last_used ++;
25249       if (per_cu->cu->last_used <= dwarf_max_cache_age)
25250         dwarf2_mark (per_cu->cu);
25251       per_cu = per_cu->cu->read_in_chain;
25252     }
25253
25254   per_cu = dwarf2_per_objfile->read_in_chain;
25255   last_chain = &dwarf2_per_objfile->read_in_chain;
25256   while (per_cu != NULL)
25257     {
25258       struct dwarf2_per_cu_data *next_cu;
25259
25260       next_cu = per_cu->cu->read_in_chain;
25261
25262       if (!per_cu->cu->mark)
25263         {
25264           delete per_cu->cu;
25265           *last_chain = next_cu;
25266         }
25267       else
25268         last_chain = &per_cu->cu->read_in_chain;
25269
25270       per_cu = next_cu;
25271     }
25272 }
25273
25274 /* Remove a single compilation unit from the cache.  */
25275
25276 static void
25277 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25278 {
25279   struct dwarf2_per_cu_data *per_cu, **last_chain;
25280   struct dwarf2_per_objfile *dwarf2_per_objfile
25281     = target_per_cu->dwarf2_per_objfile;
25282
25283   per_cu = dwarf2_per_objfile->read_in_chain;
25284   last_chain = &dwarf2_per_objfile->read_in_chain;
25285   while (per_cu != NULL)
25286     {
25287       struct dwarf2_per_cu_data *next_cu;
25288
25289       next_cu = per_cu->cu->read_in_chain;
25290
25291       if (per_cu == target_per_cu)
25292         {
25293           delete per_cu->cu;
25294           per_cu->cu = NULL;
25295           *last_chain = next_cu;
25296           break;
25297         }
25298       else
25299         last_chain = &per_cu->cu->read_in_chain;
25300
25301       per_cu = next_cu;
25302     }
25303 }
25304
25305 /* Cleanup function for the dwarf2_per_objfile data.  */
25306
25307 static void
25308 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25309 {
25310   struct dwarf2_per_objfile *dwarf2_per_objfile
25311     = static_cast<struct dwarf2_per_objfile *> (datum);
25312
25313   delete dwarf2_per_objfile;
25314 }
25315
25316 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25317    We store these in a hash table separate from the DIEs, and preserve them
25318    when the DIEs are flushed out of cache.
25319
25320    The CU "per_cu" pointer is needed because offset alone is not enough to
25321    uniquely identify the type.  A file may have multiple .debug_types sections,
25322    or the type may come from a DWO file.  Furthermore, while it's more logical
25323    to use per_cu->section+offset, with Fission the section with the data is in
25324    the DWO file but we don't know that section at the point we need it.
25325    We have to use something in dwarf2_per_cu_data (or the pointer to it)
25326    because we can enter the lookup routine, get_die_type_at_offset, from
25327    outside this file, and thus won't necessarily have PER_CU->cu.
25328    Fortunately, PER_CU is stable for the life of the objfile.  */
25329
25330 struct dwarf2_per_cu_offset_and_type
25331 {
25332   const struct dwarf2_per_cu_data *per_cu;
25333   sect_offset sect_off;
25334   struct type *type;
25335 };
25336
25337 /* Hash function for a dwarf2_per_cu_offset_and_type.  */
25338
25339 static hashval_t
25340 per_cu_offset_and_type_hash (const void *item)
25341 {
25342   const struct dwarf2_per_cu_offset_and_type *ofs
25343     = (const struct dwarf2_per_cu_offset_and_type *) item;
25344
25345   return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25346 }
25347
25348 /* Equality function for a dwarf2_per_cu_offset_and_type.  */
25349
25350 static int
25351 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25352 {
25353   const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25354     = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25355   const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25356     = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25357
25358   return (ofs_lhs->per_cu == ofs_rhs->per_cu
25359           && ofs_lhs->sect_off == ofs_rhs->sect_off);
25360 }
25361
25362 /* Set the type associated with DIE to TYPE.  Save it in CU's hash
25363    table if necessary.  For convenience, return TYPE.
25364
25365    The DIEs reading must have careful ordering to:
25366     * Not cause infite loops trying to read in DIEs as a prerequisite for
25367       reading current DIE.
25368     * Not trying to dereference contents of still incompletely read in types
25369       while reading in other DIEs.
25370     * Enable referencing still incompletely read in types just by a pointer to
25371       the type without accessing its fields.
25372
25373    Therefore caller should follow these rules:
25374      * Try to fetch any prerequisite types we may need to build this DIE type
25375        before building the type and calling set_die_type.
25376      * After building type call set_die_type for current DIE as soon as
25377        possible before fetching more types to complete the current type.
25378      * Make the type as complete as possible before fetching more types.  */
25379
25380 static struct type *
25381 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25382 {
25383   struct dwarf2_per_objfile *dwarf2_per_objfile
25384     = cu->per_cu->dwarf2_per_objfile;
25385   struct dwarf2_per_cu_offset_and_type **slot, ofs;
25386   struct objfile *objfile = dwarf2_per_objfile->objfile;
25387   struct attribute *attr;
25388   struct dynamic_prop prop;
25389
25390   /* For Ada types, make sure that the gnat-specific data is always
25391      initialized (if not already set).  There are a few types where
25392      we should not be doing so, because the type-specific area is
25393      already used to hold some other piece of info (eg: TYPE_CODE_FLT
25394      where the type-specific area is used to store the floatformat).
25395      But this is not a problem, because the gnat-specific information
25396      is actually not needed for these types.  */
25397   if (need_gnat_info (cu)
25398       && TYPE_CODE (type) != TYPE_CODE_FUNC
25399       && TYPE_CODE (type) != TYPE_CODE_FLT
25400       && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25401       && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25402       && TYPE_CODE (type) != TYPE_CODE_METHOD
25403       && !HAVE_GNAT_AUX_INFO (type))
25404     INIT_GNAT_SPECIFIC (type);
25405
25406   /* Read DW_AT_allocated and set in type.  */
25407   attr = dwarf2_attr (die, DW_AT_allocated, cu);
25408   if (attr_form_is_block (attr))
25409     {
25410       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25411         add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25412     }
25413   else if (attr != NULL)
25414     {
25415       complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25416                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25417                  sect_offset_str (die->sect_off));
25418     }
25419
25420   /* Read DW_AT_associated and set in type.  */
25421   attr = dwarf2_attr (die, DW_AT_associated, cu);
25422   if (attr_form_is_block (attr))
25423     {
25424       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25425         add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25426     }
25427   else if (attr != NULL)
25428     {
25429       complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25430                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25431                  sect_offset_str (die->sect_off));
25432     }
25433
25434   /* Read DW_AT_data_location and set in type.  */
25435   attr = dwarf2_attr (die, DW_AT_data_location, cu);
25436   if (attr_to_dynamic_prop (attr, die, cu, &prop))
25437     add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25438
25439   if (dwarf2_per_objfile->die_type_hash == NULL)
25440     {
25441       dwarf2_per_objfile->die_type_hash =
25442         htab_create_alloc_ex (127,
25443                               per_cu_offset_and_type_hash,
25444                               per_cu_offset_and_type_eq,
25445                               NULL,
25446                               &objfile->objfile_obstack,
25447                               hashtab_obstack_allocate,
25448                               dummy_obstack_deallocate);
25449     }
25450
25451   ofs.per_cu = cu->per_cu;
25452   ofs.sect_off = die->sect_off;
25453   ofs.type = type;
25454   slot = (struct dwarf2_per_cu_offset_and_type **)
25455     htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25456   if (*slot)
25457     complaint (_("A problem internal to GDB: DIE %s has type already set"),
25458                sect_offset_str (die->sect_off));
25459   *slot = XOBNEW (&objfile->objfile_obstack,
25460                   struct dwarf2_per_cu_offset_and_type);
25461   **slot = ofs;
25462   return type;
25463 }
25464
25465 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25466    or return NULL if the die does not have a saved type.  */
25467
25468 static struct type *
25469 get_die_type_at_offset (sect_offset sect_off,
25470                         struct dwarf2_per_cu_data *per_cu)
25471 {
25472   struct dwarf2_per_cu_offset_and_type *slot, ofs;
25473   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25474
25475   if (dwarf2_per_objfile->die_type_hash == NULL)
25476     return NULL;
25477
25478   ofs.per_cu = per_cu;
25479   ofs.sect_off = sect_off;
25480   slot = ((struct dwarf2_per_cu_offset_and_type *)
25481           htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25482   if (slot)
25483     return slot->type;
25484   else
25485     return NULL;
25486 }
25487
25488 /* Look up the type for DIE in CU in die_type_hash,
25489    or return NULL if DIE does not have a saved type.  */
25490
25491 static struct type *
25492 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25493 {
25494   return get_die_type_at_offset (die->sect_off, cu->per_cu);
25495 }
25496
25497 /* Add a dependence relationship from CU to REF_PER_CU.  */
25498
25499 static void
25500 dwarf2_add_dependence (struct dwarf2_cu *cu,
25501                        struct dwarf2_per_cu_data *ref_per_cu)
25502 {
25503   void **slot;
25504
25505   if (cu->dependencies == NULL)
25506     cu->dependencies
25507       = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25508                               NULL, &cu->comp_unit_obstack,
25509                               hashtab_obstack_allocate,
25510                               dummy_obstack_deallocate);
25511
25512   slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25513   if (*slot == NULL)
25514     *slot = ref_per_cu;
25515 }
25516
25517 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25518    Set the mark field in every compilation unit in the
25519    cache that we must keep because we are keeping CU.  */
25520
25521 static int
25522 dwarf2_mark_helper (void **slot, void *data)
25523 {
25524   struct dwarf2_per_cu_data *per_cu;
25525
25526   per_cu = (struct dwarf2_per_cu_data *) *slot;
25527
25528   /* cu->dependencies references may not yet have been ever read if QUIT aborts
25529      reading of the chain.  As such dependencies remain valid it is not much
25530      useful to track and undo them during QUIT cleanups.  */
25531   if (per_cu->cu == NULL)
25532     return 1;
25533
25534   if (per_cu->cu->mark)
25535     return 1;
25536   per_cu->cu->mark = true;
25537
25538   if (per_cu->cu->dependencies != NULL)
25539     htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25540
25541   return 1;
25542 }
25543
25544 /* Set the mark field in CU and in every other compilation unit in the
25545    cache that we must keep because we are keeping CU.  */
25546
25547 static void
25548 dwarf2_mark (struct dwarf2_cu *cu)
25549 {
25550   if (cu->mark)
25551     return;
25552   cu->mark = true;
25553   if (cu->dependencies != NULL)
25554     htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25555 }
25556
25557 static void
25558 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25559 {
25560   while (per_cu)
25561     {
25562       per_cu->cu->mark = false;
25563       per_cu = per_cu->cu->read_in_chain;
25564     }
25565 }
25566
25567 /* Trivial hash function for partial_die_info: the hash value of a DIE
25568    is its offset in .debug_info for this objfile.  */
25569
25570 static hashval_t
25571 partial_die_hash (const void *item)
25572 {
25573   const struct partial_die_info *part_die
25574     = (const struct partial_die_info *) item;
25575
25576   return to_underlying (part_die->sect_off);
25577 }
25578
25579 /* Trivial comparison function for partial_die_info structures: two DIEs
25580    are equal if they have the same offset.  */
25581
25582 static int
25583 partial_die_eq (const void *item_lhs, const void *item_rhs)
25584 {
25585   const struct partial_die_info *part_die_lhs
25586     = (const struct partial_die_info *) item_lhs;
25587   const struct partial_die_info *part_die_rhs
25588     = (const struct partial_die_info *) item_rhs;
25589
25590   return part_die_lhs->sect_off == part_die_rhs->sect_off;
25591 }
25592
25593 struct cmd_list_element *set_dwarf_cmdlist;
25594 struct cmd_list_element *show_dwarf_cmdlist;
25595
25596 static void
25597 set_dwarf_cmd (const char *args, int from_tty)
25598 {
25599   help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25600              gdb_stdout);
25601 }
25602
25603 static void
25604 show_dwarf_cmd (const char *args, int from_tty)
25605 {
25606   cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25607 }
25608
25609 int dwarf_always_disassemble;
25610
25611 static void
25612 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25613                                struct cmd_list_element *c, const char *value)
25614 {
25615   fprintf_filtered (file,
25616                     _("Whether to always disassemble "
25617                       "DWARF expressions is %s.\n"),
25618                     value);
25619 }
25620
25621 static void
25622 show_check_physname (struct ui_file *file, int from_tty,
25623                      struct cmd_list_element *c, const char *value)
25624 {
25625   fprintf_filtered (file,
25626                     _("Whether to check \"physname\" is %s.\n"),
25627                     value);
25628 }
25629
25630 void
25631 _initialize_dwarf2_read (void)
25632 {
25633   dwarf2_objfile_data_key
25634     = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25635
25636   add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25637 Set DWARF specific variables.\n\
25638 Configure DWARF variables such as the cache size"),
25639                   &set_dwarf_cmdlist, "maintenance set dwarf ",
25640                   0/*allow-unknown*/, &maintenance_set_cmdlist);
25641
25642   add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25643 Show DWARF specific variables\n\
25644 Show DWARF variables such as the cache size"),
25645                   &show_dwarf_cmdlist, "maintenance show dwarf ",
25646                   0/*allow-unknown*/, &maintenance_show_cmdlist);
25647
25648   add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25649                             &dwarf_max_cache_age, _("\
25650 Set the upper bound on the age of cached DWARF compilation units."), _("\
25651 Show the upper bound on the age of cached DWARF compilation units."), _("\
25652 A higher limit means that cached compilation units will be stored\n\
25653 in memory longer, and more total memory will be used.  Zero disables\n\
25654 caching, which can slow down startup."),
25655                             NULL,
25656                             show_dwarf_max_cache_age,
25657                             &set_dwarf_cmdlist,
25658                             &show_dwarf_cmdlist);
25659
25660   add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25661                            &dwarf_always_disassemble, _("\
25662 Set whether `info address' always disassembles DWARF expressions."), _("\
25663 Show whether `info address' always disassembles DWARF expressions."), _("\
25664 When enabled, DWARF expressions are always printed in an assembly-like\n\
25665 syntax.  When disabled, expressions will be printed in a more\n\
25666 conversational style, when possible."),
25667                            NULL,
25668                            show_dwarf_always_disassemble,
25669                            &set_dwarf_cmdlist,
25670                            &show_dwarf_cmdlist);
25671
25672   add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25673 Set debugging of the DWARF reader."), _("\
25674 Show debugging of the DWARF reader."), _("\
25675 When enabled (non-zero), debugging messages are printed during DWARF\n\
25676 reading and symtab expansion.  A value of 1 (one) provides basic\n\
25677 information.  A value greater than 1 provides more verbose information."),
25678                             NULL,
25679                             NULL,
25680                             &setdebuglist, &showdebuglist);
25681
25682   add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25683 Set debugging of the DWARF DIE reader."), _("\
25684 Show debugging of the DWARF DIE reader."), _("\
25685 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25686 The value is the maximum depth to print."),
25687                              NULL,
25688                              NULL,
25689                              &setdebuglist, &showdebuglist);
25690
25691   add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25692 Set debugging of the dwarf line reader."), _("\
25693 Show debugging of the dwarf line reader."), _("\
25694 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25695 A value of 1 (one) provides basic information.\n\
25696 A value greater than 1 provides more verbose information."),
25697                              NULL,
25698                              NULL,
25699                              &setdebuglist, &showdebuglist);
25700
25701   add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25702 Set cross-checking of \"physname\" code against demangler."), _("\
25703 Show cross-checking of \"physname\" code against demangler."), _("\
25704 When enabled, GDB's internal \"physname\" code is checked against\n\
25705 the demangler."),
25706                            NULL, show_check_physname,
25707                            &setdebuglist, &showdebuglist);
25708
25709   add_setshow_boolean_cmd ("use-deprecated-index-sections",
25710                            no_class, &use_deprecated_index_sections, _("\
25711 Set whether to use deprecated gdb_index sections."), _("\
25712 Show whether to use deprecated gdb_index sections."), _("\
25713 When enabled, deprecated .gdb_index sections are used anyway.\n\
25714 Normally they are ignored either because of a missing feature or\n\
25715 performance issue.\n\
25716 Warning: This option must be enabled before gdb reads the file."),
25717                            NULL,
25718                            NULL,
25719                            &setlist, &showlist);
25720
25721   dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25722                                                         &dwarf2_locexpr_funcs);
25723   dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25724                                                         &dwarf2_loclist_funcs);
25725
25726   dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25727                                         &dwarf2_block_frame_base_locexpr_funcs);
25728   dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25729                                         &dwarf2_block_frame_base_loclist_funcs);
25730
25731 #if GDB_SELF_TEST
25732   selftests::register_test ("dw2_expand_symtabs_matching",
25733                             selftests::dw2_expand_symtabs_matching::run_test);
25734 #endif
25735 }